ab)-(?P=word)"}},
+ {"function": "scrapling::regex", "case": "lookbehind_and_conditional",
+ "request": {"html": "abcdef ab c
", "pattern": r"(?:(?<=abc)def)|((a)?(?(2)b|c))"}},
+ {"function": "scrapling::regex", "case": "atomic_and_possessive",
+ "request": {"html": "aaab aaaa
", "pattern": r"(?>a+)b|a++a"}},
+ {"function": "scrapling::regex", "case": "unicode_name_escape",
+ "request": {"html": "A—B
", "pattern": r"\N{EM DASH}"}},
+ {"function": "scrapling::find-by-regex", "case": "unicode_ignorecase_extra",
+ "request": {"html": "Kelvin
", "pattern": r"kelvin"}},
+ {"function": "scrapling::regex", "case": "zero_width_findall",
+ "request": {"html": "ab
", "pattern": r"x*"}},
+ {"function": "scrapling::regex", "case": "w3lib_html4_entities",
+ "request": {"html": "' &Copy; €  &unknown; &unknown
",
+ "pattern": r"&(?:[A-Za-z]+|#[0-9]+);?"}},
+ {"function": "scrapling::regex", "case": "invalid_unterminated_group",
+ "request": {"html": "basic", "pattern": "("}},
+ {"function": "scrapling::regex", "case": "invalid_range",
+ "request": {"html": "basic", "pattern": "[z-a]"}},
+ {"function": "scrapling::regex", "case": "invalid_global_flag_position",
+ "request": {"html": "basic", "pattern": "a(?i)b"}},
+ {"function": "scrapling::regex", "case": "invalid_variable_lookbehind",
+ "request": {"html": "basic", "pattern": r"(?<=a*)b"}},
+ {"function": "scrapling::regex", "case": "invalid_group_reference",
+ "request": {"html": "basic", "pattern": r"\1"}},
+ {"function": "scrapling::find-by-text", "case": "exact_default",
+ "request": {"html": "basic", "text": "Apple"}},
+ {"function": "scrapling::find-by-text", "case": "partial_case",
+ "request": {"html": "basic", "text": "aPP", "partial": True}},
+ {"function": "scrapling::find-by-text", "case": "case_sensitive_miss",
+ "request": {"html": "basic", "text": "apple", "case_sensitive": True}},
+ {"function": "scrapling::find-by-text", "case": "clean_match_whitespace",
+ "request": {"html": "edge", "text": "bold"}},
+ {"function": "scrapling::find-by-text", "case": "no_clean_exact_ws",
+ "request": {"html": "edge", "text": "bold", "clean_match": False}},
+ {"function": "scrapling::find-by-text", "case": "first_flag",
+ "request": {"html": "basic", "text": "Apple", "first": True}},
+ {"function": "scrapling::find-by-text", "case": "none",
+ "request": {"html": "basic", "text": "Zebra"}},
+ {"function": "scrapling::find-by-regex", "case": "default_insensitive",
+ "request": {"html": "basic", "pattern": r"price \d+"}},
+ {"function": "scrapling::find-by-regex", "case": "sensitive_miss",
+ "request": {"html": "basic", "pattern": r"PRICE \d+", "case_sensitive": True}},
+ {"function": "scrapling::find-by-regex", "case": "limit_zero",
+ "request": {"html": "messy", "pattern": r"\w+", "limit": 0}},
+ {"function": "scrapling::find-by-regex", "case": "messy_cards",
+ "request": {"html": "messy", "pattern": r"card$"}},
+ {"function": "scrapling::find", "case": "by_tag",
+ "request": {"html": "basic", "tag": "a"}},
+ {"function": "scrapling::find", "case": "by_tag_list",
+ "request": {"html": "basic", "tag": ["h1", "p"]}},
+ {"function": "scrapling::find", "case": "attrs_exact_whole_value",
+ "request": {"html": "messy", "attrs": {"class": "card"}}}, # must NOT match "card wide"
+ {"function": "scrapling::find", "case": "attrs_bool_coercion",
+ "request": {"html": "edge", "tag": "input", "attrs": {"disabled": ""}}},
+ {"function": "scrapling::find", "case": "tag_and_text_regex",
+ "request": {"html": "basic", "tag": "a", "text_regex": "Ap", "first": True}},
+ {"function": "scrapling::find", "case": "text_regex_only_all_elements",
+ "request": {"html": "basic", "text_regex": "price"}},
+ {"function": "scrapling::find", "case": "no_filters_error",
+ "request": {"html": "basic"}},
+ {"function": "scrapling::find", "case": "limit_clamps",
+ "request": {"html": "messy", "tag": "li", "limit": 2}},
+ {"function": "scrapling::find", "case": "negative_limit_empty",
+ "request": {"html": "basic", "tag": "a", "limit": -1}},
+ {"function": "scrapling::find-by-text", "case": "clean_trims_trailing_space",
+ "request": {"html": "messy", "text": "intro paragraph with"}},
+ {"function": "scrapling::find-by-text", "case": "no_clean_keeps_trailing_space",
+ "request": {"html": "messy", "text": "intro paragraph with", "clean_match": False}},
+ {"function": "scrapling::find", "case": "by_tag_input_attrs_map",
+ "request": {"html": "edge", "tag": "input"}},
+ {"function": "scrapling::find", "case": "attrs_operator_contains",
+ "request": {"html": "basic", "attrs": {"href*": "/a"}}},
+ {"function": "scrapling::find", "case": "attrs_operator_prefix",
+ "request": {"html": "basic", "attrs": {"href^": "/"}}},
+ {"function": "scrapling::find", "case": "tag_html_root",
+ "request": {"html": "basic", "tag": "html"}},
+ {"function": "scrapling::find", "case": "empty_text_regex_error",
+ "request": {"html": "basic", "text_regex": ""}},
+ {"function": "scrapling::find", "case": "star_tag_falls_through",
+ "request": {"html": "basic", "tag": "*"}},
+ {"function": "scrapling::css", "case": "all_default",
+ "request": {"html": "basic", "query": "li a"}},
+ {"function": "scrapling::css", "case": "first_text",
+ "request": {"html": "basic", "query": "li a", "first": True}},
+ {"function": "scrapling::css", "case": "first_attr",
+ "request": {"html": "basic", "query": "li a", "first": True, "attr": "href"}},
+ {"function": "scrapling::css", "case": "attr_miss_in_all",
+ "request": {"html": "basic", "query": "li a", "attr": "data-x"}},
+ {"function": "scrapling::css", "case": "no_match_modes",
+ "request": {"html": "basic", "query": ".nope"}},
+ {"function": "scrapling::css", "case": "no_match_first",
+ "request": {"html": "basic", "query": ".nope", "first": True}},
+ {"function": "scrapling::css", "case": "pseudo_text",
+ "request": {"html": "basic", "query": "h1::text", "first": True}},
+ {"function": "scrapling::css", "case": "pseudo_attr",
+ "request": {"html": "basic", "query": "a::attr(href)"}},
+ {"function": "scrapling::css", "case": "invalid_selector",
+ "request": {"html": "basic", "query": "li:::bad"}},
+ {"function": "scrapling::extract", "case": "mixed_specs",
+ "request": {"html": "basic", "selectors": [
+ {"name": "title", "css": "h1"},
+ {"name": "links", "css": "li a", "attr": "href", "all": True},
+ {"name": "names", "css": "li a", "all": True},
+ {"name": "price", "regex": r"price (\d+)"},
+ {"name": "first_li_html", "css": "li", "html": True},
+ ]}},
+ {"function": "scrapling::extract", "case": "spec_without_query",
+ "request": {"html": "basic", "selectors": [{"name": "x"}, {"name": "y", "all": True}]}},
+ {"function": "scrapling::extract", "case": "empty_selectors",
+ "request": {"html": "basic", "selectors": []}},
+ {"function": "scrapling::extract", "case": "regex_all_spec",
+ "request": {"html": "basic", "selectors": [{"name": "nums", "regex": r"\d+", "all": True}]}},
+ {"function": "scrapling::xpath", "case": "first_h1",
+ "request": {"html": "basic", "query": "//h1", "first": True}},
+ {"function": "scrapling::xpath", "case": "all_anchors_text",
+ "request": {"html": "basic", "query": "//ul/li/a"}},
+ {"function": "scrapling::xpath", "case": "attr_axis_terminal",
+ "request": {"html": "basic", "query": "//a/@href"}},
+ {"function": "scrapling::xpath", "case": "text_terminal",
+ "request": {"html": "basic", "query": "//h1/text()", "first": True}},
+ {"function": "scrapling::xpath", "case": "positional",
+ "request": {"html": "basic", "query": "//li[2]/a", "first": True}},
+ {"function": "scrapling::xpath", "case": "predicate_attr_value",
+ "request": {"html": "messy", "query": "//div[@class='card']", }},
+ {"function": "scrapling::xpath", "case": "contains_href",
+ "request": {"html": "basic", "query": "//a[contains(@href, 'b')]", "first": True}},
+ {"function": "scrapling::xpath", "case": "union_doc_order",
+ "request": {"html": "basic", "query": "//h1 | //p"}},
+ {"function": "scrapling::xpath", "case": "attr_param_on_elements",
+ "request": {"html": "basic", "query": "//li/a", "attr": "href"}},
+ {"function": "scrapling::xpath", "case": "invalid_syntax",
+ "request": {"html": "basic", "query": "//["}},
+ {"function": "scrapling::extract", "case": "xpath_specs",
+ "request": {"html": "basic", "selectors": [
+ {"name": "first_link", "xpath": "//ul/li/a", "attr": "href"},
+ {"name": "all_text", "xpath": "//li/a/text()", "all": True},
+ ]}},
+ # Task 13.5: dom/parser parity batch (blank text, template contents, //
+ # axis, empty attr).
+ {"function": "scrapling::xpath", "case": "text_runs_main_messy",
+ "request": {"html": "messy", "query": "//main/text()"}},
+ {"function": "scrapling::xpath", "case": "text_runs_body_messy",
+ "request": {"html": "messy", "query": "//body/text()"}},
+ {"function": "scrapling::css", "case": "text_pseudo_messy_main",
+ "request": {"html": "messy", "query": "main::text"}},
+ {"function": "scrapling::xpath", "case": "template_child_step",
+ "request": {"html": "messy", "query": "//template/p"}},
+ {"function": "scrapling::css", "case": "template_child_css",
+ "request": {"html": "messy", "query": "template > p", "first": True}},
+ {"function": "scrapling::xpath", "case": "explicit_axis_after_slashslash",
+ "request": {"html": "basic", "query": "//descendant::li[2]"}},
+ {"function": "scrapling::css", "case": "empty_attr_falls_back_to_text",
+ "request": {"html": "basic", "query": "li a", "first": True, "attr": ""}},
+ {"function": "scrapling::xpath", "case": "textarea_blank_body_kept",
+ "request": {"html": "edge", "query": "//textarea/text()"}},
+ {"function": "scrapling::describe", "case": "h1_css",
+ "request": {"html": "basic", "query": "h1"}},
+ {"function": "scrapling::describe", "case": "no_match",
+ "request": {"html": "basic", "query": ".nope"}},
+ {"function": "scrapling::describe", "case": "xpath_kind",
+ "request": {"html": "basic", "query": "//li[2]/a", "kind": "xpath"}},
+ {"function": "scrapling::describe", "case": "weird_kind_is_xpath",
+ "request": {"html": "basic", "query": "//h1", "kind": "bogus"}},
+ {"function": "scrapling::describe", "case": "text_pseudo",
+ "request": {"html": "basic", "query": "h1::text"}},
+ {"function": "scrapling::describe", "case": "id_shortcircuit_full",
+ "request": {"html": "edge", "query": "#wrap p"}},
+ # Task 15: find-similar (structural auto-match + __are_alike scoring).
+ {"function": "scrapling::find-similar", "case": "list_items",
+ "request": {"html": "basic", "anchor": "li"}},
+ {"function": "scrapling::find-similar", "case": "subselectors",
+ "request": {"html": "basic", "anchor": "li",
+ "selectors": [{"name": "href", "css": "a", "attr": "href"}]}},
+ {"function": "scrapling::find-similar", "case": "anchor_missing",
+ "request": {"html": "basic", "anchor": ".nope"}},
+ {"function": "scrapling::find-similar", "case": "cards_attr_scoring",
+ "request": {"html": "messy", "anchor": "div.card[data-id='1']"}},
+ {"function": "scrapling::find-similar", "case": "cards_high_threshold",
+ "request": {"html": "messy", "anchor": "div.card[data-id='1']", "similarity_threshold": 0.9}},
+ {"function": "scrapling::find-similar", "case": "match_text",
+ "request": {"html": "basic", "anchor": "li", "match_text": True}},
+ # Fix: match_text scoring must use clean_spaces (deletes \n/\r outright,
+ # never trims), not clean (\n/\r -> ' ', trims). Anchor is attribute-bare
+ # so __are_alike's attrs contribution is zero either way (target empty,
+ # candidate non-empty -> "nothing added") — checks come ONLY from
+ # match_text, so the accept/reject verdict is a pure function of which
+ # cleaner ran. Anchor's leading text is "line one\nand two " (embedded
+ # newline); the sibling's is the literal already-squished "line oneand
+ # two " — clean_spaces(anchor) == that string exactly (ratio 1.0);
+ # clean(anchor) inserts a space and trims (ratio 0.9677 rounds to 0.97,
+ # see fix report) — similarity_threshold sits strictly between the two.
+ {"function": "scrapling::find-similar", "case": "match_text_multiline_leading",
+ "request": {"html": "edge", "anchor": "#wrap > div", "match_text": True,
+ "similarity_threshold": 0.99}},
+ # Task 16: to-markdown (Convertor._extract_content — main-content
+ # sanitizer, css_selector scoping, html/markdown/text modes).
+ {"function": "scrapling::to-markdown", "case": "markdown_basic",
+ "request": {"html": "basic"}},
+ {"function": "scrapling::to-markdown", "case": "text_basic",
+ "request": {"html": "basic", "format": "text"}},
+ {"function": "scrapling::to-markdown", "case": "html_roundtrip",
+ "request": {"html": "basic", "format": "html"}},
+ {"function": "scrapling::to-markdown", "case": "text_messy_main_only",
+ "request": {"html": "messy", "format": "text", "main_content_only": True}},
+ {"function": "scrapling::to-markdown", "case": "scoped_css",
+ "request": {"html": "messy", "format": "text", "css_selector": "div.card"}},
+ {"function": "scrapling::to-markdown", "case": "bad_format",
+ "request": {"html": "basic", "format": "pdf"}},
+ # Fix review: `_HIDDEN_XPATH`/`.iter()` are self-excluding (`.//`) — the
+ # scope root (body, here) must not drop itself even when IT carries the
+ # hidden attribute; only matching descendants would. Inline html: no
+ # corpus entry names this shape.
+ {"function": "scrapling::to-markdown", "case": "hidden_body_self_exempt",
+ "request": {"html": 'keep me
',
+ "format": "text", "main_content_only": True}},
+ # markdownify 1.2.3 defaults, after Convertor serializes the selected
+ # lxml subtree and BeautifulSoup 4.15 reparses it with `html.parser`.
+ # These are strict wrapper fixtures (not calls to markdownify itself):
+ # together they cover the tag conversions where htmd differs visibly.
+ {"function": "scrapling::to-markdown", "case": "markdown_inline_defaults",
+ "request": {"html": '''
+ A *title* Sub_head Third\n head
+ bold em gone
+ a``bquote H2 O x2
+ https://e.test/a_b
+ Link
+
one
+
Three Four
+
Term one definition\nline Next bold
+
\n a * b\n`tick`\n after
+ '''}},
+ {"function": "scrapling::to-markdown", "case": "markdown_table_and_video",
+ "request": {"html": '''
+ Cap Head A B
+ Figure text Trailer Only
+ '''}},
+ {"function": "scrapling::to-markdown", "case": "markdown_unknown_and_noise_tags",
+ "request": {"html": '''
+ alpha beta\n gamma
+ before mid after
+ T
<![CDATA[` makes the second parse observable. lxml first serializes
+ # the rest of the source as escaped plaintext; BeautifulSoup's
+ # `html.parser` then treats the serialized closing tags as plaintext too.
+ {"function": "scrapling::to-markdown", "case": "markdown_html_parser_second_parse",
+ "request": {"html": "<p>before</p><plaintext><b>looks bold</b><p>tail</p></plaintext><p>after</p>"}},
+ # Fix review: a `::text`/`::attr()` pseudo-selector match must render
+ # through the same pipeline as an element match, not be silently dropped.
+ {"function": "scrapling::to-markdown", "case": "pseudo_text_selector_text_mode",
+ "request": {"html": "basic", "format": "text", "css_selector": "li a::text"}},
+ {"function": "scrapling::to-markdown", "case": "pseudo_text_selector_html_mode",
+ "request": {"html": "basic", "format": "html", "css_selector": "li a::text"}},
+ # Final-review fix wave: detached `::text` (parsel/scrapy's descendant-
+ # text idiom, "a ::text" — self + every descendant, any depth — distinct
+ # from attached "a::text", own runs only) and its bare form.
+ {"function": "scrapling::css", "case": "detached_text_descendants",
+ "request": {"html": "basic", "query": "li ::text"}},
+ {"function": "scrapling::css", "case": "detached_text_first",
+ "request": {"html": "basic", "query": "h1 ::text", "first": True}},
+ # Genuinely bare `::text` (empty stem, no element name at all) — distinct
+ # from detached_text_first above, which still has a stem ("h1").
+ {"function": "scrapling::css", "case": "bare_detached_text",
+ "request": {"html": "basic", "query": "::text"}},
+ {"function": "scrapling::extract", "case": "detached_text_spec",
+ "request": {"html": "messy", "selectors": [{"name": "card_text", "css": "div.card ::text", "all": True}]}},
+ # Libxml HTML recovery and serialization contract.
+ {"function": "scrapling::find", "case": "implied_document_nodes",
+ "request": {"html": "<title>T</title><p>P", "tag": ["html", "head", "body"]}},
+ {"function": "scrapling::find", "case": "duplicate_and_boolean_attributes",
+ "request": {"html": "<input z=1 disabled a='' z=2 checked=checked>", "tag": "input"}},
+ {"function": "scrapling::extract", "case": "malformed_table_recovery",
+ "request": {"html": "<table><td>A<td>B<div>C", "selectors": [{"name": "table", "css": "table", "html": True}]}},
+ {"function": "scrapling::extract", "case": "misnested_formatting_recovery",
+ "request": {"html": "<p><b>one<i>two</b>three</i>tail", "selectors": [{"name": "body", "css": "body", "html": True}]}},
+ {"function": "scrapling::extract", "case": "foreign_content_serialization",
+ "request": {"html": "<svg viewBox='0 0 1 1'><foreignObject><DIV xlink:href='x'>T</DIV></foreignObject></svg>",
+ "selectors": [{"name": "svg", "css": "svg", "html": True}]}},
+ {"function": "scrapling::extract", "case": "entities_and_invalid_codepoints",
+ "request": {"html": "<p>© ' � � ¬anentity;</p>",
+ "selectors": [{"name": "text", "xpath": "//p/text()", "all": True},
+ {"name": "html", "css": "p", "html": True}]}},
+ {"function": "scrapling::extract", "case": "comments_removed_and_text_merged",
+ "request": {"html": "<p>a<!--gone-->b<![CDATA[c]]]]><![CDATA[>d</p>",
+ "selectors": [{"name": "text", "xpath": "//p/text()", "all": True},
+ {"name": "html", "css": "p", "html": True}]}},
+ {"function": "scrapling::extract", "case": "template_nested_content",
+ "request": {"html": "<template><table><td>T</template><p>P", "selectors": [
+ {"name": "template", "css": "template", "html": True},
+ {"name": "td", "xpath": "//template//td", "all": True},
+ ]}},
+ # CSS is translated with cssselect 1.5 then evaluated as XPath.
+ {"function": "scrapling::css", "case": "sibling_text_pseudo",
+ "request": {"html": "<h1>H</h1>x<p>A<b>B</b>C</p><p>D</p>", "query": "h1 + p::text"}},
+ {"function": "scrapling::css", "case": "general_sibling_attr_pseudo",
+ "request": {"html": "<h1>H</h1><p data-x='a'>A</p><p data-x='b'>B</p>", "query": "h1 ~ p::attr(data-x)"}},
+ {"function": "scrapling::css", "case": "nth_not_and_attribute_operators",
+ "request": {"html": "<ul><li class='x' data-v='en-us'>A</li><li data-v='en'>B</li><li data-v='fr'>C</li></ul>",
+ "query": "li:nth-child(2):not(.x)[data-v|='en']", "first": True}},
+ {"function": "scrapling::css", "case": "grouped_selector_document_order",
+ "request": {"html": "<p>P</p><h1>H</h1><p>Q</p>", "query": "h1, p"}},
+ {"function": "scrapling::find-similar", "case": "subselector_scope_cannot_escape",
+ "request": {"html": "<main><section><a>inside</a></section></main><a>outside</a>", "anchor": "section",
+ "selectors": [{"name": "escaped", "css": "body a", "all": True},
+ {"name": "inside", "css": "a", "all": True}]}},
+ # XPath 1.0 axes, functions, coercion, scalar quirks, and errors.
+ {"function": "scrapling::xpath", "case": "ancestor_axis_reverse_position",
+ "request": {"html": "<main id='m'><section id='s'><p>P</p></section></main>", "query": "//p/ancestor::*[1]/@id"}},
+ {"function": "scrapling::xpath", "case": "preceding_axis_reverse_position",
+ "request": {"html": "<p id='a'>A</p><p id='b'>B</p><p id='c'>C</p>", "query": "//p[@id='c']/preceding::p[1]/@id"}},
+ {"function": "scrapling::xpath", "case": "following_axis_document_order",
+ "request": {"html": "<div><i>A</i></div><p>B</p><p>C</p>", "query": "//i/following::p/text()"}},
+ {"function": "scrapling::xpath", "case": "attribute_wildcard_order",
+ "request": {"html": "<p z='1' a='2' m='3'>P</p>", "query": "//p/@*"}},
+ {"function": "scrapling::xpath", "case": "predicate_string_functions",
+ "request": {"html": "<p> Alpha beta </p><p>Gamma</p>",
+ "query": "//p[starts-with(normalize-space(.), 'Alpha') and string-length(normalize-space(.)) = 10]"}},
+ {"function": "scrapling::xpath", "case": "predicate_arithmetic_and_round",
+ "request": {"html": "<i>1</i><i>2</i><i>3</i><i>4</i>", "query": "//i[position() = round(last() div 2)]"}},
+ {"function": "scrapling::xpath", "case": "global_parenthesized_position",
+ "request": {"html": "<div><p>A</p><p>B</p></div><section><p>C</p></section>", "query": "(//p)[2]"}},
+ {"function": "scrapling::xpath", "case": "string_scalar_splits_into_text_nodes",
+ "request": {"html": "<p>Alpha</p>", "query": "string(//p)"}},
+ {"function": "scrapling::xpath", "case": "false_scalar_becomes_empty",
+ "request": {"html": "<p>Alpha</p>", "query": "boolean(//nope)"}},
+ {"function": "scrapling::xpath", "case": "true_scalar_type_error",
+ "request": {"html": "<p>Alpha</p>", "query": "boolean(//p)"}},
+ {"function": "scrapling::xpath", "case": "number_scalar_type_error",
+ "request": {"html": "<p>Alpha</p>", "query": "count(//p)"}},
+ {"function": "scrapling::xpath", "case": "unknown_function_error",
+ "request": {"html": "<p>Alpha</p>", "query": "no-such-function()"}},
+]
+
+
+def gen_behavior(output: Path = WORKER) -> None:
+ from src.handlers import create_handlers
+
+ handlers = create_handlers(lambda: {})
+ for name in ("basic", "edge", "messy"):
+ CORPUS[name] = (WORKER / "tests/corpus" / f"{name}.html").read_text()
+ n = 0
+ for entry in MATRIX:
+ req = dict(entry["request"])
+ # Named corpus file, or (to-markdown's scope-root/pseudo-selector
+ # fixtures) inline HTML that names no corpus entry at all.
+ req["html"] = CORPUS.get(req["html"], req["html"])
+ fn = entry["function"]
+ try:
+ resp = {"ok": asyncio.run(handlers[fn.split("::", 1)[1].replace("-", "_")](req))}
+ except Exception as exc: # noqa: BLE001 — error text is part of the contract
+ resp = {"err": str(exc)}
+ dump(
+ output / "tests/golden/behavior" / fn.split("::")[1] / (entry["case"] + ".json"),
+ {
+ "function": wire_id(fn),
+ "case": entry["case"],
+ "request": req,
+ **resp,
+ },
+ )
+ n += 1
+ print(f"wrote {n} behavior fixtures")
+
+
+class _BrowserFixtureHandler(http.server.BaseHTTPRequestHandler):
+ def do_GET(self) -> None: # noqa: N802 - stdlib handler API
+ body = (WORKER / "tests/corpus/browser_visual.html").read_bytes()
+ self.send_response(200)
+ self.send_header("Content-Type", "text/html; charset=utf-8")
+ self.send_header("Content-Length", str(len(body)))
+ self.end_headers()
+ self.wfile.write(body)
+
+ def log_message(self, *_args) -> None:
+ pass
+
+
+class _ThreadingServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
+ daemon_threads = True
+
+
+def gen_browser(output: Path = WORKER) -> None:
+ """Generate deterministic screenshot fixtures through the public wrapper."""
+ from PIL import Image
+ from src.handlers import create_handlers
+
+ server = _ThreadingServer(("127.0.0.1", 0), _BrowserFixtureHandler)
+ thread = threading.Thread(target=server.serve_forever, daemon=True)
+ thread.start()
+ origin = f"http://127.0.0.1:{server.server_port}"
+ cfg = {"defaults": {"headless": True, "network_idle": False, "proxy": "", "include_html": False}}
+ handler = create_handlers(lambda: cfg)["screenshot"]
+ cases = [
+ ("dynamic-viewport-png", {"fetcher": "dynamic", "format": "png", "full_page": False}),
+ ("dynamic-full-png", {"fetcher": "dynamic", "format": "png", "full_page": True}),
+ ("stealthy-viewport-png", {"fetcher": "stealthy", "format": "png", "full_page": False}),
+ ("stealthy-full-jpeg", {"fetcher": "stealthy", "format": "jpeg", "full_page": True}),
+ ]
+ destination = output / "tests/golden/browser"
+ destination.mkdir(parents=True, exist_ok=True)
+ records = []
+ try:
+ for name, options in cases:
+ request = {"url": f"{origin}/visual", "retries": 1, **options}
+ response = asyncio.run(handler(request))
+ blocks = []
+ image_index = 0
+ for block in response["content"]:
+ if block["type"] != "image":
+ blocks.append({**block, "text": block["text"].replace(origin, "{origin}")})
+ continue
+ image_index += 1
+ data = base64.b64decode(block["data"])
+ suffix = "jpg" if block["mime"] == "image/jpeg" else "png"
+ filename = f"{name}-{image_index}.{suffix}"
+ (destination / filename).write_bytes(data)
+ with Image.open(destination / filename) as image:
+ dimensions = [image.width, image.height]
+ blocks.append({
+ "type": "image",
+ "mime": block["mime"],
+ "file": filename,
+ "bytes": len(data),
+ "sha256": hashlib.sha256(data).hexdigest(),
+ "dimensions": dimensions,
+ })
+ records.append({
+ "case": name,
+ "request": {**request, "url": "{origin}/visual"},
+ "response": {
+ "content": blocks,
+ "url": response["url"].replace(origin, "{origin}"),
+ "mime": response["mime"],
+ },
+ })
+ finally:
+ server.shutdown()
+ server.server_close()
+ thread.join()
+ dump(destination / "manifest.json", {"cases": records})
+ print(f"wrote {len(cases)} browser fixtures")
+
+
+def check_browser() -> None:
+ with tempfile.TemporaryDirectory() as tmp:
+ output = Path(tmp)
+ gen_browser(output)
+ fresh = output / "tests/golden/browser"
+ committed = WORKER / "tests/golden/browser"
+ names = {path.name for path in fresh.iterdir()} | {path.name for path in committed.iterdir()}
+ drift = [name for name in names if not (fresh / name).exists() or not (committed / name).exists()
+ or (fresh / name).read_bytes() != (committed / name).read_bytes()]
+ if drift:
+ raise SystemExit(f"browser goldens are stale: {sorted(drift)}")
+ print("browser goldens are current")
+
+
+def check() -> None:
+ with tempfile.TemporaryDirectory() as tmp:
+ output = Path(tmp)
+ gen_schemas(output)
+ gen_behavior(output)
+ generated = output / "tests/golden"
+ committed = WORKER / "tests/golden"
+ drift = []
+ for fresh in generated.rglob("*.json"):
+ relative = fresh.relative_to(generated)
+ checked_in = committed / relative
+ if not checked_in.exists() or fresh.read_bytes() != checked_in.read_bytes():
+ drift.append(str(relative))
+ generated_behavior = {
+ path.relative_to(generated / "behavior") for path in (generated / "behavior").rglob("*.json")
+ }
+ committed_behavior = {
+ path.relative_to(committed / "behavior") for path in (committed / "behavior").rglob("*.json")
+ }
+ drift.extend(str(path) for path in generated_behavior ^ committed_behavior)
+ if drift:
+ raise SystemExit(f"goldens are stale: {sorted(set(drift))}")
+ print("goldens are current")
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ "mode",
+ choices=["schemas", "behavior", "browser", "check", "browser-check"],
+ nargs="?",
+ default="schemas",
+ )
+ parser.add_argument(
+ "--parser-runtime",
+ action="store_true",
+ help="verify immutable parser inputs but not host fonts, locale, or timezone",
+ )
+ args = parser.parse_args()
+ random.seed(0)
+ if os.environ.get("PYTHONHASHSEED") != "0":
+ os.execve(sys.executable, [sys.executable, *sys.argv], {**os.environ, "PYTHONHASHSEED": "0"})
+ verify_command = [sys.executable, HERE / "verify_oracle.py"]
+ if args.parser_runtime:
+ verify_command.append("--parser-runtime")
+ subprocess.run(verify_command, check=True)
+ {
+ "schemas": gen_schemas,
+ "behavior": gen_behavior,
+ "browser": gen_browser,
+ "check": check,
+ "browser-check": check_browser,
+ }[args.mode]()
diff --git a/browser/scripts/verify_oracle.py b/browser/scripts/verify_oracle.py
new file mode 100644
index 000000000..85ee7b1b5
--- /dev/null
+++ b/browser/scripts/verify_oracle.py
@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""Write or verify the frozen standalone-worker oracle manifest."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import locale
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+WORKER = Path(__file__).resolve().parent.parent
+REPO = WORKER.parent
+MANIFEST = WORKER / "oracle/manifest.json"
+LOCK = WORKER / "oracle/requirements.lock"
+ASSET_SUFFIXES = {".dat", ".json", ".pem", ".txt", ".xz", ".zip"}
+BROWSERS = (
+ (
+ "chromium-linux-x64",
+ "pw-chromium-1223-linux-x64.zip",
+ "https://cdn.playwright.dev/builds/cft/148.0.7778.96/linux64/chrome-linux64.zip",
+ ),
+ (
+ "chromium-headless-shell-linux-x64",
+ "pw-headless-1223-linux-x64.zip",
+ "https://cdn.playwright.dev/builds/cft/148.0.7778.96/linux64/chrome-headless-shell-linux64.zip",
+ ),
+ (
+ "ffmpeg-linux-x64",
+ "pw-ffmpeg-1011-linux-x64.zip",
+ "https://cdn.playwright.dev/dbazure/download/playwright/builds/ffmpeg/1011/ffmpeg-linux.zip",
+ ),
+ (
+ "chromium-linux-arm64",
+ "pw-chromium-1223-linux-arm64.zip",
+ "https://cdn.playwright.dev/dbazure/download/playwright/builds/chromium/1223/chromium-linux-arm64.zip",
+ ),
+ (
+ "chromium-headless-shell-linux-arm64",
+ "pw-headless-1223-linux-arm64.zip",
+ "https://cdn.playwright.dev/dbazure/download/playwright/builds/chromium/1223/chromium-headless-shell-linux-arm64.zip",
+ ),
+ (
+ "ffmpeg-linux-arm64",
+ "pw-ffmpeg-1011-linux-arm64.zip",
+ "https://cdn.playwright.dev/dbazure/download/playwright/builds/ffmpeg/1011/ffmpeg-linux-arm64.zip",
+ ),
+)
+
+
+def sha256(path: Path) -> str:
+ digest = hashlib.sha256()
+ with path.open("rb") as stream:
+ for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+ digest.update(chunk)
+ return digest.hexdigest()
+
+
+def file_record(path: Path, name: str | None = None) -> dict[str, object]:
+ return {"path": name or str(path), "size": path.stat().st_size, "sha256": sha256(path)}
+
+
+def records_digest(records: list[dict[str, object]]) -> str:
+ digest = hashlib.sha256()
+ for record in records:
+ digest.update(str(record["path"]).encode())
+ digest.update(b"\0")
+ digest.update(str(record["sha256"]).encode())
+ digest.update(b"\0")
+ return digest.hexdigest()
+
+
+def source_version() -> str:
+ # The CI bot bumps this after every scrapling merge; reading it keeps the
+ # recorded version from silently lying (pyproject.toml is itself one of
+ # the fingerprinted files, so a bump already forces a re-freeze).
+ pyproject = (REPO / "scrapling/pyproject.toml").read_text()
+ match = re.search(r'(?m)^version = "([^"]+)"$', pyproject)
+ if not match:
+ raise SystemExit("cannot read version from scrapling/pyproject.toml")
+ return match.group(1)
+
+
+def source_manifest() -> dict[str, object]:
+ # Fingerprint only the source the oracle executes (gen_goldens.py imports
+ # scrapling/src directly; its dependencies come from oracle/
+ # requirements.lock, not the worker's own metadata). Worker metadata —
+ # iii.worker.yaml, README, permissions, pyproject — is deliberately
+ # excluded: PR CI runs on the merge commit, so any main-side churn in
+ # those files would break every open PR's freeze without touching parse
+ # behavior. The version label is provenance, not a compared input.
+ output = subprocess.check_output(
+ ["git", "ls-files", "-z", "scrapling/src"], cwd=REPO
+ )
+ paths = [Path(item.decode()) for item in output.split(b"\0") if item]
+ files = [file_record(REPO / path, str(path)) for path in paths]
+ return {"version": source_version(), "sha256": records_digest(files), "files": files}
+
+
+def canonical_name(value: str) -> str:
+ return re.sub(r"[-_.]+", "-", value).lower()
+
+
+def package_manifest() -> tuple[list[dict[str, object]], list[dict[str, object]], str]:
+ packages = []
+ assets = []
+ runtime_digest = hashlib.sha256()
+ for distribution in sorted(
+ importlib.metadata.distributions(),
+ key=lambda item: canonical_name(item.metadata["Name"]),
+ ):
+ name = canonical_name(distribution.metadata["Name"])
+ files = []
+ for relative in sorted(distribution.files or (), key=str):
+ path = Path(distribution.locate_file(relative))
+ if not path.is_file():
+ continue
+ record = file_record(path, str(relative))
+ files.append(record)
+ if path.suffix.lower() in ASSET_SUFFIXES:
+ assets.append({"package": name, **record})
+ relative_name = str(relative)
+ if not relative_name.startswith("../../../bin/") and not relative_name.endswith(
+ ".dist-info/RECORD"
+ ):
+ for value in (name, relative_name, str(record["sha256"])):
+ runtime_digest.update(value.encode())
+ runtime_digest.update(b"\0")
+ packages.append(
+ {
+ "name": name,
+ "version": distribution.version,
+ "files": len(files),
+ "bytes": sum(int(item["size"]) for item in files),
+ "sha256": records_digest(files),
+ }
+ )
+ return packages, assets, runtime_digest.hexdigest()
+
+
+def font_manifest() -> list[dict[str, object]]:
+ output = subprocess.check_output(["fc-list", "--format=%{file}\n"], text=True)
+ paths = sorted({Path(item) for item in output.splitlines() if item})
+ return [file_record(path) for path in paths]
+
+
+def timezone_manifest() -> dict[str, object]:
+ path = Path("/etc/localtime").resolve()
+ prefix = Path("/usr/share/zoneinfo")
+ try:
+ name = str(path.relative_to(prefix))
+ except ValueError:
+ name = os.environ.get("TZ", str(path))
+ return {"name": name, **file_record(path)}
+
+
+def browser_manifest(archive_dir: Path) -> list[dict[str, object]]:
+ records = []
+ for name, filename, url in BROWSERS:
+ path = archive_dir / filename
+ if not path.is_file():
+ raise SystemExit(f"missing browser oracle archive: {path}")
+ records.append({"name": name, "url": url, **file_record(path, filename)})
+ return records
+
+
+def snapshot(archive_dir: Path) -> dict[str, object]:
+ packages, assets, parser_runtime_sha256 = package_manifest()
+ fonts = font_manifest()
+ certifi = importlib.import_module("certifi")
+ executable = Path(sys.executable).resolve()
+ return {
+ "format": 1,
+ "source": source_manifest(),
+ "python": {
+ "version": sys.version.split()[0],
+ "implementation": sys.implementation.name,
+ "executable": file_record(executable),
+ "parser_runtime_sha256": parser_runtime_sha256,
+ "packages": packages,
+ "requirements_lock": file_record(LOCK, "oracle/requirements.lock"),
+ },
+ "browser": {
+ "playwright_revision": "1223",
+ "chromium_version": "148.0.7778.96",
+ "archives": browser_manifest(archive_dir),
+ },
+ "assets": assets,
+ "host": {
+ "locale": locale.setlocale(locale.LC_ALL, ""),
+ "locale_environment": {
+ key: os.environ.get(key, "")
+ for key in ("LANG", "LC_ALL", "LC_CTYPE")
+ },
+ "timezone": timezone_manifest(),
+ "ca_bundle": file_record(Path(certifi.where()), "certifi/cacert.pem"),
+ "fonts_sha256": records_digest(fonts),
+ "fonts": fonts,
+ },
+ "determinism": {"PYTHONHASHSEED": "0", "random_seed": 0},
+ }
+
+
+def verify_archives(expected: dict[str, object], archive_dir: Path) -> None:
+ actual = browser_manifest(archive_dir)
+ if actual != expected["browser"]["archives"]:
+ raise SystemExit("browser oracle archives differ from oracle/manifest.json")
+
+
+def verify(archive_dir: Path | None) -> None:
+ expected = json.loads(MANIFEST.read_text())
+ # Archive bytes are release inputs, not required to regenerate parse-only
+ # goldens. Reuse the frozen entries while comparing everything local.
+ current = snapshot(archive_dir or Path("/nonexistent")) if archive_dir else None
+ if current is None:
+ packages, assets, parser_runtime_sha256 = package_manifest()
+ fonts = font_manifest()
+ certifi = importlib.import_module("certifi")
+ executable = Path(sys.executable).resolve()
+ current = {
+ **expected,
+ "source": source_manifest(),
+ "python": {
+ "version": sys.version.split()[0],
+ "implementation": sys.implementation.name,
+ "executable": file_record(executable),
+ "parser_runtime_sha256": parser_runtime_sha256,
+ "packages": packages,
+ "requirements_lock": file_record(LOCK, "oracle/requirements.lock"),
+ },
+ "assets": assets,
+ "host": {
+ "locale": locale.setlocale(locale.LC_ALL, ""),
+ "locale_environment": {
+ key: os.environ.get(key, "")
+ for key in ("LANG", "LC_ALL", "LC_CTYPE")
+ },
+ "timezone": timezone_manifest(),
+ "ca_bundle": file_record(Path(certifi.where()), "certifi/cacert.pem"),
+ "fonts_sha256": records_digest(fonts),
+ "fonts": fonts,
+ },
+ }
+ if current != expected:
+ report_diff(expected, current)
+ raise SystemExit("oracle environment differs from oracle/manifest.json")
+ if archive_dir:
+ verify_archives(expected, archive_dir)
+ print("oracle environment verified")
+
+
+def verify_parser_runtime() -> None:
+ """Verify inputs that can affect parse differentials, excluding host/browser data."""
+ expected = json.loads(MANIFEST.read_text())
+ packages, assets, parser_runtime_sha256 = package_manifest()
+
+ def compared_source(source: dict[str, object]) -> dict[str, object]:
+ # The version label tracks scrapling/pyproject.toml, which the CI bot
+ # bumps after every merge; it is provenance, not a parse input.
+ return {key: source[key] for key in ("sha256", "files")}
+
+ current = {
+ "source": compared_source(source_manifest()),
+ "python": {
+ "version": sys.version.split()[0],
+ "implementation": sys.implementation.name,
+ "parser_runtime_sha256": parser_runtime_sha256,
+ "packages": [
+ {"name": item["name"], "version": item["version"]}
+ for item in packages
+ ],
+ "requirements_lock": file_record(LOCK, "oracle/requirements.lock"),
+ },
+ "assets": assets,
+ }
+ frozen = {
+ "source": compared_source(expected["source"]),
+ "python": {
+ "version": expected["python"]["version"],
+ "implementation": expected["python"]["implementation"],
+ "parser_runtime_sha256": expected["python"]["parser_runtime_sha256"],
+ "packages": [
+ {"name": item["name"], "version": item["version"]}
+ for item in expected["python"]["packages"]
+ ],
+ "requirements_lock": expected["python"]["requirements_lock"],
+ },
+ "assets": expected["assets"],
+ }
+ if current != frozen:
+ report_diff(frozen, current)
+ raise SystemExit("parser oracle runtime differs from oracle/manifest.json")
+ print("parser oracle runtime verified")
+
+
+def report_diff(frozen: object, current: object, path: str = "", budget: list[int] | None = None) -> None:
+ """Print the leaf paths where the snapshots disagree (first 20)."""
+ if budget is None:
+ budget = [20]
+ if budget[0] <= 0:
+ return
+ if isinstance(frozen, dict) and isinstance(current, dict):
+ for key in sorted(set(frozen) | set(current)):
+ if key not in frozen:
+ budget[0] -= 1
+ print(f"diff {path}.{key}: only in current", file=sys.stderr)
+ elif key not in current:
+ budget[0] -= 1
+ print(f"diff {path}.{key}: only frozen", file=sys.stderr)
+ else:
+ report_diff(frozen[key], current[key], f"{path}.{key}", budget)
+ return
+ if isinstance(frozen, list) and isinstance(current, list):
+ if len(frozen) != len(current):
+ budget[0] -= 1
+ print(f"diff {path}: {len(frozen)} frozen items vs {len(current)} current", file=sys.stderr)
+ for index, (a, b) in enumerate(zip(frozen, current)):
+ report_diff(a, b, f"{path}[{index}]", budget)
+ return
+ if frozen != current:
+ budget[0] -= 1
+ print(f"diff {path}: frozen={frozen!r} current={current!r}", file=sys.stderr)
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--write", action="store_true")
+ parser.add_argument("--archive-dir", type=Path)
+ parser.add_argument("--parser-runtime", action="store_true")
+ args = parser.parse_args()
+ if args.write:
+ if not args.archive_dir:
+ parser.error("--write requires --archive-dir")
+ MANIFEST.write_text(json.dumps(snapshot(args.archive_dir), indent=2) + "\n")
+ print(f"wrote {MANIFEST}")
+ elif args.parser_runtime:
+ if args.archive_dir:
+ parser.error("--parser-runtime does not accept --archive-dir")
+ verify_parser_runtime()
+ else:
+ verify(args.archive_dir)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/browser/skills/SKILL.md b/browser/skills/SKILL.md
index 5835192f2..378ca5e4f 100644
--- a/browser/skills/SKILL.md
+++ b/browser/skills/SKILL.md
@@ -3,13 +3,20 @@ name: browser
description: >-
Interactive Chromium sessions for reading and driving real web pages: open a
URL, read the page as text, click and type, and read the page's own console
- and network history. Reach for it when a task involves a running web app,
- especially "why is this page broken".
+ and network history. Also scrapes: HTTP and browser fetching, screenshots,
+ persistent sessions, crawling, and CSS/XPath/regex parsing of HTML you
+ already have. Reach for it when a task involves a running web app,
+ especially "why is this page broken", or when pulling data off the web.
---
# browser
-The browser worker runs real Chromium sessions on the bus. Start a session,
+The browser worker does two things. It runs real Chromium sessions on the bus
+(`browser::*`), and it parses HTML natively without a browser
+(`browser::*` — CSS/XPath/regex queries, element search,
+HTML→Markdown, over any HTML string you already have).
+
+Start a session,
navigate, and the page becomes data: `browser::snapshot` returns an
accessibility outline whose `[ref=eN]` handles feed straight into
`browser::act`, and everything the page logs (console calls, uncaught
@@ -38,9 +45,16 @@ on navigation; re-snapshot before acting after any page change.
## Boundaries
-- One-shot fetching and scraping belong to `web::fetch` (plain HTTP) and the
- scrapling worker (stealth fetching and bulk extraction). Do not start a
- browser session just to read a static page once.
+- Do not start a browser session just to read a page once. One-shot fetching
+ is `browser::fetch` (no browser) or `browser::dynamic-fetch`
+ (Chromium, when the page needs JS). Sessions are for flows that need state
+ between steps.
+- Parsing HTML you already have needs neither a session nor a fetch: use the
+ `browser::*` parse function below. Starting Chromium to run a
+ CSS selector over a string you are already holding is pure waste.
+- `solve_cloudflare` is available on `browser::stealthy-fetch` and stealthy
+ Scrapling sessions. Use `browser::handoff` for challenges in an interactive
+ session or when automated solving does not clear the page.
- Attach mode reaches the user's real browser profile with its logged-in
sessions. It is disabled unless `allow_attach` is set, and adoption is
exclusive (one session per tab) so two sessions never fight over a tab.
@@ -107,6 +121,85 @@ on navigation; re-snapshot before acting after any page change.
- `browser::styles::read` / `browser::styles::write` — computed styles and
live inline CSS edits on one element.
+### Fetching, sessions and crawl
+
+These reach the network, so they need approval. All return one envelope —
+`{status, url, headers, cookies, encoding}` — and can extract or render inline
+via `selectors` / `format: markdown|text` / `include_html`, so you rarely need
+a second call to parse what you fetched. Each takes a single `url` or a bulk
+`urls` list.
+
+- `browser::fetch` — plain HTTP, no browser. The default choice: fastest,
+ cheapest. Safe mode uses bounded native HTTP; certified compat mode uses the
+ frozen curl-impersonate wire behavior.
+- `browser::dynamic-fetch` — real Chromium over CDP, for pages that
+ need JavaScript. Supports `wait_selector` (+ `wait_selector_state`),
+ `network_idle`, and a plain `wait`.
+- `browser::stealthy-fetch` — same, plus masking of the automation
+ tells a page can read. Escalate here only when `dynamic-fetch` is detected.
+- `browser::screenshot-url` — page as image tiles (≤1024px wide, ≤6
+ tiles); says so in the caption when a page is taller than the budget.
+- `browser::session-open` / `session-fetch` / `session-close` /
+ `session-list` — keep cookies and browser state across fetches.
+ HTTP, dynamic and stealthy types are private FIFO sessions with UUID4 hex
+ ids; they never appear in `browser::sessions::list` and reject interactive
+ ids. Close sessions when done.
+- `browser::crawl` — breadth-first from `start_urls`, same-domain by
+ default, capped by `max_pages` (20) and `max_depth` (2). The response holds
+ only a ≤10-item sample; read the rest from the stream it names.
+
+Safe mode refuses private, loopback and cloud-metadata addresses on every one
+of these connections (including redirects and crawl hops). To scrape a local
+dev server the operator must set `browser.scrapling.allow_loopback` in worker
+config. Compat mode reproduces the standalone worker's unrestricted network
+behavior and is for trusted calls.
+
+### HTML parsing — no session, no browser, no network
+
+These take an `html` string and never touch Chromium. Use them on HTML from
+any source (a fetch body, a file, a page you already read).
+
+- `browser::extract` — declarative selector list in one call:
+ each entry names a `css`/`xpath`/`regex` plus optional `attr`/`html`/`all`,
+ and the response is a `{name: value}` map. The right default when pulling
+ several fields off one document.
+- `browser::css` / `browser::xpath` — one query;
+ `first: true` returns a scalar, otherwise an array. `attr` pulls an
+ attribute instead of text.
+- `browser::regex` — regex over the document's visible text.
+- `browser::find` — element search by tag/attribute filters
+ (+ optional text regex), BeautifulSoup-style.
+- `browser::find-by-text` / `browser::find-by-regex` —
+ find elements by their visible text. Responses carry generated css/xpath
+ selectors for each hit, so you can feed one straight back into a query.
+- `browser::find-similar` — give one example element, get its
+ structural siblings. The fast path for "extract every card/row on this
+ page" without hand-writing a selector.
+- `browser::describe` — inspect the first match: attributes,
+ class list, generated selectors, parent/child/sibling counts.
+- `browser::to-markdown` — HTML → compact Markdown (or text), with
+ an optional CSS scope and a main-content cleaner. Use it to shrink a page
+ before putting it in context.
+
+`adaptive: true` persists element identities in the configured SQLite file.
+Parse calls are auto-allowed, so do not assume parsing is side-effect-free
+when adaptive tracking is enabled. Safe mode enforces the configured database
+quota; compat mode preserves the standalone worker's unbounded behavior.
+
+### Safe and compat modes
+
+`browser.scrapling.security_mode` defaults to `safe`. Safe mode keeps SSRF,
+TLS, proxy, response-size, timeout, and adaptive-database policy checks; an
+option the safe backend cannot enforce is refused with an actionable error.
+Compat is eligible only on certified Linux x86_64/aarch64 builds containing
+the frozen curl-impersonate and Chromium artifacts. Other targets reject it,
+and a Tier-1 build missing an artifact reports a capability error instead of
+silently using the safe transport.
+
+Native ids are `browser::<leaf>`. Map `scrapling::screenshot` to
+`browser::screenshot-url`; `browser::screenshot` is the interactive-session
+function. Crawl's default stream is `browser::crawl`.
+
## Workflow: inspect before acting
1. Snapshot first; act on refs from the latest snapshot, never from memory
diff --git a/browser/src/config.rs b/browser/src/config.rs
index 83e63316d..e5f76f014 100644
--- a/browser/src/config.rs
+++ b/browser/src/config.rs
@@ -13,6 +13,101 @@ use serde::{Deserialize, Serialize};
pub type SharedConfig = Arc<ArcSwap<WorkerConfig>>;
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "lowercase")]
+pub enum SecurityMode {
+ #[default]
+ Safe,
+ Compat,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
+pub struct ScraplingDefaults {
+ pub impersonate: String,
+ pub headless: bool,
+ pub network_idle: bool,
+ pub proxy: String,
+ pub include_html: bool,
+}
+
+impl Default for ScraplingDefaults {
+ fn default() -> Self {
+ Self {
+ impersonate: "chrome".to_string(),
+ headless: true,
+ network_idle: false,
+ proxy: String::new(),
+ include_html: false,
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
+#[serde(default)]
+pub struct ScraplingConfig {
+ pub security_mode: SecurityMode,
+ pub chromium_executable: String,
+ pub allow_loopback: bool,
+ pub defaults: ScraplingDefaults,
+ pub max_bulk_concurrency: u64,
+ pub max_sessions: u64,
+ pub session_idle_timeout_s: u64,
+ pub adaptive_storage_path: String,
+ pub adaptive_max_bytes: u64,
+ /// Append the browser::* scraping guidance to agent system prompts.
+ /// Hot-applies: flipping it in the console binds/unbinds the
+ /// pre-generate hook live, no restart (same knob the Python scrapling
+ /// worker and the fp/web workers carry).
+ pub inject_guidance: bool,
+}
+
+impl Default for ScraplingConfig {
+ fn default() -> Self {
+ Self {
+ security_mode: SecurityMode::Safe,
+ chromium_executable: String::new(),
+ allow_loopback: false,
+ defaults: ScraplingDefaults::default(),
+ max_bulk_concurrency: 5,
+ max_sessions: 8,
+ session_idle_timeout_s: 900,
+ adaptive_storage_path: "./data/scrapling/elements.db".to_string(),
+ adaptive_max_bytes: 268_435_456,
+ inject_guidance: true,
+ }
+ }
+}
+
+impl ScraplingConfig {
+ pub fn startup_snapshot(&self) -> ScraplingStartupConfig {
+ ScraplingStartupConfig {
+ max_sessions: self.max_sessions,
+ session_idle_timeout_s: self.session_idle_timeout_s,
+ adaptive_storage_path: self.adaptive_storage_path.clone(),
+ }
+ }
+
+ pub fn adaptive_quota(&self) -> Option<u64> {
+ (self.security_mode == SecurityMode::Safe).then_some(self.adaptive_max_bytes)
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ScraplingStartupConfig {
+ pub max_sessions: u64,
+ pub session_idle_timeout_s: u64,
+ pub adaptive_storage_path: String,
+}
+
+pub const fn scrapling_compat_supported() -> bool {
+ cfg!(all(
+ feature = "scrapling-compat",
+ target_os = "linux",
+ any(target_arch = "x86_64", target_arch = "aarch64")
+ ))
+}
+
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(default)]
pub struct WorkerConfig {
@@ -62,6 +157,19 @@ pub struct WorkerConfig {
/// browser and adopt its tabs. Off by default: attaching reaches the
/// user's real profile with its logged-in sessions, so it is opt-in.
pub allow_attach: bool,
+ /// Native Scrapling compatibility settings. These are isolated from the
+ /// interactive browser runtime above.
+ pub scrapling: ScraplingConfig,
+ /// Internal compatibility projection for routes that have not yet moved
+ /// to the private Scrapling runtime. It is populated from `scrapling` and
+ /// is deliberately absent from the public configuration schema/wire.
+ #[serde(skip)]
+ #[schemars(skip)]
+ pub allow_loopback: bool,
+ /// Internal compatibility projection; see `allow_loopback`.
+ #[serde(skip)]
+ #[schemars(skip)]
+ pub max_bulk_concurrency: u64,
}
impl Default for WorkerConfig {
@@ -82,6 +190,9 @@ impl Default for WorkerConfig {
allowed_schemes: vec!["http".to_string(), "https".to_string(), "file".to_string()],
max_snapshot_nodes: 2_000,
allow_attach: false,
+ scrapling: ScraplingConfig::default(),
+ allow_loopback: false,
+ max_bulk_concurrency: 5,
}
}
}
@@ -97,17 +208,41 @@ impl WorkerConfig {
/// under a `browser` wrapper or flat — accept both.
pub fn from_json(v: &serde_json::Value) -> Result<WorkerConfig, String> {
let inner = v.get("browser").unwrap_or(v);
- serde_json::from_value(inner.clone()).map_err(|e| format!("invalid browser config: {e}"))
+ let mut config: WorkerConfig = serde_json::from_value(inner.clone())
+ .map_err(|e| format!("invalid browser config: {e}"))?;
+ config.validate()?;
+ config.sync_scrapling_projection();
+ Ok(config)
}
pub fn to_json(&self) -> serde_json::Value {
serde_json::to_value(self).expect("WorkerConfig serializes")
}
- pub fn into_shared(self) -> SharedConfig {
+ pub fn into_shared(mut self) -> SharedConfig {
+ self.sync_scrapling_projection();
Arc::new(ArcSwap::from_pointee(self))
}
+ pub fn validate(&self) -> Result<(), String> {
+ self.validate_with_compat_support(scrapling_compat_supported())
+ }
+
+ fn validate_with_compat_support(&self, compat_supported: bool) -> Result<(), String> {
+ if self.scrapling.security_mode == SecurityMode::Compat && !compat_supported {
+ return Err(
+ "browser.scrapling.security_mode=compat is unsupported on this target; compat requires Tier-1 Linux x86_64 or aarch64"
+ .to_string(),
+ );
+ }
+ Ok(())
+ }
+
+ fn sync_scrapling_projection(&mut self) {
+ self.allow_loopback = self.scrapling.allow_loopback;
+ self.max_bulk_concurrency = self.scrapling.max_bulk_concurrency;
+ }
+
/// Clamp a caller-supplied timeout to the configured ceiling, defaulting
/// when omitted.
pub fn clamp_timeout(&self, requested: Option<u64>) -> u64 {
@@ -139,6 +274,32 @@ mod tests {
assert_eq!(c.allowed_schemes, vec!["http", "https", "file"]);
assert_eq!(c.max_snapshot_nodes, 2_000);
assert!(!c.allow_attach);
+ assert_eq!(c.scrapling.security_mode, SecurityMode::Safe);
+ assert_eq!(c.scrapling.chromium_executable, "");
+ assert!(!c.scrapling.allow_loopback);
+ assert_eq!(c.scrapling.defaults.impersonate, "chrome");
+ assert!(c.scrapling.defaults.headless);
+ assert!(!c.scrapling.defaults.network_idle);
+ assert_eq!(c.scrapling.defaults.proxy, "");
+ assert!(!c.scrapling.defaults.include_html);
+ assert_eq!(c.scrapling.max_bulk_concurrency, 5);
+ assert_eq!(c.scrapling.max_sessions, 8);
+ assert_eq!(c.scrapling.session_idle_timeout_s, 900);
+ assert_eq!(
+ c.scrapling.adaptive_storage_path,
+ "./data/scrapling/elements.db"
+ );
+ assert_eq!(c.scrapling.adaptive_max_bytes, 268_435_456);
+ assert_eq!(c.scrapling.adaptive_quota(), Some(268_435_456));
+ }
+
+ #[test]
+ fn compat_keeps_the_oracles_unbounded_adaptive_storage() {
+ let config = ScraplingConfig {
+ security_mode: SecurityMode::Compat,
+ ..ScraplingConfig::default()
+ };
+ assert_eq!(config.adaptive_quota(), None);
}
#[test]
@@ -168,6 +329,121 @@ mod tests {
assert!(!c.headless);
}
+ #[test]
+ fn nested_scrapling_values_parse_without_changing_interactive_values() {
+ let value = serde_json::json!({
+ "browser": {
+ "headless": false,
+ "max_sessions": 3,
+ "scrapling": {
+ "allow_loopback": true,
+ "max_bulk_concurrency": 2,
+ "max_sessions": 7,
+ "session_idle_timeout_s": 45,
+ "adaptive_storage_path": "/tmp/scrapling-test.db",
+ "adaptive_max_bytes": 1024,
+ "defaults": {
+ "impersonate": "firefox",
+ "headless": false,
+ "network_idle": true,
+ "proxy": "http://proxy.test:8080",
+ "include_html": true
+ }
+ }
+ }
+ });
+
+ let config = WorkerConfig::from_json(&value).unwrap();
+ assert!(!config.headless);
+ assert_eq!(config.max_sessions, 3);
+ assert!(config.scrapling.allow_loopback);
+ assert_eq!(config.scrapling.max_bulk_concurrency, 2);
+ assert_eq!(config.scrapling.max_sessions, 7);
+ assert_eq!(config.scrapling.session_idle_timeout_s, 45);
+ assert_eq!(
+ config.scrapling.adaptive_storage_path,
+ "/tmp/scrapling-test.db"
+ );
+ assert_eq!(config.scrapling.adaptive_max_bytes, 1024);
+ assert_eq!(config.scrapling.defaults.impersonate, "firefox");
+ assert!(!config.scrapling.defaults.headless);
+ assert!(config.scrapling.defaults.network_idle);
+ assert_eq!(config.scrapling.defaults.proxy, "http://proxy.test:8080");
+ assert!(config.scrapling.defaults.include_html);
+ assert!(config.allow_loopback);
+ assert_eq!(config.max_bulk_concurrency, 2);
+ }
+
+ #[test]
+ fn serialized_config_exposes_scrapling_settings_only_in_nested_block() {
+ let value = WorkerConfig::default().to_json();
+ assert!(value.get("scrapling").is_some());
+ assert!(value.get("allow_loopback").is_none());
+ assert!(value.get("max_bulk_concurrency").is_none());
+ }
+
+ #[test]
+ fn startup_snapshot_owns_frozen_session_and_adaptive_values() {
+ let mut config = WorkerConfig::default();
+ config.scrapling.max_sessions = 6;
+ config.scrapling.session_idle_timeout_s = 123;
+ config.scrapling.adaptive_storage_path = "/tmp/first.db".to_string();
+
+ let snapshot = config.scrapling.startup_snapshot();
+ config.scrapling.max_sessions = 9;
+ config.scrapling.session_idle_timeout_s = 456;
+ config.scrapling.adaptive_storage_path = "/tmp/second.db".to_string();
+
+ assert_eq!(snapshot.max_sessions, 6);
+ assert_eq!(snapshot.session_idle_timeout_s, 123);
+ assert_eq!(snapshot.adaptive_storage_path, "/tmp/first.db");
+ }
+
+ #[test]
+ fn compat_is_explicitly_rejected_when_target_is_not_tier_one() {
+ let mut config = WorkerConfig::default();
+ config.scrapling.security_mode = SecurityMode::Compat;
+ let error = config.validate_with_compat_support(false).unwrap_err();
+ assert_eq!(
+ error,
+ "browser.scrapling.security_mode=compat is unsupported on this target; compat requires Tier-1 Linux x86_64 or aarch64"
+ );
+ }
+
+ #[test]
+ fn compat_validation_tracks_the_compiled_target() {
+ let result = WorkerConfig::from_json(&serde_json::json!({
+ "scrapling": {"security_mode": "compat"}
+ }));
+ if scrapling_compat_supported() {
+ assert_eq!(
+ result.unwrap().scrapling.security_mode,
+ SecurityMode::Compat
+ );
+ } else {
+ assert_eq!(
+ result.unwrap_err(),
+ "browser.scrapling.security_mode=compat is unsupported on this target; compat requires Tier-1 Linux x86_64 or aarch64"
+ );
+ }
+ }
+
+ #[test]
+ fn safe_mode_is_accepted_on_every_target() {
+ WorkerConfig::default()
+ .validate_with_compat_support(false)
+ .unwrap();
+ }
+
+ #[test]
+ fn unknown_security_mode_is_rejected() {
+ let error = WorkerConfig::from_json(&serde_json::json!({
+ "scrapling": {"security_mode": "unsafe"}
+ }))
+ .unwrap_err();
+ assert!(error.contains("unknown variant `unsafe`"), "{error}");
+ }
+
#[test]
fn clamp_timeout_defaults_and_ceils() {
let c = WorkerConfig::default();
@@ -183,5 +459,38 @@ mod tests {
assert!(props.get("executable").is_some());
assert!(props.get("headless").is_some());
assert!(props.get("allowed_schemes").is_some());
+ let scrapling = &props["scrapling"];
+ assert_eq!(
+ scrapling["default"],
+ serde_json::to_value(WorkerConfig::default().scrapling).unwrap()
+ );
+ assert_eq!(
+ scrapling["allOf"][0]["$ref"],
+ "#/definitions/ScraplingConfig"
+ );
+ let scrapling_properties = &s["definitions"]["ScraplingConfig"]["properties"];
+ let names: std::collections::BTreeSet<_> = scrapling_properties
+ .as_object()
+ .unwrap()
+ .keys()
+ .map(String::as_str)
+ .collect();
+ assert_eq!(
+ names,
+ std::collections::BTreeSet::from([
+ "adaptive_max_bytes",
+ "adaptive_storage_path",
+ "allow_loopback",
+ "chromium_executable",
+ "defaults",
+ "inject_guidance",
+ "max_bulk_concurrency",
+ "max_sessions",
+ "security_mode",
+ "session_idle_timeout_s",
+ ])
+ );
+ assert!(props.get("allow_loopback").is_none());
+ assert!(props.get("max_bulk_concurrency").is_none());
}
}
diff --git a/browser/src/configuration.rs b/browser/src/configuration.rs
index 7bef16766..fc086899f 100644
--- a/browser/src/configuration.rs
+++ b/browser/src/configuration.rs
@@ -68,7 +68,11 @@ struct OnConfigChangeResponse {
ok: bool,
}
-pub fn register_config_trigger(iii: &IIIClient, config: SharedConfig) -> Result<(), Error> {
+pub fn register_config_trigger(
+ iii: &IIIClient,
+ config: SharedConfig,
+ guidance: crate::scrapling::GuidanceState,
+) -> Result<(), Error> {
let cfg = config.clone();
let engine = iii.clone();
iii.register_function(
@@ -76,8 +80,9 @@ pub fn register_config_trigger(iii: &IIIClient, config: SharedConfig) -> Result<
RegisterFunction::new_async(move |_req: OnConfigChangeRequest| {
let cfg = cfg.clone();
let engine = engine.clone();
+ let guidance = guidance.clone();
async move {
- on_config_change(&engine, &cfg).await;
+ on_config_change(&engine, &cfg, &guidance).await;
Ok::<OnConfigChangeResponse, Error>(OnConfigChangeResponse { ok: true })
}
})
@@ -96,10 +101,19 @@ pub fn register_config_trigger(iii: &IIIClient, config: SharedConfig) -> Result<
Ok(())
}
-async fn on_config_change(iii: &IIIClient, config: &SharedConfig) {
+async fn on_config_change(
+ iii: &IIIClient,
+ config: &SharedConfig,
+ guidance: &crate::scrapling::GuidanceState,
+) {
match fetch_config(iii).await {
Ok(cfg) => {
+ crate::scrapling::adaptive::configure_quota(cfg.scrapling.adaptive_quota());
+ let inject_guidance = cfg.scrapling.inject_guidance;
config.store(std::sync::Arc::new(cfg));
+ // Hot-apply: flipping browser.scrapling.inject_guidance in the
+ // console binds/unbinds the pre-generate guidance hook live.
+ crate::scrapling::apply_guidance(iii, guidance, inject_guidance);
tracing::info!("browser configuration reloaded");
}
Err(e) => tracing::error!(error = %e, "config-change: keeping previous config"),
diff --git a/browser/src/lib.rs b/browser/src/lib.rs
index 8b3f763e5..ddfbfcb87 100644
--- a/browser/src/lib.rs
+++ b/browser/src/lib.rs
@@ -1,12 +1,16 @@
//! Library surface for the `browser` worker: interactive Chromium sessions
-//! on the iii bus. The binary (`src/main.rs`) is a thin boot sequence;
-//! everything testable lives here.
+//! on the iii bus, plus the native `browser::*` HTML-parsing
+//! surface. The binary (`src/main.rs`) is a thin boot sequence; everything
+//! testable lives here.
pub mod config;
pub mod configuration;
pub mod events;
pub mod functions;
+pub mod logging;
pub mod manifest;
+pub mod scrapling;
pub mod session;
pub mod snapshot;
+pub mod ssrf;
pub mod ui;
diff --git a/browser/src/logging.rs b/browser/src/logging.rs
new file mode 100644
index 000000000..482704729
--- /dev/null
+++ b/browser/src/logging.rs
@@ -0,0 +1,99 @@
+//! Log-filter construction for the worker binary.
+//!
+//! chromiumoxide 0.9.1's protocol bindings lag the system Chromium, so events
+//! carrying enum values added since (e.g. DOM.pseudoElementAdded with
+//! `overscroll-backdrop` on Chrome 151) fail its untagged-enum deserialize and
+//! its handler WARN-spams "WS Invalid message" on every such frame — dozens
+//! per page load. The frames are dropped either way (`ignore_invalid_messages`
+//! defaults on; command responses can't fail this way, only events), so the
+//! WARN carries no signal an operator can act on. Demote that module to
+//! `error` unless the operator's RUST_LOG addresses chromiumoxide explicitly.
+//!
+//! ponytail: known ceiling — a Network.loadingFailed carrying one of the
+//! Chrome-151 corsError values is still silently dropped before our listener;
+//! recovering it needs chromiumoxide regenerated against the newer protocol
+//! (no such release yet; 0.9.1 is current).
+
+use tracing_subscriber::EnvFilter;
+
+/// The worker's env filter: RUST_LOG (default `info`), with
+/// `chromiumoxide::handler` demoted to `error` unless RUST_LOG mentions
+/// chromiumoxide — an explicit operator directive always wins.
+pub fn env_filter(rust_log: Option<&str>) -> EnvFilter {
+ let mut filter = match rust_log {
+ Some(directives) => EnvFilter::new(directives),
+ None => EnvFilter::new("info"),
+ };
+ if rust_log.is_none_or(|directives| !directives.contains("chromiumoxide")) {
+ filter = filter.add_directive(
+ "chromiumoxide::handler=error"
+ .parse()
+ .expect("static directive parses"),
+ );
+ }
+ filter
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::io::Write;
+ use std::sync::{Arc, Mutex};
+ use tracing_subscriber::layer::SubscriberExt;
+
+ #[derive(Clone, Default)]
+ struct Buffer(Arc<Mutex<Vec<u8>>>);
+
+ impl Write for Buffer {
+ fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+ self.0.lock().unwrap().extend_from_slice(buf);
+ Ok(buf.len())
+ }
+ fn flush(&mut self) -> std::io::Result<()> {
+ Ok(())
+ }
+ }
+
+ fn captured(filter: EnvFilter) -> String {
+ let buffer = Buffer::default();
+ let writer = buffer.clone();
+ let subscriber = tracing_subscriber::registry().with(filter).with(
+ tracing_subscriber::fmt::layer()
+ .with_writer(move || writer.clone())
+ .with_ansi(false),
+ );
+ tracing::subscriber::with_default(subscriber, || {
+ tracing::warn!(target: "chromiumoxide::handler", "WS Invalid message");
+ tracing::error!(target: "chromiumoxide::handler", "WS Connection error");
+ tracing::warn!(target: "browser::session", "worker warn passes");
+ });
+ let bytes = buffer.0.lock().unwrap().clone();
+ String::from_utf8(bytes).unwrap()
+ }
+
+ #[test]
+ fn default_filter_drops_the_invalid_message_spam_but_keeps_errors() {
+ let out = captured(env_filter(None));
+ assert!(
+ !out.contains("WS Invalid message"),
+ "spam not dropped:\n{out}"
+ );
+ assert!(
+ out.contains("WS Connection error"),
+ "real errors lost:\n{out}"
+ );
+ assert!(
+ out.contains("worker warn passes"),
+ "worker warns lost:\n{out}"
+ );
+ }
+
+ #[test]
+ fn explicit_chromiumoxide_directive_in_rust_log_wins() {
+ let out = captured(env_filter(Some("info,chromiumoxide=warn")));
+ assert!(
+ out.contains("WS Invalid message"),
+ "operator's explicit directive was overridden:\n{out}"
+ );
+ }
+}
diff --git a/browser/src/main.rs b/browser/src/main.rs
index f9273e8fb..372243884 100644
--- a/browser/src/main.rs
+++ b/browser/src/main.rs
@@ -1,6 +1,7 @@
//! `browser` binary entry: connect, register configuration + fetch the
-//! authoritative value, register the five `browser::*` trigger types and
-//! twelve functions, start the idle sweep, then sleep until Ctrl+C.
+//! authoritative value, register the `browser::*` trigger types and functions
+//! plus the native `browser::*` parse surface, start the idle
+//! sweep, then sleep until Ctrl+C.
use std::sync::Arc;
use std::time::Duration;
@@ -13,7 +14,7 @@ use iii_sdk::{register_worker, InitOptions};
use browser::config::WorkerConfig;
use browser::events::{self, IiiDeliverer};
use browser::session::Sessions;
-use browser::{configuration, functions, manifest};
+use browser::{configuration, functions, manifest, scrapling};
#[derive(Parser, Debug)]
#[command(
@@ -53,11 +54,9 @@ async fn wait_for_shutdown_signal() -> Result<()> {
#[tokio::main]
async fn main() -> Result<()> {
+ let rust_log = std::env::var("RUST_LOG").ok();
tracing_subscriber::fmt()
- .with_env_filter(
- tracing_subscriber::EnvFilter::try_from_default_env()
- .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
- )
+ .with_env_filter(browser::logging::env_filter(rust_log.as_deref()))
.init();
let cli = Cli::parse();
@@ -120,10 +119,19 @@ async fn main() -> Result<()> {
.await
.map_err(anyhow::Error::msg)
.context("loading browser configuration")?;
+ let scrapling_startup = cfg.scrapling.startup_snapshot();
+ scrapling::adaptive::configure(&scrapling_startup.adaptive_storage_path)
+ .map_err(anyhow::Error::msg)
+ .context("configuring Scrapling adaptive storage")?;
+ scrapling::adaptive::configure_quota(cfg.scrapling.adaptive_quota());
tracing::info!(
headless = cfg.headless,
max_sessions = cfg.max_sessions,
console_buffer = cfg.console_buffer,
+ scrapling_security_mode = ?cfg.scrapling.security_mode,
+ scrapling_max_sessions = scrapling_startup.max_sessions,
+ scrapling_session_idle_timeout_s = scrapling_startup.session_idle_timeout_s,
+ scrapling_adaptive_storage_path = %scrapling_startup.adaptive_storage_path,
"loaded browser configuration"
);
let shared = cfg.into_shared();
@@ -138,27 +146,45 @@ async fn main() -> Result<()> {
let sessions = Sessions::new(shared.clone(), emitter, iii.clone());
functions::register_all(&iii, &sessions);
- configuration::register_config_trigger(&iii, shared.clone())
+ // Scrapling owns a private HTTP/dynamic/stealthy registry. Its ids never
+ // enter or control the interactive browser::sessions::* registry.
+ let scrapling_ctx = Arc::new(scrapling::net::Ctx::new(sessions.clone(), iii.clone()));
+ scrapling::register_all(&iii, &scrapling_ctx);
+ // The guidance hook FUNCTION is registered above (inert without a
+ // binding); the binding follows the inject_guidance knob — applied here
+ // at boot and re-applied by the config-change handler, so console flips
+ // take effect without a restart.
+ let guidance = scrapling::GuidanceState::default();
+ scrapling::apply_guidance(&iii, &guidance, shared.load().scrapling.inject_guidance);
+
+ configuration::register_config_trigger(&iii, shared.clone(), guidance)
.context("registering configuration change trigger")?;
// Injectable console UI — after the browser::* functions so the console
// can attribute the assets.
browser::ui::register(&iii);
- // Idle sweep: stop sessions nobody has touched for idle_stop_ms.
+ // Idle sweep closes metadata and backends together in both registries.
let sweep_sessions = sessions.clone();
+ let sweep_ctx = scrapling_ctx.clone();
let sweep = tokio::spawn(async move {
let mut tick = tokio::time::interval(Duration::from_secs(60));
loop {
tick.tick().await;
sweep_sessions.sweep_idle().await;
+ for id in sweep_ctx.http.sweep_idle() {
+ tracing::info!(session = %id, "scrapling session reaped (idle)");
+ }
}
});
- tracing::info!("browser ready: browser::* sessions + console capture + pick");
+ tracing::info!(
+ "browser ready: browser::* sessions + console capture + pick, browser::* parsing"
+ );
wait_for_shutdown_signal().await?;
tracing::info!("browser shutting down");
sweep.abort();
+ scrapling_ctx.http.close_all().await;
sessions.stop_all().await;
iii.shutdown_async().await;
Ok(())
diff --git a/browser/src/manifest.rs b/browser/src/manifest.rs
index f0bbc37fd..4d39daa54 100644
--- a/browser/src/manifest.rs
+++ b/browser/src/manifest.rs
@@ -17,7 +17,8 @@ pub fn build_manifest() -> ModuleManifest {
version: env!("CARGO_PKG_VERSION").to_string(),
description:
"Interactive Chromium sessions on the iii bus. Navigate, act, read the page console, \
- pick elements."
+ pick elements. Also parses HTML natively without a browser \
+ (browser::* — css/xpath/regex, element search, markdown)."
.to_string(),
default_config: WorkerConfig::default().to_json(),
supported_targets: vec![env!("TARGET").to_string()],
diff --git a/browser/src/scrapling/adaptive.rs b/browser/src/scrapling/adaptive.rs
new file mode 100644
index 000000000..19403f93a
--- /dev/null
+++ b/browser/src/scrapling/adaptive.rs
@@ -0,0 +1,685 @@
+//! Scrapling 0.4.9 Smart Element Tracking over the shared compatibility DOM.
+
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{OnceLock, RwLock};
+use std::time::Duration;
+
+use rusqlite::{params, types::ValueRef, Connection};
+use serde::{Deserialize, Serialize};
+use serde_json::Map;
+
+use crate::scrapling::dom::{self, Doc, ElementRef};
+use crate::scrapling::query::{self, QueryResult};
+
+const DEFAULT_PATH: &str = "./data/scrapling/elements.db";
+const MIN_SCORE: f64 = 40.0;
+
+// Delta from psl 2.1.180 to tld 0.13.2's frozen 2026-03-06 PSL. The source
+// snapshot's SHA-256 is
+// abf32ce9987d505b89765d76f35760543851235508f1f426b5b259a2062b5f68.
+const FROZEN_ADDED_EXACT: &str = "1cooldns.com
+auth.cognito-idp.eusc-de-east-1.on.amazonwebservices.eu
+blob.core.usgovcloudapi.net
+bumbleshrimp.com
+com.kh
+corespeed.app
+ddnsguru.com
+discourse.diy
+drive-platform.com
+drive-platform.io
+dynuddns.com
+dynuddns.net
+dynuhosting.com
+edu.kh
+eu-west-1.convex.cloud
+eu-west-1.convex.site
+file.core.usgovcloudapi.net
+file.core.windows.net
+gov.kh
+hue.vn
+imagine.diy
+intouch.email
+kdns.fr
+keenetic.io
+keenetic.link
+keenetic.name
+keenetic.pro
+kh
+miren.app
+miren.systems
+ms.fun
+ms.show
+my.be
+mybox.company
+mybox.me
+mybox.page
+mysynology.net
+net.kh
+opik.net
+org.kh
+pivohosting.com
+roxa.org
+s3-website.dualstack.us-gov-east-1.amazonaws.com
+s3-website.dualstack.us-gov-west-1.amazonaws.com
+sandbox.deno.net
+shiptoday.app
+shiptoday.build
+sol.site
+spawnbase.app
+spryt.net
+transfer-webapp.ap-southeast-7.on.aws
+transfer-webapp.mx-central-1.on.aws
+us-east-1.convex.cloud
+us-east-1.convex.site
+usgovtrafficmanager.net
+web.core.usgovcloudapi.net
+web.core.windows.net
+wiredbladehosting.com";
+const FROZEN_ADDED_WILDCARD_BASES: &str = "aa.crm.dev
+ab.crm.dev
+ac.crm.dev
+ad.crm.dev
+ae.crm.dev
+af.crm.dev
+begetcdn.cloud
+ci.crm.dev
+pa.crm.dev
+pb.crm.dev
+pc.crm.dev
+pd.crm.dev
+pe.crm.dev
+pf.crm.dev";
+const FROZEN_REMOVED_EXACT: &[&str] = &["12chars.dev", "12chars.it", "12chars.pro", "mazeplay.com"];
+
+static STORAGE_PATH: OnceLock<RwLock<PathBuf>> = OnceLock::new();
+// `u64::MAX` means oracle-compatible unbounded storage.
+static MAX_BYTES: AtomicU64 = AtomicU64::new(u64::MAX);
+
+fn configured_path() -> &'static RwLock<PathBuf> {
+ STORAGE_PATH.get_or_init(|| RwLock::new(PathBuf::from(DEFAULT_PATH)))
+}
+
+/// Set the process-wide adaptive database path, matching the standalone
+/// worker's one-time `storage.configure(...)` boot setting.
+pub fn configure(path: impl AsRef<Path>) -> Result<(), String> {
+ let path = path.as_ref();
+ if let Some(parent) = path.parent() {
+ std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
+ }
+ *configured_path()
+ .write()
+ .map_err(|error| error.to_string())? = path.to_path_buf();
+ Ok(())
+}
+
+/// Apply the live safe-mode storage ceiling. Compat passes `None` to retain
+/// the standalone worker's unbounded behavior.
+pub fn configure_quota(max_bytes: Option<u64>) {
+ MAX_BYTES.store(max_bytes.unwrap_or(u64::MAX), Ordering::Relaxed);
+}
+
+fn storage_path() -> Result<PathBuf, String> {
+ configured_path()
+ .read()
+ .map(|path| path.clone())
+ .map_err(|error| error.to_string())
+}
+
+pub fn css_query<'a>(
+ doc: &'a Doc,
+ scope: Option<ElementRef<'a>>,
+ selector: &str,
+ domain: Option<&str>,
+ identifier: &str,
+ auto_save: bool,
+) -> Result<Vec<QueryResult<'a>>, String> {
+ let mut storage = Storage::open(domain)?;
+ if selector.contains(',') {
+ let selectors = cssselect::parse(selector)
+ .map_err(|error| format!("Invalid CSS selector '{selector}': {error}"))?;
+ let mut results = Vec::new();
+ for parsed in selectors {
+ let direct = query::css_query(doc, scope, &parsed.canonical())?;
+ results.extend(storage.resolve(doc, direct, identifier, auto_save)?);
+ }
+ Ok(results)
+ } else {
+ let direct = query::css_query(doc, scope, selector)?;
+ storage.resolve(doc, direct, identifier, auto_save)
+ }
+}
+
+pub fn xpath_query<'a>(
+ doc: &'a Doc,
+ scope: Option<ElementRef<'a>>,
+ selector: &str,
+ domain: Option<&str>,
+ identifier: &str,
+ auto_save: bool,
+) -> Result<Vec<QueryResult<'a>>, String> {
+ let direct = crate::scrapling::xpath::xpath_query(doc, scope, selector)?;
+ Storage::open(domain)?.resolve(doc, direct, identifier, auto_save)
+}
+
+struct Storage {
+ connection: Connection,
+ domain: String,
+}
+
+impl Storage {
+ fn open(domain: Option<&str>) -> Result<Self, String> {
+ let path = storage_path()?;
+ if let Some(parent) = path.parent() {
+ std::fs::create_dir_all(parent).map_err(|error| error.to_string())?;
+ }
+ let connection = Connection::open(path).map_err(|error| error.to_string())?;
+ connection
+ .busy_timeout(Duration::from_secs(5))
+ .map_err(|error| error.to_string())?;
+ connection
+ .pragma_update(None, "journal_mode", "WAL")
+ .map_err(|error| error.to_string())?;
+ connection
+ .execute_batch(
+ "CREATE TABLE IF NOT EXISTS storage (\n\
+ id INTEGER PRIMARY KEY,\n\
+ url TEXT,\n\
+ identifier TEXT,\n\
+ element_data TEXT,\n\
+ UNIQUE (url, identifier)\n\
+ );",
+ )
+ .map_err(|error| error.to_string())?;
+ Ok(Self {
+ connection,
+ domain: base_url(domain),
+ })
+ }
+
+ fn resolve<'a>(
+ &mut self,
+ doc: &'a Doc,
+ direct: Vec<QueryResult<'a>>,
+ identifier: &str,
+ auto_save: bool,
+ ) -> Result<Vec<QueryResult<'a>>, String> {
+ if !direct.is_empty() {
+ if auto_save {
+ self.save(result_element(&direct[0]), identifier)?;
+ }
+ return Ok(direct);
+ }
+
+ let Some(saved) = self.retrieve(identifier)? else {
+ return Ok(Vec::new());
+ };
+ let relocated = relocate(doc, &saved);
+ if auto_save {
+ if let Some(first) = relocated.first().copied() {
+ self.save(first, identifier)?;
+ }
+ }
+ Ok(relocated.into_iter().map(QueryResult::Element).collect())
+ }
+
+ fn save(&mut self, element: ElementRef<'_>, identifier: &str) -> Result<(), String> {
+ let bytes = serde_json::to_vec(&ElementData::from_element(element))
+ .map_err(|error| error.to_string())?;
+ let transaction = self
+ .connection
+ .transaction()
+ .map_err(|error| error.to_string())?;
+ transaction
+ .execute(
+ "INSERT OR REPLACE INTO storage (url, identifier, element_data) VALUES (?, ?, ?)",
+ params![self.domain, identifier, bytes],
+ )
+ .map_err(|error| error.to_string())?;
+ let max_bytes = MAX_BYTES.load(Ordering::Relaxed);
+ if max_bytes != u64::MAX {
+ let pages: u64 = transaction
+ .pragma_query_value(None, "page_count", |row| row.get(0))
+ .map_err(|error| error.to_string())?;
+ let page_size: u64 = transaction
+ .pragma_query_value(None, "page_size", |row| row.get(0))
+ .map_err(|error| error.to_string())?;
+ if pages.saturating_mul(page_size) > max_bytes {
+ return Err(format!(
+ "adaptive storage quota exceeded ({max_bytes} bytes); raise browser.scrapling.adaptive_max_bytes or disable adaptive mode"
+ ));
+ }
+ }
+ transaction.commit().map_err(|error| error.to_string())
+ }
+
+ fn retrieve(&self, identifier: &str) -> Result<Option<ElementData>, String> {
+ let mut statement = self
+ .connection
+ .prepare("SELECT element_data FROM storage WHERE url = ? AND identifier = ?")
+ .map_err(|error| error.to_string())?;
+ let mut rows = statement
+ .query(params![self.domain, identifier])
+ .map_err(|error| error.to_string())?;
+ let Some(row) = rows.next().map_err(|error| error.to_string())? else {
+ return Ok(None);
+ };
+ let value = row.get_ref(0).map_err(|error| error.to_string())?;
+ let bytes = match value {
+ ValueRef::Blob(bytes) | ValueRef::Text(bytes) => bytes,
+ _ => return Err("adaptive element_data is neither BLOB nor TEXT".to_string()),
+ };
+ serde_json::from_slice(bytes)
+ .map(Some)
+ .map_err(|error| error.to_string())
+ }
+}
+
+fn result_element<'a>(result: &QueryResult<'a>) -> ElementRef<'a> {
+ match result {
+ QueryResult::Element(element) => *element,
+ QueryResult::Text { parent, .. } => *parent,
+ }
+}
+
+fn base_url(domain: Option<&str>) -> String {
+ let Some(raw) = domain.filter(|value| !value.is_empty()) else {
+ return "default".to_string();
+ };
+ let lower = raw.to_lowercase();
+ let parsed = url::Url::parse(&lower).or_else(|_| url::Url::parse(&format!("http://{lower}")));
+ let Some(host) = parsed
+ .ok()
+ .and_then(|url| url.host_str().map(str::to_string))
+ else {
+ return "default".to_string();
+ };
+ frozen_registrable_domain(&host).unwrap_or_else(|| "default".to_string())
+}
+
+fn frozen_registrable_domain(host: &str) -> Option<String> {
+ let exact = FROZEN_ADDED_EXACT
+ .lines()
+ .filter(|rule| host == *rule || host.ends_with(&format!(".{rule}")))
+ .max_by_key(|rule| rule.len());
+ let wildcard = FROZEN_ADDED_WILDCARD_BASES
+ .lines()
+ .filter_map(|base| {
+ let prefix = host.strip_suffix(&format!(".{base}"))?;
+ (!prefix.is_empty()).then_some((base, prefix))
+ })
+ .max_by_key(|(base, _)| base.len());
+
+ let frozen_suffix = match (exact, wildcard) {
+ (Some(rule), Some((base, prefix))) if base.len() + prefix.len() + 1 > rule.len() => {
+ let wildcard_label = prefix.rsplit('.').next()?;
+ format!("{wildcard_label}.{base}")
+ }
+ (Some(rule), _) => rule.to_string(),
+ (None, Some((base, prefix))) => {
+ let wildcard_label = prefix.rsplit('.').next()?;
+ format!("{wildcard_label}.{base}")
+ }
+ (None, None) => String::new(),
+ };
+ if !frozen_suffix.is_empty() {
+ return registrable_for_suffix(host, &frozen_suffix);
+ }
+
+ for rule in FROZEN_REMOVED_EXACT {
+ if host == *rule || host.ends_with(&format!(".{rule}")) {
+ return Some((*rule).to_string());
+ }
+ }
+ if host == "goo"
+ || host.ends_with(".goo")
+ || host == "wolterskluwer"
+ || host.ends_with(".wolterskluwer")
+ {
+ return None;
+ }
+ if host.ends_with(".cns.joyent.com") {
+ return Some("joyent.com".to_string());
+ }
+ if let Some(prefix) = host.strip_suffix(".kh") {
+ if !prefix.is_empty() {
+ let label = prefix.rsplit('.').next()?;
+ return Some(format!("{label}.kh"));
+ }
+ }
+
+ let suffix = psl::suffix(host.as_bytes())?;
+ if !suffix.is_known() {
+ return None;
+ }
+ psl::domain_str(host)
+ .or_else(|| std::str::from_utf8(suffix.trim().as_bytes()).ok())
+ .map(str::to_string)
+}
+
+fn registrable_for_suffix(host: &str, suffix: &str) -> Option<String> {
+ if host == suffix {
+ return Some(suffix.to_string());
+ }
+ let prefix = host.strip_suffix(&format!(".{suffix}"))?;
+ let label = prefix.rsplit('.').next()?;
+ Some(format!("{label}.{suffix}"))
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ElementData {
+ tag: String,
+ attributes: Map<String, serde_json::Value>,
+ text: Option<String>,
+ path: Vec<String>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ parent_name: Option<String>,
+ #[serde(default, skip_serializing_if = "Map::is_empty")]
+ parent_attribs: Map<String, serde_json::Value>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ parent_text: Option<String>,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ siblings: Vec<String>,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ children: Vec<String>,
+}
+
+impl ElementData {
+ fn from_element(element: ElementRef<'_>) -> Self {
+ let attributes = element
+ .attrs()
+ .filter_map(|(name, value)| {
+ let value = value.trim();
+ (!value.is_empty()).then(|| {
+ (
+ name.to_string(),
+ serde_json::Value::String(value.to_string()),
+ )
+ })
+ })
+ .collect();
+ let raw_text = dom::leading_text(element);
+ let text = (!raw_text.is_empty()).then(|| raw_text.trim().to_string());
+ let mut path = vec![element.name().to_string()];
+ let mut current = element;
+ while let Some(parent) = dom::parent_element(current) {
+ path.push(parent.name().to_string());
+ current = parent;
+ }
+ path.reverse();
+
+ let parent = dom::parent_element(element);
+ let parent_name = parent.map(|value| value.name().to_string());
+ let parent_attribs = parent
+ .map(|value| dom::attrs_json(value))
+ .unwrap_or_default();
+ let parent_text = parent.and_then(|value| {
+ let raw = dom::leading_text(value);
+ (!raw.is_empty()).then(|| raw.trim().to_string())
+ });
+ let siblings = parent
+ .map(|value| {
+ dom::element_children(value)
+ .into_iter()
+ .filter(|child| child.id() != element.id())
+ .map(|child| child.name().to_string())
+ .collect()
+ })
+ .unwrap_or_default();
+ let children = dom::element_children(element)
+ .into_iter()
+ .map(|child| child.name().to_string())
+ .collect();
+
+ Self {
+ tag: element.name().to_string(),
+ attributes,
+ text,
+ path,
+ parent_name,
+ parent_attribs,
+ parent_text,
+ siblings,
+ children,
+ }
+ }
+}
+
+fn relocate<'a>(doc: &'a Doc, saved: &ElementData) -> Vec<ElementRef<'a>> {
+ let mut best = f64::NEG_INFINITY;
+ let mut matches = Vec::new();
+ for element in dom::descendant_elements(doc.root()) {
+ let score = similarity(saved, &ElementData::from_element(element));
+ if score > best {
+ best = score;
+ matches.clear();
+ matches.push(element);
+ } else if score == best {
+ matches.push(element);
+ }
+ }
+ if best >= MIN_SCORE {
+ matches
+ } else {
+ Vec::new()
+ }
+}
+
+fn similarity(original: &ElementData, candidate: &ElementData) -> f64 {
+ let mut score = f64::from(original.tag == candidate.tag);
+ let mut checks = 1usize;
+
+ if let Some(text) = original.text.as_deref().filter(|value| !value.is_empty()) {
+ score += string_ratio(text, candidate.text.as_deref().unwrap_or(""));
+ checks += 1;
+ }
+
+ score += map_ratio(&original.attributes, &candidate.attributes);
+ checks += 1;
+ for name in ["class", "id", "href", "src"] {
+ if let Some(value) =
+ string_attr(&original.attributes, name).filter(|value| !value.is_empty())
+ {
+ score += string_ratio(
+ value,
+ string_attr(&candidate.attributes, name).unwrap_or(""),
+ );
+ checks += 1;
+ }
+ }
+
+ score += sequence_ratio(&original.path, &candidate.path);
+ checks += 1;
+
+ if let Some(parent_name) = original
+ .parent_name
+ .as_deref()
+ .filter(|value| !value.is_empty())
+ {
+ if let Some(candidate_parent) = candidate.parent_name.as_deref() {
+ score += string_ratio(parent_name, candidate_parent);
+ checks += 1;
+ score += map_ratio(&original.parent_attribs, &candidate.parent_attribs);
+ checks += 1;
+ if let Some(parent_text) = original
+ .parent_text
+ .as_deref()
+ .filter(|value| !value.is_empty())
+ {
+ score += string_ratio(parent_text, candidate.parent_text.as_deref().unwrap_or(""));
+ checks += 1;
+ }
+ }
+ }
+
+ if !original.siblings.is_empty() {
+ score += sequence_ratio(&original.siblings, &candidate.siblings);
+ checks += 1;
+ }
+
+ round2((score / checks as f64) * 100.0)
+}
+
+fn string_attr<'a>(map: &'a Map<String, serde_json::Value>, name: &str) -> Option<&'a str> {
+ map.get(name).and_then(serde_json::Value::as_str)
+}
+
+fn map_ratio(left: &Map<String, serde_json::Value>, right: &Map<String, serde_json::Value>) -> f64 {
+ let left_keys: Vec<&str> = left.keys().map(String::as_str).collect();
+ let right_keys: Vec<&str> = right.keys().map(String::as_str).collect();
+ let left_values: Vec<&str> = left
+ .values()
+ .filter_map(serde_json::Value::as_str)
+ .collect();
+ let right_values: Vec<&str> = right
+ .values()
+ .filter_map(serde_json::Value::as_str)
+ .collect();
+ sequence_ratio(&left_keys, &right_keys) * 0.5
+ + sequence_ratio(&left_values, &right_values) * 0.5
+}
+
+fn round2(value: f64) -> f64 {
+ format!("{value:.2}").parse().expect("formatted f64")
+}
+
+fn string_ratio(left: &str, right: &str) -> f64 {
+ sequence_ratio(
+ &left.chars().collect::<Vec<_>>(),
+ &right.chars().collect::<Vec<_>>(),
+ )
+}
+
+fn sequence_ratio<T: Eq + Hash>(left: &[T], right: &[T]) -> f64 {
+ let total = left.len() + right.len();
+ if total == 0 {
+ return 1.0;
+ }
+ let mut positions: HashMap<&T, Vec<usize>> = HashMap::new();
+ for (index, item) in right.iter().enumerate() {
+ positions.entry(item).or_default().push(index);
+ }
+ if right.len() >= 200 {
+ let threshold = right.len() / 100 + 1;
+ positions.retain(|_, indexes| indexes.len() <= threshold);
+ }
+
+ let mut queue = vec![(0, left.len(), 0, right.len())];
+ let mut blocks = Vec::new();
+ while let Some((left_start, left_end, right_start, right_end)) = queue.pop() {
+ let (i, j, size) = longest_match(
+ left,
+ right,
+ &positions,
+ left_start,
+ left_end,
+ right_start,
+ right_end,
+ );
+ if size == 0 {
+ continue;
+ }
+ if left_start < i && right_start < j {
+ queue.push((left_start, i, right_start, j));
+ }
+ if i + size < left_end && j + size < right_end {
+ queue.push((i + size, left_end, j + size, right_end));
+ }
+ blocks.push((i, j, size));
+ }
+ blocks.sort_unstable();
+ let matches: usize = blocks.into_iter().map(|(_, _, size)| size).sum();
+ 2.0 * matches as f64 / total as f64
+}
+
+#[allow(clippy::too_many_arguments)]
+fn longest_match<T: Eq + Hash>(
+ left: &[T],
+ right: &[T],
+ positions: &HashMap<&T, Vec<usize>>,
+ left_start: usize,
+ left_end: usize,
+ right_start: usize,
+ right_end: usize,
+) -> (usize, usize, usize) {
+ let (mut best_i, mut best_j, mut best_size) = (left_start, right_start, 0usize);
+ let mut previous = HashMap::new();
+ for (i, item) in left.iter().enumerate().take(left_end).skip(left_start) {
+ let mut current = HashMap::new();
+ if let Some(indexes) = positions.get(item) {
+ for &j in indexes {
+ if j < right_start {
+ continue;
+ }
+ if j >= right_end {
+ break;
+ }
+ let size = if j == 0 {
+ 1
+ } else {
+ previous.get(&(j - 1)).copied().unwrap_or(0) + 1
+ };
+ current.insert(j, size);
+ if size > best_size {
+ (best_i, best_j, best_size) = (i + 1 - size, j + 1 - size, size);
+ }
+ }
+ }
+ previous = current;
+ }
+ while best_i > left_start && best_j > right_start && left[best_i - 1] == right[best_j - 1] {
+ best_i -= 1;
+ best_j -= 1;
+ best_size += 1;
+ }
+ while best_i + best_size < left_end
+ && best_j + best_size < right_end
+ && left[best_i + best_size] == right[best_j + best_size]
+ {
+ best_size += 1;
+ }
+ (best_i, best_j, best_size)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ struct UnlimitedOnDrop;
+
+ impl Drop for UnlimitedOnDrop {
+ fn drop(&mut self) {
+ configure_quota(None);
+ }
+ }
+
+ #[test]
+ fn sequence_matcher_compares_unicode_code_points() {
+ assert_eq!(string_ratio("é", "è"), 0.0);
+ }
+
+ #[test]
+ fn sequence_matcher_does_not_extend_before_right_index_zero() {
+ assert_eq!(sequence_ratio(b"xx", b"x"), 2.0 / 3.0);
+ }
+
+ #[test]
+ fn safe_quota_rolls_back_an_oversized_save() {
+ let path = std::env::temp_dir().join(format!(
+ "browser-adaptive-quota-{}.db",
+ uuid::Uuid::new_v4().simple()
+ ));
+ configure(&path).unwrap();
+ configure_quota(Some(1));
+ let _reset = UnlimitedOnDrop;
+ let doc = dom::parse("<p id=x>saved identity</p>");
+ let error = css_query(&doc, None, "p", Some("example.com"), "p", true).unwrap_err();
+ assert!(error.contains("adaptive storage quota exceeded"), "{error}");
+
+ for suffix in ["", "-wal", "-shm"] {
+ let _ = std::fs::remove_file(format!("{}{suffix}", path.display()));
+ }
+ }
+}
diff --git a/browser/src/scrapling/browserforge.rs b/browser/src/scrapling/browserforge.rs
new file mode 100644
index 000000000..7968fa8a5
--- /dev/null
+++ b/browser/src/scrapling/browserforge.rs
@@ -0,0 +1,630 @@
+//! Frozen BrowserForge 1.2.4 header generator used by Scrapling 0.4.9.
+
+use std::collections::{HashMap, HashSet};
+use std::io::Read;
+use std::sync::{Mutex, OnceLock};
+
+use serde::Deserialize;
+use serde_json::{Map, Value};
+
+const MISSING: &str = "*MISSING_VALUE*";
+const INPUT_JSON: &str = include_str!("../../vendor/browserforge-1.2.4/input-network.json");
+const HEADER_JSON: &str = include_str!("../../vendor/browserforge-1.2.4/header-network.json");
+
+const CHROME_ORDER: &[&str] = &[
+ "Host",
+ "Connection",
+ "Content-Length",
+ "Cache-Control",
+ "sec-ch-ua",
+ "sec-ch-ua-mobile",
+ "sec-ch-ua-platform",
+ "Origin",
+ "Content-Type",
+ "Upgrade-Insecure-Requests",
+ "User-Agent",
+ "Accept",
+ "Sec-Fetch-Site",
+ "Sec-Fetch-Mode",
+ "Sec-Fetch-User",
+ "Sec-Fetch-Dest",
+ "Referer",
+ "Accept-Encoding",
+ "Accept-Language",
+ "Cookie",
+ ":method",
+ ":authority",
+ ":scheme",
+ ":path",
+ "content-length",
+ "cache-control",
+ "sec-ch-ua",
+ "sec-ch-ua-mobile",
+ "sec-ch-ua-platform",
+ "origin",
+ "content-type",
+ "upgrade-insecure-requests",
+ "user-agent",
+ "accept",
+ "sec-fetch-site",
+ "sec-fetch-mode",
+ "sec-fetch-user",
+ "sec-fetch-dest",
+ "referer",
+ "accept-encoding",
+ "accept-language",
+ "cookie",
+ "priority",
+];
+
+const FIREFOX_ORDER: &[&str] = &[
+ "Host",
+ "User-Agent",
+ "Accept",
+ "Accept-Language",
+ "Accept-Encoding",
+ "Content-Type",
+ "Content-Length",
+ "Origin",
+ "Connection",
+ "Referer",
+ "Cookie",
+ "Upgrade-Insecure-Requests",
+ "Sec-Fetch-Dest",
+ "Sec-Fetch-Mode",
+ "Sec-Fetch-Site",
+ "Sec-Fetch-User",
+ "Priority",
+ ":method",
+ ":path",
+ ":authority",
+ ":scheme",
+ "user-agent",
+ "accept",
+ "accept-language",
+ "accept-encoding",
+ "content-type",
+ "content-length",
+ "origin",
+ "referer",
+ "cookie",
+ "upgrade-insecure-requests",
+ "sec-fetch-dest",
+ "sec-fetch-mode",
+ "sec-fetch-site",
+ "sec-fetch-user",
+ "priority",
+ "te",
+];
+
+#[derive(Deserialize)]
+struct Network {
+ nodes: Vec<Node>,
+}
+
+#[derive(Deserialize)]
+struct Node {
+ name: String,
+ #[serde(rename = "parentNames")]
+ parent_names: Vec<String>,
+ #[serde(rename = "possibleValues")]
+ possible_values: Vec<String>,
+ #[serde(rename = "conditionalProbabilities")]
+ probabilities: Value,
+}
+
+#[derive(Clone, Copy)]
+enum Profile {
+ Http,
+ Browser,
+}
+
+static INPUT: OnceLock<Result<Network, String>> = OnceLock::new();
+static HEADERS: OnceLock<Result<Network, String>> = OnceLock::new();
+static RNG: OnceLock<Mutex<PythonRandom>> = OnceLock::new();
+static HTTP_DEFAULT_UA: OnceLock<Result<String, String>> = OnceLock::new();
+static BROWSER_DEFAULTS: OnceLock<Result<(), String>> = OnceLock::new();
+
+fn network(
+ slot: &'static OnceLock<Result<Network, String>>,
+ source: &'static str,
+) -> Result<&'static Network, String> {
+ match slot.get_or_init(|| serde_json::from_str(source).map_err(|error| error.to_string())) {
+ Ok(network) => Ok(network),
+ Err(error) => Err(error.clone()),
+ }
+}
+
+fn input_network() -> Result<&'static Network, String> {
+ network(&INPUT, INPUT_JSON)
+}
+
+fn header_network() -> Result<&'static Network, String> {
+ network(&HEADERS, HEADER_JSON)
+}
+
+fn rng() -> &'static Mutex<PythonRandom> {
+ RNG.get_or_init(|| Mutex::new(PythonRandom::from_os()))
+}
+
+fn lock_rng() -> std::sync::MutexGuard<'static, PythonRandom> {
+ rng()
+ .lock()
+ .unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+pub fn default_user_agent() -> Result<String, String> {
+ HTTP_DEFAULT_UA
+ .get_or_init(|| {
+ generate(Profile::Http, &mut lock_rng())?
+ .into_iter()
+ .find(|(name, _)| name == "User-Agent")
+ .map(|(_, value)| value)
+ .ok_or_else(|| "BrowserForge produced no User-Agent".to_string())
+ })
+ .clone()
+}
+
+pub fn generate_http_headers() -> Result<Vec<(String, String)>, String> {
+ // Importing Scrapling's static engine initializes this cached value before
+ // it generates per-request headers. The otherwise-unused draw is visible
+ // when deterministic RNG fixtures make multiple requests.
+ default_user_agent()?;
+ generate(Profile::Http, &mut lock_rng())
+}
+
+pub fn initialize_browser_defaults() -> Result<(), String> {
+ BROWSER_DEFAULTS
+ .get_or_init(|| {
+ // `_config_tools.py` imports fingerprints (which initializes the
+ // HTTP default) and then generates Chromium and Chrome defaults.
+ default_user_agent()?;
+ let mut random = lock_rng();
+ generate(Profile::Browser, &mut random)?;
+ generate(Profile::Browser, &mut random)?;
+ Ok(())
+ })
+ .clone()
+}
+
+pub(crate) fn randint(first: u32, last: u32) -> u32 {
+ debug_assert!(first <= last);
+ first + lock_rng().randbelow(last - first + 1)
+}
+
+fn generate(profile: Profile, random: &mut PythonRandom) -> Result<Vec<(String, String)>, String> {
+ let input = input_network()?;
+ let mut constraints = HashMap::<String, Vec<String>>::new();
+ constraints.insert("*DEVICE".to_string(), vec!["desktop".to_string()]);
+ constraints.insert(
+ "*OPERATING_SYSTEM".to_string(),
+ match profile {
+ Profile::Http => vec!["windows", "macos", "linux"],
+ Profile::Browser => vec!["linux"],
+ }
+ .into_iter()
+ .map(str::to_string)
+ .collect(),
+ );
+ let browser_values = &input
+ .nodes
+ .iter()
+ .find(|node| node.name == "*BROWSER_HTTP")
+ .ok_or("BrowserForge input network has no *BROWSER_HTTP node")?
+ .possible_values;
+ let browser_http = match profile {
+ Profile::Browser => browser_values
+ .iter()
+ .filter(|value| browser_allowed(value, profile, "chrome"))
+ .cloned()
+ .collect(),
+ Profile::Http => ["chrome", "firefox", "edge"]
+ .into_iter()
+ .flat_map(|name| {
+ browser_values
+ .iter()
+ .filter(move |value| browser_allowed(value, profile, name))
+ .cloned()
+ })
+ .collect(),
+ };
+ constraints.insert("*BROWSER_HTTP".to_string(), browser_http);
+
+ let mut sample = Map::new();
+ if !consistent_sample(input, &constraints, &mut sample, 0, random) {
+ return Err("No headers based on this input can be generated. Please relax or change some of the requirements you specified.".to_string());
+ }
+ generate_unrestricted(header_network()?, &mut sample, random)?;
+
+ let browser_http = sample
+ .get("*BROWSER_HTTP")
+ .and_then(Value::as_str)
+ .ok_or("BrowserForge sample has no *BROWSER_HTTP")?;
+ let add_sec_fetch = browser_http
+ .split_once('|')
+ .and_then(|(browser, _)| browser.split_once('/').map(|(name, _)| name))
+ .map(|name| matches!(name, "chrome" | "firefox" | "edge"))
+ .ok_or("BrowserForge produced an invalid *BROWSER_HTTP")?;
+ sample.insert(
+ "accept-language".to_string(),
+ Value::String("en-US;q=1.0".to_string()),
+ );
+ if add_sec_fetch {
+ for (name, value) in [
+ ("sec-fetch-mode", "same-site"),
+ ("sec-fetch-dest", "navigate"),
+ ("sec-fetch-site", "?1"),
+ ("sec-fetch-user", "document"),
+ ] {
+ sample.insert(name.to_string(), Value::String(value.to_string()));
+ }
+ }
+
+ let visible = sample
+ .into_iter()
+ .filter_map(|(name, value)| {
+ let value = value.as_str()?.to_string();
+ (!(name.eq_ignore_ascii_case("connection") && value == "close")
+ && !name.starts_with('*')
+ && value != MISSING)
+ .then_some((name, value))
+ })
+ .collect::<HashMap<_, _>>();
+ let user_agent = visible
+ .get("User-Agent")
+ .or_else(|| visible.get("user-agent"))
+ .map(String::as_str)
+ .ok_or("Failed to find User-Agent in generated response")?;
+ // BrowserForge checks Chrome before Edge. Their order tables are equal for
+ // the fields this frozen dataset emits, so preserve that quirk directly.
+ let order = if user_agent.contains("Firefox") || user_agent.contains("FxiOS") {
+ FIREFOX_ORDER
+ } else if user_agent.contains("Chrome") || user_agent.contains("CriOS") {
+ CHROME_ORDER
+ } else {
+ return Err("Failed to find browser in User-Agent".to_string());
+ };
+ let mut seen = HashSet::new();
+ Ok(order
+ .iter()
+ .filter(|name| seen.insert(**name))
+ .filter_map(|name| {
+ visible
+ .get(*name)
+ .map(|value| (pascalize(name), value.clone()))
+ })
+ .collect())
+}
+
+fn browser_allowed(value: &str, profile: Profile, wanted: &str) -> bool {
+ let Some((browser, http)) = value.split_once('|') else {
+ return false;
+ };
+ if http != "2" {
+ return false;
+ }
+ let Some((name, version)) = browser.split_once('/') else {
+ return false;
+ };
+ let major = version
+ .split('.')
+ .next()
+ .and_then(|value| value.parse::<u32>().ok());
+ if name != wanted {
+ return false;
+ }
+ match (profile, name, major) {
+ (Profile::Browser, "chrome", Some(148)) => true,
+ (Profile::Http, "chrome", Some(148)) => true,
+ (Profile::Http, "firefox", Some(version)) => version >= 142,
+ (Profile::Http, "edge", Some(version)) => version >= 140,
+ _ => false,
+ }
+}
+
+fn consistent_sample(
+ network: &Network,
+ constraints: &HashMap<String, Vec<String>>,
+ sample: &mut Map<String, Value>,
+ depth: usize,
+ random: &mut PythonRandom,
+) -> bool {
+ if depth == network.nodes.len() {
+ return true;
+ }
+ let node = &network.nodes[depth];
+ let possibilities = constraints
+ .get(&node.name)
+ .map(Vec::as_slice)
+ .unwrap_or(&node.possible_values);
+ let mut banned = HashSet::new();
+ loop {
+ let Some(value) = sample_restricted(node, sample, possibilities, &banned, random) else {
+ return false;
+ };
+ sample.insert(node.name.clone(), Value::String(value.clone()));
+ if consistent_sample(network, constraints, sample, depth + 1, random) {
+ return true;
+ }
+ banned.insert(value);
+ sample.shift_remove(&node.name);
+ }
+}
+
+fn generate_unrestricted(
+ network: &Network,
+ sample: &mut Map<String, Value>,
+ random: &mut PythonRandom,
+) -> Result<(), String> {
+ for node in &network.nodes {
+ if sample.contains_key(&node.name) {
+ continue;
+ }
+ let probabilities = probability_table(node, sample)
+ .ok_or_else(|| format!("BrowserForge has no probabilities for {}", node.name))?;
+ let choices = probabilities.keys().map(String::as_str).collect::<Vec<_>>();
+ let value = sample_value(&choices, probabilities, random)
+ .ok_or_else(|| format!("BrowserForge has no value for {}", node.name))?;
+ sample.insert(node.name.clone(), Value::String(value));
+ }
+ Ok(())
+}
+
+fn sample_restricted(
+ node: &Node,
+ sample: &Map<String, Value>,
+ possibilities: &[String],
+ banned: &HashSet<String>,
+ random: &mut PythonRandom,
+) -> Option<String> {
+ let probabilities = probability_table(node, sample)?;
+ let choices = possibilities
+ .iter()
+ .map(String::as_str)
+ .filter(|value| !banned.contains(*value) && probabilities.contains_key(*value))
+ .collect::<Vec<_>>();
+ sample_value(&choices, probabilities, random)
+}
+
+fn probability_table<'a>(
+ node: &'a Node,
+ sample: &Map<String, Value>,
+) -> Option<&'a Map<String, Value>> {
+ let mut current = &node.probabilities;
+ for parent in &node.parent_names {
+ let table = current.as_object()?;
+ let parent = sample.get(parent)?.as_str()?;
+ current = table
+ .get("deeper")
+ .and_then(Value::as_object)
+ .and_then(|deeper| deeper.get(parent))
+ .or_else(|| table.get("skip"))?;
+ }
+ current.as_object()
+}
+
+fn sample_value(
+ choices: &[&str],
+ probabilities: &Map<String, Value>,
+ random: &mut PythonRandom,
+) -> Option<String> {
+ let first = choices.first()?;
+ let anchor = random.random();
+ let mut cumulative = 0.0;
+ for choice in choices {
+ cumulative += probabilities.get(*choice)?.as_f64()?;
+ if cumulative > anchor {
+ return Some((*choice).to_string());
+ }
+ }
+ Some((*first).to_string())
+}
+
+fn pascalize(name: &str) -> String {
+ if name.starts_with(':') || name.starts_with("sec-ch-ua") {
+ return name.to_string();
+ }
+ if matches!(name, "dnt" | "rtt" | "ect") {
+ return name.to_ascii_uppercase();
+ }
+ name.split('-')
+ .map(|part| {
+ let mut chars = part.chars();
+ chars
+ .next()
+ .map(|first| {
+ first
+ .to_uppercase()
+ .chain(chars.flat_map(char::to_lowercase))
+ .collect::<String>()
+ })
+ .unwrap_or_default()
+ })
+ .collect::<Vec<_>>()
+ .join("-")
+}
+
+struct PythonRandom {
+ state: [u32; 624],
+ index: usize,
+}
+
+impl PythonRandom {
+ fn from_os() -> Self {
+ let mut bytes = [0u8; 624 * 4];
+ if std::fs::File::open("/dev/urandom")
+ .and_then(|mut file| file.read_exact(&mut bytes))
+ .is_ok()
+ {
+ let mut key = [0u32; 624];
+ for (word, bytes) in key.iter_mut().zip(bytes.chunks_exact(4)) {
+ *word = u32::from_ne_bytes(bytes.try_into().expect("four-byte chunk"));
+ }
+ return Self::from_key(&key);
+ }
+ let fallback = std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .unwrap_or_default()
+ .as_nanos() as u32;
+ Self::from_key(&[fallback, std::process::id()])
+ }
+
+ #[cfg(test)]
+ fn seeded(seed: u32) -> Self {
+ Self::from_key(&[seed])
+ }
+
+ fn from_key(key: &[u32]) -> Self {
+ let mut random = Self {
+ state: [0; 624],
+ index: 624,
+ };
+ random.init_genrand(19_650_218);
+ let mut i = 1usize;
+ let mut j = 0usize;
+ for _ in 0..624.max(key.len()) {
+ let previous = random.state[i - 1];
+ random.state[i] = (random.state[i]
+ ^ (previous ^ (previous >> 30)).wrapping_mul(1_664_525))
+ .wrapping_add(key[j])
+ .wrapping_add(j as u32);
+ i += 1;
+ j += 1;
+ if i >= 624 {
+ random.state[0] = random.state[623];
+ i = 1;
+ }
+ if j >= key.len() {
+ j = 0;
+ }
+ }
+ for _ in 0..623 {
+ let previous = random.state[i - 1];
+ random.state[i] = (random.state[i]
+ ^ (previous ^ (previous >> 30)).wrapping_mul(1_566_083_941))
+ .wrapping_sub(i as u32);
+ i += 1;
+ if i >= 624 {
+ random.state[0] = random.state[623];
+ i = 1;
+ }
+ }
+ random.state[0] = 0x8000_0000;
+ random.index = 624;
+ random
+ }
+
+ fn init_genrand(&mut self, seed: u32) {
+ self.state[0] = seed;
+ for index in 1..624 {
+ let previous = self.state[index - 1];
+ self.state[index] = 1_812_433_253u32
+ .wrapping_mul(previous ^ (previous >> 30))
+ .wrapping_add(index as u32);
+ }
+ }
+
+ fn word(&mut self) -> u32 {
+ if self.index >= 624 {
+ for index in 0..624 {
+ let y = (self.state[index] & 0x8000_0000)
+ | (self.state[(index + 1) % 624] & 0x7fff_ffff);
+ self.state[index] = self.state[(index + 397) % 624]
+ ^ (y >> 1)
+ ^ if y & 1 == 0 { 0 } else { 0x9908_b0df };
+ }
+ self.index = 0;
+ }
+ let mut value = self.state[self.index];
+ self.index += 1;
+ value ^= value >> 11;
+ value ^= (value << 7) & 0x9d2c_5680;
+ value ^= (value << 15) & 0xefc6_0000;
+ value ^= value >> 18;
+ value
+ }
+
+ fn random(&mut self) -> f64 {
+ let high = (self.word() >> 5) as u64;
+ let low = (self.word() >> 6) as u64;
+ ((high << 26) | low) as f64 / 9_007_199_254_740_992.0
+ }
+
+ fn getrandbits(&mut self, bits: u32) -> u32 {
+ debug_assert!((1..=32).contains(&bits));
+ self.word() >> (32 - bits)
+ }
+
+ fn randbelow(&mut self, upper: u32) -> u32 {
+ debug_assert!(upper > 0);
+ let bits = 32 - upper.leading_zeros();
+ loop {
+ let value = self.getrandbits(bits);
+ if value < upper {
+ return value;
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn cpython_seed_zero_and_frozen_header_sample_match() {
+ let mut random = PythonRandom::seeded(0);
+ assert_eq!(random.random(), 0.8444218515250481);
+ let headers = generate(Profile::Http, &mut PythonRandom::seeded(0)).unwrap();
+ assert_eq!(
+ headers,
+ vec![
+ ("sec-ch-ua".into(), "\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"".into()),
+ ("sec-ch-ua-mobile".into(), "?0".into()),
+ ("sec-ch-ua-platform".into(), "\"macOS\"".into()),
+ ("Upgrade-Insecure-Requests".into(), "1".into()),
+ ("User-Agent".into(), "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36".into()),
+ ("Accept".into(), "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7".into()),
+ ("Sec-Fetch-Site".into(), "?1".into()),
+ ("Sec-Fetch-Mode".into(), "same-site".into()),
+ ("Sec-Fetch-User".into(), "document".into()),
+ ("Sec-Fetch-Dest".into(), "navigate".into()),
+ ("Accept-Encoding".into(), "gzip, deflate, br, zstd".into()),
+ ("Accept-Language".into(), "en-US;q=1.0".into()),
+ ]
+ );
+ }
+
+ #[test]
+ fn cpython_randint_click_sequence_matches() {
+ let mut random = PythonRandom::seeded(0);
+ assert_eq!(26 + random.randbelow(3), 27);
+ assert_eq!(25 + random.randbelow(3), 26);
+ assert_eq!(100 + random.randbelow(101), 105);
+ }
+
+ #[test]
+ fn browser_profile_matches_frozen_linux_chromium() {
+ let headers = generate(Profile::Browser, &mut PythonRandom::seeded(0)).unwrap();
+ assert_eq!(
+ headers
+ .iter()
+ .find(|(name, _)| name == "User-Agent")
+ .map(|(_, value)| value.as_str()),
+ Some("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36")
+ );
+ }
+
+ #[test]
+ fn ten_thousand_seed_header_corpus_matches_browserforge() {
+ let mut hash = 14_695_981_039_346_656_037u64;
+ for seed in 0..10_000 {
+ for (name, value) in generate(Profile::Http, &mut PythonRandom::seeded(seed)).unwrap() {
+ for byte in name.bytes().chain([0]).chain(value.bytes()).chain([255]) {
+ hash = (hash ^ u64::from(byte)).wrapping_mul(1_099_511_628_211);
+ }
+ }
+ }
+ assert_eq!(hash, 0xa96f_eabb_879e_a69c);
+ }
+}
diff --git a/browser/src/scrapling/cdp.rs b/browser/src/scrapling/cdp.rs
new file mode 100644
index 000000000..76ea832b1
--- /dev/null
+++ b/browser/src/scrapling/cdp.rs
@@ -0,0 +1,842 @@
+//! Private raw Chrome DevTools Protocol connection foundation.
+//!
+//! Chromium's `--remote-debugging-pipe` protocol is UTF-8 JSON terminated by
+//! a NUL byte. The browser reads commands from descriptor 3 and writes events
+//! and responses to descriptor 4. Launch code owns creating/inheriting those
+//! descriptors; this module owns framing, routing, cancellation and teardown.
+
+use std::collections::HashMap;
+use std::fmt;
+use std::future::Future;
+use std::io::{Read, Write};
+use std::pin::Pin;
+use std::process::{Child, Command, ExitStatus};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, MutexGuard, Weak};
+use std::task::{Context, Poll};
+use std::thread::{self, JoinHandle};
+
+use futures::{SinkExt, StreamExt};
+use serde_json::{Map, Value};
+use tokio::sync::{broadcast, mpsc, oneshot, watch};
+use tokio_tungstenite::tungstenite::Message;
+
+pub const REMOTE_DEBUGGING_PIPE_ARG: &str = "--remote-debugging-pipe";
+pub const MAX_CDP_MESSAGE_BYTES: usize = 64 * 1024 * 1024;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum CdpError {
+ Closed,
+ Transport(String),
+ InvalidMessage(String),
+ Protocol {
+ code: i64,
+ message: String,
+ data: Option<Value>,
+ },
+ UnsupportedTransport(String),
+}
+
+impl fmt::Display for CdpError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Closed => f.write_str("CDP connection is closed"),
+ Self::Transport(message) | Self::InvalidMessage(message) => f.write_str(message),
+ Self::Protocol { code, message, .. } => write!(f, "CDP error {code}: {message}"),
+ Self::UnsupportedTransport(message) => f.write_str(message),
+ }
+ }
+}
+
+impl std::error::Error for CdpError {}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct CdpEvent {
+ pub session_id: Option<String>,
+ pub method: String,
+ pub params: Value,
+}
+
+#[derive(Debug)]
+pub enum EventError {
+ Closed,
+}
+
+impl fmt::Display for EventError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Closed => f.write_str("CDP event stream is closed"),
+ }
+ }
+}
+
+impl std::error::Error for EventError {}
+
+pub struct EventReceiver {
+ receiver: broadcast::Receiver<CdpEvent>,
+ disconnected: watch::Receiver<bool>,
+ session_id: Option<String>,
+ /// Deliver events from EVERY session, not just `session_id`. Needed by
+ /// the child-target router: auto-attached OOPIF/worker targets announce
+ /// themselves tagged with their PARENT page's sessionId, which a
+ /// root-scoped receiver would filter out.
+ any_session: bool,
+}
+
+impl EventReceiver {
+ pub async fn recv(&mut self) -> Result<CdpEvent, EventError> {
+ loop {
+ if *self.disconnected.borrow() {
+ return Err(EventError::Closed);
+ }
+ tokio::select! {
+ changed = self.disconnected.changed() => {
+ if changed.is_err() || *self.disconnected.borrow() {
+ return Err(EventError::Closed);
+ }
+ }
+ event = self.receiver.recv() => match event {
+ Ok(event) if self.any_session || event.session_id == self.session_id => {
+ return Ok(event);
+ }
+ Ok(_) => {}
+ Err(broadcast::error::RecvError::Closed) => return Err(EventError::Closed),
+ // Lagged is recoverable: the receiver skipped old events
+ // and can keep going. Surfacing it as an error made every
+ // consumer treat a busy page as a dead connection (the
+ // child-target router died forever; waits hard-failed
+ // pages that loaded fine). A waiter that missed its event
+ // falls back to its own deadline instead.
+ Err(broadcast::error::RecvError::Lagged(_)) => {}
+ }
+ }
+ }
+ }
+}
+
+struct Pending {
+ session_id: Option<String>,
+ sender: oneshot::Sender<Result<Value, CdpError>>,
+}
+
+enum WriterCommand {
+ Frame(Vec<u8>),
+ Shutdown,
+}
+
+#[derive(Default)]
+struct ProcessState {
+ child: Option<Child>,
+ status: Option<ExitStatus>,
+}
+
+struct Inner {
+ next_id: AtomicU64,
+ closed: AtomicBool,
+ pending: Mutex<HashMap<u64, Pending>>,
+ events: broadcast::Sender<CdpEvent>,
+ disconnected: watch::Sender<bool>,
+ writer_tx: mpsc::UnboundedSender<WriterCommand>,
+ writer_thread: Mutex<Option<JoinHandle<()>>>,
+ reader_thread: Mutex<Option<JoinHandle<()>>>,
+ websocket_task: Mutex<Option<tokio::task::JoinHandle<()>>>,
+ process: Mutex<ProcessState>,
+}
+
+impl Inner {
+ fn terminate(&self, reason: CdpError) {
+ if self.closed.swap(true, Ordering::AcqRel) {
+ return;
+ }
+ let callbacks = std::mem::take(&mut *lock(&self.pending));
+ for (_, pending) in callbacks {
+ let _ = pending.sender.send(Err(reason.clone()));
+ }
+ let _ = self.writer_tx.send(WriterCommand::Shutdown);
+ let _ = self.disconnected.send(true);
+ self.terminate_process();
+ }
+
+ fn terminate_process(&self) {
+ let mut process = lock(&self.process);
+ let Some(mut child) = process.child.take() else {
+ return;
+ };
+ let status = match child.try_wait() {
+ Ok(Some(status)) => Some(status),
+ Ok(None) => child.kill().and_then(|()| child.wait()).ok(),
+ Err(_) => child.kill().and_then(|()| child.wait()).ok(),
+ };
+ process.status = status;
+ }
+
+ fn route(&self, message: Value) -> Result<(), CdpError> {
+ let object = message
+ .as_object()
+ .ok_or_else(|| CdpError::InvalidMessage("CDP message is not an object".to_string()))?;
+ let session_id = object
+ .get("sessionId")
+ .and_then(Value::as_str)
+ .map(str::to_string);
+
+ if object.get("id").and_then(Value::as_i64) == Some(-9999) {
+ return Ok(());
+ }
+ if object.contains_key("id") {
+ let id = object.get("id").and_then(Value::as_u64).ok_or_else(|| {
+ CdpError::InvalidMessage("CDP response has an invalid id".to_string())
+ })?;
+ let mut pending = lock(&self.pending);
+ // Command ids are client-global, so the id alone identifies the
+ // command. Chrome emits some id-bearing ERROR frames untagged
+ // (e.g. "Session with given id not found") — dropping those on a
+ // sessionId mismatch orphans the await forever. Only a frame
+ // tagged with a DIFFERENT session is rejected.
+ let matches_session = pending
+ .get(&id)
+ .is_some_and(|callback| session_id.is_none() || callback.session_id == session_id);
+ if !matches_session {
+ return Ok(());
+ }
+ let callback = pending.remove(&id).expect("checked pending command");
+ let result = if let Some(error) = object.get("error").and_then(Value::as_object) {
+ Err(CdpError::Protocol {
+ code: error.get("code").and_then(Value::as_i64).unwrap_or(0),
+ message: error
+ .get("message")
+ .and_then(Value::as_str)
+ .unwrap_or("Unknown protocol error")
+ .to_string(),
+ data: error.get("data").cloned(),
+ })
+ } else {
+ Ok(object.get("result").cloned().unwrap_or(Value::Null))
+ };
+ let _ = callback.sender.send(result);
+ return Ok(());
+ }
+
+ let method = object
+ .get("method")
+ .and_then(Value::as_str)
+ .ok_or_else(|| CdpError::InvalidMessage("CDP event has no method".to_string()))?;
+ let _ = self.events.send(CdpEvent {
+ session_id,
+ method: method.to_string(),
+ params: object.get("params").cloned().unwrap_or(Value::Null),
+ });
+ Ok(())
+ }
+}
+
+impl Drop for Inner {
+ fn drop(&mut self) {
+ self.closed.store(true, Ordering::Release);
+ let _ = self.writer_tx.send(WriterCommand::Shutdown);
+ let _ = self.disconnected.send(true);
+ if let Some(task) = lock(&self.websocket_task).take() {
+ task.abort();
+ }
+ self.terminate_process();
+ }
+}
+
+#[derive(Clone)]
+pub struct CdpClient {
+ inner: Arc<Inner>,
+}
+
+impl fmt::Debug for CdpClient {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("CdpClient")
+ .field("closed", &self.is_closed())
+ .finish_non_exhaustive()
+ }
+}
+
+impl CdpClient {
+ pub fn from_pipe<R, W>(reader: R, writer: W, child: Option<Child>) -> Result<Self, CdpError>
+ where
+ R: Read + Send + 'static,
+ W: Write + Send + 'static,
+ {
+ let (inner, writer_rx) = new_inner(child);
+
+ let writer_inner = Arc::downgrade(&inner);
+ let writer_thread = thread::Builder::new()
+ .name("scrapling-cdp-writer".to_string())
+ .spawn(move || writer_loop(writer, writer_rx, writer_inner))
+ .map_err(|error| CdpError::Transport(error.to_string()))?;
+ *lock(&inner.writer_thread) = Some(writer_thread);
+
+ let reader_inner = Arc::downgrade(&inner);
+ let reader_thread = match thread::Builder::new()
+ .name("scrapling-cdp-reader".to_string())
+ .spawn(move || reader_loop(reader, reader_inner))
+ {
+ Ok(thread) => thread,
+ Err(error) => {
+ inner.terminate(CdpError::Transport(error.to_string()));
+ if let Some(thread) = lock(&inner.writer_thread).take() {
+ let _ = thread.join();
+ }
+ return Err(CdpError::Transport(error.to_string()));
+ }
+ };
+ *lock(&inner.reader_thread) = Some(reader_thread);
+ Ok(Self { inner })
+ }
+
+ #[cfg(unix)]
+ /// Spawn one Chrome process with CDP mapped to fd3/fd4.
+ ///
+ /// `CommandExt::pre_exec` has no removal API, so `command` is single-use
+ /// after this call, including when spawning fails.
+ pub fn launch_pipe(command: &mut Command) -> Result<Self, CdpError> {
+ use std::fs::File;
+ use std::os::fd::AsRawFd;
+ use std::os::unix::process::CommandExt;
+
+ let (child_commands, parent_commands) = pipe_cloexec()?;
+ let (parent_events, child_events) = pipe_cloexec()?;
+ let child_commands = dup_cloexec(child_commands.as_raw_fd())?;
+ let child_events = dup_cloexec(child_events.as_raw_fd())?;
+ let command_fd = child_commands.as_raw_fd();
+ let event_fd = child_events.as_raw_fd();
+
+ if !command
+ .get_args()
+ .any(|argument| argument == REMOTE_DEBUGGING_PIPE_ARG)
+ {
+ command.arg(REMOTE_DEBUGGING_PIPE_ARG);
+ }
+ // SAFETY: the closure calls only async-signal-safe libc functions and
+ // captures raw integers. Both sources are duplicated above fd 4, so
+ // mapping one cannot clobber the other.
+ unsafe {
+ command.pre_exec(move || {
+ if libc::dup2(command_fd, 3) == -1 || libc::dup2(event_fd, 4) == -1 {
+ return Err(std::io::Error::last_os_error());
+ }
+ Ok(())
+ });
+ }
+
+ let child = command
+ .spawn()
+ .map_err(|error| CdpError::Transport(format!("launching Chrome: {error}")))?;
+ drop(child_commands);
+ drop(child_events);
+ let reader = File::from(parent_events);
+ let writer = File::from(parent_commands);
+ Self::from_pipe(reader, writer, Some(child))
+ }
+
+ #[cfg(not(unix))]
+ pub fn launch_pipe(_command: &mut Command) -> Result<Self, CdpError> {
+ Err(CdpError::UnsupportedTransport(
+ "--remote-debugging-pipe launch is supported only on Unix".to_string(),
+ ))
+ }
+
+ pub async fn connect_websocket_url(url: &str) -> Result<Self, CdpError> {
+ let scheme = url.split(':').next().unwrap_or_default();
+ if !matches!(scheme, "ws" | "wss") {
+ return Err(CdpError::UnsupportedTransport(format!(
+ "cdp_url must use ws:// or wss://, got '{url}'"
+ )));
+ }
+ let (socket, _) = tokio_tungstenite::connect_async(url)
+ .await
+ .map_err(|error| CdpError::Transport(format!("connecting cdp_url '{url}': {error}")))?;
+ let (inner, writer_rx) = new_inner(None);
+ let task_inner = Arc::downgrade(&inner);
+ let task = tokio::spawn(websocket_loop(socket, writer_rx, task_inner));
+ *lock(&inner.websocket_task) = Some(task);
+ Ok(Self { inner })
+ }
+
+ pub fn session(&self, session_id: impl Into<String>) -> CdpSession {
+ CdpSession {
+ client: self.clone(),
+ session_id: session_id.into(),
+ }
+ }
+
+ pub fn send(&self, method: &str, params: Value) -> Result<CdpCommand, CdpError> {
+ self.send_to(None, method, params)
+ }
+
+ fn send_to(
+ &self,
+ session_id: Option<String>,
+ method: &str,
+ params: Value,
+ ) -> Result<CdpCommand, CdpError> {
+ if self.is_closed() {
+ return Err(CdpError::Closed);
+ }
+ if method.is_empty() {
+ return Err(CdpError::InvalidMessage(
+ "CDP method cannot be empty".to_string(),
+ ));
+ }
+ let id = self.inner.next_id.fetch_add(1, Ordering::Relaxed) + 1;
+ let mut message = Map::new();
+ message.insert("id".to_string(), Value::from(id));
+ message.insert("method".to_string(), Value::from(method));
+ message.insert("params".to_string(), params);
+ if let Some(value) = &session_id {
+ message.insert("sessionId".to_string(), Value::from(value.clone()));
+ }
+ let mut frame = serde_json::to_vec(&Value::Object(message))
+ .map_err(|error| CdpError::InvalidMessage(error.to_string()))?;
+ if frame.len() > MAX_CDP_MESSAGE_BYTES {
+ return Err(CdpError::InvalidMessage(format!(
+ "CDP message exceeds {MAX_CDP_MESSAGE_BYTES} bytes"
+ )));
+ }
+ frame.push(0);
+
+ let (sender, receiver) = oneshot::channel();
+ lock(&self.inner.pending).insert(id, Pending { session_id, sender });
+ if self
+ .inner
+ .writer_tx
+ .send(WriterCommand::Frame(frame))
+ .is_err()
+ {
+ lock(&self.inner.pending).remove(&id);
+ self.inner.terminate(CdpError::Closed);
+ return Err(CdpError::Closed);
+ }
+ // Close the TOCTOU with terminate(): it may have drained `pending`
+ // between the is_closed check above and the insert, leaving this
+ // entry to never complete. Re-check after the insert — whichever side
+ // runs second cleans up.
+ if self.is_closed() {
+ lock(&self.inner.pending).remove(&id);
+ return Err(CdpError::Closed);
+ }
+ Ok(CdpCommand {
+ id,
+ receiver,
+ inner: Arc::downgrade(&self.inner),
+ completed: false,
+ deadline: None,
+ })
+ }
+
+ pub fn subscribe(&self) -> EventReceiver {
+ EventReceiver {
+ receiver: self.inner.events.subscribe(),
+ disconnected: self.inner.disconnected.subscribe(),
+ session_id: None,
+ any_session: false,
+ }
+ }
+
+ /// Subscribe to events from every session (see `EventReceiver::any_session`).
+ pub fn subscribe_any(&self) -> EventReceiver {
+ EventReceiver {
+ receiver: self.inner.events.subscribe(),
+ disconnected: self.inner.disconnected.subscribe(),
+ session_id: None,
+ any_session: true,
+ }
+ }
+
+ pub fn is_closed(&self) -> bool {
+ self.inner.closed.load(Ordering::Acquire)
+ }
+
+ pub fn close(&self) -> Result<(), CdpError> {
+ self.inner.terminate(CdpError::Closed);
+ join_thread(&self.inner.writer_thread)?;
+ join_thread(&self.inner.reader_thread)?;
+ Ok(())
+ }
+
+ pub fn process_status(&self) -> Option<ExitStatus> {
+ lock(&self.inner.process).status
+ }
+
+ #[cfg(test)]
+ pub fn pending_count(&self) -> usize {
+ lock(&self.inner.pending).len()
+ }
+}
+
+#[derive(Clone, Debug)]
+pub struct CdpSession {
+ client: CdpClient,
+ session_id: String,
+}
+
+impl CdpSession {
+ pub fn id(&self) -> &str {
+ &self.session_id
+ }
+
+ pub fn send(&self, method: &str, params: Value) -> Result<CdpCommand, CdpError> {
+ self.client
+ .send_to(Some(self.session_id.clone()), method, params)
+ }
+
+ pub fn subscribe(&self) -> EventReceiver {
+ EventReceiver {
+ receiver: self.client.inner.events.subscribe(),
+ disconnected: self.client.inner.disconnected.subscribe(),
+ session_id: Some(self.session_id.clone()),
+ any_session: false,
+ }
+ }
+}
+
+/// Hard ceiling on any single CDP command round-trip. A blocked renderer
+/// main thread (`while(1){}` with the hang monitor disabled, a wedged
+/// browser process) simply never answers, and an unbounded await here is
+/// how one-shot fetches hang and session actors wedge forever. Generous on
+/// purpose: real commands answer in milliseconds and even a tarpit
+/// navigation is bounded by Chrome's own ~5-minute network timeout region.
+const COMMAND_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(180);
+
+pub struct CdpCommand {
+ id: u64,
+ receiver: oneshot::Receiver<Result<Value, CdpError>>,
+ inner: Weak<Inner>,
+ completed: bool,
+ deadline: Option<Pin<Box<tokio::time::Sleep>>>,
+}
+
+impl Future for CdpCommand {
+ type Output = Result<Value, CdpError>;
+
+ fn poll(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output> {
+ match Pin::new(&mut self.receiver).poll(context) {
+ Poll::Ready(Ok(result)) => {
+ self.completed = true;
+ Poll::Ready(result)
+ }
+ Poll::Ready(Err(_)) => {
+ self.completed = true;
+ Poll::Ready(Err(CdpError::Closed))
+ }
+ Poll::Pending => {
+ let deadline = self
+ .deadline
+ .get_or_insert_with(|| Box::pin(tokio::time::sleep(COMMAND_TIMEOUT)));
+ match deadline.as_mut().poll(context) {
+ Poll::Ready(()) => {
+ self.completed = true;
+ if let Some(inner) = self.inner.upgrade() {
+ lock(&inner.pending).remove(&self.id);
+ }
+ Poll::Ready(Err(CdpError::Transport(format!(
+ "CDP command timed out after {}s (renderer or browser unresponsive)",
+ COMMAND_TIMEOUT.as_secs()
+ ))))
+ }
+ Poll::Pending => Poll::Pending,
+ }
+ }
+ }
+ }
+}
+
+impl Drop for CdpCommand {
+ fn drop(&mut self) {
+ if self.completed {
+ return;
+ }
+ if let Some(inner) = self.inner.upgrade() {
+ lock(&inner.pending).remove(&self.id);
+ }
+ }
+}
+
+fn new_inner(child: Option<Child>) -> (Arc<Inner>, mpsc::UnboundedReceiver<WriterCommand>) {
+ let (writer_tx, writer_rx) = mpsc::unbounded_channel();
+ // Sized for bursty pages: every session's events share this channel, and
+ // an overflow only costs the laggard skipped events (recv treats Lagged
+ // as recoverable), but skipping is still worth avoiding.
+ let (events, _) = broadcast::channel(4096);
+ let (disconnected, _) = watch::channel(false);
+ let inner = Arc::new(Inner {
+ next_id: AtomicU64::new(0),
+ closed: AtomicBool::new(false),
+ pending: Mutex::new(HashMap::new()),
+ events,
+ disconnected,
+ writer_tx,
+ writer_thread: Mutex::new(None),
+ reader_thread: Mutex::new(None),
+ websocket_task: Mutex::new(None),
+ process: Mutex::new(ProcessState {
+ child,
+ status: None,
+ }),
+ });
+ (inner, writer_rx)
+}
+
+fn writer_loop<W: Write>(
+ mut writer: W,
+ mut commands: mpsc::UnboundedReceiver<WriterCommand>,
+ inner: Weak<Inner>,
+) {
+ while let Some(command) = commands.blocking_recv() {
+ match command {
+ WriterCommand::Frame(frame) => {
+ if let Err(error) = writer.write_all(&frame).and_then(|()| writer.flush()) {
+ if let Some(inner) = inner.upgrade() {
+ inner.terminate(CdpError::Transport(format!("writing CDP pipe: {error}")));
+ }
+ break;
+ }
+ }
+ WriterCommand::Shutdown => break,
+ }
+ }
+}
+
+async fn websocket_loop<S>(
+ socket: tokio_tungstenite::WebSocketStream<S>,
+ mut commands: mpsc::UnboundedReceiver<WriterCommand>,
+ inner: Weak<Inner>,
+) where
+ S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
+{
+ let (mut writer, mut reader) = socket.split();
+ loop {
+ tokio::select! {
+ command = commands.recv() => match command {
+ Some(WriterCommand::Frame(mut frame)) => {
+ if frame.last() == Some(&0) {
+ frame.pop();
+ }
+ let text = match String::from_utf8(frame) {
+ Ok(text) => text,
+ Err(error) => {
+ terminate_weak(&inner, CdpError::InvalidMessage(error.to_string()));
+ break;
+ }
+ };
+ if let Err(error) = writer.send(Message::Text(text.into())).await {
+ terminate_weak(&inner, CdpError::Transport(format!("writing cdp_url: {error}")));
+ break;
+ }
+ }
+ Some(WriterCommand::Shutdown) | None => {
+ let _ = writer.send(Message::Close(None)).await;
+ let _ = writer.close().await;
+ break;
+ }
+ },
+ incoming = reader.next() => match incoming {
+ Some(Ok(Message::Text(text))) => {
+ if !route_websocket_message(&inner, text.as_bytes()) {
+ break;
+ }
+ }
+ Some(Ok(Message::Binary(bytes))) => {
+ if !route_websocket_message(&inner, &bytes) {
+ break;
+ }
+ }
+ Some(Ok(Message::Ping(bytes))) => {
+ if let Err(error) = writer.send(Message::Pong(bytes)).await {
+ terminate_weak(&inner, CdpError::Transport(format!("writing cdp_url pong: {error}")));
+ break;
+ }
+ }
+ Some(Ok(Message::Pong(_))) => {}
+ Some(Ok(Message::Close(_))) | None => {
+ terminate_weak(&inner, CdpError::Closed);
+ break;
+ }
+ Some(Ok(Message::Frame(_))) => {}
+ Some(Err(error)) => {
+ terminate_weak(&inner, CdpError::Transport(format!("reading cdp_url: {error}")));
+ break;
+ }
+ }
+ }
+ }
+}
+
+fn route_websocket_message(inner: &Weak<Inner>, bytes: &[u8]) -> bool {
+ let message = match serde_json::from_slice(bytes) {
+ Ok(message) => message,
+ Err(error) => {
+ terminate_weak(
+ inner,
+ CdpError::InvalidMessage(format!("invalid CDP JSON: {error}")),
+ );
+ return false;
+ }
+ };
+ let Some(inner) = inner.upgrade() else {
+ return false;
+ };
+ match inner.route(message) {
+ Ok(()) => true,
+ Err(error) => {
+ inner.terminate(error);
+ false
+ }
+ }
+}
+
+fn terminate_weak(inner: &Weak<Inner>, error: CdpError) {
+ if let Some(inner) = inner.upgrade() {
+ inner.terminate(error);
+ }
+}
+
+fn reader_loop<R: Read>(reader: R, inner: Weak<Inner>) {
+ let mut frames = NulFrames::new(reader);
+ loop {
+ let result = match frames.next() {
+ Ok(Some(frame)) => serde_json::from_slice(&frame)
+ .map_err(|error| CdpError::InvalidMessage(format!("invalid CDP JSON: {error}"))),
+ Ok(None) => {
+ if let Some(inner) = inner.upgrade() {
+ inner.terminate(CdpError::Closed);
+ }
+ return;
+ }
+ Err(error) => Err(error),
+ };
+ let Some(inner) = inner.upgrade() else {
+ return;
+ };
+ match result.and_then(|message| inner.route(message)) {
+ Ok(()) => {}
+ Err(error) => {
+ inner.terminate(error);
+ return;
+ }
+ }
+ }
+}
+
+struct NulFrames<R> {
+ reader: R,
+ pending: Vec<u8>,
+}
+
+impl<R: Read> NulFrames<R> {
+ fn new(reader: R) -> Self {
+ Self {
+ reader,
+ pending: Vec::new(),
+ }
+ }
+
+ fn next(&mut self) -> Result<Option<Vec<u8>>, CdpError> {
+ loop {
+ if let Some(end) = self.pending.iter().position(|byte| *byte == 0) {
+ if end > MAX_CDP_MESSAGE_BYTES {
+ return Err(CdpError::InvalidMessage(format!(
+ "CDP message exceeds {MAX_CDP_MESSAGE_BYTES} bytes"
+ )));
+ }
+ let mut remainder = self.pending.split_off(end + 1);
+ std::mem::swap(&mut remainder, &mut self.pending);
+ remainder.pop();
+ return Ok(Some(remainder));
+ }
+ if self.pending.len() > MAX_CDP_MESSAGE_BYTES {
+ return Err(CdpError::InvalidMessage(format!(
+ "CDP message exceeds {MAX_CDP_MESSAGE_BYTES} bytes"
+ )));
+ }
+ let mut buffer = [0; 8192];
+ match self.reader.read(&mut buffer) {
+ Ok(0) if self.pending.is_empty() => return Ok(None),
+ Ok(0) => {
+ return Err(CdpError::InvalidMessage(
+ "CDP pipe closed during a frame".to_string(),
+ ));
+ }
+ Ok(count) => self.pending.extend_from_slice(&buffer[..count]),
+ Err(error) if error.kind() == std::io::ErrorKind::Interrupted => {}
+ Err(error) => {
+ return Err(CdpError::Transport(format!("reading CDP pipe: {error}")));
+ }
+ }
+ }
+ }
+}
+
+fn join_thread(slot: &Mutex<Option<JoinHandle<()>>>) -> Result<(), CdpError> {
+ if let Some(thread) = lock(slot).take() {
+ thread
+ .join()
+ .map_err(|_| CdpError::Transport("CDP transport thread panicked".to_string()))?;
+ }
+ Ok(())
+}
+
+#[cfg(unix)]
+fn pipe_cloexec() -> Result<(std::os::fd::OwnedFd, std::os::fd::OwnedFd), CdpError> {
+ use std::os::fd::FromRawFd;
+
+ let mut descriptors = [-1; 2];
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ // SAFETY: `descriptors` points to space for exactly two file descriptors.
+ let result = unsafe { libc::pipe2(descriptors.as_mut_ptr(), libc::O_CLOEXEC) };
+ #[cfg(not(any(target_os = "linux", target_os = "android")))]
+ // SAFETY: `descriptors` points to space for exactly two file descriptors.
+ let result = unsafe { libc::pipe(descriptors.as_mut_ptr()) };
+ if result == -1 {
+ return Err(CdpError::Transport(format!(
+ "creating Chrome CDP pipe: {}",
+ std::io::Error::last_os_error()
+ )));
+ }
+ // SAFETY: successful `pipe2` returned two new, uniquely owned descriptors.
+ let pipes = unsafe {
+ (
+ std::os::fd::OwnedFd::from_raw_fd(descriptors[0]),
+ std::os::fd::OwnedFd::from_raw_fd(descriptors[1]),
+ )
+ };
+ #[cfg(not(any(target_os = "linux", target_os = "android")))]
+ for descriptor in [&pipes.0, &pipes.1] {
+ use std::os::fd::AsRawFd;
+
+ // SAFETY: the descriptor is owned and live for this call.
+ if unsafe { libc::fcntl(descriptor.as_raw_fd(), libc::F_SETFD, libc::FD_CLOEXEC) } == -1 {
+ return Err(CdpError::Transport(format!(
+ "setting close-on-exec on Chrome CDP pipe: {}",
+ std::io::Error::last_os_error()
+ )));
+ }
+ }
+ Ok(pipes)
+}
+
+#[cfg(unix)]
+fn dup_cloexec(descriptor: std::os::fd::RawFd) -> Result<std::os::fd::OwnedFd, CdpError> {
+ use std::os::fd::FromRawFd;
+
+ // Keep both pre-exec source descriptors above Chrome's fixed fd3/fd4.
+ // SAFETY: `descriptor` is live for this call and `fcntl` creates a new fd.
+ let duplicated = unsafe { libc::fcntl(descriptor, libc::F_DUPFD_CLOEXEC, 5) };
+ if duplicated == -1 {
+ return Err(CdpError::Transport(format!(
+ "duplicating Chrome CDP pipe: {}",
+ std::io::Error::last_os_error()
+ )));
+ }
+ // SAFETY: successful `fcntl(F_DUPFD_CLOEXEC)` returned a new owned fd.
+ Ok(unsafe { std::os::fd::OwnedFd::from_raw_fd(duplicated) })
+}
+
+fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
+ mutex
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+}
diff --git a/browser/src/scrapling/crawl.rs b/browser/src/scrapling/crawl.rs
new file mode 100644
index 000000000..25a908527
--- /dev/null
+++ b/browser/src/scrapling/crawl.rs
@@ -0,0 +1,896 @@
+//! `browser::crawl` — breadth-first crawl from one or more start
+//! URLs, extracting per page and streaming the results (crawl.py:73-190).
+//!
+//! The frontier walk is parameterised over the fetch step, so the whole
+//! algorithm — ordering, dedup, the depth and page caps, per-page error
+//! isolation — is testable against a canned link graph with no network and no
+//! browser. Only the closure passed in at registration does I/O.
+
+use std::collections::{HashSet, VecDeque};
+use std::time::Duration;
+
+use futures::stream::{FuturesUnordered, StreamExt};
+use futures::FutureExt;
+use serde_json::{json, Value};
+
+use crate::config::SecurityMode;
+use crate::scrapling::dom;
+use crate::scrapling::page::{serialize_page, PageData};
+
+/// The RPC response carries only a sample; the full set goes to the stream.
+const SAMPLE_MAX: usize = 10;
+/// Ceiling on the per-page politeness delay (see the note where it is read).
+const MAX_DOWNLOAD_DELAY_SECS: f64 = 300.0;
+
+#[derive(Debug)]
+pub struct CrawlOpts {
+ pub start_urls: Vec<String>,
+ pub fetcher: String,
+ pub allowed_domains: Vec<String>,
+ pub same_domain: bool,
+ pub max_pages: i64,
+ pub max_depth: i64,
+ pub concurrency: usize,
+ pub download_delay: Duration,
+ pub stream_name: Value,
+}
+
+impl CrawlOpts {
+ /// Defaults are crawl.py's, which are hardcoded there rather than
+ /// configurable: 20 pages, depth 2, same-domain on, no delay.
+ pub fn from_payload(payload: &Value, max_concurrency: usize) -> Result<Self, String> {
+ Self::from_payload_for_mode(payload, max_concurrency, SecurityMode::Safe)
+ }
+
+ pub fn from_payload_for_mode(
+ payload: &Value,
+ max_concurrency: usize,
+ mode: SecurityMode,
+ ) -> Result<Self, String> {
+ let mut start_urls = crawl_strings(payload.get("start_urls"), "decode")?;
+ if start_urls.is_empty() {
+ if let Some(value) = payload.get("url").filter(|value| json_truthy(value)) {
+ if let Some(url) = value.as_str() {
+ start_urls.push(url.to_string());
+ } else {
+ return Err(format!(
+ "'{}' object has no attribute 'decode'",
+ python_type(value)
+ ));
+ }
+ }
+ }
+ if start_urls.is_empty() {
+ return Err("provide `start_urls`".to_string());
+ }
+ let fetcher = match payload.get("fetcher") {
+ None => "http".to_string(),
+ Some(Value::String(value)) => value.clone(),
+ Some(value) => {
+ return Err(format!(
+ "unknown fetcher: {} (use http|stealthy|dynamic)",
+ python_repr(value)
+ ))
+ }
+ };
+ if !matches!(fetcher.as_str(), "http" | "stealthy" | "dynamic") {
+ return Err(format!(
+ "unknown fetcher: {fetcher} (use http|stealthy|dynamic)"
+ ));
+ }
+ let concurrency_ceiling = max_concurrency.max(1).min(i64::MAX as usize) as i64;
+ Ok(Self {
+ start_urls,
+ fetcher,
+ allowed_domains: crawl_strings(payload.get("allowed_domains"), "lower")?
+ .into_iter()
+ // Normalize to the same punycode form host_of/normalize_link
+ // produce, so an IDN allow-entry matches IDN candidate hosts.
+ .map(|value| ascii_host(&value))
+ .collect(),
+ same_domain: payload.get("same_domain").is_none_or(json_truthy),
+ max_pages: python_int(payload, "max_pages", 20)?,
+ max_depth: python_int(payload, "max_depth", 2)?,
+ // The caller may ask for less, never for more than the server cap.
+ concurrency: python_int(payload, "concurrency", concurrency_ceiling)?
+ .clamp(1, concurrency_ceiling) as usize,
+ // Clamped for the same reason the fetch timeouts are:
+ // `from_secs_f64` panics on an unrepresentable value, and a panic
+ // in a detached handler drops the invocation and hangs the caller.
+ download_delay: crawl_delay(payload.get("download_delay"), mode)?,
+ stream_name: payload
+ .get("stream_name")
+ .filter(|value| json_truthy(value))
+ .cloned()
+ .unwrap_or_else(|| json!("browser::crawl")),
+ })
+ }
+}
+
+fn python_type(value: &Value) -> &'static str {
+ match value {
+ Value::Null => "NoneType",
+ Value::Bool(_) => "bool",
+ Value::Number(value) if value.is_f64() => "float",
+ Value::Number(_) => "int",
+ Value::String(_) => "str",
+ Value::Array(_) => "list",
+ Value::Object(_) => "dict",
+ }
+}
+
+pub(crate) fn python_repr(value: &Value) -> String {
+ match value {
+ Value::Null => "None".into(),
+ Value::Bool(true) => "True".into(),
+ Value::Bool(false) => "False".into(),
+ Value::String(value) => format!("'{value}'"),
+ Value::Number(value) => value.to_string(),
+ Value::Array(values) => format!(
+ "[{}]",
+ values
+ .iter()
+ .map(python_repr)
+ .collect::<Vec<_>>()
+ .join(", ")
+ ),
+ Value::Object(values) => format!(
+ "{{{}}}",
+ values
+ .iter()
+ .map(|(key, value)| format!("'{key}': {}", python_repr(value)))
+ .collect::<Vec<_>>()
+ .join(", ")
+ ),
+ }
+}
+
+fn crawl_strings(value: Option<&Value>, method: &str) -> Result<Vec<String>, String> {
+ let Some(value) = value.filter(|value| json_truthy(value)) else {
+ return Ok(Vec::new());
+ };
+ let values = match value {
+ Value::String(value) => return Ok(value.chars().map(String::from).collect()),
+ Value::Array(values) => values
+ .iter()
+ .map(|value| {
+ value.as_str().map(str::to_string).ok_or_else(|| {
+ format!(
+ "'{}' object has no attribute '{method}'",
+ python_type(value)
+ )
+ })
+ })
+ .collect(),
+ Value::Object(values) => Ok(values.keys().cloned().collect()),
+ _ => Err(format!("'{}' object is not iterable", python_type(value))),
+ }?;
+ Ok(values)
+}
+
+fn python_int(payload: &Value, key: &str, default: i64) -> Result<i64, String> {
+ match payload.get(key) {
+ None | Some(Value::Null) => Ok(default),
+ Some(Value::Bool(value)) => Ok(i64::from(*value)),
+ Some(Value::Number(value)) => Ok(value
+ .as_i64()
+ .or_else(|| {
+ value
+ .as_u64()
+ .map(|value| value.min(i64::MAX as u64) as i64)
+ })
+ .or_else(|| value.as_f64().map(|value| value as i64))
+ .unwrap_or(default)),
+ Some(Value::String(value)) => value
+ .trim()
+ .parse()
+ .map_err(|_| format!("invalid literal for int() with base 10: '{}'", value)),
+ Some(value) => Err(format!(
+ "int() argument must be a string, a bytes-like object or a real number, not '{}'",
+ python_type(value)
+ )),
+ }
+}
+
+fn crawl_delay(value: Option<&Value>, mode: SecurityMode) -> Result<Duration, String> {
+ let value = match value {
+ None | Some(Value::Null | Value::Bool(false)) => 0.0,
+ Some(Value::Bool(true)) => 1.0,
+ Some(Value::Number(value)) => value.as_f64().unwrap_or_default(),
+ Some(Value::String(value)) if value.is_empty() => 0.0,
+ Some(Value::String(value)) => value
+ .trim()
+ .parse::<f64>()
+ .map_err(|_| format!("could not convert string to float: '{value}'"))?,
+ Some(Value::Array(value)) if value.is_empty() => 0.0,
+ Some(Value::Object(value)) if value.is_empty() => 0.0,
+ Some(Value::Array(_)) => {
+ return Err("float() argument must be a string or a real number, not 'list'".into())
+ }
+ Some(Value::Object(_)) => {
+ return Err("float() argument must be a string or a real number, not 'dict'".into())
+ }
+ };
+ let value = if value <= 0.0 {
+ 0.0
+ } else if mode == SecurityMode::Safe {
+ value.min(MAX_DOWNLOAD_DELAY_SECS)
+ } else {
+ value
+ };
+ Duration::try_from_secs_f64(value).map_err(|_| "timestamp too large to convert".to_string())
+}
+
+/// Host with a leading `www.` folded away, so `example.com` and
+/// `www.example.com` count as one site (crawl.py `_same_site`).
+fn fold_www(host: &str) -> &str {
+ host.strip_prefix("www.").unwrap_or(host)
+}
+
+/// Same site if either host is the other, or a subdomain of it, after folding
+/// `www.` — the relationship holds in both directions, as in the reference.
+pub fn same_site(a: &str, b: &str) -> bool {
+ let (a, b) = (fold_www(a), fold_www(b));
+ a == b || a.ends_with(&format!(".{b}")) || b.ends_with(&format!(".{a}"))
+}
+
+/// Normalize a bare domain to its lowercase ASCII/punycode form, matching
+/// what `host_of` yields for a full URL. Falls back to the lowercased input
+/// for anything url can't parse as a host.
+fn ascii_host(domain: &str) -> String {
+ url::Url::parse(&format!("http://{domain}"))
+ .ok()
+ .and_then(|url| url.host_str().map(str::to_lowercase))
+ .unwrap_or_else(|| domain.to_lowercase())
+}
+
+pub fn host_of(raw: &str) -> Option<String> {
+ // Use url::Url's host, not a raw netloc scan: extracted links are
+ // re-serialized through url::Url (punycode), so an IDN seed scanned raw
+ // (`münchen.example`) would never match a candidate (`xn--mnchen-3ya…`)
+ // and the crawl would follow zero links. Normalizing both sides the same
+ // way keeps IDN crawls working. The non-default port is kept, matching
+ // urllib's netloc (so `e.com:8443` and `e.com:9443` stay distinct sites).
+ let url = url::Url::parse(raw).ok()?;
+ let host = url.host_str()?.to_lowercase();
+ Some(match url.port() {
+ Some(port) => format!("{host}:{port}"),
+ None => host,
+ })
+}
+
+/// Should we follow this link? (crawl.py `_domain_ok`)
+pub fn domain_ok(candidate: &str, opts: &CrawlOpts, seed_hosts: &[String]) -> bool {
+ let Some(host) = host_of(candidate) else {
+ return false;
+ };
+ if !opts.allowed_domains.is_empty() {
+ return opts
+ .allowed_domains
+ .iter()
+ .any(|d| host == *d || host.ends_with(&format!(".{d}")));
+ }
+ if opts.same_domain {
+ return seed_hosts.iter().any(|s| same_site(&host, s));
+ }
+ true
+}
+
+/// Absolutise against the page URL and drop the `#fragment`, so `p#a` and
+/// `p#b` collapse onto one already-seen URL (crawl.py uses `urldefrag`).
+pub fn normalize_link(base: &str, href: &str) -> Option<String> {
+ let base = url::Url::parse(base).ok()?;
+ let mut joined = base.join(href).ok()?;
+ joined.set_fragment(None);
+ if !matches!(joined.scheme(), "http" | "https") {
+ return None;
+ }
+ Some(joined.to_string())
+}
+
+/// Every `<a href>` on the page, absolutised and fragment-stripped.
+pub fn extract_links(html: &str, base: &str) -> Vec<String> {
+ let doc = dom::parse(html);
+ dom::descendant_elements(doc.root())
+ .into_iter()
+ .filter(|element| element.name() == "a")
+ .filter_map(|element| element.attr("href"))
+ .filter_map(|href| normalize_link(base, href))
+ .collect()
+}
+
+pub fn fetch_payload(payload: &Value, url: &str) -> Value {
+ const FETCH_KEYS: &[&str] = &[
+ "impersonate",
+ "proxy",
+ "headless",
+ "network_idle",
+ "solve_cloudflare",
+ "real_chrome",
+ "wait_selector",
+ "timeout",
+ "useragent",
+ ];
+ let mut request = serde_json::Map::new();
+ for key in FETCH_KEYS {
+ if let Some(value) = payload.get(*key) {
+ request.insert((*key).into(), value.clone());
+ }
+ }
+ request.insert("url".into(), json!(url));
+ if let Some(value) = payload.get("selectors").filter(|value| json_truthy(value)) {
+ request.insert("selectors".into(), value.clone());
+ }
+ if let Some(value) = payload.get("format").filter(|value| json_truthy(value)) {
+ request.insert("format".into(), value.clone());
+ for key in ["main_content_only", "css_selector"] {
+ if let Some(value) = payload.get(key).filter(|value| !value.is_null()) {
+ request.insert(key.into(), value.clone());
+ }
+ }
+ }
+ Value::Object(request)
+}
+
+pub struct CrawlOutcome {
+ /// A bounded SAMPLE for the RPC response — never the full set. Use
+ /// `item_count` for the real total; `items.len()` caps at `SAMPLE_MAX`.
+ pub items: Vec<Value>,
+ /// Pages that produced a result, matching crawl.py's `stats["items"]`.
+ pub item_count: usize,
+ pub crawled: usize,
+ pub errors: usize,
+ pub stopped: &'static str,
+}
+
+/// Walk the frontier. `fetch` does the I/O; `emit` receives every item (in
+/// completion order) for streaming. Neither is allowed to abort the crawl:
+/// a failing page becomes an `{url, error}` item, exactly as in the reference
+/// where `visit()` never raises.
+pub async fn run<F, Fut, E>(
+ opts: &CrawlOpts,
+ payload: &Value,
+ fetch: F,
+ mut emit: E,
+) -> CrawlOutcome
+where
+ F: Fn(String) -> Fut,
+ Fut: std::future::Future<Output = Result<PageData, String>>,
+ E: for<'a> FnMut(
+ &'a Value,
+ ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send + 'a>>,
+{
+ let seed_hosts: Vec<String> = opts.start_urls.iter().filter_map(|u| host_of(u)).collect();
+ let include_html = crate::scrapling::page::include_html(payload);
+
+ let mut frontier: VecDeque<(String, i64)> =
+ opts.start_urls.iter().map(|u| (u.clone(), 0)).collect();
+ let mut seen: HashSet<String> = opts.start_urls.iter().cloned().collect();
+ let mut items = Vec::new();
+ let (mut crawled, mut errors, mut started, mut item_count) = (0usize, 0usize, 0usize, 0usize);
+
+ let mut pending = FuturesUnordered::new();
+ loop {
+ while pending.len() < opts.concurrency && (started as i64) < opts.max_pages {
+ let Some((url, depth)) = frontier.pop_front() else {
+ break;
+ };
+ started += 1;
+ let fut = fetch(url.clone());
+ pending.push(async move { (url, depth, fut.await) });
+ }
+ let Some(first) = pending.next().await else {
+ break;
+ };
+
+ // `asyncio.wait(..., FIRST_COMPLETED)` returns every task that is
+ // already done, not just the one that woke the scheduler. Process that
+ // whole batch before refilling the pool or applying the delay.
+ let mut done = vec![first];
+ while let Some(Some(completed)) = pending.next().now_or_never() {
+ done.push(completed);
+ }
+ for (url, depth, result) in done {
+ let item = match result {
+ Ok(page) => match serialize_page(&page, payload, include_html) {
+ Ok(serialized) => {
+ if depth < opts.max_depth {
+ for link in extract_links(&page.html, &page.url) {
+ if seen.contains(&link) || !domain_ok(&link, opts, &seed_hosts) {
+ continue;
+ }
+ seen.insert(link.clone());
+ frontier.push_back((link, depth + 1));
+ }
+ }
+ reduce_page(&url, serialized, include_html)
+ }
+ Err(e) => {
+ errors += 1;
+ json!({"url": url, "error": e})
+ }
+ },
+ Err(e) => {
+ errors += 1;
+ json!({"url": url, "error": e})
+ }
+ };
+ crawled += 1;
+ if item.get("error").is_none() {
+ item_count += 1;
+ }
+ emit(&item).await;
+ if items.len() < SAMPLE_MAX {
+ items.push(item);
+ }
+ }
+ if !opts.download_delay.is_zero() {
+ tokio::time::sleep(opts.download_delay).await;
+ }
+ }
+
+ CrawlOutcome {
+ items,
+ item_count,
+ crawled,
+ errors,
+ // Anything left in the frontier means the page cap, not exhaustion,
+ // ended the crawl.
+ stopped: if frontier.is_empty() {
+ "done"
+ } else {
+ "max_pages"
+ },
+ }
+}
+
+fn reduce_page(url: &str, page: Value, include_html: bool) -> Value {
+ let mut item = serde_json::Map::new();
+ item.insert("url".into(), json!(url));
+ item.insert(
+ "status".into(),
+ page.get("status").cloned().unwrap_or(Value::Null),
+ );
+ if page.get("extracted").is_some_and(json_truthy) {
+ item.insert("extracted".into(), page["extracted"].clone());
+ }
+ if page.get("content").is_some_and(|value| !value.is_null()) {
+ item.insert("content".into(), page["content"].clone());
+ }
+ if include_html && page.get("html").is_some_and(|value| !value.is_null()) {
+ item.insert("html".into(), page["html"].clone());
+ }
+ Value::Object(item)
+}
+
+pub(crate) fn json_truthy(value: &Value) -> bool {
+ match value {
+ Value::Null => false,
+ Value::Bool(value) => *value,
+ Value::Number(value) => value.as_f64() != Some(0.0),
+ Value::String(value) => !value.is_empty(),
+ Value::Array(value) => !value.is_empty(),
+ Value::Object(value) => !value.is_empty(),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::cell::RefCell;
+
+ fn opts(payload: Value) -> CrawlOpts {
+ CrawlOpts::from_payload(&payload, 5).unwrap()
+ }
+
+ fn page(url: &str, html: &str) -> PageData {
+ PageData {
+ status: Some(200),
+ url: url.to_string(),
+ html: html.to_string(),
+ ..Default::default()
+ }
+ }
+
+ /// A canned site: url -> html. Anything not in the map is a fetch error.
+ async fn run_on(o: &CrawlOpts, site: &[(&str, &str)], payload: &Value) -> CrawlOutcome {
+ let order = RefCell::new(Vec::new());
+ let out = run(
+ o,
+ payload,
+ |url| {
+ order.borrow_mut().push(url.clone());
+ let found = site
+ .iter()
+ .find(|(u, _)| *u == url)
+ .map(|(u, h)| page(u, h));
+ async move { found.ok_or_else(|| "404 not found".to_string()) }
+ },
+ |_| Box::pin(async {}),
+ )
+ .await;
+ out
+ }
+
+ #[test]
+ fn same_site_folds_www_both_directions() {
+ assert!(same_site("example.com", "www.example.com"));
+ assert!(same_site("blog.example.com", "example.com"));
+ assert!(same_site("example.com", "blog.example.com"));
+ assert!(!same_site("example.com", "example.org"));
+ assert!(!same_site("notexample.com", "example.com"));
+ }
+
+ #[test]
+ fn links_are_absolutised_and_fragment_stripped() {
+ let links = extract_links(
+ r#"<a href="/a">1</a><a href="/a#x">2</a><a href="https://o.com/b">3</a>
+ <a href="mailto:x@y.z">4</a>"#,
+ "https://e.com/start",
+ );
+ assert_eq!(
+ links,
+ vec![
+ "https://e.com/a",
+ "https://e.com/a", // #x stripped -> same url, deduped by `seen`
+ "https://o.com/b",
+ ]
+ );
+ }
+
+ #[test]
+ fn allowed_domains_overrides_same_domain() {
+ let o = opts(json!({"url": "https://e.com/", "allowed_domains": ["o.com"]}));
+ let seeds = vec!["e.com".to_string()];
+ assert!(domain_ok("https://o.com/x", &o, &seeds));
+ assert!(domain_ok("https://sub.o.com/x", &o, &seeds));
+ assert!(!domain_ok("https://e.com/x", &o, &seeds));
+ }
+
+ #[tokio::test]
+ async fn breadth_first_order_and_fragment_dedup() {
+ let o = opts(json!({"url": "https://e.com/", "max_depth": 2, "concurrency": 1}));
+ let site = [
+ (
+ "https://e.com/",
+ r#"<a href="/a">a</a><a href="/b">b</a><a href="/a#dup">a</a>"#,
+ ),
+ ("https://e.com/a", r#"<a href="/c">c</a>"#),
+ ("https://e.com/b", ""),
+ ("https://e.com/c", ""),
+ ];
+ let out = run_on(&o, &site, &json!({})).await;
+ // seed, then depth 1 (a, b), then depth 2 (c) — and /a only once
+ assert_eq!(out.crawled, 4);
+ assert_eq!(out.errors, 0);
+ assert_eq!(out.stopped, "done");
+ }
+
+ #[tokio::test]
+ async fn max_depth_zero_visits_only_the_seeds() {
+ let o = opts(json!({"url": "https://e.com/", "max_depth": 0}));
+ let site = [
+ ("https://e.com/", r#"<a href="/a">a</a>"#),
+ ("https://e.com/a", ""),
+ ];
+ let out = run_on(&o, &site, &json!({})).await;
+ assert_eq!(out.crawled, 1);
+ assert_eq!(out.stopped, "done");
+ }
+
+ #[tokio::test]
+ async fn page_cap_stops_and_reports_max_pages() {
+ let o = opts(json!({"url": "https://e.com/", "max_pages": 2, "max_depth": 3}));
+ let site = [
+ ("https://e.com/", r#"<a href="/a">a</a><a href="/b">b</a>"#),
+ ("https://e.com/a", ""),
+ ("https://e.com/b", ""),
+ ];
+ let out = run_on(&o, &site, &json!({})).await;
+ assert_eq!(out.crawled, 2);
+ assert_eq!(out.stopped, "max_pages");
+ }
+
+ #[tokio::test]
+ async fn a_failing_page_never_sinks_the_crawl() {
+ let o = opts(json!({"url": "https://e.com/", "max_depth": 1}));
+ // /missing is not in the canned site -> fetch error
+ let site = [
+ (
+ "https://e.com/",
+ r#"<a href="/missing">x</a><a href="/ok">y</a>"#,
+ ),
+ ("https://e.com/ok", ""),
+ ];
+ let out = run_on(&o, &site, &json!({})).await;
+ assert_eq!(out.crawled, 3);
+ assert_eq!(out.errors, 1);
+ let err_item = out
+ .items
+ .iter()
+ .find(|i| i.get("error").is_some())
+ .expect("the failed page is still reported");
+ assert_eq!(err_item["url"], json!("https://e.com/missing"));
+ assert_eq!(err_item["error"], json!("404 not found"));
+ }
+
+ #[tokio::test]
+ async fn off_site_links_are_not_followed_by_default() {
+ let o = opts(json!({"url": "https://e.com/", "max_depth": 2}));
+ let site = [
+ ("https://e.com/", r#"<a href="https://other.com/x">x</a>"#),
+ ("https://other.com/x", ""),
+ ];
+ let out = run_on(&o, &site, &json!({})).await;
+ assert_eq!(out.crawled, 1, "off-site link must not be crawled");
+ }
+
+ #[tokio::test]
+ async fn response_items_are_sampled_but_every_item_is_emitted() {
+ let o = opts(json!({"url": "https://e.com/p0", "max_pages": 30, "max_depth": 1}));
+ // one seed linking to 20 pages
+ let links: String = (1..=20)
+ .map(|i| format!(r#"<a href="/p{i}">p</a>"#))
+ .collect();
+ let mut site: Vec<(String, String)> = vec![("https://e.com/p0".into(), links)];
+ for i in 1..=20 {
+ site.push((format!("https://e.com/p{i}"), String::new()));
+ }
+ let refs: Vec<(&str, &str)> = site.iter().map(|(u, h)| (u.as_str(), h.as_str())).collect();
+
+ let emitted = RefCell::new(0usize);
+ let out = run(
+ &o,
+ &json!({}),
+ |url| {
+ let found = refs
+ .iter()
+ .find(|(u, _)| *u == url)
+ .map(|(u, h)| page(u, h));
+ async move { found.ok_or_else(|| "missing".to_string()) }
+ },
+ |_| {
+ *emitted.borrow_mut() += 1;
+ Box::pin(async {})
+ },
+ )
+ .await;
+
+ assert_eq!(out.crawled, 21);
+ assert_eq!(*emitted.borrow(), 21, "every page is streamed");
+ assert_eq!(out.items.len(), SAMPLE_MAX, "the response only samples");
+ // The reported count is the real one, not the sample size — reporting
+ // items=10 for a 21-page crawl would silently cap forever.
+ assert_eq!(out.item_count, 21);
+ }
+
+ #[tokio::test]
+ async fn item_count_counts_successes_only_and_errors_count_separately() {
+ let o = opts(json!({"url": "https://e.com/", "max_depth": 1}));
+ let site = [
+ (
+ "https://e.com/",
+ r#"<a href="/gone">x</a><a href="/ok">y</a>"#,
+ ),
+ ("https://e.com/ok", ""),
+ ];
+ let out = run_on(&o, &site, &json!({})).await;
+ assert_eq!(out.crawled, 3, "every visit counts as crawled");
+ assert_eq!(out.errors, 1);
+ assert_eq!(out.item_count, 2, "the failed page is not an item");
+ }
+
+ #[test]
+ fn concurrency_is_clamped_to_the_server_cap() {
+ let o = CrawlOpts::from_payload(&json!({"url": "https://e.com/"}), 5).unwrap();
+ assert_eq!(
+ o.concurrency, 5,
+ "the oracle defaults to the configured ceiling"
+ );
+ let o = CrawlOpts::from_payload(&json!({"url": "https://e.com/", "concurrency": 99}), 5)
+ .unwrap();
+ assert_eq!(o.concurrency, 5);
+ let o = CrawlOpts::from_payload(&json!({"url": "https://e.com/", "concurrency": 0}), 5)
+ .unwrap();
+ assert_eq!(o.concurrency, 1);
+ }
+
+ #[test]
+ fn domain_keys_include_the_port_like_urllib_netloc() {
+ assert_eq!(
+ host_of("https://e.com:8443/a").as_deref(),
+ Some("e.com:8443")
+ );
+ assert!(!same_site("e.com:8443", "e.com:9443"));
+ }
+
+ #[tokio::test]
+ async fn negative_page_cap_starts_nothing() {
+ let o = opts(json!({"url": "https://e.com/", "max_pages": -1}));
+ let out = run_on(&o, &[("https://e.com/", "")], &json!({})).await;
+ assert_eq!(out.crawled, 0);
+ assert_eq!(out.stopped, "max_pages");
+ }
+
+ #[tokio::test]
+ async fn crawl_sample_has_the_reduced_wrapper_shape() {
+ let o = opts(json!({"url": "https://e.com/"}));
+ let out = run_on(
+ &o,
+ &[("https://e.com/", "<h1>Hi</h1>")],
+ &json!({"selectors": [{"name": "h", "css": "h1"}]}),
+ )
+ .await;
+ assert_eq!(
+ out.items,
+ vec![json!({
+ "url": "https://e.com/",
+ "status": 200,
+ "extracted": {"h": "Hi"},
+ })]
+ );
+ }
+
+ #[tokio::test]
+ async fn a_completion_batch_is_recorded_before_refilling_the_pool() {
+ let o = opts(json!({
+ "start_urls": ["https://e.com/1", "https://e.com/2", "https://e.com/3"],
+ "concurrency": 2,
+ "max_depth": 0,
+ }));
+ let events = RefCell::new(Vec::new());
+ let out = run(
+ &o,
+ &json!({}),
+ |url| {
+ events.borrow_mut().push(format!("start:{url}"));
+ async move { Ok(page(&url, "")) }
+ },
+ |item| {
+ events
+ .borrow_mut()
+ .push(format!("emit:{}", item["url"].as_str().unwrap()));
+ Box::pin(async {})
+ },
+ )
+ .await;
+ assert_eq!(out.crawled, 3);
+
+ let events = events.into_inner();
+ let third_start = events
+ .iter()
+ .position(|event| event == "start:https://e.com/3")
+ .unwrap();
+ assert_eq!(
+ events[..third_start]
+ .iter()
+ .filter(|event| event.starts_with("emit:"))
+ .count(),
+ 2,
+ "the oracle processes every task returned by FIRST_COMPLETED before refilling: {events:?}"
+ );
+ }
+
+ #[test]
+ fn missing_start_urls_and_bad_fetcher_are_rejected() {
+ assert_eq!(
+ CrawlOpts::from_payload(&json!({}), 5).unwrap_err(),
+ "provide `start_urls`"
+ );
+ assert!(
+ CrawlOpts::from_payload(&json!({"url": "u", "fetcher": "carrier"}), 5)
+ .unwrap_err()
+ .contains("unknown fetcher")
+ );
+ }
+
+ #[test]
+ fn wrapper_coercions_and_errors_match_python() {
+ assert_eq!(
+ CrawlOpts::from_payload(&json!({"url": "https://e.com/", "max_pages": [1]}), 5)
+ .unwrap_err(),
+ "int() argument must be a string, a bytes-like object or a real number, not 'list'"
+ );
+ assert_eq!(
+ CrawlOpts::from_payload(&json!({"url": "https://e.com/", "max_depth": "x"}), 5)
+ .unwrap_err(),
+ "invalid literal for int() with base 10: 'x'"
+ );
+ assert_eq!(
+ CrawlOpts::from_payload(&json!({"url": "https://e.com/", "fetcher": null}), 5)
+ .unwrap_err(),
+ "unknown fetcher: None (use http|stealthy|dynamic)"
+ );
+ assert_eq!(
+ CrawlOpts::from_payload(&json!({"start_urls": [1]}), 5).unwrap_err(),
+ "'int' object has no attribute 'decode'"
+ );
+
+ let options = opts(json!({
+ "start_urls": "ab",
+ "allowed_domains": {"EXAMPLE.COM": true},
+ "same_domain": 0,
+ "max_pages": " 2 "
+ }));
+ assert_eq!(options.start_urls, ["a", "b"]);
+ assert_eq!(options.allowed_domains, ["example.com"]);
+ assert!(!options.same_domain);
+ assert_eq!(options.max_pages, 2);
+ }
+
+ #[test]
+ fn per_page_payload_only_forwards_the_wrapper_allowlist() {
+ let request = fetch_payload(
+ &json!({
+ "url": "https://old.invalid",
+ "headers": {"x": "silently excluded by the oracle crawl wrapper"},
+ "impersonate": "chrome",
+ "timeout": 9,
+ "selectors": [{"name": "h", "css": "h1"}],
+ "format": "text",
+ "main_content_only": false,
+ "css_selector": "main",
+ "include_html": true,
+ }),
+ "https://e.com/page",
+ );
+ assert_eq!(
+ request,
+ json!({
+ "impersonate": "chrome",
+ "timeout": 9,
+ "url": "https://e.com/page",
+ "selectors": [{"name": "h", "css": "h1"}],
+ "format": "text",
+ "main_content_only": false,
+ "css_selector": "main",
+ })
+ );
+ }
+
+ #[test]
+ fn an_absurd_download_delay_is_clamped_not_panicked_on() {
+ for v in [1e20, f64::MAX] {
+ let o = opts(json!({"url": "https://e.com/", "download_delay": v}));
+ assert!(o.download_delay <= Duration::from_secs_f64(MAX_DOWNLOAD_DELAY_SECS));
+ }
+ assert_eq!(
+ opts(json!({"url": "https://e.com/", "download_delay": f64::NAN})).download_delay,
+ Duration::ZERO
+ );
+ assert_eq!(
+ CrawlOpts::from_payload_for_mode(
+ &json!({"url": "https://e.com/", "download_delay": 301}),
+ 5,
+ SecurityMode::Compat,
+ )
+ .unwrap()
+ .download_delay,
+ Duration::from_secs(301)
+ );
+ assert_eq!(
+ CrawlOpts::from_payload_for_mode(
+ &json!({"url": "https://e.com/", "download_delay": -1}),
+ 5,
+ SecurityMode::Compat,
+ )
+ .unwrap()
+ .download_delay,
+ Duration::ZERO
+ );
+ assert_eq!(
+ CrawlOpts::from_payload(&json!({"url": "https://e.com/", "download_delay": [1]}), 5,)
+ .unwrap_err(),
+ "float() argument must be a string or a real number, not 'list'"
+ );
+ }
+
+ #[test]
+ fn stream_name_defaults_to_our_namespace() {
+ assert_eq!(opts(json!({"url": "u"})).stream_name, "browser::crawl");
+ assert_eq!(
+ opts(json!({"url": "u", "stream_name": 3})).stream_name,
+ json!(3)
+ );
+ }
+}
diff --git a/browser/src/scrapling/dom.rs b/browser/src/scrapling/dom.rs
new file mode 100644
index 000000000..c25cfb3cc
--- /dev/null
+++ b/browser/src/scrapling/dom.rs
@@ -0,0 +1,521 @@
+//! Libxml-compatible HTML tree used by every Scrapling parser operation.
+
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+
+use serde_json::Value;
+use xmloxide::html::{parse_html_with_options, HtmlParseOptions};
+use xmloxide::serial::html::serialize_html_subtree;
+use xmloxide::tree::NodeKind;
+use xmloxide::{Document, NodeId};
+
+const LXML_MIXED_CONTENT_TAGS: &[&str] = &[
+ "body",
+ "div",
+ "p",
+ "span",
+ "a",
+ "b",
+ "i",
+ "u",
+ "s",
+ "strike",
+ "tt",
+ "big",
+ "small",
+ "cite",
+ "q",
+ "kbd",
+ "ins",
+ "del",
+ "em",
+ "strong",
+ "h1",
+ "h2",
+ "h3",
+ "h4",
+ "h5",
+ "h6",
+ "li",
+ "dt",
+ "dd",
+ "td",
+ "th",
+ "caption",
+ "pre",
+ "code",
+ "label",
+ "button",
+ "legend",
+ "address",
+ "blockquote",
+ "form",
+];
+const LXML_RAW_TEXT_TAGS: &[&str] = &["script", "style", "title", "textarea"];
+
+#[derive(Debug, Clone)]
+pub struct Doc {
+ pub tree: Document,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct ElementRef<'a> {
+ doc: &'a Doc,
+ id: NodeId,
+}
+
+impl PartialEq for ElementRef<'_> {
+ fn eq(&self, other: &Self) -> bool {
+ std::ptr::eq(self.doc, other.doc) && self.id == other.id
+ }
+}
+
+impl Eq for ElementRef<'_> {}
+
+impl Hash for ElementRef<'_> {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ std::ptr::from_ref(self.doc).hash(state);
+ self.id.hash(state);
+ }
+}
+
+impl<'a> ElementRef<'a> {
+ pub fn id(self) -> NodeId {
+ self.id
+ }
+
+ pub fn doc(self) -> &'a Doc {
+ self.doc
+ }
+
+ pub fn name(self) -> &'a str {
+ self.doc.tree.node_name(self.id).unwrap_or("")
+ }
+
+ pub fn attr(self, name: &str) -> Option<&'a str> {
+ self.doc.tree.attribute(self.id, name)
+ }
+
+ pub fn attrs(self) -> impl Iterator<Item = (&'a str, &'a str)> + 'a {
+ self.doc
+ .tree
+ .attributes(self.id)
+ .iter()
+ .map(|attr| (attr.name.as_str(), attr.value.as_str()))
+ }
+}
+
+pub fn parse(input: &str) -> Doc {
+ let cleaned = input.trim().replace('\0', "");
+ let trim_implicit_leading = (cleaned.starts_with("<!--") || cleaned.starts_with("<![CDATA["))
+ && !cleaned.to_ascii_lowercase().contains("<body");
+ let body = if cleaned.is_empty() {
+ "<html></html>"
+ } else {
+ &cleaned
+ };
+ let options = HtmlParseOptions::default().recover(true).no_blanks(false);
+ let mut tree = parse_html_with_options(body, &options).unwrap_or_else(|_| {
+ parse_html_with_options("<html></html>", &HtmlParseOptions::default()).unwrap()
+ });
+ if tree.root_element().is_none() {
+ tree = parse_html_with_options(&format!("<html><body>{body}</body></html>"), &options)
+ .unwrap_or_else(|_| parse_html_with_options("<html></html>", &options).unwrap());
+ }
+
+ let removed: Vec<_> = tree
+ .descendants(tree.root())
+ .filter(|id| {
+ matches!(
+ tree.node(*id).kind,
+ // lxml's cleaner drops PIs too; keeping them made ::text /
+ // find-by-text / describe / get_all_text diverge.
+ NodeKind::Comment { .. }
+ | NodeKind::CData { .. }
+ | NodeKind::ProcessingInstruction { .. }
+ )
+ })
+ .collect();
+ for id in removed {
+ tree.remove_node(id);
+ }
+ if trim_implicit_leading {
+ trim_body_leading_whitespace(&mut tree);
+ }
+ merge_adjacent_text(&mut tree);
+ detach_blank_text(&mut tree);
+ Doc { tree }
+}
+
+fn trim_body_leading_whitespace(tree: &mut Document) {
+ let body = tree
+ .descendants(tree.root())
+ .find(|id| tree.node_name(*id) == Some("body"));
+ let first = body.and_then(|id| tree.first_child(id));
+ if let Some(id) = first.filter(|id| is_text(tree, *id)) {
+ let trimmed = tree.node_text(id).unwrap_or("").trim_start().to_string();
+ tree.set_text_content(id, &trimmed);
+ }
+}
+
+fn is_text(tree: &Document, id: NodeId) -> bool {
+ matches!(
+ tree.node(id).kind,
+ NodeKind::Text { .. } | NodeKind::CData { .. }
+ )
+}
+
+fn merge_adjacent_text(tree: &mut Document) {
+ let parents: Vec<_> = std::iter::once(tree.root())
+ .chain(tree.descendants(tree.root()))
+ .collect();
+ for parent in parents {
+ let children: Vec<_> = tree.children(parent).collect();
+ let mut previous = None;
+ for child in children {
+ if !is_text(tree, child) {
+ previous = None;
+ continue;
+ }
+ if let Some(first) = previous {
+ let merged = format!(
+ "{}{}",
+ tree.node_text(first).unwrap_or(""),
+ tree.node_text(child).unwrap_or("")
+ );
+ tree.set_text_content(first, &merged);
+ tree.remove_node(child);
+ } else {
+ previous = Some(child);
+ }
+ }
+ }
+}
+
+fn detach_blank_text(tree: &mut Document) {
+ let ids: Vec<_> = tree.descendants(tree.root()).collect();
+ let mut drop_ids = Vec::new();
+ for id in ids {
+ if !is_text(tree, id)
+ || tree
+ .prev_sibling(id)
+ .is_some_and(|prev| is_text(tree, prev))
+ {
+ continue;
+ }
+ let mut run = vec![id];
+ let mut all_blank = tree
+ .node_text(id)
+ .is_some_and(|text| text.chars().all(char::is_whitespace));
+ let mut next = tree.next_sibling(id);
+ while let Some(node) = next {
+ if !is_text(tree, node) {
+ break;
+ }
+ all_blank &= tree
+ .node_text(node)
+ .is_some_and(|text| text.chars().all(char::is_whitespace));
+ run.push(node);
+ next = tree.next_sibling(node);
+ }
+ if !all_blank {
+ continue;
+ }
+ let previous_tag = tree.prev_sibling(id).and_then(|node| tree.node_name(node));
+ let keep = previous_tag.map_or_else(
+ || {
+ tree.parent(id)
+ .and_then(|node| tree.node_name(node))
+ .is_some_and(|name| {
+ LXML_MIXED_CONTENT_TAGS.contains(&name)
+ || LXML_RAW_TEXT_TAGS.contains(&name)
+ })
+ },
+ |name| LXML_MIXED_CONTENT_TAGS.contains(&name),
+ );
+ if !keep {
+ drop_ids.extend(run);
+ }
+ }
+ for id in drop_ids {
+ tree.remove_node(id);
+ }
+}
+
+impl Doc {
+ pub fn root(&self) -> ElementRef<'_> {
+ let id = self
+ .tree
+ .root_element()
+ .expect("HTML parser always emits a root");
+ ElementRef { doc: self, id }
+ }
+
+ pub fn element(&self, id: NodeId) -> Option<ElementRef<'_>> {
+ self.tree
+ .is_element(id)
+ .then_some(ElementRef { doc: self, id })
+ }
+
+ pub fn first_by_tag(&self, tag: &str) -> Option<ElementRef<'_>> {
+ std::iter::once(self.root())
+ .chain(descendant_elements(self.root()))
+ .find(|element| element.name() == tag)
+ }
+}
+
+pub fn merged_text_children(el: ElementRef<'_>) -> Vec<(bool, String)> {
+ let tree = &el.doc.tree;
+ let mut runs = Vec::new();
+ let mut seen_element = false;
+ let mut current: Option<String> = None;
+ for child in tree.children(el.id) {
+ if is_text(tree, child) {
+ current
+ .get_or_insert_with(String::new)
+ .push_str(tree.node_text(child).unwrap_or(""));
+ } else {
+ if let Some(run) = current.take() {
+ runs.push((!seen_element, run));
+ }
+ seen_element |= tree.is_element(child);
+ }
+ }
+ if let Some(run) = current {
+ runs.push((!seen_element, run));
+ }
+ runs
+}
+
+pub fn descendant_text_runs(el: ElementRef<'_>) -> Vec<(ElementRef<'_>, usize, String)> {
+ let tree = &el.doc.tree;
+ let mut out = Vec::new();
+ let mut indexes: HashMap<NodeId, usize> = HashMap::new();
+ let mut owner = None;
+ let mut current = String::new();
+ for node in tree.descendants(el.id) {
+ if !is_text(tree, node) {
+ flush_run(&mut owner, &mut current, &mut out, &mut indexes);
+ continue;
+ }
+ let parent = tree.parent(node).and_then(|id| el.doc.element(id));
+ if parent.map(ElementRef::id) != owner.map(ElementRef::id) {
+ flush_run(&mut owner, &mut current, &mut out, &mut indexes);
+ owner = parent;
+ }
+ current.push_str(tree.node_text(node).unwrap_or(""));
+ }
+ flush_run(&mut owner, &mut current, &mut out, &mut indexes);
+ out
+}
+
+fn flush_run<'a>(
+ owner: &mut Option<ElementRef<'a>>,
+ text: &mut String,
+ out: &mut Vec<(ElementRef<'a>, usize, String)>,
+ indexes: &mut HashMap<NodeId, usize>,
+) {
+ if let Some(element) = owner.take() {
+ let index = indexes.entry(element.id).or_default();
+ out.push((element, *index, std::mem::take(text)));
+ *index += 1;
+ }
+}
+
+pub fn leading_text(el: ElementRef<'_>) -> String {
+ merged_text_children(el)
+ .first()
+ .filter(|(leading, _)| *leading)
+ .map(|(_, text)| text.clone())
+ .unwrap_or_default()
+}
+
+pub fn first_text_run_nonblank(el: ElementRef<'_>) -> bool {
+ merged_text_children(el)
+ .first()
+ .is_some_and(|(_, text)| !crate::scrapling::text::normalize_space(text).is_empty())
+}
+
+pub fn get_all_text(
+ el: ElementRef<'_>,
+ separator: &str,
+ strip: bool,
+ ignore: &[&str],
+ valid_values: bool,
+) -> String {
+ let tree = &el.doc.tree;
+ let mut fragments = Vec::new();
+ let mut owner = None;
+ let mut current = String::new();
+
+ let flush = |current: &mut String, fragments: &mut Vec<String>| {
+ if current.is_empty() {
+ return;
+ }
+ let trimmed = current.trim();
+ if !valid_values || !trimmed.is_empty() {
+ fragments.push(if strip {
+ trimmed.to_string()
+ } else {
+ current.clone()
+ });
+ }
+ current.clear();
+ };
+
+ for node in tree.descendants(el.id) {
+ if !is_text(tree, node) {
+ flush(&mut current, &mut fragments);
+ owner = None;
+ continue;
+ }
+ let mut cursor = tree.parent(node);
+ let mut ignored = false;
+ while let Some(ancestor) = cursor {
+ if tree
+ .node_name(ancestor)
+ .is_some_and(|name| ignore.iter().any(|item| item.eq_ignore_ascii_case(name)))
+ {
+ ignored = true;
+ break;
+ }
+ if ancestor == el.id {
+ break;
+ }
+ cursor = tree.parent(ancestor);
+ }
+ if ignored {
+ flush(&mut current, &mut fragments);
+ owner = None;
+ continue;
+ }
+ let parent = tree.parent(node);
+ if parent != owner {
+ flush(&mut current, &mut fragments);
+ owner = parent;
+ }
+ current.push_str(tree.node_text(node).unwrap_or(""));
+ }
+ flush(&mut current, &mut fragments);
+ fragments.join(separator)
+}
+
+pub fn outer_html(el: ElementRef<'_>) -> String {
+ serialize_html_subtree(&el.doc.tree, el.id)
+}
+
+pub fn attrs_json(el: ElementRef<'_>) -> serde_json::Map<String, Value> {
+ el.attrs()
+ .map(|(name, value)| (name.to_string(), Value::String(value.to_string())))
+ .collect()
+}
+
+pub fn parent_element(el: ElementRef<'_>) -> Option<ElementRef<'_>> {
+ el.doc.tree.parent(el.id).and_then(|id| el.doc.element(id))
+}
+
+pub fn element_children(el: ElementRef<'_>) -> Vec<ElementRef<'_>> {
+ el.doc
+ .tree
+ .children(el.id)
+ .filter_map(|id| el.doc.element(id))
+ .collect()
+}
+
+pub fn descendant_elements(el: ElementRef<'_>) -> Vec<ElementRef<'_>> {
+ el.doc
+ .tree
+ .descendants(el.id)
+ .filter_map(|id| el.doc.element(id))
+ .collect()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn first<'a>(doc: &'a Doc, tag: &str) -> ElementRef<'a> {
+ doc.first_by_tag(tag).unwrap()
+ }
+
+ #[test]
+ fn parse_and_text_match_libxml_cleanup() {
+ let doc = parse("<span>CONDITION: <!-- hi -->Excellent</span>");
+ let span = first(&doc, "span");
+ assert_eq!(leading_text(span), "CONDITION: Excellent");
+ assert_eq!(outer_html(span), "<span>CONDITION: Excellent</span>");
+
+ let doc = parse("<p>a\0b</p>");
+ assert_eq!(get_all_text(first(&doc, "p"), "\n", false, &[], true), "ab");
+
+ let doc = parse("<!--c--> b");
+ assert_eq!(outer_html(doc.root()), "<html><body>b</body></html>");
+ let doc = parse("<div><!--c--> b</div>");
+ assert_eq!(outer_html(first(&doc, "div")), "<div> b</div>");
+ }
+
+ #[test]
+ fn empty_input_keeps_the_oracles_explicit_html_root() {
+ let doc = parse("");
+ assert_eq!(doc.root().name(), "html");
+ assert_eq!(outer_html(doc.root()), "<html></html>");
+
+ let doc = parse(">");
+ assert_eq!(outer_html(doc.root()), "<html><body>></body></html>");
+ }
+
+ #[test]
+ fn text_runs_and_ignored_subtrees_match_scrapling() {
+ let doc = parse("<div>a<script>bad()</script>b<style>.x{}</style>c</div>");
+ assert_eq!(
+ get_all_text(first(&doc, "div"), "\n", false, &["script", "style"], true),
+ "a\nb\nc"
+ );
+ let doc = parse("<p>lead<b>x</b>tail</p>");
+ assert_eq!(leading_text(first(&doc, "p")), "lead");
+ }
+
+ #[test]
+ fn blank_text_uses_libxmls_legacy_content_model() {
+ let doc = parse("<main> <h1>a</h1> <p>b</p> <h2>c</h2> <table><tr><td>d</td></tr></table> <p>e</p></main>");
+ let runs: Vec<_> = merged_text_children(first(&doc, "main"))
+ .into_iter()
+ .map(|(_, value)| value)
+ .collect();
+ assert_eq!(runs, [" ", " ", " "]);
+ assert_eq!(
+ merged_text_children(first(&parse("<pre> \n </pre>"), "pre")),
+ [(true, " \n ".to_string())]
+ );
+ }
+
+ #[test]
+ fn attributes_and_recovery_are_ordered_and_libxml_serialized() {
+ let doc = parse("<input z=1 disabled a='' z=2 checked=checked>");
+ let input = first(&doc, "input");
+ assert_eq!(
+ attrs_json(input).keys().collect::<Vec<_>>(),
+ ["z", "disabled", "a", "checked"]
+ );
+ assert_eq!(outer_html(input), "<input z=\"1\" disabled a=\"\" checked>");
+
+ let doc = parse("<table><td>A<td>B<div>C");
+ assert_eq!(
+ outer_html(first(&doc, "table")),
+ "<table><td>A</td><td>B<div>C</div></td></table>"
+ );
+ }
+
+ #[test]
+ fn template_contents_are_ordinary_children() {
+ let doc = parse("<template><p>x</p></template>");
+ let template = first(&doc, "template");
+ assert_eq!(
+ element_children(template)
+ .into_iter()
+ .map(ElementRef::name)
+ .collect::<Vec<_>>(),
+ ["p"]
+ );
+ }
+}
diff --git a/browser/src/scrapling/egress_gate.rs b/browser/src/scrapling/egress_gate.rs
new file mode 100644
index 000000000..89ae33cf4
--- /dev/null
+++ b/browser/src/scrapling/egress_gate.rs
@@ -0,0 +1,260 @@
+use std::net::SocketAddr;
+
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::oneshot;
+use tokio::task::JoinHandle;
+
+use crate::ssrf::{check_target, parse_target, SsrfPolicy};
+
+const MAX_HEADER_BYTES: usize = 64 * 1024;
+
+/// Local HTTP/CONNECT proxy used by safe-mode Chromium. Every connection is
+/// resolved, checked, and then pinned to the checked address before dialing.
+pub struct EgressGate {
+ address: SocketAddr,
+ stop: Option<oneshot::Sender<()>>,
+ task: Option<JoinHandle<()>>,
+}
+
+impl EgressGate {
+ pub async fn start(policy: SsrfPolicy) -> Result<Self, String> {
+ let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
+ .await
+ .map_err(|e| format!("starting browser egress gate: {e}"))?;
+ let address = listener
+ .local_addr()
+ .map_err(|e| format!("reading browser egress gate address: {e}"))?;
+ let (stop, mut stopped) = oneshot::channel();
+ let task = tokio::spawn(async move {
+ loop {
+ tokio::select! {
+ _ = &mut stopped => break,
+ accepted = listener.accept() => match accepted {
+ Ok((socket, _)) => {
+ tokio::spawn(handle(socket, policy));
+ }
+ Err(_) => break,
+ }
+ }
+ }
+ });
+ Ok(Self {
+ address,
+ stop: Some(stop),
+ task: Some(task),
+ })
+ }
+
+ pub fn proxy_url(&self) -> String {
+ format!("http://{}", self.address)
+ }
+
+ pub async fn close(mut self) {
+ if let Some(stop) = self.stop.take() {
+ let _ = stop.send(());
+ }
+ if let Some(task) = self.task.take() {
+ let _ = task.await;
+ }
+ }
+}
+
+impl Drop for EgressGate {
+ fn drop(&mut self) {
+ if let Some(stop) = self.stop.take() {
+ let _ = stop.send(());
+ }
+ if let Some(task) = self.task.take() {
+ task.abort();
+ }
+ }
+}
+
+async fn handle(mut client: TcpStream, policy: SsrfPolicy) {
+ if let Err((status, detail)) = proxy(&mut client, policy).await {
+ let body = format!("browser egress denied: {detail}\n");
+ let _ = client
+ .write_all(
+ format!(
+ "HTTP/1.1 {status}\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+ body.len()
+ )
+ .as_bytes(),
+ )
+ .await;
+ }
+}
+
+async fn proxy(client: &mut TcpStream, policy: SsrfPolicy) -> Result<(), (&'static str, String)> {
+ let request = read_head(client).await?;
+ let split = request
+ .windows(4)
+ .position(|window| window == b"\r\n\r\n")
+ .map(|position| position + 4)
+ .ok_or_else(|| ("400 Bad Request", "incomplete request headers".to_string()))?;
+ let head = std::str::from_utf8(&request[..split]).map_err(|_| {
+ (
+ "400 Bad Request",
+ "request headers are not UTF-8".to_string(),
+ )
+ })?;
+ let first_end = head
+ .find("\r\n")
+ .ok_or_else(|| ("400 Bad Request", "missing request line".to_string()))?;
+ let mut request_line = head[..first_end].split_whitespace();
+ let method = request_line.next().unwrap_or_default();
+ let target = request_line.next().unwrap_or_default();
+ let version = request_line.next().unwrap_or_default();
+ if request_line.next().is_some() || !version.starts_with("HTTP/") {
+ return Err(("400 Bad Request", "invalid request line".to_string()));
+ }
+
+ let (parsed, connect) = if method.eq_ignore_ascii_case("CONNECT") {
+ (parse_target(&format!("https://{target}/")), true)
+ } else {
+ (parse_target(target), false)
+ };
+ let parsed = parsed.map_err(|e| ("400 Bad Request", e))?;
+ let resolved = check_target(&parsed, &policy)
+ .await
+ .map_err(|e| ("403 Forbidden", e.message))?;
+ let mut upstream = TcpStream::connect(SocketAddr::new(resolved.address, resolved.port))
+ .await
+ .map_err(|e| {
+ (
+ "502 Bad Gateway",
+ format!("connecting to {}: {e}", parsed.hostname),
+ )
+ })?;
+
+ if connect {
+ client
+ .write_all(b"HTTP/1.1 200 Connection Established\r\n\r\n")
+ .await
+ .map_err(|e| ("502 Bad Gateway", e.to_string()))?;
+ } else {
+ let path = match parsed.url.query() {
+ Some(query) => format!("{}?{query}", parsed.url.path()),
+ None => parsed.url.path().to_string(),
+ };
+ // The upstream socket is pinned to the FIRST validated host; only one
+ // request may ever travel on it. Strip the client's connection
+ // management and force `Connection: close` so a keep-alive client
+ // cannot send a second (differently-addressed) request down this
+ // pinned socket.
+ let mut forwarded = format!("{method} {path} {version}\r\n");
+ for line in head[first_end + 2..].split("\r\n") {
+ if line.is_empty() {
+ continue;
+ }
+ let name = line.split(':').next().unwrap_or_default().trim();
+ if name.eq_ignore_ascii_case("connection")
+ || name.eq_ignore_ascii_case("proxy-connection")
+ || name.eq_ignore_ascii_case("keep-alive")
+ {
+ continue;
+ }
+ forwarded.push_str(line);
+ forwarded.push_str("\r\n");
+ }
+ forwarded.push_str("Connection: close\r\n\r\n");
+ upstream
+ .write_all(forwarded.as_bytes())
+ .await
+ .map_err(|e| ("502 Bad Gateway", e.to_string()))?;
+ }
+ if request.len() > split {
+ upstream
+ .write_all(&request[split..])
+ .await
+ .map_err(|e| ("502 Bad Gateway", e.to_string()))?;
+ }
+ tokio::io::copy_bidirectional(client, &mut upstream)
+ .await
+ .map_err(|e| ("502 Bad Gateway", e.to_string()))?;
+ Ok(())
+}
+
+async fn read_head(client: &mut TcpStream) -> Result<Vec<u8>, (&'static str, String)> {
+ let mut request = Vec::with_capacity(1024);
+ while !request.windows(4).any(|window| window == b"\r\n\r\n") {
+ if request.len() == MAX_HEADER_BYTES {
+ return Err((
+ "431 Request Header Fields Too Large",
+ "request headers exceed 64 KiB".to_string(),
+ ));
+ }
+ let start = request.len();
+ let end = (start + 4096).min(MAX_HEADER_BYTES);
+ request.resize(end, 0);
+ let read = client
+ .read(&mut request[start..end])
+ .await
+ .map_err(|e| ("400 Bad Request", e.to_string()))?;
+ request.truncate(start + read);
+ if read == 0 {
+ return Err((
+ "400 Bad Request",
+ "connection closed before headers".to_string(),
+ ));
+ }
+ }
+ Ok(request)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[tokio::test]
+ async fn proxies_http_and_blocks_metadata_connects() {
+ let origin = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
+ .await
+ .unwrap();
+ let origin_address = origin.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (mut socket, _) = origin.accept().await.unwrap();
+ let request = read_head(&mut socket).await.unwrap();
+ let request = String::from_utf8(request).unwrap();
+ assert!(request.starts_with("GET /path?q=1 HTTP/1.1\r\n"));
+ // Exactly one Connection header, forced to close.
+ assert_eq!(request.matches("Connection:").count(), 1);
+ assert!(request.contains("\r\nConnection: close\r\n"));
+ socket
+ .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+ .await
+ .unwrap();
+ });
+ let gate = EgressGate::start(SsrfPolicy {
+ allow_loopback: true,
+ })
+ .await
+ .unwrap();
+ let gate_address = gate.address;
+ let mut client = TcpStream::connect(gate_address).await.unwrap();
+ client
+ .write_all(
+ format!(
+ "GET http://{origin_address}/path?q=1 HTTP/1.1\r\nHost: {origin_address}\r\nConnection: close\r\n\r\n"
+ )
+ .as_bytes(),
+ )
+ .await
+ .unwrap();
+ let mut response = String::new();
+ client.read_to_string(&mut response).await.unwrap();
+ assert!(response.ends_with("\r\n\r\nok"));
+ server.await.unwrap();
+
+ let mut client = TcpStream::connect(gate_address).await.unwrap();
+ client
+ .write_all(b"CONNECT 169.254.169.254:80 HTTP/1.1\r\nHost: 169.254.169.254\r\n\r\n")
+ .await
+ .unwrap();
+ let mut response = String::new();
+ client.read_to_string(&mut response).await.unwrap();
+ assert!(response.starts_with("HTTP/1.1 403 Forbidden\r\n"));
+ gate.close().await;
+ }
+}
diff --git a/browser/src/scrapling/fetch.rs b/browser/src/scrapling/fetch.rs
new file mode 100644
index 000000000..64b79154c
--- /dev/null
+++ b/browser/src/scrapling/fetch.rs
@@ -0,0 +1,1617 @@
+//! `browser::fetch` — the no-browser HTTP tier (core.py's
+//! `fetch_raw(tier="http")`).
+//!
+//! Safe mode uses `reqwest` + rustls and refuses options that would pretend to
+//! provide curl-cffi wire parity or bypass its egress/TLS policy. Certified
+//! Tier-1 compat builds instead link the frozen curl-impersonate engine behind
+//! the `scrapling-compat` feature.
+//!
+//! In safe mode redirects are followed by hand (`Policy::none`) so every hop
+//! goes back through the SSRF check — the initial URL being public says
+//! nothing about where hop 3 points. Each hop also pins the socket to the
+//! address we validated, which closes the DNS-rebinding window between the
+//! check and the connect.
+
+use std::net::SocketAddr;
+use std::time::Duration;
+
+use serde_json::{json, Map, Value};
+
+use crate::scrapling::page::PageData;
+use crate::ssrf::{check_target, parse_target, SsrfPolicy};
+
+#[cfg(feature = "scrapling-compat")]
+mod curl_compat;
+#[cfg(feature = "scrapling-compat")]
+pub(crate) use curl_compat::CompatSession;
+
+/// Chrome-ish default headers. The python worker's `stealthy_headers` (on by
+/// default) adds a realistic header set plus a Google referer; this is the
+/// header-level part of that, which is all we can honestly offer.
+const DEFAULT_UA: &str = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) \
+ Chrome/131.0.0.0 Safari/537.36";
+const DEFAULT_ACCEPT: &str =
+ "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8";
+
+/// Ceilings on caller-supplied durations. `Duration::from_secs_f64` panics on
+/// unrepresentable input, and an hour is already far past any sane fetch.
+const MAX_TIMEOUT_SECS: f64 = 3_600.0;
+const MAX_RETRY_DELAY_SECS: f64 = 60.0;
+/// Total wall-clock budget for one `fetch` call. Without it, `timeout` is
+/// per-request and multiplies out across redirect hops and retries — the
+/// reference passes `timeout` to curl's `CURLOPT_TIMEOUT`, which is a TOTAL
+/// budget, so a caller asking for 30s must not be able to wait 46 minutes.
+const TOTAL_BUDGET_MULTIPLIER: u32 = 3;
+/// Upper clamp for `max_redirects` on the safe tier. The schema is a bare
+/// integer, so oversized values must clamp rather than panic; anything past
+/// this is a redirect loop, not a fetch.
+const MAX_REDIRECTS: i64 = 100;
+/// Cap on a single response body. Without it one URL can OOM the worker and
+/// take every live browser session with it.
+const MAX_BODY_BYTES: usize = 32 * 1024 * 1024;
+
+/// Headers that must not survive a redirect to a different origin. reqwest
+/// strips these itself when it follows redirects; we follow them by hand (to
+/// re-check each hop against the SSRF policy), so stripping is ours to do.
+/// curl has done this since CVE-2018-1000007.
+fn is_sensitive_header(name: &str) -> bool {
+ let n = name.to_ascii_lowercase();
+ matches!(
+ n.as_str(),
+ "authorization" | "cookie" | "proxy-authorization" | "www-authenticate"
+ )
+}
+
+/// Same origin = same scheme, host and effective port.
+fn same_origin(a: &url::Url, b: &url::Url) -> bool {
+ a.scheme() == b.scheme()
+ && a.host_str() == b.host_str()
+ && a.port_or_known_default() == b.port_or_known_default()
+}
+
+fn redirected_request(status: u16, method: &str, send_body: bool) -> (String, bool) {
+ if matches!(status, 301..=303) {
+ (
+ if method == "post" { "get" } else { method }.to_string(),
+ false,
+ )
+ } else {
+ (method.to_string(), send_body)
+ }
+}
+
+#[derive(Clone, Debug)]
+pub struct HttpOptions {
+ pub mode: HttpMode,
+ pub method: String,
+ pub timeout: Duration,
+ /// Preserve curl-cffi's signed millisecond value for compat setopt error
+ /// parity. Safe mode only consumes the bounded `Duration` above.
+ pub compat_timeout_ms: i64,
+ pub follow_redirects: bool,
+ pub compat_follow_redirects: i64,
+ pub max_redirects: i64,
+ pub retries: i64,
+ pub retry_delay: Duration,
+ pub retry_delay_negative: bool,
+ pub proxy: Option<String>,
+ pub proxies: Vec<(String, String)>,
+ pub proxy_auth: Option<(String, String)>,
+ pub auth: Option<(String, String)>,
+ pub impersonate: Option<String>,
+ pub http3: bool,
+ pub verify: bool,
+ pub headers: Vec<(String, String)>,
+ pub cookies: Vec<(String, String)>,
+ pub params: Vec<(String, String)>,
+ pub body: Option<Body>,
+ /// Shared cookie jar for `session-fetch`. Each hop still builds its own
+ /// pinned client, so the jar is what carries cookies across requests (and
+ /// across redirects) on a persistent HTTP session.
+ pub jar: Option<std::sync::Arc<reqwest::cookie::Jar>>,
+ #[cfg(feature = "scrapling-compat")]
+ pub(crate) compat_session: Option<CompatSession>,
+}
+
+#[derive(Clone, Debug)]
+pub enum Body {
+ Form(Value),
+ Json(Value),
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum HttpMode {
+ Safe,
+ Compat,
+}
+
+fn str_pairs(payload: &Value, key: &str) -> Vec<(String, String)> {
+ payload
+ .get(key)
+ .and_then(Value::as_object)
+ .map(|m| {
+ m.iter()
+ .map(|(k, v)| {
+ let s = match v {
+ Value::String(s) => s.clone(),
+ other => other.to_string(),
+ };
+ (k.clone(), s)
+ })
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default()
+}
+
+fn python_scalar(value: &Value) -> String {
+ match value {
+ Value::String(value) => value.clone(),
+ Value::Bool(value) => if *value { "True" } else { "False" }.to_string(),
+ Value::Null => "None".to_string(),
+ Value::Number(value) => value.to_string(),
+ Value::Array(_) | Value::Object(_) => python_repr(value),
+ }
+}
+
+fn python_repr(value: &Value) -> String {
+ match value {
+ Value::Null => "None".to_string(),
+ Value::Bool(value) => if *value { "True" } else { "False" }.to_string(),
+ Value::Number(value) => value.to_string(),
+ Value::String(value) => {
+ let quote = if value.contains('\'') && !value.contains('"') {
+ '"'
+ } else {
+ '\''
+ };
+ let escaped = value
+ .replace('\\', "\\\\")
+ .replace(quote, &format!("\\{quote}"));
+ format!("{quote}{escaped}{quote}")
+ }
+ Value::Array(values) => format!(
+ "[{}]",
+ values
+ .iter()
+ .map(python_repr)
+ .collect::<Vec<_>>()
+ .join(", ")
+ ),
+ Value::Object(values) => format!(
+ "{{{}}}",
+ values
+ .iter()
+ .map(|(name, value)| format!(
+ "{}: {}",
+ python_repr(&Value::String(name.clone())),
+ python_repr(value)
+ ))
+ .collect::<Vec<_>>()
+ .join(", ")
+ ),
+ }
+}
+
+fn python_json(value: &Value) -> String {
+ match value {
+ Value::Array(values) => format!(
+ "[{}]",
+ values
+ .iter()
+ .map(python_json)
+ .collect::<Vec<_>>()
+ .join(", ")
+ ),
+ Value::Object(values) => format!(
+ "{{{}}}",
+ values
+ .iter()
+ .map(|(name, value)| format!(
+ "{}: {}",
+ serde_json::to_string(name).expect("JSON string serialization cannot fail"),
+ python_json(value)
+ ))
+ .collect::<Vec<_>>()
+ .join(", ")
+ ),
+ other => other.to_string(),
+ }
+}
+
+fn params_pairs(payload: &Value) -> Vec<(String, String)> {
+ let mut pairs = Vec::new();
+ if let Some(params) = payload.get("params").and_then(Value::as_object) {
+ for (name, value) in params {
+ if let Value::Array(values) = value {
+ pairs.extend(
+ values
+ .iter()
+ .map(|value| (name.clone(), python_scalar(value))),
+ );
+ } else {
+ let value = if matches!(value, Value::Bool(_) | Value::Object(_)) {
+ python_json(value)
+ } else {
+ python_scalar(value)
+ };
+ pairs.push((name.clone(), value));
+ }
+ }
+ }
+ pairs
+}
+
+fn pair(payload: &Value, key: &str) -> Result<Option<(String, String)>, String> {
+ let Some(value) = payload.get(key).filter(|value| !value.is_null()) else {
+ return Ok(None);
+ };
+ let values = value
+ .as_array()
+ .ok_or_else(|| format!("{key} must be [username, password]"))?;
+ if values.len() < 2 {
+ return Err(format!(
+ "not enough values to unpack (expected 2, got {})",
+ values.len()
+ ));
+ }
+ if values.len() > 2 {
+ return Err("too many values to unpack (expected 2)".to_string());
+ }
+ let string = |index: usize| {
+ values[index]
+ .as_str()
+ .map(str::to_owned)
+ .ok_or_else(|| format!("{key} must be [username, password]"))
+ };
+ Ok(Some((string(0)?, string(1)?)))
+}
+
+impl HttpOptions {
+ /// Read the request. Defaults mirror scrapling's own
+ /// (`engines/static.py`): 30s timeout, 3 attempts, 1s between them,
+ /// 30 redirect hops.
+ pub fn from_payload(payload: &Value) -> Result<Self, String> {
+ Self::from_payload_for_mode(payload, HttpMode::Safe)
+ }
+
+ pub fn from_payload_for_mode(payload: &Value, mode: HttpMode) -> Result<Self, String> {
+ if mode == HttpMode::Compat && !cfg!(feature = "scrapling-compat") {
+ return Err(
+ "browser::fetch compat HTTP engine is not compiled into this binary; rebuild the Tier-1 target with feature `scrapling-compat` and the certified curl-impersonate artifacts"
+ .to_string(),
+ );
+ }
+ if mode == HttpMode::Safe {
+ let reject = |field: &str, enabled: bool, reason: &str| -> Result<(), String> {
+ if enabled {
+ Err(format!(
+ "safe mode refuses `{field}`: {reason}; use a certified compat build or remove the option"
+ ))
+ } else {
+ Ok(())
+ }
+ };
+ if let Some(value) = payload.get("impersonate").filter(|value| !value.is_null()) {
+ let value = value.as_str().ok_or("impersonate must be a string")?;
+ reject(
+ "impersonate",
+ !matches!(value, "" | "chrome"),
+ "the safe engine implements only its bounded Chrome header profile",
+ )?;
+ }
+ reject(
+ "http3",
+ payload
+ .get("http3")
+ .and_then(Value::as_bool)
+ .unwrap_or(false),
+ "the safe reqwest engine has no certified HTTP/3 transport",
+ )?;
+ reject(
+ "verify:false",
+ payload.get("verify").and_then(Value::as_bool) == Some(false),
+ "TLS certificate verification cannot be disabled",
+ )?;
+ reject(
+ "proxy",
+ payload
+ .get("proxy")
+ .and_then(Value::as_str)
+ .is_some_and(|value| !value.is_empty()),
+ "a caller proxy can resolve or route to addresses outside the egress policy",
+ )?;
+ reject(
+ "proxies",
+ payload
+ .get("proxies")
+ .and_then(Value::as_object)
+ .is_some_and(|value| !value.is_empty()),
+ "per-scheme proxies bypass address pinning",
+ )?;
+ reject(
+ "proxy_auth",
+ payload.get("proxy_auth").is_some_and(|v| !v.is_null()),
+ "proxy authentication is unavailable when caller proxies are refused",
+ )?;
+ reject(
+ "stealthy_headers:true",
+ payload.get("stealthy_headers").and_then(Value::as_bool) == Some(true),
+ "the safe reqwest engine cannot reproduce BrowserForge's generated header fingerprint",
+ )?;
+ }
+ let method = payload
+ .get("method")
+ .and_then(Value::as_str)
+ .unwrap_or("get")
+ .to_ascii_lowercase();
+ if !matches!(method.as_str(), "get" | "post" | "put" | "delete") {
+ return Err(format!("unsupported method: {method}"));
+ }
+ // `timeout` is SECONDS on this tier (it is milliseconds on the browser
+ // tiers — the schemas say so explicitly, and the two disagree on
+ // purpose because the underlying libraries do).
+ //
+ // The upper clamp is not cosmetic: `Duration::from_secs_f64` PANICS on
+ // a value it cannot represent, and the schema declares a bare
+ // `number`, so `{"timeout": 1e20}` would panic inside the handler.
+ // The SDK spawns handlers detached, so that panic would drop the
+ // invocation entirely and hang the caller with no result.
+ let timeout = payload
+ .get("timeout")
+ .and_then(Value::as_f64)
+ .filter(|value| value.is_finite())
+ .unwrap_or(30.0);
+ let compat_timeout_ms = (timeout * 1_000.0) as i64;
+ let timeout = if mode == HttpMode::Safe {
+ if timeout > 0.0 {
+ timeout.min(MAX_TIMEOUT_SECS)
+ } else {
+ 30.0
+ }
+ } else {
+ timeout.clamp(0.0, MAX_TIMEOUT_SECS)
+ };
+ let raw_retry_delay = payload
+ .get("retry_delay")
+ .and_then(Value::as_f64)
+ .filter(|value| value.is_finite())
+ .unwrap_or(1.0);
+ let retry_delay_negative = raw_retry_delay < 0.0;
+ let retry_delay = if mode == HttpMode::Safe {
+ raw_retry_delay.clamp(0.0, MAX_RETRY_DELAY_SECS)
+ } else {
+ raw_retry_delay.clamp(0.0, (u64::MAX / 2) as f64)
+ };
+ let params = params_pairs(payload);
+ let body = match (payload.get("json"), payload.get("data")) {
+ (Some(j), _) if !j.is_null() => Some(Body::Json(j.clone())),
+ (_, Some(d)) if !d.is_null() => Some(Body::Form(d.clone())),
+ _ => None,
+ };
+ let raw_max_redirects = payload
+ .get("max_redirects")
+ .and_then(Value::as_i64)
+ .unwrap_or(30);
+ if mode == HttpMode::Safe && raw_max_redirects < 0 {
+ return Err(format!(
+ "safe mode refuses `max_redirects:{raw_max_redirects}`: unlimited or invalid redirect counts exceed the bounded request policy; use a non-negative limit"
+ ));
+ }
+ let explicit_impersonate = payload
+ .get("impersonate")
+ .and_then(Value::as_str)
+ .map(str::to_owned);
+ if mode == HttpMode::Compat
+ && payload
+ .get("proxy")
+ .and_then(Value::as_str)
+ .is_some_and(|value| !value.is_empty())
+ && payload
+ .get("proxies")
+ .and_then(Value::as_object)
+ .is_some_and(|value| !value.is_empty())
+ {
+ return Err("Cannot specify both 'proxy' and 'proxies'".to_string());
+ }
+ let impersonate = if mode == HttpMode::Compat {
+ explicit_impersonate.or_else(|| Some("chrome".to_string()))
+ } else {
+ None
+ };
+ let compat_default_ua = (mode == HttpMode::Compat)
+ .then(crate::scrapling::browserforge::default_user_agent)
+ .transpose()?;
+ let impersonate = impersonate.filter(|value| !value.is_empty());
+ let headers = stealthy_headers(
+ payload,
+ mode,
+ impersonate.is_some(),
+ compat_default_ua.as_deref(),
+ )?;
+ Ok(Self {
+ mode,
+ method,
+ timeout: Duration::from_secs_f64(timeout),
+ compat_timeout_ms,
+ follow_redirects: payload
+ .get("follow_redirects")
+ .and_then(Value::as_bool)
+ .unwrap_or(true),
+ compat_follow_redirects: match payload.get("follow_redirects").and_then(Value::as_bool)
+ {
+ Some(true) => 1,
+ Some(false) => 0,
+ None => 4,
+ },
+ max_redirects: raw_max_redirects,
+ retries: payload.get("retries").and_then(Value::as_i64).unwrap_or(3),
+ retry_delay: Duration::from_secs_f64(retry_delay),
+ retry_delay_negative,
+ proxy: payload
+ .get("proxy")
+ .and_then(Value::as_str)
+ .filter(|p| !p.is_empty())
+ .map(str::to_string),
+ proxies: str_pairs(payload, "proxies"),
+ proxy_auth: pair(payload, "proxy_auth")?,
+ auth: pair(payload, "auth")?,
+ impersonate,
+ http3: payload
+ .get("http3")
+ .and_then(Value::as_bool)
+ .unwrap_or(false),
+ verify: payload
+ .get("verify")
+ .and_then(Value::as_bool)
+ .unwrap_or(true),
+ headers,
+ cookies: str_pairs(payload, "cookies"),
+ params,
+ body,
+ jar: None,
+ #[cfg(feature = "scrapling-compat")]
+ compat_session: None,
+ })
+ }
+
+ fn method_allows_body(&self) -> bool {
+ self.method != "get"
+ }
+}
+
+/// Caller headers, with browser-ish defaults filled in underneath unless
+/// `stealthy_headers: false`. Caller-supplied values always win.
+fn stealthy_headers(
+ payload: &Value,
+ mode: HttpMode,
+ impersonation_enabled: bool,
+ compat_default_ua: Option<&str>,
+) -> Result<Vec<(String, String)>, String> {
+ let mut headers = str_pairs(payload, "headers");
+ let stealth = payload
+ .get("stealthy_headers")
+ .and_then(Value::as_bool)
+ .unwrap_or(true);
+ let has = |h: &[(String, String)], name: &str| {
+ h.iter().any(|(key, _)| key.eq_ignore_ascii_case(name))
+ };
+ if !stealth {
+ if mode == HttpMode::Compat && !impersonation_enabled && !has(&headers, "user-agent") {
+ headers.push((
+ "User-Agent".into(),
+ compat_default_ua.unwrap_or(DEFAULT_UA).into(),
+ ));
+ }
+ return Ok(headers);
+ }
+ if mode == HttpMode::Compat && impersonation_enabled {
+ if !has(&headers, "referer") {
+ headers.push(("referer".into(), "https://www.google.com/".into()));
+ }
+ } else if mode == HttpMode::Compat {
+ let supplied = headers
+ .iter()
+ .map(|(name, _)| name.to_ascii_lowercase())
+ .collect::<std::collections::HashSet<_>>();
+ if !supplied.contains("referer") {
+ headers.push(("referer".into(), "https://www.google.com/".into()));
+ }
+ for (name, value) in crate::scrapling::browserforge::generate_http_headers()? {
+ if !supplied.contains(&name.to_ascii_lowercase()) {
+ headers.push((name, value));
+ }
+ }
+ } else {
+ if !has(&headers, "user-agent") {
+ headers.push(("user-agent".into(), DEFAULT_UA.into()));
+ }
+ if !has(&headers, "accept") {
+ headers.push(("accept".into(), DEFAULT_ACCEPT.into()));
+ }
+ if !has(&headers, "accept-language") {
+ headers.push(("accept-language".into(), "en-US,en;q=0.9".into()));
+ }
+ }
+ Ok(headers)
+}
+
+fn build_client(
+ hostname: &str,
+ address: SocketAddr,
+ opts: &HttpOptions,
+) -> Result<reqwest::Client, String> {
+ let mut b = reqwest::Client::builder()
+ // Manual redirects: every hop is re-validated (see module docs).
+ .redirect(reqwest::redirect::Policy::none())
+ .pool_max_idle_per_host(0)
+ .timeout(opts.timeout);
+ if let Some(jar) = &opts.jar {
+ b = b.cookie_provider(jar.clone());
+ }
+ match &opts.proxy {
+ // Through a proxy we cannot pin the socket — the proxy does its own
+ // resolution, so `.resolve()` would be ignored and the pin would be a
+ // false comfort. The proxy ENDPOINT itself is blocklist-checked
+ // separately (see `check_proxy`): it is the address this worker
+ // actually dials, so validating only the target would leave an
+ // internal proxy usable as a pivot into the private network.
+ Some(p) => {
+ b = b.proxy(reqwest::Proxy::all(p).map_err(|e| format!("invalid proxy: {e}"))?);
+ }
+ None => {
+ b = b.resolve(hostname, address);
+ }
+ }
+ b.build().map_err(|e| e.to_string())
+}
+
+fn charset_of(headers: &reqwest::header::HeaderMap) -> Option<String> {
+ let ct = headers.get(reqwest::header::CONTENT_TYPE)?.to_str().ok()?;
+ ct.split(';')
+ .filter_map(|p| p.split_once('='))
+ .find(|(k, _)| k.trim().eq_ignore_ascii_case("charset"))
+ .map(|(_, v)| v.trim().trim_matches('"').to_ascii_lowercase())
+}
+
+#[cfg(feature = "scrapling-compat")]
+fn charset_of_raw(headers: &Map<String, Value>) -> Option<String> {
+ let content_type = headers.get("content-type")?.as_str()?;
+ content_type
+ .split(';')
+ .filter_map(|part| part.split_once('='))
+ .find(|(name, _)| name.trim().eq_ignore_ascii_case("charset"))
+ .map(|(_, value)| value.trim().trim_matches('"').to_ascii_lowercase())
+}
+
+fn decode_body(bytes: &[u8], encoding: Option<&str>) -> String {
+ let decoder = encoding
+ .and_then(|label| encoding_rs::Encoding::for_label(label.as_bytes()))
+ .unwrap_or(encoding_rs::UTF_8);
+ decoder.decode(bytes).0.into_owned()
+}
+
+fn checked_body_len(current: usize, incoming: usize) -> Option<usize> {
+ current
+ .checked_add(incoming)
+ .filter(|total| *total <= MAX_BODY_BYTES)
+}
+
+async fn bounded_body(mut response: reqwest::Response, url: &str) -> Result<Vec<u8>, String> {
+ if let Some(len) = response.content_length() {
+ if len > MAX_BODY_BYTES as u64 {
+ return Err(format!(
+ "response body is {len} bytes, over the {MAX_BODY_BYTES}-byte cap ({url})"
+ ));
+ }
+ }
+ let mut body = Vec::new();
+ while let Some(chunk) = response
+ .chunk()
+ .await
+ .map_err(|error| format!("reading body of {url}: {error}"))?
+ {
+ if checked_body_len(body.len(), chunk.len()).is_none() {
+ return Err(format!(
+ "response body exceeded the {MAX_BODY_BYTES}-byte cap while streaming ({url})"
+ ));
+ }
+ body.extend_from_slice(&chunk);
+ }
+ Ok(body)
+}
+
+fn flatten_headers(headers: &reqwest::header::HeaderMap) -> Map<String, Value> {
+ // Repeated headers (Set-Cookie, Vary, Link, ...) are joined with ", ",
+ // matching what the compat/curl engine produces — last-value-wins would
+ // silently drop data.
+ let mut out = Map::new();
+ for k in headers.keys() {
+ let joined = headers
+ .get_all(k)
+ .iter()
+ .filter_map(|v| v.to_str().ok())
+ .collect::<Vec<_>>()
+ .join(", ");
+ out.insert(k.as_str().to_string(), json!(joined));
+ }
+ out
+}
+
+/// Cookies the response set, as a flat name -> value map.
+fn response_cookies(headers: &reqwest::header::HeaderMap) -> Map<String, Value> {
+ let mut out = Map::new();
+ for v in headers.get_all(reqwest::header::SET_COOKIE) {
+ let Ok(s) = v.to_str() else { continue };
+ let pair = s.split(';').next().unwrap_or("");
+ if let Some((name, value)) = pair.split_once('=') {
+ out.insert(name.trim().to_string(), json!(value.trim()));
+ }
+ }
+ out
+}
+
+/// Validate a caller-supplied proxy endpoint against the same blocklist the
+/// targets go through. When a proxy is configured it — not the target — is
+/// what this worker connects to, so skipping this check would let
+/// `{"proxy": "http://10.0.0.5:3128"}` reach straight into the private
+/// network while the target check looked at an unrelated public host.
+///
+/// `parse_target` only admits http/https, which also rejects `socks5h://…`
+/// (whose whole point is proxy-side DNS we cannot inspect).
+pub async fn check_proxy(opts: &HttpOptions, policy: &SsrfPolicy) -> Result<(), String> {
+ let Some(raw) = &opts.proxy else {
+ return Ok(());
+ };
+ let target =
+ parse_target(raw).map_err(|e| format!("proxy is not a usable http(s) endpoint: {e}"))?;
+ check_target(&target, policy)
+ .await
+ .map_err(|r| format!("proxy refused: {}", r.message))?;
+ Ok(())
+}
+
+/// One attempt: walk the redirect chain, SSRF-checking every hop.
+async fn attempt(
+ url: &str,
+ opts: &HttpOptions,
+ policy: &SsrfPolicy,
+ deadline: std::time::Instant,
+) -> Result<PageData, String> {
+ let mut current = url.to_string();
+ let mut method = opts.method.clone();
+ let mut send_body = opts.method_allows_body();
+ let mut cookies = Map::new();
+ // Cookies set by responses along the chain, replayed host-only: a cookie
+ // is only sent back to the exact host that set it. That covers
+ // login/consent flows that bounce through the same host without ever
+ // leaking a value cross-host.
+ let mut hop_cookies: std::collections::HashMap<String, Map<String, Value>> =
+ std::collections::HashMap::new();
+ let origin = parse_target(url)?.url.clone();
+ // Schema declares a bare integer; an oversized value must clamp, not
+ // panic in try_from. Negative is rejected at parse for safe mode.
+ let max_redirects = opts.max_redirects.clamp(0, MAX_REDIRECTS) as u32;
+ for hop in 0..=max_redirects {
+ if std::time::Instant::now() >= deadline {
+ return Err(format!(
+ "exceeded the total budget while following redirects (hop {hop}) fetching {url}"
+ ));
+ }
+ let target = parse_target(¤t)?;
+ // Cross-origin hop: drop credentials the caller scoped to the origin
+ // they addressed. An open redirect on a trusted host would otherwise
+ // hand an Authorization bearer to whoever it points at.
+ let cross_origin = !same_origin(&origin, &target.url);
+ let resolved = check_target(&target, policy).await.map_err(|r| r.message)?;
+ let client = build_client(
+ &target.hostname,
+ SocketAddr::new(resolved.address, resolved.port),
+ opts,
+ )?;
+
+ let request_method = reqwest::Method::from_bytes(method.to_uppercase().as_bytes())
+ .map_err(|e| e.to_string())?;
+ let mut req = client.request(request_method, target.url.clone());
+ for (k, v) in &opts.headers {
+ if cross_origin && is_sensitive_header(k) {
+ continue;
+ }
+ req = req.header(k, v);
+ }
+ let mut jar = Map::new();
+ // A manual Cookie header makes reqwest skip its cookie store for the
+ // request, so when a session jar exists its cookies must be merged in
+ // here or they would be silently suppressed by per-request cookies.
+ if let Some(session_jar) = &opts.jar {
+ use reqwest::cookie::CookieStore;
+ if let Some(header) = session_jar.cookies(&target.url) {
+ if let Ok(s) = header.to_str() {
+ for pair in s.split("; ") {
+ if let Some((k, v)) = pair.split_once('=') {
+ jar.insert(k.to_string(), json!(v));
+ }
+ }
+ }
+ }
+ }
+ if !cross_origin {
+ for (k, v) in &opts.cookies {
+ jar.insert(k.clone(), json!(v));
+ }
+ }
+ // Server-set cookies from earlier hops to this same host override the
+ // caller's on a name collision — that's what a cookie jar does.
+ if let Some(set) = hop_cookies.get(&target.hostname) {
+ for (k, v) in set {
+ jar.insert(k.clone(), v.clone());
+ }
+ }
+ if !jar.is_empty() {
+ let jar = jar
+ .iter()
+ .map(|(k, v)| format!("{k}={}", v.as_str().unwrap_or_default()))
+ .collect::<Vec<_>>()
+ .join("; ");
+ req = req.header(reqwest::header::COOKIE, jar);
+ }
+ if hop == 0 && !opts.params.is_empty() {
+ req = req.query(&opts.params);
+ }
+ if !cross_origin {
+ if let Some((username, password)) = &opts.auth {
+ req = req.basic_auth(username, Some(password));
+ }
+ }
+ // The wrapper forwards data/json for POST, PUT, and DELETE. DELETE
+ // bodies are unusual but explicitly supported by Scrapling.
+ if send_body {
+ match &opts.body {
+ Some(Body::Json(v)) => req = req.json(v),
+ Some(Body::Form(v)) => {
+ let form: Vec<(String, String)> = v
+ .as_object()
+ .map(|m| {
+ m.iter()
+ .map(|(k, val)| {
+ let s = match val {
+ Value::String(s) => s.clone(),
+ other => other.to_string(),
+ };
+ (k.clone(), s)
+ })
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ req = req.form(&form);
+ }
+ None => {}
+ }
+ }
+
+ let resp = req.send().await.map_err(|e| {
+ if e.is_timeout() {
+ format!("timeout after {:?} fetching {current}", opts.timeout)
+ } else {
+ format!("transport error fetching {current}: {e}")
+ }
+ })?;
+
+ let status = resp.status();
+ let headers = resp.headers().clone();
+ for (k, v) in response_cookies(&headers) {
+ hop_cookies
+ .entry(target.hostname.clone())
+ .or_default()
+ .insert(k.clone(), v.clone());
+ cookies.insert(k, v);
+ }
+
+ if opts.follow_redirects && status.is_redirection() {
+ if let Some(loc) = headers
+ .get(reqwest::header::LOCATION)
+ .and_then(|l| l.to_str().ok())
+ {
+ (method, send_body) = redirected_request(status.as_u16(), &method, send_body);
+ current = target
+ .url
+ .join(loc)
+ .map_err(|e| format!("bad redirect target {loc}: {e}"))?
+ .to_string();
+ continue;
+ }
+ }
+
+ let encoding = charset_of(&headers);
+ let final_url = resp.url().to_string();
+ let body = bounded_body(resp, ¤t).await?;
+ let html = decode_body(&body, encoding.as_deref());
+ return Ok(PageData {
+ status: Some(status.as_u16()),
+ url: final_url,
+ headers: flatten_headers(&headers),
+ cookies,
+ encoding,
+ html,
+ captured_xhr: vec![],
+ });
+ }
+ Err(format!(
+ "too many redirects (>{}) starting at {url}",
+ max_redirects
+ ))
+}
+
+/// Fetch one URL, retrying transport failures. HTTP error statuses are NOT
+/// retried — a 404 is an answer, and re-asking produces the same 404 while
+/// costing the caller their timeout budget.
+pub async fn fetch_page(
+ url: &str,
+ opts: &HttpOptions,
+ policy: &SsrfPolicy,
+) -> Result<PageData, String> {
+ if opts.mode == HttpMode::Compat {
+ #[cfg(feature = "scrapling-compat")]
+ {
+ if let Some(session) = opts.compat_session.clone() {
+ return curl_compat::fetch_page_with_session(
+ url.to_string(),
+ opts.clone(),
+ session,
+ )
+ .await;
+ }
+ return curl_compat::fetch_page(url.to_string(), opts.clone()).await;
+ }
+ #[cfg(not(feature = "scrapling-compat"))]
+ {
+ return Err(
+ "browser::fetch compat HTTP engine is not compiled into this binary".to_string(),
+ );
+ }
+ }
+ check_proxy(opts, policy).await?;
+ // `opts.timeout` is per REQUEST; across redirect hops and retries it
+ // multiplies out (3 retries x 31 hops x 30s ≈ 46 minutes by default).
+ // The reference hands `timeout` to curl's CURLOPT_TIMEOUT, which is a
+ // total budget, so bound the whole call too.
+ let budget = opts.timeout * TOTAL_BUDGET_MULTIPLIER;
+ let started = std::time::Instant::now();
+ let deadline = started + budget;
+ let mut last = String::new();
+ let attempts = opts.retries.max(0) as u32;
+ for i in 0..attempts {
+ if started.elapsed() >= budget {
+ return Err(if last.is_empty() {
+ format!("exceeded the total budget of {budget:?} fetching {url}")
+ } else {
+ last
+ });
+ }
+ match attempt(url, opts, policy, deadline).await {
+ Ok(page) => return Ok(page),
+ Err(e) => {
+ // A refused host is a verdict, not a flake: retrying just
+ // repeats the same DNS answer and the same rejection.
+ if e.contains("refusing to dial")
+ || e.contains("is in ")
+ || e.starts_with("scheme not allowed")
+ || e.starts_with("url is not a valid")
+ || e.starts_with("unsupported method")
+ {
+ return Err(e);
+ }
+ last = e;
+ if i + 1 < attempts && !opts.retry_delay.is_zero() {
+ tokio::time::sleep(opts.retry_delay).await;
+ }
+ }
+ }
+ }
+ if attempts == 0 {
+ Err("No active session available.".to_string())
+ } else {
+ Err(last)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::io::{Read, Write};
+ use std::net::TcpListener;
+ use std::sync::mpsc;
+
+ fn options_with_proxy_for_validation(raw: &str) -> HttpOptions {
+ let mut options = HttpOptions::from_payload(&json!({})).unwrap();
+ options.proxy = Some(raw.to_string());
+ options
+ }
+
+ fn read_request(stream: &mut std::net::TcpStream) -> String {
+ let mut request = Vec::new();
+ let mut chunk = [0u8; 4096];
+ let mut expected = None;
+ loop {
+ let read = stream.read(&mut chunk).unwrap();
+ request.extend_from_slice(&chunk[..read]);
+ if expected.is_none() {
+ if let Some(end) = request.windows(4).position(|part| part == b"\r\n\r\n") {
+ let headers = String::from_utf8_lossy(&request[..end]);
+ let length = headers
+ .lines()
+ .find_map(|line| {
+ line.to_ascii_lowercase()
+ .strip_prefix("content-length:")
+ .and_then(|value| value.trim().parse::<usize>().ok())
+ })
+ .unwrap_or(0);
+ expected = Some(end + 4 + length);
+ }
+ }
+ if read == 0 || expected.is_some_and(|length| request.len() >= length) {
+ break;
+ }
+ }
+ String::from_utf8(request).unwrap()
+ }
+
+ fn safe_server() -> (String, mpsc::Receiver<String>) {
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let address = listener.local_addr().unwrap();
+ let (sender, receiver) = mpsc::channel();
+ std::thread::spawn(move || {
+ let (mut stream, _) = listener.accept().unwrap();
+ sender.send(read_request(&mut stream)).unwrap();
+ stream
+ .write_all(
+ b"HTTP/1.1 200 OK\r\nContent-Type: text/plain; charset=utf-8\r\nTransfer-Encoding: chunked\r\nConnection: close\r\n\r\n2\r\nhe\r\n3\r\nllo\r\n0\r\n\r\n",
+ )
+ .unwrap();
+ });
+ (format!("http://{address}/safe"), receiver)
+ }
+
+ #[test]
+ fn method_defaults_to_get_and_rejects_unknown() {
+ assert_eq!(HttpOptions::from_payload(&json!({})).unwrap().method, "get");
+ assert_eq!(
+ HttpOptions::from_payload(&json!({"method": "POST"}))
+ .unwrap()
+ .method,
+ "post"
+ );
+ assert_eq!(
+ HttpOptions::from_payload(&json!({"method": "patch"})).unwrap_err(),
+ "unsupported method: patch"
+ );
+ }
+
+ #[test]
+ fn safe_mode_refuses_network_options_it_cannot_enforce() {
+ let cases = [
+ (json!({"http3": true}), "http3"),
+ (json!({"verify": false}), "verify:false"),
+ (json!({"proxy": "http://proxy.test"}), "proxy"),
+ (
+ json!({"proxies": {"https": "http://proxy.test"}}),
+ "proxies",
+ ),
+ (json!({"proxy_auth": ["u", "p"]}), "proxy_auth"),
+ (json!({"stealthy_headers": true}), "stealthy_headers:true"),
+ ];
+ for (payload, option) in cases {
+ let error = HttpOptions::from_payload_for_mode(&payload, HttpMode::Safe).unwrap_err();
+ assert!(error.contains(option), "{option}: {error}");
+ }
+ assert!(HttpOptions::from_payload_for_mode(
+ &json!({"impersonate": "chrome"}),
+ HttpMode::Safe
+ )
+ .is_ok());
+ assert!(HttpOptions::from_payload_for_mode(
+ &json!({"impersonate": "firefox"}),
+ HttpMode::Safe
+ )
+ .unwrap_err()
+ .contains("impersonate"));
+ }
+
+ #[test]
+ fn ordered_fields_and_basic_auth_are_preserved() {
+ let options = HttpOptions::from_payload_for_mode(
+ &json!({
+ "headers": {"x-second": "2", "x-first": "1"},
+ "params": {"z": "last", "a": [1, 2]},
+ "cookies": {"second": "2", "first": "1"},
+ "auth": ["user", "pass"]
+ }),
+ HttpMode::Safe,
+ )
+ .unwrap();
+ assert_eq!(options.headers[0], ("x-second".into(), "2".into()));
+ assert_eq!(options.headers[1], ("x-first".into(), "1".into()));
+ assert_eq!(options.params[0], ("z".into(), "last".into()));
+ assert_eq!(options.params[1], ("a".into(), "1".into()));
+ assert_eq!(options.params[2], ("a".into(), "2".into()));
+ assert_eq!(options.cookies[0], ("second".into(), "2".into()));
+ assert_eq!(options.auth, Some(("user".into(), "pass".into())));
+ }
+
+ #[test]
+ fn params_match_curl_cffi_json_and_doseq_coercion() {
+ let options = HttpOptions::from_payload(&json!({
+ "params": {
+ "bool": true,
+ "none": null,
+ "obj": {"a": 1},
+ "arr": [true, null, {"z": 2}]
+ }
+ }))
+ .unwrap();
+ assert_eq!(
+ options.params,
+ vec![
+ ("bool".into(), "true".into()),
+ ("none".into(), "None".into()),
+ ("obj".into(), r#"{"a": 1}"#.into()),
+ ("arr".into(), "True".into()),
+ ("arr".into(), "None".into()),
+ ("arr".into(), "{'z': 2}".into()),
+ ]
+ );
+ }
+
+ #[test]
+ fn delete_accepts_the_same_body_inputs_as_post_and_put() {
+ let options = HttpOptions::from_payload_for_mode(
+ &json!({"method": "delete", "json": {"delete": true}}),
+ HttpMode::Safe,
+ )
+ .unwrap();
+ assert!(matches!(options.body, Some(Body::Json(_))));
+ assert!(options.method_allows_body());
+ }
+
+ #[test]
+ fn safe_refuses_unlimited_redirects_while_compat_preserves_minus_one() {
+ let error =
+ HttpOptions::from_payload_for_mode(&json!({"max_redirects": -1}), HttpMode::Safe)
+ .unwrap_err();
+ assert!(error.contains("max_redirects:-1"), "{error}");
+
+ let options =
+ HttpOptions::from_payload_for_mode(&json!({"max_redirects": -1}), HttpMode::Compat);
+ if cfg!(feature = "scrapling-compat") {
+ assert_eq!(options.unwrap().max_redirects, -1);
+ } else {
+ assert!(options.unwrap_err().contains("not compiled"));
+ }
+ }
+
+ #[cfg(feature = "scrapling-compat")]
+ #[test]
+ fn compat_option_errors_match_the_wrapper_oracle() {
+ assert_eq!(
+ HttpOptions::from_payload_for_mode(
+ &json!({"proxy": "http://a", "proxies": {"http": "http://b"}}),
+ HttpMode::Compat,
+ )
+ .unwrap_err(),
+ "Cannot specify both 'proxy' and 'proxies'"
+ );
+ assert_eq!(
+ HttpOptions::from_payload_for_mode(&json!({"auth": ["u"]}), HttpMode::Compat)
+ .unwrap_err(),
+ "not enough values to unpack (expected 2, got 1)"
+ );
+ }
+
+ #[test]
+ fn timeout_is_seconds_on_this_tier() {
+ let o = HttpOptions::from_payload(&json!({"timeout": 2.5})).unwrap();
+ assert_eq!(o.timeout, Duration::from_millis(2500));
+ // default 30s, and a nonsense value falls back rather than becoming 0
+ assert_eq!(
+ HttpOptions::from_payload(&json!({})).unwrap().timeout,
+ Duration::from_secs(30)
+ );
+ assert_eq!(
+ HttpOptions::from_payload(&json!({"timeout": 0}))
+ .unwrap()
+ .timeout,
+ Duration::from_secs(30)
+ );
+ }
+
+ #[test]
+ fn retries_preserve_zero_attempt_quirk() {
+ assert_eq!(HttpOptions::from_payload(&json!({})).unwrap().retries, 3);
+ assert_eq!(
+ HttpOptions::from_payload(&json!({"retries": 0}))
+ .unwrap()
+ .retries,
+ 0
+ );
+ }
+
+ #[cfg(feature = "scrapling-compat")]
+ #[test]
+ fn compat_preserves_signed_curl_values_and_retry_quirks() {
+ let timeout = HttpOptions::from_payload_for_mode(
+ &json!({"timeout": -1, "retries": 1, "stealthy_headers": false}),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(timeout.compat_timeout_ms, -1000);
+
+ let redirects = HttpOptions::from_payload_for_mode(
+ &json!({"max_redirects": -2, "retries": 1, "stealthy_headers": false}),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(redirects.max_redirects, -2);
+
+ let retries = HttpOptions::from_payload_for_mode(
+ &json!({"retries": -1, "stealthy_headers": false}),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(retries.retries, -1);
+
+ let delay = HttpOptions::from_payload_for_mode(
+ &json!({"retry_delay": -1, "stealthy_headers": false}),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert!(delay.retry_delay_negative);
+ }
+
+ #[cfg(feature = "scrapling-compat")]
+ #[test]
+ fn compat_does_not_silently_replace_explicit_empty_impersonation() {
+ let generated =
+ HttpOptions::from_payload_for_mode(&json!({"impersonate": ""}), HttpMode::Compat)
+ .unwrap();
+ assert_eq!(generated.impersonate, None);
+ assert!(generated
+ .headers
+ .iter()
+ .any(|(name, value)| name == "referer" && value == "https://www.google.com/"));
+ assert!(generated
+ .headers
+ .iter()
+ .any(|(name, value)| name == "User-Agent" && value.contains("Mozilla/5.0")));
+
+ let without_stealth = HttpOptions::from_payload_for_mode(
+ &json!({"impersonate": "", "stealthy_headers": false}),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(without_stealth.impersonate, None);
+ assert_eq!(
+ without_stealth.headers,
+ vec![(
+ "User-Agent".into(),
+ crate::scrapling::browserforge::default_user_agent().unwrap()
+ )]
+ );
+ }
+
+ #[test]
+ fn stealthy_headers_fill_defaults_but_never_override_caller() {
+ let o = HttpOptions::from_payload(&json!({"headers": {"User-Agent": "mine"}})).unwrap();
+ assert_eq!(o.headers[0], ("User-Agent".into(), "mine".into()));
+ assert!(
+ !o.headers.iter().any(|(name, _)| name == "user-agent"),
+ "must not add a second, case-variant UA header"
+ );
+ assert!(o.headers.iter().any(|(name, _)| name == "accept"));
+
+ let off = HttpOptions::from_payload(&json!({"stealthy_headers": false})).unwrap();
+ assert!(off.headers.is_empty());
+ }
+
+ #[test]
+ fn json_body_wins_over_data_and_only_on_post_put() {
+ let o = HttpOptions::from_payload(&json!({"json": {"a": 1}, "data": {"b": 2}})).unwrap();
+ assert!(matches!(o.body, Some(Body::Json(_))));
+ }
+
+ #[test]
+ fn charset_parsed_from_content_type() {
+ let mut h = reqwest::header::HeaderMap::new();
+ h.insert(
+ reqwest::header::CONTENT_TYPE,
+ "text/html; charset=ISO-8859-1".parse().unwrap(),
+ );
+ assert_eq!(charset_of(&h).as_deref(), Some("iso-8859-1"));
+ assert_eq!(charset_of(&reqwest::header::HeaderMap::new()), None);
+ }
+
+ #[test]
+ fn streamed_body_limit_is_checked_even_without_content_length() {
+ assert_eq!(
+ checked_body_len(MAX_BODY_BYTES - 1, 1),
+ Some(MAX_BODY_BYTES)
+ );
+ assert_eq!(checked_body_len(MAX_BODY_BYTES, 1), None);
+ assert_eq!(checked_body_len(usize::MAX, 1), None);
+ }
+
+ #[test]
+ fn set_cookie_headers_flatten_to_name_value() {
+ let mut h = reqwest::header::HeaderMap::new();
+ h.append(
+ reqwest::header::SET_COOKIE,
+ "sid=abc; Path=/; HttpOnly".parse().unwrap(),
+ );
+ h.append(
+ reqwest::header::SET_COOKIE,
+ "theme=dark; Max-Age=60".parse().unwrap(),
+ );
+ let c = response_cookies(&h);
+ assert_eq!(c.get("sid").unwrap(), &json!("abc"));
+ assert_eq!(c.get("theme").unwrap(), &json!("dark"));
+ }
+
+ #[test]
+ fn absurd_durations_are_clamped_not_panicked_on() {
+ // `Duration::from_secs_f64` panics on an unrepresentable value, and
+ // the SDK spawns handlers detached — so a panic here would drop the
+ // invocation and hang the caller with no result at all.
+ for v in [1e20, f64::MAX, 1e308] {
+ let o = HttpOptions::from_payload(&json!({"timeout": v, "retry_delay": v})).unwrap();
+ assert!(o.timeout <= Duration::from_secs_f64(MAX_TIMEOUT_SECS));
+ assert!(o.retry_delay <= Duration::from_secs_f64(MAX_RETRY_DELAY_SECS));
+ }
+ // NaN and infinity fall back to the default rather than clamping.
+ let o = HttpOptions::from_payload(&json!({"timeout": f64::NAN})).unwrap();
+ assert_eq!(o.timeout, Duration::from_secs(30));
+ }
+
+ #[test]
+ fn sensitive_headers_are_recognised_case_insensitively() {
+ for h in [
+ "Authorization",
+ "authorization",
+ "COOKIE",
+ "Proxy-Authorization",
+ ] {
+ assert!(is_sensitive_header(h), "{h} must be treated as sensitive");
+ }
+ for h in ["accept", "user-agent", "x-custom"] {
+ assert!(!is_sensitive_header(h));
+ }
+ }
+
+ #[test]
+ fn same_origin_compares_scheme_host_and_effective_port() {
+ let u = |s: &str| url::Url::parse(s).unwrap();
+ assert!(same_origin(&u("https://a.test/x"), &u("https://a.test/y")));
+ // default port is the same origin as the explicit one
+ assert!(same_origin(
+ &u("https://a.test/"),
+ &u("https://a.test:443/")
+ ));
+ assert!(!same_origin(&u("https://a.test/"), &u("http://a.test/")));
+ assert!(!same_origin(&u("https://a.test/"), &u("https://b.test/")));
+ assert!(!same_origin(
+ &u("https://a.test/"),
+ &u("https://a.test:8443/")
+ ));
+ }
+
+ #[test]
+ fn redirect_method_and_body_rules_match_curl() {
+ for status in 301..=303 {
+ assert_eq!(
+ redirected_request(status, "post", true),
+ ("get".into(), false)
+ );
+ for method in ["put", "delete"] {
+ assert_eq!(
+ redirected_request(status, method, true),
+ (method.into(), false)
+ );
+ }
+ }
+ for status in [307, 308] {
+ for method in ["post", "put", "delete"] {
+ assert_eq!(
+ redirected_request(status, method, true),
+ (method.into(), true)
+ );
+ }
+ }
+ }
+
+ #[tokio::test]
+ async fn cross_origin_redirect_drops_credentials_body_and_initial_query() {
+ let destination = TcpListener::bind("127.0.0.1:0").unwrap();
+ let destination_address = destination.local_addr().unwrap();
+ let origin = TcpListener::bind("127.0.0.1:0").unwrap();
+ let origin_address = origin.local_addr().unwrap();
+ let (sender, requests) = mpsc::channel();
+
+ let first_sender = sender.clone();
+ std::thread::spawn(move || {
+ let (mut stream, _) = origin.accept().unwrap();
+ first_sender.send(read_request(&mut stream)).unwrap();
+ write!(
+ stream,
+ "HTTP/1.1 302 Found\r\nLocation: http://{destination_address}/end\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
+ )
+ .unwrap();
+ });
+ std::thread::spawn(move || {
+ let (mut stream, _) = destination.accept().unwrap();
+ sender.send(read_request(&mut stream)).unwrap();
+ stream
+ .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+ .unwrap();
+ });
+
+ let options = HttpOptions::from_payload(&json!({
+ "method": "post",
+ "data": {"a": "b"},
+ "params": {"q": 1},
+ "auth": ["u", "p"],
+ "cookies": {"sid": "x"},
+ "headers": {"X-Test": "kept"},
+ "follow_redirects": true,
+ "retries": 1,
+ "stealthy_headers": false
+ }))
+ .unwrap();
+ let page = fetch_page(
+ &format!("http://{origin_address}/start"),
+ &options,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap();
+
+ let first = requests.recv().unwrap();
+ assert!(first.starts_with("POST /start?q=1 HTTP/1.1\r\n"), "{first}");
+ assert!(first
+ .to_ascii_lowercase()
+ .contains("authorization: basic dtpw"));
+ assert!(first.to_ascii_lowercase().contains("cookie: sid=x"));
+ assert!(first.ends_with("a=b"), "{first}");
+
+ let second = requests.recv().unwrap();
+ let lower = second.to_ascii_lowercase();
+ assert!(second.starts_with("GET /end HTTP/1.1\r\n"), "{second}");
+ assert!(!lower.contains("authorization:"), "{second}");
+ assert!(!lower.contains("cookie:"), "{second}");
+ assert!(lower.contains("x-test: kept"), "{second}");
+ assert!(!second.contains("?q=1"), "{second}");
+ assert_eq!(page.html, "ok");
+ }
+
+ #[tokio::test]
+ async fn redirect_to_metadata_is_refused_before_the_second_request() {
+ let origin = TcpListener::bind("127.0.0.1:0").unwrap();
+ let origin_address = origin.local_addr().unwrap();
+ std::thread::spawn(move || {
+ let (mut stream, _) = origin.accept().unwrap();
+ let _ = read_request(&mut stream);
+ stream
+ .write_all(
+ b"HTTP/1.1 302 Found\r\nLocation: http://169.254.169.254/latest/meta-data/\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
+ )
+ .unwrap();
+ });
+ let options = HttpOptions::from_payload(&json!({
+ "follow_redirects": true,
+ "retries": 3,
+ "retry_delay": 0,
+ "stealthy_headers": false
+ }))
+ .unwrap();
+ let error = fetch_page(
+ &format!("http://{origin_address}/redirect"),
+ &options,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap_err();
+ assert!(error.contains("link-local"), "{error}");
+ }
+
+ #[tokio::test]
+ async fn a_private_proxy_is_refused_before_any_request() {
+ // The proxy is the address this worker actually dials, so validating
+ // only the (public) target would let an internal proxy be used as a
+ // pivot into the private network.
+ let opts = options_with_proxy_for_validation("http://169.254.169.254:3128");
+ let err = check_proxy(
+ &opts,
+ &SsrfPolicy {
+ allow_loopback: false,
+ },
+ )
+ .await
+ .unwrap_err();
+ assert!(err.starts_with("proxy refused:"), "got: {err}");
+ assert!(err.contains("link-local"), "got: {err}");
+ }
+
+ #[tokio::test]
+ async fn a_socks_proxy_is_refused_because_its_dns_is_uninspectable() {
+ let opts = options_with_proxy_for_validation("socks5h://127.0.0.1:1080");
+ let err = check_proxy(
+ &opts,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap_err();
+ assert!(err.contains("not a usable http(s) endpoint"), "got: {err}");
+ }
+
+ #[tokio::test]
+ async fn invalid_proxy_errors_do_not_echo_credentials() {
+ let raw = "http://user:pass@[";
+ let opts = options_with_proxy_for_validation(raw);
+ let check_err = check_proxy(
+ &opts,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap_err();
+ assert!(
+ !check_err.contains("user:pass"),
+ "credentials leaked: {check_err}"
+ );
+ assert!(
+ check_err.contains("not a usable http(s) endpoint"),
+ "got: {check_err}"
+ );
+
+ let build_err =
+ match build_client("example.com", SocketAddr::from(([1, 1, 1, 1], 443)), &opts) {
+ Ok(_) => panic!("invalid proxy unexpectedly built a client"),
+ Err(error) => error,
+ };
+ assert!(
+ !build_err.contains("user:pass"),
+ "credentials leaked: {build_err}"
+ );
+ assert!(build_err.contains("invalid proxy"), "got: {build_err}");
+ }
+
+ #[tokio::test]
+ async fn no_proxy_configured_is_not_an_error() {
+ let opts = HttpOptions::from_payload(&json!({})).unwrap();
+ assert!(check_proxy(
+ &opts,
+ &SsrfPolicy {
+ allow_loopback: false
+ }
+ )
+ .await
+ .is_ok());
+ }
+
+ #[tokio::test]
+ async fn a_public_proxy_passes_the_check() {
+ let opts = options_with_proxy_for_validation("http://1.1.1.1:8080");
+ assert!(check_proxy(
+ &opts,
+ &SsrfPolicy {
+ allow_loopback: false
+ }
+ )
+ .await
+ .is_ok());
+ }
+
+ #[tokio::test]
+ async fn ssrf_rejection_is_not_retried_and_names_the_range() {
+ let opts = HttpOptions::from_payload(&json!({"retries": 3, "retry_delay": 0})).unwrap();
+ let policy = SsrfPolicy {
+ allow_loopback: false,
+ };
+ let err = fetch_page("http://169.254.169.254/latest/meta-data/", &opts, &policy)
+ .await
+ .unwrap_err();
+ assert!(err.contains("link-local"), "got: {err}");
+ }
+
+ #[tokio::test]
+ async fn safe_engine_streams_unknown_length_and_sends_delete_body() {
+ let (url, request) = safe_server();
+ let options = HttpOptions::from_payload(&json!({
+ "method": "delete",
+ "json": {"delete": true},
+ "stealthy_headers": false,
+ "retries": 1
+ }))
+ .unwrap();
+ let page = fetch_page(
+ &url,
+ &options,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap();
+ let raw = request.recv().unwrap();
+ assert!(raw.starts_with("DELETE /safe HTTP/1.1\r\n"), "{raw}");
+ assert!(raw.ends_with("{\"delete\":true}"), "{raw}");
+ assert_eq!(page.html, "hello");
+ }
+
+ #[tokio::test]
+ async fn fetches_a_real_page_over_the_wire() {
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let address = listener.local_addr().unwrap();
+ std::thread::spawn(move || {
+ let (mut stream, _) = listener.accept().unwrap();
+ let mut request = [0; 4096];
+ let _ = stream.read(&mut request).unwrap();
+ let body = b"<html><body><h1>Example Domain</h1></body></html>";
+ write!(
+ stream,
+ "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+ body.len()
+ )
+ .unwrap();
+ stream.write_all(body).unwrap();
+ });
+ let url = format!("http://{address}/");
+ let opts = HttpOptions::from_payload(&json!({"stealthy_headers": false})).unwrap();
+ let page = fetch_page(
+ &url,
+ &opts,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .expect("hermetic origin should be reachable");
+
+ assert_eq!(page.status, Some(200));
+ assert_eq!(page.url, url);
+ assert_eq!(
+ page.html,
+ "<html><body><h1>Example Domain</h1></body></html>"
+ );
+ assert_eq!(page.headers["content-type"], "text/html; charset=utf-8");
+
+ // And the shared envelope on top of it: inline extraction + render.
+ let out = crate::scrapling::page::serialize_page(
+ &page,
+ &json!({"selectors": [{"name": "title", "css": "h1"}], "format": "text"}),
+ false,
+ )
+ .unwrap();
+ assert_eq!(out["extracted"]["title"], json!("Example Domain"));
+ assert_eq!(out["status"], json!(200));
+ assert_eq!(out["content"], "Example Domain");
+ }
+
+ #[tokio::test]
+ async fn non_http_scheme_refused() {
+ let opts = HttpOptions::from_payload(&json!({})).unwrap();
+ let err = fetch_page(
+ "file:///etc/passwd",
+ &opts,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap_err();
+ assert!(err.contains("scheme not allowed"), "got: {err}");
+ }
+}
diff --git a/browser/src/scrapling/fetch/curl_compat.rs b/browser/src/scrapling/fetch/curl_compat.rs
new file mode 100644
index 000000000..30316b671
--- /dev/null
+++ b/browser/src/scrapling/fetch/curl_compat.rs
@@ -0,0 +1,961 @@
+use std::collections::HashMap;
+use std::ffi::{c_char, c_long, c_void, CStr, CString};
+use std::ptr;
+use std::sync::{Arc, Mutex, OnceLock};
+
+use curl_impersonate_sys as curl;
+use serde_json::{Map, Value};
+
+use super::{charset_of_raw, python_scalar, Body, HttpOptions};
+use crate::scrapling::page::PageData;
+
+static GLOBAL: OnceLock<Result<(), String>> = OnceLock::new();
+
+fn global_init() -> Result<(), String> {
+ GLOBAL
+ .get_or_init(|| {
+ let code = unsafe { curl::curl_global_init(curl::CURL_GLOBAL_DEFAULT) };
+ if code == curl::CURLE_OK {
+ Ok(())
+ } else {
+ Err(format!("curl_global_init failed with code {code}"))
+ }
+ })
+ .clone()
+}
+
+#[derive(Debug)]
+struct Easy(*mut curl::CURL);
+
+// libcurl permits moving an easy handle between threads as long as only one
+// thread uses it at a time. CompatSession's mutex provides that exclusion.
+unsafe impl Send for Easy {}
+
+impl Easy {
+ fn new() -> Result<Self, String> {
+ global_init()?;
+ let handle = unsafe { curl::curl_easy_init() };
+ if handle.is_null() {
+ Err("curl_easy_init returned null".to_string())
+ } else {
+ Ok(Self(handle))
+ }
+ }
+}
+
+impl Drop for Easy {
+ fn drop(&mut self) {
+ unsafe { curl::curl_easy_cleanup(self.0) };
+ }
+}
+
+#[derive(Debug)]
+struct SessionState {
+ easy: Easy,
+ cookies: Vec<String>,
+}
+
+impl SessionState {
+ fn new() -> Result<Self, String> {
+ Ok(Self {
+ easy: Easy::new()?,
+ cookies: Vec::new(),
+ })
+ }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct CompatSession(Arc<Mutex<SessionState>>);
+
+impl CompatSession {
+ pub(crate) fn new() -> Result<Self, String> {
+ SessionState::new().map(|state| Self(Arc::new(Mutex::new(state))))
+ }
+}
+
+struct Slist(*mut curl::curl_slist);
+
+impl Slist {
+ fn new() -> Self {
+ Self(ptr::null_mut())
+ }
+
+ fn append(&mut self, value: &CString) -> Result<(), String> {
+ let next = unsafe { curl::curl_slist_append(self.0, value.as_ptr()) };
+ if next.is_null() {
+ Err("curl_slist_append ran out of memory".to_string())
+ } else {
+ self.0 = next;
+ Ok(())
+ }
+ }
+}
+
+impl Drop for Slist {
+ fn drop(&mut self) {
+ if !self.0.is_null() {
+ unsafe { curl::curl_slist_free_all(self.0) };
+ }
+ }
+}
+
+#[derive(Default)]
+struct Transfer {
+ body: Vec<u8>,
+ headers: Vec<u8>,
+}
+
+unsafe extern "C" fn write_body(
+ data: *mut c_char,
+ size: usize,
+ count: usize,
+ userdata: *mut c_void,
+) -> usize {
+ let Some(length) = size.checked_mul(count) else {
+ return 0;
+ };
+ let transfer = &mut *(userdata.cast::<Transfer>());
+ transfer
+ .body
+ .extend_from_slice(std::slice::from_raw_parts(data.cast::<u8>(), length));
+ length
+}
+
+unsafe extern "C" fn write_header(
+ data: *mut c_char,
+ size: usize,
+ count: usize,
+ userdata: *mut c_void,
+) -> usize {
+ let Some(length) = size.checked_mul(count) else {
+ return 0;
+ };
+ let transfer = &mut *(userdata.cast::<Transfer>());
+ transfer
+ .headers
+ .extend_from_slice(std::slice::from_raw_parts(data.cast::<u8>(), length));
+ length
+}
+
+unsafe fn set_long(easy: &Easy, option: curl::CURLoption, value: c_long) -> Result<(), String> {
+ code(curl::curl_easy_setopt(easy.0, option, value))
+}
+
+unsafe fn set_ptr(easy: &Easy, option: curl::CURLoption, value: *mut c_void) -> Result<(), String> {
+ code(curl::curl_easy_setopt(easy.0, option, value))
+}
+
+unsafe fn set_str(easy: &Easy, option: curl::CURLoption, value: &CString) -> Result<(), String> {
+ code(curl::curl_easy_setopt(easy.0, option, value.as_ptr()))
+}
+
+fn code(value: curl::CURLcode) -> Result<(), String> {
+ if value == curl::CURLE_OK {
+ Ok(())
+ } else {
+ let detail = unsafe { CStr::from_ptr(curl::curl_easy_strerror(value)) }.to_string_lossy();
+ Err(format!("curl: ({value}) {detail}"))
+ }
+}
+
+fn impersonation_alias(value: &str) -> &str {
+ match value {
+ "chrome" => "chrome146",
+ "edge" => "edge101",
+ "safari" | "safari_beta" => "safari2601",
+ "safari_ios" | "safari_ios_beta" => "safari260_ios",
+ "chrome_android" => "chrome131_android",
+ "firefox" => "firefox147",
+ "tor" => "tor145",
+ other => other,
+ }
+}
+
+fn request_url(url: &str, params: &[(String, String)]) -> Result<CString, String> {
+ let mut parsed = url::Url::parse(url).map_err(|error| error.to_string())?;
+ let mut merged: Vec<(String, String)> = parsed
+ .query_pairs()
+ .map(|(name, value)| (name.into_owned(), value.into_owned()))
+ .collect();
+ let mut old_counts = HashMap::new();
+ let mut new_counts = HashMap::new();
+ for (name, _) in &merged {
+ *old_counts.entry(name.clone()).or_insert(0usize) += 1;
+ }
+ for (name, _) in params {
+ *new_counts.entry(name.clone()).or_insert(0usize) += 1;
+ }
+ for (name, value) in params {
+ if old_counts.get(name.as_str()) == Some(&1) && new_counts.get(name.as_str()) == Some(&1) {
+ if let Some(existing) = merged.iter_mut().find(|(key, _)| key == name) {
+ existing.1 = value.clone();
+ continue;
+ }
+ }
+ merged.push((name.clone(), value.clone()));
+ }
+ if !params.is_empty() {
+ parsed.query_pairs_mut().clear().extend_pairs(merged.iter());
+ }
+ CString::new(parsed.as_str()).map_err(|_| "URL contains a NUL byte".to_string())
+}
+
+fn selected_proxy<'a>(url: &str, options: &'a HttpOptions) -> Option<&'a str> {
+ if let Some(proxy) = options.proxy.as_deref() {
+ return Some(proxy);
+ }
+ let parsed = url::Url::parse(url).ok()?;
+ let scheme = parsed.scheme();
+ let host = parsed.host_str();
+ let lookup = |wanted: &str| {
+ options
+ .proxies
+ .iter()
+ .find(|(key, _)| key == wanted)
+ .map(|(_, value)| value.as_str())
+ };
+ if let Some(host) = host {
+ if let Some(proxy) =
+ lookup(&format!("{scheme}://{host}")).or_else(|| lookup(&format!("all://{host}")))
+ {
+ return Some(proxy);
+ }
+ }
+ lookup(scheme).or_else(|| lookup("all"))
+}
+
+fn body_bytes(body: &Body) -> Result<(Vec<u8>, &'static str), String> {
+ match body {
+ Body::Json(value) => serde_json::to_vec(value)
+ .map(|bytes| (bytes, "application/json"))
+ .map_err(|error| error.to_string()),
+ Body::Form(Value::Object(values)) => {
+ let mut serializer = url::form_urlencoded::Serializer::new(String::new());
+ for (name, value) in values {
+ serializer.append_pair(name, &python_scalar(value));
+ }
+ Ok((
+ serializer.finish().into_bytes(),
+ "application/x-www-form-urlencoded",
+ ))
+ }
+ Body::Form(value) => Ok((
+ python_scalar(value).into_bytes(),
+ "application/octet-stream",
+ )),
+ }
+}
+
+fn response_headers(raw: &[u8]) -> Map<String, Value> {
+ let text = String::from_utf8_lossy(raw);
+ let block = text
+ .rsplit("\r\n\r\n")
+ .find(|block| block.starts_with("HTTP/"))
+ .unwrap_or("");
+ let mut headers = Map::new();
+ for line in block.lines().skip(1) {
+ if let Some((name, value)) = line.split_once(':') {
+ let name = name.trim().to_ascii_lowercase();
+ let value = value.trim();
+ if let Some(existing) = headers.get(&name).and_then(Value::as_str) {
+ let combined = format!("{existing}, {value}");
+ headers.insert(name, combined.into());
+ } else {
+ headers.insert(name, value.into());
+ }
+ }
+ }
+ headers
+}
+
+fn response_cookies(raw: &[u8]) -> Map<String, Value> {
+ let mut cookies = Map::new();
+ let text = String::from_utf8_lossy(raw);
+ let block = text
+ .rsplit("\r\n\r\n")
+ .find(|block| block.starts_with("HTTP/"))
+ .unwrap_or("");
+ for line in block.lines().skip(1) {
+ // Header names are case-insensitive; match any casing, not just the
+ // two common spellings.
+ let Some(value) = line
+ .split_once(':')
+ .filter(|(name, _)| name.eq_ignore_ascii_case("set-cookie"))
+ .map(|(_, value)| value)
+ else {
+ continue;
+ };
+ if let Some((name, value)) = value.trim().split(';').next().unwrap_or("").split_once('=') {
+ cookies.insert(name.trim().to_string(), value.trim().into());
+ }
+ }
+ cookies
+}
+
+fn cookie_key(line: &str) -> Option<(&str, &str, &str)> {
+ let fields = line.split('\t').collect::<Vec<_>>();
+ (fields.len() == 7).then(|| (fields[0], fields[2], fields[5]))
+}
+
+fn apply_cookie_changes(cookies: &mut Vec<String>, changes: *mut curl::curl_slist) {
+ let mut current = changes;
+ while !current.is_null() {
+ let raw = unsafe { CStr::from_ptr((*current).data) }.to_string_lossy();
+ if let Some((action, value)) = raw.split_once('\t') {
+ if let Some(key) = cookie_key(value) {
+ cookies.retain(|existing| cookie_key(existing) != Some(key));
+ if action == "SET" {
+ cookies.push(value.to_string());
+ }
+ }
+ }
+ current = unsafe { (*current).next };
+ }
+ if !changes.is_null() {
+ unsafe { curl::curl_slist_free_all(changes) };
+ }
+}
+
+fn request_cookie_lines(url: &str, options: &HttpOptions) -> Result<Vec<CString>, String> {
+ let parsed = url::Url::parse(url).map_err(|error| error.to_string())?;
+ let mut host = parsed
+ .host_str()
+ .ok_or_else(|| "URL has no host".to_string())?
+ .to_ascii_lowercase();
+ if !host.contains('.') && host.parse::<std::net::Ipv4Addr>().is_err() {
+ host.push_str(".local");
+ }
+ options
+ .cookies
+ .iter()
+ .map(|(name, value)| {
+ CString::new(format!("{host}\tFALSE\t/\tFALSE\t0\t{name}\t{value}"))
+ .map_err(|_| "cookie contains a NUL byte".to_string())
+ })
+ .collect()
+}
+
+fn one_attempt(
+ url: &str,
+ options: &HttpOptions,
+ session: &mut SessionState,
+) -> Result<PageData, String> {
+ // curl-cffi reports setopt failures with the option number, caller value,
+ // and libcurl's option hex. Keep these validations ahead of handle setup
+ // so the Rust binding has the same deterministic error without relying on
+ // undefined behavior at the variadic FFI boundary.
+ if options.compat_timeout_ms < 0 {
+ return Err(format!(
+ "Failed to setopt 155 {}, curl: (43) setopt 0x9b got bad argument. See https://curl.se/libcurl/c/libcurl-errors.html first for more details.",
+ options.compat_timeout_ms
+ ));
+ }
+ if options.max_redirects < -1 {
+ return Err(format!(
+ "Failed to setopt 68 {}, curl: (43) setopt 0x44 got bad argument. See https://curl.se/libcurl/c/libcurl-errors.html first for more details.",
+ options.max_redirects
+ ));
+ }
+ let easy = &session.easy;
+ unsafe { curl::curl_easy_reset(easy.0) };
+ let final_url = request_url(url, &options.params)?;
+ let mut keepalive = vec![final_url.clone()];
+ let mut transfer = Transfer::default();
+ let mut error_buffer = [0u8; 256];
+
+ unsafe {
+ set_str(easy, curl::CURLOPT_URL, &final_url)?;
+ set_long(easy, curl::CURLOPT_NOSIGNAL, 1)?;
+ set_long(
+ easy,
+ curl::CURLOPT_TIMEOUT_MS,
+ options.compat_timeout_ms as c_long,
+ )?;
+ set_long(
+ easy,
+ curl::CURLOPT_FOLLOWLOCATION,
+ options.compat_follow_redirects as c_long,
+ )?;
+ set_long(
+ easy,
+ curl::CURLOPT_MAXREDIRS,
+ options.max_redirects as c_long,
+ )?;
+ let accept_encoding = CString::new("gzip, deflate, br, zstd").unwrap();
+ set_str(easy, curl::CURLOPT_ACCEPT_ENCODING, &accept_encoding)?;
+ keepalive.push(accept_encoding);
+ set_ptr(
+ easy,
+ curl::CURLOPT_ERRORBUFFER,
+ error_buffer.as_mut_ptr().cast(),
+ )?;
+ set_ptr(
+ easy,
+ curl::CURLOPT_WRITEDATA,
+ (&mut transfer as *mut Transfer).cast(),
+ )?;
+ code(curl::curl_easy_setopt(
+ easy.0,
+ curl::CURLOPT_WRITEFUNCTION,
+ write_body as unsafe extern "C" fn(*mut c_char, usize, usize, *mut c_void) -> usize,
+ ))?;
+ set_ptr(
+ easy,
+ curl::CURLOPT_HEADERDATA,
+ (&mut transfer as *mut Transfer).cast(),
+ )?;
+ code(curl::curl_easy_setopt(
+ easy.0,
+ curl::CURLOPT_HEADERFUNCTION,
+ write_header as unsafe extern "C" fn(*mut c_char, usize, usize, *mut c_void) -> usize,
+ ))?;
+ }
+
+ let empty = CString::new("").unwrap();
+ let clear = CString::new("ALL").unwrap();
+ let session_cookies = session
+ .cookies
+ .iter()
+ .map(|value| CString::new(value.as_str()).expect("libcurl cookie lines contain no NUL"))
+ .collect::<Vec<_>>();
+ let request_cookies = request_cookie_lines(url, options)?;
+ unsafe {
+ set_str(easy, curl::CURLOPT_COOKIEFILE, &empty)?;
+ set_str(easy, curl::CURLOPT_COOKIELIST, &clear)?;
+ for cookie in session_cookies.iter().chain(&request_cookies) {
+ set_str(easy, curl::CURLOPT_COOKIELIST, cookie)?;
+ }
+ }
+ keepalive.extend([empty, clear]);
+
+ if let Some(target) = options.impersonate.as_deref() {
+ let target = CString::new(impersonation_alias(target))
+ .map_err(|_| "impersonate contains a NUL byte".to_string())?;
+ let result = unsafe { curl::curl_easy_impersonate(easy.0, target.as_ptr(), 1) };
+ if result != curl::CURLE_OK {
+ return Err(format!(
+ "Impersonating {} is not supported",
+ options.impersonate.as_deref().unwrap_or_default()
+ ));
+ }
+ keepalive.push(target);
+ }
+ unsafe {
+ if options.http3 {
+ set_long(
+ easy,
+ curl::CURLOPT_HTTP_VERSION,
+ curl::CURL_HTTP_VERSION_3ONLY,
+ )?;
+ }
+ set_long(easy, curl::CURLOPT_SSL_VERIFYPEER, options.verify as c_long)?;
+ set_long(
+ easy,
+ curl::CURLOPT_SSL_VERIFYHOST,
+ if options.verify { 2 } else { 0 },
+ )?;
+ }
+
+ for (option, credentials, auth_option) in [
+ (
+ curl::CURLOPT_USERPWD,
+ options.auth.as_ref(),
+ curl::CURLOPT_HTTPAUTH,
+ ),
+ (
+ curl::CURLOPT_PROXYUSERPWD,
+ options.proxy_auth.as_ref(),
+ curl::CURLOPT_PROXYAUTH,
+ ),
+ ] {
+ if let Some((username, password)) = credentials {
+ let value = CString::new(format!("{username}:{password}"))
+ .map_err(|_| "credentials contain a NUL byte".to_string())?;
+ unsafe {
+ set_str(easy, option, &value)?;
+ set_long(easy, auth_option, curl::CURLAUTH_BASIC)?;
+ }
+ keepalive.push(value);
+ }
+ }
+ if let Some(proxy) = selected_proxy(url, options) {
+ let value = CString::new(proxy).map_err(|_| "proxy contains a NUL byte".to_string())?;
+ unsafe { set_str(easy, curl::CURLOPT_PROXY, &value)? };
+ keepalive.push(value);
+ }
+
+ let mut header_values = Vec::new();
+ let mut headers = Slist::new();
+ for (name, value) in &options.headers {
+ let line = if value.is_empty() {
+ format!("{name};")
+ } else {
+ format!("{name}: {value}")
+ };
+ let value = CString::new(line).map_err(|_| format!("header {name} contains a NUL byte"))?;
+ headers.append(&value)?;
+ header_values.push(value);
+ }
+ let expect = CString::new("Expect:").unwrap();
+ headers.append(&expect)?;
+ header_values.push(expect);
+
+ let mut body = None;
+ if options.method_allows_body()
+ && (options.body.is_some() || matches!(options.method.as_str(), "post" | "put"))
+ {
+ let (bytes, content_type) = match &options.body {
+ Some(value) => {
+ let (bytes, content_type) = body_bytes(value)?;
+ (bytes, Some(content_type))
+ }
+ None => (Vec::new(), None),
+ };
+ if let Some(content_type) = content_type {
+ if !options
+ .headers
+ .iter()
+ .any(|(name, _)| name.eq_ignore_ascii_case("content-type"))
+ {
+ let value = CString::new(format!("Content-Type: {content_type}")).unwrap();
+ headers.append(&value)?;
+ header_values.push(value);
+ }
+ }
+ unsafe {
+ set_ptr(
+ easy,
+ curl::CURLOPT_POSTFIELDS,
+ bytes.as_ptr().cast_mut().cast(),
+ )?;
+ set_long(easy, curl::CURLOPT_POSTFIELDSIZE, bytes.len() as c_long)?;
+ }
+ body = Some(bytes);
+ }
+ let method = CString::new(options.method.to_ascii_uppercase()).unwrap();
+ if options.method != "get" {
+ unsafe { set_str(easy, curl::CURLOPT_CUSTOMREQUEST, &method)? };
+ }
+ if !headers.0.is_null() {
+ unsafe { set_ptr(easy, curl::CURLOPT_HTTPHEADER, headers.0.cast())? };
+ }
+
+ let result = unsafe { curl::curl_easy_perform(easy.0) };
+ let mut changes = ptr::null_mut();
+ if unsafe { curl::curl_easy_getinfo(easy.0, curl::CURLINFO_COOKIECHANGES, &mut changes) }
+ == curl::CURLE_OK
+ {
+ apply_cookie_changes(&mut session.cookies, changes);
+ }
+ drop((body, method, header_values, keepalive));
+ if result != curl::CURLE_OK {
+ let detail = error_buffer
+ .split(|byte| *byte == 0)
+ .next()
+ .and_then(|bytes| std::str::from_utf8(bytes).ok())
+ .filter(|value| !value.is_empty())
+ .map(str::to_owned)
+ .unwrap_or_else(|| unsafe {
+ CStr::from_ptr(curl::curl_easy_strerror(result))
+ .to_string_lossy()
+ .into_owned()
+ });
+ return Err(format!(
+ "Failed to perform, curl: ({result}) {detail}. See https://curl.se/libcurl/c/libcurl-errors.html first for more details."
+ ));
+ }
+
+ let mut status = 0 as c_long;
+ let mut effective: *mut c_char = ptr::null_mut();
+ unsafe {
+ code(curl::curl_easy_getinfo(
+ easy.0,
+ curl::CURLINFO_RESPONSE_CODE,
+ &mut status,
+ ))?;
+ code(curl::curl_easy_getinfo(
+ easy.0,
+ curl::CURLINFO_EFFECTIVE_URL,
+ &mut effective,
+ ))?;
+ }
+ let effective = if effective.is_null() {
+ url.to_string()
+ } else {
+ unsafe { CStr::from_ptr(effective) }
+ .to_string_lossy()
+ .into_owned()
+ };
+ let headers = response_headers(&transfer.headers);
+ let encoding = charset_of_raw(&headers).or_else(|| Some("utf-8".to_string()));
+ let html = super::decode_body(&transfer.body, encoding.as_deref());
+ Ok(PageData {
+ status: u16::try_from(status).ok(),
+ url: effective,
+ headers,
+ cookies: response_cookies(&transfer.headers),
+ encoding,
+ html,
+ captured_xhr: vec![],
+ })
+}
+
+fn blocking_fetch_in_session(
+ url: &str,
+ options: &HttpOptions,
+ session: &mut SessionState,
+) -> Result<PageData, String> {
+ let attempts = options.retries.max(0) as usize;
+ if attempts == 0 {
+ return Err("No active session available.".to_string());
+ }
+ let mut last = String::new();
+ for attempt in 0..attempts {
+ match one_attempt(url, options, session) {
+ Ok(page) => return Ok(page),
+ Err(error) => {
+ last = error;
+ if attempt + 1 < attempts && !options.retry_delay.is_zero() {
+ std::thread::sleep(options.retry_delay);
+ } else if attempt + 1 < attempts && options.retry_delay_negative {
+ return Err("sleep length must be non-negative".to_string());
+ }
+ }
+ }
+ }
+ Err(last)
+}
+
+fn blocking_fetch(url: &str, options: &HttpOptions) -> Result<PageData, String> {
+ let mut session = SessionState::new()?;
+ blocking_fetch_in_session(url, options, &mut session)
+}
+
+pub async fn fetch_page(url: String, options: HttpOptions) -> Result<PageData, String> {
+ tokio::task::spawn_blocking(move || blocking_fetch(&url, &options))
+ .await
+ .map_err(|error| format!("curl worker failed: {error}"))?
+}
+
+pub(crate) async fn fetch_page_with_session(
+ url: String,
+ options: HttpOptions,
+ session: CompatSession,
+) -> Result<PageData, String> {
+ tokio::task::spawn_blocking(move || {
+ let mut session = session
+ .0
+ .lock()
+ .map_err(|_| "curl session lock is poisoned".to_string())?;
+ blocking_fetch_in_session(&url, &options, &mut session)
+ })
+ .await
+ .map_err(|error| format!("curl worker failed: {error}"))?
+}
+
+#[cfg(test)]
+mod tests {
+ use std::io::{Read, Write};
+ use std::net::TcpListener;
+ use std::sync::mpsc;
+
+ use serde_json::json;
+
+ use super::*;
+ use crate::scrapling::fetch::HttpMode;
+
+ fn one_request_server() -> (String, mpsc::Receiver<String>) {
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let address = listener.local_addr().unwrap();
+ let (sender, receiver) = mpsc::channel();
+ std::thread::spawn(move || {
+ let (mut stream, _) = listener.accept().unwrap();
+ let mut bytes = Vec::new();
+ let mut chunk = [0u8; 4096];
+ let mut expected = None;
+ loop {
+ let read = stream.read(&mut chunk).unwrap();
+ if read == 0 {
+ break;
+ }
+ bytes.extend_from_slice(&chunk[..read]);
+ if expected.is_none() {
+ if let Some(end) = bytes.windows(4).position(|part| part == b"\r\n\r\n") {
+ let headers = String::from_utf8_lossy(&bytes[..end]);
+ let length = headers
+ .lines()
+ .find_map(|line| {
+ line.to_ascii_lowercase()
+ .strip_prefix("content-length:")
+ .and_then(|value| value.trim().parse::<usize>().ok())
+ })
+ .unwrap_or(0);
+ expected = Some(end + 4 + length);
+ }
+ }
+ if expected.is_some_and(|length| bytes.len() >= length) {
+ break;
+ }
+ }
+ sender.send(String::from_utf8(bytes).unwrap()).unwrap();
+ stream
+ .write_all(
+ b"HTTP/1.1 201 Created\r\nContent-Type: text/plain; charset=iso-8859-1\r\nSet-Cookie: sid=abc; Path=/\r\nContent-Length: 2\r\nConnection: close\r\n\r\nOK",
+ )
+ .unwrap();
+ });
+ (format!("http://{address}/endpoint"), receiver)
+ }
+
+ fn cookie_server(count: usize) -> (String, mpsc::Receiver<String>) {
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let address = listener.local_addr().unwrap();
+ let (sender, receiver) = mpsc::channel();
+ std::thread::spawn(move || {
+ for index in 0..count {
+ let (mut stream, _) = listener.accept().unwrap();
+ let mut request = Vec::new();
+ let mut chunk = [0u8; 4096];
+ while !request.windows(4).any(|part| part == b"\r\n\r\n") {
+ let read = stream.read(&mut chunk).unwrap();
+ request.extend_from_slice(&chunk[..read]);
+ }
+ sender.send(String::from_utf8(request).unwrap()).unwrap();
+ let cookie = if index == 0 {
+ "Set-Cookie: stored=server; Path=/\r\n"
+ } else {
+ ""
+ };
+ write!(
+ stream,
+ "HTTP/1.1 200 OK\r\n{cookie}Content-Length: 2\r\nConnection: close\r\n\r\nok"
+ )
+ .unwrap();
+ }
+ });
+ (format!("http://{address}"), receiver)
+ }
+
+ #[tokio::test]
+ async fn persistent_session_reuses_server_cookies_but_not_request_cookies() {
+ let (base, requests) = cookie_server(3);
+ let session = CompatSession::new().unwrap();
+ let base_options = HttpOptions::from_payload_for_mode(
+ &json!({"impersonate":"", "stealthy_headers":false, "retries":1}),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ fetch_page_with_session(format!("{base}/set"), base_options.clone(), session.clone())
+ .await
+ .unwrap();
+ let mut temporary = base_options.clone();
+ temporary.cookies = vec![("once".to_string(), "request".to_string())];
+ fetch_page_with_session(format!("{base}/temporary"), temporary, session.clone())
+ .await
+ .unwrap();
+ fetch_page_with_session(format!("{base}/again"), base_options, session)
+ .await
+ .unwrap();
+
+ let first = requests.recv().unwrap();
+ let second = requests.recv().unwrap().to_ascii_lowercase();
+ let third = requests.recv().unwrap().to_ascii_lowercase();
+ assert!(!first.to_ascii_lowercase().contains("cookie:"));
+ assert!(second.contains("stored=server"), "{second}");
+ assert!(second.contains("once=request"), "{second}");
+ assert!(third.contains("stored=server"), "{third}");
+ assert!(!third.contains("once=request"), "{third}");
+ }
+
+ #[test]
+ fn compat_sends_delete_body_and_preserves_ordered_inputs() {
+ let (url, request) = one_request_server();
+ let payload = json!({
+ "method": "delete",
+ "json": {"delete": true},
+ "params": {"b": [2, 3], "a": "x"},
+ "headers": {"x-second": "2", "x-first": "1"},
+ "cookies": {"second": "2", "first": "1"},
+ "auth": ["user", "pass"],
+ "impersonate": "chrome136",
+ "stealthy_headers": false,
+ "retries": 1,
+ "include_html": true
+ });
+ let options = HttpOptions::from_payload_for_mode(&payload, HttpMode::Compat).unwrap();
+
+ let page = blocking_fetch(&url, &options).unwrap();
+ let raw = request.recv().unwrap();
+ assert!(
+ raw.starts_with("DELETE /endpoint?b=2&b=3&a=x HTTP/1.1\r\n"),
+ "{raw}"
+ );
+ assert!(raw.ends_with("{\"delete\":true}"), "{raw}");
+ assert!(
+ raw.contains("Authorization: Basic dXNlcjpwYXNz\r\n"),
+ "{raw}"
+ );
+ assert!(raw.contains("Cookie: second=2; first=1\r\n"), "{raw}");
+ assert!(raw.find("x-second: 2").unwrap() < raw.find("x-first: 1").unwrap());
+ assert_eq!(page.status, Some(201));
+ assert_eq!(page.cookies["sid"], json!("abc"));
+ assert_eq!(page.encoding.as_deref(), Some("iso-8859-1"));
+ assert_eq!(page.html, "OK");
+ let envelope = crate::scrapling::page::serialize_page(&page, &payload, true).unwrap();
+ assert_eq!(envelope["status"], json!(201));
+ assert_eq!(envelope["url"], json!(format!("{url}?b=2&b=3&a=x")));
+ assert_eq!(envelope["headers"]["set-cookie"], json!("sid=abc; Path=/"));
+ assert_eq!(envelope["cookies"]["sid"], json!("abc"));
+ assert_eq!(envelope["encoding"], json!("iso-8859-1"));
+ // HTML normalization belongs to the shared compatibility DOM. The
+ // HTTP engine contract at this boundary is the decoded response body.
+ assert_eq!(page.html, "OK");
+ }
+
+ #[test]
+ fn unsupported_impersonation_matches_oracle_error() {
+ let options = HttpOptions::from_payload_for_mode(
+ &json!({"impersonate": "bogus", "retries": 1}),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(
+ blocking_fetch("http://127.0.0.1:1", &options).unwrap_err(),
+ "Impersonating bogus is not supported"
+ );
+ }
+
+ #[test]
+ fn invalid_signed_setopt_values_match_oracle_errors() {
+ let timeout = HttpOptions::from_payload_for_mode(
+ &json!({
+ "timeout": -1,
+ "retries": 1,
+ "impersonate": "chrome136",
+ "stealthy_headers": false
+ }),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(
+ blocking_fetch("http://127.0.0.1:1", &timeout).unwrap_err(),
+ "Failed to setopt 155 -1000, curl: (43) setopt 0x9b got bad argument. See https://curl.se/libcurl/c/libcurl-errors.html first for more details."
+ );
+
+ let redirects = HttpOptions::from_payload_for_mode(
+ &json!({
+ "max_redirects": -2,
+ "retries": 1,
+ "impersonate": "chrome136",
+ "stealthy_headers": false
+ }),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(
+ blocking_fetch("http://127.0.0.1:1", &redirects).unwrap_err(),
+ "Failed to setopt 68 -2, curl: (43) setopt 0x44 got bad argument. See https://curl.se/libcurl/c/libcurl-errors.html first for more details."
+ );
+ }
+
+ #[test]
+ fn negative_retry_values_match_oracle_errors() {
+ let retries = HttpOptions::from_payload_for_mode(
+ &json!({
+ "retries": -1,
+ "impersonate": "chrome136",
+ "stealthy_headers": false
+ }),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(
+ blocking_fetch("http://127.0.0.1:1", &retries).unwrap_err(),
+ "No active session available."
+ );
+
+ let retry_delay = HttpOptions::from_payload_for_mode(
+ &json!({
+ "retries": 2,
+ "retry_delay": -1,
+ "impersonate": "chrome136",
+ "stealthy_headers": false
+ }),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ assert_eq!(
+ blocking_fetch("http://127.0.0.1:1", &retry_delay).unwrap_err(),
+ "sleep length must be non-negative"
+ );
+ }
+
+ #[test]
+ fn form_values_use_python_urlencode_coercion() {
+ let body = Body::Form(json!({
+ "bool": true,
+ "none": null,
+ "obj": {"a": 1},
+ "arr": [1, 2]
+ }));
+ let (bytes, content_type) = body_bytes(&body).unwrap();
+ assert_eq!(content_type, "application/x-www-form-urlencoded");
+ assert_eq!(
+ String::from_utf8(bytes).unwrap(),
+ "bool=True&none=None&obj=%7B%27a%27%3A+1%7D&arr=%5B1%2C+2%5D"
+ );
+ }
+
+ #[test]
+ fn only_final_response_headers_and_cookies_are_exposed() {
+ let raw = b"HTTP/1.1 302 Found\r\nSet-Cookie: stale=1\r\nX-Hop: first\r\n\r\nHTTP/1.1 200 OK\r\nSet-Cookie: final=2\r\nSet-Cookie: other=3\r\nX-Hop: second\r\nX-Hop: third\r\n\r\n";
+ let headers = response_headers(raw);
+ let cookies = response_cookies(raw);
+ assert_eq!(headers["x-hop"], json!("second, third"));
+ assert_eq!(headers["set-cookie"], json!("final=2, other=3"));
+ assert_eq!(
+ cookies,
+ json!({"final": "2", "other": "3"})
+ .as_object()
+ .unwrap()
+ .clone()
+ );
+ }
+
+ #[test]
+ fn compat_decodes_content_encoding_like_curl_cffi() {
+ const GZIP_OK: &[u8] = &[
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xf3, 0xf7, 0x06, 0x00,
+ 0x2d, 0xd9, 0x36, 0xd7, 0x02, 0x00, 0x00, 0x00,
+ ];
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let address = listener.local_addr().unwrap();
+ std::thread::spawn(move || {
+ let (mut stream, _) = listener.accept().unwrap();
+ let mut request = [0u8; 8192];
+ let _ = stream.read(&mut request).unwrap();
+ stream
+ .write_all(
+ format!(
+ "HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+ GZIP_OK.len()
+ )
+ .as_bytes(),
+ )
+ .unwrap();
+ stream.write_all(GZIP_OK).unwrap();
+ });
+ let options = HttpOptions::from_payload_for_mode(
+ &json!({
+ "retries": 1,
+ "impersonate": "chrome136",
+ "stealthy_headers": false
+ }),
+ HttpMode::Compat,
+ )
+ .unwrap();
+ let page = blocking_fetch(&format!("http://{address}/gzip"), &options).unwrap();
+ assert_eq!(page.html, "OK");
+ assert_eq!(page.encoding.as_deref(), Some("utf-8"));
+ }
+}
diff --git a/browser/src/scrapling/inject_guidance.rs b/browser/src/scrapling/inject_guidance.rs
new file mode 100644
index 000000000..0b5003ffa
--- /dev/null
+++ b/browser/src/scrapling/inject_guidance.rs
@@ -0,0 +1,132 @@
+//! harness::hook::pre-generate guidance: teach agents the scrapling surface —
+//! which fetch tier to reach for, what needs no browser at all, and which
+//! capabilities this worker does NOT have. Bound with on_error: fail_open
+//! (pre_generate defaults fail-CLOSED and a missing guidance line must never
+//! abort a turn).
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+pub const GUIDANCE_HOOK_ID: &str = "browser::inject-guidance";
+pub const GUIDANCE_HOOK_DESC: &str =
+ "Internal: appends browser::* scraping and HTML parsing guidance to the agent system prompt.";
+
+pub const GUIDANCE: &str = "\
+## Scraping and HTML parsing (browser::*)
+Use `browser::fetch` for plain HTTP, `browser::dynamic-fetch` for JavaScript, \
+and `browser::stealthy-fetch` for automation masking. Use \
+`browser::screenshot-url` to capture a URL; `browser::screenshot` captures an \
+existing interactive session. `browser::session-open`, \
+`browser::session-fetch`, `browser::session-close`, and \
+`browser::session-list` preserve cookies and browser state. `browser::crawl` \
+walks same-domain links and streams results. For HTML already in hand, use \
+`browser::extract`, `browser::css`, `browser::xpath`, `browser::regex`, \
+`browser::find`, `browser::find-by-text`, `browser::find-by-regex`, \
+`browser::find-similar`, `browser::describe`, or `browser::to-markdown`. \
+Fetching functions require approval; parse functions do not. Adaptive \
+queries persist identities in SQLite. `solve_cloudflare` is supported by \
+stealthy fetches; use `browser::handoff` for human-only steps in an \
+interactive session.";
+
+#[derive(Debug, Default, Deserialize, JsonSchema)]
+pub struct GenerateContext {
+ #[serde(default)]
+ pub system_prompt: String,
+}
+
+#[derive(Debug, Default, Deserialize, JsonSchema)]
+pub struct PreGenerateEvent {
+ #[serde(default)]
+ pub generate: GenerateContext,
+}
+
+#[derive(Debug, Default, Serialize, JsonSchema)]
+pub struct PreGenerateMutations {
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub system_prompt: Option<String>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub struct PreGenerateResponse {
+ pub mutations: PreGenerateMutations,
+}
+
+/// Empty base → {} (preserve harness prompt); else full replacement base+guidance.
+pub fn mutations_for(base: &str) -> PreGenerateResponse {
+ if base.is_empty() {
+ return PreGenerateResponse {
+ mutations: PreGenerateMutations::default(),
+ };
+ }
+ PreGenerateResponse {
+ mutations: PreGenerateMutations {
+ system_prompt: Some(format!("{base}\n\n{GUIDANCE}")),
+ },
+ }
+}
+
+pub async fn handle(event: PreGenerateEvent) -> Result<PreGenerateResponse, iii_sdk::Error> {
+ Ok(mutations_for(&event.generate.system_prompt))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn empty_base_preserves_harness_prompt() {
+ let v = serde_json::to_value(mutations_for("")).unwrap();
+ assert_eq!(v, serde_json::json!({"mutations": {}}));
+ }
+
+ #[test]
+ fn nonempty_base_appends_guidance() {
+ let v = serde_json::to_value(mutations_for("BASE")).unwrap();
+ let s = v["mutations"]["system_prompt"].as_str().unwrap();
+ assert!(s.starts_with("BASE\n\n## Scraping and HTML parsing"));
+ }
+
+ /// The guidance is what routes agents to these functions, so it must not
+ /// promise capabilities the worker does not have, and every Scrapling id
+ /// it names must actually be registered.
+ #[test]
+ fn guidance_names_only_real_functions_and_no_absent_capability() {
+ let registered: Vec<&str> = crate::scrapling::STATIC_IDS
+ .iter()
+ .map(|id| id.trim_start_matches("browser::"))
+ .collect();
+ for word in [
+ "fetch",
+ "dynamic-fetch",
+ "stealthy-fetch",
+ "screenshot-url",
+ "session-open",
+ "session-fetch",
+ "session-close",
+ "session-list",
+ "crawl",
+ "extract",
+ "css",
+ "xpath",
+ "regex",
+ "find",
+ "find-by-text",
+ "find-by-regex",
+ "find-similar",
+ "describe",
+ "to-markdown",
+ ] {
+ assert!(
+ GUIDANCE.contains(word),
+ "guidance never mentions `{word}`, so agents will not find it"
+ );
+ assert!(registered.contains(&word), "`{word}` is not registered");
+ }
+ assert!(
+ GUIDANCE.contains("Adaptive queries persist identities in SQLite"),
+ "adaptive persistence must be disclosed"
+ );
+ assert!(GUIDANCE.contains("`solve_cloudflare` is supported"));
+ assert!(GUIDANCE.contains("browser::handoff"));
+ }
+}
diff --git a/browser/src/scrapling/markdown.rs b/browser/src/scrapling/markdown.rs
new file mode 100644
index 000000000..1d53e58b8
--- /dev/null
+++ b/browser/src/scrapling/markdown.rs
@@ -0,0 +1,1235 @@
+//! scrapling::to-markdown rendering: html/markdown/text extraction, with an
+//! optional main-content sanitizer and CSS scope
+//! (`Convertor._extract_content`, scrapling/core/shell.py, normative).
+
+use std::collections::HashSet;
+
+use xmloxide::tree::NodeKind;
+use xmloxide::NodeId;
+
+use crate::scrapling::dom::{self, Doc, ElementRef};
+use crate::scrapling::query;
+
+/// `_strip_noise_tags` + the tag half of `_sanitize_for_ai`'s `_HIDDEN_XPATH`
+/// union: `<template>` is dropped the same way as the noise tags — folding
+/// it into one name-set costs nothing since detaching is order-independent
+/// (matching is by predicate only, never by "is a sibling already gone").
+fn is_noise_tag(name: &str) -> bool {
+ matches!(name, "script" | "style" | "noscript" | "svg" | "template")
+}
+
+/// The `contains(@style, ...)` half of `_HIDDEN_XPATH` (shell.py) — plain
+/// substring tests, not CSS parsing.
+const HIDDEN_STYLE_SUBSTRINGS: &[&str] = &[
+ "display:none",
+ "display: none",
+ "visibility:hidden",
+ "visibility: hidden",
+ "opacity:0",
+ "opacity: 0",
+ "font-size:0",
+ "font-size: 0",
+ "height:0",
+ "height: 0",
+ "width:0",
+ "width: 0",
+];
+
+/// `_ZWC_PATTERN` (shell.py): zero-width/invisible-formatting characters
+/// stripped from text nodes by the prompt-injection sanitizer.
+const ZERO_WIDTH_CHARS: [char; 6] = [
+ '\u{200b}', '\u{200c}', '\u{200d}', '\u{feff}', '\u{2060}', '\u{180e}',
+];
+
+fn is_hidden(doc: &Doc, id: NodeId) -> bool {
+ is_noise_tag(doc.tree.node_name(id).unwrap_or(""))
+ || doc.tree.attribute(id, "aria-hidden") == Some("true")
+ || doc
+ .tree
+ .attribute(id, "style")
+ .is_some_and(|s| HIDDEN_STYLE_SUBSTRINGS.iter().any(|pat| s.contains(pat)))
+}
+
+/// `_strip_noise_tags` + `_sanitize_for_ai`, fused into one in-place pass over
+/// a tree the caller already cloned (never called on the caller's own doc):
+/// detach every noise/hidden/aria-hidden/template element (`drop_tree` —
+/// lxml keeps a dropped element's TAIL text by splicing it onto the
+/// predecessor, but html5ever/scraper never attaches trailing text to an
+/// element in the first place — it's already an ordinary sibling text node —
+/// so a plain `detach()` reproduces that splice for free), then strip
+/// zero-width chars from every surviving text node.
+///
+/// `scope_id` (the element `render` is about to treat as the page — `body`,
+/// or the whole document if there's no `body`) is exempt from the hidden
+/// check: `_HIDDEN_XPATH` is rooted at `.//` (XPath descendant axis, self
+/// excluded), so `<body aria-hidden="true">` or `<body style="display:
+/// none">` never drops itself in Python, only matching *descendants* do.
+/// Oracle-probed: both yield their content, not `""`. The name-based checks
+/// (script/style/noscript/svg/template) need no such exemption in practice —
+/// `scope_id` is always a `<body>` or the document's `<html>` root, never one
+/// of those tag names — but exempting it from the whole predicate uniformly
+/// is simpler than splitting the check in two, and is a no-op for that half.
+fn sanitize_main_content(doc: &mut Doc, scope_id: NodeId) {
+ let drop_ids: Vec<_> = doc
+ .tree
+ .descendants(doc.tree.root())
+ .filter(|id| *id != scope_id && doc.tree.is_element(*id) && is_hidden(doc, *id))
+ .collect();
+ for id in drop_ids {
+ doc.tree.remove_node(id);
+ }
+
+ let text_ids: Vec<_> = doc
+ .tree
+ .descendants(doc.tree.root())
+ .filter(|id| matches!(doc.tree.node(*id).kind, NodeKind::Text { .. }))
+ .collect();
+ for id in text_ids {
+ let cleaned: String = doc
+ .tree
+ .node_text(id)
+ .unwrap_or("")
+ .chars()
+ .filter(|c| !ZERO_WIDTH_CHARS.contains(c))
+ .collect();
+ doc.tree.set_text_content(id, &cleaned);
+ }
+}
+
+/// First `<body>` in document order, else the whole document's root element
+/// (`page.css("body").first or page`, shell.py).
+fn body_or_root(doc: &Doc) -> ElementRef<'_> {
+ doc.first_by_tag("body").unwrap_or_else(|| doc.root())
+}
+
+/// Collapse runs of `\n`, then `\r`, then `\t`, then space — in that order,
+/// each to a single occurrence (the `Convertor._extract_content` text-mode
+/// loop, shell.py: sequential `re.sub(f"[{s}]+", s, ...)` per character).
+/// markdownify's `all_whitespace_re` = `[\t \r\n]+` → single space. Crucially
+/// ASCII-only: NBSP (and other Unicode spaces) are NOT collapsed, unlike
+/// Rust's `split_whitespace`, which treats U+00A0 as whitespace.
+fn collapse_ascii_ws(s: &str) -> String {
+ let mut out = String::with_capacity(s.len());
+ let mut prev_ws = false;
+ for ch in s.chars() {
+ if matches!(ch, '\t' | ' ' | '\r' | '\n') {
+ if !prev_ws {
+ out.push(' ');
+ prev_ws = true;
+ }
+ } else {
+ out.push(ch);
+ prev_ws = false;
+ }
+ }
+ out
+}
+
+fn collapse_whitespace(mut s: String) -> String {
+ for c in ['\n', '\r', '\t', ' '] {
+ let mut out = String::with_capacity(s.len());
+ let mut prev_was_c = false;
+ for ch in s.chars() {
+ if ch == c {
+ if prev_was_c {
+ continue;
+ }
+ prev_was_c = true;
+ } else {
+ prev_was_c = false;
+ }
+ out.push(ch);
+ }
+ s = out;
+ }
+ s
+}
+
+// The public wrapper exposes markdownify with no option overrides. This is a
+// repository-owned port of markdownify 1.2.3's complete default conversion
+// behavior. Its first step deliberately reparses the lxml-serialized subtree
+// with the same tree shape as BeautifulSoup 4.15's `html.parser` builder.
+// That second parse is observable for raw-text elements such as <plaintext>.
+
+#[derive(Clone, Debug)]
+enum MarkdownNodeKind {
+ Document,
+ Element {
+ name: String,
+ attrs: Vec<(String, String)>,
+ },
+ Text(String),
+ Comment,
+ Doctype,
+}
+
+#[derive(Clone, Debug)]
+struct MarkdownNode {
+ kind: MarkdownNodeKind,
+ parent: Option<usize>,
+ children: Vec<usize>,
+}
+
+#[derive(Debug)]
+struct MarkdownTree {
+ nodes: Vec<MarkdownNode>,
+}
+
+impl MarkdownTree {
+ fn new() -> Self {
+ Self {
+ nodes: vec![MarkdownNode {
+ kind: MarkdownNodeKind::Document,
+ parent: None,
+ children: Vec::new(),
+ }],
+ }
+ }
+
+ fn append(&mut self, parent: usize, kind: MarkdownNodeKind) -> usize {
+ let id = self.nodes.len();
+ self.nodes.push(MarkdownNode {
+ kind,
+ parent: Some(parent),
+ children: Vec::new(),
+ });
+ self.nodes[parent].children.push(id);
+ id
+ }
+
+ fn name(&self, id: usize) -> Option<&str> {
+ match &self.nodes[id].kind {
+ MarkdownNodeKind::Document => Some("[document]"),
+ MarkdownNodeKind::Element { name, .. } => Some(name),
+ _ => None,
+ }
+ }
+
+ fn attr(&self, id: usize, name: &str) -> Option<&str> {
+ match &self.nodes[id].kind {
+ MarkdownNodeKind::Element { attrs, .. } => attrs
+ .iter()
+ .find(|(key, _)| key == name)
+ .map(|(_, value)| value.as_str()),
+ _ => None,
+ }
+ }
+
+ fn element_children_recursive(&self, id: usize, names: &[&str], out: &mut Vec<usize>) {
+ for child in &self.nodes[id].children {
+ if self.name(*child).is_some_and(|name| names.contains(&name)) {
+ out.push(*child);
+ }
+ self.element_children_recursive(*child, names, out);
+ }
+ }
+
+ fn sibling_index(&self, id: usize) -> Option<(usize, usize)> {
+ let parent = self.nodes[id].parent?;
+ let index = self.nodes[parent]
+ .children
+ .iter()
+ .position(|candidate| *candidate == id)?;
+ Some((parent, index))
+ }
+
+ fn previous_sibling(&self, id: usize) -> Option<usize> {
+ let (parent, index) = self.sibling_index(id)?;
+ index.checked_sub(1).map(|i| self.nodes[parent].children[i])
+ }
+
+ fn next_sibling(&self, id: usize) -> Option<usize> {
+ let (parent, index) = self.sibling_index(id)?;
+ self.nodes[parent].children.get(index + 1).copied()
+ }
+
+ fn previous_element_sibling(&self, id: usize) -> Option<usize> {
+ let (parent, index) = self.sibling_index(id)?;
+ self.nodes[parent].children[..index]
+ .iter()
+ .rev()
+ .copied()
+ .find(|candidate| self.name(*candidate).is_some())
+ }
+
+ fn has_ancestor(&self, id: usize, name: &str) -> bool {
+ let mut cursor = self.nodes[id].parent;
+ while let Some(parent) = cursor {
+ if self.name(parent) == Some(name) {
+ return true;
+ }
+ cursor = self.nodes[parent].parent;
+ }
+ false
+ }
+}
+
+const VOID_TAGS: &[&str] = &[
+ "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source",
+ "track", "wbr",
+];
+
+fn decode_html_parser_entities(value: &str) -> String {
+ html_escape::decode_html_entities(value).into_owned()
+}
+
+fn find_tag_end(input: &str, start: usize) -> usize {
+ let bytes = input.as_bytes();
+ let mut quote = None;
+ let mut i = start;
+ while i < bytes.len() {
+ match bytes[i] {
+ b'\'' | b'"' if quote.is_none() => quote = Some(bytes[i]),
+ current if quote == Some(current) => quote = None,
+ b'>' if quote.is_none() => return i,
+ _ => {}
+ }
+ i += 1;
+ }
+ bytes.len()
+}
+
+fn parse_start_tag(raw: &str) -> (String, Vec<(String, String)>, bool) {
+ let bytes = raw.as_bytes();
+ let mut i = 0;
+ while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+ i += 1;
+ }
+ let name_start = i;
+ while i < bytes.len() && !bytes[i].is_ascii_whitespace() && !matches!(bytes[i], b'/' | b'>') {
+ i += 1;
+ }
+ let name = raw[name_start..i].to_ascii_lowercase();
+ let mut attrs: Vec<(String, String)> = Vec::new();
+ let mut self_closing = false;
+
+ while i < bytes.len() {
+ while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+ i += 1;
+ }
+ if i >= bytes.len() {
+ break;
+ }
+ if bytes[i] == b'/' {
+ self_closing = true;
+ i += 1;
+ continue;
+ }
+ let attr_start = i;
+ while i < bytes.len()
+ && !bytes[i].is_ascii_whitespace()
+ && !matches!(bytes[i], b'=' | b'/' | b'>')
+ {
+ i += 1;
+ }
+ if attr_start == i {
+ i += 1;
+ continue;
+ }
+ let attr_name = raw[attr_start..i].to_ascii_lowercase();
+ while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+ i += 1;
+ }
+ let mut value = String::new();
+ if i < bytes.len() && bytes[i] == b'=' {
+ i += 1;
+ while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+ i += 1;
+ }
+ if i < bytes.len() && matches!(bytes[i], b'\'' | b'"') {
+ let quote = bytes[i];
+ i += 1;
+ let value_start = i;
+ while i < bytes.len() && bytes[i] != quote {
+ i += 1;
+ }
+ value = decode_html_parser_entities(&raw[value_start..i]);
+ if i < bytes.len() {
+ i += 1;
+ }
+ } else {
+ let value_start = i;
+ while i < bytes.len() && !bytes[i].is_ascii_whitespace() && bytes[i] != b'/' {
+ i += 1;
+ }
+ value = decode_html_parser_entities(&raw[value_start..i]);
+ }
+ }
+ // html.parser/BeautifulSoup keeps the last duplicate attribute.
+ if let Some(existing) = attrs.iter_mut().find(|(key, _)| key == &attr_name) {
+ existing.1 = value;
+ } else {
+ attrs.push((attr_name, value));
+ }
+ }
+ (name, attrs, self_closing)
+}
+
+/// Parse the already libxml-serialized selection the way the default
+/// BeautifulSoup HTMLParserTreeBuilder observes it. Libxml has already done
+/// malformed-markup recovery, so this stage primarily needs HTMLParser's
+/// tokenization, entity handling, raw-text behavior, and sibling tree.
+fn parse_markdown_tree(input: &str) -> MarkdownTree {
+ let mut tree = MarkdownTree::new();
+ let mut stack = vec![0usize];
+ let mut i = 0usize;
+ let bytes = input.as_bytes();
+
+ while i < bytes.len() {
+ if bytes[i] != b'<' {
+ let end = input[i..]
+ .find('<')
+ .map_or(bytes.len(), |offset| i + offset);
+ if end > i {
+ let text = decode_html_parser_entities(&input[i..end]);
+ tree.append(*stack.last().unwrap(), MarkdownNodeKind::Text(text));
+ }
+ i = end;
+ continue;
+ }
+ if input[i..].starts_with("<!--") {
+ let end = input[i + 4..]
+ .find("-->")
+ .map_or(bytes.len(), |offset| i + 4 + offset + 3);
+ tree.append(*stack.last().unwrap(), MarkdownNodeKind::Comment);
+ i = end;
+ continue;
+ }
+ if input[i..].get(..2).is_some_and(|s| s == "</") {
+ let end = find_tag_end(input, i + 2);
+ let name = input[i + 2..end]
+ .split_ascii_whitespace()
+ .next()
+ .unwrap_or("")
+ .trim_end_matches('/')
+ .to_ascii_lowercase();
+ if let Some(position) = stack
+ .iter()
+ .rposition(|node| tree.name(*node) == Some(name.as_str()))
+ {
+ stack.truncate(position);
+ }
+ i = end.saturating_add(1);
+ continue;
+ }
+ if input[i..].get(..2).is_some_and(|s| s == "<!") {
+ let end = find_tag_end(input, i + 2);
+ tree.append(*stack.last().unwrap(), MarkdownNodeKind::Doctype);
+ i = end.saturating_add(1);
+ continue;
+ }
+ if input[i..].get(..2).is_some_and(|s| s == "<?") {
+ let end = find_tag_end(input, i + 2);
+ tree.append(*stack.last().unwrap(), MarkdownNodeKind::Comment);
+ i = end.saturating_add(1);
+ continue;
+ }
+
+ let end = find_tag_end(input, i + 1);
+ if end == bytes.len() {
+ tree.append(
+ *stack.last().unwrap(),
+ MarkdownNodeKind::Text(decode_html_parser_entities(&input[i..])),
+ );
+ break;
+ }
+ let (name, attrs, self_closing) = parse_start_tag(&input[i + 1..end]);
+ if name.is_empty() {
+ tree.append(
+ *stack.last().unwrap(),
+ MarkdownNodeKind::Text("<".to_string()),
+ );
+ i += 1;
+ continue;
+ }
+ let node = tree.append(
+ *stack.last().unwrap(),
+ MarkdownNodeKind::Element {
+ name: name.clone(),
+ attrs,
+ },
+ );
+ i = end + 1;
+
+ if name == "plaintext" {
+ // Python's HTMLParser treats every remaining byte, including
+ // apparent closing tags and entities, as literal plaintext.
+ if i < bytes.len() {
+ tree.append(node, MarkdownNodeKind::Text(input[i..].to_string()));
+ }
+ break;
+ }
+ if matches!(name.as_str(), "script" | "style") {
+ let closing = format!("</{name}");
+ let lower_tail = input[i..].to_ascii_lowercase();
+ if let Some(offset) = lower_tail.find(&closing) {
+ if offset > 0 {
+ tree.append(
+ node,
+ MarkdownNodeKind::Text(input[i..i + offset].to_string()),
+ );
+ }
+ let close_start = i + offset;
+ i = find_tag_end(input, close_start + 2).saturating_add(1);
+ continue;
+ }
+ }
+ if !self_closing && !VOID_TAGS.contains(&name.as_str()) {
+ stack.push(node);
+ }
+ }
+ tree
+}
+
+fn heading_number(name: &str) -> Option<usize> {
+ let digits: String = name
+ .strip_prefix('h')?
+ .chars()
+ .take_while(char::is_ascii_digit)
+ .collect();
+ (!digits.is_empty()).then(|| digits.parse().ok()).flatten()
+}
+
+fn is_block_name(name: Option<&str>) -> bool {
+ name.is_some_and(|name| {
+ heading_number(name).is_some()
+ || matches!(
+ name,
+ "p" | "blockquote"
+ | "article"
+ | "div"
+ | "section"
+ | "ol"
+ | "ul"
+ | "li"
+ | "dl"
+ | "dt"
+ | "dd"
+ | "table"
+ | "thead"
+ | "tbody"
+ | "tfoot"
+ | "tr"
+ | "td"
+ | "th"
+ )
+ })
+}
+
+fn removes_whitespace_outside(tree: &MarkdownTree, node: Option<usize>) -> bool {
+ node.is_some_and(|id| is_block_name(tree.name(id)) || tree.name(id) == Some("pre"))
+}
+
+fn block_content(tree: &MarkdownTree, node: usize) -> bool {
+ match &tree.nodes[node].kind {
+ MarkdownNodeKind::Element { .. } => true,
+ MarkdownNodeKind::Text(text) => !text.trim().is_empty(),
+ _ => false,
+ }
+}
+
+fn next_block_content(tree: &MarkdownTree, id: usize) -> Option<usize> {
+ let (parent, index) = tree.sibling_index(id)?;
+ tree.nodes[parent].children[index + 1..]
+ .iter()
+ .copied()
+ .find(|candidate| block_content(tree, *candidate))
+}
+
+fn normalize_markdown_text(text: &str) -> String {
+ let chars: Vec<char> = text.chars().collect();
+ let mut out = String::with_capacity(text.len());
+ let mut i = 0;
+ while i < chars.len() {
+ if matches!(chars[i], ' ' | '\t' | '\r' | '\n') {
+ let mut has_newline = false;
+ while i < chars.len() && matches!(chars[i], ' ' | '\t' | '\r' | '\n') {
+ has_newline |= matches!(chars[i], '\r' | '\n');
+ i += 1;
+ }
+ out.push(if has_newline { '\n' } else { ' ' });
+ } else {
+ out.push(chars[i]);
+ i += 1;
+ }
+ }
+ out
+}
+
+fn escape_markdown_text(text: &str) -> String {
+ text.replace('*', r"\*").replace('_', r"\_")
+}
+
+fn trim_ascii_markdown(value: &str) -> &str {
+ value.trim_matches([' ', '\t', '\r', '\n'])
+}
+
+fn chomp(value: &str) -> (&'static str, &'static str, &str) {
+ let prefix = if value.starts_with(' ') { " " } else { "" };
+ let suffix = if value.ends_with(' ') { " " } else { "" };
+ (prefix, suffix, value.trim())
+}
+
+fn split_boundary_newlines(value: &str) -> (String, String, String) {
+ let leading = value.bytes().take_while(|byte| *byte == b'\n').count();
+ let remainder = &value[leading..];
+ if remainder.is_empty() {
+ return ("\n".repeat(leading), String::new(), String::new());
+ }
+ let trailing = remainder
+ .bytes()
+ .rev()
+ .take_while(|byte| *byte == b'\n')
+ .count();
+ let content_end = remainder.len() - trailing;
+ (
+ "\n".repeat(leading),
+ remainder[..content_end].to_string(),
+ "\n".repeat(trailing),
+ )
+}
+
+fn indent_lines(value: &str, prefix: &str, empty_prefix: &str) -> String {
+ value
+ .split('\n')
+ .map(|line| {
+ if line.is_empty() {
+ empty_prefix.to_string()
+ } else {
+ format!("{prefix}{line}")
+ }
+ })
+ .collect::<Vec<_>>()
+ .join("\n")
+}
+
+struct MarkdownConverter<'a> {
+ tree: &'a MarkdownTree,
+}
+
+impl<'a> MarkdownConverter<'a> {
+ fn process(&self) -> String {
+ self.process_tag(0, &HashSet::new())
+ }
+
+ fn process_element(&self, id: usize, parent_tags: &HashSet<String>) -> String {
+ match &self.tree.nodes[id].kind {
+ MarkdownNodeKind::Text(_) => self.process_text(id, parent_tags),
+ MarkdownNodeKind::Element { .. } | MarkdownNodeKind::Document => {
+ self.process_tag(id, parent_tags)
+ }
+ MarkdownNodeKind::Comment | MarkdownNodeKind::Doctype => String::new(),
+ }
+ }
+
+ fn can_ignore_child(&self, child: usize, remove_inside: bool) -> bool {
+ match &self.tree.nodes[child].kind {
+ MarkdownNodeKind::Element { .. } => false,
+ MarkdownNodeKind::Comment | MarkdownNodeKind::Doctype => true,
+ MarkdownNodeKind::Text(text) => {
+ if !text.trim().is_empty() {
+ return false;
+ }
+ let previous = self.tree.previous_sibling(child);
+ let next = self.tree.next_sibling(child);
+ (remove_inside && (previous.is_none() || next.is_none()))
+ || removes_whitespace_outside(self.tree, previous)
+ || removes_whitespace_outside(self.tree, next)
+ }
+ MarkdownNodeKind::Document => true,
+ }
+ }
+
+ fn process_tag(&self, id: usize, parent_tags: &HashSet<String>) -> String {
+ let name = self.tree.name(id).unwrap_or("");
+ let remove_inside = is_block_name(Some(name));
+ let mut child_context = parent_tags.clone();
+ child_context.insert(name.to_string());
+ if heading_number(name).is_some() || matches!(name, "td" | "th") {
+ child_context.insert("_inline".to_string());
+ }
+ if matches!(name, "pre" | "code" | "kbd" | "samp") {
+ child_context.insert("_noformat".to_string());
+ }
+
+ let mut child_strings: Vec<String> = self.tree.nodes[id]
+ .children
+ .iter()
+ .copied()
+ .filter(|child| !self.can_ignore_child(*child, remove_inside))
+ .map(|child| self.process_element(child, &child_context))
+ .filter(|value| !value.is_empty())
+ .collect();
+
+ if name != "pre" && !self.tree.has_ancestor(id, "pre") {
+ let mut collapsed = vec![String::new()];
+ for child in child_strings {
+ let (mut leading, content, trailing) = split_boundary_newlines(&child);
+ if collapsed.last().is_some_and(|last| !last.is_empty()) && !leading.is_empty() {
+ let previous = collapsed.pop().unwrap();
+ leading = "\n".repeat(2.min(previous.len().max(leading.len())));
+ }
+ collapsed.extend([leading, content, trailing]);
+ }
+ child_strings = collapsed;
+ }
+ let text = child_strings.concat();
+ self.convert_tag(id, name, text, parent_tags)
+ }
+
+ fn process_text(&self, id: usize, parent_tags: &HashSet<String>) -> String {
+ let MarkdownNodeKind::Text(raw) = &self.tree.nodes[id].kind else {
+ unreachable!()
+ };
+ let mut text = if parent_tags.contains("pre") {
+ raw.clone()
+ } else {
+ normalize_markdown_text(raw)
+ };
+ if !parent_tags.contains("_noformat") {
+ text = escape_markdown_text(&text);
+ }
+
+ let parent = self.tree.nodes[id].parent;
+ let previous = self.tree.previous_sibling(id);
+ let next = self.tree.next_sibling(id);
+ if removes_whitespace_outside(self.tree, previous)
+ || (parent.is_some_and(|node| is_block_name(self.tree.name(node)))
+ && previous.is_none())
+ {
+ text = text.trim_start_matches([' ', '\t', '\r', '\n']).to_string();
+ }
+ if removes_whitespace_outside(self.tree, next)
+ || (parent.is_some_and(|node| is_block_name(self.tree.name(node))) && next.is_none())
+ {
+ text = text.trim_end().to_string();
+ }
+ text
+ }
+
+ fn inline(&self, text: String, markup: &str, parent_tags: &HashSet<String>) -> String {
+ if parent_tags.contains("_noformat") {
+ return text;
+ }
+ let (prefix, suffix, inner) = chomp(&text);
+ if inner.is_empty() {
+ String::new()
+ } else {
+ format!("{prefix}{markup}{inner}{markup}{suffix}")
+ }
+ }
+
+ fn convert_tag(
+ &self,
+ id: usize,
+ name: &str,
+ text: String,
+ parent_tags: &HashSet<String>,
+ ) -> String {
+ if name == "[document]" {
+ return text.trim_matches('\n').to_string();
+ }
+ if let Some(number) = heading_number(name) {
+ return self.convert_heading(number, &text, parent_tags);
+ }
+ match name {
+ "a" => self.convert_a(id, text, parent_tags),
+ "b" | "strong" => self.inline(text, "**", parent_tags),
+ "em" | "i" => self.inline(text, "*", parent_tags),
+ "del" | "s" => self.inline(text, "~~", parent_tags),
+ "sub" | "sup" => self.inline(text, "", parent_tags),
+ "code" | "kbd" | "samp" => self.convert_code(text, parent_tags),
+ "blockquote" => self.convert_blockquote(text, parent_tags),
+ "br" => {
+ if parent_tags.contains("_inline") {
+ if text.is_empty() {
+ " ".into()
+ } else {
+ format!("{text} ")
+ }
+ } else {
+ format!(" \n{text}")
+ }
+ }
+ "div" | "article" | "section" => self.convert_div(text, parent_tags),
+ "dd" => self.convert_dd(text, parent_tags),
+ "dt" => self.convert_dt(text, parent_tags),
+ "dl" => self.convert_div(text, parent_tags),
+ "hr" => "\n\n---\n\n".to_string(),
+ "img" => self.convert_img(id, parent_tags),
+ "video" => self.convert_video(id, text, parent_tags),
+ "ul" | "ol" => self.convert_list(id, text, parent_tags),
+ "li" => self.convert_li(id, text),
+ "p" => self.convert_p(text, parent_tags),
+ "pre" => self.convert_pre(text),
+ "q" => format!("\"{text}\""),
+ "script" | "style" => String::new(),
+ "table" => format!("\n\n{}\n\n", text.trim()),
+ "caption" => format!("{}\n\n", text.trim()),
+ "figcaption" => format!("\n\n{}\n\n", text.trim()),
+ "td" | "th" => self.convert_cell(id, text),
+ "tr" => self.convert_row(id, text),
+ _ => text,
+ }
+ }
+
+ fn convert_a(&self, id: usize, text: String, parent_tags: &HashSet<String>) -> String {
+ if parent_tags.contains("_noformat") {
+ return text;
+ }
+ let (prefix, suffix, inner) = chomp(&text);
+ if inner.is_empty() {
+ return String::new();
+ }
+ // markdownify treats an empty href/title as absent (`if href`,
+ // `not title` are falsy on ""), so an empty href is no link and an
+ // empty title never blocks the autolink form.
+ let href = self.tree.attr(id, "href").filter(|value| !value.is_empty());
+ let title = self
+ .tree
+ .attr(id, "title")
+ .filter(|value| !value.is_empty());
+ if href.is_some_and(|href| inner.replace(r"\_", "_") == href) && title.is_none() {
+ return format!("<{href}>", href = href.unwrap());
+ }
+ let Some(href) = href else {
+ return inner.to_string();
+ };
+ let title = title
+ .map(|value| format!(" \"{}\"", value.replace('"', r#"\""#)))
+ .unwrap_or_default();
+ format!("{prefix}[{inner}]({href}{title}){suffix}")
+ }
+
+ fn convert_blockquote(&self, text: String, parent_tags: &HashSet<String>) -> String {
+ let text = trim_ascii_markdown(&text);
+ if parent_tags.contains("_inline") {
+ return format!(" {text} ");
+ }
+ if text.is_empty() {
+ return "\n".to_string();
+ }
+ format!("\n{}\n\n", indent_lines(text, "> ", ">"))
+ }
+
+ fn convert_code(&self, text: String, parent_tags: &HashSet<String>) -> String {
+ if parent_tags.contains("_noformat") {
+ return text;
+ }
+ let (prefix, suffix, inner) = chomp(&text);
+ if inner.is_empty() {
+ return String::new();
+ }
+ let bytes = inner.as_bytes();
+ let mut maximum = 0;
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'`' {
+ let start = i;
+ while i < bytes.len() && bytes[i] == b'`' {
+ i += 1;
+ }
+ maximum = maximum.max(i - start);
+ } else {
+ i += 1;
+ }
+ }
+ let delimiter = "`".repeat(maximum + 1);
+ let inner = if maximum > 0 {
+ format!(" {inner} ")
+ } else {
+ inner.to_string()
+ };
+ format!("{prefix}{delimiter}{inner}{delimiter}{suffix}")
+ }
+
+ fn convert_div(&self, text: String, parent_tags: &HashSet<String>) -> String {
+ if parent_tags.contains("_inline") {
+ return format!(" {} ", text.trim());
+ }
+ let text = text.trim();
+ if text.is_empty() {
+ String::new()
+ } else {
+ format!("\n\n{text}\n\n")
+ }
+ }
+
+ fn convert_dd(&self, text: String, parent_tags: &HashSet<String>) -> String {
+ let text = text.trim();
+ if parent_tags.contains("_inline") {
+ return format!(" {text} ");
+ }
+ if text.is_empty() {
+ return "\n".to_string();
+ }
+ let indented = indent_lines(text, " ", "");
+ format!(":{}\n", &indented[1..])
+ }
+
+ fn convert_dt(&self, text: String, parent_tags: &HashSet<String>) -> String {
+ let text = collapse_ascii_ws(text.trim());
+ if parent_tags.contains("_inline") {
+ return format!(" {text} ");
+ }
+ if text.is_empty() {
+ "\n".to_string()
+ } else {
+ format!("\n\n{text}\n")
+ }
+ }
+
+ fn convert_heading(&self, number: usize, text: &str, parent_tags: &HashSet<String>) -> String {
+ if parent_tags.contains("_inline") {
+ return text.to_string();
+ }
+ let number = number.clamp(1, 6);
+ let text = text.trim();
+ if number <= 2 {
+ if text.is_empty() {
+ return String::new();
+ }
+ let underline = if number == 1 { '=' } else { '-' };
+ return format!(
+ "\n\n{text}\n{}\n\n",
+ underline.to_string().repeat(text.chars().count())
+ );
+ }
+ let text = collapse_ascii_ws(text);
+ format!("\n\n{} {text}\n\n", "#".repeat(number))
+ }
+
+ fn convert_img(&self, id: usize, parent_tags: &HashSet<String>) -> String {
+ let alt = self.tree.attr(id, "alt").unwrap_or("");
+ if parent_tags.contains("_inline") {
+ return alt.to_string();
+ }
+ let src = self.tree.attr(id, "src").unwrap_or("");
+ let title = self
+ .tree
+ .attr(id, "title")
+ .filter(|value| !value.is_empty())
+ .map(|value| format!(" \"{}\"", value.replace('"', r#"\""#)))
+ .unwrap_or_default();
+ format!("")
+ }
+
+ fn convert_video(&self, id: usize, text: String, parent_tags: &HashSet<String>) -> String {
+ if parent_tags.contains("_inline") {
+ return text;
+ }
+ let mut src = self.tree.attr(id, "src").unwrap_or("");
+ if src.is_empty() {
+ let mut sources = Vec::new();
+ self.tree
+ .element_children_recursive(id, &["source"], &mut sources);
+ src = sources
+ .iter()
+ .find_map(|source| self.tree.attr(*source, "src"))
+ .unwrap_or("");
+ }
+ let poster = self.tree.attr(id, "poster").unwrap_or("");
+ match (src.is_empty(), poster.is_empty()) {
+ (false, false) => format!("[]({src})"),
+ (false, true) => format!("[{text}]({src})"),
+ (true, false) => format!(""),
+ (true, true) => text,
+ }
+ }
+
+ fn convert_list(&self, id: usize, text: String, parent_tags: &HashSet<String>) -> String {
+ // markdownify: before_paragraph is true when the next block-content
+ // sibling is anything but another list — INCLUDING a bare text node
+ // (name None), which the old `.and_then(name)` dropped, so a list
+ // trailed by text lost its separating blank line.
+ let before_paragraph = next_block_content(self.tree, id)
+ .is_some_and(|node| !matches!(self.tree.name(node), Some("ul" | "ol")));
+ if parent_tags.contains("li") {
+ return format!("\n{}", text.trim_end());
+ }
+ format!("\n\n{text}{}", if before_paragraph { "\n" } else { "" })
+ }
+
+ fn convert_li(&self, id: usize, text: String) -> String {
+ let text = text.trim();
+ if text.is_empty() {
+ return "\n".to_string();
+ }
+ let parent = self.tree.nodes[id].parent;
+ let bullet = if parent.and_then(|node| self.tree.name(node)) == Some("ol") {
+ let parent = parent.unwrap();
+ // ponytail: ASCII-only, like colspan below. Python's int() also
+ // parses Unicode decimal digits (Arabic-Indic, etc.), which std
+ // can't decode without a unicode-data crate — a marginal `start`
+ // value not worth the dependency. Upgrade: add `unicode` and map
+ // Nd digits if a golden ever needs it.
+ let start = self
+ .tree
+ .attr(parent, "start")
+ .filter(|value| !value.is_empty() && value.chars().all(|c| c.is_ascii_digit()))
+ .and_then(|value| value.parse::<usize>().ok())
+ .unwrap_or(1);
+ let previous_items = self
+ .tree
+ .sibling_index(id)
+ .map(|(parent, index)| {
+ self.tree.nodes[parent].children[..index]
+ .iter()
+ .filter(|node| self.tree.name(**node) == Some("li"))
+ .count()
+ })
+ .unwrap_or(0);
+ format!("{}.", start + previous_items)
+ } else {
+ let mut depth: isize = -1;
+ let mut cursor = Some(id);
+ while let Some(node) = cursor {
+ if self.tree.name(node) == Some("ul") {
+ depth += 1;
+ }
+ cursor = self.tree.nodes[node].parent;
+ }
+ ['*', '+', '-'][depth.rem_euclid(3) as usize].to_string()
+ };
+ let marker = format!("{bullet} ");
+ let indent = " ".repeat(marker.len());
+ let indented = indent_lines(text, &indent, "");
+ format!("{marker}{}\n", &indented[marker.len()..])
+ }
+
+ fn convert_p(&self, text: String, parent_tags: &HashSet<String>) -> String {
+ if parent_tags.contains("_inline") {
+ return format!(" {} ", trim_ascii_markdown(&text));
+ }
+ let text = trim_ascii_markdown(&text);
+ if text.is_empty() {
+ String::new()
+ } else {
+ format!("\n\n{text}\n\n")
+ }
+ }
+
+ fn convert_pre(&self, text: String) -> String {
+ if text.is_empty() {
+ return String::new();
+ }
+ // markdownify's STRIP mode: remove everything through the last
+ // leading newline (but preserve indentation after it), then remove
+ // all trailing spaces/newlines.
+ let start = text
+ .char_indices()
+ .take_while(|(_, c)| matches!(c, ' ' | '\n'))
+ .filter(|(_, c)| *c == '\n')
+ .map(|(index, _)| index + 1)
+ .last()
+ .unwrap_or(0);
+ let text = text[start..].trim_end_matches([' ', '\n']);
+ format!("\n\n```\n{text}\n```\n\n")
+ }
+
+ fn convert_cell(&self, id: usize, text: String) -> String {
+ let colspan = self
+ .tree
+ .attr(id, "colspan")
+ .filter(|value| value.chars().all(|c| c.is_ascii_digit()))
+ .and_then(|value| value.parse::<usize>().ok())
+ .unwrap_or(1)
+ .clamp(1, 1000);
+ format!(
+ " {}{}",
+ text.trim().replace('\n', " "),
+ " |".repeat(colspan)
+ )
+ }
+
+ fn convert_row(&self, id: usize, text: String) -> String {
+ let mut cells = Vec::new();
+ self.tree
+ .element_children_recursive(id, &["td", "th"], &mut cells);
+ let is_first_row = self.tree.previous_element_sibling(id).is_none();
+ let parent = self.tree.nodes[id].parent.unwrap_or(0);
+ let parent_name = self.tree.name(parent).unwrap_or("");
+ let is_headrow = cells.iter().all(|cell| self.tree.name(*cell) == Some("th"))
+ || (parent_name == "thead" && {
+ let mut rows = Vec::new();
+ self.tree
+ .element_children_recursive(parent, &["tr"], &mut rows);
+ rows.len() == 1
+ });
+ let table_has_thead = self.tree.nodes[parent].parent.is_some_and(|table| {
+ let mut heads = Vec::new();
+ self.tree
+ .element_children_recursive(table, &["thead"], &mut heads);
+ !heads.is_empty()
+ });
+ let head_missing = (is_first_row && parent_name != "tbody")
+ || (is_first_row && parent_name == "tbody" && !table_has_thead);
+ let full_colspan: usize = cells
+ .iter()
+ .map(|cell| {
+ self.tree
+ .attr(*cell, "colspan")
+ .filter(|value| value.chars().all(|c| c.is_ascii_digit()))
+ .and_then(|value| value.parse::<usize>().ok())
+ .unwrap_or(1)
+ .clamp(1, 1000)
+ })
+ .sum();
+ let mut overline = String::new();
+ let mut underline = String::new();
+ if is_headrow && is_first_row {
+ underline = format!("| {} |\n", vec!["---"; full_colspan].join(" | "));
+ } else {
+ let tbody_at_table_start =
+ parent_name == "tbody" && self.tree.previous_element_sibling(parent).is_none();
+ if head_missing || (is_first_row && (parent_name == "table" || tbody_at_table_start)) {
+ overline.push_str(&format!("| {} |\n", vec![""; full_colspan].join(" | ")));
+ overline.push_str(&format!("| {} |\n", vec!["---"; full_colspan].join(" | ")));
+ }
+ }
+ format!("{overline}|{text}\n{underline}")
+ }
+}
+
+fn markdownify(content: &str) -> String {
+ let tree = parse_markdown_tree(content);
+ MarkdownConverter { tree: &tree }.process()
+}
+
+/// One target's rendering, `extraction_type` mode (shell.py). A
+/// `QueryResult::Text` (a `::text`/`::attr()` pseudo-match) short-circuits
+/// exactly like Python's text-node `Selector`: both `html_content` and
+/// `get_all_text` return the bare value with no re-serialization
+/// (`parser.py` — `if self._is_text_node(self._root): return ...`), so
+/// `html`/`markdown` treat the value as their "outer html" and `text` skips
+/// straight past `get_all_text` to collapsing the value itself.
+///
+/// Oracle-probed (`li a::text` / `a::attr(href)` on basic.html): all three
+/// modes give the identical bare value there, because it contains no HTML or
+/// markdown-special characters. Markdown mode still runs the value through
+/// the converter rather than passing it through raw, because markdownify
+/// escapes markdown-significant characters even in a tag-less string —
+/// reprobed with `1. *starred* & _under_ # hash`:
+/// `markdownify` gives `1. \*starred\* & \_under\_ # hash`; the local port is
+/// still run for this tag-less input because escaping is part of its contract.
+fn render_one(target: &query::QueryResult, format: &str) -> Result<String, String> {
+ if format == "text" {
+ let raw = match target {
+ query::QueryResult::Element(el) => dom::get_all_text(
+ *el,
+ "\n",
+ true,
+ &["script", "style", "noscript", "svg", "iframe"],
+ true,
+ ),
+ query::QueryResult::Text { value, .. } => value.clone(),
+ };
+ return Ok(collapse_whitespace(raw));
+ }
+ let content_source = match target {
+ query::QueryResult::Element(el) => dom::outer_html(*el),
+ query::QueryResult::Text { value, .. } => value.clone(),
+ };
+ match format {
+ "html" => Ok(content_source),
+ "markdown" => Ok(markdownify(&content_source)),
+ _ => unreachable!("format validated by render()"),
+ }
+}
+
+/// `Convertor._extract_content` + `render_content`'s `"".join(...).strip()`
+/// (shell.py / core.py, normative): validate format; optionally re-scope to
+/// `body` and sanitize a clone; optionally scope further to every
+/// `css_selector` match (concatenated, no separator; `::text`/`::attr()`
+/// pseudo-matches render too, see `render_one`); render each target in
+/// `format`; join and trim once at the end.
+pub fn render(
+ doc: &Doc,
+ format: &str,
+ css_selector: Option<&str>,
+ main_content_only: bool,
+) -> Result<String, String> {
+ if !matches!(format, "markdown" | "text" | "html") {
+ return Err(format!("unsupported format: {format}"));
+ }
+
+ // Resolve the scope root on the ORIGINAL tree first — `body_or_root`'s
+ // tag lookup doesn't depend on sanitization — then clone and sanitize
+ // with that id exempted (see `sanitize_main_content`'s doc comment).
+ // NodeIds are stable across `Document::clone()`, so the id found here
+ // still names the same node in the clone.
+ let sanitized = main_content_only.then(|| {
+ let scope_id = body_or_root(doc).id();
+ let mut sanitized = doc.clone();
+ sanitize_main_content(&mut sanitized, scope_id);
+ (sanitized, scope_id)
+ });
+ let (active_doc, root): (&Doc, ElementRef) = match &sanitized {
+ Some((d, id)) => (d, d.element(*id).expect("body_or_root remains an element")),
+ None => (doc, doc.root()),
+ };
+
+ let targets: Vec<query::QueryResult> = match css_selector.filter(|s| !s.is_empty()) {
+ Some(sel) => query::css_query(active_doc, Some(root), sel)?,
+ None => vec![query::QueryResult::Element(root)],
+ };
+
+ let mut content = String::new();
+ for t in &targets {
+ content.push_str(&render_one(t, format)?);
+ }
+ Ok(content.trim().to_string())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::scrapling::dom;
+
+ #[test]
+ fn markdown_contains_heading_and_list() {
+ let d = dom::parse(r#"<html><body><h1>Hello</h1><ul><li>a</li></ul></body></html>"#);
+ let md = render(&d, "markdown", None, false).unwrap();
+ assert!(md.contains("Hello"));
+ assert!(md.contains("a"));
+ }
+
+ #[test]
+ fn hidden_and_zero_width_stripping() {
+ let d = dom::parse(concat!(
+ r#"<html><body><p>keep</p><p style="display:none">drop</p>"#,
+ "<p>ze\u{200b}ro</p></body></html>"
+ ));
+ let txt = render(&d, "text", None, true).unwrap();
+ assert!(txt.contains("keep"));
+ assert!(!txt.contains("drop"));
+ assert!(txt.contains("zero"));
+ }
+
+ #[test]
+ fn bad_format_error_matches_python() {
+ let d = dom::parse("<p>x</p>");
+ assert_eq!(
+ render(&d, "pdf", None, false).unwrap_err(),
+ "unsupported format: pdf"
+ );
+ }
+
+ /// `_HIDDEN_XPATH` is `.//*[@aria-hidden='true']` — descendant axis, self
+ /// excluded — so the scope root carrying the attribute must not drop
+ /// itself. Oracle-confirmed: `{"content": "keep me"}`, not `""`.
+ #[test]
+ fn body_aria_hidden_does_not_drop_itself() {
+ let d = dom::parse(r#"<html><body aria-hidden="true"><p>keep me</p></body></html>"#);
+ assert_eq!(render(&d, "text", None, true).unwrap(), "keep me");
+ }
+
+ /// Same exemption, via the style-substring half of `_HIDDEN_XPATH`
+ /// (`.//*[contains(@style, "display:none") ...]`). Oracle-confirmed:
+ /// `{"content": "keep me too"}`.
+ #[test]
+ fn body_style_hidden_does_not_drop_itself() {
+ let d = dom::parse(r#"<html><body style="display:none"><p>keep me too</p></body></html>"#);
+ assert_eq!(render(&d, "text", None, true).unwrap(), "keep me too");
+ }
+}
diff --git a/browser/src/scrapling/mod.rs b/browser/src/scrapling/mod.rs
new file mode 100644
index 000000000..f6c247a1d
--- /dev/null
+++ b/browser/src/scrapling/mod.rs
@@ -0,0 +1,260 @@
+//! The `browser::*` surface: scrapling's parse-only functions,
+//! natively. `register_all` binds the 19 parse functions and the guidance hook
+//! function on the iii bus; `apply_guidance` binds the guidance hook to
+//! `harness::hook::pre-generate`.
+//!
+//! Wire contract: schemas byte-identical to scrapling/src/schemas.py modulo the
+//! `browser::` id prefix (golden-pinned); behavior differential-pinned against
+//! the frozen Scrapling 0.4.9 worker.
+//!
+//! Registration deliberately stays separate from `crate::functions`
+//! (the 29 `browser::*` functions): that module pins its surface with
+//! schemars-derived schemas and self-regenerating goldens, while this one
+//! carries Python-mirrored literals checked against read-only goldens. Two
+//! catalogs, two invariants, no interleaving.
+
+pub mod adaptive;
+mod browserforge;
+pub mod cdp;
+pub mod crawl;
+pub mod dom;
+pub mod egress_gate;
+pub mod fetch;
+pub mod inject_guidance;
+pub mod markdown;
+pub mod net;
+pub mod ops;
+pub mod page;
+pub mod query;
+pub mod raw_browser;
+pub mod schemas;
+pub mod selgen;
+pub mod sessions;
+pub mod similar;
+pub mod text;
+pub mod xpath;
+
+use std::sync::Arc;
+
+use serde_json::Value;
+
+pub(crate) fn require_str<'a>(payload: &'a Value, key: &str) -> Result<&'a str, String> {
+ payload
+ .get(key)
+ .and_then(Value::as_str)
+ .ok_or_else(|| format!("'{key}'"))
+}
+
+/// The 19 catalog function ids (in `schemas::catalog()` order) plus the
+/// internal guidance hook, last. `register_all` asserts it registers exactly
+/// this set, in this order.
+pub const STATIC_IDS: &[&str] = &[
+ "browser::fetch",
+ "browser::stealthy-fetch",
+ "browser::dynamic-fetch",
+ "browser::screenshot-url",
+ "browser::extract",
+ "browser::css",
+ "browser::xpath",
+ "browser::regex",
+ "browser::find-similar",
+ "browser::find",
+ "browser::find-by-text",
+ "browser::find-by-regex",
+ "browser::describe",
+ "browser::to-markdown",
+ "browser::session-open",
+ "browser::session-fetch",
+ "browser::session-close",
+ "browser::session-list",
+ "browser::crawl",
+ inject_guidance::GUIDANCE_HOOK_ID,
+];
+
+/// An op's dispatch fn pointer (named alias: clippy::type_complexity on the
+/// bare `fn(&Value) -> Result<Value, String>` spelled out at every use site).
+type Op = fn(&Value) -> Result<Value, String>;
+
+/// Look up the op fn for a catalog function id. `None` for anything not in
+/// the catalog (including the guidance hook, which isn't dispatched here).
+pub fn op_for(id: &str) -> Option<Op> {
+ Some(match id {
+ "browser::extract" => ops::extract::op,
+ "browser::css" => ops::css_fn::op,
+ "browser::xpath" => ops::xpath_fn::op,
+ "browser::regex" => ops::regex_fn::op,
+ "browser::find-similar" => ops::find_similar::op,
+ "browser::find" => ops::find::op,
+ "browser::find-by-text" => ops::find_by_text::op,
+ "browser::find-by-regex" => ops::find_by_regex::op,
+ "browser::describe" => ops::describe::op,
+ "browser::to-markdown" => ops::to_markdown::op,
+ _ => return None,
+ })
+}
+
+pub fn dispatch_op(function_id: &str, payload: &Value) -> Result<Value, String> {
+ match op_for(function_id) {
+ Some(op) => op(payload),
+ None => Err(format!("not implemented: {function_id}")),
+ }
+}
+
+/// Register all 19 `browser::*` functions plus the internal
+/// guidance hook on the iii bus.
+///
+/// The catalog is served by two handler families and every entry belongs to
+/// exactly one: the ten parse ops are sync and stateless
+/// (`fn(&Value) -> Result<Value>`, found via `op_for`), while the nine
+/// outbound ones are async and need `net::Ctx`. Both take and return untyped
+/// `serde_json::Value` — schemars would derive the permissive `AnyValue`
+/// schema for that — so the `.request_format`/`.response_format` overrides
+/// carrying `schemas::catalog()`'s Python-mirrored literals are mandatory.
+/// The guidance hook uses real typed structs and relies on derivation.
+pub fn register_all(iii: &Arc<iii_sdk::IIIClient>, ctx: &Arc<net::Ctx>) {
+ let mut registered: Vec<&str> = Vec::new();
+ for spec in crate::scrapling::schemas::catalog() {
+ registered.push(spec.function_id);
+ match op_for(spec.function_id) {
+ Some(op) => {
+ iii.register_function(
+ spec.function_id,
+ iii_sdk::RegisterFunction::new_async(
+ move |payload: serde_json::Value| async move {
+ // Parse ops are synchronous and CPU-bound; some
+ // (regex/find-by-regex on the vendored sre_engine,
+ // which has no backtracking limit) can run for a
+ // long time on adversarial input. Run them off the
+ // async runtime so one call can't peg a runtime
+ // worker and stall the interactive functions and
+ // outbound fetches that share it.
+ tokio::task::spawn_blocking(move || op(&payload))
+ .await
+ .map_err(|e| iii_sdk::Error::from(format!("parse op failed: {e}")))?
+ .map_err(iii_sdk::Error::from)
+ },
+ )
+ .description(spec.description)
+ .request_format(spec.request.clone())
+ .response_format(spec.response.clone()),
+ );
+ }
+ None => {
+ let id = spec.function_id;
+ let cx = ctx.clone();
+ iii.register_function(
+ id,
+ iii_sdk::RegisterFunction::new_async(move |payload: serde_json::Value| {
+ let cx = cx.clone();
+ async move {
+ net::dispatch(&cx, id, &payload)
+ .await
+ .map_err(iii_sdk::Error::from)
+ }
+ })
+ .description(spec.description)
+ .request_format(spec.request.clone())
+ .response_format(spec.response.clone()),
+ );
+ }
+ }
+ }
+ registered.push(inject_guidance::GUIDANCE_HOOK_ID);
+ iii.register_function(
+ inject_guidance::GUIDANCE_HOOK_ID,
+ iii_sdk::RegisterFunction::new_async(
+ |event: inject_guidance::PreGenerateEvent| async move {
+ inject_guidance::handle(event).await
+ },
+ )
+ .description(inject_guidance::GUIDANCE_HOOK_DESC)
+ .metadata(serde_json::json!({ "internal": true })),
+ );
+ assert_eq!(
+ registered, STATIC_IDS,
+ "register_all must register exactly STATIC_IDS"
+ );
+ tracing::info!("browser::* functions registered");
+}
+
+/// The live pre-generate guidance binding, if any. Shared with the
+/// configuration change handler so a `browser.scrapling.inject_guidance`
+/// flip binds/unbinds at runtime — no worker restart (mirrors
+/// fp/src/guidance.rs).
+pub type GuidanceState = iii_config_client::BindingSlot;
+
+/// Reconcile the guidance binding with the configured `inject_guidance`
+/// value: on → bind once; off → unregister and drop the handle. Idempotent
+/// under repeated config events; a failed bind retries on the next event.
+/// The hook FUNCTION stays registered either way (`register_all`) — an
+/// unbound function is inert, and keeping it registered is what lets a
+/// config flip enable injection without a restart.
+///
+/// `on_error: fail_open` is MANDATORY: pre_generate defaults fail-CLOSED,
+/// and a missing guidance line must never abort a turn.
+/// `metadata.inject_prompt` carries the guidance statically so the harness
+/// appends it without an RPC per generate step; without it every model-call
+/// step makes a live call to this worker and blocks generation on the answer
+/// (and the guidance vanishes from the frozen-prompt preview).
+pub fn apply_guidance(iii: &iii_sdk::IIIClient, state: &GuidanceState, enabled: bool) {
+ state.reconcile(
+ enabled,
+ || {
+ iii_config_client::try_bind(
+ iii,
+ iii_sdk::protocol::RegisterTriggerInput {
+ trigger_type: "harness::hook::pre-generate".to_string(),
+ function_id: inject_guidance::GUIDANCE_HOOK_ID.to_string(),
+ config: serde_json::json!({ "on_error": "fail_open" }),
+ metadata: Some(
+ serde_json::json!({ "inject_prompt": inject_guidance::GUIDANCE }),
+ ),
+ },
+ )
+ },
+ "inject_guidance on: appending browser::* scraping guidance to agent system prompts",
+ "inject_guidance off: browser::* scraping guidance stays out of agent system prompts",
+ );
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ /// `register_all` picks a handler family per catalog entry. If an id
+ /// belonged to neither (or both), registration would silently ship a
+ /// function that always answers "not implemented" — so pin the partition
+ /// here rather than discovering it on the bus.
+ #[test]
+ fn every_catalog_id_has_exactly_one_handler_family() {
+ for spec in schemas::catalog() {
+ let sync = op_for(spec.function_id).is_some();
+ let net = net::NET_IDS.contains(&spec.function_id);
+ assert!(
+ sync ^ net,
+ "{} must be handled by exactly one family (sync parse op: {sync}, net: {net})",
+ spec.function_id
+ );
+ }
+ }
+
+ #[test]
+ fn static_ids_are_the_catalog_in_order_plus_the_hook() {
+ let mut expected: Vec<&str> = schemas::catalog().iter().map(|s| s.function_id).collect();
+ expected.push(inject_guidance::GUIDANCE_HOOK_ID);
+ assert_eq!(STATIC_IDS, expected.as_slice());
+ }
+
+ #[test]
+ fn net_ids_covers_every_non_parse_catalog_entry() {
+ let catalog_net: Vec<&str> = schemas::catalog()
+ .iter()
+ .map(|s| s.function_id)
+ .filter(|id| op_for(id).is_none())
+ .collect();
+ assert_eq!(catalog_net.len(), net::NET_IDS.len());
+ for id in &catalog_net {
+ assert!(net::NET_IDS.contains(id), "{id} missing from NET_IDS");
+ }
+ }
+}
diff --git a/browser/src/scrapling/net.rs b/browser/src/scrapling/net.rs
new file mode 100644
index 000000000..6c621589b
--- /dev/null
+++ b/browser/src/scrapling/net.rs
@@ -0,0 +1,524 @@
+//! The nine outbound `browser::*` functions: the fetch tiers,
+//! screenshot, persistent sessions and crawl.
+//!
+//! Unlike the ten parse ops (sync, stateless, `fn(&Value) -> Result<Value>`),
+//! these are async and need state — an HTTP session registry, the browser
+//! session registry, config and the bus — so they carry a `Ctx` and register
+//! through their own path in `super::register_all`.
+
+use std::sync::Arc;
+
+use futures::StreamExt;
+use serde_json::{json, Value};
+
+use crate::config::{SecurityMode, SharedConfig, WorkerConfig};
+use crate::scrapling::crawl::{self, CrawlOpts};
+use crate::scrapling::fetch::{self, HttpMode, HttpOptions};
+use crate::scrapling::page::{self, PageData};
+use crate::scrapling::raw_browser::{RawBrowser, RawBrowserOptions};
+use crate::scrapling::sessions::{parse_type, uses_compat_only_options, Registry};
+use crate::session::Sessions;
+use crate::ssrf::SsrfPolicy;
+
+pub struct Ctx {
+ pub http: Registry,
+ pub config: SharedConfig,
+ pub iii: Arc<iii_sdk::IIIClient>,
+}
+
+impl Ctx {
+ pub fn new(sessions: Arc<Sessions>, iii: Arc<iii_sdk::IIIClient>) -> Self {
+ let config = sessions.config.clone();
+ let startup = config.load().scrapling.startup_snapshot();
+ Self {
+ http: Registry::new(startup.max_sessions, startup.session_idle_timeout_s),
+ config,
+ iii,
+ }
+ }
+
+ pub fn policy(&self) -> SsrfPolicy {
+ SsrfPolicy {
+ allow_loopback: self.config.load().scrapling.allow_loopback,
+ }
+ }
+}
+
+/// Run one fetch per target URL, single or bulk, isolating per-URL failures.
+async fn fetch_targets<F, Fut>(
+ payload: &Value,
+ concurrency: usize,
+ fetch_one: F,
+) -> Result<Value, String>
+where
+ F: Fn(String) -> Fut + Sync,
+ Fut: std::future::Future<Output = Result<PageData, String>>,
+{
+ let (urls, bulk) = page::targets(payload)?;
+ let include_html = page::include_html(payload);
+ if !bulk {
+ let p = fetch_one(urls[0].clone()).await?;
+ return page::serialize_page(&p, payload, include_html);
+ }
+ let out = futures::stream::iter(urls.into_iter().map(|url| {
+ let fetch_one = &fetch_one;
+ async move {
+ match fetch_one(url.clone()).await {
+ Ok(page) => page::serialize_page(&page, payload, include_html)
+ .map_err(|error| (url.clone(), error)),
+ Err(error) => Err((url, error)),
+ }
+ }
+ }))
+ .buffered(concurrency)
+ .collect::<Vec<_>>()
+ .await;
+ Ok(page::bulk_results(out))
+}
+
+fn one_shot_payload(config: &WorkerConfig, payload: &Value, include_html_default: bool) -> Value {
+ let mut request = payload.as_object().cloned().unwrap_or_default();
+ let defaults = &config.scrapling.defaults;
+ // Safe mode refuses every proxy, so injecting the config default would
+ // fail every outbound call with an error blaming a "caller proxy" the
+ // caller never sent. The knob is compat-only; safe mode leaves it out and
+ // a caller-passed proxy still gets the explicit refusal.
+ let inject_proxy = config.scrapling.security_mode == SecurityMode::Compat;
+ for (key, value) in [
+ ("impersonate", json!(defaults.impersonate)),
+ ("headless", json!(defaults.headless)),
+ ("network_idle", json!(defaults.network_idle)),
+ ("proxy", json!(defaults.proxy)),
+ ] {
+ if key == "proxy" && !inject_proxy {
+ continue;
+ }
+ if request.get(key).is_none_or(Value::is_null) && value != json!("") {
+ request.insert(key.to_string(), value);
+ }
+ }
+ if include_html_default && request.get("include_html").is_none_or(Value::is_null) {
+ request.insert("include_html".to_string(), json!(defaults.include_html));
+ }
+ Value::Object(request)
+}
+
+fn http_mode(ctx: &Ctx) -> HttpMode {
+ match ctx.config.load().scrapling.security_mode {
+ SecurityMode::Safe => HttpMode::Safe,
+ SecurityMode::Compat => HttpMode::Compat,
+ }
+}
+
+async fn raw_browser_targets(ctx: &Ctx, payload: &Value, stealth: bool) -> Result<Value, String> {
+ let config = ctx.config.load_full();
+ let request = one_shot_payload(&config, payload, true);
+ let mut options = RawBrowserOptions::from_payload(&request)?;
+ options.clamp_durations(config.max_timeout_ms);
+ options.validate_policy(config.scrapling.security_mode)?;
+ let concurrency = usize::try_from(config.scrapling.max_bulk_concurrency)
+ .unwrap_or(usize::MAX)
+ .max(1);
+ let (urls, bulk) = page::targets(&request)?;
+ let include_html = page::include_html(&request);
+ if !bulk {
+ let browser = RawBrowser::start(&config, &options, stealth, false).await?;
+ let fetched = browser.fetch(&urls[0], &options, stealth).await?;
+ return page::serialize_page(&fetched, &request, include_html);
+ }
+ let output = futures::stream::iter(urls.into_iter().map(|url| {
+ let config = config.clone();
+ let options = options.clone();
+ let request = request.clone();
+ async move {
+ let fetched = async {
+ let browser = RawBrowser::start(&config, &options, stealth, false).await?;
+ browser.fetch(&url, &options, stealth).await
+ }
+ .await;
+ match fetched {
+ Ok(page) => page::serialize_page(&page, &request, include_html)
+ .map_err(|error| (url.clone(), error)),
+ Err(error) => Err((url, error)),
+ }
+ }
+ }))
+ .buffered(concurrency)
+ .collect::<Vec<_>>()
+ .await;
+ Ok(page::bulk_results(output))
+}
+
+// ---- the nine handlers ---------------------------------------------------
+
+pub async fn op_fetch(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ let config = ctx.config.load_full();
+ let request = one_shot_payload(&config, payload, true);
+ let opts = HttpOptions::from_payload_for_mode(&request, http_mode(ctx))?;
+ let policy = ctx.policy();
+ let concurrency = usize::try_from(config.scrapling.max_bulk_concurrency)
+ .unwrap_or(usize::MAX)
+ .max(1);
+ fetch_targets(&request, concurrency, |url| {
+ let opts = &opts;
+ let policy = &policy;
+ async move { fetch::fetch_page(&url, opts, policy).await }
+ })
+ .await
+}
+
+pub async fn op_dynamic_fetch(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ raw_browser_targets(ctx, payload, false).await
+}
+
+pub async fn op_stealthy_fetch(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ raw_browser_targets(ctx, payload, true).await
+}
+
+pub async fn op_screenshot(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ let cfg = ctx.config.load_full();
+ let request = one_shot_payload(&cfg, payload, false);
+ let url = request
+ .get("url")
+ .and_then(Value::as_str)
+ .filter(|u| !u.is_empty())
+ .ok_or("provide `url`")?;
+ let fetcher = request
+ .get("fetcher")
+ .and_then(Value::as_str)
+ .unwrap_or("dynamic");
+ let format = request
+ .get("format")
+ .and_then(Value::as_str)
+ .unwrap_or("png");
+ let full_page = request
+ .get("full_page")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+
+ let mut options = RawBrowserOptions::from_payload(&request)?;
+ options.clamp_durations(cfg.max_timeout_ms);
+ let browser = RawBrowser::start(&cfg, &options, fetcher == "stealthy", false).await?;
+ let (content, mime, final_url) = browser
+ .screenshot(url, &options, fetcher == "stealthy", full_page, format)
+ .await?;
+ Ok(json!({"content": content, "mime": mime, "url": final_url}))
+}
+
+pub async fn op_session_open(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ let stype = parse_type(payload)?;
+ let mode = ctx.config.load().scrapling.security_mode;
+ let compat_only = uses_compat_only_options(payload) || mode == SecurityMode::Compat;
+ if compat_only && mode == SecurityMode::Safe {
+ return Err(
+ "session options require browser.scrapling.security_mode=compat; remove them or switch modes"
+ .to_string(),
+ );
+ }
+ if stype == crate::scrapling::sessions::SessionType::Http {
+ ctx.http
+ .open_http(payload, compat_only, http_mode(ctx))
+ .await
+ } else {
+ ctx.http
+ .open_browser(stype, payload, compat_only, ctx.config.load_full())
+ .await
+ }
+}
+
+pub async fn op_session_fetch(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ let sid = payload
+ .get("session_id")
+ .and_then(Value::as_str)
+ .ok_or("provide `session_id`")?;
+ let url = payload
+ .get("url")
+ .and_then(Value::as_str)
+ .filter(|u| !u.is_empty())
+ .ok_or("provide `url`")?
+ .to_string();
+ validate_session_mode(
+ ctx.http.uses_compat_only_options(sid)?,
+ ctx.config.load().scrapling.security_mode,
+ )?;
+ match ctx.http.session_type(sid)? {
+ crate::scrapling::sessions::SessionType::Http => {
+ let backend = ctx.http.http_backend(sid)?;
+ let request = backend.request(payload);
+ let include_html = page::include_html(&request);
+ let policy = ctx.policy();
+ ctx.http
+ .run(
+ sid,
+ Box::pin(async move {
+ let mut options =
+ HttpOptions::from_payload_for_mode(&request, backend.mode)?;
+ options.jar = Some(backend.jar.clone());
+ #[cfg(feature = "scrapling-compat")]
+ {
+ options.compat_session = backend.compat.clone();
+ }
+ let fetched = fetch::fetch_page(&url, &options, &policy).await?;
+ page::serialize_page(&fetched, &request, include_html)
+ }),
+ )
+ .await
+ }
+ crate::scrapling::sessions::SessionType::Dynamic
+ | crate::scrapling::sessions::SessionType::Stealthy => {
+ let backend = ctx.http.browser_backend(sid)?;
+ let request = backend.request(payload);
+ let proxy_override = payload
+ .get("proxy")
+ .filter(|value| !value.is_null())
+ .is_some_and(|value| value.as_str() != Some(""));
+ let include_html = page::include_html(&request);
+ let security_mode = backend.security_mode;
+ let max_timeout_ms = ctx.config.load().max_timeout_ms;
+ ctx.http
+ .run(
+ sid,
+ Box::pin(async move {
+ let mut options = RawBrowserOptions::from_payload(&request)?;
+ options.clamp_durations(max_timeout_ms);
+ options.validate_policy(security_mode)?;
+ let fetched = backend
+ .browser
+ .fetch_session(&url, &options, backend.stealth, proxy_override)
+ .await?;
+ page::serialize_page(&fetched, &request, include_html)
+ }),
+ )
+ .await
+ }
+ }
+}
+
+fn validate_session_mode(compat_only: bool, mode: SecurityMode) -> Result<(), String> {
+ if compat_only && mode == SecurityMode::Safe {
+ return Err(
+ "this session uses compat-only options and safe mode is now active; close and reopen the session"
+ .to_string(),
+ );
+ }
+ Ok(())
+}
+
+pub async fn op_session_close(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ let sid = payload
+ .get("session_id")
+ .and_then(Value::as_str)
+ .ok_or("provide `session_id`")?;
+ Ok(ctx.http.close(sid).await)
+}
+
+pub async fn op_session_list(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ Ok(ctx.http.list(payload.get("type")))
+}
+
+pub async fn op_crawl(ctx: &Ctx, payload: &Value) -> Result<Value, String> {
+ let cfg = ctx.config.load_full();
+ let opts = CrawlOpts::from_payload_for_mode(
+ payload,
+ cfg.scrapling.max_bulk_concurrency as usize,
+ cfg.scrapling.security_mode,
+ )?;
+ let (group_id, group_id_text) = crawl_group_id(payload);
+
+ let http = opts.fetcher == "http";
+ let policy = ctx.policy();
+ let mode = ctx.config.load().scrapling.security_mode;
+ // Atomic, not Cell: this future is handed to the SDK, which requires Send
+ // + Sync.
+ let seq = std::sync::atomic::AtomicUsize::new(0);
+
+ let outcome = crawl::run(
+ &opts,
+ payload,
+ |url| {
+ let cfg = cfg.clone();
+ let policy = &policy;
+ let stealth = opts.fetcher == "stealthy";
+ let request = one_shot_payload(&cfg, &crawl::fetch_payload(payload, &url), false);
+ async move {
+ if http {
+ let options = HttpOptions::from_payload_for_mode(
+ &request,
+ match mode {
+ SecurityMode::Safe => HttpMode::Safe,
+ SecurityMode::Compat => HttpMode::Compat,
+ },
+ )?;
+ fetch::fetch_page(&url, &options, policy).await
+ } else {
+ let mut options = RawBrowserOptions::from_payload(&request)?;
+ options.clamp_durations(cfg.max_timeout_ms);
+ options.validate_policy(cfg.scrapling.security_mode)?;
+ let browser = RawBrowser::start(&cfg, &options, stealth, false).await?;
+ browser.fetch(&url, &options, stealth).await
+ }
+ }
+ },
+ |item| {
+ let n = seq.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
+ let iii = ctx.iii.clone();
+ let payload = json!({
+ "stream_name": opts.stream_name,
+ "group_id": group_id,
+ "item_id": format!("{group_id_text}-{n:06}"),
+ "data": item,
+ });
+ Box::pin(async move {
+ let res = iii
+ .trigger(iii_sdk::protocol::TriggerRequest {
+ function_id: "stream::set".to_string(),
+ payload,
+ action: None,
+ timeout_ms: Some(5_000),
+ })
+ .await;
+ if let Err(e) = res {
+ tracing::debug!(error = %e, "crawl stream::set failed; continuing");
+ }
+ })
+ },
+ )
+ .await;
+
+ Ok(json!({
+ "stats": {
+ "crawled": outcome.crawled,
+ "items": outcome.item_count,
+ "errors": outcome.errors,
+ "stopped": outcome.stopped,
+ },
+ "items": outcome.items,
+ "stream": {"name": opts.stream_name, "group_id": group_id},
+ }))
+}
+
+fn crawl_group_id(payload: &Value) -> (Value, String) {
+ if let Some(value) = payload
+ .get("group_id")
+ .filter(|value| crawl::json_truthy(value))
+ {
+ let text = match value {
+ Value::String(value) => value.clone(),
+ Value::Bool(true) => "True".into(),
+ Value::Bool(false) | Value::Null => unreachable!("falsy values were filtered"),
+ other => crawl::python_repr(other),
+ };
+ return (value.clone(), text);
+ }
+ let id = uuid::Uuid::new_v4().simple().to_string();
+ (json!(id), id)
+}
+
+/// Route one of the nine async function ids to its handler. The ten sync
+/// parse ops go through `super::op_for` instead; `super::register_all` picks
+/// the path per catalog entry.
+pub async fn dispatch(ctx: &Ctx, function_id: &str, payload: &Value) -> Result<Value, String> {
+ match function_id {
+ "browser::fetch" => op_fetch(ctx, payload).await,
+ "browser::dynamic-fetch" => op_dynamic_fetch(ctx, payload).await,
+ "browser::stealthy-fetch" => op_stealthy_fetch(ctx, payload).await,
+ "browser::screenshot-url" => op_screenshot(ctx, payload).await,
+ "browser::session-open" => op_session_open(ctx, payload).await,
+ "browser::session-fetch" => op_session_fetch(ctx, payload).await,
+ "browser::session-close" => op_session_close(ctx, payload).await,
+ "browser::session-list" => op_session_list(ctx, payload).await,
+ "browser::crawl" => op_crawl(ctx, payload).await,
+ other => Err(format!("not implemented: {other}")),
+ }
+}
+
+/// Every id `dispatch` handles, in catalog order. `super::register_all`
+/// asserts this partitions the catalog exactly with `op_for`.
+pub const NET_IDS: &[&str] = &[
+ "browser::fetch",
+ "browser::stealthy-fetch",
+ "browser::dynamic-fetch",
+ "browser::screenshot-url",
+ "browser::session-open",
+ "browser::session-fetch",
+ "browser::session-close",
+ "browser::session-list",
+ "browser::crawl",
+];
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn every_net_id_dispatches_somewhere() {
+ // A typo'd arm in `dispatch` would silently become "not implemented"
+ // at runtime; this pins the two lists together instead.
+ for id in NET_IDS {
+ assert!(
+ !matches!(id, &"") && crate::scrapling::op_for(id).is_none(),
+ "{id} must not also be a sync parse op"
+ );
+ }
+ }
+
+ #[test]
+ fn one_shot_defaults_apply_to_null_fields_but_crawl_html_stays_request_only() {
+ let mut config = WorkerConfig::default();
+ config.scrapling.defaults.impersonate = "firefox".to_string();
+ config.scrapling.defaults.headless = false;
+ config.scrapling.defaults.network_idle = true;
+ config.scrapling.defaults.proxy = "http://configured".to_string();
+ config.scrapling.defaults.include_html = true;
+ let request = one_shot_payload(
+ &config,
+ &json!({"impersonate": null, "headless": true}),
+ true,
+ );
+ assert_eq!(request["impersonate"], "firefox");
+ assert_eq!(request["headless"], true);
+ assert_eq!(request["network_idle"], true);
+ assert_eq!(request["include_html"], true);
+ // Safe mode (the default) refuses every proxy, so the config default
+ // must NOT be injected — otherwise every fetch fails blaming a caller
+ // proxy nobody sent. Compat mode injects it.
+ assert!(request.get("proxy").is_none());
+ config.scrapling.security_mode = SecurityMode::Compat;
+ let compat = one_shot_payload(&config, &json!({}), true);
+ assert_eq!(compat["proxy"], "http://configured");
+ assert!(one_shot_payload(&config, &json!({}), false)
+ .get("include_html")
+ .is_none());
+ }
+
+ #[test]
+ fn crawl_group_id_honors_nonempty_input_or_generates_uuid4_hex() {
+ assert_eq!(
+ crawl_group_id(&json!({"group_id": "caller-group"})),
+ (json!("caller-group"), "caller-group".into())
+ );
+ assert_eq!(
+ crawl_group_id(&json!({"group_id": 3})),
+ (json!(3), "3".into())
+ );
+ for payload in [json!({}), json!({"group_id": ""})] {
+ let (value, generated) = crawl_group_id(&payload);
+ assert_eq!(value, generated);
+ assert_eq!(generated.len(), 32);
+ assert!(generated
+ .bytes()
+ .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)));
+ assert_eq!(&generated[12..13], "4");
+ }
+ }
+
+ #[test]
+ fn safe_mode_invalidates_a_compat_only_session() {
+ assert_eq!(
+ validate_session_mode(true, SecurityMode::Safe).unwrap_err(),
+ "this session uses compat-only options and safe mode is now active; close and reopen the session"
+ );
+ assert!(validate_session_mode(true, SecurityMode::Compat).is_ok());
+ assert!(validate_session_mode(false, SecurityMode::Safe).is_ok());
+ }
+}
diff --git a/browser/src/scrapling/ops/common.rs b/browser/src/scrapling/ops/common.rs
new file mode 100644
index 000000000..8d7adac93
--- /dev/null
+++ b/browser/src/scrapling/ops/common.rs
@@ -0,0 +1,86 @@
+//! Shared response-shaping helpers (core.py `_bounded`, `serialize_element`).
+
+use serde_json::{json, Value};
+
+use crate::scrapling::{dom, dom::ElementRef, selgen};
+
+pub const MAX_FIND_ITEMS: usize = 100;
+
+pub fn bounded(total: usize, payload: &Value) -> usize {
+ if payload
+ .get("first")
+ .and_then(Value::as_bool)
+ .unwrap_or(false)
+ {
+ return total.min(1);
+ }
+ // `as_i64` is None for a JSON float or numeric string (an LLM emitting
+ // `"limit": 5.0` is common), which would silently fall back to the 100
+ // cap; coerce those too before defaulting.
+ let limit = payload.get("limit").and_then(|v| {
+ v.as_i64()
+ .or_else(|| v.as_f64().map(|f| f as i64))
+ .or_else(|| v.as_str().and_then(|s| s.trim().parse::<i64>().ok()))
+ });
+ let ceiling = match limit {
+ // Clamp to [0, MAX]: limit 0 → none; negative must NOT slice from the end.
+ Some(l) => l.clamp(0, MAX_FIND_ITEMS as i64) as usize,
+ None => MAX_FIND_ITEMS,
+ };
+ total.min(ceiling)
+}
+
+pub fn serialize_element(el: ElementRef) -> Value {
+ json!({
+ "tag": el.name(),
+ "text": dom::get_all_text(el, "\n", true, &["script", "style"], true),
+ "html": dom::outer_html(el),
+ "attrs": dom::attrs_json(el),
+ "css": selgen::css_selector(el),
+ "xpath": selgen::xpath_selector(el),
+ })
+}
+
+/// Shared `{"count", "items"}` tail for the find* ops: `count` is the
+/// pre-cap total, `items` the `bounded` slice, serialized.
+pub fn bounded_items_response(matches: &[ElementRef], payload: &Value) -> Value {
+ let cap = bounded(matches.len(), payload);
+ json!({
+ "count": matches.len(),
+ "items": matches[..cap].iter().map(|e| serialize_element(*e)).collect::<Vec<_>>(),
+ })
+}
+
+/// core.py `_pull`: attr → attribute value or `null` (Text results: always
+/// `null`, they have no attributes of their own); `html` → outer HTML (Text:
+/// the string itself); else `get_all_text` (Text: the string itself).
+pub fn pull(
+ result: &crate::scrapling::query::QueryResult,
+ attr: Option<&str>,
+ html: bool,
+) -> Value {
+ match result {
+ crate::scrapling::query::QueryResult::Element(el) => {
+ if let Some(a) = attr {
+ el.attr(a).map(Into::into).unwrap_or(Value::Null)
+ } else if html {
+ Value::String(crate::scrapling::dom::outer_html(*el))
+ } else {
+ Value::String(crate::scrapling::dom::get_all_text(
+ *el,
+ "\n",
+ false,
+ &["script", "style"],
+ true,
+ ))
+ }
+ }
+ crate::scrapling::query::QueryResult::Text { value, .. } => {
+ if attr.is_some() {
+ Value::Null
+ } else {
+ Value::String(value.clone())
+ }
+ }
+ }
+}
diff --git a/browser/src/scrapling/ops/css_fn.rs b/browser/src/scrapling/ops/css_fn.rs
new file mode 100644
index 000000000..e0c010a13
--- /dev/null
+++ b/browser/src/scrapling/ops/css_fn.rs
@@ -0,0 +1,70 @@
+//! scrapling::css — one CSS query over HTML; first-or-all; `attr` pulls an
+//! attribute else text (core.py `op_query(payload, "css")`).
+
+use serde_json::{json, Value};
+
+use crate::scrapling::{adaptive, dom, query};
+use crate::scrapling::{ops::common, require_str};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let q = require_str(payload, "query")?;
+ let doc = dom::parse(html);
+ let adaptive_enabled = payload
+ .get("adaptive")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let results = if adaptive_enabled {
+ let identifier = payload
+ .get("identifier")
+ .and_then(Value::as_str)
+ .filter(|value| !value.is_empty())
+ .unwrap_or(q);
+ let auto_save = match payload.get("auto_save") {
+ None => true,
+ Some(value) => value.as_bool().unwrap_or(false),
+ };
+ adaptive::css_query(
+ &doc,
+ None,
+ q,
+ payload.get("adaptive_domain").and_then(Value::as_str),
+ identifier,
+ auto_save,
+ )?
+ } else {
+ query::css_query(&doc, None, q)?
+ };
+ let attr = payload
+ .get("attr")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty());
+ if payload
+ .get("first")
+ .and_then(Value::as_bool)
+ .unwrap_or(false)
+ {
+ Ok(json!({ "result": results.first().map(|r| common::pull(r, attr, false)) }))
+ } else {
+ Ok(
+ json!({ "result": results.iter().map(|r| common::pull(r, attr, false)).collect::<Vec<_>>() }),
+ )
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+
+ #[test]
+ fn adaptive_adjacent_fields_without_adaptive_are_ignored() {
+ let out = op(&json!({
+ "html": "<html><body><p>x</p></body></html>",
+ "query": "p", "first": true,
+ "auto_save": true, "adaptive_domain": "example.com", "identifier": "k"
+ }))
+ .unwrap();
+ assert_eq!(out, json!({"result": "x"}));
+ }
+}
diff --git a/browser/src/scrapling/ops/describe.rs b/browser/src/scrapling/ops/describe.rs
new file mode 100644
index 000000000..77397cf11
--- /dev/null
+++ b/browser/src/scrapling/ops/describe.rs
@@ -0,0 +1,80 @@
+//! scrapling::describe — full identity + structure of the first css/xpath
+//! match (core.py `op_describe`).
+
+use serde_json::{json, Value};
+
+use crate::scrapling::{dom, query, selgen};
+use crate::scrapling::{ops::common, require_str};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let q = require_str(payload, "query")?;
+ let doc = dom::parse(html);
+ // Python is `kind.get("kind", "css") == "css"`: the "css" default applies
+ // ONLY to a MISSING key. An explicit `null` (or any non-"css" value) is
+ // not equal to "css", so it takes the xpath branch — match that.
+ let is_css = match payload.get("kind") {
+ None => true,
+ Some(value) => value.as_str() == Some("css"),
+ };
+ let results = if is_css {
+ query::css_query(&doc, None, q)?
+ } else {
+ crate::scrapling::xpath::xpath_query(&doc, None, q)?
+ };
+ let Some(first) = results.first() else {
+ return Ok(json!({"found": false}));
+ };
+ let element = match first {
+ query::QueryResult::Element(el) => {
+ let parent = dom::parent_element(*el);
+ let mut e = common::serialize_element(*el);
+ let obj = e.as_object_mut().unwrap();
+ obj.insert("full_css".into(), json!(selgen::full_css_selector(*el)));
+ obj.insert("full_xpath".into(), json!(selgen::full_xpath_selector(*el)));
+ obj.insert(
+ "classes".into(),
+ json!(el
+ .attr("class")
+ .unwrap_or("")
+ .split_whitespace()
+ .collect::<Vec<_>>()),
+ );
+ obj.insert(
+ "parent_tag".into(),
+ parent.map(|p| json!(p.name())).unwrap_or(Value::Null),
+ );
+ obj.insert("children".into(), json!(dom::element_children(*el).len()));
+ obj.insert(
+ "siblings".into(),
+ json!(parent
+ .map(|p| dom::element_children(p).len().saturating_sub(1))
+ .unwrap_or(0)),
+ );
+ e
+ }
+ query::QueryResult::Text { value, parent } => json!({
+ "tag": "#text",
+ "text": value, "html": value, "attrs": {},
+ "css": "", "xpath": "",
+ "full_css": "", "full_xpath": "",
+ "classes": [],
+ "parent_tag": parent.name(),
+ "children": 0,
+ "siblings": dom::element_children(*parent).len(),
+ }),
+ };
+ Ok(json!({"found": true, "element": element}))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn no_match_is_exactly_found_false() {
+ let out = op(&serde_json::json!({"html": "<p>x</p>", "query": ".nope"})).unwrap();
+ assert_eq!(out, serde_json::json!({"found": false}));
+ assert!(out.get("element").is_none());
+ }
+}
diff --git a/browser/src/scrapling/ops/extract.rs b/browser/src/scrapling/ops/extract.rs
new file mode 100644
index 000000000..f745138ee
--- /dev/null
+++ b/browser/src/scrapling/ops/extract.rs
@@ -0,0 +1,125 @@
+//! scrapling::extract — a declarative selector list (css/xpath/regex,
+//! attr/html/all) applied to one context element (core.py `apply_selectors`
+//! + `op_extract`). Also the find-similar per-item projection (Task 15).
+
+use serde_json::{json, Value};
+
+use crate::scrapling::{adaptive, dom, query, text};
+use crate::scrapling::{ops::common, require_str};
+
+/// Precedence per spec: `regex` short-circuits css/xpath; else css beats
+/// xpath; no query at all → `[]`/`null` by `all`. Empty-string
+/// css/xpath/regex are falsy (Python `spec.get("css") or ...`), so they fall
+/// through like an absent key rather than erroring on an empty selector.
+pub fn apply_selectors(
+ doc: &dom::Doc,
+ ctx: dom::ElementRef<'_>,
+ specs: &[Value],
+) -> Result<Value, String> {
+ apply_selectors_with_adaptive(doc, ctx, specs, false, None, false)
+}
+
+fn apply_selectors_with_adaptive(
+ doc: &dom::Doc,
+ ctx: dom::ElementRef<'_>,
+ specs: &[Value],
+ adaptive_enabled: bool,
+ domain: Option<&str>,
+ auto_save: bool,
+) -> Result<Value, String> {
+ let mut out = serde_json::Map::new();
+ for spec in specs {
+ let name = spec
+ .get("name")
+ .and_then(Value::as_str)
+ .ok_or("'name'")?
+ .to_string();
+ let want_all = spec.get("all").and_then(Value::as_bool).unwrap_or(false);
+ if let Some(pattern) = spec
+ .get("regex")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty())
+ {
+ // regex specs run on the CONTEXT element's text, not the query result.
+ let text = dom::get_all_text(ctx, "\n", false, &["script", "style"], true);
+ let re = text::compile(pattern, false)?;
+ out.insert(
+ name,
+ if want_all {
+ json!(re.findall(&text))
+ } else {
+ json!(re.find_first(&text))
+ },
+ );
+ continue;
+ }
+ let css = spec
+ .get("css")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty());
+ let xp = spec
+ .get("xpath")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty());
+ let results = match (css, xp, adaptive_enabled) {
+ (Some(q), _, true) => adaptive::css_query(doc, Some(ctx), q, domain, &name, auto_save)?,
+ (None, Some(q), true) => {
+ adaptive::xpath_query(doc, Some(ctx), q, domain, &name, auto_save)?
+ }
+ (Some(q), _, false) => query::css_query(doc, Some(ctx), q)?,
+ (None, Some(q), false) => crate::scrapling::xpath::xpath_query(doc, Some(ctx), q)?,
+ (None, None, _) => {
+ out.insert(name, if want_all { json!([]) } else { Value::Null });
+ continue;
+ }
+ };
+ let attr = spec
+ .get("attr")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty());
+ let html_flag = spec.get("html").and_then(Value::as_bool).unwrap_or(false);
+ out.insert(
+ name,
+ if want_all {
+ json!(results
+ .iter()
+ .map(|r| common::pull(r, attr, html_flag))
+ .collect::<Vec<_>>())
+ } else {
+ results
+ .first()
+ .map(|r| common::pull(r, attr, html_flag))
+ .unwrap_or(Value::Null)
+ },
+ );
+ }
+ Ok(Value::Object(out))
+}
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let doc = dom::parse(html);
+ let specs = payload
+ .get("selectors")
+ .and_then(Value::as_array)
+ .cloned()
+ .unwrap_or_default();
+ let adaptive_enabled = payload
+ .get("adaptive")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let auto_save = match payload.get("auto_save") {
+ None => adaptive_enabled,
+ Some(value) => value.as_bool().unwrap_or(false),
+ };
+ Ok(json!({
+ "extracted": apply_selectors_with_adaptive(
+ &doc,
+ doc.root(),
+ &specs,
+ adaptive_enabled,
+ payload.get("adaptive_domain").and_then(Value::as_str),
+ auto_save,
+ )?
+ }))
+}
diff --git a/browser/src/scrapling/ops/find.rs b/browser/src/scrapling/ops/find.rs
new file mode 100644
index 000000000..37cf7f7cd
--- /dev/null
+++ b/browser/src/scrapling/ops/find.rs
@@ -0,0 +1,105 @@
+//! scrapling::find — BeautifulSoup-style tag/attrs/text-regex search.
+
+use serde_json::Value;
+
+use crate::scrapling::{dom, query, text};
+use crate::scrapling::{ops::common, require_str};
+
+pub(crate) fn py_str(v: &Value) -> String {
+ match v {
+ Value::Bool(true) => "True".to_string(),
+ Value::Bool(false) => "False".to_string(),
+ Value::String(s) => s.clone(),
+ Value::Null => "None".to_string(),
+ other => other.to_string(),
+ }
+}
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ // Python filters on truthiness (`if tag:`, `if text_regex:`): an empty
+ // string or empty list is the same as absent. `attrs: {}` already falls
+ // out empty below with no extra guard needed.
+ let tags: Vec<String> = match payload.get("tag") {
+ Some(Value::String(s)) if !s.is_empty() => vec![s.clone()],
+ Some(Value::Array(a)) => a
+ .iter()
+ .filter_map(Value::as_str)
+ .map(String::from)
+ .collect(),
+ _ => vec![],
+ };
+ let attrs: Vec<(String, String)> = payload
+ .get("attrs")
+ .and_then(Value::as_object)
+ .map(|m| m.iter().map(|(k, v)| (k.clone(), py_str(v))).collect())
+ .unwrap_or_default();
+ let text_regex = payload
+ .get("text_regex")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty());
+
+ if tags.is_empty() && attrs.is_empty() && text_regex.is_none() {
+ return Err("provide at least one of `tag`, `attrs`, `text_regex`".to_string());
+ }
+
+ let doc = dom::parse(html);
+ let mut matches: Vec<dom::ElementRef<'_>> = if !tags.is_empty() || !attrs.is_empty() {
+ let base: Vec<String> = if tags.is_empty() {
+ vec!["*".into()]
+ } else {
+ tags
+ };
+ let selector_strs: Vec<String> = base
+ .iter()
+ .map(|t| {
+ let mut s = t.clone();
+ for (k, v) in &attrs {
+ s.push_str(&format!("[{}=\"{}\"]", k, v.replace('"', "\\\"")));
+ }
+ s
+ })
+ .filter(|s| s != "*")
+ .collect();
+ if selector_strs.is_empty() {
+ // Python's `find_all` builds one selector per tag, drops any that's
+ // exactly the bare wildcard `"*"` (a lone `tag: "*"` with no attrs),
+ // and only calls `self.css(...)` if anything survives; an all-"*"
+ // request leaves the list empty and falls through to
+ // `below_elements` (XPath `.//*`, every descendant) rather than
+ // handing cssselect an empty, invalid selector string.
+ dom::descendant_elements(doc.root())
+ } else {
+ let selector_str = selector_strs.join(", ");
+ query::css_query(&doc, None, &selector_str)?
+ .into_iter()
+ .filter_map(|result| match result {
+ query::QueryResult::Element(element) => Some(element),
+ query::QueryResult::Text { .. } => None,
+ })
+ .collect()
+ }
+ } else {
+ dom::descendant_elements(doc.root())
+ };
+
+ if let Some(pattern) = text_regex {
+ let re = text::compile(pattern, false)?;
+ matches.retain(|el| re.check_match(&dom::leading_text(*el)));
+ }
+
+ Ok(common::bounded_items_response(&matches, payload))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn attr_values_coerce_like_python_str() {
+ assert_eq!(py_str(&serde_json::json!(true)), "True");
+ assert_eq!(py_str(&serde_json::json!(false)), "False");
+ assert_eq!(py_str(&serde_json::json!(5)), "5");
+ assert_eq!(py_str(&serde_json::json!("x")), "x");
+ }
+}
diff --git a/browser/src/scrapling/ops/find_by_regex.rs b/browser/src/scrapling/ops/find_by_regex.rs
new file mode 100644
index 000000000..a404f5571
--- /dev/null
+++ b/browser/src/scrapling/ops/find_by_regex.rs
@@ -0,0 +1,36 @@
+//! scrapling::find-by-regex — leading-text regex search.
+
+use serde_json::Value;
+
+use crate::scrapling::{dom, text};
+use crate::scrapling::{ops::common, require_str};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let pattern = require_str(payload, "pattern")?;
+ let case_sensitive = payload
+ .get("case_sensitive")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let clean_match = payload
+ .get("clean_match")
+ .and_then(Value::as_bool)
+ .unwrap_or(true);
+
+ let re = text::compile(pattern, !case_sensitive)?;
+ let doc = dom::parse(html);
+ let mut matches = Vec::new();
+ for el in dom::descendant_elements(doc.root()) {
+ if !dom::first_text_run_nonblank(el) {
+ continue;
+ }
+ let mut node_text = dom::leading_text(el);
+ if clean_match {
+ node_text = text::clean(&node_text);
+ }
+ if re.check_match(&node_text) {
+ matches.push(el);
+ }
+ }
+ Ok(common::bounded_items_response(&matches, payload))
+}
diff --git a/browser/src/scrapling/ops/find_by_text.rs b/browser/src/scrapling/ops/find_by_text.rs
new file mode 100644
index 000000000..02625c211
--- /dev/null
+++ b/browser/src/scrapling/ops/find_by_text.rs
@@ -0,0 +1,75 @@
+//! scrapling::find-by-text — leading-text equality/containment search.
+
+use serde_json::Value;
+
+use crate::scrapling::{dom, text};
+use crate::scrapling::{ops::common, require_str};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let query = require_str(payload, "text")?;
+ let partial = payload
+ .get("partial")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let case_sensitive = payload
+ .get("case_sensitive")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let clean_match = payload
+ .get("clean_match")
+ .and_then(Value::as_bool)
+ .unwrap_or(true);
+
+ let query = if case_sensitive {
+ query.to_string()
+ } else {
+ query.to_lowercase()
+ };
+ let doc = dom::parse(html);
+ let mut matches = Vec::new();
+ for el in dom::descendant_elements(doc.root()) {
+ if !dom::first_text_run_nonblank(el) {
+ continue;
+ }
+ let mut node_text = dom::leading_text(el);
+ if clean_match {
+ node_text = text::clean(&node_text);
+ }
+ if !case_sensitive {
+ node_text = node_text.to_lowercase();
+ }
+ let hit = if partial {
+ node_text.contains(&query)
+ } else {
+ node_text == query
+ };
+ if hit {
+ matches.push(el);
+ }
+ }
+ Ok(common::bounded_items_response(&matches, payload))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+
+ #[test]
+ fn matches_leading_text_not_subtree() {
+ // <li> has no leading text (its text lives in <a>); the <a> matches.
+ let html = r#"<html><body><ul><li><a href="/a">Apple</a></li></ul></body></html>"#;
+ let out = op(&json!({"html": html, "text": "Apple"})).unwrap();
+ assert_eq!(out["count"], 1);
+ assert_eq!(out["items"][0]["tag"], "a");
+ }
+
+ #[test]
+ fn count_is_precap_total_when_first() {
+ let html = r#"<html><body><p>x</p><p>x</p><p>x</p></body></html>"#;
+ let out = op(&json!({"html": html, "text": "x", "first": true})).unwrap();
+ assert_eq!(out["count"], 3);
+ assert_eq!(out["items"].as_array().unwrap().len(), 1);
+ }
+}
diff --git a/browser/src/scrapling/ops/find_similar.rs b/browser/src/scrapling/ops/find_similar.rs
new file mode 100644
index 000000000..3f8412b8c
--- /dev/null
+++ b/browser/src/scrapling/ops/find_similar.rs
@@ -0,0 +1,97 @@
+//! scrapling::find-similar — structural auto-match: given one example
+//! element (the first css match), return it plus elements judged alike by
+//! `similar::find_similar`'s depth/tag-chain/attribute scoring (core.py
+//! `op_find_similar`). No adaptive refusal: Python's `op_find_similar` never
+//! reads `adaptive` either (same precedent as `describe`).
+
+use serde_json::{json, Value};
+
+use crate::scrapling::{dom, query, similar};
+use crate::scrapling::{ops::extract, require_str};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let anchor_query = require_str(payload, "anchor")?;
+ let doc = dom::parse(html);
+ let results = query::css_query(&doc, None, anchor_query)?;
+ let Some(first) = results.first() else {
+ return Ok(json!({"count": 0, "items": []}));
+ };
+
+ // A `::text`/`::attr()` anchor has no subtree to search: no similars,
+ // and — per the ledger — always the plain default item, even when
+ // `selectors` is given. (Python's `Selector` wraps text nodes too and
+ // would run `apply_selectors` against the bare string instead, but
+ // `apply_selectors` here takes an `ElementRef` ctx with nothing text-node
+ // shaped to pass it, no fixture exercises that combination, and
+ // `extract.rs` is outside this task's touched files.)
+ let anchor = match first {
+ query::QueryResult::Text { value, .. } => {
+ return Ok(json!({"count": 1, "items": [{"text": value, "html": value}]}));
+ }
+ query::QueryResult::Element(el) => *el,
+ };
+
+ let threshold = payload
+ .get("similarity_threshold")
+ .and_then(Value::as_f64)
+ .unwrap_or(0.2);
+ let match_text = payload
+ .get("match_text")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+
+ let mut elements = vec![anchor];
+ elements.extend(similar::find_similar(&doc, anchor, threshold, match_text));
+
+ // Python truthiness: an empty `selectors` list is the same as absent.
+ let specs = payload
+ .get("selectors")
+ .and_then(Value::as_array)
+ .filter(|specs| !specs.is_empty());
+
+ let items = elements
+ .iter()
+ .map(|&el| match specs {
+ Some(specs) => extract::apply_selectors(&doc, el, specs),
+ None => Ok(default_item(el)),
+ })
+ .collect::<Result<Vec<_>, String>>()?;
+
+ Ok(json!({"count": items.len(), "items": items}))
+}
+
+/// `_default_item`: note `strip=false` here — unlike `common::serialize_element`.
+fn default_item(el: dom::ElementRef<'_>) -> Value {
+ json!({
+ "text": dom::get_all_text(el, "\n", false, &["script", "style"], true),
+ "html": dom::outer_html(el),
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn text_anchor_has_no_similars_and_uses_the_value_as_both_fields() {
+ // Ledger: a `::text` anchor short-circuits `find_similar` (no
+ // subtree to search) and always reports one default item built from
+ // the extracted string itself. Oracle-checked directly against
+ // `core.op_find_similar({"html": ..., "anchor": "p::text"})`.
+ let out = op(&json!({"html": "<p>hi</p>", "anchor": "p::text"})).unwrap();
+ assert_eq!(
+ out,
+ json!({"count": 1, "items": [{"text": "hi", "html": "hi"}]})
+ );
+ }
+
+ #[test]
+ fn missing_attr_anchor_is_no_match_not_a_text_result() {
+ // `p::attr(class)` on a `<p>` with no `class`: css_query yields no
+ // result at all (nothing to extract), so this is the ordinary
+ // anchor-missing path, not the text-node short-circuit.
+ let out = op(&json!({"html": "<p>hi</p>", "anchor": "p::attr(class)"})).unwrap();
+ assert_eq!(out, json!({"count": 0, "items": []}));
+ }
+}
diff --git a/browser/src/scrapling/ops/mod.rs b/browser/src/scrapling/ops/mod.rs
new file mode 100644
index 000000000..00fe1c3b5
--- /dev/null
+++ b/browser/src/scrapling/ops/mod.rs
@@ -0,0 +1,16 @@
+//! One module per `browser::*` parse op, plus `common` for the
+//! response-shaping helpers they share. Each op is a
+//! `fn(&Value) -> Result<Value, String>` named `op`; `super::op_for` maps a
+//! function id to one of them.
+
+pub mod common;
+pub mod css_fn;
+pub mod describe;
+pub mod extract;
+pub mod find;
+pub mod find_by_regex;
+pub mod find_by_text;
+pub mod find_similar;
+pub mod regex_fn;
+pub mod to_markdown;
+pub mod xpath_fn;
diff --git a/browser/src/scrapling/ops/regex_fn.rs b/browser/src/scrapling/ops/regex_fn.rs
new file mode 100644
index 000000000..ba028341c
--- /dev/null
+++ b/browser/src/scrapling/ops/regex_fn.rs
@@ -0,0 +1,54 @@
+//! scrapling::regex — regex over the visible text of the document.
+
+use serde_json::{json, Value};
+
+use crate::scrapling::require_str;
+use crate::scrapling::{dom, text};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let pattern = require_str(payload, "pattern")?;
+ let doc = dom::parse(html);
+ let all_text = dom::get_all_text(doc.root(), "\n", false, &["script", "style"], true);
+ let re = text::compile(pattern, false)?;
+ if payload
+ .get("first")
+ .and_then(Value::as_bool)
+ .unwrap_or(false)
+ {
+ Ok(json!({ "result": re.find_first(&all_text) }))
+ } else {
+ Ok(json!({ "result": re.findall(&all_text) }))
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const HTML: &str = r#"<html><body><p>price 42 usd then 99</p></body></html>"#;
+
+ #[test]
+ fn all_matches_by_default() {
+ let out = op(&json!({"html": HTML, "pattern": r"\d+"})).unwrap();
+ assert_eq!(out, json!({"result": ["42", "99"]}));
+ }
+
+ #[test]
+ fn first_returns_scalar_or_null() {
+ assert_eq!(
+ op(&json!({"html": HTML, "pattern": r"price (\d+)", "first": true})).unwrap(),
+ json!({"result": "42"})
+ );
+ assert_eq!(
+ op(&json!({"html": HTML, "pattern": "zzz", "first": true})).unwrap(),
+ json!({"result": null})
+ );
+ }
+
+ #[test]
+ fn missing_html_or_pattern_is_an_error() {
+ assert!(op(&json!({"pattern": "x"})).is_err());
+ assert!(op(&json!({"html": HTML})).is_err());
+ }
+}
diff --git a/browser/src/scrapling/ops/to_markdown.rs b/browser/src/scrapling/ops/to_markdown.rs
new file mode 100644
index 000000000..781829702
--- /dev/null
+++ b/browser/src/scrapling/ops/to_markdown.rs
@@ -0,0 +1,25 @@
+//! scrapling::to-markdown — HTML to markdown/text/html, with an optional
+//! main-content sanitizer and CSS scope (core.py `op_to_markdown`). Always
+//! operates on the whole document: no `adaptive` field in its schema (see
+//! schemas.rs `markdown_request`), so no `common::refuse_adaptive` here.
+
+use serde_json::{json, Value};
+
+use crate::scrapling::require_str;
+use crate::scrapling::{dom, markdown};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let doc = dom::parse(html);
+ let format = payload
+ .get("format")
+ .and_then(Value::as_str)
+ .unwrap_or("markdown");
+ let css_selector = payload.get("css_selector").and_then(Value::as_str);
+ let main_content_only = payload
+ .get("main_content_only")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let content = markdown::render(&doc, format, css_selector, main_content_only)?;
+ Ok(json!({"format": format, "content": content}))
+}
diff --git a/browser/src/scrapling/ops/xpath_fn.rs b/browser/src/scrapling/ops/xpath_fn.rs
new file mode 100644
index 000000000..0d1d50179
--- /dev/null
+++ b/browser/src/scrapling/ops/xpath_fn.rs
@@ -0,0 +1,83 @@
+//! scrapling::xpath — one XPath query over HTML; first-or-all; `attr` pulls an
+//! attribute else text (core.py `op_query(payload, "xpath")`).
+
+use serde_json::{json, Value};
+
+use crate::scrapling::{adaptive, dom, xpath};
+use crate::scrapling::{ops::common, require_str};
+
+pub fn op(payload: &Value) -> Result<Value, String> {
+ let html = require_str(payload, "html")?;
+ let q = require_str(payload, "query")?;
+ let doc = dom::parse(html);
+ let adaptive_enabled = payload
+ .get("adaptive")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let attr = payload
+ .get("attr")
+ .and_then(Value::as_str)
+ .filter(|s| !s.is_empty());
+ let results = (if adaptive_enabled {
+ let identifier = payload
+ .get("identifier")
+ .and_then(Value::as_str)
+ .filter(|value| !value.is_empty())
+ .unwrap_or(q);
+ let auto_save = match payload.get("auto_save") {
+ None => true,
+ Some(value) => value.as_bool().unwrap_or(false),
+ };
+ adaptive::xpath_query(
+ &doc,
+ None,
+ q,
+ payload.get("adaptive_domain").and_then(Value::as_str),
+ identifier,
+ auto_save,
+ )
+ } else {
+ xpath::xpath_query(&doc, None, q)
+ })
+ .map_err(|error| {
+ if attr.is_some() && error == "'str' object has no attribute 'iter'" {
+ "'str' object has no attribute 'attrib'".to_string()
+ } else {
+ error
+ }
+ })?;
+ if payload
+ .get("first")
+ .and_then(Value::as_bool)
+ .unwrap_or(false)
+ {
+ Ok(json!({ "result": results.first().map(|r| common::pull(r, attr, false)) }))
+ } else {
+ Ok(
+ json!({ "result": results.iter().map(|r| common::pull(r, attr, false)).collect::<Vec<_>>() }),
+ )
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+
+ #[test]
+ fn invalid_selector_reports_the_original_expression() {
+ let err = op(&json!({"html": "<p>x</p>", "query": "//["})).unwrap_err();
+ assert_eq!(err, "Invalid XPath selector: //[");
+ }
+
+ #[test]
+ fn scalar_attribute_pull_keeps_the_python_error() {
+ let err = op(&json!({
+ "html": "<p>x</p>",
+ "query": "string(//p)",
+ "attr": "href"
+ }))
+ .unwrap_err();
+ assert_eq!(err, "'str' object has no attribute 'attrib'");
+ }
+}
diff --git a/browser/src/scrapling/page.rs b/browser/src/scrapling/page.rs
new file mode 100644
index 000000000..9f823b7d7
--- /dev/null
+++ b/browser/src/scrapling/page.rs
@@ -0,0 +1,274 @@
+//! The shared fetch response envelope, mirroring `scrapling/src/core.py`'s
+//! `serialize_page` (core.py:185-208).
+//!
+//! Every outbound function — `fetch`, `dynamic-fetch`, `stealthy-fetch`,
+//! `session-fetch` and each page of `crawl` — returns this shape, so the
+//! post-fetch half (inline extraction, markdown/text rendering, raw HTML) is
+//! written once here and reuses the parse modules the worker already has.
+
+use serde_json::{json, Map, Value};
+
+use crate::scrapling::{dom, markdown, ops::extract::apply_selectors};
+
+/// What a fetch tier produces, independent of how it fetched.
+///
+/// `cookies` is a name -> value map for HTTP. Browser tiers preserve the
+/// frozen worker's observable serialization quirk and return `{}`.
+#[derive(Debug, Default, Clone)]
+pub struct PageData {
+ pub status: Option<u16>,
+ pub url: String,
+ pub headers: Map<String, Value>,
+ pub cookies: Map<String, Value>,
+ pub encoding: Option<String>,
+ /// Outer HTML of the fetched document.
+ pub html: String,
+ pub captured_xhr: Vec<Value>,
+}
+
+/// Build the response envelope for one fetched page.
+///
+/// Key order follows `serialize_page`'s insertion order, which is NOT the
+/// property order its JSON Schema declares: the base five, then `extracted`,
+/// then `captured_xhr`, then `format` *before* `content`, then `html`. With
+/// `serde_json/preserve_order` on, that order is what goes on the wire.
+pub fn serialize_page(
+ page: &PageData,
+ payload: &Value,
+ include_html: bool,
+) -> Result<Value, String> {
+ let mut out = Map::new();
+ out.insert(
+ "status".into(),
+ page.status.map(|s| json!(s)).unwrap_or(Value::Null),
+ );
+ out.insert("url".into(), json!(page.url));
+ out.insert("headers".into(), Value::Object(page.headers.clone()));
+ out.insert("cookies".into(), Value::Object(page.cookies.clone()));
+ out.insert(
+ "encoding".into(),
+ page.encoding
+ .as_ref()
+ .map(|e| json!(e))
+ .unwrap_or(Value::Null),
+ );
+
+ // Parse at most once, and only when something actually needs the tree.
+ let selectors = payload
+ .get("selectors")
+ .and_then(Value::as_array)
+ .filter(|s| !s.is_empty());
+ let fmt = payload
+ .get("format")
+ .and_then(Value::as_str)
+ .filter(|f| matches!(*f, "markdown" | "text"));
+ let doc = if selectors.is_some() || fmt.is_some() || include_html {
+ Some(dom::parse(&page.html))
+ } else {
+ None
+ };
+
+ if let Some(specs) = selectors {
+ let doc = doc.as_ref().expect("parsed when selectors present");
+ out.insert("extracted".into(), apply_selectors(doc, doc.root(), specs)?);
+ }
+ if !page.captured_xhr.is_empty() {
+ return Err("Object of type Response is not JSON serializable".to_string());
+ }
+ if let Some(fmt) = fmt {
+ let doc = doc.as_ref().expect("parsed when format present");
+ let main_content_only = payload
+ .get("main_content_only")
+ .and_then(Value::as_bool)
+ .unwrap_or(false);
+ let css_selector = payload.get("css_selector").and_then(Value::as_str);
+ out.insert("format".into(), json!(fmt));
+ out.insert(
+ "content".into(),
+ json!(markdown::render(doc, fmt, css_selector, main_content_only)?),
+ );
+ }
+ if include_html {
+ let doc = doc.as_ref().expect("parsed when HTML is included");
+ out.insert("html".into(), json!(dom::outer_html(doc.root())));
+ }
+ Ok(Value::Object(out))
+}
+
+/// `include_html` after the caller-specific default precedence has already
+/// been applied. Crawl deliberately passes only its request value.
+pub fn include_html(payload: &Value) -> bool {
+ payload
+ .get("include_html")
+ .and_then(Value::as_bool)
+ .unwrap_or(false)
+}
+
+/// The bulk `urls` form: one entry per URL, in request order, where a failed
+/// URL contributes `{url, error}` instead of sinking the whole batch
+/// (handlers.py:26-42).
+pub fn bulk_results(results: Vec<Result<Value, (String, String)>>) -> Value {
+ let items: Vec<Value> = results
+ .into_iter()
+ .map(|r| match r {
+ Ok(v) => v,
+ Err((url, error)) => json!({"url": url, "error": error}),
+ })
+ .collect();
+ json!({ "results": items })
+}
+
+/// Read the request's target(s): either a single `url` or a bulk `urls` list.
+/// Mirrors handlers.py:20-22, including its error text.
+pub fn targets(payload: &Value) -> Result<(Vec<String>, bool), String> {
+ if let Some(list) = payload.get("urls").and_then(Value::as_array) {
+ let urls: Vec<String> = list
+ .iter()
+ .filter_map(Value::as_str)
+ .map(str::to_string)
+ .collect();
+ if !urls.is_empty() {
+ return Ok((urls, true));
+ }
+ }
+ match payload.get("url").and_then(Value::as_str) {
+ Some(u) if !u.is_empty() => Ok((vec![u.to_string()], false)),
+ _ => Err("provide `url` or `urls`".to_string()),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn page() -> PageData {
+ PageData {
+ status: Some(200),
+ url: "https://example.com/".into(),
+ headers: [("content-type".to_string(), json!("text/html"))]
+ .into_iter()
+ .collect(),
+ cookies: [("sid".to_string(), json!("abc"))].into_iter().collect(),
+ encoding: Some("utf-8".into()),
+ html: "<html><head></head><body><h1>Hi</h1><a href=\"/x\">go</a></body></html>".into(),
+ captured_xhr: vec![],
+ }
+ }
+
+ #[test]
+ fn base_envelope_has_exactly_the_five_keys_in_order() {
+ let out = serialize_page(&page(), &json!({}), false).unwrap();
+ let keys: Vec<&str> = out
+ .as_object()
+ .unwrap()
+ .keys()
+ .map(|s| s.as_str())
+ .collect();
+ assert_eq!(keys, ["status", "url", "headers", "cookies", "encoding"]);
+ }
+
+ #[test]
+ fn selectors_add_extracted() {
+ let payload = json!({"selectors": [{"name": "title", "css": "h1"}]});
+ let out = serialize_page(&page(), &payload, false).unwrap();
+ assert_eq!(out["extracted"]["title"], json!("Hi"));
+ }
+
+ #[test]
+ fn empty_selector_list_adds_nothing() {
+ let out = serialize_page(&page(), &json!({"selectors": []}), false).unwrap();
+ assert!(out.get("extracted").is_none());
+ }
+
+ #[test]
+ fn captured_browser_responses_preserve_the_public_serialization_error() {
+ let mut page = page();
+ page.captured_xhr.push(json!({"status": 200}));
+ assert_eq!(
+ serialize_page(&page, &json!({}), false).unwrap_err(),
+ "Object of type Response is not JSON serializable"
+ );
+ }
+
+ #[test]
+ fn format_emits_format_before_content() {
+ let out = serialize_page(&page(), &json!({"format": "text"}), false).unwrap();
+ let keys: Vec<&str> = out
+ .as_object()
+ .unwrap()
+ .keys()
+ .map(|s| s.as_str())
+ .collect();
+ let f = keys.iter().position(|k| *k == "format").unwrap();
+ let c = keys.iter().position(|k| *k == "content").unwrap();
+ assert!(
+ f < c,
+ "serialize_page inserts format before content: {keys:?}"
+ );
+ // Verified against the reference implementation: `op_to_markdown` in
+ // text mode yields "Hi\ngo" for this HTML (the h1 is a block, so it
+ // ends the line).
+ assert_eq!(out["content"], json!("Hi\ngo"));
+ }
+
+ #[test]
+ fn unsupported_format_is_ignored_not_an_error() {
+ // core.py only renders for markdown|text; anything else falls through.
+ let out = serialize_page(&page(), &json!({"format": "html"}), false).unwrap();
+ assert!(out.get("content").is_none());
+ assert!(out.get("format").is_none());
+ }
+
+ #[test]
+ fn include_html_appends_libxml_serialized_html_last() {
+ let mut page = page();
+ page.html = "<p>Hi</p>".into();
+ let out = serialize_page(&page, &json!({}), true).unwrap();
+ let keys: Vec<&str> = out
+ .as_object()
+ .unwrap()
+ .keys()
+ .map(|s| s.as_str())
+ .collect();
+ assert_eq!(*keys.last().unwrap(), "html");
+ assert_eq!(out["html"], json!("<html><body><p>Hi</p></body></html>"));
+ }
+
+ #[test]
+ fn null_status_and_encoding_serialize_as_null() {
+ let mut p = page();
+ p.status = None;
+ p.encoding = None;
+ let out = serialize_page(&p, &json!({}), false).unwrap();
+ assert_eq!(out["status"], Value::Null);
+ assert_eq!(out["encoding"], Value::Null);
+ }
+
+ #[test]
+ fn targets_prefers_urls_then_url_then_errors() {
+ assert_eq!(
+ targets(&json!({"urls": ["a", "b"]})).unwrap(),
+ (vec!["a".to_string(), "b".to_string()], true)
+ );
+ assert_eq!(
+ targets(&json!({"url": "a"})).unwrap(),
+ (vec!["a".to_string()], false)
+ );
+ // an empty `urls` falls back to `url` rather than fetching nothing
+ assert_eq!(
+ targets(&json!({"urls": [], "url": "a"})).unwrap(),
+ (vec!["a".to_string()], false)
+ );
+ assert_eq!(targets(&json!({})).unwrap_err(), "provide `url` or `urls`");
+ }
+
+ #[test]
+ fn bulk_results_keeps_order_and_isolates_failures() {
+ let out = bulk_results(vec![
+ Ok(json!({"url": "a", "status": 200})),
+ Err(("b".into(), "boom".into())),
+ ]);
+ assert_eq!(out["results"][0]["status"], json!(200));
+ assert_eq!(out["results"][1], json!({"url": "b", "error": "boom"}));
+ }
+}
diff --git a/browser/src/scrapling/query.rs b/browser/src/scrapling/query.rs
new file mode 100644
index 000000000..5a1880d23
--- /dev/null
+++ b/browser/src/scrapling/query.rs
@@ -0,0 +1,61 @@
+//! Scrapling CSS queries: cssselect translation evaluated by the shared XPath
+//! engine, against the same libxml-compatible tree and context node.
+
+use crate::scrapling::dom::{Doc, ElementRef};
+
+#[derive(Debug, Clone)]
+pub enum QueryResult<'a> {
+ Element(ElementRef<'a>),
+ Text {
+ value: String,
+ parent: ElementRef<'a>,
+ },
+}
+
+pub fn css_query<'a>(
+ doc: &'a Doc,
+ scope: Option<ElementRef<'a>>,
+ selector: &str,
+) -> Result<Vec<QueryResult<'a>>, String> {
+ let xpath = cssselect::HtmlTranslator::new()
+ .css_to_xpath(selector)
+ .map_err(|error| format!("Invalid CSS selector '{selector}': {error}"))?;
+ crate::scrapling::xpath::xpath_query(doc, scope, &xpath)
+ .map_err(|error| format!("Invalid CSS selector '{selector}': {error}"))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::scrapling::dom;
+
+ fn values(results: &[QueryResult<'_>]) -> Vec<String> {
+ results
+ .iter()
+ .map(|result| match result {
+ QueryResult::Element(element) => format!("<{}>", element.name()),
+ QueryResult::Text { value, .. } => value.clone(),
+ })
+ .collect()
+ }
+
+ #[test]
+ fn pseudo_elements_and_scopes_use_xpath_semantics() {
+ let doc = dom::parse("<main><section><a href='/a'>A<b>B</b>C</a></section></main>");
+ assert_eq!(
+ values(&css_query(&doc, None, "a::text").unwrap()),
+ ["A", "C"]
+ );
+ assert_eq!(
+ values(&css_query(&doc, None, "a ::text").unwrap()),
+ ["A", "B", "C"]
+ );
+ assert_eq!(
+ values(&css_query(&doc, None, "a::attr(href)").unwrap()),
+ ["/a"]
+ );
+
+ let section = doc.first_by_tag("section").unwrap();
+ assert!(css_query(&doc, Some(section), "body a").unwrap().is_empty());
+ }
+}
diff --git a/browser/src/scrapling/raw_browser.rs b/browser/src/scrapling/raw_browser.rs
new file mode 100644
index 000000000..4bd9506ec
--- /dev/null
+++ b/browser/src/scrapling/raw_browser.rs
@@ -0,0 +1,2901 @@
+use std::collections::{HashMap, HashSet};
+use std::hash::Hasher;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::OnceLock;
+use std::time::{Duration, Instant};
+
+use base64::engine::general_purpose::STANDARD;
+use base64::Engine;
+use image::codecs::png::{CompressionType, FilterType as PngFilterType, PngEncoder};
+use image::imageops::FilterType;
+use image::{GenericImageView, ImageEncoder};
+use serde_json::{json, Map, Value};
+
+use crate::config::{SecurityMode, WorkerConfig};
+use crate::scrapling::cdp::{CdpClient, CdpEvent, CdpSession, EventReceiver};
+use crate::scrapling::egress_gate::EgressGate;
+use crate::scrapling::page::PageData;
+use crate::ssrf::SsrfPolicy;
+
+/// The frozen Tier-1 Chromium builds compat mode certifies against: the
+/// x86_64 Chrome-for-Testing 148 build and the aarch64 Playwright chromium
+/// build 1223 (same 148 milestone; Playwright snapshots report patch .0).
+/// Both are pinned by sha256 in oracle/manifest.json and fetched by
+/// scripts/fetch_chromium_artifacts.sh.
+pub(crate) const CERTIFIED_CHROME_VERSIONS: &[&str] = &["148.0.7778.96", "148.0.7778.0"];
+const DEFAULT_USER_AGENT: &str = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36";
+const GOOGLE_REFERER: &str = "https://www.google.com/";
+const MAX_TILE_WIDTH: u32 = 1024;
+const MAX_TILE_HEIGHT: u32 = 1536;
+const MAX_TILES: usize = 6;
+
+const DEFAULT_ARGS: &[&str] = &[
+ "--no-pings",
+ "--no-first-run",
+ "--disable-infobars",
+ "--disable-breakpad",
+ "--no-service-autorun",
+ "--homepage=about:blank",
+ "--password-store=basic",
+ "--disable-hang-monitor",
+ "--no-default-browser-check",
+ "--disable-session-crashed-bubble",
+ "--disable-search-engine-choice-screen",
+];
+
+const PLAYWRIGHT_ARGS: &[&str] = &[
+ "--disable-field-trial-config",
+ "--disable-background-networking",
+ "--disable-background-timer-throttling",
+ "--disable-backgrounding-occluded-windows",
+ "--disable-back-forward-cache",
+ "--disable-breakpad",
+ "--disable-client-side-phishing-detection",
+ "--disable-component-extensions-with-background-pages",
+ "--no-default-browser-check",
+ "--disable-dev-shm-usage",
+ "--disable-edgeupdater",
+ "--disable-features=AvoidUnnecessaryBeforeUnloadCheckSync,BoundaryEventDispatchTracksNodeRemoval,DestroyProfileOnBrowserClose,DialMediaRouteProvider,GlobalMediaControls,HttpsUpgrades,LensOverlay,MediaRouter,PaintHolding,ThirdPartyStoragePartitioning,Translate,AutoDeElevate,RenderDocument,OptimizationHints,msForceBrowserSignIn,msEdgeUpdateLaunchServicesPreferredVersion",
+ "--enable-features=CDPScreenshotNewSurface",
+ "--allow-pre-commit-input",
+ "--disable-hang-monitor",
+ "--disable-ipc-flooding-protection",
+ "--disable-prompt-on-repost",
+ "--disable-renderer-backgrounding",
+ "--force-color-profile=srgb",
+ "--metrics-recording-only",
+ "--no-first-run",
+ "--password-store=basic",
+ "--use-mock-keychain",
+ "--no-service-autorun",
+ "--export-tagged-pdf",
+ "--disable-search-engine-choice-screen",
+ "--unsafely-disable-devtools-self-xss-warnings",
+ "--edge-skip-compat-layer-relaunch",
+ "--disable-infobars",
+ "--disable-sync",
+ "--enable-unsafe-swiftshader",
+];
+
+const PATCHRIGHT_ARGS: &[&str] = &[
+ "--disable-field-trial-config",
+ "--disable-background-networking",
+ "--disable-background-timer-throttling",
+ "--disable-backgrounding-occluded-windows",
+ "--disable-breakpad",
+ "--no-default-browser-check",
+ "--disable-dev-shm-usage",
+ "--disable-edgeupdater",
+ "--disable-features=AvoidUnnecessaryBeforeUnloadCheckSync,BoundaryEventDispatchTracksNodeRemoval,DestroyProfileOnBrowserClose,DialMediaRouteProvider,GlobalMediaControls,HttpsUpgrades,LensOverlay,MediaRouter,PaintHolding,ThirdPartyStoragePartitioning,Translate,AutoDeElevate,RenderDocument,OptimizationHints,msForceBrowserSignIn,msEdgeUpdateLaunchServicesPreferredVersion",
+ "--enable-features=CDPScreenshotNewSurface",
+ "--disable-hang-monitor",
+ "--disable-prompt-on-repost",
+ "--disable-renderer-backgrounding",
+ "--force-color-profile=srgb",
+ "--no-first-run",
+ "--password-store=basic",
+ "--use-mock-keychain",
+ "--no-service-autorun",
+ "--export-tagged-pdf",
+ "--disable-search-engine-choice-screen",
+ "--edge-skip-compat-layer-relaunch",
+ "--disable-infobars",
+ "--disable-search-engine-choice-screen",
+ "--disable-sync",
+ "--disable-blink-features=AutomationControlled",
+];
+
+const STEALTH_ARGS: &[&str] = &[
+ "--test-type",
+ "--lang=en-US",
+ "--mute-audio",
+ "--disable-sync",
+ "--hide-scrollbars",
+ "--disable-logging",
+ "--start-maximized",
+ "--enable-async-dns",
+ "--accept-lang=en-US",
+ "--use-mock-keychain",
+ "--disable-translate",
+ "--disable-voice-input",
+ "--window-position=0,0",
+ "--disable-wake-on-wifi",
+ "--ignore-gpu-blocklist",
+ "--enable-tcp-fast-open",
+ "--enable-web-bluetooth",
+ "--disable-cloud-import",
+ "--disable-print-preview",
+ "--disable-dev-shm-usage",
+ "--metrics-recording-only",
+ "--disable-crash-reporter",
+ "--disable-partial-raster",
+ "--disable-gesture-typing",
+ "--disable-checker-imaging",
+ "--disable-prompt-on-repost",
+ "--force-color-profile=srgb",
+ "--font-render-hinting=none",
+ "--aggressive-cache-discard",
+ "--disable-cookie-encryption",
+ "--disable-domain-reliability",
+ "--disable-threaded-animation",
+ "--disable-threaded-scrolling",
+ "--enable-simple-cache-backend",
+ "--disable-background-networking",
+ "--enable-surface-synchronization",
+ "--disable-image-animation-resync",
+ "--disable-renderer-backgrounding",
+ "--disable-ipc-flooding-protection",
+ "--prerender-from-omnibox=disabled",
+ "--safebrowsing-disable-auto-update",
+ "--disable-offer-upload-credit-cards",
+ "--disable-background-timer-throttling",
+ "--disable-new-content-rendering-timeout",
+ "--run-all-compositor-stages-before-draw",
+ "--disable-client-side-phishing-detection",
+ "--disable-backgrounding-occluded-windows",
+ "--disable-layer-tree-host-memory-pressure",
+ "--autoplay-policy=user-gesture-required",
+ "--disable-offer-store-unmasked-wallet-cards",
+ "--disable-blink-features=AutomationControlled",
+ "--disable-component-extensions-with-background-pages",
+ "--enable-features=NetworkService,NetworkServiceInProcess,TrustTokens,TrustTokensAlwaysAllowIssuance",
+ "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4",
+ "--disable-features=AudioServiceOutOfProcess,TranslateUI,BlinkGenPropertyTrees",
+];
+
+// CPython 3.12 set order with PYTHONHASHSEED=0, retained as an independent
+// frozen transcript assertion for the default stealth launch.
+#[cfg(test)]
+const STEALTH_DEFAULT_ARGS: &[&str] = &[
+ "--homepage=about:blank",
+ "--disable-threaded-animation",
+ "--disable-offer-store-unmasked-wallet-cards",
+ "--disable-component-extensions-with-background-pages",
+ "--enable-async-dns",
+ "--disable-new-content-rendering-timeout",
+ "--disable-background-networking",
+ "--disable-sync",
+ "--no-service-autorun",
+ "--disable-checker-imaging",
+ "--enable-tcp-fast-open",
+ "--enable-surface-synchronization",
+ "--disable-offer-upload-credit-cards",
+ "--run-all-compositor-stages-before-draw",
+ "--autoplay-policy=user-gesture-required",
+ "--enable-features=NetworkService,NetworkServiceInProcess,TrustTokens,TrustTokensAlwaysAllowIssuance",
+ "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4",
+ "--accept-lang=en-US",
+ "--use-mock-keychain",
+ "--disable-ipc-flooding-protection",
+ "--no-first-run",
+ "--disable-threaded-scrolling",
+ "--safebrowsing-disable-auto-update",
+ "--disable-infobars",
+ "--enable-web-bluetooth",
+ "--disable-domain-reliability",
+ "--disable-client-side-phishing-detection",
+ "--hide-scrollbars",
+ "--enable-simple-cache-backend",
+ "--disable-features=AudioServiceOutOfProcess,TranslateUI,BlinkGenPropertyTrees",
+ "--prerender-from-omnibox=disabled",
+ "--test-type",
+ "--disable-dev-shm-usage",
+ "--metrics-recording-only",
+ "--disable-session-crashed-bubble",
+ "--mute-audio",
+ "--aggressive-cache-discard",
+ "--lang=en-US",
+ "--disable-voice-input",
+ "--disable-blink-features=AutomationControlled",
+ "--disable-breakpad",
+ "--disable-cookie-encryption",
+ "--disable-background-timer-throttling",
+ "--disable-gesture-typing",
+ "--window-position=0,0",
+ "--disable-hang-monitor",
+ "--disable-crash-reporter",
+ "--disable-logging",
+ "--disable-image-animation-resync",
+ "--force-color-profile=srgb",
+ "--disable-layer-tree-host-memory-pressure",
+ "--ignore-gpu-blocklist",
+ "--disable-renderer-backgrounding",
+ "--disable-print-preview",
+ "--start-maximized",
+ "--disable-wake-on-wifi",
+ "--disable-partial-raster",
+ "--disable-prompt-on-repost",
+ "--no-default-browser-check",
+ "--password-store=basic",
+ "--no-pings",
+ "--disable-backgrounding-occluded-windows",
+ "--disable-translate",
+ "--disable-cloud-import",
+ "--disable-search-engine-choice-screen",
+ "--font-render-hinting=none",
+];
+
+const BLOCKED_RESOURCE_TYPES: &[&str] = &[
+ "Font",
+ "Image",
+ "Media",
+ "TextTrack",
+ "WebSocket",
+ "Stylesheet",
+];
+
+static AD_DOMAINS: OnceLock<HashSet<&'static str>> = OnceLock::new();
+type ProxyConfig = (Option<String>, Option<(String, String)>);
+
+#[derive(Clone, Debug)]
+pub struct RawBrowserOptions {
+ pub headless: bool,
+ pub network_idle: bool,
+ pub load_dom: bool,
+ pub timeout: Duration,
+ pub wait: Duration,
+ pub wait_selector: Option<String>,
+ pub wait_selector_state: String,
+ pub disable_resources: bool,
+ pub block_ads: bool,
+ pub blocked_domains: Vec<String>,
+ pub proxy: Option<String>,
+ pub proxy_auth: Option<(String, String)>,
+ pub useragent: Option<String>,
+ pub cookies: Vec<Value>,
+ pub extra_headers: Map<String, Value>,
+ pub google_search: bool,
+ pub capture_xhr: Option<String>,
+ pub locale: Option<String>,
+ pub timezone_id: Option<String>,
+ pub dns_over_https: bool,
+ pub extra_flags: Vec<String>,
+ pub retries: usize,
+ pub retry_delay: Duration,
+ pub cdp_url: Option<String>,
+ pub real_chrome: bool,
+ pub block_webrtc: bool,
+ pub hide_canvas: bool,
+ pub allow_webgl: bool,
+ pub solve_cloudflare: bool,
+}
+
+/// Upper clamp for `retry_delay` (seconds). `Duration::from_secs_f64` PANICS
+/// on values it cannot represent, and the schema declares a bare number, so
+/// an unclamped `{"retry_delay": 1e300}` would panic inside the handler and
+/// hang the caller (the HTTP tier clamps for exactly this reason).
+const MAX_RETRY_DELAY_SECS: f64 = 60.0;
+
+impl RawBrowserOptions {
+ pub fn from_payload(payload: &Value) -> Result<Self, String> {
+ let mut timeout = float_field(payload, "timeout", 30_000.0)?;
+ let wait = float_field(payload, "wait", 0.0)?;
+ let retry_delay = float_field(payload, "retry_delay", 1.0)?.min(MAX_RETRY_DELAY_SECS);
+ let retries = bounded_int_field(payload, "retries", 3, 1, 10)?;
+ let _max_pages = bounded_int_field(payload, "max_pages", 1, 1, 50)?;
+ let solve_cloudflare = bool_field(payload, "solve_cloudflare", false)?;
+ if solve_cloudflare {
+ timeout = timeout.max(60_000.0);
+ }
+ let wait_selector_state = string_field(payload, "wait_selector_state", "attached")?;
+ if !matches!(
+ wait_selector_state.as_str(),
+ "attached" | "detached" | "visible" | "hidden"
+ ) {
+ return Err(format!(
+ "Invalid argument type: Invalid enum value '{wait_selector_state}' - at `$.wait_selector_state`"
+ ));
+ }
+ let (proxy, proxy_auth) = proxy_field(payload)?;
+ Ok(Self {
+ headless: bool_field(payload, "headless", true)?,
+ network_idle: bool_field(payload, "network_idle", false)?,
+ load_dom: bool_field(payload, "load_dom", true)?,
+ timeout: Duration::from_millis(timeout as u64),
+ wait: Duration::from_millis(wait as u64),
+ wait_selector: optional_string_field(payload, "wait_selector")?,
+ wait_selector_state,
+ disable_resources: bool_field(payload, "disable_resources", false)?,
+ block_ads: bool_field(payload, "block_ads", false)?,
+ blocked_domains: string_list_field(payload, "blocked_domains")?,
+ proxy,
+ proxy_auth,
+ useragent: optional_string_field(payload, "useragent")?
+ .filter(|value| !value.is_empty()),
+ cookies: cookies(payload.get("cookies"))?,
+ extra_headers: string_map_field(payload, "extra_headers")?,
+ google_search: bool_field(payload, "google_search", true)?,
+ capture_xhr: optional_string_field(payload, "capture_xhr")?
+ .filter(|value| !value.is_empty()),
+ locale: optional_string_field(payload, "locale")?.filter(|value| !value.is_empty()),
+ timezone_id: optional_string_field(payload, "timezone_id")?
+ .filter(|value| !value.is_empty()),
+ dns_over_https: bool_field(payload, "dns_over_https", false)?,
+ extra_flags: string_list_field(payload, "extra_flags")?,
+ retries: retries as usize,
+ retry_delay: Duration::from_secs_f64(retry_delay),
+ cdp_url: cdp_url(payload)?,
+ real_chrome: bool_field(payload, "real_chrome", false)?,
+ block_webrtc: bool_field(payload, "block_webrtc", false)?,
+ hide_canvas: bool_field(payload, "hide_canvas", false)?,
+ allow_webgl: bool_field(payload, "allow_webgl", true)?,
+ solve_cloudflare,
+ })
+ }
+
+ /// Clamp `timeout` and `wait` to the configured ceiling. The deleted
+ /// python-shaped tier clamped to `max_timeout_ms` and the interactive
+ /// tier still does; without this a caller-supplied `wait` holds a
+ /// Chromium page (or wedges a session actor) for an arbitrary time.
+ pub fn clamp_durations(&mut self, max_timeout_ms: u64) {
+ let cap = Duration::from_millis(max_timeout_ms.max(1));
+ self.timeout = self.timeout.min(cap);
+ self.wait = self.wait.min(cap);
+ }
+
+ pub fn validate_policy(&self, mode: SecurityMode) -> Result<(), String> {
+ if mode == SecurityMode::Compat {
+ return Ok(());
+ }
+ // Keep in sync with `sessions::uses_compat_only_options`, or an
+ // option refused here slips through session-open and only errors at
+ // first fetch (and vice versa).
+ let mut refused = Vec::new();
+ if self.proxy.is_some() {
+ refused.push("proxy");
+ }
+ if self.cdp_url.is_some() {
+ refused.push("cdp_url");
+ }
+ if self.dns_over_https {
+ refused.push("dns_over_https");
+ }
+ if !self.extra_flags.is_empty() {
+ refused.push("extra_flags");
+ }
+ // Refused rather than silently discarded: safe mode never honors it,
+ // and an ignored option is a lie to the caller.
+ if self.real_chrome {
+ refused.push("real_chrome");
+ }
+ if !refused.is_empty() {
+ return Err(format!(
+ "{} require browser.scrapling.security_mode=compat",
+ refused.join(", ")
+ ));
+ }
+ Ok(())
+ }
+}
+
+fn present<'a>(payload: &'a Value, key: &str) -> Option<&'a Value> {
+ payload.get(key).filter(|value| !value.is_null())
+}
+
+fn python_type(value: &Value) -> &'static str {
+ match value {
+ Value::Null => "null",
+ Value::Bool(_) => "bool",
+ Value::Number(number) if number.is_i64() || number.is_u64() => "int",
+ Value::Number(_) => "float",
+ Value::String(_) => "str",
+ Value::Array(_) => "array",
+ Value::Object(_) => "object",
+ }
+}
+
+fn type_error(expected: &str, value: &Value, path: &str) -> String {
+ format!(
+ "Invalid argument type: Expected `{expected}`, got `{}` - at `${path}`",
+ python_type(value)
+ )
+}
+
+fn bool_field(payload: &Value, key: &str, default: bool) -> Result<bool, String> {
+ let Some(value) = present(payload, key) else {
+ return Ok(default);
+ };
+ if let Some(value) = value.as_bool() {
+ return Ok(value);
+ }
+ if value
+ .as_f64()
+ .is_some_and(|value| value == if default { 1.0 } else { 0.0 })
+ {
+ return Ok(default);
+ }
+ Err(type_error("bool", value, &format!(".{key}")))
+}
+
+fn float_field(payload: &Value, key: &str, default: f64) -> Result<f64, String> {
+ let Some(value) = present(payload, key) else {
+ return Ok(default);
+ };
+ if let Some(number) = value.as_f64() {
+ if number < 0.0 {
+ return Err(format!(
+ "Invalid argument type: Expected `float` >= 0.0 - at `$.{key}`"
+ ));
+ }
+ return Ok(number);
+ }
+ if value
+ .as_bool()
+ .is_some_and(|value| (if value { 1.0 } else { 0.0 }) == default)
+ {
+ return Ok(default);
+ }
+ Err(type_error("float", value, &format!(".{key}")))
+}
+
+fn bounded_int_field(
+ payload: &Value,
+ key: &str,
+ default: i64,
+ minimum: i64,
+ maximum: i64,
+) -> Result<i64, String> {
+ let Some(value) = present(payload, key) else {
+ return Ok(default);
+ };
+ let number = if let Some(number) = value.as_i64() {
+ number
+ } else if let Some(number) = value.as_u64() {
+ if number > maximum as u64 {
+ return Err(format!(
+ "Invalid argument type: Expected `int` <= {maximum} - at `$.{key}`"
+ ));
+ }
+ number as i64
+ } else if value
+ .as_f64()
+ .is_some_and(|number| number == default as f64)
+ || value
+ .as_bool()
+ .is_some_and(|number| i64::from(number) == default)
+ {
+ default
+ } else {
+ return Err(type_error("int", value, &format!(".{key}")));
+ };
+ if number < minimum {
+ return Err(format!(
+ "Invalid argument type: Expected `int` >= {minimum} - at `$.{key}`"
+ ));
+ }
+ if number > maximum {
+ return Err(format!(
+ "Invalid argument type: Expected `int` <= {maximum} - at `$.{key}`"
+ ));
+ }
+ Ok(number)
+}
+
+fn string_field(payload: &Value, key: &str, default: &str) -> Result<String, String> {
+ let Some(value) = present(payload, key) else {
+ return Ok(default.to_string());
+ };
+ value
+ .as_str()
+ .map(str::to_string)
+ .ok_or_else(|| type_error("str", value, &format!(".{key}")))
+}
+
+fn optional_string_field(payload: &Value, key: &str) -> Result<Option<String>, String> {
+ let Some(value) = present(payload, key) else {
+ return Ok(None);
+ };
+ value
+ .as_str()
+ .map(|value| Some(value.to_string()))
+ .ok_or_else(|| type_error("str | null", value, &format!(".{key}")))
+}
+
+fn string_list_field(payload: &Value, key: &str) -> Result<Vec<String>, String> {
+ let Some(value) = present(payload, key) else {
+ return Ok(Vec::new());
+ };
+ let values = value
+ .as_array()
+ .ok_or_else(|| type_error("array | null", value, &format!(".{key}")))?;
+ values
+ .iter()
+ .enumerate()
+ .map(|(index, value)| {
+ value
+ .as_str()
+ .map(str::to_string)
+ .ok_or_else(|| type_error("str", value, &format!(".{key}[{index}]")))
+ })
+ .collect()
+}
+
+fn string_map_field(payload: &Value, key: &str) -> Result<Map<String, Value>, String> {
+ let Some(value) = present(payload, key) else {
+ return Ok(Map::new());
+ };
+ let values = value
+ .as_object()
+ .ok_or_else(|| type_error("object | null", value, &format!(".{key}")))?;
+ for value in values.values() {
+ if !value.is_string() {
+ return Err(type_error("str", value, &format!(".{key}[...]")));
+ }
+ }
+ Ok(values.clone())
+}
+
+fn cdp_url(payload: &Value) -> Result<Option<String>, String> {
+ let Some(url) = optional_string_field(payload, "cdp_url")? else {
+ return Ok(None);
+ };
+ if url.is_empty() {
+ return Ok(None);
+ }
+ let Some(authority) = url
+ .strip_prefix("ws://")
+ .or_else(|| url.strip_prefix("wss://"))
+ else {
+ return Err(
+ "Invalid argument type: CDP URL must use 'ws://' or 'wss://' scheme".to_string(),
+ );
+ };
+ if authority
+ .split(['/', '?', '#'])
+ .next()
+ .unwrap_or_default()
+ .is_empty()
+ {
+ return Err("Invalid argument type: Invalid hostname for the CDP URL".to_string());
+ }
+ Ok(Some(url))
+}
+
+fn proxy_field(payload: &Value) -> Result<ProxyConfig, String> {
+ let Some(value) = present(payload, "proxy") else {
+ return Ok((None, None));
+ };
+ if let Some(proxy) = value.as_str() {
+ if proxy.is_empty() {
+ return Ok((None, None));
+ }
+ let parsed = url::Url::parse(proxy)
+ .map_err(|_| "Invalid argument type: Invalid proxy string!".to_string())?;
+ if !matches!(parsed.scheme(), "http" | "https" | "socks4" | "socks5")
+ || parsed.host_str().is_none()
+ {
+ return Err("Invalid argument type: Invalid proxy string!".to_string());
+ }
+ let mut server = format!(
+ "{}://{}",
+ parsed.scheme(),
+ parsed.host_str().unwrap_or_default()
+ );
+ if let Some(port) = parsed.port() {
+ server.push_str(&format!(":{port}"));
+ }
+ let username = parsed.username().to_string();
+ let password = parsed.password().unwrap_or_default().to_string();
+ let auth = (!username.is_empty() || !password.is_empty()).then_some((username, password));
+ return Ok((Some(server), auth));
+ }
+ if let Some(values) = value.as_object() {
+ for value in values.values() {
+ if !value.is_string() {
+ return Err(type_error("str", value, ".proxy[...]"));
+ }
+ }
+ let server = values.get("server").and_then(Value::as_str).ok_or_else(|| {
+ "Invalid argument type: Invalid proxy dictionary: Object missing required field `server`"
+ .to_string()
+ })?;
+ let username = values
+ .get("username")
+ .and_then(Value::as_str)
+ .unwrap_or_default()
+ .to_string();
+ let password = values
+ .get("password")
+ .and_then(Value::as_str)
+ .unwrap_or_default()
+ .to_string();
+ let auth = (!username.is_empty() || !password.is_empty()).then_some((username, password));
+ return Ok((Some(server.to_string()), auth));
+ }
+ if value.as_array().is_some_and(Vec::is_empty) {
+ return Ok((None, None));
+ }
+ Err(type_error("str | object | array | null", value, ".proxy"))
+}
+
+pub struct RawBrowser {
+ client: CdpClient,
+ context_id: Option<String>,
+ persistent: bool,
+ remote: bool,
+ closed: AtomicBool,
+ child_router: tokio::task::JoinHandle<()>,
+ _profile: Option<TempProfile>,
+ _gate: Option<EgressGate>,
+}
+
+impl RawBrowser {
+ pub async fn start(
+ config: &WorkerConfig,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ persistent: bool,
+ ) -> Result<Self, String> {
+ crate::scrapling::browserforge::initialize_browser_defaults()?;
+ options.validate_policy(config.scrapling.security_mode)?;
+ let gate = if config.scrapling.security_mode == SecurityMode::Safe {
+ Some(
+ EgressGate::start(SsrfPolicy {
+ allow_loopback: config.scrapling.allow_loopback,
+ })
+ .await?,
+ )
+ } else {
+ None
+ };
+
+ let (client, profile, remote) = if let Some(url) = &options.cdp_url {
+ (
+ CdpClient::connect_websocket_url(url)
+ .await
+ .map_err(|e| e.to_string())?,
+ None,
+ true,
+ )
+ } else {
+ let executable = chromium_executable(config, options.real_chrome)?;
+ // The exact-version pin exists for the compat fingerprint story
+ // (its error message says so); safe mode must accept whatever
+ // Chromium the system has or the default config is dead on every
+ // stock Linux install.
+ if config.scrapling.security_mode == SecurityMode::Compat
+ && cfg!(all(
+ target_os = "linux",
+ any(target_arch = "x86_64", target_arch = "aarch64")
+ ))
+ {
+ certify_chromium(&executable)?;
+ }
+ let profile = TempProfile::new()?;
+ let mut command =
+ launch_command(&executable, &profile.path, options, stealth, gate.as_ref());
+ let client = CdpClient::launch_pipe(&mut command).map_err(|e| e.to_string())?;
+ (client, Some(profile), false)
+ };
+
+ initialize_root(&client, persistent && !remote).await?;
+ let child_router = tokio::spawn(route_child_targets(client.clone(), stealth));
+ let context_id = if remote {
+ Some(create_browser_context(&client, options.proxy.as_deref()).await?)
+ } else {
+ None
+ };
+ Ok(Self {
+ client,
+ context_id,
+ persistent,
+ remote,
+ closed: AtomicBool::new(false),
+ child_router,
+ _profile: profile,
+ _gate: gate,
+ })
+ }
+
+ pub async fn fetch(
+ &self,
+ url: &str,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ ) -> Result<PageData, String> {
+ self.fetch_inner(url, options, stealth, false).await
+ }
+
+ pub async fn fetch_session(
+ &self,
+ url: &str,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ proxy_override: bool,
+ ) -> Result<PageData, String> {
+ self.fetch_inner(url, options, stealth, proxy_override)
+ .await
+ }
+
+ async fn fetch_inner(
+ &self,
+ url: &str,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ proxy_override: bool,
+ ) -> Result<PageData, String> {
+ let mut last = None;
+ for attempt in 0..options.retries {
+ let temporary_context = if proxy_override && options.proxy.is_some() {
+ if !self.remote {
+ return Err("Browser not initialized for proxy rotation mode".to_string());
+ }
+ Some(create_browser_context(&self.client, options.proxy.as_deref()).await?)
+ } else {
+ None
+ };
+ let context = temporary_context.as_deref().or(self.context_id.as_deref());
+ let result = self.fetch_once(url, options, stealth, context).await;
+ if let Some(context) = temporary_context {
+ dispose_browser_context(&self.client, &context).await;
+ }
+ match result {
+ Ok(page) => return Ok(page),
+ Err(error) => last = Some(error),
+ }
+ if attempt + 1 < options.retries {
+ tokio::time::sleep(options.retry_delay).await;
+ }
+ }
+ Err(last.unwrap_or_else(|| "Request failed".to_string()))
+ }
+
+ async fn fetch_once(
+ &self,
+ url: &str,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ context_id: Option<&str>,
+ ) -> Result<PageData, String> {
+ let mut page = RawPage::open(&self.client, context_id, options, stealth).await?;
+ let result = page.navigate(url, options).await;
+ page.close().await;
+ result
+ }
+
+ pub async fn screenshot(
+ &self,
+ url: &str,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ full_page: bool,
+ format: &str,
+ ) -> Result<(Vec<Value>, String, String), String> {
+ let mut page =
+ RawPage::open(&self.client, self.context_id.as_deref(), options, stealth).await?;
+ // Close the page on every path — an early `?` here would leak the tab.
+ let shot = async {
+ let final_url = page.navigate(url, options).await?.url;
+ let (image, mime) = page.screenshot(full_page, format).await?;
+ Ok::<_, String>((final_url, image, mime))
+ }
+ .await;
+ page.close().await;
+ let (final_url, image, mime) = shot?;
+ let (tiles, width, height, truncated) = tile_screenshot(&image, format)?;
+ let kb =
+ python_round(tiles.iter().map(Vec::len).sum::<usize>() as f64 / 1024.0).max(1) as usize;
+ let mut content = tiles
+ .into_iter()
+ .map(|tile| json!({"type": "image", "mime": mime, "data": STANDARD.encode(tile)}))
+ .collect::<Vec<_>>();
+ let mut caption = format!(
+ "screenshot of {final_url} — {width}x{height}px, {} tile(s), {kb} KB",
+ content.len()
+ );
+ if truncated {
+ caption.push_str(" (truncated: page taller than 6 tiles)");
+ }
+ content.push(json!({"type": "text", "text": caption}));
+ Ok((content, mime, final_url))
+ }
+
+ pub async fn shutdown(&self) {
+ if self.closed.swap(true, Ordering::AcqRel) {
+ return;
+ }
+ self.child_router.abort();
+ if let Some(context) = &self.context_id {
+ dispose_browser_context(&self.client, context).await;
+ }
+ if self.persistent && !self.remote {
+ if let Ok(command) = self.client.send("Browser.close", json!({})) {
+ let _ = command.await;
+ }
+ }
+ let _ = self.client.close();
+ }
+}
+
+impl Drop for RawBrowser {
+ fn drop(&mut self) {
+ if self.closed.swap(true, Ordering::AcqRel) {
+ return;
+ }
+ self.child_router.abort();
+ if let Some(context_id) = self.context_id.take() {
+ if let Ok(command) = self.client.send(
+ "Target.disposeBrowserContext",
+ json!({"browserContextId": context_id}),
+ ) {
+ drop(command);
+ }
+ }
+ if self.persistent && !self.remote {
+ if let Ok(command) = self.client.send("Browser.close", json!({})) {
+ drop(command);
+ }
+ }
+ let _ = self.client.close();
+ }
+}
+
+async fn create_browser_context(client: &CdpClient, proxy: Option<&str>) -> Result<String, String> {
+ let mut params = Map::new();
+ params.insert("disposeOnDetach".to_string(), json!(true));
+ if let Some(proxy) = proxy {
+ params.insert("proxyServer".to_string(), json!(proxy));
+ params.insert("proxyBypassList".to_string(), json!("<-loopback>"));
+ }
+ client
+ .send("Target.createBrowserContext", Value::Object(params))
+ .map_err(|error| error.to_string())?
+ .await
+ .map_err(|error| error.to_string())?
+ .get("browserContextId")
+ .and_then(Value::as_str)
+ .map(str::to_string)
+ .ok_or_else(|| "Target.createBrowserContext returned no browserContextId".to_string())
+}
+
+async fn dispose_browser_context(client: &CdpClient, context: &str) {
+ if let Ok(command) = client.send(
+ "Target.disposeBrowserContext",
+ json!({"browserContextId": context}),
+ ) {
+ let _ = command.await;
+ }
+}
+
+async fn route_child_targets(client: CdpClient, stealth: bool) {
+ // Auto-attach happens on the PAGE session, so child targets announce
+ // themselves tagged with the page's sessionId — a root-scoped receiver
+ // never sees them and the child stays frozen on waitForDebuggerOnStart.
+ let mut events = client.subscribe_any();
+ while let Ok(event) = events.recv().await {
+ if event.method != "Target.attachedToTarget" {
+ continue;
+ }
+ let Some(session_id) = event.params.get("sessionId").and_then(Value::as_str) else {
+ continue;
+ };
+ let target_type = event
+ .params
+ .pointer("/targetInfo/type")
+ .and_then(Value::as_str)
+ .unwrap_or_default();
+ if target_type == "page" {
+ continue;
+ }
+ let session = client.session(session_id);
+ let runtime = if stealth {
+ session.send(
+ "Runtime.evaluate",
+ json!({
+ "expression": "globalThis",
+ "serializationOptions": {"serialization": "idOnly"},
+ "returnByValue": false
+ }),
+ )
+ } else {
+ session.send("Runtime.enable", json!({}))
+ };
+ if let Ok(runtime) = runtime {
+ let _ = runtime.await;
+ }
+ if let Ok(resume) = session.send("Runtime.runIfWaitingForDebugger", json!({})) {
+ let _ = resume.await;
+ }
+ }
+}
+
+struct RawPage {
+ client: CdpClient,
+ session: CdpSession,
+ target_id: String,
+ events: EventReceiver,
+}
+
+impl RawPage {
+ async fn open(
+ client: &CdpClient,
+ context_id: Option<&str>,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ ) -> Result<Self, String> {
+ let mut root_events = client.subscribe();
+ let mut params = json!({"url": "about:blank", "newWindow": false});
+ if let Some(context) = context_id {
+ params["browserContextId"] = json!(context);
+ }
+ let target_id = client
+ .send("Target.createTarget", params)
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?
+ .get("targetId")
+ .and_then(Value::as_str)
+ .ok_or("Target.createTarget returned no targetId")?
+ .to_string();
+ // From here on the created target must not leak: every error path
+ // closes it, or failed opens pile up tabs in the pooled browser.
+ let attach = async {
+ let deadline = Instant::now() + options.timeout;
+ let session_id = loop {
+ let remaining = deadline.saturating_duration_since(Instant::now());
+ if remaining.is_zero() {
+ return Err(format!("timed out attaching to browser target {target_id}"));
+ }
+ let event = tokio::time::timeout(remaining, root_events.recv())
+ .await
+ .map_err(|_| format!("timed out attaching to browser target {target_id}"))?
+ .map_err(|e| e.to_string())?;
+ if event.method == "Target.attachedToTarget"
+ && event
+ .params
+ .pointer("/targetInfo/targetId")
+ .and_then(Value::as_str)
+ == Some(target_id.as_str())
+ {
+ break event
+ .params
+ .get("sessionId")
+ .and_then(Value::as_str)
+ .ok_or("Target.attachedToTarget returned no sessionId")?
+ .to_string();
+ }
+ };
+ let session = client.session(session_id);
+ let events = session.subscribe();
+ initialize_page(&session, options, stealth).await?;
+ Ok((session, events))
+ }
+ .await;
+ match attach {
+ Ok((session, events)) => Ok(Self {
+ client: client.clone(),
+ session,
+ target_id,
+ events,
+ }),
+ Err(error) => {
+ if let Ok(close) = client.send("Target.closeTarget", json!({"targetId": target_id}))
+ {
+ let _ = close.await;
+ }
+ Err(error)
+ }
+ }
+ }
+
+ async fn navigate(
+ &mut self,
+ url: &str,
+ options: &RawBrowserOptions,
+ ) -> Result<PageData, String> {
+ let navigate = self
+ .session
+ .send(
+ "Page.navigate",
+ json!({
+ "url": url,
+ "referrer": referer(options),
+ "transitionType": "typed"
+ }),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ if let Some(error) = navigate.get("errorText").and_then(Value::as_str) {
+ return Err(error.to_string());
+ }
+ let main_frame = navigate
+ .get("frameId")
+ .and_then(Value::as_str)
+ .map(str::to_string);
+
+ let deadline = Instant::now() + options.timeout;
+ let mut loaded = false;
+ let mut dom_loaded = !options.load_dom;
+ let mut inflight = HashSet::new();
+ let mut quiet_since = Instant::now();
+ let mut responses = HashMap::<String, ResponseInfo>::new();
+ let mut document_request = None;
+ let mut xhr_ids = Vec::new();
+ loop {
+ if loaded
+ && dom_loaded
+ && (!options.network_idle
+ || (inflight.is_empty() && quiet_since.elapsed() >= Duration::from_millis(500)))
+ {
+ break;
+ }
+ let remaining = deadline.saturating_duration_since(Instant::now());
+ if remaining.is_zero() {
+ break;
+ }
+ let event = match tokio::time::timeout(
+ remaining.min(Duration::from_millis(100)),
+ self.events.recv(),
+ )
+ .await
+ {
+ Ok(Ok(event)) => event,
+ Ok(Err(error)) => return Err(error.to_string()),
+ Err(_) => continue,
+ };
+ self.track_event(
+ event,
+ options,
+ main_frame.as_deref(),
+ &mut loaded,
+ &mut dom_loaded,
+ &mut inflight,
+ &mut quiet_since,
+ &mut responses,
+ &mut document_request,
+ &mut xhr_ids,
+ )
+ .await?;
+ }
+
+ if options.solve_cloudflare {
+ self.solve_cloudflare(
+ options,
+ main_frame.as_deref(),
+ &mut loaded,
+ &mut dom_loaded,
+ &mut inflight,
+ &mut quiet_since,
+ &mut responses,
+ &mut document_request,
+ &mut xhr_ids,
+ )
+ .await?;
+ }
+ if let Some(selector) = &options.wait_selector {
+ let found = self
+ .wait_selector(selector, &options.wait_selector_state, options.timeout)
+ .await;
+ if found && options.network_idle {
+ self.wait_for_network_idle(
+ options.timeout,
+ options,
+ main_frame.as_deref(),
+ &mut loaded,
+ &mut dom_loaded,
+ &mut inflight,
+ &mut quiet_since,
+ &mut responses,
+ &mut document_request,
+ &mut xhr_ids,
+ )
+ .await?;
+ }
+ }
+ if !options.wait.is_zero() {
+ tokio::time::sleep(options.wait).await;
+ }
+ let final_url = self
+ .evaluate("location.href", true)
+ .await?
+ .as_str()
+ .unwrap_or(url)
+ .to_string();
+ let response = document_request
+ .as_ref()
+ .and_then(|request| responses.get(request))
+ .cloned();
+ let content_type = response
+ .as_ref()
+ .and_then(|value| value.headers.get("content-type"))
+ .and_then(Value::as_str)
+ .unwrap_or_default();
+ let html = if content_type.contains("html") || document_request.is_none() {
+ self.page_html().await?
+ } else {
+ let body = self
+ .session
+ .send(
+ "Network.getResponseBody",
+ json!({"requestId": document_request.as_deref().unwrap_or_default()}),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ let body = decode_network_body(&body, charset(content_type).as_deref())?;
+ let document = crate::scrapling::dom::parse(&body);
+ crate::scrapling::dom::outer_html(document.root())
+ };
+ let mut captured_xhr = Vec::new();
+ for id in xhr_ids {
+ if let Some(info) = responses.get(&id) {
+ captured_xhr.push(info.as_value());
+ }
+ }
+ Ok(PageData {
+ status: response.as_ref().and_then(|value| value.status),
+ url: final_url,
+ headers: response
+ .as_ref()
+ .map(|value| value.headers.clone())
+ .unwrap_or_default(),
+ // The frozen wrapper's tuple-of-cookie-dicts serialization quirk is `{}`.
+ cookies: Map::new(),
+ encoding: response
+ .as_ref()
+ .and_then(|value| value.headers.get("content-type"))
+ .and_then(Value::as_str)
+ .and_then(charset)
+ .or_else(|| Some("utf-8".to_string())),
+ html,
+ captured_xhr,
+ })
+ }
+
+ async fn evaluate(&self, expression: &str, return_by_value: bool) -> Result<Value, String> {
+ let result = self
+ .session
+ .send(
+ "Runtime.evaluate",
+ json!({
+ "expression": expression,
+ "returnByValue": return_by_value,
+ "awaitPromise": true,
+ "userGesture": true
+ }),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ if let Some(exception) = result.get("exceptionDetails") {
+ return Err(format!("JavaScript evaluation failed: {exception}"));
+ }
+ Ok(result
+ .get("result")
+ .and_then(|value| value.get("value"))
+ .cloned()
+ .unwrap_or(Value::Null))
+ }
+
+ async fn intercept(&self, event: &CdpEvent, options: &RawBrowserOptions) -> Result<(), String> {
+ let request_id = event
+ .params
+ .get("requestId")
+ .and_then(Value::as_str)
+ .ok_or("Fetch.requestPaused returned no requestId")?;
+ let resource = event
+ .params
+ .get("resourceType")
+ .and_then(Value::as_str)
+ .unwrap_or_default();
+ let host = event
+ .params
+ .pointer("/request/url")
+ .and_then(Value::as_str)
+ .and_then(|url| url::Url::parse(url).ok())
+ .and_then(|url| url.host_str().map(str::to_string));
+ let blocked = (options.disable_resources && BLOCKED_RESOURCE_TYPES.contains(&resource))
+ || host.as_deref().is_some_and(|host| {
+ options
+ .blocked_domains
+ .iter()
+ .any(|domain| domain_matches(host, domain))
+ || (options.block_ads
+ && ad_domains()
+ .iter()
+ .any(|domain| domain_matches(host, domain)))
+ });
+ let (method, params) = if blocked {
+ (
+ "Fetch.failRequest",
+ json!({"requestId": request_id, "errorReason": "BlockedByClient"}),
+ )
+ } else {
+ ("Fetch.continueRequest", json!({"requestId": request_id}))
+ };
+ self.session
+ .send(method, params)
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ Ok(())
+ }
+
+ async fn authenticate(
+ &self,
+ event: &CdpEvent,
+ options: &RawBrowserOptions,
+ ) -> Result<(), String> {
+ let request_id = event
+ .params
+ .get("requestId")
+ .and_then(Value::as_str)
+ .ok_or("Fetch.authRequired returned no requestId")?;
+ let is_proxy = event
+ .params
+ .pointer("/authChallenge/source")
+ .and_then(Value::as_str)
+ == Some("Proxy");
+ let response = if let (true, Some((username, password))) = (is_proxy, &options.proxy_auth) {
+ json!({
+ "response": "ProvideCredentials",
+ "username": username,
+ "password": password
+ })
+ } else {
+ json!({"response": "Default"})
+ };
+ self.session
+ .send(
+ "Fetch.continueWithAuth",
+ json!({"requestId": request_id, "authChallengeResponse": response}),
+ )
+ .map_err(|error| error.to_string())?
+ .await
+ .map_err(|error| error.to_string())?;
+ Ok(())
+ }
+
+ async fn page_html(&self) -> Result<String, String> {
+ Ok(self
+ .evaluate("document.documentElement.outerHTML", true)
+ .await?
+ .as_str()
+ .unwrap_or_default()
+ .to_string())
+ }
+
+ async fn wait_selector(&self, selector: &str, state: &str, timeout: Duration) -> bool {
+ let selector = serde_json::to_string(selector).unwrap_or_else(|_| "null".to_string());
+ let predicate = match state {
+ "detached" => format!("!document.querySelector({selector})"),
+ "visible" => format!("(()=>{{const e=document.querySelector({selector});return !!e&&(e.offsetParent!==null||e.getClientRects().length>0)}})()"),
+ "hidden" => format!("(()=>{{const e=document.querySelector({selector});return !e||(e.offsetParent===null&&e.getClientRects().length===0)}})()"),
+ _ => format!("!!document.querySelector({selector})"),
+ };
+ let deadline = Instant::now() + timeout;
+ while Instant::now() < deadline {
+ if self.evaluate(&predicate, true).await == Ok(Value::Bool(true)) {
+ return true;
+ }
+ tokio::time::sleep(Duration::from_millis(100)).await;
+ }
+ false
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ async fn track_event(
+ &self,
+ event: CdpEvent,
+ options: &RawBrowserOptions,
+ main_frame: Option<&str>,
+ loaded: &mut bool,
+ dom_loaded: &mut bool,
+ inflight: &mut HashSet<String>,
+ quiet_since: &mut Instant,
+ responses: &mut HashMap<String, ResponseInfo>,
+ document_request: &mut Option<String>,
+ xhr_ids: &mut Vec<String>,
+ ) -> Result<(), String> {
+ match event.method.as_str() {
+ "Fetch.requestPaused" => {
+ self.intercept(&event, options).await?;
+ return Ok(());
+ }
+ "Fetch.authRequired" => {
+ self.authenticate(&event, options).await?;
+ return Ok(());
+ }
+ _ => {}
+ }
+ handle_event(
+ event,
+ main_frame,
+ options.capture_xhr.as_deref(),
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ );
+ Ok(())
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ async fn wait_for_network_idle(
+ &mut self,
+ timeout: Duration,
+ options: &RawBrowserOptions,
+ main_frame: Option<&str>,
+ loaded: &mut bool,
+ dom_loaded: &mut bool,
+ inflight: &mut HashSet<String>,
+ quiet_since: &mut Instant,
+ responses: &mut HashMap<String, ResponseInfo>,
+ document_request: &mut Option<String>,
+ xhr_ids: &mut Vec<String>,
+ ) -> Result<(), String> {
+ let deadline = Instant::now() + timeout;
+ loop {
+ let idle = inflight.is_empty() && quiet_since.elapsed() >= Duration::from_millis(500);
+ let remaining = deadline.saturating_duration_since(Instant::now());
+ if remaining.is_zero() {
+ return Ok(());
+ }
+ let wait = if idle {
+ Duration::from_millis(1)
+ } else {
+ remaining.min(Duration::from_millis(100))
+ };
+ match tokio::time::timeout(wait, self.events.recv()).await {
+ Ok(Ok(event)) => {
+ self.track_event(
+ event,
+ options,
+ main_frame,
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ )
+ .await?;
+ }
+ Ok(Err(error)) => return Err(error.to_string()),
+ Err(_) if idle => return Ok(()),
+ Err(_) => {}
+ }
+ }
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ async fn wait_for_load_state(
+ &mut self,
+ timeout: Duration,
+ options: &RawBrowserOptions,
+ main_frame: Option<&str>,
+ loaded: &mut bool,
+ dom_loaded: &mut bool,
+ inflight: &mut HashSet<String>,
+ quiet_since: &mut Instant,
+ responses: &mut HashMap<String, ResponseInfo>,
+ document_request: &mut Option<String>,
+ xhr_ids: &mut Vec<String>,
+ ) -> Result<(), String> {
+ let deadline = Instant::now() + timeout;
+ loop {
+ match tokio::time::timeout(Duration::from_millis(1), self.events.recv()).await {
+ Ok(Ok(event)) => {
+ self.track_event(
+ event,
+ options,
+ main_frame,
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ )
+ .await?;
+ continue;
+ }
+ Ok(Err(error)) => return Err(error.to_string()),
+ Err(_) => {}
+ }
+ if self
+ .evaluate("document.readyState === 'complete'", true)
+ .await?
+ == Value::Bool(true)
+ {
+ return Ok(());
+ }
+ let remaining = deadline.saturating_duration_since(Instant::now());
+ if remaining.is_zero() {
+ return Err("Timeout while waiting for page load state".to_string());
+ }
+ match tokio::time::timeout(
+ remaining.min(Duration::from_millis(100)),
+ self.events.recv(),
+ )
+ .await
+ {
+ Ok(Ok(event)) => {
+ self.track_event(
+ event,
+ options,
+ main_frame,
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ )
+ .await?;
+ }
+ Ok(Err(error)) => return Err(error.to_string()),
+ Err(_) => {}
+ }
+ }
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ async fn solve_cloudflare(
+ &mut self,
+ options: &RawBrowserOptions,
+ main_frame: Option<&str>,
+ loaded: &mut bool,
+ dom_loaded: &mut bool,
+ inflight: &mut HashSet<String>,
+ quiet_since: &mut Instant,
+ responses: &mut HashMap<String, ResponseInfo>,
+ document_request: &mut Option<String>,
+ xhr_ids: &mut Vec<String>,
+ ) -> Result<(), String> {
+ // Every poll loop below waits on Cloudflare resolving; a challenge
+ // that never clears (a hard block, a broken Turnstile) would otherwise
+ // spin forever and brick the session slot. One deadline bounds the
+ // whole solve.
+ let solve_deadline = Instant::now() + options.timeout;
+ let expired = || Instant::now() >= solve_deadline;
+ let mut html;
+ loop {
+ if expired() {
+ return Err("timed out solving the Cloudflare challenge".to_string());
+ }
+ self.wait_for_network_idle(
+ Duration::from_secs(5),
+ options,
+ main_frame,
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ )
+ .await?;
+ html = self.page_html().await?;
+ let Some(challenge) = cloudflare_challenge(&html) else {
+ return Ok(());
+ };
+ if challenge == "non-interactive" {
+ while html.contains("<title>Just a moment...</title>") {
+ if expired() {
+ return Err("timed out solving the Cloudflare challenge".to_string());
+ }
+ tokio::time::sleep(Duration::from_secs(1)).await;
+ self.wait_for_load_state(
+ options.timeout,
+ options,
+ main_frame,
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ )
+ .await?;
+ html = self.page_html().await?;
+ }
+ return Ok(());
+ }
+
+ let selector = if challenge == "embedded" {
+ "#cf_turnstile div, #cf-turnstile div, .turnstile>div>div"
+ } else {
+ ".main-content p+div>div>div"
+ };
+ if challenge != "embedded" {
+ while html.contains("Verifying you are human.") {
+ if expired() {
+ return Err("timed out solving the Cloudflare challenge".to_string());
+ }
+ tokio::time::sleep(Duration::from_millis(500)).await;
+ html = self.page_html().await?;
+ }
+ }
+
+ let (has_iframe, mut outer_box) = self.challenge_iframe_box().await?;
+ if has_iframe && challenge != "embedded" {
+ while outer_box.is_none() {
+ if expired() {
+ return Err("timed out solving the Cloudflare challenge".to_string());
+ }
+ tokio::time::sleep(Duration::from_millis(500)).await;
+ outer_box = self.challenge_iframe_box().await?.1;
+ }
+ }
+ if !has_iframe || outer_box.is_none() {
+ html = self.page_html().await?;
+ if !html.contains("<title>Just a moment...</title>") {
+ return Ok(());
+ }
+ outer_box = self.selector_box(selector).await?;
+ }
+ let (x, y) = outer_box
+ .ok_or_else(|| "TypeError: 'NoneType' object is not subscriptable".to_string())?;
+ let x = x + f64::from(crate::scrapling::browserforge::randint(26, 28));
+ let y = y + f64::from(crate::scrapling::browserforge::randint(25, 27));
+ let delay = crate::scrapling::browserforge::randint(100, 200);
+ self.session
+ .send(
+ "Input.dispatchMouseEvent",
+ json!({"type":"mouseMoved","x":x,"y":y}),
+ )
+ .map_err(|error| error.to_string())?
+ .await
+ .map_err(|error| error.to_string())?;
+ self.session
+ .send(
+ "Input.dispatchMouseEvent",
+ json!({"type":"mousePressed","x":x,"y":y,"button":"left","clickCount":1}),
+ )
+ .map_err(|error| error.to_string())?
+ .await
+ .map_err(|error| error.to_string())?;
+ tokio::time::sleep(Duration::from_millis(u64::from(delay))).await;
+ self.session
+ .send(
+ "Input.dispatchMouseEvent",
+ json!({"type":"mouseReleased","x":x,"y":y,"button":"left","clickCount":1}),
+ )
+ .map_err(|error| error.to_string())?
+ .await
+ .map_err(|error| error.to_string())?;
+
+ self.wait_for_network_idle(
+ options.timeout,
+ options,
+ main_frame,
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ )
+ .await?;
+ if challenge != "embedded" {
+ for _ in 0..100 {
+ html = self.page_html().await?;
+ if !html.contains("<title>Just a moment...</title>") {
+ break;
+ }
+ tokio::time::sleep(Duration::from_millis(100)).await;
+ }
+ }
+ self.wait_for_load_state(
+ options.timeout,
+ options,
+ main_frame,
+ loaded,
+ dom_loaded,
+ inflight,
+ quiet_since,
+ responses,
+ document_request,
+ xhr_ids,
+ )
+ .await?;
+ html = self.page_html().await?;
+ if !html.contains("<title>Just a moment...</title>") {
+ return Ok(());
+ }
+ }
+ }
+
+ async fn challenge_iframe_box(&self) -> Result<(bool, Option<(f64, f64)>), String> {
+ let tree = self
+ .session
+ .send("Page.getFrameTree", json!({}))
+ .map_err(|error| error.to_string())?
+ .await
+ .map_err(|error| error.to_string())?;
+ let Some(frame_id) = challenge_frame_id(tree.get("frameTree").unwrap_or(&Value::Null))
+ else {
+ return Ok((false, None));
+ };
+ let owner = self
+ .session
+ .send("DOM.getFrameOwner", json!({"frameId": frame_id}))
+ .map_err(|error| error.to_string())?
+ .await;
+ let Ok(owner) = owner else {
+ return Ok((true, None));
+ };
+ let Some(backend_node_id) = owner.get("backendNodeId").and_then(Value::as_u64) else {
+ return Ok((true, None));
+ };
+ let model = self
+ .session
+ .send("DOM.getBoxModel", json!({"backendNodeId": backend_node_id}))
+ .map_err(|error| error.to_string())?
+ .await;
+ let Ok(model) = model else {
+ return Ok((true, None));
+ };
+ Ok((
+ true,
+ box_origin(model.pointer("/model/border").unwrap_or(&Value::Null)),
+ ))
+ }
+
+ async fn selector_box(&self, selector: &str) -> Result<Option<(f64, f64)>, String> {
+ let selector = serde_json::to_string(selector).map_err(|error| error.to_string())?;
+ let point = self
+ .evaluate(
+ &format!("(()=>{{const e=[...document.querySelectorAll({selector})].at(-1);if(!e)return null;const r=e.getBoundingClientRect();return{{x:r.x,y:r.y,w:r.width,h:r.height}}}})()"),
+ true,
+ )
+ .await?;
+ match (
+ point.get("x").and_then(Value::as_f64),
+ point.get("y").and_then(Value::as_f64),
+ point.get("w").and_then(Value::as_f64),
+ point.get("h").and_then(Value::as_f64),
+ ) {
+ (Some(x), Some(y), Some(width), Some(height)) if width > 0.0 && height > 0.0 => {
+ Ok(Some((x, y)))
+ }
+ _ => Ok(None),
+ }
+ }
+
+ async fn screenshot(&self, full_page: bool, format: &str) -> Result<(Vec<u8>, String), String> {
+ let (format, mime) = match format {
+ "png" => ("png", "image/png"),
+ "jpeg" | "jpg" => ("jpeg", "image/jpeg"),
+ other => return Err(format!("unsupported format: {other} (use png or jpeg)")),
+ };
+ let mut params = json!({"format": format, "fromSurface": true});
+ if full_page {
+ let metrics = self
+ .session
+ .send("Page.getLayoutMetrics", json!({}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ if let Some(size) = metrics.get("cssContentSize") {
+ params["captureBeyondViewport"] = json!(true);
+ params["clip"] = json!({
+ "x": size.get("x").and_then(Value::as_f64).unwrap_or(0.0),
+ "y": size.get("y").and_then(Value::as_f64).unwrap_or(0.0),
+ "width": size.get("width").and_then(Value::as_f64).unwrap_or(1280.0),
+ "height": size.get("height").and_then(Value::as_f64).unwrap_or(800.0),
+ "scale": 1
+ });
+ }
+ }
+ let shot = self
+ .session
+ .send("Page.captureScreenshot", params)
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ let data = shot
+ .get("data")
+ .and_then(Value::as_str)
+ .ok_or("Page.captureScreenshot returned no data")?;
+ Ok((
+ STANDARD.decode(data).map_err(|e| e.to_string())?,
+ mime.to_string(),
+ ))
+ }
+
+ async fn close(&self) {
+ if let Ok(command) = self
+ .client
+ .send("Target.closeTarget", json!({"targetId": self.target_id}))
+ {
+ let _ = command.await;
+ }
+ }
+}
+
+#[derive(Clone)]
+struct ResponseInfo {
+ url: String,
+ status: Option<u16>,
+ headers: Map<String, Value>,
+ request_headers: Map<String, Value>,
+}
+
+impl ResponseInfo {
+ fn as_value(&self) -> Value {
+ json!({
+ "status": self.status,
+ "url": self.url,
+ "headers": self.headers,
+ "cookies": {},
+ "encoding": self.headers.get("content-type").and_then(Value::as_str).and_then(charset).unwrap_or_else(|| "utf-8".to_string()),
+ "content": "",
+ "history": [],
+ "request_headers": self.request_headers,
+ })
+ }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn handle_event(
+ event: CdpEvent,
+ main_frame: Option<&str>,
+ capture_xhr: Option<&str>,
+ loaded: &mut bool,
+ dom_loaded: &mut bool,
+ inflight: &mut HashSet<String>,
+ quiet_since: &mut Instant,
+ responses: &mut HashMap<String, ResponseInfo>,
+ document_request: &mut Option<String>,
+ xhr_ids: &mut Vec<String>,
+) {
+ match event.method.as_str() {
+ "Page.loadEventFired" => *loaded = true,
+ "Page.domContentEventFired" => *dom_loaded = true,
+ "Network.requestWillBeSent" => {
+ if let Some(request_id) = event.params.get("requestId").and_then(Value::as_str) {
+ inflight.insert(request_id.to_string());
+ }
+ *quiet_since = Instant::now();
+ if event.params.get("type").and_then(Value::as_str) == Some("Document")
+ && event
+ .params
+ .get("frameId")
+ .and_then(Value::as_str)
+ .is_some_and(|frame| main_frame.is_none_or(|main| main == frame))
+ {
+ *document_request = event
+ .params
+ .get("requestId")
+ .and_then(Value::as_str)
+ .map(str::to_string);
+ }
+ }
+ "Network.loadingFinished" | "Network.loadingFailed" => {
+ if let Some(request_id) = event.params.get("requestId").and_then(Value::as_str) {
+ inflight.remove(request_id);
+ }
+ *quiet_since = Instant::now();
+ }
+ "Network.responseReceived" => {
+ let Some(id) = event.params.get("requestId").and_then(Value::as_str) else {
+ return;
+ };
+ let response = event.params.get("response").cloned().unwrap_or(Value::Null);
+ let url = response
+ .get("url")
+ .and_then(Value::as_str)
+ .unwrap_or_default()
+ .to_string();
+ let resource_type = event.params.get("type").and_then(Value::as_str);
+ if matches!(resource_type, Some("XHR" | "Fetch"))
+ && capture_xhr.is_some_and(|pattern| {
+ crate::scrapling::text::compile(pattern, false)
+ .is_ok_and(|pattern| pattern.check_match(&url))
+ })
+ {
+ xhr_ids.push(id.to_string());
+ }
+ responses.insert(
+ id.to_string(),
+ ResponseInfo {
+ url,
+ status: response
+ .get("status")
+ .and_then(Value::as_f64)
+ .map(|status| status as u16),
+ headers: response
+ .get("headers")
+ .and_then(Value::as_object)
+ .map(playwright_headers)
+ .unwrap_or_default(),
+ request_headers: event
+ .params
+ .pointer("/response/requestHeaders")
+ .and_then(Value::as_object)
+ .cloned()
+ .unwrap_or_default(),
+ },
+ );
+ }
+ _ => {}
+ }
+}
+
+fn playwright_headers(headers: &Map<String, Value>) -> Map<String, Value> {
+ headers
+ .iter()
+ .map(|(name, value)| {
+ let name = name.to_ascii_lowercase();
+ let value = value
+ .as_str()
+ .map(|value| {
+ if name == "set-cookie" {
+ value.to_string()
+ } else {
+ value.replace('\n', ", ")
+ }
+ })
+ .map(Value::String)
+ .unwrap_or_else(|| value.clone());
+ (name, value)
+ })
+ .collect()
+}
+
+async fn initialize_root(client: &CdpClient, persistent: bool) -> Result<(), String> {
+ client
+ .send("Browser.getVersion", json!({}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ client
+ .send(
+ "Target.setAutoAttach",
+ json!({
+ "autoAttach": true,
+ "waitForDebuggerOnStart": true,
+ "flatten": true
+ }),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ if persistent {
+ client
+ .send("Target.getTargetInfo", json!({}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ Ok(())
+}
+
+async fn initialize_page(
+ page: &CdpSession,
+ options: &RawBrowserOptions,
+ stealth: bool,
+) -> Result<(), String> {
+ for (method, params) in [
+ ("Page.enable", json!({})),
+ ("Page.getFrameTree", json!({})),
+ ("Log.enable", json!({})),
+ ("Page.setLifecycleEventsEnabled", json!({"enabled": true})),
+ ] {
+ page.send(method, params)
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ if !stealth {
+ page.send("Runtime.enable", json!({}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ page.send(
+ "Page.addScriptToEvaluateOnNewDocument",
+ json!({"source": "", "worldName": "__playwright_utility_world__"}),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ let (width, height) = if stealth { (1920, 1080) } else { (1280, 720) };
+ page.send(
+ "Emulation.setDeviceMetricsOverride",
+ json!({
+ "width": width,
+ "height": height,
+ "deviceScaleFactor": 2,
+ "mobile": false,
+ "screenWidth": width,
+ "screenHeight": height
+ }),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ page.send(
+ "Emulation.setEmulatedMedia",
+ json!({"features": [{"name": "prefers-color-scheme", "value": "dark"}]}),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ page.send("Network.enable", json!({}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ if options.disable_resources
+ || options.block_ads
+ || !options.blocked_domains.is_empty()
+ || options.proxy_auth.is_some()
+ {
+ page.send(
+ "Fetch.enable",
+ json!({
+ "patterns": [{"urlPattern": "*", "requestStage": "Request"}],
+ "handleAuthRequests": options.proxy_auth.is_some()
+ }),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ page.send(
+ "Target.setAutoAttach",
+ json!({"autoAttach": true, "waitForDebuggerOnStart": true, "flatten": true}),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ let user_agent = options
+ .useragent
+ .as_deref()
+ .or(options.headless.then_some(DEFAULT_USER_AGENT));
+ if user_agent.is_some() || options.locale.is_some() {
+ let mut params = Map::new();
+ params.insert(
+ "userAgent".to_string(),
+ json!(user_agent.unwrap_or(DEFAULT_USER_AGENT)),
+ );
+ if let Some(locale) = &options.locale {
+ params.insert("acceptLanguage".to_string(), json!(locale));
+ }
+ page.send("Network.setUserAgentOverride", Value::Object(params))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ if !options.extra_headers.is_empty() {
+ page.send(
+ "Network.setExtraHTTPHeaders",
+ json!({"headers": options.extra_headers}),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ if let Some(timezone) = &options.timezone_id {
+ page.send(
+ "Emulation.setTimezoneOverride",
+ json!({"timezoneId": timezone}),
+ )
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ if !options.cookies.is_empty() {
+ page.send("Network.setCookies", json!({"cookies": options.cookies}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ if let Some(locale) = &options.locale {
+ page.send("Emulation.setLocaleOverride", json!({"locale": locale}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ }
+ page.send("Runtime.runIfWaitingForDebugger", json!({}))
+ .map_err(|e| e.to_string())?
+ .await
+ .map_err(|e| e.to_string())?;
+ Ok(())
+}
+
+fn referer(options: &RawBrowserOptions) -> String {
+ let has_referer = options
+ .extra_headers
+ .keys()
+ .any(|header| header.eq_ignore_ascii_case("referer"));
+ if options.google_search && !has_referer {
+ GOOGLE_REFERER.to_string()
+ } else {
+ String::new()
+ }
+}
+
+fn cookies(value: Option<&Value>) -> Result<Vec<Value>, String> {
+ let Some(value) = value.filter(|value| !value.is_null()) else {
+ return Ok(Vec::new());
+ };
+ let values = value
+ .as_array()
+ .ok_or_else(|| type_error("array | null", value, ".cookies"))?;
+ let mut output = Vec::with_capacity(values.len());
+ for (index, value) in values.iter().enumerate() {
+ let object = value
+ .as_object()
+ .ok_or_else(|| type_error("object", value, &format!(".cookies[{index}]")))?;
+ let mut cookie = Map::new();
+ for key in ["name", "value", "url", "domain", "path", "partitionKey"] {
+ let Some(value) = object.get(key) else {
+ continue;
+ };
+ if !value.is_null() && !value.is_string() {
+ return Err(type_error(
+ if matches!(key, "name" | "value") {
+ "str"
+ } else {
+ "str | null"
+ },
+ value,
+ &format!(".cookies[{index}].{key}"),
+ ));
+ }
+ cookie.insert(key.to_string(), value.clone());
+ }
+ if let Some(value) = object.get("expires") {
+ if !value.is_null() && value.as_f64().is_none() {
+ return Err(type_error(
+ "float | null",
+ value,
+ &format!(".cookies[{index}].expires"),
+ ));
+ }
+ cookie.insert("expires".to_string(), value.clone());
+ }
+ for key in ["httpOnly", "secure"] {
+ let Some(value) = object.get(key) else {
+ continue;
+ };
+ if !value.is_null() && !value.is_boolean() {
+ return Err(type_error(
+ "bool | null",
+ value,
+ &format!(".cookies[{index}].{key}"),
+ ));
+ }
+ cookie.insert(key.to_string(), value.clone());
+ }
+ if let Some(value) = object.get("sameSite") {
+ if let Some(site) = value.as_str() {
+ if !matches!(site, "Lax" | "None" | "Strict") {
+ return Err(format!(
+ "Invalid argument type: Invalid enum value '{site}' - at `$.cookies[{index}].sameSite`"
+ ));
+ }
+ } else if !value.is_null() {
+ return Err(type_error(
+ "str | null",
+ value,
+ &format!(".cookies[{index}].sameSite"),
+ ));
+ }
+ cookie.insert("sameSite".to_string(), value.clone());
+ }
+ output.push(Value::Object(cookie));
+ }
+ Ok(output)
+}
+
+fn charset(content_type: &str) -> Option<String> {
+ content_type
+ .split(';')
+ .find_map(|part| part.trim().strip_prefix("charset="))
+ .map(|value| value.trim_matches(['\'', '"']).to_string())
+}
+
+fn decode_network_body(body: &Value, encoding: Option<&str>) -> Result<String, String> {
+ let raw = body.get("body").and_then(Value::as_str).unwrap_or_default();
+ let bytes = if body
+ .get("base64Encoded")
+ .and_then(Value::as_bool)
+ .unwrap_or(false)
+ {
+ STANDARD.decode(raw).map_err(|e| e.to_string())?
+ } else {
+ raw.as_bytes().to_vec()
+ };
+ let decoder = encoding
+ .and_then(|label| encoding_rs::Encoding::for_label(label.as_bytes()))
+ .unwrap_or(encoding_rs::UTF_8);
+ Ok(decoder.decode(&bytes).0.into_owned())
+}
+
+#[allow(clippy::type_complexity)]
+fn tile_screenshot(bytes: &[u8], format: &str) -> Result<(Vec<Vec<u8>>, u32, u32, bool), String> {
+ let mut image =
+ image::load_from_memory(bytes).map_err(|e| format!("decoding screenshot: {e}"))?;
+ if image.width() > MAX_TILE_WIDTH {
+ let height =
+ python_round(image.height() as f64 * MAX_TILE_WIDTH as f64 / image.width() as f64)
+ .max(1) as u32;
+ image = image.resize_exact(MAX_TILE_WIDTH, height, FilterType::CatmullRom);
+ }
+ let (width, height) = image.dimensions();
+ let needed = height.div_ceil(MAX_TILE_HEIGHT) as usize;
+ let mut tiles = Vec::with_capacity(needed.min(MAX_TILES));
+ for top in (0..height)
+ .step_by(MAX_TILE_HEIGHT as usize)
+ .take(MAX_TILES)
+ {
+ let tile = image.crop_imm(0, top, width, (height - top).min(MAX_TILE_HEIGHT));
+ let mut encoded = Vec::new();
+ match format {
+ "png" => PngEncoder::new_with_quality(
+ &mut encoded,
+ CompressionType::Level(6),
+ PngFilterType::Adaptive,
+ )
+ .write_image(
+ tile.as_bytes(),
+ tile.width(),
+ tile.height(),
+ tile.color().into(),
+ )
+ .map_err(|e| format!("encoding PNG tile: {e}"))?,
+ "jpeg" | "jpg" => {
+ let tile = tile.to_rgb8();
+ let mut encoder = jpeg_encoder::Encoder::new(&mut encoded, 75);
+ encoder.set_sampling_factor(jpeg_encoder::SamplingFactor::R_4_2_0);
+ encoder
+ .set_chroma_subsampling_method(jpeg_encoder::ChromaSubsamplingMethod::Average);
+ encoder
+ .encode(
+ tile.as_raw(),
+ tile.width() as u16,
+ tile.height() as u16,
+ jpeg_encoder::ColorType::Rgb,
+ )
+ .map_err(|e| format!("encoding JPEG tile: {e}"))?;
+ }
+ other => return Err(format!("unsupported format: {other} (use png or jpeg)")),
+ }
+ tiles.push(encoded);
+ }
+ Ok((tiles, width, height, needed > MAX_TILES))
+}
+
+fn python_round(value: f64) -> i64 {
+ let floor = value.floor();
+ let fraction = value - floor;
+ if fraction < 0.5 || (fraction == 0.5 && floor as i64 % 2 == 0) {
+ floor as i64
+ } else {
+ floor as i64 + 1
+ }
+}
+
+fn ad_domains() -> &'static HashSet<&'static str> {
+ AD_DOMAINS.get_or_init(|| {
+ include_str!("../../vendor/scrapling-0.4.9-ad-domains.txt")
+ .lines()
+ .filter(|line| !line.is_empty() && !line.starts_with('#'))
+ .collect()
+ })
+}
+
+fn domain_matches(host: &str, domain: &str) -> bool {
+ host.eq_ignore_ascii_case(domain)
+ || host
+ .strip_suffix(domain)
+ .is_some_and(|prefix| prefix.ends_with('.'))
+}
+
+fn cloudflare_challenge(html: &str) -> Option<&'static str> {
+ for challenge in ["non-interactive", "managed", "interactive"] {
+ if html.contains(&format!("cType: '{challenge}'")) {
+ return Some(challenge);
+ }
+ }
+ let document = crate::scrapling::dom::parse(html);
+ crate::scrapling::query::css_query(
+ &document,
+ None,
+ "script[src*='challenges.cloudflare.com/turnstile/v']",
+ )
+ .is_ok_and(|matches| !matches.is_empty())
+ .then_some("embedded")
+}
+
+fn challenge_frame_id(tree: &Value) -> Option<&str> {
+ let url = tree.pointer("/frame/url").and_then(Value::as_str);
+ if url.is_some_and(|url| {
+ ["http://", "https://"].into_iter().any(|scheme| {
+ url.strip_prefix(scheme).is_some_and(|url| {
+ url.starts_with("challenges.cloudflare.com/cdn-cgi/challenge-platform/")
+ })
+ })
+ }) {
+ return tree.pointer("/frame/id").and_then(Value::as_str);
+ }
+ tree.get("childFrames")
+ .and_then(Value::as_array)
+ .and_then(|children| children.iter().find_map(challenge_frame_id))
+}
+
+fn box_origin(quad: &Value) -> Option<(f64, f64)> {
+ let coordinates = quad
+ .as_array()?
+ .iter()
+ .map(Value::as_f64)
+ .collect::<Option<Vec<_>>>()?;
+ if coordinates.len() != 8 {
+ return None;
+ }
+ let xs = [
+ coordinates[0],
+ coordinates[2],
+ coordinates[4],
+ coordinates[6],
+ ];
+ let ys = [
+ coordinates[1],
+ coordinates[3],
+ coordinates[5],
+ coordinates[7],
+ ];
+ let min_x = xs.into_iter().fold(f64::INFINITY, f64::min);
+ let max_x = xs.into_iter().fold(f64::NEG_INFINITY, f64::max);
+ let min_y = ys.into_iter().fold(f64::INFINITY, f64::min);
+ let max_y = ys.into_iter().fold(f64::NEG_INFINITY, f64::max);
+ (max_x > min_x && max_y > min_y).then_some((min_x, min_y))
+}
+
+fn chromium_executable(config: &WorkerConfig, _real_chrome: bool) -> Result<PathBuf, String> {
+ if !config.scrapling.chromium_executable.is_empty() {
+ let path = PathBuf::from(&config.scrapling.chromium_executable);
+ return path.is_file().then_some(path).ok_or_else(|| {
+ "configured browser.scrapling.chromium_executable is not a file".to_string()
+ });
+ }
+ let mut interactive = config.clone();
+ interactive.executable.clear();
+ crate::functions::doctor::detect_chromium(&interactive).ok_or_else(|| {
+ "no Chromium executable found; configure browser.scrapling.chromium_executable".to_string()
+ })
+}
+
+fn certify_chromium(path: &Path) -> Result<(), String> {
+ let version = crate::functions::doctor::chromium_version(path)
+ .ok_or_else(|| format!("could not read Chromium version from {}", path.display()))?;
+ if version
+ .split_whitespace()
+ .any(|value| CERTIFIED_CHROME_VERSIONS.contains(&value))
+ {
+ Ok(())
+ } else {
+ Err(format!(
+ "compat mode requires Chrome {}; {} reports {version}",
+ CERTIFIED_CHROME_VERSIONS.join(" or "),
+ path.display()
+ ))
+ }
+}
+
+fn python_string_hash(value: &str) -> u64 {
+ if value.is_empty() {
+ return 0;
+ }
+ let maximum = value.chars().map(u32::from).max().unwrap_or_default();
+ let mut bytes = Vec::with_capacity(value.len());
+ if maximum <= u32::from(u8::MAX) {
+ bytes.extend(value.chars().map(|character| character as u8));
+ } else if maximum <= u32::from(u16::MAX) {
+ for character in value.chars() {
+ bytes.extend_from_slice(&(character as u16).to_ne_bytes());
+ }
+ } else {
+ for character in value.chars() {
+ bytes.extend_from_slice(&u32::from(character).to_ne_bytes());
+ }
+ }
+ let mut hasher = siphasher::sip::SipHasher13::new_with_keys(0, 0);
+ hasher.write(&bytes);
+ match hasher.finish() {
+ u64::MAX => u64::MAX - 1,
+ hash => hash,
+ }
+}
+
+fn python_set_insert_clean(table: &mut [Option<(String, u64)>], key: String, hash: u64) {
+ let mask = table.len() - 1;
+ let mut perturb = hash as usize;
+ let mut index = perturb & mask;
+ loop {
+ if table[index].is_none() {
+ table[index] = Some((key, hash));
+ return;
+ }
+ if index + 9 <= mask {
+ for offset in 1..=9 {
+ if table[index + offset].is_none() {
+ table[index + offset] = Some((key, hash));
+ return;
+ }
+ }
+ }
+ perturb >>= 5;
+ index = index.wrapping_mul(5).wrapping_add(1).wrapping_add(perturb) & mask;
+ }
+}
+
+fn python_set_order(values: impl IntoIterator<Item = String>) -> Vec<String> {
+ let mut table = vec![None; 8];
+ let mut used = 0usize;
+ for key in values {
+ let hash = python_string_hash(&key);
+ let mask = table.len() - 1;
+ let mut perturb = hash as usize;
+ let mut index = perturb & mask;
+ let slot = loop {
+ let probes = if index + 9 <= mask { 9 } else { 0 };
+ let mut unused = None;
+ for offset in 0..=probes {
+ match &table[index + offset] {
+ None => {
+ unused = Some(index + offset);
+ break;
+ }
+ Some((existing, existing_hash))
+ if *existing_hash == hash && existing == &key =>
+ {
+ unused = None;
+ break;
+ }
+ Some(_) => {}
+ }
+ }
+ if let Some(slot) = unused {
+ break Some(slot);
+ }
+ if (0..=probes).any(|offset| {
+ table[index + offset]
+ .as_ref()
+ .is_some_and(|(existing, existing_hash)| {
+ *existing_hash == hash && existing == &key
+ })
+ }) {
+ break None;
+ }
+ perturb >>= 5;
+ index = index.wrapping_mul(5).wrapping_add(1).wrapping_add(perturb) & mask;
+ };
+ let Some(slot) = slot else {
+ continue;
+ };
+ table[slot] = Some((key, hash));
+ used += 1;
+ if used * 5 >= mask * 3 {
+ let minimum = used * 4;
+ let mut size = 8usize;
+ while size <= minimum {
+ size *= 2;
+ }
+ let old = std::mem::replace(&mut table, vec![None; size]);
+ for (key, hash) in old.into_iter().flatten() {
+ python_set_insert_clean(&mut table, key, hash);
+ }
+ }
+ }
+ table.into_iter().flatten().map(|(key, _)| key).collect()
+}
+
+fn scrapling_browser_args(options: &RawBrowserOptions, stealth: bool) -> Vec<String> {
+ if !stealth && options.extra_flags.is_empty() {
+ return DEFAULT_ARGS
+ .iter()
+ .map(|value| (*value).to_string())
+ .collect();
+ }
+ let mut arguments = DEFAULT_ARGS
+ .iter()
+ .map(|value| (*value).to_string())
+ .collect::<Vec<_>>();
+ if !options.extra_flags.is_empty() {
+ arguments.extend(options.extra_flags.iter().cloned());
+ } else {
+ arguments.extend(STEALTH_ARGS.iter().map(|value| (*value).to_string()));
+ if options.block_webrtc {
+ arguments.extend([
+ "--webrtc-ip-handling-policy=disable_non_proxied_udp".to_string(),
+ "--force-webrtc-ip-handling-policy".to_string(),
+ ]);
+ }
+ if !options.allow_webgl {
+ arguments.extend([
+ "--disable-webgl".to_string(),
+ "--disable-webgl-image-chromium".to_string(),
+ "--disable-webgl2".to_string(),
+ ]);
+ }
+ if options.hide_canvas {
+ arguments.push("--fingerprinting-canvas-image-data-noise".to_string());
+ }
+ }
+ python_set_order(arguments)
+}
+
+fn launch_command(
+ executable: &Path,
+ profile: &Path,
+ options: &RawBrowserOptions,
+ stealth: bool,
+ gate: Option<&EgressGate>,
+) -> Command {
+ let mut command = Command::new(executable);
+ command
+ .stdin(Stdio::null())
+ .stdout(Stdio::null())
+ .stderr(Stdio::null());
+ for argument in if stealth {
+ PATCHRIGHT_ARGS
+ } else {
+ PLAYWRIGHT_ARGS
+ } {
+ command.arg(argument);
+ }
+ if options.headless {
+ command
+ .arg("--headless")
+ .arg("--hide-scrollbars")
+ .arg("--mute-audio")
+ .arg("--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4");
+ }
+ command.arg("--no-sandbox");
+ command.args(scrapling_browser_args(options, stealth));
+ if options.dns_over_https {
+ command.arg("--dns-over-https-templates=https://cloudflare-dns.com/dns-query");
+ }
+ if let Some(proxy) = gate
+ .map(EgressGate::proxy_url)
+ .or_else(|| options.proxy.clone())
+ {
+ command
+ .arg(format!("--proxy-server={proxy}"))
+ .arg("--proxy-bypass-list=<-loopback>");
+ }
+ if gate.is_some() {
+ command
+ .arg("--disable-quic")
+ .arg("--force-webrtc-ip-handling-policy")
+ .arg("--webrtc-ip-handling-policy=disable_non_proxied_udp");
+ }
+ command
+ .arg(format!("--user-data-dir={}", profile.display()))
+ .arg(crate::scrapling::cdp::REMOTE_DEBUGGING_PIPE_ARG)
+ .arg("about:blank");
+ command
+}
+
+struct TempProfile {
+ path: PathBuf,
+}
+
+impl TempProfile {
+ fn new() -> Result<Self, String> {
+ let path = std::env::temp_dir().join(format!(
+ "browser-scrapling-{}",
+ uuid::Uuid::new_v4().simple()
+ ));
+ std::fs::create_dir(&path).map_err(|e| format!("creating browser profile: {e}"))?;
+ Ok(Self { path })
+ }
+}
+
+impl Drop for TempProfile {
+ fn drop(&mut self) {
+ let _ = std::fs::remove_dir_all(&self.path);
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use tokio::io::{AsyncReadExt, AsyncWriteExt};
+ use tokio::net::TcpListener;
+
+ #[test]
+ fn validates_defaults_and_safe_refusals() {
+ let options = RawBrowserOptions::from_payload(&json!({})).unwrap();
+ assert_eq!(options.retries, 3);
+ assert_eq!(options.timeout, Duration::from_secs(30));
+ assert_eq!(referer(&options), GOOGLE_REFERER);
+ let options = RawBrowserOptions::from_payload(&json!({
+ "proxy": "http://proxy",
+ "cdp_url": "ws://remote",
+ "extra_flags": ["--no-proxy-server"]
+ }))
+ .unwrap();
+ let error = options.validate_policy(SecurityMode::Safe).unwrap_err();
+ assert!(error.contains("proxy, cdp_url, extra_flags"));
+ assert!(options.validate_policy(SecurityMode::Compat).is_ok());
+ assert_eq!(ad_domains().len(), 3526);
+ assert!(ad_domains().contains("doubleclick.net"));
+ assert!(domain_matches("a.b.doubleclick.net", "doubleclick.net"));
+ assert!(!domain_matches("notdoubleclick.net", "doubleclick.net"));
+ assert_eq!(
+ BLOCKED_RESOURCE_TYPES,
+ [
+ "Font",
+ "Image",
+ "Media",
+ "TextTrack",
+ "WebSocket",
+ "Stylesheet"
+ ]
+ );
+ assert_eq!(
+ cloudflare_challenge("<script>cType: 'managed'</script>"),
+ Some("managed")
+ );
+ assert_eq!(
+ cloudflare_challenge(
+ "<script src='https://challenges.cloudflare.com/turnstile/v0/api.js'>"
+ ),
+ Some("embedded")
+ );
+ assert_eq!(
+ cloudflare_challenge("<p>https://challenges.cloudflare.com/turnstile/v0/api.js</p>"),
+ None
+ );
+ let tree = json!({
+ "frame": {"id": "root", "url": "https://example.test"},
+ "childFrames": [{
+ "frame": {
+ "id": "challenge",
+ "url": "https://challenges.cloudflare.com/cdn-cgi/challenge-platform/h/g"
+ }
+ }]
+ });
+ assert_eq!(challenge_frame_id(&tree), Some("challenge"));
+ assert_eq!(
+ box_origin(&json!([10, 20, 110, 20, 110, 70, 10, 70])),
+ Some((10.0, 20.0))
+ );
+ assert_eq!(box_origin(&json!([10, 20, 10, 20, 10, 20, 10, 20])), None);
+ }
+
+ #[test]
+ fn browser_validation_matches_frozen_msgspec_errors() {
+ for (payload, expected) in [
+ (
+ json!({"retries": 0}),
+ "Invalid argument type: Expected `int` >= 1 - at `$.retries`",
+ ),
+ (
+ json!({"retries": 11}),
+ "Invalid argument type: Expected `int` <= 10 - at `$.retries`",
+ ),
+ (
+ json!({"max_pages": 0}),
+ "Invalid argument type: Expected `int` >= 1 - at `$.max_pages`",
+ ),
+ (
+ json!({"timeout": -1}),
+ "Invalid argument type: Expected `float` >= 0.0 - at `$.timeout`",
+ ),
+ (
+ json!({"wait_selector_state": "bogus"}),
+ "Invalid argument type: Invalid enum value 'bogus' - at `$.wait_selector_state`",
+ ),
+ (
+ json!({"cookies": {}}),
+ "Invalid argument type: Expected `array | null`, got `object` - at `$.cookies`",
+ ),
+ (
+ json!({"extra_flags": [1]}),
+ "Invalid argument type: Expected `str`, got `int` - at `$.extra_flags[0]`",
+ ),
+ (
+ json!({"cookies": [{"name": 1}]}),
+ "Invalid argument type: Expected `str`, got `int` - at `$.cookies[0].name`",
+ ),
+ (
+ json!({"extra_headers": {"x-test": 1}}),
+ "Invalid argument type: Expected `str`, got `int` - at `$.extra_headers[...]`",
+ ),
+ (
+ json!({"proxy": {"username": "user"}}),
+ "Invalid argument type: Invalid proxy dictionary: Object missing required field `server`",
+ ),
+ (
+ json!({"cdp_url": "http://example.test"}),
+ "Invalid argument type: CDP URL must use 'ws://' or 'wss://' scheme",
+ ),
+ ] {
+ assert_eq!(RawBrowserOptions::from_payload(&payload).unwrap_err(), expected);
+ }
+ let options = RawBrowserOptions::from_payload(&json!({
+ "proxy": "http://user:pass@proxy.example:8080/path",
+ "cookies": [{"name": "a", "value": "b", "unknown": true}]
+ }))
+ .unwrap();
+ assert_eq!(options.proxy.as_deref(), Some("http://proxy.example:8080"));
+ assert_eq!(
+ options.proxy_auth,
+ Some(("user".to_string(), "pass".to_string()))
+ );
+ assert_eq!(options.cookies, vec![json!({"name": "a", "value": "b"})]);
+ }
+
+ #[test]
+ fn screenshot_tiles_match_pillow_dimensions_pixels_and_cap() {
+ let source = image::DynamicImage::ImageRgba8(image::RgbaImage::from_pixel(
+ 800,
+ 1600,
+ image::Rgba([7, 11, 13, 255]),
+ ));
+ let mut png = Vec::new();
+ source
+ .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
+ .unwrap();
+ let (tiles, width, height, truncated) = tile_screenshot(&png, "png").unwrap();
+ assert_eq!(
+ (width, height, tiles.len(), truncated),
+ (800, 1600, 2, false)
+ );
+ assert_eq!(
+ image::load_from_memory(&tiles[0])
+ .unwrap()
+ .get_pixel(0, 0)
+ .0,
+ [7, 11, 13, 255]
+ );
+
+ let tall = image::DynamicImage::new_rgb8(100, MAX_TILE_HEIGHT * 7);
+ let mut png = Vec::new();
+ tall.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
+ .unwrap();
+ let (tiles, _, _, truncated) = tile_screenshot(&png, "png").unwrap();
+ assert_eq!(tiles.len(), 6);
+ assert!(truncated);
+ assert_eq!(python_round(2.5), 2);
+ assert_eq!(python_round(3.5), 4);
+ }
+
+ #[test]
+ fn launch_args_force_safe_proxy_and_webrtc() {
+ let options = RawBrowserOptions::from_payload(&json!({})).unwrap();
+ let profile = Path::new("/tmp/profile");
+ let gate = tokio::runtime::Runtime::new()
+ .unwrap()
+ .block_on(EgressGate::start(SsrfPolicy {
+ allow_loopback: true,
+ }))
+ .unwrap();
+ let command = launch_command(
+ Path::new("/bin/true"),
+ profile,
+ &options,
+ false,
+ Some(&gate),
+ );
+ let args = command
+ .get_args()
+ .map(|value| value.to_string_lossy().to_string())
+ .collect::<Vec<_>>();
+ assert!(args
+ .iter()
+ .any(|value| value.starts_with("--proxy-server=http://127.0.0.1:")));
+ assert!(args.contains(&"--disable-quic".to_string()));
+ assert!(args.contains(&"--webrtc-ip-handling-policy=disable_non_proxied_udp".to_string()));
+ }
+
+ #[test]
+ fn dynamic_launch_order_matches_the_frozen_worker() {
+ let options = RawBrowserOptions::from_payload(&json!({})).unwrap();
+ let command = launch_command(
+ Path::new("/bin/true"),
+ Path::new("/tmp/profile"),
+ &options,
+ false,
+ None,
+ );
+ let actual = command
+ .get_args()
+ .map(|value| value.to_string_lossy().to_string())
+ .collect::<Vec<_>>();
+ let expected = PLAYWRIGHT_ARGS
+ .iter()
+ .copied()
+ .chain([
+ "--headless",
+ "--hide-scrollbars",
+ "--mute-audio",
+ "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4",
+ "--no-sandbox",
+ ])
+ .chain(DEFAULT_ARGS.iter().copied())
+ .chain([
+ "--user-data-dir=/tmp/profile",
+ "--remote-debugging-pipe",
+ "about:blank",
+ ])
+ .map(str::to_string)
+ .collect::<Vec<_>>();
+ assert_eq!(actual, expected);
+ }
+
+ #[test]
+ fn cpython_set_order_matches_frozen_hash_seed_zero() {
+ assert_eq!(python_string_hash("a") as i64, 4_644_417_185_603_328_019);
+ assert_eq!(python_string_hash("abc") as i64, -4_594_863_902_769_663_758);
+ assert_eq!(
+ python_set_order(
+ DEFAULT_ARGS
+ .iter()
+ .map(|value| (*value).to_string())
+ .chain(["--z-last", "--a-first", "--no-pings"].map(str::to_string))
+ ),
+ [
+ "--homepage=about:blank",
+ "--z-last",
+ "--a-first",
+ "--disable-breakpad",
+ "--disable-infobars",
+ "--no-default-browser-check",
+ "--disable-hang-monitor",
+ "--no-service-autorun",
+ "--password-store=basic",
+ "--no-pings",
+ "--disable-session-crashed-bubble",
+ "--disable-search-engine-choice-screen",
+ "--no-first-run",
+ ]
+ .map(str::to_string)
+ );
+ }
+
+ #[test]
+ fn stealth_launch_order_matches_the_frozen_worker() {
+ let options = RawBrowserOptions::from_payload(&json!({})).unwrap();
+ let command = launch_command(
+ Path::new("/bin/true"),
+ Path::new("/tmp/profile"),
+ &options,
+ true,
+ None,
+ );
+ let actual = command
+ .get_args()
+ .map(|value| value.to_string_lossy().to_string())
+ .collect::<Vec<_>>();
+ let expected = PATCHRIGHT_ARGS
+ .iter()
+ .copied()
+ .chain([
+ "--headless",
+ "--hide-scrollbars",
+ "--mute-audio",
+ "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4",
+ "--no-sandbox",
+ ])
+ .chain(STEALTH_DEFAULT_ARGS.iter().copied())
+ .chain([
+ "--user-data-dir=/tmp/profile",
+ "--remote-debugging-pipe",
+ "about:blank",
+ ])
+ .map(str::to_string)
+ .collect::<Vec<_>>();
+ assert_eq!(actual, expected);
+ assert_eq!(
+ scrapling_browser_args(&options, true),
+ STEALTH_DEFAULT_ARGS
+ .iter()
+ .map(|value| (*value).to_string())
+ .collect::<Vec<_>>()
+ );
+ }
+
+ #[test]
+ fn explicit_stealth_flags_preserve_the_frozen_override_quirk() {
+ let options = RawBrowserOptions::from_payload(&json!({
+ "extra_flags": ["--z-last", "--a-first", "--no-pings"],
+ "block_webrtc": true,
+ "allow_webgl": false,
+ "hide_canvas": true
+ }))
+ .unwrap();
+ assert_eq!(
+ scrapling_browser_args(&options, true),
+ [
+ "--homepage=about:blank",
+ "--z-last",
+ "--a-first",
+ "--disable-breakpad",
+ "--disable-infobars",
+ "--no-default-browser-check",
+ "--disable-hang-monitor",
+ "--no-service-autorun",
+ "--password-store=basic",
+ "--no-pings",
+ "--disable-session-crashed-bubble",
+ "--disable-search-engine-choice-screen",
+ "--no-first-run",
+ ]
+ .map(str::to_string)
+ );
+ }
+
+ #[tokio::test]
+ async fn safe_browser_fetches_loopback_through_the_gate() {
+ let executable = std::env::var_os("SCRAPLING_CHROMIUM_EXECUTABLE")
+ .map(PathBuf::from)
+ .or_else(|| crate::functions::doctor::detect_chromium(&WorkerConfig::default()));
+ let Some(executable) = executable.filter(|path| certify_chromium(path).is_ok()) else {
+ return;
+ };
+ let origin = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
+ .await
+ .unwrap();
+ let address = origin.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ for _ in 0..2 {
+ let (mut socket, _) = origin.accept().await.unwrap();
+ let mut request = [0; 4096];
+ let _ = socket.read(&mut request).await.unwrap();
+ socket
+ .write_all(
+ b"HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: 48\r\nConnection: close\r\n\r\n<html><body><h1>raw cdp works</h1></body></html>",
+ )
+ .await
+ .unwrap();
+ }
+ });
+ let mut config = WorkerConfig::default();
+ config.scrapling.chromium_executable = executable.display().to_string();
+ config.scrapling.allow_loopback = true;
+ let options =
+ RawBrowserOptions::from_payload(&json!({"retries": 1, "timeout": 5000})).unwrap();
+ let page = tokio::time::timeout(Duration::from_secs(15), async {
+ let browser = RawBrowser::start(&config, &options, false, false).await?;
+ browser
+ .fetch(&format!("http://{address}/"), &options, false)
+ .await
+ })
+ .await
+ .expect("raw browser fetch timed out")
+ .unwrap();
+ assert_eq!(page.status, Some(200));
+ assert!(page.html.contains("raw cdp works"), "{}", page.html);
+ server.abort();
+ }
+}
diff --git a/browser/src/scrapling/schemas.rs b/browser/src/scrapling/schemas.rs
new file mode 100644
index 000000000..b2daaaf1a
--- /dev/null
+++ b/browser/src/scrapling/schemas.rs
@@ -0,0 +1,726 @@
+//! The 19 scrapling::* request/response schemas, mirrored byte-for-byte from
+//! scrapling/src/schemas.py (goldens are generated FROM that file — this
+//! module must match it, key order included; serde_json preserve_order).
+
+use serde_json::{json, Value};
+
+pub struct FunctionSpec {
+ pub function_id: &'static str,
+ pub description: &'static str,
+ pub request: Value,
+ pub response: Value,
+}
+
+fn selector_item() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"},
+ "css": {"type": "string"},
+ "xpath": {"type": "string"},
+ "regex": {"type": "string"},
+ "attr": {"type": "string", "description": "extract this attribute instead of text"},
+ "html": {"type": "boolean", "description": "extract inner HTML instead of text"},
+ "all": {"type": "boolean", "description": "return every match as a list"},
+ },
+ "required": ["name"],
+ })
+}
+
+fn selectors() -> Value {
+ json!({"type": "array", "items": selector_item()})
+}
+
+// css/xpath/regex results: first-match string, all-matches array, or null.
+fn result_schema() -> Value {
+ json!({"type": ["array", "string", "null"], "items": {"type": ["string", "null"]}})
+}
+
+fn adaptive_props() -> Vec<(&'static str, Value)> {
+ vec![
+ (
+ "adaptive",
+ json!({"type": "boolean", "description": "relocate elements after a site change via saved identities"}),
+ ),
+ (
+ "auto_save",
+ json!({"type": "boolean", "description": "save matched identities (defaults on when adaptive)"}),
+ ),
+ (
+ "adaptive_domain",
+ json!({"type": "string", "description": "page URL/domain that keys saved identities"}),
+ ),
+ ]
+}
+
+fn with_adaptive(mut base: serde_json::Map<String, Value>) -> Value {
+ for (k, v) in adaptive_props() {
+ base.insert(k.to_string(), v);
+ }
+ Value::Object(base)
+}
+
+fn extract_request() -> Value {
+ let props = json!({
+ "html": {"type": "string"},
+ "selectors": selectors(),
+ });
+ json!({
+ "type": "object",
+ "properties": with_adaptive(props.as_object().unwrap().clone()),
+ "required": ["html", "selectors"],
+ })
+}
+
+fn query_request() -> Value {
+ let props = json!({
+ "html": {"type": "string"},
+ "query": {"type": "string"},
+ "first": {"type": "boolean"},
+ "attr": {"type": "string"},
+ "identifier": {"type": "string", "description": "stable key for the saved element"},
+ });
+ json!({
+ "type": "object",
+ "properties": with_adaptive(props.as_object().unwrap().clone()),
+ "required": ["html", "query"],
+ })
+}
+
+fn regex_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "html": {"type": "string"},
+ "pattern": {"type": "string"},
+ "first": {"type": "boolean"},
+ },
+ "required": ["html", "pattern"],
+ })
+}
+
+fn find_similar_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "html": {"type": "string"},
+ "anchor": {"type": "string", "description": "CSS selector to one example element"},
+ "similarity_threshold": {"type": "number"},
+ "match_text": {"type": "boolean"},
+ "selectors": selectors(),
+ },
+ "required": ["html", "anchor"],
+ })
+}
+
+// One matched element: text, inner HTML, attributes, and the auto-generated
+// CSS/XPath selectors that locate it.
+fn element() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "tag": {"type": "string"},
+ "text": {"type": "string"},
+ "html": {"type": "string"},
+ "attrs": {"type": "object"},
+ "css": {"type": "string"},
+ "xpath": {"type": "string"},
+ },
+ })
+}
+
+fn elements_response() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "count": {"type": "integer"},
+ "items": {"type": "array", "items": element()},
+ },
+ })
+}
+
+fn find_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "html": {"type": "string"},
+ "tag": {
+ "type": ["string", "array"],
+ "items": {"type": "string"},
+ "description": "tag name or list of tag names",
+ },
+ "attrs": {"type": "object", "description": "attribute filters, e.g. {\"class\": \"card\"}"},
+ "text_regex": {"type": "string", "description": "keep only elements whose text matches this regex"},
+ "first": {"type": "boolean"},
+ "limit": {"type": "integer"},
+ },
+ "required": ["html"],
+ })
+}
+
+fn find_by_text_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "html": {"type": "string"},
+ "text": {"type": "string"},
+ "partial": {"type": "boolean", "description": "match elements that contain the text"},
+ "case_sensitive": {"type": "boolean"},
+ "clean_match": {"type": "boolean", "description": "ignore surrounding/collapsing whitespace"},
+ "first": {"type": "boolean"},
+ "limit": {"type": "integer"},
+ },
+ "required": ["html", "text"],
+ })
+}
+
+fn find_by_regex_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "html": {"type": "string"},
+ "pattern": {"type": "string"},
+ "case_sensitive": {"type": "boolean"},
+ "clean_match": {"type": "boolean"},
+ "first": {"type": "boolean"},
+ "limit": {"type": "integer"},
+ },
+ "required": ["html", "pattern"],
+ })
+}
+
+fn describe_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "html": {"type": "string"},
+ "query": {"type": "string"},
+ "kind": {"type": "string", "enum": ["css", "xpath"]},
+ },
+ "required": ["html", "query"],
+ })
+}
+
+// element properties + full_css/full_xpath/classes/parent_tag/children/siblings.
+fn describe_response() -> Value {
+ let mut props = element()["properties"].as_object().unwrap().clone();
+ props.insert("full_css".to_string(), json!({"type": "string"}));
+ props.insert("full_xpath".to_string(), json!({"type": "string"}));
+ props.insert(
+ "classes".to_string(),
+ json!({"type": "array", "items": {"type": "string"}}),
+ );
+ props.insert(
+ "parent_tag".to_string(),
+ json!({"type": ["string", "null"]}),
+ );
+ props.insert("children".to_string(), json!({"type": "integer"}));
+ props.insert("siblings".to_string(), json!({"type": "integer"}));
+ json!({
+ "type": "object",
+ "properties": {
+ "found": {"type": "boolean"},
+ "element": {
+ "type": "object",
+ "properties": Value::Object(props),
+ },
+ },
+ })
+}
+
+fn markdown_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "html": {"type": "string"},
+ "format": {"type": "string", "enum": ["markdown", "text", "html"]},
+ "css_selector": {"type": "string", "description": "convert only the subtree matching this CSS selector"},
+ "main_content_only": {"type": "boolean", "description": "strip nav/scripts/hidden nodes first"},
+ },
+ "required": ["html"],
+ })
+}
+
+// --- shared fragments for fetch/stealthy-fetch/dynamic-fetch/session-fetch/crawl
+// (mirrors schemas.py's _BULK_TARGET/_BROWSER_WAIT/_CONTENT_OUT/_COMMON_OUT) ---
+
+fn obj(props: Vec<(&'static str, Value)>) -> Value {
+ Value::Object(props.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+}
+
+fn bulk_target_props() -> Vec<(&'static str, Value)> {
+ vec![
+ ("url", json!({"type": "string"})),
+ (
+ "urls",
+ json!({"type": "array", "items": {"type": "string"}}),
+ ),
+ ]
+}
+
+fn browser_wait_props() -> Vec<(&'static str, Value)> {
+ vec![
+ ("headless", json!({"type": "boolean"})),
+ ("network_idle", json!({"type": "boolean"})),
+ ("load_dom", json!({"type": "boolean"})),
+ (
+ "timeout",
+ json!({"type": "number", "description": "milliseconds (browser fetcher)"}),
+ ),
+ (
+ "wait",
+ json!({"type": "number", "description": "extra ms to wait after load"}),
+ ),
+ ("wait_selector", json!({"type": "string"})),
+ (
+ "wait_selector_state",
+ json!({"type": "string", "enum": ["attached", "detached", "visible", "hidden"]}),
+ ),
+ ("disable_resources", json!({"type": "boolean"})),
+ ("block_ads", json!({"type": "boolean"})),
+ (
+ "blocked_domains",
+ json!({"type": "array", "items": {"type": "string"}}),
+ ),
+ ("proxy", json!({"type": "string"})),
+ ("useragent", json!({"type": "string"})),
+ ("cookies", json!({"type": "object"})),
+ ("extra_headers", json!({"type": "object"})),
+ ("google_search", json!({"type": "boolean"})),
+ ("capture_xhr", json!({"type": "string"})),
+ ("locale", json!({"type": "string"})),
+ ("timezone_id", json!({"type": "string"})),
+ ("dns_over_https", json!({"type": "boolean"})),
+ (
+ "extra_flags",
+ json!({"type": "array", "items": {"type": "string"}}),
+ ),
+ ("max_pages", json!({"type": "integer"})),
+ ("retries", json!({"type": "integer"})),
+ ("retry_delay", json!({"type": "number"})),
+ ]
+}
+
+// Post-fetch content rendering (reuses Scrapling's Convertor): compact the
+// page to markdown/text instead of dumping raw HTML.
+fn content_out_props() -> Vec<(&'static str, Value)> {
+ vec![
+ (
+ "format",
+ json!({"type": "string", "enum": ["markdown", "text"], "description": "render page body to this format"}),
+ ),
+ (
+ "main_content_only",
+ json!({"type": "boolean", "description": "strip nav/scripts/hidden before rendering"}),
+ ),
+ (
+ "css_selector",
+ json!({"type": "string", "description": "scope the render to this CSS subtree (e.g. a page's content div)"}),
+ ),
+ ]
+}
+
+// selectors/include_html + content_out: shared tail of every fetch-family request.
+fn common_out_props() -> Vec<(&'static str, Value)> {
+ let mut props = vec![
+ ("selectors", selectors()),
+ ("include_html", json!({"type": "boolean"})),
+ ];
+ props.extend(content_out_props());
+ props
+}
+
+// fetch/stealthy-fetch/dynamic-fetch/session-fetch: identical page/extraction output.
+fn fetch_response() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "status": {"type": ["integer", "null"]},
+ "url": {"type": "string"},
+ "headers": {"type": "object"},
+ "cookies": {"type": "object"},
+ "encoding": {"type": ["string", "null"]},
+ "extracted": {"type": "object"},
+ "html": {"type": "string"},
+ "content": {"type": "string", "description": "markdown/text render when `format` requested"},
+ "format": {"type": "string"},
+ "captured_xhr": {"type": "array", "items": {"type": "object"}},
+ "results": {"type": "array", "items": {"type": "object"}},
+ "error": {"type": "string"},
+ },
+ })
+}
+
+fn fetch_request() -> Value {
+ let mut props = bulk_target_props();
+ props.extend([
+ ("method", json!({"type": "string", "enum": ["get", "post", "put", "delete"]})),
+ ("headers", json!({"type": "object"})),
+ ("params", json!({"type": "object"})),
+ ("data", json!({"type": "object"})),
+ ("json", json!({"type": "object"})),
+ ("cookies", json!({"type": "object"})),
+ ("proxy", json!({"type": "string"})),
+ (
+ "proxies",
+ json!({"type": "object", "description": "per-scheme proxies, e.g. {\"https\": \"http://...\"}"}),
+ ),
+ (
+ "proxy_auth",
+ json!({"type": "array", "items": {"type": "string"}, "description": "[user, password]"}),
+ ),
+ ("impersonate", json!({"type": "string", "description": "TLS/UA fingerprint, e.g. 'chrome'"})),
+ ("timeout", json!({"type": "number", "description": "seconds (HTTP fetcher)"})),
+ ("follow_redirects", json!({"type": "boolean"})),
+ ("max_redirects", json!({"type": "integer"})),
+ ("stealthy_headers", json!({"type": "boolean"})),
+ ("http3", json!({"type": "boolean"})),
+ ("verify", json!({"type": "boolean"})),
+ ("retries", json!({"type": "integer"})),
+ ("retry_delay", json!({"type": "number"})),
+ ]);
+ props.extend(common_out_props());
+ json!({"type": "object", "properties": obj(props)})
+}
+
+fn stealthy_fetch_request() -> Value {
+ let mut props = bulk_target_props();
+ props.extend(browser_wait_props());
+ props.extend([
+ ("solve_cloudflare", json!({"type": "boolean"})),
+ ("block_webrtc", json!({"type": "boolean"})),
+ ("hide_canvas", json!({"type": "boolean"})),
+ ("allow_webgl", json!({"type": "boolean"})),
+ ]);
+ props.extend(common_out_props());
+ json!({"type": "object", "properties": obj(props)})
+}
+
+fn dynamic_fetch_request() -> Value {
+ let mut props = bulk_target_props();
+ props.extend(browser_wait_props());
+ props.extend([
+ ("real_chrome", json!({"type": "boolean"})),
+ ("cdp_url", json!({"type": "string"})),
+ ]);
+ props.extend(common_out_props());
+ json!({"type": "object", "properties": obj(props)})
+}
+
+fn screenshot_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "url": {"type": "string"},
+ "fetcher": {"type": "string", "enum": ["dynamic", "stealthy"]},
+ "full_page": {"type": "boolean"},
+ "format": {"type": "string", "enum": ["png", "jpeg"]},
+ "headless": {"type": "boolean"},
+ "network_idle": {"type": "boolean"},
+ "timeout": {"type": "number"},
+ "wait_selector": {"type": "string"},
+ "proxy": {"type": "string"},
+ },
+ "required": ["url"],
+ })
+}
+
+// Harness content blocks: image tiles + a trailing text caption. The harness
+// forwards `content` verbatim so the model sees images, never base64 text.
+fn screenshot_response() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "content": {
+ "type": "array",
+ "description": "image blocks (one per tile, width<=1024/height<=1536) + a text caption",
+ "items": {
+ "type": "object",
+ "properties": {
+ "type": {"type": "string", "enum": ["image", "text"]},
+ "mime": {"type": "string"},
+ "data": {"type": "string", "description": "base64 image bytes (image blocks)"},
+ "text": {"type": "string"},
+ },
+ "required": ["type"],
+ },
+ },
+ "mime": {"type": "string"},
+ "url": {"type": "string"},
+ },
+ })
+}
+
+fn session_open_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "type": {"type": "string", "enum": ["http", "dynamic", "stealthy"], "description": "session engine"},
+ "impersonate": {"type": "string"},
+ "headers": {"type": "object"},
+ "proxy": {"type": "string"},
+ "proxies": {"type": "object"},
+ "headless": {"type": "boolean"},
+ "useragent": {"type": "string"},
+ "solve_cloudflare": {"type": "boolean"},
+ "real_chrome": {"type": "boolean"},
+ "timeout": {"type": "number"},
+ "capture_xhr": {"type": "string", "description": "regex; capture matching XHRs (browser sessions)"},
+ },
+ })
+}
+
+fn session_open_response() -> Value {
+ json!({"type": "object", "properties": {"session_id": {"type": "string"}, "type": {"type": "string"}}})
+}
+
+fn session_fetch_request() -> Value {
+ let mut props = vec![
+ ("session_id", json!({"type": "string"})),
+ ("url", json!({"type": "string"})),
+ (
+ "method",
+ json!({"type": "string", "enum": ["get", "post", "put", "delete"]}),
+ ),
+ ("headers", json!({"type": "object"})),
+ ("params", json!({"type": "object"})),
+ ("data", json!({"type": "object"})),
+ ("json", json!({"type": "object"})),
+ ("wait_selector", json!({"type": "string"})),
+ ];
+ props.extend(common_out_props());
+ json!({
+ "type": "object",
+ "properties": obj(props),
+ "required": ["session_id", "url"],
+ })
+}
+
+fn session_close_request() -> Value {
+ json!({"type": "object", "properties": {"session_id": {"type": "string"}}, "required": ["session_id"]})
+}
+
+fn session_close_response() -> Value {
+ json!({"type": "object", "properties": {"closed": {"type": "boolean"}}})
+}
+
+fn session_list_request() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "type": {"type": "string", "enum": ["http", "dynamic", "stealthy"], "description": "filter by type"},
+ },
+ })
+}
+
+fn session_list_response() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "sessions": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "session_id": {"type": "string"},
+ "type": {"type": "string"},
+ "created_at": {"type": "number"},
+ "last_used": {"type": "number"},
+ "idle_s": {"type": "number"},
+ },
+ },
+ },
+ },
+ })
+}
+
+fn crawl_request() -> Value {
+ let mut props = vec![
+ (
+ "start_urls",
+ json!({"type": "array", "items": {"type": "string"}}),
+ ),
+ (
+ "url",
+ json!({"type": "string", "description": "single start URL (alternative to start_urls)"}),
+ ),
+ (
+ "fetcher",
+ json!({"type": "string", "enum": ["http", "stealthy", "dynamic"]}),
+ ),
+ ("selectors", selectors()),
+ (
+ "allowed_domains",
+ json!({"type": "array", "items": {"type": "string"}, "description": "only follow links on these hosts"}),
+ ),
+ (
+ "same_domain",
+ json!({"type": "boolean", "description": "follow only same-host links (default true)"}),
+ ),
+ ("max_pages", json!({"type": "integer"})),
+ ("max_depth", json!({"type": "integer"})),
+ ("concurrency", json!({"type": "integer"})),
+ (
+ "download_delay",
+ json!({"type": "number", "description": "seconds to wait between crawl rounds"}),
+ ),
+ ];
+ props.extend(content_out_props());
+ props.extend([
+ ("include_html", json!({"type": "boolean"})),
+ ("impersonate", json!({"type": "string"})),
+ (
+ "stream_name",
+ json!({"type": "string", "description": "stream to emit items on (default browser::crawl)"}),
+ ),
+ ]);
+ json!({"type": "object", "properties": obj(props)})
+}
+
+fn crawl_response() -> Value {
+ json!({
+ "type": "object",
+ "properties": {
+ "stats": {
+ "type": "object",
+ "properties": {
+ "crawled": {"type": "integer"},
+ "items": {"type": "integer"},
+ "errors": {"type": "integer"},
+ "stopped": {"type": "string"},
+ },
+ },
+ "items": {"type": "array", "items": {"type": "object"}, "description": "a small sample of streamed items"},
+ "stream": {
+ "type": "object",
+ "properties": {"name": {"type": "string"}, "group_id": {"type": "string"}},
+ "description": "read the full item stream via stream::on with this name + group_id",
+ },
+ },
+ })
+}
+
+pub fn catalog() -> Vec<FunctionSpec> {
+ vec![
+ FunctionSpec {
+ function_id: "browser::fetch",
+ description: "Fast HTTP fetch, TLS impersonation: get/post/put/delete, inline extraction, bulk `urls`.",
+ request: fetch_request(),
+ response: fetch_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::stealthy-fetch",
+ description: "Camoufox stealth browser: solves Cloudflare, hardens WebRTC/canvas; extraction + bulk.",
+ request: stealthy_fetch_request(),
+ response: fetch_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::dynamic-fetch",
+ description: "Playwright/Chromium fetch: JS render, waits, XHR capture, CDP; extraction + bulk.",
+ request: dynamic_fetch_request(),
+ response: fetch_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::screenshot-url",
+ description: "Capture a page screenshot as image content blocks via a browser fetcher (dynamic or stealthy).",
+ request: screenshot_request(),
+ response: screenshot_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::extract",
+ description: "Parse HTML with a selector list (css/xpath/regex, text/attr/html, all-or-first).",
+ request: extract_request(),
+ response: json!({"type": "object", "properties": {"extracted": {"type": "object"}}}),
+ },
+ FunctionSpec {
+ function_id: "browser::css",
+ description: "One CSS query over HTML; first-or-all; `attr` pulls an attribute else text.",
+ request: query_request(),
+ response: json!({"type": "object", "properties": {"result": result_schema()}}),
+ },
+ FunctionSpec {
+ function_id: "browser::xpath",
+ description: "One XPath query over HTML; first-or-all; `attr` pulls an attribute else text.",
+ request: query_request(),
+ response: json!({"type": "object", "properties": {"result": result_schema()}}),
+ },
+ FunctionSpec {
+ function_id: "browser::regex",
+ description: "Run a regex over the visible text of provided HTML; `first` returns the first match, else all.",
+ request: regex_request(),
+ response: json!({"type": "object", "properties": {"result": result_schema()}}),
+ },
+ FunctionSpec {
+ function_id: "browser::find-similar",
+ description: "Structural auto-match: given one example element, return it plus similar elements.",
+ request: find_similar_request(),
+ response: json!({
+ "type": "object",
+ "properties": {
+ "count": {"type": "integer"},
+ "items": {"type": "array", "items": {"type": "object"}},
+ },
+ }),
+ },
+ FunctionSpec {
+ function_id: "browser::find",
+ description: "Find elements by tag/attribute filters (+ optional text regex); BeautifulSoup-style.",
+ request: find_request(),
+ response: elements_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::find-by-text",
+ description: "Find elements whose visible text matches a string (exact or `partial`).",
+ request: find_by_text_request(),
+ response: elements_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::find-by-regex",
+ description: "Find elements whose visible text matches a regex pattern.",
+ request: find_by_regex_request(),
+ response: elements_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::describe",
+ description: "Describe the first css/xpath match: attrs, generated selectors, class list, DOM context.",
+ request: describe_request(),
+ response: describe_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::to-markdown",
+ description: "Convert HTML to compact Markdown (or text/html); optional CSS scope + main-content clean.",
+ request: markdown_request(),
+ response: json!({"type": "object", "properties": {"format": {"type": "string"}, "content": {"type": "string"}}}),
+ },
+ FunctionSpec {
+ function_id: "browser::session-open",
+ description: "Open a persistent HTTP/browser session; returns a session_id that reuses cookies + state.",
+ request: session_open_request(),
+ response: session_open_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::session-fetch",
+ description: "Fetch a URL on an open session (reuses its cookies/browser); same page/extraction output.",
+ request: session_fetch_request(),
+ response: fetch_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::session-close",
+ description: "Close a session and free its browser/connection.",
+ request: session_close_request(),
+ response: session_close_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::session-list",
+ description: "List open sessions with their type and idle time.",
+ request: session_list_request(),
+ response: session_list_response(),
+ },
+ FunctionSpec {
+ function_id: "browser::crawl",
+ description: "BFS-crawl from start_urls (follow same-domain links), extract per page, stream items.",
+ request: crawl_request(),
+ response: crawl_response(),
+ },
+ ]
+}
diff --git a/browser/src/scrapling/selgen.rs b/browser/src/scrapling/selgen.rs
new file mode 100644
index 000000000..1b68618c4
--- /dev/null
+++ b/browser/src/scrapling/selgen.rs
@@ -0,0 +1,149 @@
+//! scrapling's generated-selector algorithm (core/mixins.py), ported verbatim.
+
+use crate::scrapling::dom::{self, ElementRef};
+
+fn general_selection(el: ElementRef, css: bool, full_path: bool) -> String {
+ let mut parts: Vec<String> = Vec::new();
+ let mut target = el;
+ while let Some(parent) = dom::parent_element(target) {
+ if let Some(id) = target.attr("id").filter(|s| !s.is_empty()) {
+ if css {
+ parts.push(format!("#{id}"));
+ } else if full_path {
+ parts.push(format!("*[@id='{id}']"));
+ } else {
+ parts.push(format!("[@id='{id}']"));
+ }
+ if !full_path {
+ parts.reverse();
+ return if css {
+ parts.join(" > ")
+ } else {
+ format!("//*{}", parts.join("/"))
+ };
+ }
+ } else {
+ let tag = target.name();
+ let mut index = 0usize;
+ for sibling in dom::element_children(parent) {
+ if sibling.name() == tag {
+ index += 1;
+ }
+ if sibling.id() == target.id() {
+ break;
+ }
+ }
+ let mut part = tag.to_string();
+ if index > 1 {
+ if css {
+ part.push_str(&format!(":nth-of-type({index})"));
+ } else {
+ part.push_str(&format!("[{index}]"));
+ }
+ }
+ parts.push(part);
+ }
+ target = parent;
+ if target.name() == "html" {
+ break;
+ }
+ }
+ parts.reverse();
+ if css {
+ parts.join(" > ")
+ } else {
+ format!("//{}", parts.join("/"))
+ }
+}
+
+pub fn css_selector(el: ElementRef) -> String {
+ general_selection(el, true, false)
+}
+pub fn full_css_selector(el: ElementRef) -> String {
+ general_selection(el, true, true)
+}
+pub fn xpath_selector(el: ElementRef) -> String {
+ general_selection(el, false, false)
+}
+pub fn full_xpath_selector(el: ElementRef) -> String {
+ general_selection(el, false, true)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn matches<'a>(d: &'a dom::Doc, selector: &str) -> Vec<ElementRef<'a>> {
+ crate::scrapling::query::css_query(d, None, selector)
+ .unwrap()
+ .into_iter()
+ .filter_map(|result| match result {
+ crate::scrapling::query::QueryResult::Element(element) => Some(element),
+ _ => None,
+ })
+ .collect()
+ }
+
+ fn first<'a>(d: &'a dom::Doc, selector: &str) -> ElementRef<'a> {
+ matches(d, selector)[0]
+ }
+
+ const HTML: &str = r#"<html><body><h1 class="t">Hello</h1><ul><li><a href="/a">Apple</a></li><li><a href="/b">Banana</a></li></ul></body></html>"#;
+
+ #[test]
+ fn plain_chain_stops_below_html() {
+ let d = dom::parse(HTML);
+ assert_eq!(css_selector(first(&d, "a")), "body > ul > li > a");
+ assert_eq!(xpath_selector(first(&d, "a")), "//body/ul/li/a");
+ }
+
+ #[test]
+ fn nth_of_type_only_when_index_gt_1() {
+ let d = dom::parse(HTML);
+ let second_li = matches(&d, "li")[1];
+ assert_eq!(css_selector(second_li), "body > ul > li:nth-of-type(2)");
+ assert_eq!(xpath_selector(second_li), "//body/ul/li[2]");
+ }
+
+ #[test]
+ fn id_short_circuits_short_variants() {
+ let d = dom::parse(r#"<html><body><div id="main"><p>x</p><p>y</p></div></body></html>"#);
+ let p2 = matches(&d, "p")[1];
+ assert_eq!(css_selector(p2), "#main > p:nth-of-type(2)");
+ assert_eq!(xpath_selector(p2), "//*[@id='main']/p[2]");
+ // full variants do NOT short-circuit:
+ assert_eq!(full_css_selector(p2), "body > #main > p:nth-of-type(2)");
+ assert_eq!(full_xpath_selector(p2), "//body/*[@id='main']/p[2]");
+ }
+
+ #[test]
+ fn html_element_yields_empty() {
+ let d = dom::parse(HTML);
+ assert_eq!(css_selector(d.root()), "");
+ }
+
+ #[test]
+ fn empty_id_falls_through_to_tag_addressing() {
+ // Python's `if target.attrib.get("id"):` is a truthiness check, so
+ // `id=""` must NOT take the id branch (verified against scrapling
+ // 0.4.9: same output for short and full variants).
+ let d = dom::parse(r#"<html><body><div id=""><p>x</p><p>y</p></div></body></html>"#);
+ let p2 = matches(&d, "p")[1];
+ assert_eq!(css_selector(p2), "body > div > p:nth-of-type(2)");
+ assert_eq!(xpath_selector(p2), "//body/div/p[2]");
+ assert_eq!(full_css_selector(p2), "body > div > p:nth-of-type(2)");
+ assert_eq!(full_xpath_selector(p2), "//body/div/p[2]");
+ }
+
+ #[test]
+ fn html_element_xpath_variants_yield_double_slash() {
+ // css stays "" (no guard needed), but xpath's unconditional
+ // "//" + parts.join("/") naturally yields "//" for an empty parts
+ // list (verified against scrapling 0.4.9).
+ let d = dom::parse(HTML);
+ assert_eq!(css_selector(d.root()), "");
+ assert_eq!(xpath_selector(d.root()), "//");
+ assert_eq!(full_css_selector(d.root()), "");
+ assert_eq!(full_xpath_selector(d.root()), "//");
+ }
+}
diff --git a/browser/src/scrapling/sessions.rs b/browser/src/scrapling/sessions.rs
new file mode 100644
index 000000000..8775d6434
--- /dev/null
+++ b/browser/src/scrapling/sessions.rs
@@ -0,0 +1,909 @@
+//! Private persistent-session registry for `browser::session-*`.
+
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::atomic::{AtomicI64, Ordering};
+use std::sync::{Arc, Mutex};
+
+use serde_json::{json, Map, Value};
+use tokio::sync::{mpsc, oneshot};
+
+use crate::config::WorkerConfig;
+#[cfg(feature = "scrapling-compat")]
+use crate::scrapling::fetch::CompatSession;
+use crate::scrapling::fetch::HttpMode;
+use crate::scrapling::raw_browser::{RawBrowser, RawBrowserOptions};
+use crate::session::now_ms;
+
+pub(crate) type Job = Pin<Box<dyn Future<Output = Result<Value, String>> + Send + 'static>>;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SessionType {
+ Http,
+ Dynamic,
+ Stealthy,
+}
+
+impl SessionType {
+ pub fn as_str(self) -> &'static str {
+ match self {
+ Self::Http => "http",
+ Self::Dynamic => "dynamic",
+ Self::Stealthy => "stealthy",
+ }
+ }
+}
+
+pub fn parse_type(payload: &Value) -> Result<SessionType, String> {
+ let Some(value) = payload.get("type") else {
+ return Ok(SessionType::Http);
+ };
+ match value.as_str() {
+ Some("http") => Ok(SessionType::Http),
+ Some("dynamic") => Ok(SessionType::Dynamic),
+ Some("stealthy") => Ok(SessionType::Stealthy),
+ _ => Err(format!(
+ "unknown session type: {} (use http|dynamic|stealthy)",
+ python_repr(value)
+ )),
+ }
+}
+
+fn python_repr(value: &Value) -> String {
+ match value {
+ Value::Null => "None".to_string(),
+ Value::Bool(true) => "True".to_string(),
+ Value::Bool(false) => "False".to_string(),
+ Value::String(value) => format!("'{value}'"),
+ other => other.to_string(),
+ }
+}
+
+#[derive(Debug)]
+pub struct HttpBackend {
+ pub jar: Arc<reqwest::cookie::Jar>,
+ pub mode: HttpMode,
+ #[cfg(feature = "scrapling-compat")]
+ pub(crate) compat: Option<CompatSession>,
+ constructor: Value,
+}
+
+impl HttpBackend {
+ #[cfg(test)]
+ fn new(payload: &Value) -> Self {
+ Self::new_for_mode(payload, HttpMode::Safe).expect("safe HTTP backend is infallible")
+ }
+
+ fn new_for_mode(payload: &Value, mode: HttpMode) -> Result<Self, String> {
+ #[cfg(not(feature = "scrapling-compat"))]
+ if mode == HttpMode::Compat {
+ return Err(
+ "browser::fetch compat HTTP engine is not compiled into this binary".to_string(),
+ );
+ }
+ Ok(Self {
+ jar: Arc::new(reqwest::cookie::Jar::default()),
+ mode,
+ #[cfg(feature = "scrapling-compat")]
+ compat: (mode == HttpMode::Compat)
+ .then(CompatSession::new)
+ .transpose()?,
+ constructor: constructor_config(payload),
+ })
+ }
+
+ pub fn request(&self, payload: &Value) -> Value {
+ merge_request(&self.constructor, payload)
+ }
+}
+
+pub struct BrowserBackend {
+ pub browser: Arc<RawBrowser>,
+ constructor: Value,
+ pub stealth: bool,
+ pub security_mode: crate::config::SecurityMode,
+}
+
+impl BrowserBackend {
+ pub fn request(&self, payload: &Value) -> Value {
+ merge_browser_request(&self.constructor, payload)
+ }
+}
+
+enum Backend {
+ Http(Arc<HttpBackend>),
+ Browser(Arc<BrowserBackend>),
+}
+
+enum Command {
+ Run {
+ job: Job,
+ response: oneshot::Sender<Result<Value, String>>,
+ },
+ Close {
+ response: oneshot::Sender<()>,
+ },
+}
+
+struct Entry {
+ id: String,
+ session_type: SessionType,
+ created_ms: i64,
+ last_used_ms: AtomicI64,
+ compat_only: bool,
+ backend: Backend,
+ commands: mpsc::UnboundedSender<Command>,
+}
+
+impl Entry {
+ fn info(&self, observed_ms: i64) -> Value {
+ let last = self.last_used_ms.load(Ordering::Relaxed);
+ let idle = (observed_ms - last).max(0) as f64 / 1000.0;
+ json!({
+ "session_id": self.id,
+ "type": self.session_type.as_str(),
+ "created_at": self.created_ms as f64 / 1000.0,
+ "last_used": last as f64 / 1000.0,
+ "idle_s": (idle * 10.0).round() / 10.0,
+ })
+ }
+}
+
+#[derive(Default)]
+struct State {
+ entries: HashMap<String, Arc<Entry>>,
+ insertion_order: Vec<String>,
+ pending: usize,
+}
+
+pub struct Registry {
+ state: Mutex<State>,
+ max_sessions: usize,
+ idle_timeout_ms: u64,
+}
+
+impl Registry {
+ pub fn new(max_sessions: u64, idle_timeout_s: u64) -> Self {
+ Self {
+ state: Mutex::new(State::default()),
+ max_sessions: usize::try_from(max_sessions).unwrap_or(usize::MAX),
+ idle_timeout_ms: idle_timeout_s.saturating_mul(1_000),
+ }
+ }
+
+ fn lock(&self) -> std::sync::MutexGuard<'_, State> {
+ self.state
+ .lock()
+ .unwrap_or_else(|poisoned| poisoned.into_inner())
+ }
+
+ async fn open_with<F>(
+ &self,
+ session_type: SessionType,
+ compat_only: bool,
+ construct: F,
+ ) -> Result<Value, String>
+ where
+ F: Future<Output = Result<Backend, String>>,
+ {
+ {
+ let mut state = self.lock();
+ if state.entries.len() + state.pending >= self.max_sessions {
+ return Err(format!(
+ "session limit reached ({}); close one first",
+ self.max_sessions
+ ));
+ }
+ state.pending += 1;
+ }
+
+ // Decrement on EVERY exit — error, panic or cancellation. A missed
+ // decrement leaks a slot forever and eventually bricks session-open.
+ struct PendingGuard<'a>(&'a Registry);
+ impl Drop for PendingGuard<'_> {
+ fn drop(&mut self) {
+ self.0.lock().pending -= 1;
+ }
+ }
+ let pending = PendingGuard(self);
+ let backend = construct.await;
+ drop(pending);
+ let mut state = self.lock();
+ let backend = backend?;
+ let id = uuid::Uuid::new_v4().simple().to_string();
+ let now = now_ms();
+ let (commands, receiver) = mpsc::unbounded_channel();
+ let entry = Arc::new(Entry {
+ id: id.clone(),
+ session_type,
+ created_ms: now,
+ last_used_ms: AtomicI64::new(now),
+ compat_only,
+ backend,
+ commands,
+ });
+ tokio::spawn(run_actor(entry.clone(), receiver));
+ state.insertion_order.push(id.clone());
+ state.entries.insert(id.clone(), entry);
+ Ok(json!({"session_id": id, "type": session_type.as_str()}))
+ }
+
+ pub async fn open_http(
+ &self,
+ payload: &Value,
+ compat_only: bool,
+ mode: HttpMode,
+ ) -> Result<Value, String> {
+ let payload = payload.clone();
+ self.open_with(SessionType::Http, compat_only, async move {
+ Ok(Backend::Http(Arc::new(HttpBackend::new_for_mode(
+ &payload, mode,
+ )?)))
+ })
+ .await
+ }
+
+ pub async fn open_browser(
+ &self,
+ session_type: SessionType,
+ payload: &Value,
+ compat_only: bool,
+ config: Arc<WorkerConfig>,
+ ) -> Result<Value, String> {
+ let constructor = browser_constructor_config(payload);
+ let payload = payload.clone();
+ let stealth = session_type == SessionType::Stealthy;
+ self.open_with(session_type, compat_only, async move {
+ let mut options = RawBrowserOptions::from_payload(&payload)?;
+ options.clamp_durations(config.max_timeout_ms);
+ let browser = RawBrowser::start(&config, &options, stealth, true).await?;
+ Ok(Backend::Browser(Arc::new(BrowserBackend {
+ browser: Arc::new(browser),
+ constructor,
+ stealth,
+ security_mode: config.scrapling.security_mode,
+ })))
+ })
+ .await
+ }
+
+ pub fn http_backend(&self, id: &str) -> Result<Arc<HttpBackend>, String> {
+ let state = self.lock();
+ let entry = state
+ .entries
+ .get(id)
+ .ok_or_else(|| format!("unknown session: {id}"))?;
+ match &entry.backend {
+ Backend::Http(backend) => Ok(backend.clone()),
+ Backend::Browser(_) => Err(format!("session {id} is not an HTTP session")),
+ }
+ }
+
+ pub fn browser_backend(&self, id: &str) -> Result<Arc<BrowserBackend>, String> {
+ let state = self.lock();
+ let entry = state
+ .entries
+ .get(id)
+ .ok_or_else(|| format!("unknown session: {id}"))?;
+ match &entry.backend {
+ Backend::Browser(backend) => Ok(backend.clone()),
+ Backend::Http(_) => Err(format!("session {id} is not a browser session")),
+ }
+ }
+
+ pub fn session_type(&self, id: &str) -> Result<SessionType, String> {
+ self.lock()
+ .entries
+ .get(id)
+ .map(|entry| entry.session_type)
+ .ok_or_else(|| format!("unknown session: {id}"))
+ }
+
+ pub fn uses_compat_only_options(&self, id: &str) -> Result<bool, String> {
+ self.lock()
+ .entries
+ .get(id)
+ .map(|entry| entry.compat_only)
+ .ok_or_else(|| format!("unknown session: {id}"))
+ }
+
+ pub async fn run(&self, id: &str, job: Job) -> Result<Value, String> {
+ let response = {
+ let state = self.lock();
+ let entry = state
+ .entries
+ .get(id)
+ .ok_or_else(|| format!("unknown session: {id}"))?;
+ let (send, receive) = oneshot::channel();
+ entry
+ .commands
+ .send(Command::Run {
+ job,
+ response: send,
+ })
+ .map_err(|_| format!("unknown session: {id}"))?;
+ receive
+ };
+ response
+ .await
+ .map_err(|_| format!("unknown session: {id}"))?
+ }
+
+ pub async fn close(&self, id: &str) -> Value {
+ let response = {
+ let mut state = self.lock();
+ let Some(entry) = state.entries.remove(id) else {
+ return json!({"closed": false});
+ };
+ state.insertion_order.retain(|existing| existing != id);
+ let (send, receive) = oneshot::channel();
+ let _ = entry.commands.send(Command::Close { response: send });
+ receive
+ };
+ let _ = response.await;
+ json!({"closed": true})
+ }
+
+ pub async fn close_all(&self) {
+ let ids = {
+ let state = self.lock();
+ state
+ .insertion_order
+ .iter()
+ .filter(|id| state.entries.contains_key(*id))
+ .cloned()
+ .collect::<Vec<_>>()
+ };
+ futures::future::join_all(ids.iter().map(|id| self.close(id))).await;
+ }
+
+ pub fn list(&self, type_filter: Option<&Value>) -> Value {
+ let now = now_ms();
+ let state = self.lock();
+ let sessions = state
+ .insertion_order
+ .iter()
+ .filter_map(|id| state.entries.get(id))
+ .filter(|entry| match type_filter {
+ None => true,
+ Some(Value::String(wanted)) => entry.session_type.as_str() == wanted,
+ Some(_) => false,
+ })
+ .map(|entry| entry.info(now))
+ .collect::<Vec<_>>();
+ json!({"sessions": sessions})
+ }
+
+ pub fn sweep_idle(&self) -> Vec<String> {
+ let idle_ms = self.idle_timeout_ms;
+ if idle_ms == 0 {
+ return Vec::new();
+ }
+ let cutoff = now_ms().saturating_sub(i64::try_from(idle_ms).unwrap_or(i64::MAX));
+ let mut state = self.lock();
+ let stale = state
+ .insertion_order
+ .iter()
+ .filter_map(|id| state.entries.get(id).map(|entry| (id, entry)))
+ .filter(|(_, entry)| entry.last_used_ms.load(Ordering::Relaxed) < cutoff)
+ .map(|(id, _)| id.clone())
+ .collect::<Vec<_>>();
+ for id in &stale {
+ if let Some(entry) = state.entries.remove(id) {
+ state.insertion_order.retain(|existing| existing != id);
+ let (response, _) = oneshot::channel();
+ let _ = entry.commands.send(Command::Close { response });
+ }
+ }
+ stale
+ }
+}
+
+async fn run_actor(entry: Arc<Entry>, mut receiver: mpsc::UnboundedReceiver<Command>) {
+ while let Some(command) = receiver.recv().await {
+ match command {
+ Command::Run { job, response } => {
+ entry.last_used_ms.store(now_ms(), Ordering::Relaxed);
+ // Jobs are now bounded from below (fetch timeouts clamped to
+ // max_timeout_ms, every CDP command has a hard ceiling), so a
+ // job can no longer hang forever and wedge the Close queued
+ // behind it — the root cause the FIFO actor used to expose.
+ let result = job.await;
+ entry.last_used_ms.store(now_ms(), Ordering::Relaxed);
+ let _ = response.send(result);
+ }
+ Command::Close { response } => {
+ if let Backend::Browser(backend) = &entry.backend {
+ // Bounded: a wedged CDP connection must not make Close
+ // (or worker shutdown) wait forever; dropping the client
+ // kills the Chromium child regardless.
+ let _ = tokio::time::timeout(
+ std::time::Duration::from_secs(10),
+ backend.browser.shutdown(),
+ )
+ .await;
+ }
+ drop(receiver);
+ drop(entry);
+ let _ = response.send(());
+ return;
+ }
+ }
+ }
+}
+
+const HTTP_CONSTRUCTOR_KEYS: &[&str] = &[
+ "impersonate",
+ "http3",
+ "stealthy_headers",
+ "proxy",
+ "proxies",
+ "proxy_auth",
+ "timeout",
+ "headers",
+ "retries",
+ "retry_delay",
+ "follow_redirects",
+ "max_redirects",
+ "verify",
+];
+
+const BROWSER_CONSTRUCTOR_KEYS: &[&str] = &[
+ "headless",
+ "network_idle",
+ "load_dom",
+ "timeout",
+ "wait",
+ "wait_selector",
+ "wait_selector_state",
+ "disable_resources",
+ "proxy",
+ "useragent",
+ "cookies",
+ "google_search",
+ "block_ads",
+ "blocked_domains",
+ "real_chrome",
+ "cdp_url",
+ "capture_xhr",
+ "locale",
+ "timezone_id",
+ "extra_headers",
+ "dns_over_https",
+ "retries",
+ "retry_delay",
+ "extra_flags",
+ "max_pages",
+ "solve_cloudflare",
+ "block_webrtc",
+ "hide_canvas",
+ "allow_webgl",
+];
+
+const BROWSER_FETCH_KEYS: &[&str] = &[
+ "google_search",
+ "timeout",
+ "wait",
+ "wait_selector",
+ "wait_selector_state",
+ "disable_resources",
+ "extra_headers",
+ "network_idle",
+ "load_dom",
+ "blocked_domains",
+ "solve_cloudflare",
+ "proxy",
+];
+
+fn constructor_config(payload: &Value) -> Value {
+ selected_config(payload, HTTP_CONSTRUCTOR_KEYS)
+}
+
+fn browser_constructor_config(payload: &Value) -> Value {
+ selected_config(payload, BROWSER_CONSTRUCTOR_KEYS)
+}
+
+fn selected_config(payload: &Value, keys: &[&str]) -> Value {
+ let mut result = Map::new();
+ if let Some(values) = payload.as_object() {
+ for &key in keys {
+ if let Some(value) = values.get(key).filter(|value| !value.is_null()) {
+ result.insert(key.to_string(), value.clone());
+ }
+ }
+ }
+ Value::Object(result)
+}
+
+fn merge_request(constructor: &Value, payload: &Value) -> Value {
+ let mut result = constructor.as_object().cloned().unwrap_or_default();
+ if let Some(values) = payload.as_object() {
+ for (key, value) in values {
+ if key != "session_id" && key != "type" && !value.is_null() {
+ result.insert(key.clone(), value.clone());
+ }
+ }
+ }
+ Value::Object(result)
+}
+
+fn merge_browser_request(constructor: &Value, payload: &Value) -> Value {
+ let mut result = constructor.as_object().cloned().unwrap_or_default();
+ if let Some(values) = payload.as_object() {
+ for (key, value) in values {
+ if key != "session_id"
+ && key != "type"
+ && !value.is_null()
+ && !(key == "proxy" && value.as_str() == Some(""))
+ && (!BROWSER_CONSTRUCTOR_KEYS.contains(&key.as_str())
+ || BROWSER_FETCH_KEYS.contains(&key.as_str()))
+ {
+ result.insert(key.clone(), value.clone());
+ }
+ }
+ if values
+ .get("headers")
+ .and_then(Value::as_object)
+ .is_some_and(|headers| !headers.is_empty())
+ && !values.contains_key("extra_headers")
+ {
+ result.insert("extra_headers".to_string(), values["headers"].clone());
+ }
+ }
+ Value::Object(result)
+}
+
+/// Every option that safe mode refuses somewhere must be listed here, or a
+/// session opens fine and only errors (or is silently ignored) at first
+/// fetch. Keep in sync with the safe-mode rejects in
+/// `HttpOptions::from_payload_for_mode` (HTTP tier) and
+/// `RawBrowserOptions::validate_policy` (browser tier).
+pub fn uses_compat_only_options(payload: &Value) -> bool {
+ payload.get("verify") == Some(&Value::Bool(false))
+ || ["proxy", "cdp_url"].iter().any(|key| {
+ payload
+ .get(key)
+ .and_then(Value::as_str)
+ .is_some_and(|v| !v.is_empty())
+ })
+ || payload.get("proxy_auth").is_some_and(|v| !v.is_null())
+ || payload
+ .get("proxies")
+ .and_then(Value::as_object)
+ .is_some_and(|v| !v.is_empty())
+ || payload
+ .get("extra_flags")
+ .and_then(Value::as_array)
+ .is_some_and(|v| !v.is_empty())
+ || payload.get("real_chrome") == Some(&Value::Bool(true))
+ || payload.get("dns_over_https") == Some(&Value::Bool(true))
+ || payload.get("stealthy_headers") == Some(&Value::Bool(true))
+ || payload.get("http3") == Some(&Value::Bool(true))
+}
+
+#[cfg(test)]
+mod tests {
+ use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+ use std::time::Duration;
+
+ use super::*;
+
+ fn id(response: &Value) -> &str {
+ response["session_id"].as_str().unwrap()
+ }
+
+ #[tokio::test]
+ async fn ids_are_uuid4_lowercase_hex_and_interactive_ids_are_foreign() {
+ let registry = Registry::new(8, 900);
+ let opened = registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ let sid = id(&opened);
+ assert_eq!(sid.len(), 32);
+ assert!(sid
+ .bytes()
+ .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)));
+ assert_eq!(&sid[12..13], "4");
+ assert_eq!(
+ registry
+ .run("b1", Box::pin(async { Ok(Value::Null) }))
+ .await
+ .unwrap_err(),
+ "unknown session: b1"
+ );
+ }
+
+ #[tokio::test]
+ async fn active_plus_pending_reserves_capacity_and_rolls_back_failure() {
+ let registry = Arc::new(Registry::new(1, 900));
+ let gate = Arc::new(tokio::sync::Notify::new());
+ let opening = {
+ let registry = registry.clone();
+ let gate = gate.clone();
+ tokio::spawn(async move {
+ registry
+ .open_with(SessionType::Http, false, async move {
+ gate.notified().await;
+ Err("constructor failed".to_string())
+ })
+ .await
+ })
+ };
+ tokio::task::yield_now().await;
+ assert_eq!(
+ registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap_err(),
+ "session limit reached (1); close one first"
+ );
+ gate.notify_one();
+ assert_eq!(opening.await.unwrap().unwrap_err(), "constructor failed");
+ registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ }
+
+ #[tokio::test]
+ async fn same_session_is_fifo_close_queues_and_different_sessions_overlap() {
+ let registry = Arc::new(Registry::new(2, 900));
+ let first = registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ let second = registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ let active = Arc::new(AtomicUsize::new(0));
+ let peak = Arc::new(AtomicUsize::new(0));
+ let order = Arc::new(Mutex::new(Vec::new()));
+ let run = |sid: String, marker: usize| {
+ let registry = registry.clone();
+ let active = active.clone();
+ let peak = peak.clone();
+ let order = order.clone();
+ tokio::spawn(async move {
+ registry
+ .run(
+ &sid,
+ Box::pin(async move {
+ let now = active.fetch_add(1, AtomicOrdering::SeqCst) + 1;
+ peak.fetch_max(now, AtomicOrdering::SeqCst);
+ order.lock().unwrap().push(marker);
+ tokio::time::sleep(Duration::from_millis(20)).await;
+ active.fetch_sub(1, AtomicOrdering::SeqCst);
+ Ok(json!(marker))
+ }),
+ )
+ .await
+ })
+ };
+ let a = run(id(&first).to_string(), 1);
+ tokio::task::yield_now().await;
+ let b = run(id(&first).to_string(), 2);
+ let c = run(id(&second).to_string(), 3);
+ tokio::task::yield_now().await;
+ let close = {
+ let registry = registry.clone();
+ let sid = id(&first).to_string();
+ tokio::spawn(async move { registry.close(&sid).await })
+ };
+ assert_eq!(a.await.unwrap().unwrap(), json!(1));
+ assert_eq!(b.await.unwrap().unwrap(), json!(2));
+ assert_eq!(c.await.unwrap().unwrap(), json!(3));
+ assert_eq!(close.await.unwrap(), json!({"closed": true}));
+ assert!(peak.load(AtomicOrdering::SeqCst) >= 2);
+ let order = order.lock().unwrap();
+ assert!(order.iter().position(|v| *v == 1) < order.iter().position(|v| *v == 2));
+ }
+
+ #[tokio::test]
+ async fn list_preserves_insertion_order_and_exact_type_filter() {
+ let registry = Registry::new(3, 900);
+ let http = registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ let second = registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ let listed = registry.list(None);
+ assert_eq!(listed["sessions"][0]["session_id"], http["session_id"]);
+ assert_eq!(listed["sessions"][1]["session_id"], second["session_id"]);
+ assert_eq!(
+ registry.list(Some(&json!("stealthy"))),
+ json!({"sessions": []})
+ );
+ assert_eq!(registry.list(Some(&json!(3))), json!({"sessions": []}));
+ }
+
+ #[tokio::test]
+ async fn private_browser_backend_opens_lists_and_closes() {
+ let executable = std::env::var_os("SCRAPLING_CHROMIUM_EXECUTABLE")
+ .map(std::path::PathBuf::from)
+ .or_else(|| crate::functions::doctor::detect_chromium(&WorkerConfig::default()));
+ let Some(executable) = executable.filter(|executable| {
+ crate::functions::doctor::chromium_version(executable).is_some_and(|version| {
+ version.split_whitespace().any(|part| {
+ crate::scrapling::raw_browser::CERTIFIED_CHROME_VERSIONS.contains(&part)
+ })
+ })
+ }) else {
+ #[cfg(feature = "scrapling-compat")]
+ panic!("certified tests require SCRAPLING_CHROMIUM_EXECUTABLE=Chrome-148");
+ #[cfg(not(feature = "scrapling-compat"))]
+ return;
+ };
+ let mut config = WorkerConfig::default();
+ config.scrapling.chromium_executable = executable.display().to_string();
+ let registry = Registry::new(2, 900);
+ let http = registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ let opened = registry
+ .open_browser(
+ SessionType::Dynamic,
+ &json!({"headless": true}),
+ false,
+ Arc::new(config),
+ )
+ .await
+ .unwrap();
+ let sid = id(&opened).to_string();
+ assert_eq!(opened["type"], "dynamic");
+ assert_eq!(
+ registry.list(None)["sessions"][0]["session_id"],
+ http["session_id"]
+ );
+ assert_eq!(registry.list(None)["sessions"][1]["session_id"], sid);
+ assert_eq!(
+ registry.list(Some(&json!("dynamic")))["sessions"][0]["session_id"],
+ sid
+ );
+ assert_eq!(
+ registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap_err(),
+ "session limit reached (2); close one first"
+ );
+ assert_eq!(registry.close(&sid).await, json!({"closed": true}));
+ assert_eq!(registry.close(id(&http)).await, json!({"closed": true}));
+ }
+
+ #[test]
+ fn constructor_state_is_allowlisted_and_null_request_values_do_not_override() {
+ let backend =
+ HttpBackend::new(&json!({"type":"http", "timeout":5, "json":{"no":"constructor"}}));
+ let merged = backend.request(&json!({"session_id":"id", "timeout":null, "url":"u"}));
+ assert_eq!(merged, json!({"timeout":5, "url":"u"}));
+ }
+
+ #[test]
+ fn browser_fetch_overrides_only_request_state() {
+ let constructor = browser_constructor_config(&json!({
+ "useragent": "constructor-agent",
+ "wait_selector": "#constructor",
+ "extra_headers": {"x-constructor": "yes"},
+ "cookies": [{"name": "a", "value": "b"}]
+ }));
+ let merged = merge_browser_request(
+ &constructor,
+ &json!({
+ "session_id": "id",
+ "url": "https://example.test",
+ "useragent": "ignored-request-agent",
+ "cookies": [],
+ "wait_selector": "#request",
+ "headers": {"authorization": "Bearer token"},
+ "proxy": "http://request-proxy:8080"
+ }),
+ );
+ assert_eq!(merged["useragent"], "constructor-agent");
+ assert_eq!(merged["cookies"], json!([{"name": "a", "value": "b"}]));
+ assert_eq!(merged["wait_selector"], "#request");
+ assert_eq!(
+ merged["extra_headers"],
+ json!({"authorization": "Bearer token"})
+ );
+ assert_eq!(merged["proxy"], "http://request-proxy:8080");
+
+ let constructor = browser_constructor_config(&json!({
+ "proxy": "http://constructor-proxy:8080"
+ }));
+ assert_eq!(
+ merge_browser_request(&constructor, &json!({"proxy": ""}))["proxy"],
+ "http://constructor-proxy:8080"
+ );
+ }
+
+ #[tokio::test]
+ async fn idle_reap_removes_metadata_and_backend_together() {
+ let registry = Registry::new(1, 1);
+ let opened = registry
+ .open_http(&json!({}), false, HttpMode::Safe)
+ .await
+ .unwrap();
+ let sid = id(&opened).to_string();
+ registry
+ .lock()
+ .entries
+ .get(&sid)
+ .unwrap()
+ .last_used_ms
+ .store(now_ms() - 2_000, Ordering::Relaxed);
+ assert_eq!(registry.sweep_idle(), std::slice::from_ref(&sid));
+ assert_eq!(registry.list(None), json!({"sessions": []}));
+ assert_eq!(
+ registry.http_backend(&sid).unwrap_err(),
+ format!("unknown session: {sid}")
+ );
+ }
+
+ #[tokio::test]
+ async fn compat_metadata_and_close_are_exact_and_idempotent() {
+ let registry = Registry::new(1, 900);
+ let opened = registry
+ .open_http(&json!({"verify": false}), true, HttpMode::Safe)
+ .await
+ .unwrap();
+ let sid = id(&opened).to_string();
+ assert!(registry.uses_compat_only_options(&sid).unwrap());
+ assert_eq!(registry.close(&sid).await, json!({"closed": true}));
+ assert_eq!(registry.close(&sid).await, json!({"closed": false}));
+ }
+
+ #[cfg(feature = "scrapling-compat")]
+ #[tokio::test]
+ async fn compat_http_transport_is_snapshotted_at_open() {
+ let registry = Registry::new(1, 900);
+ let opened = registry
+ .open_http(&json!({}), true, HttpMode::Compat)
+ .await
+ .unwrap();
+ let sid = id(&opened);
+ let backend = registry.http_backend(sid).unwrap();
+ assert_eq!(backend.mode, HttpMode::Compat);
+ assert!(backend.compat.is_some());
+ assert_eq!(registry.close(sid).await, json!({"closed": true}));
+ }
+
+ #[test]
+ fn response_and_error_text_match_the_frozen_wrapper() {
+ assert_eq!(parse_type(&json!({})).unwrap(), SessionType::Http);
+ assert_eq!(
+ parse_type(&json!({"type":"stealthy"})).unwrap(),
+ SessionType::Stealthy
+ );
+ assert_eq!(
+ parse_type(&json!({"type":"carrier-pigeon"})).unwrap_err(),
+ "unknown session type: 'carrier-pigeon' (use http|dynamic|stealthy)"
+ );
+ assert_eq!(
+ parse_type(&json!({"type":null})).unwrap_err(),
+ "unknown session type: None (use http|dynamic|stealthy)"
+ );
+ }
+
+ #[test]
+ fn every_unsafe_constructor_shape_marks_the_session_compat_only() {
+ for payload in [
+ json!({"verify": false}),
+ json!({"proxy": "http://proxy"}),
+ json!({"proxies": {"https": "http://proxy"}}),
+ json!({"proxy_auth": ["user", "pass"]}),
+ json!({"cdp_url": "ws://browser"}),
+ json!({"extra_flags": ["--no-sandbox"]}),
+ json!({"real_chrome": true}),
+ ] {
+ assert!(uses_compat_only_options(&payload), "{payload}");
+ }
+ assert!(!uses_compat_only_options(&json!({"extra_flags": []})));
+ }
+}
diff --git a/browser/src/scrapling/similar.rs b/browser/src/scrapling/similar.rs
new file mode 100644
index 000000000..df2c3ce88
--- /dev/null
+++ b/browser/src/scrapling/similar.rs
@@ -0,0 +1,419 @@
+//! `find_similar` — parser.py's structural auto-match (`Selector.find_similar`
+//! together with `__are_alike`) — and the `ratio`/`round2` numeric primitives
+//! it's built on (difflib `SequenceMatcher.ratio()` + CPython `round(x, 2)`).
+
+use std::collections::HashMap;
+
+use crate::scrapling::{dom, dom::ElementRef, text};
+
+/// `find_similar`'s `ignore_attributes` default — fixed here, not exposed as
+/// a parameter (ledger: attrs minus href/src, "not exposed").
+const IGNORE_ATTRS: [&str; 2] = ["href", "src"];
+
+/// A matching block in the same coordinate order as Python's
+/// `difflib.Match(a, b, size)`.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct Match {
+ first_start: usize,
+ second_start: usize,
+ size: usize,
+}
+
+impl Match {
+ fn new(first_start: usize, second_start: usize, size: usize) -> Self {
+ Self {
+ first_start,
+ second_start,
+ size,
+ }
+ }
+}
+
+/// The character-sequence subset of CPython 3.12's `SequenceMatcher` used by
+/// Scrapling. There is no junk predicate in the wrapper call, but the default
+/// autojunk heuristic is observable for inputs of 200 characters or more.
+struct SequenceMatcher<'a> {
+ first: &'a [char],
+ second: &'a [char],
+ second_indices: HashMap<char, Vec<usize>>,
+}
+
+impl<'a> SequenceMatcher<'a> {
+ fn new(first: &'a [char], second: &'a [char]) -> Self {
+ Self::with_autojunk(first, second, true)
+ }
+
+ fn with_autojunk(first: &'a [char], second: &'a [char], autojunk: bool) -> Self {
+ let mut second_indices: HashMap<char, Vec<usize>> = HashMap::new();
+ for (index, &value) in second.iter().enumerate() {
+ second_indices.entry(value).or_default().push(index);
+ }
+
+ // CPython's heuristic removes values occurring more than 1% + 1
+ // times, but only once the second sequence reaches 200 items.
+ if autojunk && second.len() >= 200 {
+ let popularity_cutoff = second.len() / 100 + 1;
+ second_indices.retain(|_, indices| indices.len() <= popularity_cutoff);
+ }
+
+ Self {
+ first,
+ second,
+ second_indices,
+ }
+ }
+
+ fn find_longest_match(
+ &self,
+ first_start: usize,
+ first_end: usize,
+ second_start: usize,
+ second_end: usize,
+ ) -> Match {
+ let (mut best_first, mut best_second, mut best_size) = (first_start, second_start, 0usize);
+ let mut previous_lengths = HashMap::<usize, usize>::new();
+
+ for first_index in first_start..first_end {
+ let mut current_lengths = HashMap::<usize, usize>::new();
+ if let Some(second_positions) = self.second_indices.get(&self.first[first_index]) {
+ for &second_index in second_positions {
+ if second_index < second_start {
+ continue;
+ }
+ if second_index >= second_end {
+ break;
+ }
+
+ let size = second_index
+ .checked_sub(1)
+ .and_then(|previous| previous_lengths.get(&previous).copied())
+ .unwrap_or(0)
+ + 1;
+ current_lengths.insert(second_index, size);
+ // Strictly greater preserves CPython's earliest-first tie
+ // breaking as both sequences are scanned in order.
+ if size > best_size {
+ best_first = first_index + 1 - size;
+ best_second = second_index + 1 - size;
+ best_size = size;
+ }
+ }
+ }
+ previous_lengths = current_lengths;
+ }
+
+ // Popular elements are absent from second_indices but are not junk,
+ // so CPython extends a seeded match across them in either direction.
+ while best_first > first_start
+ && best_second > second_start
+ && self.first[best_first - 1] == self.second[best_second - 1]
+ {
+ best_first -= 1;
+ best_second -= 1;
+ best_size += 1;
+ }
+ while best_first + best_size < first_end
+ && best_second + best_size < second_end
+ && self.first[best_first + best_size] == self.second[best_second + best_size]
+ {
+ best_size += 1;
+ }
+
+ Match::new(best_first, best_second, best_size)
+ }
+
+ fn get_matching_blocks(&self) -> Vec<Match> {
+ let mut queue = vec![(0, self.first.len(), 0, self.second.len())];
+ let mut blocks = Vec::new();
+
+ while let Some((first_start, first_end, second_start, second_end)) = queue.pop() {
+ let matched = self.find_longest_match(first_start, first_end, second_start, second_end);
+ if matched.size == 0 {
+ continue;
+ }
+
+ if first_start < matched.first_start && second_start < matched.second_start {
+ queue.push((
+ first_start,
+ matched.first_start,
+ second_start,
+ matched.second_start,
+ ));
+ }
+ if matched.first_start + matched.size < first_end
+ && matched.second_start + matched.size < second_end
+ {
+ queue.push((
+ matched.first_start + matched.size,
+ first_end,
+ matched.second_start + matched.size,
+ second_end,
+ ));
+ }
+ blocks.push(matched);
+ }
+
+ blocks.sort();
+
+ // Collapse adjacent blocks exactly as CPython does, then append its
+ // terminal zero-sized sentinel.
+ let mut collapsed = Vec::with_capacity(blocks.len() + 1);
+ let (mut first_start, mut second_start, mut size) = (0, 0, 0);
+ for block in blocks {
+ if first_start + size == block.first_start && second_start + size == block.second_start
+ {
+ size += block.size;
+ } else {
+ if size != 0 {
+ collapsed.push(Match::new(first_start, second_start, size));
+ }
+ first_start = block.first_start;
+ second_start = block.second_start;
+ size = block.size;
+ }
+ }
+ if size != 0 {
+ collapsed.push(Match::new(first_start, second_start, size));
+ }
+ collapsed.push(Match::new(self.first.len(), self.second.len(), 0));
+ collapsed
+ }
+
+ fn ratio(&self) -> f64 {
+ let total = self.first.len() + self.second.len();
+ if total == 0 {
+ return 1.0;
+ }
+ let matches: usize = self
+ .get_matching_blocks()
+ .into_iter()
+ .map(|block| block.size)
+ .sum();
+ 2.0 * matches as f64 / total as f64
+ }
+}
+
+/// `difflib.SequenceMatcher(None, a, b).ratio()` over chars, computed directly
+/// in f64 as `2.0 * matches / (len_a + len_b)`.
+pub fn ratio(a: &str, b: &str) -> f64 {
+ let a_chars: Vec<char> = a.chars().collect();
+ let b_chars: Vec<char> = b.chars().collect();
+ SequenceMatcher::new(&a_chars, &b_chars).ratio()
+}
+
+/// CPython `round(x, 2)`. Rust's `{:.2}` formatter and CPython's `round` are
+/// both correctly-rounded half-even decimal conversions of the same
+/// underlying binary64 value, so this agrees with the oracle bit-for-bit.
+pub fn round2(x: f64) -> f64 {
+ format!("{:.2}", x).parse().unwrap()
+}
+
+/// Number of ancestor elements (lxml `len(list(el.iterancestors()))`).
+fn depth(el: ElementRef) -> usize {
+ let mut n = 0;
+ let mut cur = el;
+ while let Some(parent) = dom::parent_element(cur) {
+ n += 1;
+ cur = parent;
+ }
+ n
+}
+
+/// Attrs minus the fixed ignore list, source order preserved — order matters
+/// here because `are_alike` sums `ratio()` calls over these in iteration
+/// order, and that sum must match Python's dict-iteration order bit-for-bit.
+fn filtered_attrs<'a>(el: ElementRef<'a>) -> Vec<(&'a str, &'a str)> {
+ el.attrs()
+ .filter(|(name, _)| !IGNORE_ATTRS.contains(name))
+ .collect()
+}
+
+/// Same tag + parent-tag + grandparent-tag chain as the anchor's precomputed
+/// `parent_tag`/`grandparent_tag` (parser.py builds `//{grandparent}/{parent}/{tag}`
+/// and evaluates it as an absolute, whole-document XPath; walked directly
+/// here instead of through the xpath engine, per the ledger).
+fn chain_matches(el: ElementRef, parent_tag: Option<&str>, grandparent_tag: Option<&str>) -> bool {
+ let Some(want_parent) = parent_tag else {
+ return true;
+ };
+ let Some(parent) = dom::parent_element(el) else {
+ return false;
+ };
+ if parent.name() != want_parent {
+ return false;
+ }
+ let Some(want_grandparent) = grandparent_tag else {
+ return true;
+ };
+ dom::parent_element(parent).is_some_and(|gp| gp.name() == want_grandparent)
+}
+
+/// `__are_alike`: accept iff `checks > 0 && round2(score / checks) >= threshold`.
+fn are_alike(
+ anchor: ElementRef,
+ target_attrs: &[(&str, &str)],
+ candidate: ElementRef,
+ threshold: f64,
+ match_text: bool,
+) -> bool {
+ let candidate_attrs = filtered_attrs(candidate);
+ let mut score = 0.0_f64;
+ let mut checks = 0usize;
+
+ if !target_attrs.is_empty() {
+ for &(k, v) in target_attrs {
+ let cv = candidate_attrs
+ .iter()
+ .copied()
+ .find(|&(ck, _)| ck == k)
+ .map_or("", |(_, cv)| cv);
+ score += ratio(v, cv);
+ }
+ // `max`, not `min`: extra candidate attrs are penalized, and fewer
+ // candidate attrs don't inflate the score via a smaller denominator.
+ checks += target_attrs.len().max(candidate_attrs.len());
+ } else if candidate_attrs.is_empty() {
+ // Both attribute-free: "this must mean something" (parser.py comment).
+ score += 1.0;
+ checks += 1;
+ }
+
+ if match_text {
+ // `__are_alike` uses `clean_spaces` (core/utils/_utils.py), NOT
+ // `TextHandler.clean` — a different cleaner: `\n`/`\r` are deleted
+ // outright (no space inserted) and the result is never trimmed.
+ let a_text = text::clean_spaces(&dom::leading_text(anchor));
+ let b_text = text::clean_spaces(&dom::leading_text(candidate));
+ score += ratio(&a_text, &b_text);
+ checks += 1;
+ }
+
+ checks > 0 && round2(score / checks as f64) >= threshold
+}
+
+/// Elements at the anchor's own ancestor depth, sharing its tag/parent-tag/
+/// grandparent-tag chain, scored alike by `__are_alike` — document order,
+/// anchor excluded, no cap.
+pub fn find_similar<'a>(
+ doc: &'a dom::Doc,
+ anchor: ElementRef<'a>,
+ threshold: f64,
+ match_text: bool,
+) -> Vec<ElementRef<'a>> {
+ let anchor_depth = depth(anchor);
+ let anchor_tag = anchor.name();
+ let anchor_parent = dom::parent_element(anchor);
+ let parent_tag = anchor_parent.map(ElementRef::name);
+ let grandparent_tag = anchor_parent
+ .and_then(dom::parent_element)
+ .map(ElementRef::name);
+ let target_attrs = filtered_attrs(anchor);
+
+ dom::descendant_elements(doc.root())
+ .into_iter()
+ .filter(|&el| el.id() != anchor.id())
+ // ponytail: depth() walk runs before the cheaper tag check; reorder
+ // if find-similar ever profiles hot.
+ .filter(|&el| depth(el) == anchor_depth)
+ .filter(|&el| el.name() == anchor_tag)
+ .filter(|&el| chain_matches(el, parent_tag, grandparent_tag))
+ .filter(|&el| are_alike(anchor, &target_attrs, el, threshold, match_text))
+ .collect()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn ratio_matches_cpython_examples() {
+ // difflib.SequenceMatcher(None,'card wide','card slim').ratio() == 0.6666666666666666
+ assert_eq!(ratio("card wide", "card slim"), 0.666_666_666_666_666_6);
+ assert_eq!(ratio("", ""), 1.0);
+ assert_eq!(ratio("abc", "abc"), 1.0);
+ }
+
+ #[test]
+ fn ratio_ignores_popular_elements_at_cpython_autojunk_threshold() {
+ // Frozen CPython 3.12.13: with len(b) == 200, the 199 `x` values
+ // are popular and removed from b2j. Since the leading values differ,
+ // there is no non-popular match from which the run can be extended.
+ let a = "x".repeat(199);
+ let b = format!("y{}", "x".repeat(199));
+ assert_eq!(ratio(&a, &b), 0.0);
+ }
+
+ #[test]
+ fn autojunk_stays_disabled_below_two_hundred_items() {
+ // Frozen CPython 3.12.13: len(b) == 199 does not activate autojunk.
+ let a = "x".repeat(198);
+ let b = format!("y{}", "x".repeat(198));
+ assert_eq!(ratio(&a, &b), 0.997_481_108_312_342_6);
+ }
+
+ #[test]
+ fn matching_blocks_follow_cpython_order_and_include_terminal_sentinel() {
+ // Frozen CPython 3.12.13:
+ // SequenceMatcher(None, "abxcd", "abcd").get_matching_blocks()
+ let a: Vec<char> = "abxcd".chars().collect();
+ let b: Vec<char> = "abcd".chars().collect();
+ let matcher = SequenceMatcher::new(&a, &b);
+ let blocks: Vec<_> = matcher
+ .get_matching_blocks()
+ .iter()
+ .map(|m| (m.first_start, m.second_start, m.size))
+ .collect();
+ assert_eq!(blocks, [(0, 0, 2), (3, 2, 2), (5, 4, 0)]);
+ }
+
+ #[test]
+ fn equal_length_ties_prefer_the_earliest_first_sequence_position() {
+ // Frozen CPython 3.12.13: the competing one-character matches are
+ // resolved to a[0] before considering the earlier position in b.
+ let a: Vec<char> = "ab".chars().collect();
+ let b: Vec<char> = "ba".chars().collect();
+ let matcher = SequenceMatcher::new(&a, &b);
+ assert_eq!(
+ matcher.get_matching_blocks(),
+ [Match::new(0, 1, 1), Match::new(2, 2, 0)]
+ );
+ }
+
+ #[test]
+ fn popular_elements_extend_a_match_seeded_by_a_rare_element() {
+ // Frozen CPython 3.12.13: `x` is popular, but it remains eligible for
+ // extension around the non-popular `z` seed.
+ let value = format!("{}z{}", "x".repeat(100), "x".repeat(100));
+ let chars: Vec<char> = value.chars().collect();
+ let matcher = SequenceMatcher::new(&chars, &chars);
+ assert_eq!(
+ matcher.get_matching_blocks(),
+ [Match::new(0, 0, 201), Match::new(201, 201, 0)]
+ );
+ assert_eq!(matcher.ratio(), 1.0);
+ }
+
+ #[test]
+ fn disabling_autojunk_retains_repeated_matches() {
+ // Frozen CPython 3.12.13 with autojunk=False.
+ let a: Vec<char> = "x".repeat(199).chars().collect();
+ let b: Vec<char> = format!("y{}", "x".repeat(199)).chars().collect();
+ let matcher = SequenceMatcher::with_autojunk(&a, &b, false);
+ let blocks: Vec<_> = matcher
+ .get_matching_blocks()
+ .iter()
+ .map(|m| (m.first_start, m.second_start, m.size))
+ .collect();
+ assert_eq!(blocks, [(0, 1, 199), (199, 200, 0)]);
+ assert_eq!(matcher.ratio(), 0.997_493_734_335_839_5);
+ }
+
+ #[test]
+ fn round2_is_half_even_decimal() {
+ assert_eq!(round2(0.665), 0.67); // 0.665 is 0.66500000000000003xx in binary
+ assert_eq!(round2(0.5), 0.5);
+ assert_eq!(round2(2.0 / 3.0), 0.67);
+ assert_eq!(round2(0.625), 0.62);
+ assert_eq!(round2(0.635), 0.64);
+ }
+}
diff --git a/browser/src/scrapling/text.rs b/browser/src/scrapling/text.rs
new file mode 100644
index 000000000..ec7833da7
--- /dev/null
+++ b/browser/src/scrapling/text.rs
@@ -0,0 +1,358 @@
+//! Python-string semantics: scrapling's TextHandler.clean()/.re() ports.
+
+use rustpython_sre_engine::{compiler, Request, SearchIter, State, StrDrive};
+
+pub fn clean(s: &str) -> String {
+ let translated: String = s
+ .chars()
+ .map(|c| {
+ if matches!(c, '\t' | '\r' | '\n') {
+ ' '
+ } else {
+ c
+ }
+ })
+ .collect();
+ collapse_spaces(&translated).trim().to_string()
+}
+
+/// scrapling `clean_spaces` (`scrapling/core/utils/_utils.py`:
+/// `__CLEANING_TABLE__ = str.maketrans({"\t": " ", "\n": None, "\r": None})`
+/// then `__CONSECUTIVE_SPACES_REGEX__.sub(" ", string)`). Unlike `clean`
+/// above: `\n`/`\r` are DELETED outright (not turned into a space — so they
+/// can glue two words together with no separator at all), and there is no
+/// trim. Used by `similar`'s `match_text` scoring (`__are_alike`); `clean`
+/// stays the one `find_by_text`/`find_by_regex` use — this is a genuinely
+/// different function in scrapling, not a duplicate.
+pub fn clean_spaces(s: &str) -> String {
+ let translated: String = s
+ .chars()
+ .filter_map(|c| match c {
+ '\t' => Some(' '),
+ '\n' | '\r' => None,
+ other => Some(other),
+ })
+ .collect();
+ collapse_spaces(&translated)
+}
+
+/// Runs of the ASCII space character collapse to one (shared by `clean` and
+/// `clean_spaces`; the only difference between them is the translate step
+/// and whether the result gets trimmed afterward).
+fn collapse_spaces(s: &str) -> String {
+ let mut out = String::with_capacity(s.len());
+ let mut prev_space = false;
+ for c in s.chars() {
+ if c == ' ' {
+ if !prev_space {
+ out.push(c);
+ }
+ prev_space = true;
+ } else {
+ out.push(c);
+ prev_space = false;
+ }
+ }
+ out
+}
+
+/// XPath normalize-space: trim + collapse all whitespace runs to single spaces.
+pub fn normalize_space(s: &str) -> String {
+ s.split([' ', '\t', '\r', '\n'])
+ .filter(|p| !p.is_empty())
+ .collect::<Vec<_>>()
+ .join(" ")
+}
+
+pub struct PyRegex {
+ codes: Vec<u32>,
+ groups: usize,
+}
+
+pub fn compile(pattern: &str, case_insensitive: bool) -> Result<PyRegex, String> {
+ let compiled =
+ compiler::compile(pattern, case_insensitive).map_err(|error| error.to_string())?;
+ Ok(PyRegex {
+ codes: compiled.codes,
+ groups: compiled.groups,
+ })
+}
+
+impl PyRegex {
+ pub fn findall(&self, text: &str) -> Vec<String> {
+ let request = Request::new(text, 0, text.count(), &self.codes, false);
+ let mut matches = SearchIter {
+ req: request,
+ state: State::default(),
+ };
+ let chars: Vec<char> = text.chars().collect();
+ let mut out = Vec::new();
+ while matches.next().is_some() {
+ if self.groups == 0 {
+ out.push(
+ chars[matches.state.start..matches.state.cursor.position]
+ .iter()
+ .collect(),
+ );
+ } else {
+ for group in 0..self.groups {
+ let (start, end) = matches.state.marks.get(group);
+ out.push(match (start.into_option(), end.into_option()) {
+ (Some(start), Some(end)) => chars[start..end].iter().collect(),
+ _ => String::new(),
+ });
+ }
+ }
+ }
+ out.into_iter()
+ .map(|match_| replace_entities(&match_))
+ .collect()
+ }
+
+ pub fn find_first(&self, text: &str) -> Option<String> {
+ self.findall(text).into_iter().next()
+ }
+
+ pub fn check_match(&self, text: &str) -> bool {
+ let request = Request::new(text, 0, text.count(), &self.codes, false);
+ State::default().search(request)
+ }
+}
+
+fn replace_entities(text: &str) -> String {
+ let mut out = String::with_capacity(text.len());
+ let mut position = 0;
+ while let Some(relative) = text[position..].find('&') {
+ let amp = position + relative;
+ out.push_str(&text[position..amp]);
+ let Some((consumed, entity, semicolon)) = parse_entity(&text[amp + 1..]) else {
+ out.push('&');
+ position = amp + 1;
+ continue;
+ };
+ let whole_end = amp + 1 + consumed;
+ let replacement: Option<String> = match entity {
+ Entity::Named(name) if name != "apos" => xmloxide::html::entities::lookup_entity(name)
+ .or_else(|| {
+ let lower = name.to_lowercase();
+ (lower != "apos")
+ .then(|| xmloxide::html::entities::lookup_entity(&lower))
+ .flatten()
+ })
+ .map(str::to_string),
+ Entity::Number(number) => codepoint(number).map(|ch| ch.to_string()),
+ _ => None,
+ };
+ if let Some(replacement) = replacement {
+ out.push_str(&replacement);
+ } else if !semicolon {
+ out.push_str(&text[amp..whole_end]);
+ }
+ position = whole_end;
+ }
+ out.push_str(&text[position..]);
+ out
+}
+
+enum Entity<'a> {
+ Named(&'a str),
+ Number(Option<u32>),
+}
+
+fn parse_entity(input: &str) -> Option<(usize, Entity<'_>, bool)> {
+ let mut chars = input.char_indices();
+ let (_, first) = chars.next()?;
+ let (body_start, radix, named) = if first == '#' {
+ match chars.next() {
+ Some((_, 'x' | 'X')) => (2, 16, false),
+ Some(_) => (1, 10, false),
+ None => return None,
+ }
+ } else {
+ (0, 10, true)
+ };
+ let body = &input[body_start..];
+ let mut body_end = 0;
+ for (offset, ch) in body.char_indices() {
+ let valid = if named {
+ ch.is_ascii_alphabetic()
+ || decimal_digit(ch).is_some()
+ || matches!(ch, '\u{130}' | '\u{131}' | '\u{17f}' | '\u{212a}')
+ } else if radix == 16 {
+ ch.is_ascii_hexdigit() || decimal_digit(ch).is_some()
+ } else {
+ decimal_digit(ch).is_some()
+ };
+ if !valid {
+ break;
+ }
+ body_end = offset + ch.len_utf8();
+ }
+ if body_end == 0 {
+ return None;
+ }
+ let semicolon = body[body_end..].starts_with(';');
+ let consumed = body_start + body_end + usize::from(semicolon);
+ let value = &body[..body_end];
+ Some((
+ consumed,
+ if named {
+ Entity::Named(value)
+ } else {
+ Entity::Number(parse_number(value, radix))
+ },
+ semicolon,
+ ))
+}
+
+fn parse_number(value: &str, radix: u32) -> Option<u32> {
+ value.chars().try_fold(0u32, |number, ch| {
+ let digit = decimal_digit(ch).or_else(|| ch.to_digit(radix))?;
+ (digit < radix)
+ .then(|| number.checked_mul(radix)?.checked_add(digit))
+ .flatten()
+ })
+}
+
+fn decimal_digit(ch: char) -> Option<u32> {
+ const ZEROES: &[u32] = &[
+ 0x0030, 0x0660, 0x06f0, 0x07c0, 0x0966, 0x09e6, 0x0a66, 0x0ae6, 0x0b66, 0x0be6, 0x0c66,
+ 0x0ce6, 0x0d66, 0x0de6, 0x0e50, 0x0ed0, 0x0f20, 0x1040, 0x1090, 0x17e0, 0x1810, 0x1946,
+ 0x19d0, 0x1a80, 0x1a90, 0x1b50, 0x1bb0, 0x1c40, 0x1c50, 0xa620, 0xa8d0, 0xa900, 0xa9d0,
+ 0xa9f0, 0xaa50, 0xabf0, 0xff10, 0x104a0, 0x10d30, 0x11066, 0x110f0, 0x11136, 0x111d0,
+ 0x112f0, 0x11450, 0x114d0, 0x11650, 0x116c0, 0x11730, 0x118e0, 0x11950, 0x11c50, 0x11d50,
+ 0x11da0, 0x11f50, 0x16a60, 0x16ac0, 0x16b50, 0x1d7ce, 0x1d7d8, 0x1d7e2, 0x1d7ec, 0x1d7f6,
+ 0x1e140, 0x1e2f0, 0x1e4f0, 0x1e950, 0x1fbf0,
+ ];
+ let codepoint = ch as u32;
+ let index = ZEROES
+ .partition_point(|candidate| *candidate <= codepoint)
+ .checked_sub(1)?;
+ let zero = ZEROES[index];
+ (codepoint - zero < 10).then_some(codepoint - zero)
+}
+
+fn codepoint(number: Option<u32>) -> Option<char> {
+ const WINDOWS_1252: [Option<char>; 32] = [
+ Some('\u{20ac}'),
+ None,
+ Some('\u{201a}'),
+ Some('\u{0192}'),
+ Some('\u{201e}'),
+ Some('\u{2026}'),
+ Some('\u{2020}'),
+ Some('\u{2021}'),
+ Some('\u{02c6}'),
+ Some('\u{2030}'),
+ Some('\u{0160}'),
+ Some('\u{2039}'),
+ Some('\u{0152}'),
+ None,
+ Some('\u{017d}'),
+ None,
+ None,
+ Some('\u{2018}'),
+ Some('\u{2019}'),
+ Some('\u{201c}'),
+ Some('\u{201d}'),
+ Some('\u{2022}'),
+ Some('\u{2013}'),
+ Some('\u{2014}'),
+ Some('\u{02dc}'),
+ Some('\u{2122}'),
+ Some('\u{0161}'),
+ Some('\u{203a}'),
+ Some('\u{0153}'),
+ None,
+ Some('\u{017e}'),
+ Some('\u{0178}'),
+ ];
+ let number = number?;
+ if (0x80..=0x9f).contains(&number) {
+ WINDOWS_1252[(number - 0x80) as usize]
+ } else {
+ char::from_u32(number)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn clean_translates_and_collapses_spaces_only() {
+ // \t\r\n each become a space, then RUNS OF SPACES collapse, then trim.
+ assert_eq!(clean(" a\t\tb\n\nc d "), "a b c d");
+ }
+
+ #[test]
+ fn clean_spaces_deletes_newlines_gluing_words_and_never_trims() {
+ // Oracle (`scrapling.core.utils.clean_spaces`), reviewer-verified
+ // counterexamples: \n/\r are DELETED (no space inserted), unlike
+ // `clean`'s \t/\r/\n -> ' ' translation, and there is no trim at all.
+ assert_eq!(clean_spaces("a\nb"), "ab");
+ assert_eq!(clean_spaces(" a "), " a "); // no trim
+ assert_eq!(clean_spaces("a\tb"), "a b"); // \t still becomes a space
+ assert_eq!(clean_spaces("a\r\nb"), "ab"); // \r and \n both deleted
+ assert_eq!(clean_spaces("a b"), "a b"); // space runs still collapse
+ assert_eq!(clean_spaces(""), "");
+ }
+
+ #[test]
+ fn normalize_space_collapses_all_whitespace() {
+ assert_eq!(normalize_space(" a \t b \n "), "a b");
+ assert_eq!(normalize_space(" \n\t "), "");
+ }
+
+ #[test]
+ fn findall_without_groups_returns_whole_matches() {
+ let re = compile(r"\d+", false).unwrap();
+ assert_eq!(re.findall("price 42 usd then 99"), vec!["42", "99"]);
+ }
+
+ #[test]
+ fn findall_with_one_group_returns_group_values() {
+ let re = compile(r"price (\d+)", false).unwrap();
+ assert_eq!(re.findall("price 42 usd then price 99"), vec!["42", "99"]);
+ }
+
+ #[test]
+ fn findall_with_two_groups_flattens_in_order() {
+ let re = compile(r"(\w+)=(\d+)", false).unwrap();
+ assert_eq!(re.findall("a=1 b=2"), vec!["a", "1", "b", "2"]);
+ }
+
+ #[test]
+ fn findall_unmatched_group_is_empty_string() {
+ let re = compile(r"(a)|(b)", false).unwrap();
+ assert_eq!(re.findall("ab"), vec!["a", "", "", "b"]);
+ }
+
+ #[test]
+ fn results_are_entity_decoded() {
+ // scrapling passes replace_entities=True: "&co" decodes to "&co"
+ let re = compile(r"&\w+", false).unwrap();
+ assert_eq!(re.findall("Smith &co"), vec!["&co"]);
+ assert_eq!(
+ replace_entities("&Copy; ' &unknown; &unknown"),
+ "© &unknown"
+ );
+ assert_eq!(replace_entities("€  € "), "€ € ");
+ assert_eq!(replace_entities("&#०; &#x９;"), "\0 \t");
+ }
+
+ #[test]
+ fn case_insensitive_flag_and_lookahead_work() {
+ let re = compile(r"apple(?= pie)", true).unwrap();
+ assert!(re.check_match("APPLE PIE".to_lowercase().as_str()));
+ assert_eq!(
+ compile(r"HeLLo", true).unwrap().findall("hello"),
+ vec!["hello"]
+ );
+ }
+
+ #[test]
+ fn invalid_pattern_is_an_error() {
+ assert!(compile(r"(", false).is_err());
+ }
+}
diff --git a/browser/src/scrapling/xpath/mod.rs b/browser/src/scrapling/xpath/mod.rs
new file mode 100644
index 000000000..8ead9fdda
--- /dev/null
+++ b/browser/src/scrapling/xpath/mod.rs
@@ -0,0 +1,98 @@
+//! XPath 1.0 compatibility wrapper over the repository-owned xmloxide fork.
+
+use xmloxide::tree::NodeKind;
+use xmloxide::xpath::{XPathNode, XPathValue};
+
+use crate::scrapling::dom::{Doc, ElementRef};
+use crate::scrapling::query::QueryResult;
+
+pub fn xpath_query<'a>(
+ doc: &'a Doc,
+ scope: Option<ElementRef<'a>>,
+ expression: &str,
+) -> Result<Vec<QueryResult<'a>>, String> {
+ let context = scope.unwrap_or_else(|| doc.root());
+ let value = xmloxide::xpath::evaluate(&doc.tree, context.id(), expression)
+ .map_err(|_| format!("Invalid XPath selector: {expression}"))?;
+ match value {
+ XPathValue::NodeSet(nodes) => Ok(nodes
+ .into_iter()
+ .filter_map(|node| query_result(doc, node))
+ .collect()),
+ XPathValue::Boolean(false) => Ok(Vec::new()),
+ XPathValue::Boolean(true) => Err("'bool' object is not iterable".to_string()),
+ XPathValue::Number(0.0) => Ok(Vec::new()),
+ XPathValue::Number(_) => Err("'float' object is not iterable".to_string()),
+ XPathValue::String(value) if value.is_empty() => Ok(Vec::new()),
+ XPathValue::String(_) => Err("'str' object has no attribute 'iter'".to_string()),
+ }
+}
+
+fn query_result<'a>(doc: &'a Doc, node: XPathNode) -> Option<QueryResult<'a>> {
+ match node {
+ XPathNode::Attribute { owner, index } => {
+ let attribute = doc.tree.attributes(owner).get(index as usize)?;
+ Some(QueryResult::Text {
+ value: attribute.value.clone(),
+ parent: doc.element(owner)?,
+ })
+ }
+ XPathNode::Node(id) => match &doc.tree.node(id).kind {
+ NodeKind::Element { .. } => doc.element(id).map(QueryResult::Element),
+ NodeKind::Text { content } | NodeKind::CData { content } => {
+ let parent = element_parent(doc, id)?;
+ Some(QueryResult::Text {
+ value: content.clone(),
+ parent,
+ })
+ }
+ _ => None,
+ },
+ }
+}
+
+fn element_parent(doc: &Doc, mut node: xmloxide::NodeId) -> Option<ElementRef<'_>> {
+ while let Some(parent) = doc.tree.parent(node) {
+ if let Some(element) = doc.element(parent) {
+ return Some(element);
+ }
+ node = parent;
+ }
+ None
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::scrapling::dom;
+
+ fn values(results: Vec<QueryResult<'_>>) -> Vec<String> {
+ results
+ .into_iter()
+ .map(|result| match result {
+ QueryResult::Element(element) => format!("<{}>", element.name()),
+ QueryResult::Text { value, .. } => value,
+ })
+ .collect()
+ }
+
+ #[test]
+ fn axes_functions_and_scalar_quirks_match_lxml_wrapper() {
+ let doc = dom::parse("<main id='m'><section id='s'><p>A</p><p>B</p></section></main>");
+ assert_eq!(
+ values(xpath_query(&doc, None, "//p/text()").unwrap()),
+ ["A", "B"]
+ );
+ assert_eq!(
+ values(xpath_query(&doc, None, "//p/ancestor::*[1]/@id").unwrap()),
+ ["s"]
+ );
+ assert!(xpath_query(&doc, None, "boolean(//nope)")
+ .unwrap()
+ .is_empty());
+ assert_eq!(
+ xpath_query(&doc, None, "boolean(//p)").unwrap_err(),
+ "'bool' object is not iterable"
+ );
+ }
+}
diff --git a/browser/src/ssrf.rs b/browser/src/ssrf.rs
new file mode 100644
index 000000000..b59503092
--- /dev/null
+++ b/browser/src/ssrf.rs
@@ -0,0 +1,400 @@
+//! SSRF defense for the outbound `browser::*` fetchers. Parse +
+//! validate the URL, resolve the host, and reject any address in a private /
+//! loopback / link-local / multicast / reserved range. The resolve+validate
+//! happens once; the socket is pinned to the validated IP (see
+//! `scrapling/fetch.rs`) to defeat DNS rebinding (TOCTOU between check and
+//! connect).
+//!
+//! Ported from `web/src/ssrf.rs`, which has carried this logic in production;
+//! the only change is `reqwest::Url` -> `url::Url` (browser already depends on
+//! `url` directly) and the config-knob name in the loopback hint. Kept as a
+//! copy rather than a shared crate: it is ~340 stable lines used by two
+//! workers, and a shared crate would cost a workspace member, a CI matrix
+//! entry and coordinated releases. Extract it if a third worker needs it.
+
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::sync::OnceLock;
+
+use ipnet::{Ipv4Net, Ipv6Net};
+
+#[derive(Debug, Clone, Copy)]
+pub struct SsrfPolicy {
+ pub allow_loopback: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct ParsedTarget {
+ pub url: url::Url,
+ pub hostname: String,
+ pub port: u16,
+}
+
+/// Parse + validate scheme and host shape. No DNS.
+pub fn parse_target(raw: &str) -> Result<ParsedTarget, String> {
+ let url = url::Url::parse(raw).map_err(|_| "url is not a valid absolute URL".to_string())?;
+ let scheme = url.scheme();
+ if scheme != "http" && scheme != "https" {
+ return Err(format!(
+ "scheme not allowed: {scheme}: (only http: and https: are permitted)"
+ ));
+ }
+ let hostname = {
+ let h = url
+ .host_str()
+ .filter(|h| !h.is_empty())
+ .ok_or_else(|| "url has no hostname".to_string())?;
+ // `host_str()` keeps the brackets on an IPv6 literal (e.g. "[::1]").
+ // Strip them so downstream code can parse the string as an IpAddr.
+ h.trim_start_matches('[').trim_end_matches(']').to_string()
+ };
+ let port = url
+ .port_or_known_default()
+ .ok_or_else(|| "invalid port".to_string())?;
+ Ok(ParsedTarget {
+ url,
+ hostname,
+ port,
+ })
+}
+
+static V4_BLOCKLIST: OnceLock<Vec<(Ipv4Net, &'static str)>> = OnceLock::new();
+static V6_BLOCKLIST: OnceLock<[(Ipv6Net, &'static str); 4]> = OnceLock::new();
+
+fn v4_blocklist() -> &'static [(Ipv4Net, &'static str)] {
+ V4_BLOCKLIST.get_or_init(|| {
+ [
+ ("0.0.0.0/8", "this-network"),
+ ("10.0.0.0/8", "private rfc1918"),
+ ("100.64.0.0/10", "cgnat rfc6598"),
+ ("127.0.0.0/8", "loopback"),
+ ("169.254.0.0/16", "link-local (incl. AWS metadata)"),
+ ("172.16.0.0/12", "private rfc1918"),
+ ("192.0.0.0/24", "ietf protocol assignments"),
+ ("192.0.2.0/24", "documentation"),
+ ("192.168.0.0/16", "private rfc1918"),
+ ("198.18.0.0/15", "benchmarking"),
+ ("198.51.100.0/24", "documentation"),
+ ("203.0.113.0/24", "documentation"),
+ ("224.0.0.0/4", "multicast"),
+ ("240.0.0.0/4", "reserved"),
+ ]
+ .into_iter()
+ .map(|(cidr, label)| (cidr.parse::<Ipv4Net>().expect("valid v4 cidr"), label))
+ .collect()
+ })
+}
+
+fn v6_blocklist() -> &'static [(Ipv6Net, &'static str)] {
+ V6_BLOCKLIST.get_or_init(|| {
+ [
+ ("fe80::/10".parse().unwrap(), "link-local fe80::/10"),
+ ("fc00::/7".parse().unwrap(), "unique-local fc00::/7"),
+ ("ff00::/8".parse().unwrap(), "multicast ff00::/8"),
+ // Local-use NAT64 (RFC 8215): the v4 embed position is
+ // operator-chosen, so it can't be validated — fail closed.
+ (
+ "64:ff9b:1::/48".parse().unwrap(),
+ "local-use nat64 64:ff9b:1::/48",
+ ),
+ ]
+ })
+}
+
+fn check_ipv4(addr: Ipv4Addr, policy: &SsrfPolicy) -> Option<&'static str> {
+ for (net, label) in v4_blocklist() {
+ if *label == "loopback" && policy.allow_loopback {
+ continue;
+ }
+ if net.contains(&addr) {
+ return Some(label);
+ }
+ }
+ None
+}
+
+/// IPv6 addresses that embed and route to an IPv4 address: NAT64
+/// (64:ff9b::/96), 6to4 (2002::/16) and the deprecated IPv4-compatible
+/// ::/96 form. The embedded IPv4 must pass the v4 blocklist, otherwise a
+/// NAT64/6to4 gateway delivers straight to a private host the v4 rules
+/// forbid.
+fn embedded_ipv4(addr: &Ipv6Addr) -> Option<Ipv4Addr> {
+ let s = addr.segments();
+ let last32 = |a: u16, b: u16| Ipv4Addr::new((a >> 8) as u8, a as u8, (b >> 8) as u8, b as u8);
+ // NAT64 well-known prefix 64:ff9b::/96 (RFC 6052 embeds v4 in the low 32
+ // bits at that prefix length).
+ if s[..6] == [0x64, 0xff9b, 0, 0, 0, 0] {
+ return Some(last32(s[6], s[7]));
+ }
+ // 6to4 2002:AABB:CCDD::/48 embeds v4 in bits 16..48.
+ if s[0] == 0x2002 {
+ return Some(last32(s[1], s[2]));
+ }
+ // IPv4-compatible ::a.b.c.d (::/96). :: and ::1 are caught earlier.
+ if s[..6] == [0, 0, 0, 0, 0, 0] {
+ return Some(last32(s[6], s[7]));
+ }
+ None
+}
+
+fn check_ipv6(addr: Ipv6Addr, policy: &SsrfPolicy) -> Option<&'static str> {
+ // IPv4-mapped (::ffff:a.b.c.d) routes to v4 — delegate to the v4 check.
+ if let Some(v4) = addr.to_ipv4_mapped() {
+ return check_ipv4(v4, policy);
+ }
+ if addr == Ipv6Addr::LOCALHOST {
+ return if policy.allow_loopback {
+ None
+ } else {
+ Some("loopback")
+ };
+ }
+ if addr == Ipv6Addr::UNSPECIFIED {
+ return Some("unspecified");
+ }
+ if let Some(v4) = embedded_ipv4(&addr) {
+ if let Some(label) = check_ipv4(v4, policy) {
+ return Some(label);
+ }
+ }
+ for (net, label) in v6_blocklist() {
+ if net.contains(&addr) {
+ return Some(label);
+ }
+ }
+ None
+}
+
+/// Returns `Some(label)` if the address is blocked, `None` if allowed.
+pub fn check_ip(addr: IpAddr, policy: &SsrfPolicy) -> Option<&'static str> {
+ match addr {
+ IpAddr::V4(v4) => check_ipv4(v4, policy),
+ IpAddr::V6(v6) => check_ipv6(v6, policy),
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct ResolvedTarget {
+ pub address: IpAddr,
+ pub hostname: String,
+ pub port: u16,
+}
+
+#[derive(Debug, Clone)]
+pub struct SsrfReject {
+ pub code: &'static str,
+ pub message: String,
+}
+
+fn loopback_hint(policy: &SsrfPolicy) -> &'static str {
+ if policy.allow_loopback {
+ ""
+ } else {
+ " (set allow_loopback=true in the browser worker config if loopback is intentional in this environment)"
+ }
+}
+
+/// Resolve the host (or accept a literal IP), validate EVERY resolved
+/// address against the blocklist, and return the address to dial (the
+/// first resolved address). If ANY address is blocked, the whole call is
+/// refused. Fail-closed: DNS failure / empty result map to `blocked_host`.
+pub async fn check_target(
+ target: &ParsedTarget,
+ policy: &SsrfPolicy,
+) -> Result<ResolvedTarget, SsrfReject> {
+ let host = &target.hostname;
+
+ // Literal IP short-circuit: skip DNS. Brackets were already stripped
+ // from IPv6 literals in parse_target.
+ if let Ok(ip) = host.parse::<IpAddr>() {
+ if let Some(label) = check_ip(ip, policy) {
+ let hint = if label == "loopback" {
+ loopback_hint(policy)
+ } else {
+ ""
+ };
+ return Err(SsrfReject {
+ code: "blocked_host",
+ message: format!("address {host} is in {label}{hint}"),
+ });
+ }
+ return Ok(ResolvedTarget {
+ address: ip,
+ hostname: host.clone(),
+ port: target.port,
+ });
+ }
+
+ let resolved: Vec<SocketAddr> =
+ match tokio::net::lookup_host((host.as_str(), target.port)).await {
+ Ok(it) => it.collect(),
+ Err(e) => {
+ return Err(SsrfReject {
+ code: "blocked_host",
+ message: format!("dns lookup failed for {host}: {e}"),
+ });
+ }
+ };
+ if resolved.is_empty() {
+ return Err(SsrfReject {
+ code: "blocked_host",
+ message: format!("dns returned no addresses for {host}"),
+ });
+ }
+
+ for sa in &resolved {
+ if let Some(label) = check_ip(sa.ip(), policy) {
+ let hint = if label == "loopback" {
+ loopback_hint(policy)
+ } else {
+ ""
+ };
+ return Err(SsrfReject {
+ code: "blocked_host",
+ message: format!(
+ "{host} resolves to {} ({label}); refusing to dial{hint}",
+ sa.ip()
+ ),
+ });
+ }
+ }
+
+ Ok(ResolvedTarget {
+ address: resolved[0].ip(),
+ hostname: host.clone(),
+ port: target.port,
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::net::IpAddr;
+
+ fn blocked(ip: &str, allow_loopback: bool) -> Option<&'static str> {
+ check_ip(
+ ip.parse::<IpAddr>().unwrap(),
+ &SsrfPolicy { allow_loopback },
+ )
+ }
+
+ #[test]
+ fn blocks_private_v4_ranges() {
+ for ip in [
+ "10.0.0.1",
+ "172.16.5.5",
+ "192.168.1.1",
+ "169.254.169.254",
+ "100.64.0.1",
+ "0.0.0.0",
+ "224.0.0.1",
+ "240.0.0.1",
+ ] {
+ assert!(blocked(ip, true).is_some(), "{ip} should be blocked");
+ }
+ }
+
+ #[test]
+ fn allows_public_v4() {
+ assert!(blocked("1.1.1.1", true).is_none());
+ assert!(blocked("93.184.216.34", true).is_none());
+ }
+
+ #[test]
+ fn loopback_policy_v4_and_v6() {
+ assert!(blocked("127.0.0.1", true).is_none());
+ assert!(blocked("127.0.0.1", false).is_some());
+ assert!(blocked("::1", true).is_none());
+ assert!(blocked("::1", false).is_some());
+ // loopback=true still blocks other private ranges
+ assert!(blocked("169.254.169.254", true).is_some());
+ assert!(blocked("10.0.0.1", true).is_some());
+ }
+
+ #[test]
+ fn blocks_v6_ranges() {
+ for ip in ["::", "fe80::1", "febf::1", "fc00::1", "fd12::1", "ff02::1"] {
+ assert!(blocked(ip, true).is_some(), "{ip} should be blocked");
+ }
+ assert!(blocked("2606:4700:4700::1111", true).is_none());
+ }
+
+ #[test]
+ fn blocks_v4_embedding_v6_forms() {
+ // NAT64 well-known prefix: embedded private v4 blocked, public allowed.
+ assert!(blocked("64:ff9b::a00:1", true).is_some()); // 10.0.0.1
+ assert!(blocked("64:ff9b::a9fe:a9fe", true).is_some()); // 169.254.169.254
+ assert!(blocked("64:ff9b::101:101", true).is_none()); // 1.1.1.1
+ // Local-use NAT64: fail closed regardless of embed.
+ assert!(blocked("64:ff9b:1::1", true).is_some());
+ // 6to4: embedded v4 validated.
+ assert!(blocked("2002:a00:1::", true).is_some()); // 10.0.0.1
+ assert!(blocked("2002:101:101::", true).is_none()); // 1.1.1.1
+ // Deprecated IPv4-compatible ::/96.
+ assert!(blocked("::a9fe:a9fe", true).is_some());
+ }
+
+ #[test]
+ fn blocks_v4_mapped_v6_metadata() {
+ // both textual and (parsed) hex forms collapse to 169.254.169.254
+ assert!(blocked("::ffff:169.254.169.254", true).is_some());
+ assert!(blocked("::ffff:a9fe:a9fe", true).is_some());
+ }
+
+ #[test]
+ fn parse_target_rejects_non_http() {
+ assert!(parse_target("ftp://example.com/").is_err());
+ assert!(parse_target("file:///etc/passwd").is_err());
+ assert!(parse_target("not a url").is_err());
+ }
+
+ #[test]
+ fn parse_target_defaults_ports() {
+ assert_eq!(parse_target("http://example.com/").unwrap().port, 80);
+ assert_eq!(parse_target("https://example.com/").unwrap().port, 443);
+ assert_eq!(parse_target("http://example.com:8080/").unwrap().port, 8080);
+ }
+
+ #[tokio::test]
+ async fn check_target_literal_v4_public_ok() {
+ let t = parse_target("http://1.1.1.1/").unwrap();
+ let r = check_target(
+ &t,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap();
+ assert_eq!(r.address, "1.1.1.1".parse::<std::net::IpAddr>().unwrap());
+ assert_eq!(r.port, 80);
+ }
+
+ #[tokio::test]
+ async fn check_target_literal_v4_private_blocked() {
+ let t = parse_target("http://169.254.169.254/").unwrap();
+ let rej = check_target(
+ &t,
+ &SsrfPolicy {
+ allow_loopback: true,
+ },
+ )
+ .await
+ .unwrap_err();
+ assert_eq!(rej.code, "blocked_host");
+ }
+
+ #[tokio::test]
+ async fn check_target_literal_v6_bracket_stripped_and_blocked() {
+ let t = parse_target("http://[::1]/").unwrap();
+ let rej = check_target(
+ &t,
+ &SsrfPolicy {
+ allow_loopback: false,
+ },
+ )
+ .await
+ .unwrap_err();
+ assert_eq!(rej.code, "blocked_host");
+ assert!(rej.message.contains("allow_loopback"));
+ }
+}
diff --git a/browser/tests/adaptive.rs b/browser/tests/adaptive.rs
new file mode 100644
index 000000000..e0a139d8d
--- /dev/null
+++ b/browser/tests/adaptive.rs
@@ -0,0 +1,243 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use browser::scrapling::{adaptive, dispatch_op};
+use rusqlite::Connection;
+use serde_json::{json, Value};
+
+fn call(id: &str, payload: Value) -> Value {
+ dispatch_op(id, &payload).unwrap()
+}
+
+#[test]
+fn adaptive_tracking_matches_the_standalone_wrapper_contract() {
+ let unique = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .unwrap()
+ .as_nanos();
+ let dir =
+ std::env::temp_dir().join(format!("browser-adaptive-{}-{unique}", std::process::id()));
+ std::fs::create_dir_all(&dir).unwrap();
+ let db = dir.join("elements.db");
+ adaptive::configure(&db).unwrap();
+
+ let domain = "https://shop.example.com";
+ let v1 =
+ r#"<html><body><div class="price-box"><span class="amount">$42</span></div></body></html>"#;
+ let v2 = r#"<html><body><section class="pricing"><span class="new-amount">$42</span></section></body></html>"#;
+
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": v1, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "css-price"}),
+ ),
+ json!({"result": ["$42"]})
+ );
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": v2, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "css-price"}),
+ ),
+ json!({"result": ["$42"]})
+ );
+
+ assert_eq!(
+ call(
+ "browser::xpath",
+ json!({"html": v1, "query": "//span[@class='amount']", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "xpath-price"}),
+ ),
+ json!({"result": ["$42"]})
+ );
+ assert_eq!(
+ call(
+ "browser::xpath",
+ json!({"html": v2, "query": "//span[@class='amount']", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "xpath-price"}),
+ ),
+ json!({"result": ["$42"]})
+ );
+
+ let ties = r#"<html><body><section><span class="new">$42</span><span class="new">$42</span></section></body></html>"#;
+ call(
+ "browser::css",
+ json!({"html": v1, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "ties"}),
+ );
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": ties, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "ties"}),
+ ),
+ json!({"result": ["$42", "$42"]})
+ );
+
+ let grouped = r#"<html><body><p class="a">A</p><p class="b">B</p></body></html>"#;
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": grouped, "query": "p.b, p.a", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "grouped"}),
+ ),
+ json!({"result": ["B", "A"]})
+ );
+
+ // The wrapper evaluates adaptive comma groups in selector order and uses
+ // the caller's identifier for every group. Each direct hit overwrites the
+ // preceding group's identity, so the last group is the persisted one.
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": "<p class='changed-a'>A</p><p class='changed-b'>B</p>",
+ "query": "p.b, p.a", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "grouped"}),
+ ),
+ json!({"result": ["A", "A"]})
+ );
+
+ // Direct results always win over a stored identity, and only the first
+ // direct match is saved.
+ call(
+ "browser::css",
+ json!({"html": "<p class='many'>first</p><p class='many'>second</p>",
+ "query": "p.many", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "first-only"}),
+ );
+ let connection = Connection::open(&db).unwrap();
+ let first_only: Vec<u8> = connection
+ .query_row(
+ "SELECT element_data FROM storage WHERE identifier = 'first-only'",
+ [],
+ |row| row.get(0),
+ )
+ .unwrap();
+ assert_eq!(
+ serde_json::from_slice::<Value>(&first_only).unwrap()["text"],
+ "first"
+ );
+ drop(connection);
+
+ // `auto_save: null` is false in the Python wrapper, while an omitted
+ // value defaults true for css/xpath and to `adaptive` for extract.
+ call(
+ "browser::css",
+ json!({"html": v1, "query": "span.amount", "adaptive": true, "auto_save": null,
+ "adaptive_domain": domain, "identifier": "null-not-saved"}),
+ );
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": v2, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "null-not-saved"}),
+ ),
+ json!({"result": []})
+ );
+
+ call(
+ "browser::css",
+ json!({"html": v1, "query": "span.amount", "adaptive": true, "auto_save": false,
+ "adaptive_domain": domain, "identifier": "not-saved"}),
+ );
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": v2, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "not-saved"}),
+ ),
+ json!({"result": []})
+ );
+
+ let selectors = json!([{"name": "price", "css": "span.amount"}]);
+ call(
+ "browser::extract",
+ json!({"html": v1, "selectors": selectors, "adaptive": true, "adaptive_domain": domain}),
+ );
+ assert_eq!(
+ call(
+ "browser::extract",
+ json!({"html": v2, "selectors": selectors, "adaptive": true, "adaptive_domain": domain}),
+ ),
+ json!({"extracted": {"price": "$42"}})
+ );
+
+ call(
+ "browser::extract",
+ json!({"html": v1, "selectors": [{"name": "extract-null", "css": "span.amount"}],
+ "adaptive": true, "auto_save": null, "adaptive_domain": domain}),
+ );
+ assert_eq!(
+ call(
+ "browser::extract",
+ json!({"html": v2, "selectors": [{"name": "extract-null", "css": "span.amount"}],
+ "adaptive": true, "adaptive_domain": domain}),
+ ),
+ json!({"extracted": {"extract-null": null}})
+ );
+
+ // These domains distinguish tld 0.13.2's frozen data from the newer PSL
+ // bundled by the Rust psl crate. `file.core.windows.net` was a suffix in
+ // the oracle, while `12chars.dev` was not yet one.
+ call(
+ "browser::css",
+ json!({"html": v1, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": "https://a.file.core.windows.net", "identifier": "added-rule"}),
+ );
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": v2, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": "https://b.file.core.windows.net", "identifier": "added-rule"}),
+ ),
+ json!({"result": []})
+ );
+ call(
+ "browser::css",
+ json!({"html": v1, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": "https://a.12chars.dev", "identifier": "removed-rule"}),
+ );
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": v2, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": "https://b.12chars.dev", "identifier": "removed-rule"}),
+ ),
+ json!({"result": ["$42"]})
+ );
+
+ let connection = Connection::open(&db).unwrap();
+ assert_eq!(
+ connection
+ .query_row("PRAGMA journal_mode", [], |row| row.get::<_, String>(0))
+ .unwrap(),
+ "wal"
+ );
+ assert_eq!(
+ connection
+ .query_row(
+ "SELECT typeof(element_data) FROM storage WHERE identifier = 'css-price'",
+ [],
+ |row| row.get::<_, String>(0),
+ )
+ .unwrap(),
+ "blob"
+ );
+ connection
+ .execute(
+ "UPDATE storage SET element_data = CAST(element_data AS TEXT) WHERE identifier = 'css-price'",
+ [],
+ )
+ .unwrap();
+ drop(connection);
+ assert_eq!(
+ call(
+ "browser::css",
+ json!({"html": v2, "query": "span.amount", "adaptive": true,
+ "adaptive_domain": domain, "identifier": "css-price"}),
+ ),
+ json!({"result": ["$42"]})
+ );
+
+ std::fs::remove_dir_all(dir).unwrap();
+}
diff --git a/browser/tests/behavior.rs b/browser/tests/behavior.rs
new file mode 100644
index 000000000..06a473953
--- /dev/null
+++ b/browser/tests/behavior.rs
@@ -0,0 +1,72 @@
+//! Differential fixtures: replay Python-captured request/response pairs
+//! through the Rust ops. Outputs and error text must match exactly; unsupported
+//! operations are failures, not skips.
+
+use serde_json::Value;
+use std::fs;
+use std::path::PathBuf;
+
+fn behavior_root() -> PathBuf {
+ PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/golden/behavior")
+}
+
+#[test]
+fn behavior_fixtures_match_reference() {
+ let mut failures = Vec::new();
+ let mut ran = 0;
+ let mut stack = vec![behavior_root()];
+ let mut files = Vec::new();
+ while let Some(dir) = stack.pop() {
+ let Ok(entries) = fs::read_dir(&dir) else {
+ continue;
+ };
+ for entry in entries.flatten() {
+ let p = entry.path();
+ if p.is_dir() {
+ stack.push(p);
+ } else if p.extension().is_some_and(|e| e == "json") {
+ files.push(p);
+ }
+ }
+ }
+ files.sort();
+ assert!(
+ !files.is_empty(),
+ "no behavior fixtures found — run gen_goldens.py behavior"
+ );
+ for file in files {
+ let fixture: Value = serde_json::from_str(&fs::read_to_string(&file).unwrap()).unwrap();
+ let fid = fixture["function"].as_str().unwrap();
+ let case = format!("{fid}/{}", fixture["case"].as_str().unwrap());
+ let got = browser::scrapling::dispatch_op(fid, &fixture["request"]);
+ match (got, fixture.get("ok")) {
+ (Ok(actual), Some(expected)) => {
+ ran += 1;
+ if &actual != expected {
+ failures.push(format!(
+ "{case}:\n expected: {expected}\n actual: {actual}"
+ ));
+ }
+ }
+ (Err(actual_err), None) => {
+ ran += 1;
+ let expected_err = fixture["err"].as_str().unwrap();
+ if actual_err != expected_err {
+ failures.push(format!(
+ "{case} (error text):\n expected: {expected_err}\n actual: {actual_err}"
+ ));
+ }
+ }
+ (Ok(v), None) => {
+ ran += 1;
+ failures.push(format!("{case}: expected error, got {v}"));
+ }
+ (Err(e), Some(_)) => {
+ ran += 1;
+ failures.push(format!("{case}: unexpected error {e}"));
+ }
+ }
+ }
+ eprintln!("behavior fixtures run: {ran}");
+ assert!(failures.is_empty(), "{}", failures.join("\n\n"));
+}
diff --git a/browser/tests/browser_compat.rs b/browser/tests/browser_compat.rs
new file mode 100644
index 000000000..7e8fed29d
--- /dev/null
+++ b/browser/tests/browser_compat.rs
@@ -0,0 +1,254 @@
+#![cfg(feature = "scrapling-compat")]
+
+use std::path::PathBuf;
+use std::time::Duration;
+
+use browser::config::{SecurityMode, WorkerConfig};
+use browser::scrapling::raw_browser::{RawBrowser, RawBrowserOptions};
+use serde_json::json;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+
+async fn origin() -> (String, tokio::task::JoinHandle<()>) {
+ let listener = TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
+ .await
+ .unwrap();
+ let address = listener.local_addr().unwrap();
+ let task = tokio::spawn(async move {
+ loop {
+ let Ok((mut socket, _)) = listener.accept().await else {
+ return;
+ };
+ tokio::spawn(async move {
+ let mut request = [0; 8192];
+ let Ok(size) = socket.read(&mut request).await else {
+ return;
+ };
+ let Some(path) = std::str::from_utf8(&request[..size])
+ .ok()
+ .and_then(|request| request.split_whitespace().nth(1))
+ else {
+ return;
+ };
+ let (status, headers, body) = match path {
+ "/plain" => (
+ "206 Partial Content",
+ "Content-Type: text/plain; charset=iso-8859-1\r\nX-Test: plain\r\n",
+ b"caf\xe9".to_vec(),
+ ),
+ "/visual" => (
+ "200 OK",
+ "Content-Type: text/html; charset=utf-8\r\n",
+ include_bytes!("corpus/browser_visual.html").to_vec(),
+ ),
+ _ => (
+ "200 OK",
+ "Content-Type: text/html; charset=utf-8\r\nX-Test: one\r\nX-Test: two\r\nSet-Cookie: sid=abc; Path=/\r\n",
+ br#"<!doctype html><html><head><title>T</title></head><body><h1>initial</h1><div id="fp"></div><script>document.querySelector('h1').textContent='rendered';document.querySelector('#fp').textContent=[navigator.language,Intl.DateTimeFormat().resolvedOptions().timeZone,devicePixelRatio,innerWidth,innerHeight].join('|')</script></body></html>"#.to_vec(),
+ ),
+ };
+ let response = format!(
+ "HTTP/1.1 {status}\r\n{headers}Date: Wed, 12 Aug 2026 16:00:00 GMT\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
+ body.len()
+ );
+ if socket.write_all(response.as_bytes()).await.is_ok() {
+ let _ = socket.write_all(&body).await;
+ }
+ });
+ }
+ });
+ (format!("http://{address}"), task)
+}
+
+fn assert_image_close(label: &str, actual: &[u8], expected: &[u8]) {
+ let actual = image::load_from_memory(actual).unwrap().to_rgba8();
+ let expected = image::load_from_memory(expected).unwrap().to_rgba8();
+ assert_eq!(actual.dimensions(), expected.dimensions());
+ let mut total_error = 0u64;
+ let mut within_three = 0usize;
+ let mut maximum = 0u8;
+ for (actual, expected) in actual.as_raw().iter().zip(expected.as_raw()) {
+ let error = actual.abs_diff(*expected);
+ total_error += u64::from(error);
+ within_three += usize::from(error <= 3);
+ maximum = maximum.max(error);
+ }
+ let channels = actual.as_raw().len();
+ let mean = total_error as f64 / channels as f64;
+ assert!(mean <= 0.5, "{label}: mean error {mean}");
+ assert!(
+ within_three * 1_000 >= channels * 999,
+ "{label}: {} of {channels} channels within 3",
+ within_three
+ );
+ assert!(maximum <= 12, "{label}: maximum error {maximum}");
+}
+
+fn config() -> WorkerConfig {
+ let mut config = WorkerConfig::default();
+ config.scrapling.security_mode = SecurityMode::Compat;
+ config.scrapling.chromium_executable = PathBuf::from(
+ std::env::var_os("SCRAPLING_CHROMIUM_EXECUTABLE")
+ .expect("SCRAPLING_CHROMIUM_EXECUTABLE must name frozen Chrome 148"),
+ )
+ .display()
+ .to_string();
+ config
+}
+
+#[tokio::test]
+async fn browser_response_matches_frozen_dynamic_and_stealth_contracts() {
+ let (origin, server) = origin().await;
+ for (stealth, viewport) in [(false, "1280|720"), (true, "1920|1080")] {
+ let options = RawBrowserOptions::from_payload(&json!({
+ "retries": 1,
+ "timeout": 5_000,
+ "locale": "fr-FR",
+ "timezone_id": "Europe/Paris"
+ }))
+ .unwrap();
+ let browser = RawBrowser::start(&config(), &options, stealth, false)
+ .await
+ .unwrap();
+ let page = browser
+ .fetch(&format!("{origin}/page"), &options, stealth)
+ .await
+ .unwrap();
+ assert_eq!(page.status, Some(200));
+ assert_eq!(page.headers["x-test"], "one, two");
+ assert_eq!(page.cookies, serde_json::Map::new());
+ assert_eq!(page.encoding.as_deref(), Some("utf-8"));
+ assert!(page.html.contains("<h1>rendered</h1>"), "{}", page.html);
+ assert!(
+ page.html
+ .contains(&format!("fr-FR|Europe/Paris|2|{viewport}")),
+ "{}",
+ page.html
+ );
+
+ let plain = browser
+ .fetch(&format!("{origin}/plain"), &options, stealth)
+ .await
+ .unwrap();
+ assert_eq!(plain.status, Some(206));
+ assert_eq!(plain.encoding.as_deref(), Some("iso-8859-1"));
+ assert_eq!(plain.html, "<html><body>café</body></html>");
+ }
+ server.abort();
+}
+
+#[tokio::test]
+async fn browser_waits_match_the_frozen_timing_contract() {
+ let (origin, server) = origin().await;
+ let options = RawBrowserOptions::from_payload(&json!({
+ "retries": 1,
+ "timeout": 5_000,
+ "wait": 25
+ }))
+ .unwrap();
+ let browser = RawBrowser::start(&config(), &options, false, false)
+ .await
+ .unwrap();
+ let started = std::time::Instant::now();
+ browser
+ .fetch(&format!("{origin}/page"), &options, false)
+ .await
+ .unwrap();
+ assert!(started.elapsed() >= Duration::from_millis(25));
+ server.abort();
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn five_browser_processes_run_within_the_release_envelope() {
+ let (origin, server) = origin().await;
+ let jobs = (0..5).map(|_| {
+ let origin = origin.clone();
+ async move {
+ let options = RawBrowserOptions::from_payload(&json!({
+ "retries": 1,
+ "timeout": 10_000
+ }))
+ .unwrap();
+ let browser = RawBrowser::start(&config(), &options, false, false)
+ .await
+ .unwrap();
+ let page = browser
+ .fetch(&format!("{origin}/page"), &options, false)
+ .await
+ .unwrap();
+ browser.shutdown().await;
+ page
+ }
+ });
+ for page in futures::future::join_all(jobs).await {
+ assert_eq!(page.status, Some(200));
+ assert!(page.html.contains("<h1>rendered</h1>"));
+ }
+ server.abort();
+}
+
+#[tokio::test]
+async fn screenshots_match_the_frozen_wrapper_metrics_and_pixels() {
+ let manifest: serde_json::Value =
+ serde_json::from_str(include_str!("golden/browser/manifest.json")).unwrap();
+ let (origin, server) = origin().await;
+ for case in manifest["cases"].as_array().unwrap() {
+ let request = &case["request"];
+ let stealth = request["fetcher"] == "stealthy";
+ let options = RawBrowserOptions::from_payload(request).unwrap();
+ let browser = RawBrowser::start(&config(), &options, stealth, false)
+ .await
+ .unwrap();
+ let (content, mime, final_url) = browser
+ .screenshot(
+ &format!("{origin}/visual"),
+ &options,
+ stealth,
+ request["full_page"].as_bool().unwrap(),
+ request["format"].as_str().unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(mime, case["response"]["mime"]);
+ assert_eq!(final_url, format!("{origin}/visual"));
+ let expected = case["response"]["content"].as_array().unwrap();
+ assert_eq!(content.len(), expected.len());
+ for (actual, expected) in content.iter().zip(expected) {
+ assert_eq!(actual["type"], expected["type"]);
+ if actual["type"] == "image" {
+ assert_eq!(actual["mime"], expected["mime"]);
+ let actual = base64::Engine::decode(
+ &base64::engine::general_purpose::STANDARD,
+ actual["data"].as_str().unwrap(),
+ )
+ .unwrap();
+ let filename = expected["file"].as_str().unwrap();
+ let expected = match filename {
+ "dynamic-viewport-png-1.png" => {
+ include_bytes!("golden/browser/dynamic-viewport-png-1.png").as_slice()
+ }
+ "dynamic-full-png-1.png" => {
+ include_bytes!("golden/browser/dynamic-full-png-1.png").as_slice()
+ }
+ "stealthy-viewport-png-1.png" => {
+ include_bytes!("golden/browser/stealthy-viewport-png-1.png").as_slice()
+ }
+ "stealthy-full-jpeg-1.jpg" => {
+ include_bytes!("golden/browser/stealthy-full-jpeg-1.jpg").as_slice()
+ }
+ name => panic!("unexpected browser fixture {name}"),
+ };
+ assert_image_close(filename, &actual, expected);
+ } else {
+ assert_eq!(
+ actual["text"],
+ expected["text"]
+ .as_str()
+ .unwrap()
+ .replace("{origin}", &origin)
+ );
+ }
+ }
+ }
+ server.abort();
+}
diff --git a/browser/tests/cdp_private.rs b/browser/tests/cdp_private.rs
new file mode 100644
index 000000000..0edc05263
--- /dev/null
+++ b/browser/tests/cdp_private.rs
@@ -0,0 +1,299 @@
+#[allow(dead_code)]
+#[path = "../src/scrapling/cdp.rs"]
+mod cdp;
+
+#[cfg(unix)]
+mod unix {
+ use std::io::{Read, Write};
+ use std::os::unix::net::UnixStream;
+ use std::process::Command;
+ use std::sync::mpsc;
+ use std::thread;
+
+ use serde_json::{json, Value};
+
+ use super::cdp::{CdpClient, CdpError, EventError, REMOTE_DEBUGGING_PIPE_ARG};
+
+ fn read_frame(stream: &mut UnixStream) -> Option<Value> {
+ let mut bytes = Vec::new();
+ let mut byte = [0];
+ loop {
+ match stream.read(&mut byte).unwrap() {
+ 0 if bytes.is_empty() => return None,
+ 0 => panic!("truncated CDP frame"),
+ _ if byte[0] == 0 => return Some(serde_json::from_slice(&bytes).unwrap()),
+ _ => bytes.push(byte[0]),
+ }
+ }
+ }
+
+ fn write_frame(stream: &mut UnixStream, value: &Value) {
+ serde_json::to_writer(&mut *stream, value).unwrap();
+ stream.write_all(&[0]).unwrap();
+ stream.flush().unwrap();
+ }
+
+ fn write_chunked_frames(stream: &mut UnixStream, values: &[Value]) {
+ let mut bytes = Vec::new();
+ for value in values {
+ serde_json::to_writer(&mut bytes, value).unwrap();
+ bytes.push(0);
+ }
+ let split = 3.min(bytes.len());
+ stream.write_all(&bytes[..split]).unwrap();
+ stream.write_all(&bytes[split..]).unwrap();
+ stream.flush().unwrap();
+ }
+
+ #[tokio::test]
+ async fn fake_pipe_frames_routes_cancels_and_tears_down() {
+ let (client_commands, mut server_commands) = UnixStream::pair().unwrap();
+ let (mut server_events, client_events) = UnixStream::pair().unwrap();
+ let (closed_tx, closed_rx) = mpsc::channel();
+
+ let server = thread::spawn(move || {
+ let root = read_frame(&mut server_commands).unwrap();
+ let page = read_frame(&mut server_commands).unwrap();
+ assert_eq!(
+ root,
+ json!({"id": 1, "method": "Browser.getVersion", "params": {}})
+ );
+ assert_eq!(
+ page,
+ json!({"id": 2, "method": "Page.getFrameTree", "params": {}, "sessionId": "page-1"})
+ );
+
+ write_chunked_frames(
+ &mut server_events,
+ &[
+ json!({"method": "Browser.downloadWillBegin", "params": {"guid": "g"}}),
+ json!({"method": "Page.loadEventFired", "params": {"timestamp": 1}, "sessionId": "page-1"}),
+ json!({"id": 2, "result": {"wrong": true}, "sessionId": "page-2"}),
+ json!({"id": 2, "result": {"frameTree": "page"}, "sessionId": "page-1"}),
+ json!({"id": 1, "result": {"product": "Chrome"}}),
+ ],
+ );
+
+ let cancelled = read_frame(&mut server_commands).unwrap();
+ assert_eq!(cancelled["id"], 3);
+ write_frame(
+ &mut server_events,
+ &json!({"id": 3, "result": {"late": true}}),
+ );
+
+ let after_cancel = read_frame(&mut server_commands).unwrap();
+ assert_eq!(after_cancel["id"], 4);
+ write_frame(
+ &mut server_events,
+ &json!({"id": 4, "error": {"code": -32000, "message": "boom"}}),
+ );
+
+ assert!(read_frame(&mut server_commands).is_none());
+ drop(server_events);
+ closed_tx.send(()).unwrap();
+ });
+
+ let child = Command::new("sh")
+ .args(["-c", "exec sleep 60"])
+ .spawn()
+ .unwrap();
+ let client = CdpClient::from_pipe(client_events, client_commands, Some(child)).unwrap();
+ let mut browser_events = client.subscribe();
+ let page = client.session("page-1");
+ let mut page_events = page.subscribe();
+
+ let root_call = client.send("Browser.getVersion", json!({})).unwrap();
+ let page_call = page.send("Page.getFrameTree", json!({})).unwrap();
+ let (root_result, page_result) = tokio::join!(root_call, page_call);
+ assert_eq!(root_result.unwrap(), json!({"product": "Chrome"}));
+ assert_eq!(page_result.unwrap(), json!({"frameTree": "page"}));
+
+ let browser_event = browser_events.recv().await.unwrap();
+ assert_eq!(browser_event.method, "Browser.downloadWillBegin");
+ assert_eq!(browser_event.session_id, None);
+ let page_event = page_events.recv().await.unwrap();
+ assert_eq!(page_event.method, "Page.loadEventFired");
+ assert_eq!(page_event.session_id.as_deref(), Some("page-1"));
+
+ let cancelled = client
+ .send("Runtime.evaluate", json!({"expression": "1"}))
+ .unwrap();
+ drop(cancelled);
+ tokio::task::yield_now().await;
+ assert_eq!(client.pending_count(), 0);
+
+ let error = client
+ .send("Broken.command", json!({}))
+ .unwrap()
+ .await
+ .unwrap_err();
+ assert!(matches!(error, CdpError::Protocol { code: -32000, .. }));
+
+ client.close().unwrap();
+ closed_rx.recv().unwrap();
+ server.join().unwrap();
+ assert!(client.is_closed());
+ assert!(client.process_status().is_some());
+ assert!(matches!(
+ browser_events.recv().await,
+ Err(EventError::Closed)
+ ));
+ assert_eq!(REMOTE_DEBUGGING_PIPE_ARG, "--remote-debugging-pipe");
+ }
+
+ #[tokio::test]
+ async fn launcher_maps_chromes_fd3_and_fd4_and_owns_the_child() {
+ let unique = format!(
+ "{}-{}",
+ std::process::id(),
+ std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .unwrap()
+ .as_nanos()
+ );
+ let capture = std::env::temp_dir().join(format!("cdp-launch-{unique}.json"));
+ let expected = b"{\"id\":1,\"method\":\"Browser.getVersion\",\"params\":{}}\0";
+ let script = r#"
+ test "$0" = "--remote-debugging-pipe" || exit 91
+ dd bs=1 count="$FRAME_LEN" <&3 >"$CAPTURE" 2>/dev/null || exit 92
+ printf '{"id":1,"result":{"product":"FakeChrome"}}\0' >&4 || exit 93
+ exec sleep 60
+ "#;
+ let mut command = Command::new("sh");
+ command
+ .arg("-c")
+ .arg(script)
+ .env("FRAME_LEN", expected.len().to_string())
+ .env("CAPTURE", &capture);
+
+ let client = CdpClient::launch_pipe(&mut command).unwrap();
+ assert_eq!(
+ client
+ .send("Browser.getVersion", json!({}))
+ .unwrap()
+ .await
+ .unwrap(),
+ json!({"product": "FakeChrome"})
+ );
+ client.close().unwrap();
+ assert!(client.process_status().is_some());
+ assert_eq!(std::fs::read(&capture).unwrap(), expected);
+ std::fs::remove_file(capture).unwrap();
+ }
+
+ #[cfg(target_os = "linux")]
+ #[test]
+ fn launcher_spawn_error_closes_every_pipe_descriptor() {
+ const ISOLATED_CHECK: &str = "BROWSER_CDP_FD_LEAK_CHECK";
+
+ fn descriptor_count() -> usize {
+ std::fs::read_dir("/proc/self/fd").unwrap().count()
+ }
+
+ if std::env::var_os(ISOLATED_CHECK).is_some() {
+ let before = descriptor_count();
+ let mut command = Command::new("/definitely/not/a/chrome/executable");
+ let error = CdpClient::launch_pipe(&mut command).unwrap_err();
+ assert!(matches!(error, CdpError::Transport(_)));
+ assert_eq!(descriptor_count(), before);
+ return;
+ }
+
+ let output = Command::new(std::env::current_exe().unwrap())
+ .args([
+ "--exact",
+ "unix::launcher_spawn_error_closes_every_pipe_descriptor",
+ ])
+ .env(ISOLATED_CHECK, "1")
+ .output()
+ .unwrap();
+ assert!(
+ output.status.success(),
+ "isolated descriptor check failed:\n{}\n{}",
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr)
+ );
+ }
+
+ #[tokio::test]
+ async fn websocket_routes_root_and_session_messages_and_closes() {
+ use futures::{SinkExt, StreamExt};
+ use tokio::net::TcpListener;
+ use tokio_tungstenite::{accept_async, tungstenite::Message};
+
+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let address = listener.local_addr().unwrap();
+ let server = tokio::spawn(async move {
+ let (stream, _) = listener.accept().await.unwrap();
+ let mut socket = accept_async(stream).await.unwrap();
+ let root: Value =
+ serde_json::from_str(socket.next().await.unwrap().unwrap().to_text().unwrap())
+ .unwrap();
+ let page: Value =
+ serde_json::from_str(socket.next().await.unwrap().unwrap().to_text().unwrap())
+ .unwrap();
+ assert_eq!(
+ root,
+ json!({"id": 1, "method": "Browser.getVersion", "params": {}})
+ );
+ assert_eq!(page["sessionId"], "page-ws");
+ socket
+ .send(Message::Text(
+ json!({"method": "Page.loadEventFired", "params": {}, "sessionId": "page-ws"})
+ .to_string()
+ .into(),
+ ))
+ .await
+ .unwrap();
+ socket
+ .send(Message::Text(
+ json!({"id": 2, "result": {"frameTree": "ws"}, "sessionId": "page-ws"})
+ .to_string()
+ .into(),
+ ))
+ .await
+ .unwrap();
+ socket
+ .send(Message::Text(
+ json!({"id": 1, "result": {"product": "WebSocketChrome"}})
+ .to_string()
+ .into(),
+ ))
+ .await
+ .unwrap();
+ matches!(socket.next().await, Some(Ok(Message::Close(_))))
+ });
+
+ let client =
+ CdpClient::connect_websocket_url(&format!("ws://{address}/devtools/browser/fake"))
+ .await
+ .unwrap();
+ let page = client.session("page-ws");
+ let mut page_events = page.subscribe();
+ let root_call = client.send("Browser.getVersion", json!({})).unwrap();
+ let page_call = page.send("Page.getFrameTree", json!({})).unwrap();
+ let (root, frame) = tokio::join!(root_call, page_call);
+ assert_eq!(root.unwrap(), json!({"product": "WebSocketChrome"}));
+ assert_eq!(frame.unwrap(), json!({"frameTree": "ws"}));
+ assert_eq!(
+ page_events.recv().await.unwrap().method,
+ "Page.loadEventFired"
+ );
+ client.close().unwrap();
+ assert!(server.await.unwrap());
+ }
+
+ #[tokio::test]
+ async fn websocket_rejects_non_cdp_schemes_before_connecting() {
+ let error = CdpClient::connect_websocket_url("http://127.0.0.1/devtools/browser/id")
+ .await
+ .unwrap_err();
+ assert!(matches!(error, CdpError::UnsupportedTransport(_)));
+ assert!(error.to_string().contains("ws:// or wss://"));
+
+ let error = CdpClient::connect_websocket_url("wss://127.0.0.1:1/devtools/browser/id")
+ .await
+ .unwrap_err();
+ assert!(matches!(error, CdpError::Transport(_)));
+ }
+}
diff --git a/browser/tests/corpus/basic.html b/browser/tests/corpus/basic.html
new file mode 100644
index 000000000..a347e2bc2
--- /dev/null
+++ b/browser/tests/corpus/basic.html
@@ -0,0 +1 @@
+<html><head></head><body><h1 class="t">Hello</h1><ul><li><a href="/a">Apple</a></li><li><a href="/b">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>
diff --git a/browser/tests/corpus/browser_visual.html b/browser/tests/corpus/browser_visual.html
new file mode 100644
index 000000000..c8374b179
--- /dev/null
+++ b/browser/tests/corpus/browser_visual.html
@@ -0,0 +1,8 @@
+<!doctype html><html><head><meta charset="utf-8"><style>
+html,body{margin:0;padding:0}
+.a{height:360px;background:#123456}
+.b{height:360px;background:#f08020}
+.c{height:360px;background:#20a060}
+.d{height:360px;background:#8030c0}
+.e{height:360px;background:#e0d040}
+</style></head><body><div class="a"></div><div class="b"></div><div class="c"></div><div class="d"></div><div class="e"></div></body></html>
diff --git a/browser/tests/corpus/edge.html b/browser/tests/corpus/edge.html
new file mode 100644
index 000000000..e0c38bef3
--- /dev/null
+++ b/browser/tests/corpus/edge.html
@@ -0,0 +1,17 @@
+<html><head></head><body>
+<div id="wrap" class="outer main">
+ <span>CONDITION: <!-- separator -->Excellent</span>
+ <p> <b>bold</b>after-bold</p>
+ <p>lead<b>mid</b>tail</p>
+ <ul><li>one</li><li>two</li><li>three</li></ul>
+ <a href="/x?a=1&b=2" data-price="10">A&B</a>
+ <input disabled type="text">
+ <script>var hidden = "never";</script>
+ <style>.x { display: none; }</style>
+ <p class="uni">Ünïcode — café</p>
+ <textarea> </textarea>
+ <div>line one
+and two <b>x</b></div>
+ <div data-x="1">line oneand two <b>y</b></div>
+</div>
+</body></html>
diff --git a/browser/tests/corpus/messy.html b/browser/tests/corpus/messy.html
new file mode 100644
index 000000000..7bd4716d6
--- /dev/null
+++ b/browser/tests/corpus/messy.html
@@ -0,0 +1,19 @@
+<html><head><title>Messy Page</title><meta charset="utf-8"></head><body>
+<nav><ul><li><a href="/home">Home</a></li><li><a href="/about">About</a></li></ul></nav>
+<template><p>never render this</p></template>
+<div aria-hidden="true">screen-reader trap</div>
+<div style="display:none">hidden A</div>
+<div style="visibility: hidden">hidden B</div>
+<main>
+ <h1>Widget Review</h1>
+ <p>Intro paragraph with <em>emphasis</em> and a <a href="/w/1">link</a>.</p>
+ <h2>Specs</h2>
+ <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>
+ <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>
+ <div class="card" data-id="1"><h3>Card One</h3><p>first card</p></div>
+ <div class="card" data-id="2"><h3>Card Two</h3><p>second card</p></div>
+ <div class="card wide" data-id="3"><h3>Card Three</h3><p>third card</p></div>
+</main>
+<footer><p>© 2026 Example — <span style="font-size:0">invisible</span>fine print</p></footer>
+<script>analytics()</script>
+</body></html>
diff --git a/browser/tests/cssselect_compat.rs b/browser/tests/cssselect_compat.rs
new file mode 100644
index 000000000..b0941ded2
--- /dev/null
+++ b/browser/tests/cssselect_compat.rs
@@ -0,0 +1,29 @@
+use cssselect::HtmlTranslator;
+
+#[test]
+fn scrapling_pseudo_elements_translate_to_xpath() {
+ let translator = HtmlTranslator::new();
+ for (css, xpath) in [
+ ("a::text", "descendant-or-self::a/text()"),
+ (
+ "a ::text",
+ "descendant-or-self::a/descendant-or-self::text()",
+ ),
+ ("::text", "descendant-or-self::text()"),
+ ("a::attr(href)", "descendant-or-self::a/@href"),
+ (
+ "a ::attr(href)",
+ "descendant-or-self::a/descendant-or-self::*/@href",
+ ),
+ (
+ "h1 + p::text",
+ "descendant-or-self::h1/following-sibling::*[(self::p) and (position() = 1)]/text()",
+ ),
+ (
+ "h1 ~ p::attr(data-x)",
+ "descendant-or-self::h1/following-sibling::p/@data-x",
+ ),
+ ] {
+ assert_eq!(translator.css_to_xpath(css).unwrap(), xpath, "{css}");
+ }
+}
diff --git a/browser/tests/e2e/.gitignore b/browser/tests/e2e/.gitignore
new file mode 100644
index 000000000..5010da0b5
--- /dev/null
+++ b/browser/tests/e2e/.gitignore
@@ -0,0 +1,16 @@
+node_modules/
+dist/
+reports/*.log
+reports/report.json
+reports/config.runtime.yaml
+reports/browser.runtime.json
+reports/elements.db
+!reports/.gitkeep
+# The engine's builtin `configuration` worker persists any config it
+# resolves through its fs adapter to `./config/<id>.yaml`, relative to CWD
+# (engine/src/workers/configuration/adapters/fs.rs's DEFAULT_DIRECTORY, in
+# the iii engine repo) — observed locally for `iii-observability`.
+# run-tests.sh removes this directory before each run; ignore it too in case
+# a run is interrupted before that cleanup fires on the next one.
+/config/
+.DS_Store
diff --git a/browser/tests/e2e/README.md b/browser/tests/e2e/README.md
new file mode 100644
index 000000000..c9b0883f4
--- /dev/null
+++ b/browser/tests/e2e/README.md
@@ -0,0 +1,169 @@
+# browser worker — end-to-end harness
+
+Self-asserting smoke harness for the `browser` worker. Validates
+all 10 native `browser::*` parse functions (extract, css, xpath, regex, find,
+find-by-text, find-by-regex, find-similar, describe, to-markdown) over the
+real iii bus — worker built and run as a real binary, engine as a real
+process, harness as a real WebSocket client — plus adaptive/XPath compatibility,
+outbound policy errors, browser rendering/screenshots, crawl validation, and
+private HTTP/dynamic/stealthy session lifecycle.
+
+Modeled on `database/tests/e2e/` in this repo, trimmed for this worker: it needs
+no database driver or dialect matrix. Most parse cases are stateless; the
+adaptive case exercises the worker-managed SQLite path. No Docker service or
+application schema is required.
+
+Runs locally and in CI (`.github/workflows/browser-scrapling-e2e.yml`).
+
+## Prerequisites
+
+- Rust toolchain (`cargo` on `$PATH`)
+- Node.js 20+ (`npm` on `$PATH`)
+- The iii engine on `$PATH`. Install with:
+ ```sh
+ curl -fsSL https://install.iii.dev/iii/main/install.sh | sh
+ ```
+ The script drops the binary at `$HOME/.local/bin/iii` (override with
+ `BIN_DIR=...` or `PREFIX=...`).
+
+## IMPORTANT: port isolation
+
+**Do not run this suite against a stack that has another browser worker
+registered.** Python uses distinct `scrapling::*` ids; this native worker uses
+root `browser::*` ids. A second browser worker at the same ids can still win
+dispatch and silently test the wrong implementation.
+
+For that reason this suite does **not** default to the iii engine's own
+default port (49134), which a local dev stack commonly already occupies.
+`config.yaml` overrides `iii-worker-manager`'s (the engine's own builtin
+WebSocket-listener worker) `port` to **49234** by default. `run-tests.sh`:
+
+1. Preflights `E2E_PORT` (49234 unless overridden) and hard-fails if
+ anything is already bound there — it never kills, reconfigures, or
+ reuses another running engine.
+2. Threads `E2E_PORT` through the engine config, the worker's `--url`, and
+ the harness's `III_URL` so all three always agree.
+
+Override with `E2E_PORT=<port> ./run-tests.sh` if 49234 is also taken.
+
+There is no `--port` flag on the `iii` CLI and no `iii start` subcommand —
+the override lives entirely in config.yaml, on the builtin
+`iii-worker-manager` worker's `config.port` key (see the comment in
+`config.yaml`).
+
+## Run
+
+```sh
+./run-tests.sh # full suite
+./run-tests.sh --filter=xpath # only cases whose name contains "xpath"
+```
+
+Builds the worker (`cargo build --release --bin browser`), starts
+the engine, starts the browser worker, and runs the harness. Exits
+0 on PASS, 1 on any FAIL.
+
+### Startup order
+
+1. iii engine (`config.yaml`, booted from an untracked
+ `reports/config.runtime.yaml` copy — see "Config-rewrite dodge" below)
+2. browser worker binary (host process, `--url ws://127.0.0.1:$E2E_PORT`)
+3. Harness test suite (`npm run dev`)
+
+Neither the worker nor the harness is engine-managed; both connect over
+WebSocket like external clients. The harness writes a runtime-only worker seed
+that enables loopback and points at the downloaded frozen Chrome artifact.
+
+### Config-rewrite dodge
+
+The iii engine is known to rewrite the config file it boots from (observed
+on `database/tests/e2e/config.yaml`, a tracked file, in this repo).
+`run-tests.sh` copies `config.yaml` to the untracked
+`reports/config.runtime.yaml` at startup and points `iii -c` at that copy,
+so a local run never dirties the tracked config. Verify with `git status`
+after a run.
+
+## Flags
+
+| Flag | Effect |
+|---|---|
+| `--keep` | Leave the engine + worker running after the run (debugging) |
+| `--no-build` | Skip the cargo build step |
+| `--filter=X` | Run only harness cases whose name contains `X` (substring match) |
+| `-h`, `--help` | Print usage |
+
+## Env overrides
+
+The script auto-detects paths relative to its own location, but each can be
+overridden:
+
+| Var | Default | Purpose |
+|---|---|---|
+| `E2E_PORT` | `49234` | Engine WebSocket port — see "port isolation" above |
+| `WORKER_SRC` | `../..` (the `browser/` crate) | Where to `cargo build` |
+| `III_BIN` | `$(command -v iii)` then `$HOME/.local/bin/iii` | Engine binary |
+| `WORKER_BIN_TARGET` | `$WORKER_SRC/target/release/browser` | Built worker |
+| `HARNESS_TIMEOUT` | `120` | Seconds to wait for the harness sentinel |
+
+## Layout
+
+| File | Role |
+|---|---|
+| `run-tests.sh` | Orchestrator |
+| `config.yaml` | Engine infra only (worker-manager port override + observability) |
+| `workers/harness/` | TypeScript smoke-test worker (runs as a host process) |
+| `workers/harness/src/cases.ts` | The 27 base cases; parse expectations come from `../../../../tests/golden/behavior/**`, while outbound cases exercise hermetic validation/state paths |
+| `workers/harness/src/cases-hardening.ts` | 18 hardening-feature cases (SSRF v6 embeds, egress gate, redirects/cookies, safe-mode policy, CDP child targets, parse parity fixes, session capacity, config hot-apply, crawl IDN); its header documents the internals that are unit-test-only by necessity |
+| `workers/harness/src/runner.ts` | Runs the cases, records pass/fail, writes `reports/report.json` |
+| `workers/harness/src/worker.ts` | Entry point; registers with the bus, emits the `HARNESS_DONE` sentinel |
+| `reports/report.json` | Per-case results (latest run) |
+
+## Cases
+
+The suite currently contains 45 cases: 27 base cases (ten parse-function
+examples, adaptive and XPath compatibility, limit/error cases, outbound
+security policy, crawl validation, and a private HTTP-session lifecycle) plus
+18 hardening-feature cases in `cases-hardening.ts` (one per wire-observable
+fix from the hardening pass, including three configuration-mutating cases that
+restore the `browser` configuration entry in `finally`). The authoritative
+names and assertions live in `workers/harness/src/cases.ts` and
+`cases-hardening.ts`; keep this summary grouped so it does not become a second
+manually numbered source of truth.
+
+| # | Case | Asserts |
+|---|---|---|
+| 1 | `extract` mixed selector list | css/xpath precedence, regex short-circuit, `attr`, `html`, `all` |
+| 2 | `css` first + attr | `first` scalar result, `attr` pulls an attribute over text |
+| 3 | `xpath` positional predicate | `//li[2]/a`, first, text |
+| 4 | `regex` first capture group | `first: true` returns the group, not the whole match |
+| 5 | `find` tag + attrs | combined filter narrows to the same set as attrs alone |
+| 6 | `find-by-text` leading-text match | exact match on the leading text run |
+| 7 | `find-by-regex` leading-text pattern | case-insensitive default |
+| 8 | `find-similar` li anchor | count 2, default `{text, html}` item shape |
+| 9 | `describe` h1 | `found`, `classes`, `parent_tag`, full identity object |
+| 10 | `to-markdown` text mode | exact string (deterministic; no markdown formatting choices) |
+| 11 | `css` adaptive direct match | adaptive query succeeds without saving fixture state |
+| 12 | `css` invalid selector | error starting `Invalid CSS selector 'li:::bad':` |
+| 13 | `xpath` ancestor axis | reverse-axis positional semantics |
+| 14 | `find` limit 0 | items clamp to `[]`; `count` stays the true (pre-cap) total |
+| 15–27 | outbound/browser/session | SSRF and safe-policy errors, dynamic/stealthy rendering, screenshot wire shape, crawl delivery, HTTP cookie state, UUID session metadata, persistent browser sessions, foreign-id rejection |
+| 28–45 | hardening features | v6-embedded-v4 SSRF forms, egress-gate header forcing + 403 page, redirect clamp/refusal, hop cookie replay + hostname scoping, header flattening, duration clamps, compat-only/`real_chrome` refusals, Cloudflare solve deadline, dedicated-worker resume, `limit` coercion, `describe kind:null`, PI stripping, markdownify parity, session pending-slot rollback, `inject_guidance` hot-apply, safe-mode config-proxy omission, crawl IDN normalization |
+
+## CI
+
+The harness runs in `.github/workflows/browser-scrapling-e2e.yml` on any PR
+that touches `browser/**`. The workflow installs the engine via the
+install script (always tracks `main`, no version pin), builds the worker,
+and shells out to `./run-tests.sh`. CI runners are ephemeral, so the
+port-isolation concern above doesn't apply there — 49234 is used anyway, for
+parity with local runs.
+
+## Troubleshooting
+
+- **`port $E2E_PORT is already in use`**: something else — possibly a dev
+ engine — is bound to it. Stop it, or re-run with `E2E_PORT=<a-free-port>`.
+ This script never kills or reuses another running engine.
+- **`worker binary missing`**: run without `--no-build` once.
+- **`iii engine binary missing`**: install with the script above.
+- **browser worker did not respond**: tail
+ `reports/browser-*.log`.
+- **Sentinel timeout**: tail `reports/harness-*.log` for the harness output.
diff --git a/browser/tests/e2e/config.yaml b/browser/tests/e2e/config.yaml
new file mode 100644
index 000000000..892c4f41f
--- /dev/null
+++ b/browser/tests/e2e/config.yaml
@@ -0,0 +1,38 @@
+# iii engine configuration — passed via `iii -c` (through run-tests.sh's
+# untracked reports/config.runtime.yaml copy; see the comment in
+# run-tests.sh for why it isn't booted from this tracked file directly).
+#
+# Infrastructure workers only. `iii-worker-manager` is the builtin worker
+# that owns the engine's WebSocket listener (engine/src/workers/worker/mod.rs
+# in the iii engine repo); its `port` is overridden to ${E2E_PORT:49234} —
+# NOT the iii default of 49134 — so this suite never shares a port (and
+# therefore never risks sharing root browser::* function registrations) with a
+# locally running dev engine. The Python worker uses distinct scrapling::* ids;
+# another browser worker at the same browser::* ids would silently test the
+# wrong implementation.
+#
+# run-tests.sh exports E2E_PORT (default 49234) before starting the engine;
+# override with `E2E_PORT=<port> ./run-tests.sh` if 49234 is also taken.
+# `:49234` (no dash) is the iii engine's own config templating syntax
+# (EngineConfig::expand_env_vars), not bash's — it's only a fallback for
+# anyone booting this file directly with `iii -c config.yaml`, bypassing
+# run-tests.sh's own preflight port check.
+#
+# The browser worker and harness are NOT registered here.
+# run-tests.sh:
+# 1. starts this engine
+# 2. spawns the browser binary as a host process (--url ws://…)
+# 3. runs the harness test suite
+
+workers:
+ - name: iii-worker-manager
+ config:
+ port: ${E2E_PORT:49234}
+
+ - name: iii-observability
+ config:
+ enabled: true
+ service_name: browser-tests
+ exporter: memory
+ logs_console_output: true
+ sampling_ratio: 1.0
diff --git a/browser/tests/e2e/reports/.gitkeep b/browser/tests/e2e/reports/.gitkeep
new file mode 100644
index 000000000..e69de29bb
diff --git a/browser/tests/e2e/run-tests.sh b/browser/tests/e2e/run-tests.sh
new file mode 100755
index 000000000..21a36bb0c
--- /dev/null
+++ b/browser/tests/e2e/run-tests.sh
@@ -0,0 +1,292 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Path overrides (set in CI; defaults assume the harness lives at
+# browser/tests/e2e/ inside the workers repo and the iii engine is
+# on $PATH or at $HOME/.local/bin/iii — which is where the install script
+# `curl -fsSL https://install.iii.dev/iii/main/install.sh | sh` puts it).
+WORKER_SRC="${WORKER_SRC:-$(cd "$ROOT_DIR/../.." && pwd)}"
+III_BIN="${III_BIN:-$(command -v iii 2>/dev/null || echo "$HOME/.local/bin/iii")}"
+WORKER_BIN_TARGET="${WORKER_BIN_TARGET:-$WORKER_SRC/target/release/browser}"
+
+# Port isolation. This machine commonly runs a shared dev engine on the iii
+# default port (49134) that already has a `browser` worker registered — some
+# other build, from some other worktree. Triggering against it would silently
+# test the wrong binary while reporting a pass. (The namespace rename to
+# root `browser::*` ids do not collide with the PYTHON scrapling worker's
+# `scrapling::*` ids, but "wrong build of the same
+# worker" is the sharper risk and it is not fixed by namespacing.)
+# The iii CLI has no `--port` flag
+# and no `iii start` subcommand (checked `iii --help`); the override lives in
+# config.yaml instead, on the builtin `iii-worker-manager` worker's `port`
+# key (confirmed by reading the iii engine source,
+# engine/src/workers/worker/mod.rs's `WorkerManagerConfig` — the same knob
+# `sdk/fixtures/config-test.yaml` uses there). So: default to a DIFFERENT
+# port than the iii default, and thread it through engine config, the
+# worker's --url, and the harness's III_URL.
+export E2E_PORT="${E2E_PORT:-49234}"
+
+REPORT_PATH="$ROOT_DIR/reports/report.json"
+TS=$(date +%Y%m%d-%H%M%S)
+ENGINE_LOG="$ROOT_DIR/reports/engine-$TS.log"
+WORKER_LOG="$ROOT_DIR/reports/browser-$TS.log"
+HARNESS_LOG="$ROOT_DIR/reports/harness-$TS.log"
+SENTINEL_TIMEOUT="${HARNESS_TIMEOUT:-240}"
+
+KEEP=0
+NO_BUILD=0
+FILTER=""
+
+for arg in "$@"; do
+ case "$arg" in
+ --keep) KEEP=1 ;;
+ --no-build) NO_BUILD=1 ;;
+ --filter=*) FILTER="${arg#--filter=}" ;;
+ -h|--help)
+ cat <<EOF
+Usage: $0 [--keep] [--no-build] [--filter=<case-substring>]
+
+ --keep Leave the engine + worker running after the run (debugging).
+ --no-build Skip cargo build of the browser worker.
+ --filter=X Run only harness cases whose name contains X (substring match;
+ there's no per-driver concept here).
+
+Env overrides:
+ E2E_PORT Engine WebSocket port (default: 49234 — deliberately
+ NOT the iii default of 49134, to avoid colliding with a
+ locally running dev stack that may have another
+ browser worker registered under the same browser::* ids).
+ Set to another port if 49234 is also taken.
+ WORKER_SRC Path to the browser crate (default: ../..).
+ III_BIN Path to the iii engine binary (default: \$(command -v iii) or \$HOME/.local/bin/iii).
+ WORKER_BIN_TARGET Path to the built worker binary (default: \$WORKER_SRC/target/release/browser).
+ HARNESS_TIMEOUT Seconds to wait for the harness sentinel (default: 240).
+EOF
+ exit 0
+ ;;
+ *) echo "unknown arg: $arg" >&2; exit 2 ;;
+ esac
+done
+
+ENGINE_PID=""
+WORKER_PID=""
+HARNESS_PID=""
+cleanup() {
+ local code=$?
+ if [[ -n "$HARNESS_PID" ]] && kill -0 "$HARNESS_PID" 2>/dev/null; then
+ kill "$HARNESS_PID" 2>/dev/null || true
+ wait "$HARNESS_PID" 2>/dev/null || true
+ fi
+ if [[ "$KEEP" -eq 0 && -n "$WORKER_PID" ]] && kill -0 "$WORKER_PID" 2>/dev/null; then
+ kill "$WORKER_PID" 2>/dev/null || true
+ wait "$WORKER_PID" 2>/dev/null || true
+ fi
+ if [[ "$KEEP" -eq 0 && -n "$ENGINE_PID" ]] && kill -0 "$ENGINE_PID" 2>/dev/null; then
+ kill "$ENGINE_PID" 2>/dev/null || true
+ wait "$ENGINE_PID" 2>/dev/null || true
+ fi
+ exit "$code"
+}
+trap cleanup EXIT INT TERM
+
+mkdir -p "$ROOT_DIR/reports"
+
+# 1. Port preflight — first, before the ~17s cargo build, so a bound port
+# fails fast instead of after paying for a build we'd have to abort anyway.
+# NEVER touch whatever is already listening — it may be someone's dev engine
+# (see the E2E_PORT comment above). If our target port is already bound,
+# hard-fail with a clear remediation instead of guessing whose engine it is
+# or trying to reuse it.
+if (echo > "/dev/tcp/127.0.0.1/$E2E_PORT") 2>/dev/null; then
+ echo "[run-tests] FATAL: port $E2E_PORT is already in use." >&2
+ echo "[run-tests] This suite refuses to share a port with another running engine — it may" >&2
+ echo "[run-tests] be a dev stack already running some other build of the browser worker," >&2
+ echo "[run-tests] which would silently test the wrong binary and still report a pass." >&2
+ echo "[run-tests] Stop whatever owns port $E2E_PORT, or re-run with E2E_PORT=<a-free-port>." >&2
+ exit 1
+fi
+
+# 2. Build the worker (unless --no-build)
+if [[ "$NO_BUILD" -eq 0 ]]; then
+ echo "[run-tests] cargo build --release --bin browser"
+ (cd "$WORKER_SRC" && cargo build --release --bin browser)
+fi
+if [[ ! -x "$WORKER_BIN_TARGET" ]]; then
+ echo "[run-tests] FATAL: worker binary missing at $WORKER_BIN_TARGET — run without --no-build" >&2
+ exit 1
+fi
+
+# 3. Verify engine binary
+if [[ ! -x "$III_BIN" ]]; then
+ echo "[run-tests] FATAL: iii engine binary missing at $III_BIN" >&2
+ echo "[run-tests] install with: curl -fsSL https://install.iii.dev/iii/main/install.sh | sh" >&2
+ exit 1
+fi
+
+# 4. Config-rewrite dodge. The iii engine is known to rewrite the config
+# file it boots from (observed on database/tests/e2e/config.yaml, a tracked
+# file, in this same repo). Boot from an untracked copy so a local run never
+# dirties the tracked config.
+RUNTIME_CONFIG="$ROOT_DIR/reports/config.runtime.yaml"
+cp "$ROOT_DIR/config.yaml" "$RUNTIME_CONFIG"
+
+# Browser fetchers are certified against the frozen Chrome build. Reuse a
+# caller-provided executable, otherwise verify the local artifact cache and
+# fetch it only when absent.
+if [[ -z "${SCRAPLING_CHROMIUM_EXECUTABLE:-}" ]]; then
+ CHROMIUM_OUTPUT=""
+ if ! CHROMIUM_OUTPUT=$("$WORKER_SRC/scripts/fetch_chromium_artifacts.sh" verify 2>/dev/null); then
+ CHROMIUM_OUTPUT=$("$WORKER_SRC/scripts/fetch_chromium_artifacts.sh" fetch)
+ fi
+ SCRAPLING_CHROMIUM_EXECUTABLE=$(awk -F= '/^SCRAPLING_CHROMIUM_EXECUTABLE=/{print substr($0, index($0,"=")+1)}' <<<"$CHROMIUM_OUTPUT")
+fi
+if [[ ! -x "$SCRAPLING_CHROMIUM_EXECUTABLE" ]]; then
+ echo "[run-tests] FATAL: frozen Chromium executable missing at $SCRAPLING_CHROMIUM_EXECUTABLE" >&2
+ exit 1
+fi
+
+BROWSER_CONFIG="$ROOT_DIR/reports/browser.runtime.json"
+python3 - "$BROWSER_CONFIG" "$SCRAPLING_CHROMIUM_EXECUTABLE" "$ROOT_DIR/reports/elements.db" <<'PY'
+import json, pathlib, sys
+pathlib.Path(sys.argv[1]).write_text(json.dumps({
+ "scrapling": {
+ "security_mode": "safe",
+ "chromium_executable": sys.argv[2],
+ "allow_loopback": True,
+ "adaptive_storage_path": sys.argv[3],
+ }
+}))
+PY
+
+# The engine's builtin `configuration` worker also persists any config
+# resolved through its fs adapter to ./config/<id>.yaml relative to CWD
+# (observed for `iii-observability`) — reset it so a stale value from a
+# previous run can never shadow what THIS run's config.yaml asks for.
+rm -rf "$ROOT_DIR/config"
+
+# 5. Install harness deps if needed
+if [[ ! -d "$ROOT_DIR/workers/harness/node_modules" ]]; then
+ echo "[run-tests] npm install (harness)"
+ (cd "$ROOT_DIR/workers/harness" && npm install --silent)
+fi
+
+# 6. Start the engine (from the untracked runtime config copy; see step 4).
+echo "[run-tests] starting iii engine on port $E2E_PORT"
+: > "$ENGINE_LOG"
+: > "$HARNESS_LOG"
+
+( cd "$ROOT_DIR" && "$III_BIN" --no-update-check -c "$RUNTIME_CONFIG" ) > "$ENGINE_LOG" 2>&1 &
+ENGINE_PID=$!
+echo "[run-tests] engine pid=$ENGINE_PID"
+
+# 7. Wait for the engine to accept TCP on $E2E_PORT. Probing the port
+# directly instead of grepping for an engine log line decouples this script
+# from the engine's logging format.
+deadline=$(( $(date +%s) + 30 ))
+while :; do
+ if (echo > "/dev/tcp/127.0.0.1/$E2E_PORT") 2>/dev/null; then
+ break
+ fi
+ if ! kill -0 "$ENGINE_PID" 2>/dev/null; then
+ echo "[run-tests] FATAL: engine exited before binding port; tail of engine log:" >&2
+ tail -40 "$ENGINE_LOG" >&2
+ exit 1
+ fi
+ if (( $(date +%s) > deadline )); then
+ echo "[run-tests] FATAL: engine did not bind port $E2E_PORT within 30s; tail of engine log:" >&2
+ tail -40 "$ENGINE_LOG" >&2
+ exit 1
+ fi
+ sleep 0.5
+done
+echo "[run-tests] engine listening on $E2E_PORT"
+
+# 8. Start the browser worker as a host process (not engine-managed).
+echo "[run-tests] starting browser worker"
+: > "$WORKER_LOG"
+( cd "$ROOT_DIR" && "$WORKER_BIN_TARGET" --config "$BROWSER_CONFIG" --url "ws://127.0.0.1:$E2E_PORT" ) > "$WORKER_LOG" 2>&1 &
+WORKER_PID=$!
+echo "[run-tests] browser worker pid=$WORKER_PID"
+
+# 9. Wait for browser::css to succeed (worker startup + function registration).
+deadline=$(( $(date +%s) + 30 ))
+while :; do
+ if "$III_BIN" trigger --port "$E2E_PORT" browser::css html='<p>x</p>' query='p' >/dev/null 2>&1; then
+ break
+ fi
+ if ! kill -0 "$WORKER_PID" 2>/dev/null; then
+ echo "[run-tests] FATAL: browser worker exited before becoming ready; tail of worker log:" >&2
+ tail -40 "$WORKER_LOG" >&2
+ exit 1
+ fi
+ if (( $(date +%s) > deadline )); then
+ echo "[run-tests] FATAL: browser worker did not respond within 30s; tail of worker log:" >&2
+ tail -40 "$WORKER_LOG" >&2
+ exit 1
+ fi
+ sleep 0.5
+done
+echo "[run-tests] browser worker ready"
+
+# 10. Launch the harness as a host node process
+echo "[run-tests] starting harness"
+HARNESS_ENV=()
+if [[ -n "$FILTER" ]]; then
+ HARNESS_ENV+=("HARNESS_FILTER=$FILTER")
+fi
+HARNESS_ENV+=("III_URL=ws://127.0.0.1:$E2E_PORT")
+HARNESS_ENV+=("HARNESS_REPORT_PATH=$REPORT_PATH")
+
+( cd "$ROOT_DIR/workers/harness" && env "${HARNESS_ENV[@]}" npm run --silent dev ) > "$HARNESS_LOG" 2>&1 &
+HARNESS_PID=$!
+echo "[run-tests] harness pid=$HARNESS_PID"
+
+# 11. Wait for sentinel line
+sentinel=""
+deadline=$(( $(date +%s) + SENTINEL_TIMEOUT ))
+while (( $(date +%s) < deadline )); do
+ if ! kill -0 "$HARNESS_PID" 2>/dev/null; then
+ if grep -m1 -E '^HARNESS_DONE: (PASS|FAIL) [0-9]+/[0-9]+$' "$HARNESS_LOG" >/dev/null 2>&1; then
+ sentinel=$(grep -m1 -E '^HARNESS_DONE: (PASS|FAIL) [0-9]+/[0-9]+$' "$HARNESS_LOG")
+ break
+ fi
+ echo "[run-tests] harness exited without sentinel; tail of harness log:" >&2
+ tail -40 "$HARNESS_LOG" >&2
+ exit 1
+ fi
+ if grep -m1 -E '^HARNESS_DONE: (PASS|FAIL) [0-9]+/[0-9]+$' "$HARNESS_LOG" >/dev/null 2>&1; then
+ sentinel=$(grep -m1 -E '^HARNESS_DONE: (PASS|FAIL) [0-9]+/[0-9]+$' "$HARNESS_LOG")
+ break
+ fi
+ sleep 1
+done
+
+if [[ -z "$sentinel" ]]; then
+ echo "[run-tests] FATAL: harness did not emit sentinel within ${SENTINEL_TIMEOUT}s" >&2
+ echo "[run-tests] tail of harness log:" >&2
+ tail -40 "$HARNESS_LOG" >&2
+ exit 1
+fi
+
+# 12. Print summary
+echo
+echo "======================================================================="
+echo "$sentinel"
+if [[ -f "$REPORT_PATH" ]]; then
+ python3 - "$REPORT_PATH" <<'PY' 2>/dev/null || cat "$REPORT_PATH"
+import json, sys
+data = json.load(open(sys.argv[1]))
+for r in data["results"]:
+ tag = "PASS" if r["status"] == "PASS" else "FAIL"
+ err = (" — " + r.get("error","")) if r["status"] == "FAIL" else ""
+ print(f" [{tag}] {r['case']}{err}")
+PY
+fi
+echo "======================================================================="
+
+case "$sentinel" in
+ *PASS*) exit 0 ;;
+ *) exit 1 ;;
+esac
diff --git a/browser/tests/e2e/workers/harness/package-lock.json b/browser/tests/e2e/workers/harness/package-lock.json
new file mode 100644
index 000000000..53a1d629a
--- /dev/null
+++ b/browser/tests/e2e/workers/harness/package-lock.json
@@ -0,0 +1,1126 @@
+{
+ "name": "browser-tests-harness",
+ "version": "0.1.0",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "browser-tests-harness",
+ "version": "0.1.0",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "iii-sdk": "0.11.2"
+ },
+ "devDependencies": {
+ "@types/node": "^20.0.0",
+ "tsx": "^4.0.0",
+ "typescript": "^5.4.0"
+ }
+ },
+ "node_modules/@esbuild/aix-ppc64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
+ "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "aix"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-arm": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
+ "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
+ "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
+ "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/darwin-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
+ "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/darwin-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
+ "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/freebsd-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
+ "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/freebsd-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
+ "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-arm": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
+ "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
+ "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-ia32": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
+ "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-loong64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
+ "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
+ "cpu": [
+ "loong64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-mips64el": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
+ "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
+ "cpu": [
+ "mips64el"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-ppc64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
+ "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-riscv64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
+ "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-s390x": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
+ "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
+ "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/netbsd-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
+ "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "netbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/netbsd-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
+ "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "netbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openbsd-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
+ "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openbsd-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
+ "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openharmony-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
+ "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/sunos-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
+ "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "sunos"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-arm64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
+ "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-ia32": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
+ "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-x64": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
+ "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@opentelemetry/api": {
+ "version": "1.9.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.1.tgz",
+ "integrity": "sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==",
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=8.0.0"
+ }
+ },
+ "node_modules/@opentelemetry/api-logs": {
+ "version": "0.57.2",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/api-logs/-/api-logs-0.57.2.tgz",
+ "integrity": "sha512-uIX52NnTM0iBh84MShlpouI7UKqkZ7MrUszTmaypHBu4r7NofznSnQRfJ+uUeDtQDj6w8eFGg5KBLDAwAPz1+A==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/api": "^1.3.0"
+ },
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/@opentelemetry/context-async-hooks": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/context-async-hooks/-/context-async-hooks-1.30.1.tgz",
+ "integrity": "sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA==",
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.0.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/core": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/core/-/core-1.30.1.tgz",
+ "integrity": "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/semantic-conventions": "1.28.0"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.0.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/core/node_modules/@opentelemetry/semantic-conventions": {
+ "version": "1.28.0",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz",
+ "integrity": "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==",
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/@opentelemetry/instrumentation": {
+ "version": "0.57.2",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/instrumentation/-/instrumentation-0.57.2.tgz",
+ "integrity": "sha512-BdBGhQBh8IjZ2oIIX6F2/Q3LKm/FDDKi6ccYKcBTeilh6SNdNKveDOLk73BkSJjQLJk6qe4Yh+hHw1UPhCDdrg==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/api-logs": "0.57.2",
+ "@types/shimmer": "^1.2.0",
+ "import-in-the-middle": "^1.8.1",
+ "require-in-the-middle": "^7.1.1",
+ "semver": "^7.5.2",
+ "shimmer": "^1.2.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": "^1.3.0"
+ }
+ },
+ "node_modules/@opentelemetry/otlp-transformer": {
+ "version": "0.57.2",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/otlp-transformer/-/otlp-transformer-0.57.2.tgz",
+ "integrity": "sha512-48IIRj49gbQVK52jYsw70+Jv+JbahT8BqT2Th7C4H7RCM9d0gZ5sgNPoMpWldmfjvIsSgiGJtjfk9MeZvjhoig==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/api-logs": "0.57.2",
+ "@opentelemetry/core": "1.30.1",
+ "@opentelemetry/resources": "1.30.1",
+ "@opentelemetry/sdk-logs": "0.57.2",
+ "@opentelemetry/sdk-metrics": "1.30.1",
+ "@opentelemetry/sdk-trace-base": "1.30.1",
+ "protobufjs": "^7.3.0"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": "^1.3.0"
+ }
+ },
+ "node_modules/@opentelemetry/propagator-b3": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-b3/-/propagator-b3-1.30.1.tgz",
+ "integrity": "sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/core": "1.30.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.0.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/propagator-jaeger": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-jaeger/-/propagator-jaeger-1.30.1.tgz",
+ "integrity": "sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/core": "1.30.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.0.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/resources": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-1.30.1.tgz",
+ "integrity": "sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/core": "1.30.1",
+ "@opentelemetry/semantic-conventions": "1.28.0"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.0.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/resources/node_modules/@opentelemetry/semantic-conventions": {
+ "version": "1.28.0",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz",
+ "integrity": "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==",
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/@opentelemetry/sdk-logs": {
+ "version": "0.57.2",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-logs/-/sdk-logs-0.57.2.tgz",
+ "integrity": "sha512-TXFHJ5c+BKggWbdEQ/inpgIzEmS2BGQowLE9UhsMd7YYlUfBQJ4uax0VF/B5NYigdM/75OoJGhAV3upEhK+3gg==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/api-logs": "0.57.2",
+ "@opentelemetry/core": "1.30.1",
+ "@opentelemetry/resources": "1.30.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.4.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/sdk-metrics": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-metrics/-/sdk-metrics-1.30.1.tgz",
+ "integrity": "sha512-q9zcZ0Okl8jRgmy7eNW3Ku1XSgg3sDLa5evHZpCwjspw7E8Is4K/haRPDJrBcX3YSn/Y7gUvFnByNYEKQNbNog==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/core": "1.30.1",
+ "@opentelemetry/resources": "1.30.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.3.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/sdk-trace-base": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-1.30.1.tgz",
+ "integrity": "sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/core": "1.30.1",
+ "@opentelemetry/resources": "1.30.1",
+ "@opentelemetry/semantic-conventions": "1.28.0"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.0.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/sdk-trace-base/node_modules/@opentelemetry/semantic-conventions": {
+ "version": "1.28.0",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz",
+ "integrity": "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==",
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/@opentelemetry/sdk-trace-node": {
+ "version": "1.30.1",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-node/-/sdk-trace-node-1.30.1.tgz",
+ "integrity": "sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/context-async-hooks": "1.30.1",
+ "@opentelemetry/core": "1.30.1",
+ "@opentelemetry/propagator-b3": "1.30.1",
+ "@opentelemetry/propagator-jaeger": "1.30.1",
+ "@opentelemetry/sdk-trace-base": "1.30.1",
+ "semver": "^7.5.2"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "peerDependencies": {
+ "@opentelemetry/api": ">=1.0.0 <1.10.0"
+ }
+ },
+ "node_modules/@opentelemetry/semantic-conventions": {
+ "version": "1.43.0",
+ "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.43.0.tgz",
+ "integrity": "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg==",
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/@protobufjs/aspromise": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+ "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@protobufjs/base64": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+ "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@protobufjs/codegen": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.5.tgz",
+ "integrity": "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@protobufjs/eventemitter": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.1.tgz",
+ "integrity": "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@protobufjs/fetch": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.1.tgz",
+ "integrity": "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==",
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@protobufjs/aspromise": "^1.1.1"
+ }
+ },
+ "node_modules/@protobufjs/float": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+ "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@protobufjs/path": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+ "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@protobufjs/pool": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+ "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@protobufjs/utf8": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.2.tgz",
+ "integrity": "sha512-b1UQwcEZ4yCnMCD8DAL1VlbvBJE9/IX4FTIp7BG1xYpf29SLazLSrqUkj4w7Y5y7cCVP6E5tcqqcI0xemPkHug==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/@types/node": {
+ "version": "20.19.43",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.43.tgz",
+ "integrity": "sha512-6oYBAi5ikg4Pl+kGsoYtawUMBT2zZMCvPNF7pVLnHZfd1zf38DRiWn/gT01RYCdUqkv7Fhr+C9ot4/tb+2sVvA==",
+ "license": "MIT",
+ "dependencies": {
+ "undici-types": "~6.21.0"
+ }
+ },
+ "node_modules/@types/shimmer": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/@types/shimmer/-/shimmer-1.2.0.tgz",
+ "integrity": "sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg==",
+ "license": "MIT"
+ },
+ "node_modules/acorn": {
+ "version": "8.18.0",
+ "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.18.0.tgz",
+ "integrity": "sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ==",
+ "license": "MIT",
+ "bin": {
+ "acorn": "bin/acorn"
+ },
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/acorn-import-attributes": {
+ "version": "1.9.5",
+ "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
+ "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
+ "license": "MIT",
+ "peerDependencies": {
+ "acorn": "^8"
+ }
+ },
+ "node_modules/cjs-module-lexer": {
+ "version": "1.4.3",
+ "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz",
+ "integrity": "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==",
+ "license": "MIT"
+ },
+ "node_modules/debug": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+ "license": "MIT",
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/es-errors": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+ "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/esbuild": {
+ "version": "0.28.2",
+ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
+ "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "bin": {
+ "esbuild": "bin/esbuild"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "optionalDependencies": {
+ "@esbuild/aix-ppc64": "0.28.2",
+ "@esbuild/android-arm": "0.28.2",
+ "@esbuild/android-arm64": "0.28.2",
+ "@esbuild/android-x64": "0.28.2",
+ "@esbuild/darwin-arm64": "0.28.2",
+ "@esbuild/darwin-x64": "0.28.2",
+ "@esbuild/freebsd-arm64": "0.28.2",
+ "@esbuild/freebsd-x64": "0.28.2",
+ "@esbuild/linux-arm": "0.28.2",
+ "@esbuild/linux-arm64": "0.28.2",
+ "@esbuild/linux-ia32": "0.28.2",
+ "@esbuild/linux-loong64": "0.28.2",
+ "@esbuild/linux-mips64el": "0.28.2",
+ "@esbuild/linux-ppc64": "0.28.2",
+ "@esbuild/linux-riscv64": "0.28.2",
+ "@esbuild/linux-s390x": "0.28.2",
+ "@esbuild/linux-x64": "0.28.2",
+ "@esbuild/netbsd-arm64": "0.28.2",
+ "@esbuild/netbsd-x64": "0.28.2",
+ "@esbuild/openbsd-arm64": "0.28.2",
+ "@esbuild/openbsd-x64": "0.28.2",
+ "@esbuild/openharmony-arm64": "0.28.2",
+ "@esbuild/sunos-x64": "0.28.2",
+ "@esbuild/win32-arm64": "0.28.2",
+ "@esbuild/win32-ia32": "0.28.2",
+ "@esbuild/win32-x64": "0.28.2"
+ }
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/function-bind": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+ "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/hasown": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+ "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+ "license": "MIT",
+ "dependencies": {
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/iii-sdk": {
+ "version": "0.11.2",
+ "resolved": "https://registry.npmjs.org/iii-sdk/-/iii-sdk-0.11.2.tgz",
+ "integrity": "sha512-S8/o53j1z+IOU6Mp1f3GbivJ59hEgWhtT6hNutVpfwhJK5Q9zS2rV2LUX1Ko6+xF/Zr3Y6xodNRmBRng0qiZZA==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "@opentelemetry/api": "^1.9.0",
+ "@opentelemetry/api-logs": "^0.57.0",
+ "@opentelemetry/core": "^1.30.0",
+ "@opentelemetry/instrumentation": "^0.57.0",
+ "@opentelemetry/otlp-transformer": "^0.57.0",
+ "@opentelemetry/resources": "^1.30.0",
+ "@opentelemetry/sdk-logs": "^0.57.0",
+ "@opentelemetry/sdk-metrics": "^1.30.0",
+ "@opentelemetry/sdk-trace-base": "^1.30.0",
+ "@opentelemetry/sdk-trace-node": "^1.30.0",
+ "@opentelemetry/semantic-conventions": "^1.28.0",
+ "ws": "^8.18.3"
+ }
+ },
+ "node_modules/import-in-the-middle": {
+ "version": "1.15.0",
+ "resolved": "https://registry.npmjs.org/import-in-the-middle/-/import-in-the-middle-1.15.0.tgz",
+ "integrity": "sha512-bpQy+CrsRmYmoPMAE/0G33iwRqwW4ouqdRg8jgbH3aKuCtOc8lxgmYXg2dMM92CRiGP660EtBcymH/eVUpCSaA==",
+ "license": "Apache-2.0",
+ "dependencies": {
+ "acorn": "^8.14.0",
+ "acorn-import-attributes": "^1.9.5",
+ "cjs-module-lexer": "^1.2.2",
+ "module-details-from-path": "^1.0.3"
+ }
+ },
+ "node_modules/is-core-module": {
+ "version": "2.16.2",
+ "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz",
+ "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==",
+ "license": "MIT",
+ "dependencies": {
+ "hasown": "^2.0.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/long": {
+ "version": "5.3.2",
+ "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+ "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+ "license": "Apache-2.0"
+ },
+ "node_modules/module-details-from-path": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/module-details-from-path/-/module-details-from-path-1.0.4.tgz",
+ "integrity": "sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w==",
+ "license": "MIT"
+ },
+ "node_modules/ms": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "license": "MIT"
+ },
+ "node_modules/path-parse": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+ "license": "MIT"
+ },
+ "node_modules/protobufjs": {
+ "version": "7.6.5",
+ "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.6.5.tgz",
+ "integrity": "sha512-/FPD0nUc9jH6rfFjji9IBqOz4pcSE3CsT1m7Ep6Mdb0LxSUMj8hgl6GomOvZzpNpAqqGaXA0P3VSrZLFzIhQrw==",
+ "hasInstallScript": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@protobufjs/aspromise": "^1.1.2",
+ "@protobufjs/base64": "^1.1.2",
+ "@protobufjs/codegen": "^2.0.5",
+ "@protobufjs/eventemitter": "^1.1.1",
+ "@protobufjs/fetch": "^1.1.1",
+ "@protobufjs/float": "^1.0.2",
+ "@protobufjs/path": "^1.1.2",
+ "@protobufjs/pool": "^1.1.0",
+ "@protobufjs/utf8": "^1.1.1",
+ "@types/node": ">=13.7.0",
+ "long": "^5.3.2"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ }
+ },
+ "node_modules/require-in-the-middle": {
+ "version": "7.5.2",
+ "resolved": "https://registry.npmjs.org/require-in-the-middle/-/require-in-the-middle-7.5.2.tgz",
+ "integrity": "sha512-gAZ+kLqBdHarXB64XpAe2VCjB7rIRv+mU8tfRWziHRJ5umKsIHN2tLLv6EtMw7WCdP19S0ERVMldNvxYCHnhSQ==",
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.3.5",
+ "module-details-from-path": "^1.0.3",
+ "resolve": "^1.22.8"
+ },
+ "engines": {
+ "node": ">=8.6.0"
+ }
+ },
+ "node_modules/resolve": {
+ "version": "1.22.12",
+ "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+ "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "is-core-module": "^2.16.1",
+ "path-parse": "^1.0.7",
+ "supports-preserve-symlinks-flag": "^1.0.0"
+ },
+ "bin": {
+ "resolve": "bin/resolve"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/semver": {
+ "version": "7.8.5",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+ "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/shimmer": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/shimmer/-/shimmer-1.2.1.tgz",
+ "integrity": "sha512-sQTKC1Re/rM6XyFM6fIAGHRPVGvyXfgzIDvzoq608vM+jeyVD0Tu1E6Np0Kc2zAIFWIj963V2800iF/9LPieQw==",
+ "license": "BSD-2-Clause"
+ },
+ "node_modules/supports-preserve-symlinks-flag": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+ "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/tsx": {
+ "version": "4.23.11",
+ "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.11.tgz",
+ "integrity": "sha512-Ry2oTEUnhBdeEdWIztY8kf3/nBGnPnjMLVGL0YfdRXMORuPER5NlKmayqxtxRxwB1xBN+RivRaJfe7PM1rtiyw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "esbuild": "~0.28.0"
+ },
+ "bin": {
+ "tsx": "dist/cli.mjs"
+ },
+ "engines": {
+ "node": ">=18.0.0"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.3"
+ }
+ },
+ "node_modules/typescript": {
+ "version": "5.9.3",
+ "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+ "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "bin": {
+ "tsc": "bin/tsc",
+ "tsserver": "bin/tsserver"
+ },
+ "engines": {
+ "node": ">=14.17"
+ }
+ },
+ "node_modules/undici-types": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+ "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+ "license": "MIT"
+ },
+ "node_modules/ws": {
+ "version": "8.21.3",
+ "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.3.tgz",
+ "integrity": "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=10.0.0"
+ },
+ "peerDependencies": {
+ "bufferutil": "^4.0.1",
+ "utf-8-validate": ">=5.0.2"
+ },
+ "peerDependenciesMeta": {
+ "bufferutil": {
+ "optional": true
+ },
+ "utf-8-validate": {
+ "optional": true
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/e2e/workers/harness/package.json b/browser/tests/e2e/workers/harness/package.json
new file mode 100644
index 000000000..e310fd5b8
--- /dev/null
+++ b/browser/tests/e2e/workers/harness/package.json
@@ -0,0 +1,20 @@
+{
+ "name": "browser-tests-harness",
+ "version": "0.1.0",
+ "type": "module",
+ "private": true,
+ "description": "Self-asserting smoke harness for the iii browser worker.",
+ "scripts": {
+ "dev": "tsx src/worker.ts",
+ "build": "tsc"
+ },
+ "dependencies": {
+ "iii-sdk": "0.11.2"
+ },
+ "devDependencies": {
+ "@types/node": "^20.0.0",
+ "tsx": "^4.0.0",
+ "typescript": "^5.4.0"
+ },
+ "license": "Apache-2.0"
+}
diff --git a/browser/tests/e2e/workers/harness/src/cases-hardening.ts b/browser/tests/e2e/workers/harness/src/cases-hardening.ts
new file mode 100644
index 000000000..2c1e3d6aa
--- /dev/null
+++ b/browser/tests/e2e/workers/harness/src/cases-hardening.ts
@@ -0,0 +1,550 @@
+/**
+ * E2E coverage for the scrapling-native hardening pass: one case per feature
+ * that is observable over the iii bus. Expected error strings are pinned
+ * full-length against the live worker (expectError is full-string equality).
+ *
+ * Deliberately NOT covered here — no wire-observable behavior exists, each is
+ * certified by unit tests in the worker crate instead:
+ * - chromiumoxide log filter (src/logging.rs): needs protocol-skew frames the
+ * frozen CI Chromium may never emit
+ * - CDP per-command 180s ceiling and Lagged-recoverable/broadcast sizing
+ * (src/scrapling/cdp.rs): internal, and 180s exceeds the suite budget
+ * - retry-delay 60s cap timing (raw_browser.rs): only a timing side channel
+ * - target-close-on-error leak fixes (raw_browser.rs): no external counter
+ * - sessions insertion_order pruning (sessions.rs): filtered out of
+ * session-list; the capacity path it protects is covered below
+ * - OOPIF iframe HTML: main-frame-only serialization by design, and same-host
+ * ports are same-site so no OOPIF forms locally; the route_child_targets
+ * fix is covered via the dedicated-Web-Worker case instead
+ */
+
+import { expect, expectEqual, expectError, type CaseContext, type TestCase } from './cases.ts'
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
+
+type Call = CaseContext['call']
+
+async function getBrowserConfig(call: Call): Promise<any> {
+ const got = await call('configuration::get', { id: 'browser' })
+ return got.value
+}
+
+async function setBrowserConfig(call: Call, value: unknown): Promise<void> {
+ await call('configuration::set', { id: 'browser', value })
+}
+
+async function guidanceTriggerVisible(call: Call): Promise<boolean> {
+ const listed = await call('engine::registered-triggers::list', { include_internal: true })
+ return (listed.registered_triggers ?? []).some(
+ (t: any) =>
+ t.trigger_type === 'harness::hook::pre-generate' && t.function_id === 'browser::inject-guidance',
+ )
+}
+
+async function pollUntil(cond: () => Promise<boolean>, label: string, timeoutMs = 10_000): Promise<void> {
+ const deadline = Date.now() + timeoutMs
+ while (Date.now() < deadline) {
+ if (await cond()) return
+ await sleep(200)
+ }
+ throw new Error(`timed out waiting for ${label}`)
+}
+
+// Five matches for the limit-coercion case; count must stay the pre-cap total.
+const LIMIT_HTML = '<html><body><ul><li>a</li><li>b</li><li>c</li><li>d</li><li>e</li></ul></body></html>'
+
+export const HARDENING_CASES: TestCase[] = [
+ {
+ // NAT64/6to4/IPv4-compatible IPv6 literals embed a v4 address that must
+ // run the v4 blocklist. Loopback embeds are NOT used here: this stack
+ // sets allow_loopback=true, which legitimately admits them.
+ name: 'ssrf: v6-embedded-v4 forms run the v4 blocklist',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::fetch', { url: 'http://[64:ff9b::a9fe:a9fe]/' }),
+ 'handler error: address 64:ff9b::a9fe:a9fe is in link-local (incl. AWS metadata)',
+ 'nat64 well-known prefix embedding the metadata address',
+ )
+ await expectError(
+ () => call('browser::fetch', { url: 'http://[64:ff9b:1::1]/' }),
+ 'handler error: address 64:ff9b:1::1 is in local-use nat64 64:ff9b:1::/48',
+ 'local-use nat64 prefix is refused wholesale',
+ )
+ await expectError(
+ () => call('browser::fetch', { url: 'http://[2002:a00:1::]/' }),
+ 'handler error: address 2002:a00:1:: is in private rfc1918',
+ '6to4 prefix embedding an rfc1918 address',
+ )
+ },
+ },
+ {
+ name: 'egress gate: forces Connection: close and denies blocked addresses with a 403 page',
+ async run({ call, origin }) {
+ const echoed = await call('browser::dynamic-fetch', {
+ url: `${origin}/echo-headers`,
+ include_html: true,
+ retries: 1,
+ timeout: 8000,
+ })
+ expectEqual(echoed.status, 200, 'echo-headers status')
+ const connections = echoed.html.match(/"connection"/gi) ?? []
+ expectEqual(connections.length, 1, 'exactly one Connection header reaches the origin')
+ expect(/"connection","close"/i.test(echoed.html), 'the forwarded Connection header is close')
+ expect(!/proxy-connection/i.test(echoed.html), 'Proxy-Connection must be stripped')
+ expect(!/keep-alive/i.test(echoed.html), 'keep-alive must be stripped')
+ expect(
+ echoed.html.includes('"url":"/echo-headers"'),
+ 'the gate re-emits the absolute-form proxy request in origin-form',
+ )
+
+ // The gate is the whole SSRF defense for browser tiers: a blocked
+ // address is not a worker error but a 403 page Chromium renders.
+ const denied = await call('browser::dynamic-fetch', {
+ url: 'http://169.254.169.254/',
+ include_html: true,
+ retries: 1,
+ timeout: 8000,
+ })
+ expectEqual(denied.status, 403, 'gate denial status')
+ expect(
+ denied.html.includes(
+ 'browser egress denied: address 169.254.169.254 is in link-local (incl. AWS metadata)',
+ ),
+ `gate denial body missing: ${denied.html}`,
+ )
+ },
+ },
+ {
+ name: 'fetch: max_redirects refuses -1 in safe mode and clamps large values to 100',
+ async run({ call, origin }) {
+ await expectError(
+ () => call('browser::fetch', { url: `${origin}/loop`, max_redirects: -1 }),
+ 'handler error: safe mode refuses `max_redirects:-1`: unlimited or invalid redirect counts exceed the bounded request policy; use a non-negative limit',
+ 'unlimited redirects refused',
+ )
+ await expectError(
+ () => call('browser::fetch', { url: `${origin}/loop`, max_redirects: 5000, retries: 1 }),
+ `handler error: too many redirects (>100) starting at ${origin}/loop`,
+ 'redirect budget clamps to 100, not 5000',
+ )
+ const halted = await call('browser::fetch', { url: `${origin}/loop`, follow_redirects: false, retries: 1 })
+ expectEqual(halted.status, 302, 'follow_redirects:false returns the redirect itself')
+ },
+ },
+ {
+ name: 'fetch: redirect Set-Cookie replays on same-host hops only',
+ async run({ call, origin }) {
+ const hopped = await call('browser::fetch', { url: `${origin}/hop-a`, include_html: true, retries: 1 })
+ expectEqual(hopped.status, 200, 'hop status')
+ expectEqual(hopped.url, `${origin}/hop-b`, 'hop final url')
+ expect(hopped.html.includes('<p>hop=1</p>'), `redirect target did not receive the hop cookie: ${hopped.html}`)
+ expectEqual(hopped.cookies, { hop: '1' }, 'envelope accumulates hop cookies')
+
+ // 127.0.0.1 -> [::1] is the same handler on a different loopback
+ // hostname: the Cookie header must not replay, while the envelope
+ // accumulator (deliberately global across hops) still reports it.
+ const scoped = await call('browser::fetch', { url: `${origin}/hop-x`, include_html: true, retries: 1 })
+ expect(scoped.html.includes('<p>none</p>'), `cross-hostname hop leaked the cookie: ${scoped.html}`)
+ expectEqual(scoped.cookies, { hopx: '1' }, 'accumulator still reports every hop cookie')
+ },
+ },
+ {
+ name: 'fetch: repeated response headers flatten with a comma join',
+ async run({ call, origin }) {
+ const r = await call('browser::fetch', { url: `${origin}/multi-cookie`, retries: 1 })
+ expectEqual(r.headers['set-cookie'], 'a=1; Path=/, b=2; Path=/', 'set-cookie flattened')
+ expectEqual(r.headers['x-test'], 'one, two', 'x-test flattened')
+ expectEqual(r.cookies, { a: '1', b: '2' }, 'cookie map splits each set-cookie')
+ },
+ },
+ {
+ name: 'browser tiers: absurd durations clamp or refuse instead of panicking',
+ async run({ call, origin }) {
+ await expectError(
+ () => call('browser::dynamic-fetch', { url: `${origin}/page`, timeout: -1 }),
+ 'handler error: Invalid argument type: Expected `float` >= 0.0 - at `$.timeout`',
+ 'negative timeout refused with the Python-parity message',
+ )
+ // Unclamped, Duration::from_secs_f64(1e300) panics inside the handler.
+ const huge = await call('browser::dynamic-fetch', {
+ url: `${origin}/page`,
+ retry_delay: 1e300,
+ retries: 1,
+ timeout: 8000,
+ include_html: true,
+ })
+ expectEqual(huge.status, 200, 'absurd retry_delay clamps instead of panicking')
+ },
+ },
+ {
+ name: 'safe mode: compat-only options are refused with the full policy message',
+ async run({ call, origin }) {
+ const url = `${origin}/page`
+ const httpRefusals: Array<[Record<string, unknown>, string, string]> = [
+ [
+ { http3: true },
+ 'handler error: safe mode refuses `http3`: the safe reqwest engine has no certified HTTP/3 transport; use a certified compat build or remove the option',
+ 'http3',
+ ],
+ [
+ { verify: false },
+ 'handler error: safe mode refuses `verify:false`: TLS certificate verification cannot be disabled; use a certified compat build or remove the option',
+ 'verify:false',
+ ],
+ [
+ { proxies: { https: 'http://127.0.0.1:9/' } },
+ 'handler error: safe mode refuses `proxies`: per-scheme proxies bypass address pinning; use a certified compat build or remove the option',
+ 'proxies',
+ ],
+ [
+ { proxy_auth: { username: 'u', password: 'p' } },
+ 'handler error: safe mode refuses `proxy_auth`: proxy authentication is unavailable when caller proxies are refused; use a certified compat build or remove the option',
+ 'proxy_auth',
+ ],
+ [
+ { stealthy_headers: true },
+ "handler error: safe mode refuses `stealthy_headers:true`: the safe reqwest engine cannot reproduce BrowserForge's generated header fingerprint; use a certified compat build or remove the option",
+ 'stealthy_headers:true',
+ ],
+ [
+ { impersonate: 'firefox' },
+ 'handler error: safe mode refuses `impersonate`: the safe engine implements only its bounded Chrome header profile; use a certified compat build or remove the option',
+ 'impersonate',
+ ],
+ ]
+ for (const [option, expected, label] of httpRefusals) {
+ await expectError(() => call('browser::fetch', { url, ...option }), expected, `fetch ${label}`)
+ }
+ await expectError(
+ () => call('browser::dynamic-fetch', { url, dns_over_https: true }),
+ 'handler error: dns_over_https require browser.scrapling.security_mode=compat',
+ 'dynamic-fetch dns_over_https',
+ )
+ await expectError(
+ () => call('browser::session-open', { type: 'http', http3: true }),
+ 'handler error: session options require browser.scrapling.security_mode=compat; remove them or switch modes',
+ 'session-open compat-only option',
+ )
+ },
+ },
+ {
+ name: 'safe mode: real_chrome is refused on every browser tier',
+ async run({ call, origin }) {
+ const url = `${origin}/page`
+ for (const functionId of ['browser::dynamic-fetch', 'browser::stealthy-fetch', 'browser::screenshot-url']) {
+ await expectError(
+ () => call(functionId, { url, real_chrome: true }),
+ 'handler error: real_chrome require browser.scrapling.security_mode=compat',
+ `${functionId} real_chrome`,
+ )
+ }
+ await expectError(
+ () => call('browser::session-open', { type: 'dynamic', real_chrome: true }),
+ 'handler error: session options require browser.scrapling.security_mode=compat; remove them or switch modes',
+ 'session-open real_chrome',
+ )
+ // Crawl validates per page inside the fetch closure, so the refusal is
+ // an inline item error (unprefixed), not a top-level rejection.
+ const crawled = await call('browser::crawl', {
+ url,
+ fetcher: 'dynamic',
+ real_chrome: true,
+ max_pages: 1,
+ max_depth: 0,
+ concurrency: 1,
+ })
+ expectEqual(crawled.stats.errors, 1, 'crawl real_chrome error count')
+ expectEqual(
+ crawled.items?.[0]?.error,
+ 'real_chrome require browser.scrapling.security_mode=compat',
+ 'crawl real_chrome inline item error',
+ )
+ },
+ },
+ {
+ name: 'dynamic-fetch: dedicated worker resumes past waitForDebuggerOnStart',
+ async run({ call, origin }) {
+ // Child targets attach frozen (waitForDebuggerOnStart). Without the
+ // child-target routing task the worker never runs and #out stays
+ // "pending" forever.
+ const r = await call('browser::dynamic-fetch', {
+ url: `${origin}/worker-page`,
+ include_html: true,
+ wait: 1500,
+ timeout: 10000,
+ retries: 1,
+ })
+ expectEqual(r.status, 200, 'worker-page status')
+ expect(r.html.includes('worker-ran'), `dedicated worker never resumed: ${r.html}`)
+ },
+ },
+ {
+ name: 'find: limit coerces floats and numeric strings, clamps negatives',
+ async run({ call }) {
+ const probe = async (limit: unknown) =>
+ await call('browser::find', { html: LIMIT_HTML, tag: 'li', limit })
+ const float = await probe(2.5)
+ expectEqual(float.count, 5, 'count stays the pre-cap total')
+ expectEqual(float.items.length, 2, 'float limit truncates toward zero')
+ expectEqual((await probe('3')).items.length, 3, 'numeric string limit parses')
+ expectEqual((await probe(' 2 ')).items.length, 2, 'whitespace-padded string limit parses')
+ expectEqual((await probe(-1)).items.length, 0, 'negative limit clamps to zero')
+ expectEqual((await probe(true)).items.length, 5, 'uncoercible limit falls back to the 100 cap')
+ const first = await call('browser::find', { html: LIMIT_HTML, tag: 'li', limit: 5, first: true })
+ expectEqual(first.items.length, 1, 'first:true short-circuits any limit')
+ },
+ },
+ {
+ name: 'describe: omitted kind is CSS, explicit null is XPath (Python parity)',
+ async run({ call }) {
+ // Omitted -> CSS branch: an XPath query is an invalid CSS selector.
+ await expectError(
+ () => call('browser::describe', { html: '<p>x</p>', query: '//p' }),
+ "handler error: Invalid CSS selector '//p': Expected selector, got <DELIM '/' at 0>",
+ 'omitted kind takes the CSS branch',
+ )
+ // Explicit null -> XPath branch (Python: payload.get("kind", "css"),
+ // where None != "css").
+ const r = await call('browser::describe', { html: '<p>x</p>', query: '//p', kind: null })
+ expectEqual(r.found, true, 'kind:null takes the XPath branch')
+ expectEqual(r.element?.tag, 'p', 'xpath describe element')
+ },
+ },
+ {
+ name: 'parse: processing instructions are stripped from the tree',
+ async run({ call }) {
+ expectEqual(
+ await call('browser::to-markdown', {
+ html: "<html><body><?php echo 'LEAK'; ?><p>hi</p></body></html>",
+ format: 'text',
+ }),
+ { format: 'text', content: 'hi' },
+ 'PI stripped from text rendering',
+ )
+ expectEqual(
+ await call('browser::css', { html: '<div><?pi LEAK?>text</div>', query: 'div', first: true }),
+ { result: 'text' },
+ 'PI stripped from css text extraction',
+ )
+ },
+ },
+ {
+ name: 'to-markdown: whitespace, empty link attrs, list spacing, ol start',
+ async run({ call }) {
+ const md = async (html: string) =>
+ (await call('browser::to-markdown', { html, format: 'markdown' })).content
+ // ASCII runs collapse; NBSP survives (split_whitespace would eat it).
+ expectEqual(await md('<h3>x\u00a0\u00a0y \n z</h3>'), '### x\u00a0\u00a0y z', 'heading collapse keeps NBSP')
+ const dt = await md('<dl><dt>Term \n Name\u00a0X</dt><dd>Def</dd></dl>')
+ expect(dt.includes('Term Name\u00a0X'), `dt collapse lost the NBSP or kept the run: ${JSON.stringify(dt)}`)
+ // Empty href/title filter to None instead of producing link markup.
+ expectEqual(await md('<p><a href="" title="">text</a></p>'), 'text', 'empty href drops link markup')
+ expectEqual(await md('<p><a href="http://x/" title="">http://x/</a></p>'), '<http://x/>', 'empty title keeps the autolink form')
+ // A bare text sibling after a list still forces the blank line.
+ expectEqual(await md('<html><body><ul><li>a</li></ul>tail</body></html>'), '* a\n\ntail', 'list before bare text keeps the blank line')
+ // ol start: ASCII digits only; anything else falls back to 1.
+ expectEqual(await md('<ol start="١"><li>a</li></ol>'), '1. a', 'non-ASCII ol start falls back to 1')
+ expectEqual(await md('<ol start="3"><li>a</li><li>b</li></ol>'), '3. a\n4. b', 'ASCII ol start numbers from it')
+ },
+ },
+ {
+ name: 'session: failed opens roll back their pending slot',
+ async run({ call }) {
+ // These fail INSIDE the constructor, after the pending counter was
+ // reserved — exactly the path the drop guard protects. Without the
+ // rollback, three failures would eat 3 of the 8 slots forever.
+ for (let i = 0; i < 3; i++) {
+ await expectError(
+ () => call('browser::session-open', { type: 'dynamic', wait_selector_state: 'bogus' }),
+ "handler error: Invalid argument type: Invalid enum value 'bogus' - at `$.wait_selector_state`",
+ `failing open ${i + 1}`,
+ )
+ }
+ const opened: string[] = []
+ try {
+ for (let i = 0; i < 8; i++) {
+ const r = await call('browser::session-open', { type: 'http' })
+ opened.push(r.session_id)
+ }
+ await expectError(
+ () => call('browser::session-open', { type: 'http' }),
+ 'handler error: session limit reached (8); close one first',
+ 'capacity intact after failed opens',
+ )
+ } finally {
+ for (const id of opened) await call('browser::session-close', { session_id: id })
+ }
+ // Closing freed the slots again.
+ const again = await call('browser::session-open', { type: 'http' })
+ expectEqual((await call('browser::session-close', { session_id: again.session_id })).closed, true, 'slot reusable after close')
+ },
+ },
+
+ // ---- configuration-mutating cases: keep these LAST, restore in finally ---
+ {
+ name: 'inject_guidance: config flip binds and unbinds the pre-generate hook live',
+ async run({ call }) {
+ // The runner registers the harness::hook::pre-generate trigger type, so
+ // the worker's boot-time binding activates from the engine's pending map
+ // (asynchronously — hence a poll, not a one-shot check).
+ await pollUntil(
+ () => guidanceTriggerVisible(call),
+ 'the boot-time guidance binding to activate (inject_guidance defaults true)',
+ )
+ const original = await getBrowserConfig(call)
+ try {
+ const off = structuredClone(original)
+ off.scrapling = { ...off.scrapling, inject_guidance: false }
+ await setBrowserConfig(call, off)
+ await pollUntil(
+ async () => !(await guidanceTriggerVisible(call)),
+ 'guidance trigger to unbind after inject_guidance=false',
+ )
+ const on = structuredClone(original)
+ on.scrapling = { ...on.scrapling, inject_guidance: true }
+ await setBrowserConfig(call, on)
+ await pollUntil(
+ () => guidanceTriggerVisible(call),
+ 'guidance trigger to rebind after inject_guidance=true',
+ )
+ } finally {
+ await setBrowserConfig(call, original)
+ }
+ // The hook itself: non-empty base appends the guidance, empty base
+ // returns no mutation (preserves the harness prompt).
+ const hooked = await call('browser::inject-guidance', { generate: { system_prompt: 'BASE' } })
+ expect(
+ typeof hooked.mutations?.system_prompt === 'string' &&
+ hooked.mutations.system_prompt.startsWith('BASE\n\n## Scraping and HTML parsing (browser::*)'),
+ `guidance hook did not append: ${JSON.stringify(hooked)}`,
+ )
+ expectEqual(
+ await call('browser::inject-guidance', { generate: { system_prompt: '' } }),
+ { mutations: {} },
+ 'empty base preserves the harness prompt',
+ )
+ },
+ },
+ {
+ name: 'solve_cloudflare: the solve loop is bounded by the configured deadline',
+ async run({ call, origin }) {
+ const original = await getBrowserConfig(call)
+ try {
+ const lowered = structuredClone(original)
+ lowered.max_timeout_ms = 3000
+ await setBrowserConfig(call, lowered)
+ await pollUntil(
+ async () => (await getBrowserConfig(call)).max_timeout_ms === 3000,
+ 'the store to show the lowered timeout cap',
+ )
+ // configuration:updated reaches the worker asynchronously; if the
+ // first attempt raced the reload it burns the SDK's 30s ceiling with
+ // a different error, so allow one retry.
+ await sleep(1500)
+ let attempt = 0
+ for (;;) {
+ const start = Date.now()
+ try {
+ await expectError(
+ () =>
+ call('browser::stealthy-fetch', {
+ url: `${origin}/cf-managed`,
+ solve_cloudflare: true,
+ include_html: true,
+ retries: 1,
+ }),
+ 'handler error: timed out solving the Cloudflare challenge',
+ 'unsolvable challenge times out',
+ )
+ expect(
+ Date.now() - start < 20_000,
+ 'the solve deadline followed the lowered max_timeout_ms (3s), not the 60s floor',
+ )
+ break
+ } catch (e) {
+ if (++attempt >= 2) throw e
+ }
+ }
+ // Control: same marker, no spin text — the solve loop falls through.
+ const clean = await call('browser::stealthy-fetch', {
+ url: `${origin}/cf-clean`,
+ solve_cloudflare: true,
+ include_html: true,
+ retries: 1,
+ })
+ expectEqual(clean.status, 200, 'clean page passes the solve loop')
+ expect(clean.html.includes('<p>done</p>'), `clean page html: ${clean.html}`)
+ } finally {
+ await setBrowserConfig(call, original)
+ }
+ },
+ },
+ {
+ name: 'safe mode: the config-default proxy is not injected into requests',
+ async run({ call, origin }) {
+ const original = await getBrowserConfig(call)
+ try {
+ const withProxy = structuredClone(original)
+ withProxy.scrapling = {
+ ...withProxy.scrapling,
+ defaults: { ...withProxy.scrapling.defaults, proxy: 'http://127.0.0.1:9/' },
+ }
+ await setBrowserConfig(call, withProxy)
+ await pollUntil(
+ async () => (await getBrowserConfig(call)).scrapling?.defaults?.proxy === 'http://127.0.0.1:9/',
+ 'the store to show the default proxy',
+ )
+ // Safe mode makes the omission itself invisible by design (that IS the
+ // fix), so the barrier is store-side plus a settle delay: pre-fix,
+ // both calls below failed against the dead proxy port.
+ await sleep(1500)
+ const http = await call('browser::fetch', { url: `${origin}/page`, retries: 1 })
+ expectEqual(http.status, 200, 'safe fetch ignores the config-default proxy')
+ const dyn = await call('browser::dynamic-fetch', { url: `${origin}/page`, retries: 1, timeout: 8000 })
+ expectEqual(dyn.status, 200, 'safe dynamic-fetch ignores the config-default proxy')
+ // The explicit caller refusal must survive the omission.
+ await expectError(
+ () => call('browser::fetch', { url: `${origin}/page`, proxy: 'http://127.0.0.1:9/' }),
+ 'handler error: safe mode refuses `proxy`: a caller proxy can resolve or route to addresses outside the egress policy; use a certified compat build or remove the option',
+ 'explicit caller proxy still refused',
+ )
+ } finally {
+ await setBrowserConfig(call, original)
+ }
+ },
+ },
+ {
+ name: 'crawl: allowed_domains are punycode-normalized before matching (IDN)',
+ async run({ call, origin }) {
+ // The /idn page links to the punycode host; the unicode allow-list only
+ // admits it if both sides normalize to xn--mnchen-3ya.example. Admitted
+ // means crawled (and failing DNS = an error item); filtered means the
+ // frontier never grows.
+ const strict = await call('browser::crawl', {
+ url: `${origin}/idn`,
+ fetcher: 'http',
+ allowed_domains: ['münchen.example'],
+ max_pages: 5,
+ max_depth: 1,
+ concurrency: 1,
+ timeout: 5,
+ })
+ expectEqual(strict.stats.crawled, 2, 'unicode allow-list admits the punycode link')
+ expectEqual(strict.stats.errors, 1, 'the admitted link fails to resolve')
+ const errored = (strict.items ?? []).find((i: any) => i.url === 'http://xn--mnchen-3ya.example/')
+ expect(Boolean(errored?.error), `expected an inline error item: ${JSON.stringify(strict.items)}`)
+
+ const control = await call('browser::crawl', {
+ url: `${origin}/idn`,
+ fetcher: 'http',
+ allowed_domains: ['nomatch.example'],
+ max_pages: 5,
+ max_depth: 1,
+ concurrency: 1,
+ timeout: 5,
+ })
+ expectEqual(control.stats.crawled, 1, 'non-matching allow-list filters the link')
+ expectEqual(control.stats.errors, 0, 'filtered links produce no error')
+ },
+ },
+]
diff --git a/browser/tests/e2e/workers/harness/src/cases.ts b/browser/tests/e2e/workers/harness/src/cases.ts
new file mode 100644
index 000000000..fb04da640
--- /dev/null
+++ b/browser/tests/e2e/workers/harness/src/cases.ts
@@ -0,0 +1,595 @@
+/**
+ * browser has no database-style drivers or dialect matrix. Each case
+ * is a direct bus call, so there's no `CaseContext.driver` /
+ * `dialect` (contrast database's harness). Expected values below are NOT
+ * invented: each case is either a byte-for-byte copy of a request/response
+ * pair from ../../../../golden/behavior/**\/*.json (the differential fixtures
+ * the Rust `tests/behavior.rs` test replays against the reference Python
+ * implementation), or — where noted — a small, code-verified extension of
+ * one (e.g. adding a redundant `tag` alongside an already-golden `attrs`
+ * filter that provably selects the same element set; see the comment on
+ * that case).
+ */
+
+export interface CaseContext {
+ /** Calls a browser function; returns parsed JSON or throws on engine error. */
+ call: (functionId: string, payload: unknown) => Promise<any>
+ /** Hermetic loopback origin owned by the harness for outbound cases. */
+ origin: string
+}
+
+export interface TestCase {
+ name: string
+ run(ctx: CaseContext): Promise<void>
+}
+
+/** Recursively sorts object keys so JSON.stringify comparison is order-insensitive
+ * (array element order still matters). browser's Cargo.toml enables
+ * serde_json's `preserve_order`, so the wire key order tracks *insertion*
+ * order in the Rust source — a cosmetic future reorder of a `json!({...})`
+ * literal shouldn't fail this suite. Same technique database's own
+ * cases-boundary.ts uses for its JSONB round-trip case (`canon`). */
+function canon(v: unknown): unknown {
+ if (Array.isArray(v)) return v.map(canon)
+ if (v !== null && typeof v === 'object') {
+ const out: Record<string, unknown> = {}
+ for (const k of Object.keys(v as Record<string, unknown>).sort()) {
+ out[k] = canon((v as Record<string, unknown>)[k])
+ }
+ return out
+ }
+ return v
+}
+
+export function expectEqual(actual: unknown, expected: unknown, msg: string): void {
+ if (JSON.stringify(canon(actual)) !== JSON.stringify(canon(expected))) {
+ throw new Error(`${msg}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`)
+ }
+}
+
+export function expect(cond: boolean, msg: string): asserts cond {
+ if (!cond) throw new Error(msg)
+}
+
+/**
+ * Asserts the complete error visible through the iii bus. Partial matches hide
+ * wrapper regressions, especially when two errors share a prefix.
+ */
+export async function expectError(
+ fn: () => Promise<unknown>,
+ expected: string,
+ label: string,
+): Promise<void> {
+ try {
+ await fn()
+ } catch (e: any) {
+ const msg = e?.message ?? String(e)
+ if (msg !== expected) {
+ throw new Error(`${label}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(msg)}`)
+ }
+ return
+ }
+ throw new Error(`${label}: expected the call to reject, but it resolved`)
+}
+
+// Shared fixture HTML, copied verbatim (including the trailing newline) from
+// tests/golden/behavior/{css,xpath,extract,regex,find,find-by-text,
+// find-by-regex,find-similar,describe,to-markdown}/*.json — the same string
+// backs 8 of the 10 happy-path cases below, exactly as it does across those
+// golden fixtures.
+const BASIC_HTML =
+ '<html><head></head><body><h1 class="t">Hello</h1><ul><li><a href="/a">Apple</a></li><li><a href="/b">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n'
+
+// Copied verbatim from tests/golden/behavior/find/limit_clamps.json (also
+// backs find-by-regex/messy_cards.json and find/attrs_exact_whole_value.json).
+const MESSY_HTML =
+ '<html><head><title>Messy Page</title><meta charset="utf-8"></head><body>\n<nav><ul><li><a href="/home">Home</a></li><li><a href="/about">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden="true">screen-reader trap</div>\n<div style="display:none">hidden A</div>\n<div style="visibility: hidden">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href="/w/1">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class="card" data-id="1"><h3>Card One</h3><p>first card</p></div>\n <div class="card" data-id="2"><h3>Card Two</h3><p>second card</p></div>\n <div class="card wide" data-id="3"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style="font-size:0">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n'
+
+// Copied verbatim from the `const HTML` in src/xpath/eval.rs's test module
+// (the fixture behind its `error_shapes` test, which asserts the exact
+// "//p/ancestor::div" input this case reuses).
+const ANCESTOR_HTML = '<main id="m"><section id="s"><p>P</p></section></main>'
+
+export const ORIGIN_PAGE_HTML =
+ '<!doctype html><html><head><title>E2E</title></head><body><h1>initial</h1><div id="fp"></div><a href="/leaf">leaf</a><script>document.querySelector("h1").textContent="rendered";document.querySelector("#fp").textContent=[navigator.language,Intl.DateTimeFormat().resolvedOptions().timeZone,devicePixelRatio,innerWidth,innerHeight].join("|")</script></body></html>'
+
+export const CASES: TestCase[] = [
+ {
+ // Golden: tests/golden/behavior/extract/mixed_specs.json
+ name: 'extract: mixed selector list (css/xpath precedence, regex, attr, html, all)',
+ async run({ call }) {
+ const r = await call('browser::extract', {
+ html: BASIC_HTML,
+ selectors: [
+ { name: 'title', css: 'h1' },
+ { name: 'links', css: 'li a', attr: 'href', all: true },
+ { name: 'names', css: 'li a', all: true },
+ { name: 'price', regex: 'price (\\d+)' },
+ { name: 'first_li_html', css: 'li', html: true },
+ ],
+ })
+ expectEqual(
+ r,
+ {
+ extracted: {
+ title: 'Hello',
+ links: ['/a', '/b'],
+ names: ['Apple', 'Banana'],
+ price: '42',
+ first_li_html: '<li><a href="/a">Apple</a></li>',
+ },
+ },
+ 'extract mixed_specs',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/css/first_attr.json
+ name: 'css: first + attr pulls the attribute of the first match',
+ async run({ call }) {
+ const r = await call('browser::css', { html: BASIC_HTML, query: 'li a', first: true, attr: 'href' })
+ expectEqual(r, { result: '/a' }, 'css first_attr')
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/xpath/positional.json
+ name: 'xpath: positional predicate + child step, first (text)',
+ async run({ call }) {
+ const r = await call('browser::xpath', { html: BASIC_HTML, query: '//li[2]/a', first: true })
+ expectEqual(r, { result: 'Banana' }, 'xpath positional')
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/regex/first_group.json
+ name: 'regex: first capture group',
+ async run({ call }) {
+ const r = await call('browser::regex', { html: BASIC_HTML, pattern: 'price (\\d+)', first: true })
+ expectEqual(r, { result: '42' }, 'regex first_group')
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/find/attrs_exact_whole_value.json, on
+ // MESSY_HTML. That fixture filters by `attrs` alone (base selector
+ // `*[class="card"]`, per src/functions/find.rs's `op`: an empty `tag`
+ // falls back to `base = ["*"]` before the attrs suffix is appended).
+ // Adding `tag: "div"` narrows the base to `div[class="card"]` instead —
+ // provably the same match set here, since every `class="card"` element
+ // in this fixture already *is* a <div> (there is no other tag carrying
+ // that class) — so this exercises the tag+attrs combination the golden
+ // itself doesn't, without inventing an unverified result: same 2 items,
+ // same count.
+ name: 'find: tag + attrs (count/items)',
+ async run({ call }) {
+ const r = await call('browser::find', { html: MESSY_HTML, tag: 'div', attrs: { class: 'card' } })
+ expectEqual(
+ r,
+ {
+ count: 2,
+ items: [
+ {
+ tag: 'div',
+ text: 'Card One\nfirst card',
+ html: '<div class="card" data-id="1"><h3>Card One</h3><p>first card</p></div>',
+ attrs: { class: 'card', 'data-id': '1' },
+ css: 'body > main > div',
+ xpath: '//body/main/div',
+ },
+ {
+ tag: 'div',
+ text: 'Card Two\nsecond card',
+ html: '<div class="card" data-id="2"><h3>Card Two</h3><p>second card</p></div>',
+ attrs: { class: 'card', 'data-id': '2' },
+ css: 'body > main > div:nth-of-type(2)',
+ xpath: '//body/main/div[2]',
+ },
+ ],
+ },
+ 'find tag+attrs',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/find-by-text/exact_default.json
+ name: 'find-by-text: leading-text exact match',
+ async run({ call }) {
+ const r = await call('browser::find-by-text', { html: BASIC_HTML, text: 'Apple' })
+ expectEqual(
+ r,
+ {
+ count: 1,
+ items: [
+ {
+ tag: 'a',
+ text: 'Apple',
+ html: '<a href="/a">Apple</a>',
+ attrs: { href: '/a' },
+ css: 'body > ul > li > a',
+ xpath: '//body/ul/li/a',
+ },
+ ],
+ },
+ 'find-by-text exact_default',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/find-by-regex/default_insensitive.json
+ name: 'find-by-regex: leading-text pattern match (case-insensitive default)',
+ async run({ call }) {
+ const r = await call('browser::find-by-regex', { html: BASIC_HTML, pattern: 'price \\d+' })
+ expectEqual(
+ r,
+ {
+ count: 1,
+ items: [
+ {
+ tag: 'p',
+ text: 'price 42 usd then 99',
+ html: '<p>price 42 usd then 99</p>',
+ attrs: {},
+ css: 'body > p',
+ xpath: '//body/p',
+ },
+ ],
+ },
+ 'find-by-regex default_insensitive',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/find-similar/list_items.json
+ name: 'find-similar: li anchor (count 2)',
+ async run({ call }) {
+ const r = await call('browser::find-similar', { html: BASIC_HTML, anchor: 'li' })
+ expectEqual(
+ r,
+ {
+ count: 2,
+ items: [
+ { text: 'Apple', html: '<li><a href="/a">Apple</a></li>' },
+ { text: 'Banana', html: '<li><a href="/b">Banana</a></li>' },
+ ],
+ },
+ 'find-similar list_items',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/describe/h1_css.json
+ name: 'describe: h1 (found, classes, parent_tag)',
+ async run({ call }) {
+ const r = await call('browser::describe', { html: BASIC_HTML, query: 'h1' })
+ expectEqual(
+ r,
+ {
+ found: true,
+ element: {
+ tag: 'h1',
+ text: 'Hello',
+ html: '<h1 class="t">Hello</h1>',
+ attrs: { class: 't' },
+ css: 'body > h1',
+ xpath: '//body/h1',
+ full_css: 'body > h1',
+ full_xpath: '//body/h1',
+ classes: ['t'],
+ parent_tag: 'body',
+ children: 0,
+ siblings: 2,
+ },
+ },
+ 'describe h1_css',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/to-markdown/text_basic.json — deterministic
+ // (no HTML->Markdown formatting choices in text mode), so an exact string.
+ name: 'to-markdown: text mode (exact string)',
+ async run({ call }) {
+ const r = await call('browser::to-markdown', { html: BASIC_HTML, format: 'text' })
+ expectEqual(r, { format: 'text', content: 'Hello\nApple\nBanana\nprice 42 usd then 99' }, 'to-markdown text_basic')
+ },
+ },
+ {
+ name: 'css: adaptive direct match',
+ async run({ call }) {
+ expectEqual(
+ await call('browser::css', {
+ html: '<p>x</p>',
+ query: 'p',
+ adaptive: true,
+ auto_save: false,
+ adaptive_domain: 'e2e.invalid',
+ identifier: 'e2e-direct',
+ }),
+ { result: ['x'] },
+ 'adaptive direct match',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/css/invalid_selector.json, plus the exact
+ // iii bus error envelope observed by callers.
+ name: 'css: invalid selector error',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::css', { html: BASIC_HTML, query: 'li:::bad' }),
+ "handler error: Invalid CSS selector 'li:::bad': Expected ident, got <DELIM ':' at 4>",
+ 'invalid css selector',
+ )
+ },
+ },
+ {
+ // Golden: xpath/ancestor_axis_reverse_position.json.
+ name: 'xpath: ancestor axis reverse position',
+ async run({ call }) {
+ expectEqual(
+ await call('browser::xpath', { html: ANCESTOR_HTML, query: '//p/ancestor::*[1]/@id' }),
+ { result: ['s'] },
+ 'ancestor axis',
+ )
+ },
+ },
+ {
+ // Golden: tests/golden/behavior/find/negative_limit_empty.json uses
+ // limit=-1 on this exact html+tag ("a" on BASIC_HTML — same fixture
+ // find/by_tag.json proves has 2 matches with no limit) and gets
+ // count=2, items=[]. src/functions/common.rs::bounded clamps limit to
+ // `[0, MAX_FIND_ITEMS]` — `l.clamp(0, MAX)` maps BOTH -1 and 0 to the
+ // same ceiling of 0 — so limit=0 is the same code path the golden
+ // already covers, just via the other input that clamps to it.
+ name: 'find: limit 0 clamps items to [], count stays the true total',
+ async run({ call }) {
+ const r = await call('browser::find', { html: BASIC_HTML, tag: 'a', limit: 0 })
+ expectEqual(r, { count: 2, items: [] }, 'find limit_clamp')
+ },
+ },
+
+ // ---- outbound surface -------------------------------------------------
+ // Every successful outbound case uses the harness-owned loopback origin.
+ // External egress remains unnecessary and SSRF policy is still exercised.
+ {
+ // The SSRF guard is the reason these functions can take an arbitrary
+ // caller-supplied URL at all, so it gets an end-to-end assertion, not
+ // just a unit test: 169.254.169.254 is the cloud metadata endpoint.
+ name: 'fetch: SSRF guard refuses the link-local metadata address',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::fetch', { url: 'http://169.254.169.254/latest/meta-data/' }),
+ 'handler error: address 169.254.169.254 is in link-local (incl. AWS metadata)',
+ 'ssrf link-local',
+ )
+ },
+ },
+ {
+ name: 'fetch: non-http scheme refused',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::fetch', { url: 'file:///etc/passwd' }),
+ 'handler error: scheme not allowed: file: (only http: and https: are permitted)',
+ 'ssrf scheme',
+ )
+ },
+ },
+ {
+ name: 'fetch: unsupported method named in the error',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::fetch', { url: 'https://example.com/', method: 'patch' }),
+ 'handler error: unsupported method: patch',
+ 'fetch method',
+ )
+ },
+ },
+ {
+ name: 'fetch: neither url nor urls',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::fetch', {}),
+ 'handler error: provide `url` or `urls`',
+ 'fetch no target',
+ )
+ },
+ },
+ {
+ name: 'browser fetchers: dynamic and stealthy render the local page',
+ async run({ call, origin }) {
+ for (const [functionId, viewport] of [
+ ['browser::dynamic-fetch', '1280|720'],
+ ['browser::stealthy-fetch', '1920|1080'],
+ ] as const) {
+ const result = await call(functionId, {
+ url: `${origin}/page`,
+ include_html: true,
+ locale: 'fr-FR',
+ timezone_id: 'Europe/Paris',
+ retries: 1,
+ timeout: 5000,
+ solve_cloudflare: functionId === 'browser::stealthy-fetch',
+ })
+ expectEqual(result.status, 200, `${functionId} status`)
+ expectEqual(result.url, `${origin}/page`, `${functionId} url`)
+ expectEqual(result.cookies, {}, `${functionId} cookie quirk`)
+ expectEqual(result.encoding, 'utf-8', `${functionId} encoding`)
+ expect(result.html.includes('<h1>rendered</h1>'), `${functionId} did not execute page script`)
+ expect(
+ result.html.includes(`fr-FR|Europe/Paris|2|${viewport}`),
+ `${functionId} fingerprint did not match the frozen viewport`,
+ )
+ }
+ },
+ },
+ {
+ name: 'screenshot-url: unknown fetcher preserves the dynamic fallback quirk',
+ async run({ call, origin }) {
+ const result = await call('browser::screenshot-url', {
+ url: `${origin}/page`,
+ fetcher: 'telepathy',
+ format: 'png',
+ retries: 1,
+ timeout: 5000,
+ })
+ expectEqual(result.mime, 'image/png', 'screenshot mime')
+ expectEqual(result.url, `${origin}/page`, 'screenshot url')
+ expectEqual(result.content.length, 2, 'screenshot content blocks')
+ expectEqual(result.content[0].type, 'image', 'screenshot image block')
+ expectEqual(result.content[0].mime, 'image/png', 'screenshot image block mime')
+ expect(
+ Buffer.from(result.content[0].data, 'base64').subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])),
+ 'screenshot is not a PNG',
+ )
+ expectEqual(result.content[1].type, 'text', 'screenshot caption block')
+ expect(
+ result.content[1].text.startsWith(`screenshot of ${origin}/page — 1024x576px, 1 tile(s), `),
+ `unexpected screenshot caption: ${result.content[1].text}`,
+ )
+ },
+ },
+ {
+ name: 'crawl: missing start_urls',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::crawl', {}),
+ 'handler error: provide `start_urls`',
+ 'crawl no seeds',
+ )
+ },
+ },
+ {
+ name: 'session: HTTP cookie state, list order, and idempotent close',
+ async run({ call, origin }) {
+ const opened = await call('browser::session-open', { type: 'http' })
+ if (typeof opened.session_id !== 'string' || !/^[0-9a-f]{32}$/.test(opened.session_id)) {
+ throw new Error(`expected a UUID4 hex http session id, got ${JSON.stringify(opened)}`)
+ }
+ expectEqual(opened.type, 'http', 'session-open type')
+
+ const listed = await call('browser::session-list', { type: 'http' })
+ const mine = (listed.sessions ?? []).find((s: any) => s.session_id === opened.session_id)
+ if (!mine) throw new Error(`session-list omitted ${opened.session_id}: ${JSON.stringify(listed)}`)
+ for (const k of ['session_id', 'type', 'created_at', 'last_used', 'idle_s']) {
+ if (!(k in mine)) throw new Error(`session-list entry missing '${k}': ${JSON.stringify(mine)}`)
+ }
+
+ const first = await call('browser::session-fetch', {
+ session_id: opened.session_id,
+ url: `${origin}/cookie`,
+ include_html: true,
+ retries: 1,
+ })
+ const second = await call('browser::session-fetch', {
+ session_id: opened.session_id,
+ url: `${origin}/cookie`,
+ include_html: true,
+ retries: 1,
+ })
+ expect(first.html.includes('<p>none</p>'), `first HTTP session fetch unexpectedly had a cookie: ${first.html}`)
+ expect(second.html.includes('<p>sid=abc</p>'), `HTTP session did not retain its cookie: ${second.html}`)
+
+ expectEqual(
+ await call('browser::session-close', { session_id: opened.session_id }),
+ { closed: true },
+ 'session-close first',
+ )
+ expectEqual(
+ await call('browser::session-close', { session_id: opened.session_id }),
+ { closed: false },
+ 'session-close idempotent',
+ )
+ },
+ },
+ {
+ // Safe mode refuses caller proxies before dialing: their own DNS/routing
+ // could bypass the address pinned by the native egress policy.
+ name: 'fetch: safe mode refuses a caller proxy',
+ async run({ call }) {
+ await expectError(
+ () =>
+ call('browser::fetch', {
+ url: 'https://example.com/',
+ proxy: 'http://169.254.169.254:3128',
+ }),
+ 'handler error: safe mode refuses `proxy`: a caller proxy can resolve or route to addresses outside the egress policy; use a certified compat build or remove the option',
+ 'safe proxy policy',
+ )
+ },
+ },
+ {
+ name: 'fetch: safe HTTP happy path returns the frozen envelope',
+ async run({ call, origin }) {
+ const result = await call('browser::fetch', {
+ url: `${origin}/page`,
+ include_html: true,
+ timeout: 1e20,
+ retries: 1,
+ })
+ expectEqual(result.status, 200, 'HTTP status')
+ expectEqual(result.url, `${origin}/page`, 'HTTP url')
+ expectEqual(result.cookies, { sid: 'abc' }, 'HTTP cookies')
+ expectEqual(result.encoding, 'utf-8', 'HTTP encoding')
+ expectEqual(result.html, ORIGIN_PAGE_HTML.replace('<!doctype html>', ''), 'HTTP normalized HTML')
+ },
+ },
+ {
+ name: 'crawl: local HTTP completion, sample, and one-based stream metadata',
+ async run({ call, origin }) {
+ const result = await call('browser::crawl', {
+ url: `${origin}/page`,
+ fetcher: 'http',
+ max_pages: 2,
+ max_depth: 1,
+ concurrency: 1,
+ group_id: 'e2e-crawl',
+ selectors: [{ name: 'heading', css: 'h1' }],
+ })
+ expectEqual(
+ result,
+ {
+ stats: { crawled: 2, items: 2, errors: 0, stopped: 'done' },
+ items: [
+ { url: `${origin}/page`, status: 200, extracted: { heading: 'initial' } },
+ { url: `${origin}/leaf`, status: 200, extracted: { heading: null } },
+ ],
+ stream: { name: 'browser::crawl', group_id: 'e2e-crawl' },
+ },
+ 'crawl result',
+ )
+ },
+ },
+ {
+ name: 'session: dynamic and stealthy browser backends fetch and close',
+ async run({ call, origin }) {
+ for (const type of ['dynamic', 'stealthy'] as const) {
+ const opened = await call('browser::session-open', {
+ type,
+ locale: 'fr-FR',
+ timezone_id: 'Europe/Paris',
+ solve_cloudflare: type === 'stealthy',
+ })
+ expectEqual(opened.type, type, `${type} session type`)
+ expect(/^[0-9a-f]{32}$/.test(opened.session_id), `${type} session id is not UUID4 hex`)
+ const fetched = await call('browser::session-fetch', {
+ session_id: opened.session_id,
+ url: `${origin}/page`,
+ include_html: true,
+ retries: 1,
+ timeout: 5000,
+ })
+ expectEqual(fetched.status, 200, `${type} session status`)
+ expect(fetched.html.includes('<h1>rendered</h1>'), `${type} session did not render`)
+ expectEqual(await call('browser::session-close', { session_id: opened.session_id }), { closed: true }, `${type} close`)
+ }
+ },
+ },
+ {
+ name: 'session-fetch: unknown session id',
+ async run({ call }) {
+ await expectError(
+ () => call('browser::session-fetch', { session_id: 'b999', url: 'https://example.com/' }),
+ 'handler error: unknown session: b999',
+ 'session unknown',
+ )
+ },
+ },
+]
diff --git a/browser/tests/e2e/workers/harness/src/runner.ts b/browser/tests/e2e/workers/harness/src/runner.ts
new file mode 100644
index 000000000..f3a70e899
--- /dev/null
+++ b/browser/tests/e2e/workers/harness/src/runner.ts
@@ -0,0 +1,219 @@
+import { writeFileSync, mkdirSync } from 'node:fs'
+import { createServer, type Server } from 'node:http'
+import { resolve } from 'node:path'
+import { once } from 'node:events'
+import type { ISdk } from 'iii-sdk'
+import { CASES, ORIGIN_PAGE_HTML, type CaseContext, type TestCase } from './cases.ts'
+import { HARDENING_CASES } from './cases-hardening.ts'
+
+const ALL_CASES: TestCase[] = [...CASES, ...HARDENING_CASES]
+
+interface CaseResult {
+ case: string
+ status: 'PASS' | 'FAIL'
+ error?: string
+ duration_ms: number
+}
+
+export interface RunnerOptions {
+ iii: ISdk
+ reportPath: string
+ /** Harness-side substring filter on case name (run-tests.sh's --filter=). */
+ filter?: string
+}
+
+export class Runner {
+ private origin = ''
+
+ constructor(private opts: RunnerOptions) {}
+
+ private async call(functionId: string, payload: unknown): Promise<any> {
+ return await this.opts.iii.trigger<unknown, any>({ function_id: functionId, payload })
+ }
+
+ private async callWithRetry(functionId: string, payload: unknown, attempts = 10): Promise<any> {
+ let lastErr: unknown
+ for (let i = 0; i < attempts; i++) {
+ try {
+ return await this.call(functionId, payload)
+ } catch (e) {
+ lastErr = e
+ await new Promise((r) => setTimeout(r, 200))
+ }
+ }
+ throw lastErr
+ }
+
+ private async runCase(c: TestCase): Promise<CaseResult> {
+ const start = Date.now()
+ const ctx: CaseContext = { call: (id, payload) => this.call(id, payload), origin: this.origin }
+ try {
+ await c.run(ctx)
+ return { case: c.name, status: 'PASS', duration_ms: Date.now() - start }
+ } catch (e: any) {
+ return { case: c.name, status: 'FAIL', error: e?.message ?? String(e), duration_ms: Date.now() - start }
+ }
+ }
+
+ async runAll(): Promise<{ pass: number; total: number; results: CaseResult[] }> {
+ // Probe with a no-op call until it succeeds; tolerates the worker-startup
+ // race (run-tests.sh already retries `iii trigger` before launching the
+ // harness at all, but the harness is also runnable standalone).
+ await this.callWithRetry('browser::css', { html: '<p>x</p>', query: 'p' })
+
+ // Claim the pre-generate hook trigger type, as a real agent-harness stack
+ // would. Without an owner the browser worker's guidance binding stays
+ // parked in the engine's pending map, which registered-triggers::list
+ // does not expose — with one, the binding goes live and the
+ // inject_guidance hot-apply case can observe it bind and unbind. The
+ // handler never fires: nothing in this suite emits pre-generate events.
+ this.opts.iii.registerTriggerType(
+ { id: 'harness::hook::pre-generate', description: 'E2E stand-in for the agent harness pre-generate hook.' },
+ { registerTrigger: async () => {}, unregisterTrigger: async () => {} },
+ )
+
+ const servers = await this.startOrigin()
+ const cases = this.opts.filter ? ALL_CASES.filter((c) => c.name.includes(this.opts.filter!)) : ALL_CASES
+
+ // Stream each case result to stdout as it completes, colored green/red
+ // only when stdout is a TTY — run-tests.sh redirects stdout to a log
+ // file, and bash's grep for the HARNESS_DONE sentinel must see plain text.
+ const useColor = process.stdout.isTTY === true
+ const GREEN = useColor ? '\x1b[32m' : ''
+ const RED = useColor ? '\x1b[31m' : ''
+ const RESET = useColor ? '\x1b[0m' : ''
+
+ const results: CaseResult[] = []
+ try {
+ for (const c of cases) {
+ const r = await this.runCase(c)
+ const color = r.status === 'PASS' ? GREEN : RED
+ const err = r.error ? ' — ' + r.error : ''
+ console.log(`[harness] ${color}${r.status}${RESET} ${r.case} (${r.duration_ms}ms)${err}`)
+ results.push(r)
+ }
+ } finally {
+ for (const server of servers) server.close()
+ }
+
+ const pass = results.filter((r) => r.status === 'PASS').length
+
+ mkdirSync(resolve(this.opts.reportPath, '..'), { recursive: true })
+ writeFileSync(this.opts.reportPath, JSON.stringify({ pass, total: results.length, results }, null, 2))
+
+ return { pass, total: results.length, results }
+ }
+
+ private async startOrigin(): Promise<Server[]> {
+ let port6 = 0
+ const handler = (req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse) => {
+ const path = new URL(req.url ?? '/', 'http://127.0.0.1').pathname
+ const address = server.address()
+ const port = address && typeof address !== 'string' ? address.port : 0
+
+ // Hardening-case endpoints own their complete response (status, headers,
+ // body); everything below them keeps the legacy uniform header block so
+ // the frozen-envelope assertions of the original cases stay byte-stable.
+ const html = (content: string, headers: Record<string, string | string[]> = {}, contentType = 'text/html; charset=utf-8') => {
+ const buf = Buffer.from(content)
+ res.statusCode = 200
+ res.setHeader('Content-Type', contentType)
+ for (const [k, v] of Object.entries(headers)) res.setHeader(k, v)
+ res.setHeader('Content-Length', buf.length)
+ res.setHeader('Connection', 'close')
+ res.end(buf)
+ }
+ const redirect = (location: string, headers: Record<string, string | string[]> = {}) => {
+ res.statusCode = 302
+ res.setHeader('Location', location)
+ for (const [k, v] of Object.entries(headers)) res.setHeader(k, v)
+ res.setHeader('Content-Length', 0)
+ res.setHeader('Connection', 'close')
+ res.end()
+ }
+ res.sendDate = false
+ switch (path) {
+ case '/loop':
+ return redirect(`http://127.0.0.1:${port}/loop`)
+ case '/hop-a':
+ return redirect(`http://127.0.0.1:${port}/hop-b`, { 'Set-Cookie': 'hop=1; Path=/' })
+ case '/hop-x':
+ // Same handler, different loopback hostname: exercises the
+ // hostname-only scoping of redirect cookie replay. An IP literal
+ // (not `localhost`) so no resolver is involved — CI resolves
+ // localhost to ::1 while dev machines resolve it to 127.0.0.1.
+ return redirect(`http://[::1]:${port6}/hop-b`, { 'Set-Cookie': 'hopx=1; Path=/' })
+ case '/hop-b':
+ return html(`<html><body><p>${req.headers.cookie ?? 'none'}</p></body></html>`)
+ case '/multi-cookie':
+ return html('<html><body><p>mc</p></body></html>', {
+ 'Set-Cookie': ['a=1; Path=/', 'b=2; Path=/'],
+ 'X-Test': ['one', 'two'],
+ })
+ case '/echo-headers':
+ // rawHeaders preserves duplicates and original casing — the egress
+ // gate case counts Connection headers, which req.headers would fold.
+ return html(
+ `<html><body><pre>${JSON.stringify({ url: req.url, rawHeaders: req.rawHeaders })}</pre></body></html>`,
+ )
+ case '/cf-managed':
+ // Fake Cloudflare managed challenge: the cType marker routes
+ // solve_cloudflare into its managed branch, and the "Verifying"
+ // text keeps it spinning until the solve deadline expires.
+ return html(
+ "<html><head><title>E2E CF</title></head><body><script>/* cType: 'managed' */</script><p>Verifying you are human.</p></body></html>",
+ )
+ case '/cf-clean':
+ // Same marker but no spin text and no challenge iframe: the solve
+ // loop must fall through and return the page normally.
+ return html(
+ "<html><head><title>fine</title></head><body><script>/* cType: 'managed' */</script><p>done</p></body></html>",
+ )
+ case '/worker-page':
+ return html(
+ '<html><body><div id="out">pending</div><script>const w=new Worker("/w.js");w.onmessage=(e)=>{document.getElementById("out").textContent=e.data}</script></body></html>',
+ )
+ case '/w.js':
+ return html("postMessage('worker-ran')", {}, 'application/javascript')
+ case '/idn':
+ return html('<html><body><a href="http://xn--mnchen-3ya.example/">m</a></body></html>')
+ default:
+ break
+ }
+ const body =
+ path === '/plain'
+ ? Buffer.from([0x63, 0x61, 0x66, 0xe9])
+ : Buffer.from(
+ path === '/leaf'
+ ? '<html><body><p>leaf</p></body></html>'
+ : path === '/cookie'
+ ? `<html><body><p>${req.headers.cookie ?? 'none'}</p></body></html>`
+ : ORIGIN_PAGE_HTML,
+ )
+ res.sendDate = false
+ res.statusCode = path === '/plain' ? 206 : 200
+ res.setHeader('Content-Type', path === '/plain' ? 'text/plain; charset=iso-8859-1' : 'text/html; charset=utf-8')
+ res.setHeader('Date', 'Wed, 12 Aug 2026 16:00:00 GMT')
+ res.setHeader('X-Test', ['one', 'two'])
+ res.setHeader('Set-Cookie', 'sid=abc; Path=/')
+ res.setHeader('Content-Length', body.length)
+ res.setHeader('Connection', 'close')
+ res.end(body)
+ }
+ const server = createServer(handler)
+ server.listen(0, '127.0.0.1')
+ await once(server, 'listening')
+ const address = server.address()
+ if (!address || typeof address === 'string') throw new Error('local origin did not bind TCP')
+ this.origin = `http://127.0.0.1:${address.port}`
+ // IPv6-loopback twin (own ephemeral port): the second loopback hostname
+ // the hop-x redirect targets. Same handler, so /hop-b answers on both.
+ const server6 = createServer(handler)
+ server6.listen(0, '::1')
+ await once(server6, 'listening')
+ const address6 = server6.address()
+ if (!address6 || typeof address6 === 'string') throw new Error('local v6 origin did not bind TCP')
+ port6 = address6.port
+ return [server, server6]
+ }
+}
diff --git a/browser/tests/e2e/workers/harness/src/worker.ts b/browser/tests/e2e/workers/harness/src/worker.ts
new file mode 100644
index 000000000..1981cd8b8
--- /dev/null
+++ b/browser/tests/e2e/workers/harness/src/worker.ts
@@ -0,0 +1,46 @@
+import { registerWorker, Logger } from 'iii-sdk'
+import { resolve } from 'node:path'
+import { Runner } from './runner.ts'
+
+const URL = process.env.III_URL ?? 'ws://127.0.0.1:49234'
+const REPORT_PATH = resolve(process.env.HARNESS_REPORT_PATH ?? './reports/report.json')
+const FILTER = process.env.HARNESS_FILTER
+
+const iii = registerWorker(URL)
+const logger = new Logger()
+const runner = new Runner({ iii, reportPath: REPORT_PATH, filter: FILTER })
+
+logger.info('harness: registered, kicking off suite', {
+ url: URL,
+ filter: FILTER ?? 'all',
+ reportPath: REPORT_PATH,
+})
+
+;(async () => {
+ // ANSI colors only when stdout is a TTY — run-tests.sh redirects to a log
+ // file, and bash's grep for the HARNESS_DONE sentinel must see plain text.
+ const useColor = process.stdout.isTTY === true
+ const GREEN = useColor ? '\x1b[32m' : ''
+ const RED = useColor ? '\x1b[31m' : ''
+ const RESET = useColor ? '\x1b[0m' : ''
+ let exitCode = 1
+ try {
+ const { pass, total } = await runner.runAll()
+ // total===0 is a FAIL, not a vacuous pass: a mistyped --filter that
+ // matches no cases would otherwise report green having run nothing.
+ const status = total > 0 && pass === total ? 'PASS' : 'FAIL'
+ const color = status === 'PASS' ? GREEN : RED
+ console.log(`HARNESS_DONE: ${color}${status}${RESET} ${pass}/${total}`)
+ exitCode = status === 'PASS' ? 0 : 1
+ } catch (e: any) {
+ console.error('[harness] fatal:', e?.stack ?? e)
+ console.log(`HARNESS_DONE: ${RED}FAIL${RESET} 0/0`)
+ exitCode = 1
+ }
+ // 200ms grace lets the OS flush ws bytes; iii.shutdown() then closes the ws
+ // and drains OTel queues. iii.shutdown() itself does NOT await the ws close
+ // handshake, hence the explicit delay.
+ await new Promise((r) => setTimeout(r, 200))
+ await iii.shutdown()
+ process.exit(exitCode)
+})()
diff --git a/browser/tests/e2e/workers/harness/tsconfig.json b/browser/tests/e2e/workers/harness/tsconfig.json
new file mode 100644
index 000000000..91c7e3885
--- /dev/null
+++ b/browser/tests/e2e/workers/harness/tsconfig.json
@@ -0,0 +1,14 @@
+{
+ "compilerOptions": {
+ "target": "ES2022",
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "esModuleInterop": true,
+ "strict": true,
+ "skipLibCheck": true,
+ "noEmit": true,
+ "allowImportingTsExtensions": true
+ },
+ "include": ["src/**/*"],
+ "exclude": ["node_modules", "dist"]
+}
diff --git a/browser/tests/golden/behavior/css/all_default.json b/browser/tests/golden/behavior/css/all_default.json
new file mode 100644
index 000000000..0f32ae302
--- /dev/null
+++ b/browser/tests/golden/behavior/css/all_default.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::css",
+ "case": "all_default",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "li a"
+ },
+ "ok": {
+ "result": [
+ "Apple",
+ "Banana"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/attr_miss_in_all.json b/browser/tests/golden/behavior/css/attr_miss_in_all.json
new file mode 100644
index 000000000..b5363c4da
--- /dev/null
+++ b/browser/tests/golden/behavior/css/attr_miss_in_all.json
@@ -0,0 +1,15 @@
+{
+ "function": "browser::css",
+ "case": "attr_miss_in_all",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "li a",
+ "attr": "data-x"
+ },
+ "ok": {
+ "result": [
+ null,
+ null
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/bare_detached_text.json b/browser/tests/golden/behavior/css/bare_detached_text.json
new file mode 100644
index 000000000..07eb1842d
--- /dev/null
+++ b/browser/tests/golden/behavior/css/bare_detached_text.json
@@ -0,0 +1,16 @@
+{
+ "function": "browser::css",
+ "case": "bare_detached_text",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "::text"
+ },
+ "ok": {
+ "result": [
+ "Hello",
+ "Apple",
+ "Banana",
+ "price 42 usd then 99"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/detached_text_descendants.json b/browser/tests/golden/behavior/css/detached_text_descendants.json
new file mode 100644
index 000000000..49641b7d3
--- /dev/null
+++ b/browser/tests/golden/behavior/css/detached_text_descendants.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::css",
+ "case": "detached_text_descendants",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "li ::text"
+ },
+ "ok": {
+ "result": [
+ "Apple",
+ "Banana"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/detached_text_first.json b/browser/tests/golden/behavior/css/detached_text_first.json
new file mode 100644
index 000000000..9c73a3c63
--- /dev/null
+++ b/browser/tests/golden/behavior/css/detached_text_first.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::css",
+ "case": "detached_text_first",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "h1 ::text",
+ "first": true
+ },
+ "ok": {
+ "result": "Hello"
+ }
+}
diff --git a/browser/tests/golden/behavior/css/empty_attr_falls_back_to_text.json b/browser/tests/golden/behavior/css/empty_attr_falls_back_to_text.json
new file mode 100644
index 000000000..7560e3f3a
--- /dev/null
+++ b/browser/tests/golden/behavior/css/empty_attr_falls_back_to_text.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::css",
+ "case": "empty_attr_falls_back_to_text",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "li a",
+ "first": true,
+ "attr": ""
+ },
+ "ok": {
+ "result": "Apple"
+ }
+}
diff --git a/browser/tests/golden/behavior/css/first_attr.json b/browser/tests/golden/behavior/css/first_attr.json
new file mode 100644
index 000000000..6360529a0
--- /dev/null
+++ b/browser/tests/golden/behavior/css/first_attr.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::css",
+ "case": "first_attr",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "li a",
+ "first": true,
+ "attr": "href"
+ },
+ "ok": {
+ "result": "/a"
+ }
+}
diff --git a/browser/tests/golden/behavior/css/first_text.json b/browser/tests/golden/behavior/css/first_text.json
new file mode 100644
index 000000000..4a39dd80d
--- /dev/null
+++ b/browser/tests/golden/behavior/css/first_text.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::css",
+ "case": "first_text",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "li a",
+ "first": true
+ },
+ "ok": {
+ "result": "Apple"
+ }
+}
diff --git a/browser/tests/golden/behavior/css/general_sibling_attr_pseudo.json b/browser/tests/golden/behavior/css/general_sibling_attr_pseudo.json
new file mode 100644
index 000000000..cfd871ace
--- /dev/null
+++ b/browser/tests/golden/behavior/css/general_sibling_attr_pseudo.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::css",
+ "case": "general_sibling_attr_pseudo",
+ "request": {
+ "html": "<h1>H</h1><p data-x='a'>A</p><p data-x='b'>B</p>",
+ "query": "h1 ~ p::attr(data-x)"
+ },
+ "ok": {
+ "result": [
+ "a",
+ "b"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/grouped_selector_document_order.json b/browser/tests/golden/behavior/css/grouped_selector_document_order.json
new file mode 100644
index 000000000..69c16341d
--- /dev/null
+++ b/browser/tests/golden/behavior/css/grouped_selector_document_order.json
@@ -0,0 +1,15 @@
+{
+ "function": "browser::css",
+ "case": "grouped_selector_document_order",
+ "request": {
+ "html": "<p>P</p><h1>H</h1><p>Q</p>",
+ "query": "h1, p"
+ },
+ "ok": {
+ "result": [
+ "P",
+ "H",
+ "Q"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/invalid_selector.json b/browser/tests/golden/behavior/css/invalid_selector.json
new file mode 100644
index 000000000..ab1dd266b
--- /dev/null
+++ b/browser/tests/golden/behavior/css/invalid_selector.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::css",
+ "case": "invalid_selector",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "li:::bad"
+ },
+ "err": "Invalid CSS selector 'li:::bad': Expected ident, got <DELIM ':' at 4>"
+}
diff --git a/browser/tests/golden/behavior/css/no_match_first.json b/browser/tests/golden/behavior/css/no_match_first.json
new file mode 100644
index 000000000..f2d81e1f3
--- /dev/null
+++ b/browser/tests/golden/behavior/css/no_match_first.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::css",
+ "case": "no_match_first",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": ".nope",
+ "first": true
+ },
+ "ok": {
+ "result": null
+ }
+}
diff --git a/browser/tests/golden/behavior/css/no_match_modes.json b/browser/tests/golden/behavior/css/no_match_modes.json
new file mode 100644
index 000000000..55b9e57d5
--- /dev/null
+++ b/browser/tests/golden/behavior/css/no_match_modes.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::css",
+ "case": "no_match_modes",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": ".nope"
+ },
+ "ok": {
+ "result": []
+ }
+}
diff --git a/browser/tests/golden/behavior/css/nth_not_and_attribute_operators.json b/browser/tests/golden/behavior/css/nth_not_and_attribute_operators.json
new file mode 100644
index 000000000..6736c8d5d
--- /dev/null
+++ b/browser/tests/golden/behavior/css/nth_not_and_attribute_operators.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::css",
+ "case": "nth_not_and_attribute_operators",
+ "request": {
+ "html": "<ul><li class='x' data-v='en-us'>A</li><li data-v='en'>B</li><li data-v='fr'>C</li></ul>",
+ "query": "li:nth-child(2):not(.x)[data-v|='en']",
+ "first": true
+ },
+ "ok": {
+ "result": "B"
+ }
+}
diff --git a/browser/tests/golden/behavior/css/pseudo_attr.json b/browser/tests/golden/behavior/css/pseudo_attr.json
new file mode 100644
index 000000000..3d12b32d6
--- /dev/null
+++ b/browser/tests/golden/behavior/css/pseudo_attr.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::css",
+ "case": "pseudo_attr",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "a::attr(href)"
+ },
+ "ok": {
+ "result": [
+ "/a",
+ "/b"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/pseudo_text.json b/browser/tests/golden/behavior/css/pseudo_text.json
new file mode 100644
index 000000000..24898922e
--- /dev/null
+++ b/browser/tests/golden/behavior/css/pseudo_text.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::css",
+ "case": "pseudo_text",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "h1::text",
+ "first": true
+ },
+ "ok": {
+ "result": "Hello"
+ }
+}
diff --git a/browser/tests/golden/behavior/css/sibling_text_pseudo.json b/browser/tests/golden/behavior/css/sibling_text_pseudo.json
new file mode 100644
index 000000000..e4a28f8f3
--- /dev/null
+++ b/browser/tests/golden/behavior/css/sibling_text_pseudo.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::css",
+ "case": "sibling_text_pseudo",
+ "request": {
+ "html": "<h1>H</h1>x<p>A<b>B</b>C</p><p>D</p>",
+ "query": "h1 + p::text"
+ },
+ "ok": {
+ "result": [
+ "A",
+ "C"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/css/template_child_css.json b/browser/tests/golden/behavior/css/template_child_css.json
new file mode 100644
index 000000000..306a08768
--- /dev/null
+++ b/browser/tests/golden/behavior/css/template_child_css.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::css",
+ "case": "template_child_css",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "query": "template > p",
+ "first": true
+ },
+ "ok": {
+ "result": "never render this"
+ }
+}
diff --git a/browser/tests/golden/behavior/css/text_pseudo_messy_main.json b/browser/tests/golden/behavior/css/text_pseudo_messy_main.json
new file mode 100644
index 000000000..e4182b130
--- /dev/null
+++ b/browser/tests/golden/behavior/css/text_pseudo_messy_main.json
@@ -0,0 +1,18 @@
+{
+ "function": "browser::css",
+ "case": "text_pseudo_messy_main",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "query": "main::text"
+ },
+ "ok": {
+ "result": [
+ "\n ",
+ "\n ",
+ "\n ",
+ "\n ",
+ "\n ",
+ "\n"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/describe/h1_css.json b/browser/tests/golden/behavior/describe/h1_css.json
new file mode 100644
index 000000000..fbf67bd02
--- /dev/null
+++ b/browser/tests/golden/behavior/describe/h1_css.json
@@ -0,0 +1,29 @@
+{
+ "function": "browser::describe",
+ "case": "h1_css",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "h1"
+ },
+ "ok": {
+ "found": true,
+ "element": {
+ "tag": "h1",
+ "text": "Hello",
+ "html": "<h1 class=\"t\">Hello</h1>",
+ "attrs": {
+ "class": "t"
+ },
+ "css": "body > h1",
+ "xpath": "//body/h1",
+ "full_css": "body > h1",
+ "full_xpath": "//body/h1",
+ "classes": [
+ "t"
+ ],
+ "parent_tag": "body",
+ "children": 0,
+ "siblings": 2
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/describe/id_shortcircuit_full.json b/browser/tests/golden/behavior/describe/id_shortcircuit_full.json
new file mode 100644
index 000000000..815bd3090
--- /dev/null
+++ b/browser/tests/golden/behavior/describe/id_shortcircuit_full.json
@@ -0,0 +1,25 @@
+{
+ "function": "browser::describe",
+ "case": "id_shortcircuit_full",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "query": "#wrap p"
+ },
+ "ok": {
+ "found": true,
+ "element": {
+ "tag": "p",
+ "text": "bold\nafter-bold",
+ "html": "<p> <b>bold</b>after-bold</p>",
+ "attrs": {},
+ "css": "#wrap > p",
+ "xpath": "//*[@id='wrap']/p",
+ "full_css": "body > #wrap > p",
+ "full_xpath": "//body/*[@id='wrap']/p",
+ "classes": [],
+ "parent_tag": "div",
+ "children": 1,
+ "siblings": 11
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/describe/no_match.json b/browser/tests/golden/behavior/describe/no_match.json
new file mode 100644
index 000000000..25a36ad12
--- /dev/null
+++ b/browser/tests/golden/behavior/describe/no_match.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::describe",
+ "case": "no_match",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": ".nope"
+ },
+ "ok": {
+ "found": false
+ }
+}
diff --git a/browser/tests/golden/behavior/describe/text_pseudo.json b/browser/tests/golden/behavior/describe/text_pseudo.json
new file mode 100644
index 000000000..47b157ae2
--- /dev/null
+++ b/browser/tests/golden/behavior/describe/text_pseudo.json
@@ -0,0 +1,25 @@
+{
+ "function": "browser::describe",
+ "case": "text_pseudo",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "h1::text"
+ },
+ "ok": {
+ "found": true,
+ "element": {
+ "tag": "#text",
+ "text": "Hello",
+ "html": "Hello",
+ "attrs": {},
+ "css": "",
+ "xpath": "",
+ "full_css": "",
+ "full_xpath": "",
+ "classes": [],
+ "parent_tag": "h1",
+ "children": 0,
+ "siblings": 0
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/describe/weird_kind_is_xpath.json b/browser/tests/golden/behavior/describe/weird_kind_is_xpath.json
new file mode 100644
index 000000000..1f720c25d
--- /dev/null
+++ b/browser/tests/golden/behavior/describe/weird_kind_is_xpath.json
@@ -0,0 +1,30 @@
+{
+ "function": "browser::describe",
+ "case": "weird_kind_is_xpath",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//h1",
+ "kind": "bogus"
+ },
+ "ok": {
+ "found": true,
+ "element": {
+ "tag": "h1",
+ "text": "Hello",
+ "html": "<h1 class=\"t\">Hello</h1>",
+ "attrs": {
+ "class": "t"
+ },
+ "css": "body > h1",
+ "xpath": "//body/h1",
+ "full_css": "body > h1",
+ "full_xpath": "//body/h1",
+ "classes": [
+ "t"
+ ],
+ "parent_tag": "body",
+ "children": 0,
+ "siblings": 2
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/describe/xpath_kind.json b/browser/tests/golden/behavior/describe/xpath_kind.json
new file mode 100644
index 000000000..5b5ec9fea
--- /dev/null
+++ b/browser/tests/golden/behavior/describe/xpath_kind.json
@@ -0,0 +1,28 @@
+{
+ "function": "browser::describe",
+ "case": "xpath_kind",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//li[2]/a",
+ "kind": "xpath"
+ },
+ "ok": {
+ "found": true,
+ "element": {
+ "tag": "a",
+ "text": "Banana",
+ "html": "<a href=\"/b\">Banana</a>",
+ "attrs": {
+ "href": "/b"
+ },
+ "css": "body > ul > li:nth-of-type(2) > a",
+ "xpath": "//body/ul/li[2]/a",
+ "full_css": "body > ul > li:nth-of-type(2) > a",
+ "full_xpath": "//body/ul/li[2]/a",
+ "classes": [],
+ "parent_tag": "li",
+ "children": 0,
+ "siblings": 0
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/comments_removed_and_text_merged.json b/browser/tests/golden/behavior/extract/comments_removed_and_text_merged.json
new file mode 100644
index 000000000..98c1277e6
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/comments_removed_and_text_merged.json
@@ -0,0 +1,27 @@
+{
+ "function": "browser::extract",
+ "case": "comments_removed_and_text_merged",
+ "request": {
+ "html": "<p>a<!--gone-->b<![CDATA[c]]]]><![CDATA[>d</p>",
+ "selectors": [
+ {
+ "name": "text",
+ "xpath": "//p/text()",
+ "all": true
+ },
+ {
+ "name": "html",
+ "css": "p",
+ "html": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "text": [
+ "abd"
+ ],
+ "html": "<p>abd</p>"
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/detached_text_spec.json b/browser/tests/golden/behavior/extract/detached_text_spec.json
new file mode 100644
index 000000000..c30696511
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/detached_text_spec.json
@@ -0,0 +1,26 @@
+{
+ "function": "browser::extract",
+ "case": "detached_text_spec",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "selectors": [
+ {
+ "name": "card_text",
+ "css": "div.card ::text",
+ "all": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "card_text": [
+ "Card One",
+ "first card",
+ "Card Two",
+ "second card",
+ "Card Three",
+ "third card"
+ ]
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/empty_selectors.json b/browser/tests/golden/behavior/extract/empty_selectors.json
new file mode 100644
index 000000000..427498274
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/empty_selectors.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::extract",
+ "case": "empty_selectors",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "selectors": []
+ },
+ "ok": {
+ "extracted": {}
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/entities_and_invalid_codepoints.json b/browser/tests/golden/behavior/extract/entities_and_invalid_codepoints.json
new file mode 100644
index 000000000..620d1ff6e
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/entities_and_invalid_codepoints.json
@@ -0,0 +1,27 @@
+{
+ "function": "browser::extract",
+ "case": "entities_and_invalid_codepoints",
+ "request": {
+ "html": "<p>© ' � � ¬anentity;</p>",
+ "selectors": [
+ {
+ "name": "text",
+ "xpath": "//p/text()",
+ "all": true
+ },
+ {
+ "name": "html",
+ "css": "p",
+ "html": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "text": [
+ "© ' � � ¬anentity;"
+ ],
+ "html": "<p>© ' � � ¬anentity;</p>"
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/foreign_content_serialization.json b/browser/tests/golden/behavior/extract/foreign_content_serialization.json
new file mode 100644
index 000000000..6f63191c4
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/foreign_content_serialization.json
@@ -0,0 +1,19 @@
+{
+ "function": "browser::extract",
+ "case": "foreign_content_serialization",
+ "request": {
+ "html": "<svg viewBox='0 0 1 1'><foreignObject><DIV xlink:href='x'>T</DIV></foreignObject></svg>",
+ "selectors": [
+ {
+ "name": "svg",
+ "css": "svg",
+ "html": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "svg": "<svg viewbox=\"0 0 1 1\"><foreignobject><div xlink:href=\"x\">T</div></foreignobject></svg>"
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/malformed_table_recovery.json b/browser/tests/golden/behavior/extract/malformed_table_recovery.json
new file mode 100644
index 000000000..44ccb099a
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/malformed_table_recovery.json
@@ -0,0 +1,19 @@
+{
+ "function": "browser::extract",
+ "case": "malformed_table_recovery",
+ "request": {
+ "html": "<table><td>A<td>B<div>C",
+ "selectors": [
+ {
+ "name": "table",
+ "css": "table",
+ "html": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "table": "<table><td>A</td><td>B<div>C</div></td></table>"
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/misnested_formatting_recovery.json b/browser/tests/golden/behavior/extract/misnested_formatting_recovery.json
new file mode 100644
index 000000000..548992e46
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/misnested_formatting_recovery.json
@@ -0,0 +1,19 @@
+{
+ "function": "browser::extract",
+ "case": "misnested_formatting_recovery",
+ "request": {
+ "html": "<p><b>one<i>two</b>three</i>tail",
+ "selectors": [
+ {
+ "name": "body",
+ "css": "body",
+ "html": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "body": "<body><p><b>one<i>two</i></b>threetail</p></body>"
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/mixed_specs.json b/browser/tests/golden/behavior/extract/mixed_specs.json
new file mode 100644
index 000000000..1658d1da3
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/mixed_specs.json
@@ -0,0 +1,48 @@
+{
+ "function": "browser::extract",
+ "case": "mixed_specs",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "selectors": [
+ {
+ "name": "title",
+ "css": "h1"
+ },
+ {
+ "name": "links",
+ "css": "li a",
+ "attr": "href",
+ "all": true
+ },
+ {
+ "name": "names",
+ "css": "li a",
+ "all": true
+ },
+ {
+ "name": "price",
+ "regex": "price (\\d+)"
+ },
+ {
+ "name": "first_li_html",
+ "css": "li",
+ "html": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "title": "Hello",
+ "links": [
+ "/a",
+ "/b"
+ ],
+ "names": [
+ "Apple",
+ "Banana"
+ ],
+ "price": "42",
+ "first_li_html": "<li><a href=\"/a\">Apple</a></li>"
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/regex_all_spec.json b/browser/tests/golden/behavior/extract/regex_all_spec.json
new file mode 100644
index 000000000..8692732eb
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/regex_all_spec.json
@@ -0,0 +1,22 @@
+{
+ "function": "browser::extract",
+ "case": "regex_all_spec",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "selectors": [
+ {
+ "name": "nums",
+ "regex": "\\d+",
+ "all": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "nums": [
+ "42",
+ "99"
+ ]
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/spec_without_query.json b/browser/tests/golden/behavior/extract/spec_without_query.json
new file mode 100644
index 000000000..f056a5bd0
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/spec_without_query.json
@@ -0,0 +1,22 @@
+{
+ "function": "browser::extract",
+ "case": "spec_without_query",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "selectors": [
+ {
+ "name": "x"
+ },
+ {
+ "name": "y",
+ "all": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "x": null,
+ "y": []
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/template_nested_content.json b/browser/tests/golden/behavior/extract/template_nested_content.json
new file mode 100644
index 000000000..cfca0fcfd
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/template_nested_content.json
@@ -0,0 +1,27 @@
+{
+ "function": "browser::extract",
+ "case": "template_nested_content",
+ "request": {
+ "html": "<template><table><td>T</template><p>P",
+ "selectors": [
+ {
+ "name": "template",
+ "css": "template",
+ "html": true
+ },
+ {
+ "name": "td",
+ "xpath": "//template//td",
+ "all": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "template": "<template><table><td>T<p>P</p></td></table></template>",
+ "td": [
+ "T\nP"
+ ]
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/extract/xpath_specs.json b/browser/tests/golden/behavior/extract/xpath_specs.json
new file mode 100644
index 000000000..1734f5a89
--- /dev/null
+++ b/browser/tests/golden/behavior/extract/xpath_specs.json
@@ -0,0 +1,28 @@
+{
+ "function": "browser::extract",
+ "case": "xpath_specs",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "selectors": [
+ {
+ "name": "first_link",
+ "xpath": "//ul/li/a",
+ "attr": "href"
+ },
+ {
+ "name": "all_text",
+ "xpath": "//li/a/text()",
+ "all": true
+ }
+ ]
+ },
+ "ok": {
+ "extracted": {
+ "first_link": "/a",
+ "all_text": [
+ "Apple",
+ "Banana"
+ ]
+ }
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-regex/default_insensitive.json b/browser/tests/golden/behavior/find-by-regex/default_insensitive.json
new file mode 100644
index 000000000..3d339f780
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-regex/default_insensitive.json
@@ -0,0 +1,21 @@
+{
+ "function": "browser::find-by-regex",
+ "case": "default_insensitive",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "price \\d+"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "p",
+ "text": "price 42 usd then 99",
+ "html": "<p>price 42 usd then 99</p>",
+ "attrs": {},
+ "css": "body > p",
+ "xpath": "//body/p"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-regex/limit_zero.json b/browser/tests/golden/behavior/find-by-regex/limit_zero.json
new file mode 100644
index 000000000..39037f35a
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-regex/limit_zero.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::find-by-regex",
+ "case": "limit_zero",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "pattern": "\\w+",
+ "limit": 0
+ },
+ "ok": {
+ "count": 28,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-regex/messy_cards.json b/browser/tests/golden/behavior/find-by-regex/messy_cards.json
new file mode 100644
index 000000000..7c99723e7
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-regex/messy_cards.json
@@ -0,0 +1,37 @@
+{
+ "function": "browser::find-by-regex",
+ "case": "messy_cards",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "pattern": "card$"
+ },
+ "ok": {
+ "count": 3,
+ "items": [
+ {
+ "tag": "p",
+ "text": "first card",
+ "html": "<p>first card</p>",
+ "attrs": {},
+ "css": "body > main > div > p",
+ "xpath": "//body/main/div/p"
+ },
+ {
+ "tag": "p",
+ "text": "second card",
+ "html": "<p>second card</p>",
+ "attrs": {},
+ "css": "body > main > div:nth-of-type(2) > p",
+ "xpath": "//body/main/div[2]/p"
+ },
+ {
+ "tag": "p",
+ "text": "third card",
+ "html": "<p>third card</p>",
+ "attrs": {},
+ "css": "body > main > div:nth-of-type(3) > p",
+ "xpath": "//body/main/div[3]/p"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-regex/sensitive_miss.json b/browser/tests/golden/behavior/find-by-regex/sensitive_miss.json
new file mode 100644
index 000000000..28eb2bb0b
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-regex/sensitive_miss.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::find-by-regex",
+ "case": "sensitive_miss",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "PRICE \\d+",
+ "case_sensitive": true
+ },
+ "ok": {
+ "count": 0,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-regex/unicode_ignorecase_extra.json b/browser/tests/golden/behavior/find-by-regex/unicode_ignorecase_extra.json
new file mode 100644
index 000000000..3ca4536b0
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-regex/unicode_ignorecase_extra.json
@@ -0,0 +1,21 @@
+{
+ "function": "browser::find-by-regex",
+ "case": "unicode_ignorecase_extra",
+ "request": {
+ "html": "<p>Kelvin</p>",
+ "pattern": "kelvin"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "p",
+ "text": "Kelvin",
+ "html": "<p>Kelvin</p>",
+ "attrs": {},
+ "css": "body > p",
+ "xpath": "//body/p"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/case_sensitive_miss.json b/browser/tests/golden/behavior/find-by-text/case_sensitive_miss.json
new file mode 100644
index 000000000..7b666245e
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/case_sensitive_miss.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::find-by-text",
+ "case": "case_sensitive_miss",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "text": "apple",
+ "case_sensitive": true
+ },
+ "ok": {
+ "count": 0,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/clean_match_whitespace.json b/browser/tests/golden/behavior/find-by-text/clean_match_whitespace.json
new file mode 100644
index 000000000..293478da1
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/clean_match_whitespace.json
@@ -0,0 +1,21 @@
+{
+ "function": "browser::find-by-text",
+ "case": "clean_match_whitespace",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "text": "bold"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "b",
+ "text": "bold",
+ "html": "<b>bold</b>",
+ "attrs": {},
+ "css": "#wrap > p > b",
+ "xpath": "//*[@id='wrap']/p/b"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/clean_trims_trailing_space.json b/browser/tests/golden/behavior/find-by-text/clean_trims_trailing_space.json
new file mode 100644
index 000000000..616ff0cad
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/clean_trims_trailing_space.json
@@ -0,0 +1,21 @@
+{
+ "function": "browser::find-by-text",
+ "case": "clean_trims_trailing_space",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "text": "intro paragraph with"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "p",
+ "text": "Intro paragraph with\nemphasis\nand a\nlink\n.",
+ "html": "<p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>",
+ "attrs": {},
+ "css": "body > main > p",
+ "xpath": "//body/main/p"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/exact_default.json b/browser/tests/golden/behavior/find-by-text/exact_default.json
new file mode 100644
index 000000000..23019b892
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/exact_default.json
@@ -0,0 +1,23 @@
+{
+ "function": "browser::find-by-text",
+ "case": "exact_default",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "text": "Apple"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/first_flag.json b/browser/tests/golden/behavior/find-by-text/first_flag.json
new file mode 100644
index 000000000..b5be96f68
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/first_flag.json
@@ -0,0 +1,24 @@
+{
+ "function": "browser::find-by-text",
+ "case": "first_flag",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "text": "Apple",
+ "first": true
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/no_clean_exact_ws.json b/browser/tests/golden/behavior/find-by-text/no_clean_exact_ws.json
new file mode 100644
index 000000000..4cdb7c359
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/no_clean_exact_ws.json
@@ -0,0 +1,22 @@
+{
+ "function": "browser::find-by-text",
+ "case": "no_clean_exact_ws",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "text": "bold",
+ "clean_match": false
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "b",
+ "text": "bold",
+ "html": "<b>bold</b>",
+ "attrs": {},
+ "css": "#wrap > p > b",
+ "xpath": "//*[@id='wrap']/p/b"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/no_clean_keeps_trailing_space.json b/browser/tests/golden/behavior/find-by-text/no_clean_keeps_trailing_space.json
new file mode 100644
index 000000000..ed2fa8d03
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/no_clean_keeps_trailing_space.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::find-by-text",
+ "case": "no_clean_keeps_trailing_space",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "text": "intro paragraph with",
+ "clean_match": false
+ },
+ "ok": {
+ "count": 0,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/none.json b/browser/tests/golden/behavior/find-by-text/none.json
new file mode 100644
index 000000000..450c06579
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/none.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::find-by-text",
+ "case": "none",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "text": "Zebra"
+ },
+ "ok": {
+ "count": 0,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find-by-text/partial_case.json b/browser/tests/golden/behavior/find-by-text/partial_case.json
new file mode 100644
index 000000000..cfb76e0d2
--- /dev/null
+++ b/browser/tests/golden/behavior/find-by-text/partial_case.json
@@ -0,0 +1,24 @@
+{
+ "function": "browser::find-by-text",
+ "case": "partial_case",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "text": "aPP",
+ "partial": true
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/anchor_missing.json b/browser/tests/golden/behavior/find-similar/anchor_missing.json
new file mode 100644
index 000000000..7b8ac26f8
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/anchor_missing.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::find-similar",
+ "case": "anchor_missing",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "anchor": ".nope"
+ },
+ "ok": {
+ "count": 0,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/cards_attr_scoring.json b/browser/tests/golden/behavior/find-similar/cards_attr_scoring.json
new file mode 100644
index 000000000..a644d762a
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/cards_attr_scoring.json
@@ -0,0 +1,25 @@
+{
+ "function": "browser::find-similar",
+ "case": "cards_attr_scoring",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "anchor": "div.card[data-id='1']"
+ },
+ "ok": {
+ "count": 3,
+ "items": [
+ {
+ "text": "Card One\nfirst card",
+ "html": "<div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>"
+ },
+ {
+ "text": "Card Two\nsecond card",
+ "html": "<div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>"
+ },
+ {
+ "text": "Card Three\nthird card",
+ "html": "<div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/cards_high_threshold.json b/browser/tests/golden/behavior/find-similar/cards_high_threshold.json
new file mode 100644
index 000000000..9808f28df
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/cards_high_threshold.json
@@ -0,0 +1,18 @@
+{
+ "function": "browser::find-similar",
+ "case": "cards_high_threshold",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "anchor": "div.card[data-id='1']",
+ "similarity_threshold": 0.9
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "text": "Card One\nfirst card",
+ "html": "<div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/list_items.json b/browser/tests/golden/behavior/find-similar/list_items.json
new file mode 100644
index 000000000..676f30d30
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/list_items.json
@@ -0,0 +1,21 @@
+{
+ "function": "browser::find-similar",
+ "case": "list_items",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "anchor": "li"
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "text": "Apple",
+ "html": "<li><a href=\"/a\">Apple</a></li>"
+ },
+ {
+ "text": "Banana",
+ "html": "<li><a href=\"/b\">Banana</a></li>"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/match_text.json b/browser/tests/golden/behavior/find-similar/match_text.json
new file mode 100644
index 000000000..3c001eea6
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/match_text.json
@@ -0,0 +1,22 @@
+{
+ "function": "browser::find-similar",
+ "case": "match_text",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "anchor": "li",
+ "match_text": true
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "text": "Apple",
+ "html": "<li><a href=\"/a\">Apple</a></li>"
+ },
+ {
+ "text": "Banana",
+ "html": "<li><a href=\"/b\">Banana</a></li>"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/match_text_multiline_leading.json b/browser/tests/golden/behavior/find-similar/match_text_multiline_leading.json
new file mode 100644
index 000000000..06b5e2f26
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/match_text_multiline_leading.json
@@ -0,0 +1,23 @@
+{
+ "function": "browser::find-similar",
+ "case": "match_text_multiline_leading",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "anchor": "#wrap > div",
+ "match_text": true,
+ "similarity_threshold": 0.99
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "text": "line one\nand two \nx",
+ "html": "<div>line one\nand two <b>x</b></div>"
+ },
+ {
+ "text": "line oneand two \ny",
+ "html": "<div data-x=\"1\">line oneand two <b>y</b></div>"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/subselector_scope_cannot_escape.json b/browser/tests/golden/behavior/find-similar/subselector_scope_cannot_escape.json
new file mode 100644
index 000000000..3e50125f2
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/subselector_scope_cannot_escape.json
@@ -0,0 +1,31 @@
+{
+ "function": "browser::find-similar",
+ "case": "subselector_scope_cannot_escape",
+ "request": {
+ "html": "<main><section><a>inside</a></section></main><a>outside</a>",
+ "anchor": "section",
+ "selectors": [
+ {
+ "name": "escaped",
+ "css": "body a",
+ "all": true
+ },
+ {
+ "name": "inside",
+ "css": "a",
+ "all": true
+ }
+ ]
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "escaped": [],
+ "inside": [
+ "inside"
+ ]
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find-similar/subselectors.json b/browser/tests/golden/behavior/find-similar/subselectors.json
new file mode 100644
index 000000000..72f6d91b1
--- /dev/null
+++ b/browser/tests/golden/behavior/find-similar/subselectors.json
@@ -0,0 +1,26 @@
+{
+ "function": "browser::find-similar",
+ "case": "subselectors",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "anchor": "li",
+ "selectors": [
+ {
+ "name": "href",
+ "css": "a",
+ "attr": "href"
+ }
+ ]
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "href": "/a"
+ },
+ {
+ "href": "/b"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/attrs_bool_coercion.json b/browser/tests/golden/behavior/find/attrs_bool_coercion.json
new file mode 100644
index 000000000..5aa76a773
--- /dev/null
+++ b/browser/tests/golden/behavior/find/attrs_bool_coercion.json
@@ -0,0 +1,15 @@
+{
+ "function": "browser::find",
+ "case": "attrs_bool_coercion",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "tag": "input",
+ "attrs": {
+ "disabled": ""
+ }
+ },
+ "ok": {
+ "count": 0,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find/attrs_exact_whole_value.json b/browser/tests/golden/behavior/find/attrs_exact_whole_value.json
new file mode 100644
index 000000000..bcdeb9a92
--- /dev/null
+++ b/browser/tests/golden/behavior/find/attrs_exact_whole_value.json
@@ -0,0 +1,37 @@
+{
+ "function": "browser::find",
+ "case": "attrs_exact_whole_value",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "attrs": {
+ "class": "card"
+ }
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "tag": "div",
+ "text": "Card One\nfirst card",
+ "html": "<div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>",
+ "attrs": {
+ "class": "card",
+ "data-id": "1"
+ },
+ "css": "body > main > div",
+ "xpath": "//body/main/div"
+ },
+ {
+ "tag": "div",
+ "text": "Card Two\nsecond card",
+ "html": "<div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>",
+ "attrs": {
+ "class": "card",
+ "data-id": "2"
+ },
+ "css": "body > main > div:nth-of-type(2)",
+ "xpath": "//body/main/div[2]"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/attrs_operator_contains.json b/browser/tests/golden/behavior/find/attrs_operator_contains.json
new file mode 100644
index 000000000..c4db3889e
--- /dev/null
+++ b/browser/tests/golden/behavior/find/attrs_operator_contains.json
@@ -0,0 +1,25 @@
+{
+ "function": "browser::find",
+ "case": "attrs_operator_contains",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "attrs": {
+ "href*": "/a"
+ }
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/attrs_operator_prefix.json b/browser/tests/golden/behavior/find/attrs_operator_prefix.json
new file mode 100644
index 000000000..45bf71957
--- /dev/null
+++ b/browser/tests/golden/behavior/find/attrs_operator_prefix.json
@@ -0,0 +1,35 @@
+{
+ "function": "browser::find",
+ "case": "attrs_operator_prefix",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "attrs": {
+ "href^": "/"
+ }
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ },
+ {
+ "tag": "a",
+ "text": "Banana",
+ "html": "<a href=\"/b\">Banana</a>",
+ "attrs": {
+ "href": "/b"
+ },
+ "css": "body > ul > li:nth-of-type(2) > a",
+ "xpath": "//body/ul/li[2]/a"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/by_tag.json b/browser/tests/golden/behavior/find/by_tag.json
new file mode 100644
index 000000000..fbaaf9096
--- /dev/null
+++ b/browser/tests/golden/behavior/find/by_tag.json
@@ -0,0 +1,33 @@
+{
+ "function": "browser::find",
+ "case": "by_tag",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "tag": "a"
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ },
+ {
+ "tag": "a",
+ "text": "Banana",
+ "html": "<a href=\"/b\">Banana</a>",
+ "attrs": {
+ "href": "/b"
+ },
+ "css": "body > ul > li:nth-of-type(2) > a",
+ "xpath": "//body/ul/li[2]/a"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/by_tag_input_attrs_map.json b/browser/tests/golden/behavior/find/by_tag_input_attrs_map.json
new file mode 100644
index 000000000..9df943209
--- /dev/null
+++ b/browser/tests/golden/behavior/find/by_tag_input_attrs_map.json
@@ -0,0 +1,24 @@
+{
+ "function": "browser::find",
+ "case": "by_tag_input_attrs_map",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "tag": "input"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "input",
+ "text": "",
+ "html": "<input disabled type=\"text\">",
+ "attrs": {
+ "disabled": "disabled",
+ "type": "text"
+ },
+ "css": "#wrap > input",
+ "xpath": "//*[@id='wrap']/input"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/by_tag_list.json b/browser/tests/golden/behavior/find/by_tag_list.json
new file mode 100644
index 000000000..2dc7207d6
--- /dev/null
+++ b/browser/tests/golden/behavior/find/by_tag_list.json
@@ -0,0 +1,34 @@
+{
+ "function": "browser::find",
+ "case": "by_tag_list",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "tag": [
+ "h1",
+ "p"
+ ]
+ },
+ "ok": {
+ "count": 2,
+ "items": [
+ {
+ "tag": "h1",
+ "text": "Hello",
+ "html": "<h1 class=\"t\">Hello</h1>",
+ "attrs": {
+ "class": "t"
+ },
+ "css": "body > h1",
+ "xpath": "//body/h1"
+ },
+ {
+ "tag": "p",
+ "text": "price 42 usd then 99",
+ "html": "<p>price 42 usd then 99</p>",
+ "attrs": {},
+ "css": "body > p",
+ "xpath": "//body/p"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/duplicate_and_boolean_attributes.json b/browser/tests/golden/behavior/find/duplicate_and_boolean_attributes.json
new file mode 100644
index 000000000..7e7859b2d
--- /dev/null
+++ b/browser/tests/golden/behavior/find/duplicate_and_boolean_attributes.json
@@ -0,0 +1,26 @@
+{
+ "function": "browser::find",
+ "case": "duplicate_and_boolean_attributes",
+ "request": {
+ "html": "<input z=1 disabled a='' z=2 checked=checked>",
+ "tag": "input"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "input",
+ "text": "",
+ "html": "<input z=\"1\" disabled a=\"\" checked>",
+ "attrs": {
+ "z": "1",
+ "disabled": "disabled",
+ "a": "",
+ "checked": "checked"
+ },
+ "css": "body > input",
+ "xpath": "//body/input"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/empty_text_regex_error.json b/browser/tests/golden/behavior/find/empty_text_regex_error.json
new file mode 100644
index 000000000..12ef42970
--- /dev/null
+++ b/browser/tests/golden/behavior/find/empty_text_regex_error.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::find",
+ "case": "empty_text_regex_error",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "text_regex": ""
+ },
+ "err": "provide at least one of `tag`, `attrs`, `text_regex`"
+}
diff --git a/browser/tests/golden/behavior/find/implied_document_nodes.json b/browser/tests/golden/behavior/find/implied_document_nodes.json
new file mode 100644
index 000000000..d29c6ca13
--- /dev/null
+++ b/browser/tests/golden/behavior/find/implied_document_nodes.json
@@ -0,0 +1,41 @@
+{
+ "function": "browser::find",
+ "case": "implied_document_nodes",
+ "request": {
+ "html": "<title>T</title><p>P",
+ "tag": [
+ "html",
+ "head",
+ "body"
+ ]
+ },
+ "ok": {
+ "count": 3,
+ "items": [
+ {
+ "tag": "html",
+ "text": "T\nP",
+ "html": "<html><head><title>T</title></head><body><p>P</p></body></html>",
+ "attrs": {},
+ "css": "",
+ "xpath": "//"
+ },
+ {
+ "tag": "head",
+ "text": "T",
+ "html": "<head><title>T</title></head>",
+ "attrs": {},
+ "css": "head",
+ "xpath": "//head"
+ },
+ {
+ "tag": "body",
+ "text": "P",
+ "html": "<body><p>P</p></body>",
+ "attrs": {},
+ "css": "body",
+ "xpath": "//body"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/limit_clamps.json b/browser/tests/golden/behavior/find/limit_clamps.json
new file mode 100644
index 000000000..44864aa57
--- /dev/null
+++ b/browser/tests/golden/behavior/find/limit_clamps.json
@@ -0,0 +1,30 @@
+{
+ "function": "browser::find",
+ "case": "limit_clamps",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "tag": "li",
+ "limit": 2
+ },
+ "ok": {
+ "count": 5,
+ "items": [
+ {
+ "tag": "li",
+ "text": "Home",
+ "html": "<li><a href=\"/home\">Home</a></li>",
+ "attrs": {},
+ "css": "body > nav > ul > li",
+ "xpath": "//body/nav/ul/li"
+ },
+ {
+ "tag": "li",
+ "text": "About",
+ "html": "<li><a href=\"/about\">About</a></li>",
+ "attrs": {},
+ "css": "body > nav > ul > li:nth-of-type(2)",
+ "xpath": "//body/nav/ul/li[2]"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/negative_limit_empty.json b/browser/tests/golden/behavior/find/negative_limit_empty.json
new file mode 100644
index 000000000..9611b8a11
--- /dev/null
+++ b/browser/tests/golden/behavior/find/negative_limit_empty.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::find",
+ "case": "negative_limit_empty",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "tag": "a",
+ "limit": -1
+ },
+ "ok": {
+ "count": 2,
+ "items": []
+ }
+}
diff --git a/browser/tests/golden/behavior/find/no_filters_error.json b/browser/tests/golden/behavior/find/no_filters_error.json
new file mode 100644
index 000000000..6861cc873
--- /dev/null
+++ b/browser/tests/golden/behavior/find/no_filters_error.json
@@ -0,0 +1,8 @@
+{
+ "function": "browser::find",
+ "case": "no_filters_error",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n"
+ },
+ "err": "provide at least one of `tag`, `attrs`, `text_regex`"
+}
diff --git a/browser/tests/golden/behavior/find/star_tag_falls_through.json b/browser/tests/golden/behavior/find/star_tag_falls_through.json
new file mode 100644
index 000000000..adf6203d7
--- /dev/null
+++ b/browser/tests/golden/behavior/find/star_tag_falls_through.json
@@ -0,0 +1,91 @@
+{
+ "function": "browser::find",
+ "case": "star_tag_falls_through",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "tag": "*"
+ },
+ "ok": {
+ "count": 9,
+ "items": [
+ {
+ "tag": "head",
+ "text": "",
+ "html": "<head></head>",
+ "attrs": {},
+ "css": "head",
+ "xpath": "//head"
+ },
+ {
+ "tag": "body",
+ "text": "Hello\nApple\nBanana\nprice 42 usd then 99",
+ "html": "<body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body>",
+ "attrs": {},
+ "css": "body",
+ "xpath": "//body"
+ },
+ {
+ "tag": "h1",
+ "text": "Hello",
+ "html": "<h1 class=\"t\">Hello</h1>",
+ "attrs": {
+ "class": "t"
+ },
+ "css": "body > h1",
+ "xpath": "//body/h1"
+ },
+ {
+ "tag": "ul",
+ "text": "Apple\nBanana",
+ "html": "<ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul>",
+ "attrs": {},
+ "css": "body > ul",
+ "xpath": "//body/ul"
+ },
+ {
+ "tag": "li",
+ "text": "Apple",
+ "html": "<li><a href=\"/a\">Apple</a></li>",
+ "attrs": {},
+ "css": "body > ul > li",
+ "xpath": "//body/ul/li"
+ },
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ },
+ {
+ "tag": "li",
+ "text": "Banana",
+ "html": "<li><a href=\"/b\">Banana</a></li>",
+ "attrs": {},
+ "css": "body > ul > li:nth-of-type(2)",
+ "xpath": "//body/ul/li[2]"
+ },
+ {
+ "tag": "a",
+ "text": "Banana",
+ "html": "<a href=\"/b\">Banana</a>",
+ "attrs": {
+ "href": "/b"
+ },
+ "css": "body > ul > li:nth-of-type(2) > a",
+ "xpath": "//body/ul/li[2]/a"
+ },
+ {
+ "tag": "p",
+ "text": "price 42 usd then 99",
+ "html": "<p>price 42 usd then 99</p>",
+ "attrs": {},
+ "css": "body > p",
+ "xpath": "//body/p"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/tag_and_text_regex.json b/browser/tests/golden/behavior/find/tag_and_text_regex.json
new file mode 100644
index 000000000..87917899a
--- /dev/null
+++ b/browser/tests/golden/behavior/find/tag_and_text_regex.json
@@ -0,0 +1,25 @@
+{
+ "function": "browser::find",
+ "case": "tag_and_text_regex",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "tag": "a",
+ "text_regex": "Ap",
+ "first": true
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "a",
+ "text": "Apple",
+ "html": "<a href=\"/a\">Apple</a>",
+ "attrs": {
+ "href": "/a"
+ },
+ "css": "body > ul > li > a",
+ "xpath": "//body/ul/li/a"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/tag_html_root.json b/browser/tests/golden/behavior/find/tag_html_root.json
new file mode 100644
index 000000000..9e227a9fe
--- /dev/null
+++ b/browser/tests/golden/behavior/find/tag_html_root.json
@@ -0,0 +1,21 @@
+{
+ "function": "browser::find",
+ "case": "tag_html_root",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "tag": "html"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "html",
+ "text": "Hello\nApple\nBanana\nprice 42 usd then 99",
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>",
+ "attrs": {},
+ "css": "",
+ "xpath": "//"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/find/text_regex_only_all_elements.json b/browser/tests/golden/behavior/find/text_regex_only_all_elements.json
new file mode 100644
index 000000000..84a33f2b1
--- /dev/null
+++ b/browser/tests/golden/behavior/find/text_regex_only_all_elements.json
@@ -0,0 +1,21 @@
+{
+ "function": "browser::find",
+ "case": "text_regex_only_all_elements",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "text_regex": "price"
+ },
+ "ok": {
+ "count": 1,
+ "items": [
+ {
+ "tag": "p",
+ "text": "price 42 usd then 99",
+ "html": "<p>price 42 usd then 99</p>",
+ "attrs": {},
+ "css": "body > p",
+ "xpath": "//body/p"
+ }
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/across_fragments_edge.json b/browser/tests/golden/behavior/regex/across_fragments_edge.json
new file mode 100644
index 000000000..b0493de58
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/across_fragments_edge.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::regex",
+ "case": "across_fragments_edge",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "pattern": "CONDITION: \\w+"
+ },
+ "ok": {
+ "result": [
+ "CONDITION: Excellent"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/atomic_and_possessive.json b/browser/tests/golden/behavior/regex/atomic_and_possessive.json
new file mode 100644
index 000000000..6cd63d2dc
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/atomic_and_possessive.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::regex",
+ "case": "atomic_and_possessive",
+ "request": {
+ "html": "<p>aaab aaaa</p>",
+ "pattern": "(?>a+)b|a++a"
+ },
+ "ok": {
+ "result": [
+ "aaab"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/entities_edge.json b/browser/tests/golden/behavior/regex/entities_edge.json
new file mode 100644
index 000000000..37917015f
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/entities_edge.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::regex",
+ "case": "entities_edge",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "pattern": "A&B"
+ },
+ "ok": {
+ "result": [
+ "A&B"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/first_group.json b/browser/tests/golden/behavior/regex/first_group.json
new file mode 100644
index 000000000..1f7e8bc1c
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/first_group.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::regex",
+ "case": "first_group",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "price (\\d+)",
+ "first": true
+ },
+ "ok": {
+ "result": "42"
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/invalid_global_flag_position.json b/browser/tests/golden/behavior/regex/invalid_global_flag_position.json
new file mode 100644
index 000000000..c831773c9
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/invalid_global_flag_position.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::regex",
+ "case": "invalid_global_flag_position",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "a(?i)b"
+ },
+ "err": "global flags not at the start of the expression at position 1"
+}
diff --git a/browser/tests/golden/behavior/regex/invalid_group_reference.json b/browser/tests/golden/behavior/regex/invalid_group_reference.json
new file mode 100644
index 000000000..43f509ef1
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/invalid_group_reference.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::regex",
+ "case": "invalid_group_reference",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "\\1"
+ },
+ "err": "invalid group reference 1 at position 1"
+}
diff --git a/browser/tests/golden/behavior/regex/invalid_range.json b/browser/tests/golden/behavior/regex/invalid_range.json
new file mode 100644
index 000000000..a698b4b99
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/invalid_range.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::regex",
+ "case": "invalid_range",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "[z-a]"
+ },
+ "err": "bad character range z-a at position 1"
+}
diff --git a/browser/tests/golden/behavior/regex/invalid_unterminated_group.json b/browser/tests/golden/behavior/regex/invalid_unterminated_group.json
new file mode 100644
index 000000000..9c4152ccc
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/invalid_unterminated_group.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::regex",
+ "case": "invalid_unterminated_group",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "("
+ },
+ "err": "missing ), unterminated subpattern at position 0"
+}
diff --git a/browser/tests/golden/behavior/regex/invalid_variable_lookbehind.json b/browser/tests/golden/behavior/regex/invalid_variable_lookbehind.json
new file mode 100644
index 000000000..e941fafea
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/invalid_variable_lookbehind.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::regex",
+ "case": "invalid_variable_lookbehind",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "(?<=a*)b"
+ },
+ "err": "look-behind requires fixed-width pattern"
+}
diff --git a/browser/tests/golden/behavior/regex/lookbehind_and_conditional.json b/browser/tests/golden/behavior/regex/lookbehind_and_conditional.json
new file mode 100644
index 000000000..cbc12184a
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/lookbehind_and_conditional.json
@@ -0,0 +1,22 @@
+{
+ "function": "browser::regex",
+ "case": "lookbehind_and_conditional",
+ "request": {
+ "html": "<p>abcdef ab c</p>",
+ "pattern": "(?:(?<=abc)def)|((a)?(?(2)b|c))"
+ },
+ "ok": {
+ "result": [
+ "ab",
+ "a",
+ "c",
+ "",
+ "",
+ "",
+ "ab",
+ "a",
+ "c",
+ ""
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/named_backreference.json b/browser/tests/golden/behavior/regex/named_backreference.json
new file mode 100644
index 000000000..e1de63271
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/named_backreference.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::regex",
+ "case": "named_backreference",
+ "request": {
+ "html": "<p>ab-ab ab-ac</p>",
+ "pattern": "(?P<word>ab)-(?P=word)"
+ },
+ "ok": {
+ "result": [
+ "ab"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/no_match_all.json b/browser/tests/golden/behavior/regex/no_match_all.json
new file mode 100644
index 000000000..31d4a238f
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/no_match_all.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::regex",
+ "case": "no_match_all",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "zzz"
+ },
+ "ok": {
+ "result": []
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/no_match_first.json b/browser/tests/golden/behavior/regex/no_match_first.json
new file mode 100644
index 000000000..c98fa06e2
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/no_match_first.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::regex",
+ "case": "no_match_first",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "zzz",
+ "first": true
+ },
+ "ok": {
+ "result": null
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/smoke_all.json b/browser/tests/golden/behavior/regex/smoke_all.json
new file mode 100644
index 000000000..8687ba3f2
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/smoke_all.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::regex",
+ "case": "smoke_all",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "\\d+"
+ },
+ "ok": {
+ "result": [
+ "42",
+ "99"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/two_groups.json b/browser/tests/golden/behavior/regex/two_groups.json
new file mode 100644
index 000000000..ff080aa5b
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/two_groups.json
@@ -0,0 +1,16 @@
+{
+ "function": "browser::regex",
+ "case": "two_groups",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "pattern": "(\\w+) (\\d+)"
+ },
+ "ok": {
+ "result": [
+ "price",
+ "42",
+ "then",
+ "99"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/unicode_name_escape.json b/browser/tests/golden/behavior/regex/unicode_name_escape.json
new file mode 100644
index 000000000..c266ef7f6
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/unicode_name_escape.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::regex",
+ "case": "unicode_name_escape",
+ "request": {
+ "html": "<p>A—B</p>",
+ "pattern": "\\N{EM DASH}"
+ },
+ "ok": {
+ "result": [
+ "—"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/w3lib_html4_entities.json b/browser/tests/golden/behavior/regex/w3lib_html4_entities.json
new file mode 100644
index 000000000..a65dcfd51
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/w3lib_html4_entities.json
@@ -0,0 +1,18 @@
+{
+ "function": "browser::regex",
+ "case": "w3lib_html4_entities",
+ "request": {
+ "html": "<p>&apos; &Copy; &#128; &#129; &unknown; &unknown</p>",
+ "pattern": "&(?:[A-Za-z]+|#[0-9]+);?"
+ },
+ "ok": {
+ "result": [
+ "",
+ "©",
+ "€",
+ "",
+ "",
+ "&unknown"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/regex/zero_width_findall.json b/browser/tests/golden/behavior/regex/zero_width_findall.json
new file mode 100644
index 000000000..8805c5090
--- /dev/null
+++ b/browser/tests/golden/behavior/regex/zero_width_findall.json
@@ -0,0 +1,15 @@
+{
+ "function": "browser::regex",
+ "case": "zero_width_findall",
+ "request": {
+ "html": "<p>ab</p>",
+ "pattern": "x*"
+ },
+ "ok": {
+ "result": [
+ "",
+ "",
+ ""
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/bad_format.json b/browser/tests/golden/behavior/to-markdown/bad_format.json
new file mode 100644
index 000000000..2115a92e0
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/bad_format.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::to-markdown",
+ "case": "bad_format",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "format": "pdf"
+ },
+ "err": "unsupported format: pdf"
+}
diff --git a/browser/tests/golden/behavior/to-markdown/hidden_body_self_exempt.json b/browser/tests/golden/behavior/to-markdown/hidden_body_self_exempt.json
new file mode 100644
index 000000000..c0a886413
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/hidden_body_self_exempt.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::to-markdown",
+ "case": "hidden_body_self_exempt",
+ "request": {
+ "html": "<html><head></head><body aria-hidden=\"true\"><p>keep me</p></body></html>",
+ "format": "text",
+ "main_content_only": true
+ },
+ "ok": {
+ "format": "text",
+ "content": "keep me"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/html_roundtrip.json b/browser/tests/golden/behavior/to-markdown/html_roundtrip.json
new file mode 100644
index 000000000..86d20ab63
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/html_roundtrip.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::to-markdown",
+ "case": "html_roundtrip",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "format": "html"
+ },
+ "ok": {
+ "format": "html",
+ "content": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/markdown_basic.json b/browser/tests/golden/behavior/to-markdown/markdown_basic.json
new file mode 100644
index 000000000..33d96c80d
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/markdown_basic.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::to-markdown",
+ "case": "markdown_basic",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n"
+ },
+ "ok": {
+ "format": "markdown",
+ "content": "Hello\n=====\n\n* [Apple](/a)\n* [Banana](/b)\n\nprice 42 usd then 99"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/markdown_blocks_and_lists.json b/browser/tests/golden/behavior/to-markdown/markdown_blocks_and_lists.json
new file mode 100644
index 000000000..003bf7325
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/markdown_blocks_and_lists.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::to-markdown",
+ "case": "markdown_blocks_and_lists",
+ "request": {
+ "html": "\n <div><blockquote><p>one<br>two</p><ul><li>A<ul><li>B<ul><li>C</li></ul></li></ul></li><li>D</li></ul></blockquote>\n <ol start=\"3\"><li>Three</li><li><p>Four</p></li></ol>\n <dl><dt> Term one </dt><dd>definition\nline</dd><dt>Next</dt><dd><b>bold</b></dd></dl>\n <pre>\n a * b\n`tick`\n</pre></div><p>after</p>\n "
+ },
+ "ok": {
+ "format": "markdown",
+ "content": "> one \n> two\n>\n> * A\n> + B\n> - C\n> * D\n\n3. Three\n4. Four\n\nTerm one\n: definition\n line\n\nNext\n: **bold**\n\n```\n a * b\n`tick`\n```\n\nafter"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/markdown_html_parser_second_parse.json b/browser/tests/golden/behavior/to-markdown/markdown_html_parser_second_parse.json
new file mode 100644
index 000000000..1229435e6
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/markdown_html_parser_second_parse.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::to-markdown",
+ "case": "markdown_html_parser_second_parse",
+ "request": {
+ "html": "<p>before</p><plaintext><b>looks bold</b><p>tail</p></plaintext><p>after</p>"
+ },
+ "ok": {
+ "format": "markdown",
+ "content": "before\n\n<b>looks bold</b><p>tail</p></plaintext><p>after</p></plaintext></body></html>"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/markdown_inline_defaults.json b/browser/tests/golden/behavior/to-markdown/markdown_inline_defaults.json
new file mode 100644
index 000000000..2241f6ad6
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/markdown_inline_defaults.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::to-markdown",
+ "case": "markdown_inline_defaults",
+ "request": {
+ "html": "\n <h1> A *title* </h1><h2>Sub_head</h2><h3>Third\n head</h3>\n <p><strong> bold </strong> <em>em</em> <del>gone</del>\n <code>a``b</code><br><q>quote</q> H<sub>2</sub>O x<sup>2</sup></p>\n <p><a href=\"https://e.test/a_b\">https://e.test/a_b</a>\n <a href=\"/x\" title='a\"b'> Link </a>\n <img alt=\"A\" src=\"i.png\" title='t\"x'></p><hr>\n "
+ },
+ "ok": {
+ "format": "markdown",
+ "content": "A \\*title\\*\n===========\n\nSub\\_head\n---------\n\n### Third head\n\n**bold** *em* ~~gone~~\n``` a``b ``` \n\"quote\" H2O x2\n\n<https://e.test/a_b>\n [Link](/x \"a\\\"b\") \n![A](i.png \"t\\\"x\")\n\n---"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/markdown_table_and_video.json b/browser/tests/golden/behavior/to-markdown/markdown_table_and_video.json
new file mode 100644
index 000000000..3521a364c
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/markdown_table_and_video.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::to-markdown",
+ "case": "markdown_table_and_video",
+ "request": {
+ "html": "\n <figure><table><caption> Cap </caption><thead><tr><th colspan=\"2\">Head <img alt=\"ALT\" src=\"x\"></th></tr></thead>\n <tbody><tr><td>A</td><td><b>B</b><br>C</td></tr></tbody></table>\n <figcaption> Figure text </figcaption></figure>\n <video poster=\"poster.jpg\"><source src=\"movie.mp4\">Trailer</video><video src=\"only.mp4\">Only</video>\n "
+ },
+ "ok": {
+ "format": "markdown",
+ "content": "Cap\n\n| Head ALT | |\n| --- | --- |\n| A | **B** C |\n\nFigure text\n\n[](movie.mp4)[Only](only.mp4)"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/markdown_unknown_and_noise_tags.json b/browser/tests/golden/behavior/to-markdown/markdown_unknown_and_noise_tags.json
new file mode 100644
index 000000000..fce134481
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/markdown_unknown_and_noise_tags.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::to-markdown",
+ "case": "markdown_unknown_and_noise_tags",
+ "request": {
+ "html": "\n <!doctype html><!--before--><main data-x=\"1\"><custom-tag> alpha beta\n gamma </custom-tag>\n <p>before <span>mid</span> after</p><script>bad()</script><style>x{}</style>\n <template><p>T</p></template></main>\n "
+ },
+ "ok": {
+ "format": "markdown",
+ "content": "alpha beta\ngamma \n\nbefore mid after\n\nT"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/pseudo_text_selector_html_mode.json b/browser/tests/golden/behavior/to-markdown/pseudo_text_selector_html_mode.json
new file mode 100644
index 000000000..7edcf2e2d
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/pseudo_text_selector_html_mode.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::to-markdown",
+ "case": "pseudo_text_selector_html_mode",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "format": "html",
+ "css_selector": "li a::text"
+ },
+ "ok": {
+ "format": "html",
+ "content": "AppleBanana"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/pseudo_text_selector_text_mode.json b/browser/tests/golden/behavior/to-markdown/pseudo_text_selector_text_mode.json
new file mode 100644
index 000000000..170a4dc34
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/pseudo_text_selector_text_mode.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::to-markdown",
+ "case": "pseudo_text_selector_text_mode",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "format": "text",
+ "css_selector": "li a::text"
+ },
+ "ok": {
+ "format": "text",
+ "content": "AppleBanana"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/scoped_css.json b/browser/tests/golden/behavior/to-markdown/scoped_css.json
new file mode 100644
index 000000000..caff64c32
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/scoped_css.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::to-markdown",
+ "case": "scoped_css",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "format": "text",
+ "css_selector": "div.card"
+ },
+ "ok": {
+ "format": "text",
+ "content": "Card One\nfirst cardCard Two\nsecond cardCard Three\nthird card"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/text_basic.json b/browser/tests/golden/behavior/to-markdown/text_basic.json
new file mode 100644
index 000000000..62e43c1b2
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/text_basic.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::to-markdown",
+ "case": "text_basic",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "format": "text"
+ },
+ "ok": {
+ "format": "text",
+ "content": "Hello\nApple\nBanana\nprice 42 usd then 99"
+ }
+}
diff --git a/browser/tests/golden/behavior/to-markdown/text_messy_main_only.json b/browser/tests/golden/behavior/to-markdown/text_messy_main_only.json
new file mode 100644
index 000000000..26735b811
--- /dev/null
+++ b/browser/tests/golden/behavior/to-markdown/text_messy_main_only.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::to-markdown",
+ "case": "text_messy_main_only",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "format": "text",
+ "main_content_only": true
+ },
+ "ok": {
+ "format": "text",
+ "content": "Home\nAbout\nWidget Review\nIntro paragraph with\nemphasis\nand a\nlink\n.\nSpecs\nName\nValue\nWeight\n3kg\nalpha\nnested\nbeta\nCard One\nfirst card\nCard Two\nsecond card\nCard Three\nthird card\n© 2026 Example — fine print"
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/all_anchors_text.json b/browser/tests/golden/behavior/xpath/all_anchors_text.json
new file mode 100644
index 000000000..8ab8929c8
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/all_anchors_text.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::xpath",
+ "case": "all_anchors_text",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//ul/li/a"
+ },
+ "ok": {
+ "result": [
+ "Apple",
+ "Banana"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/ancestor_axis_reverse_position.json b/browser/tests/golden/behavior/xpath/ancestor_axis_reverse_position.json
new file mode 100644
index 000000000..0891ab38a
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/ancestor_axis_reverse_position.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "ancestor_axis_reverse_position",
+ "request": {
+ "html": "<main id='m'><section id='s'><p>P</p></section></main>",
+ "query": "//p/ancestor::*[1]/@id"
+ },
+ "ok": {
+ "result": [
+ "s"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/attr_axis_terminal.json b/browser/tests/golden/behavior/xpath/attr_axis_terminal.json
new file mode 100644
index 000000000..192d1121b
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/attr_axis_terminal.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::xpath",
+ "case": "attr_axis_terminal",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//a/@href"
+ },
+ "ok": {
+ "result": [
+ "/a",
+ "/b"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/attr_param_on_elements.json b/browser/tests/golden/behavior/xpath/attr_param_on_elements.json
new file mode 100644
index 000000000..9b92491d7
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/attr_param_on_elements.json
@@ -0,0 +1,15 @@
+{
+ "function": "browser::xpath",
+ "case": "attr_param_on_elements",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//li/a",
+ "attr": "href"
+ },
+ "ok": {
+ "result": [
+ "/a",
+ "/b"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/attribute_wildcard_order.json b/browser/tests/golden/behavior/xpath/attribute_wildcard_order.json
new file mode 100644
index 000000000..b04f0413a
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/attribute_wildcard_order.json
@@ -0,0 +1,15 @@
+{
+ "function": "browser::xpath",
+ "case": "attribute_wildcard_order",
+ "request": {
+ "html": "<p z='1' a='2' m='3'>P</p>",
+ "query": "//p/@*"
+ },
+ "ok": {
+ "result": [
+ "1",
+ "2",
+ "3"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/contains_href.json b/browser/tests/golden/behavior/xpath/contains_href.json
new file mode 100644
index 000000000..a5a80db0e
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/contains_href.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::xpath",
+ "case": "contains_href",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//a[contains(@href, 'b')]",
+ "first": true
+ },
+ "ok": {
+ "result": "Banana"
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/explicit_axis_after_slashslash.json b/browser/tests/golden/behavior/xpath/explicit_axis_after_slashslash.json
new file mode 100644
index 000000000..25b54b1b3
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/explicit_axis_after_slashslash.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "explicit_axis_after_slashslash",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//descendant::li[2]"
+ },
+ "ok": {
+ "result": [
+ "Banana"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/false_scalar_becomes_empty.json b/browser/tests/golden/behavior/xpath/false_scalar_becomes_empty.json
new file mode 100644
index 000000000..e630c84e4
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/false_scalar_becomes_empty.json
@@ -0,0 +1,11 @@
+{
+ "function": "browser::xpath",
+ "case": "false_scalar_becomes_empty",
+ "request": {
+ "html": "<p>Alpha</p>",
+ "query": "boolean(//nope)"
+ },
+ "ok": {
+ "result": []
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/first_h1.json b/browser/tests/golden/behavior/xpath/first_h1.json
new file mode 100644
index 000000000..a7f313c42
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/first_h1.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::xpath",
+ "case": "first_h1",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//h1",
+ "first": true
+ },
+ "ok": {
+ "result": "Hello"
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/following_axis_document_order.json b/browser/tests/golden/behavior/xpath/following_axis_document_order.json
new file mode 100644
index 000000000..5e2b76b59
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/following_axis_document_order.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::xpath",
+ "case": "following_axis_document_order",
+ "request": {
+ "html": "<div><i>A</i></div><p>B</p><p>C</p>",
+ "query": "//i/following::p/text()"
+ },
+ "ok": {
+ "result": [
+ "B",
+ "C"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/global_parenthesized_position.json b/browser/tests/golden/behavior/xpath/global_parenthesized_position.json
new file mode 100644
index 000000000..2db908b2f
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/global_parenthesized_position.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "global_parenthesized_position",
+ "request": {
+ "html": "<div><p>A</p><p>B</p></div><section><p>C</p></section>",
+ "query": "(//p)[2]"
+ },
+ "ok": {
+ "result": [
+ "B"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/invalid_syntax.json b/browser/tests/golden/behavior/xpath/invalid_syntax.json
new file mode 100644
index 000000000..7733eee75
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/invalid_syntax.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::xpath",
+ "case": "invalid_syntax",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//["
+ },
+ "err": "Invalid XPath selector: //["
+}
diff --git a/browser/tests/golden/behavior/xpath/number_scalar_type_error.json b/browser/tests/golden/behavior/xpath/number_scalar_type_error.json
new file mode 100644
index 000000000..1d68945d3
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/number_scalar_type_error.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::xpath",
+ "case": "number_scalar_type_error",
+ "request": {
+ "html": "<p>Alpha</p>",
+ "query": "count(//p)"
+ },
+ "err": "'float' object is not iterable"
+}
diff --git a/browser/tests/golden/behavior/xpath/positional.json b/browser/tests/golden/behavior/xpath/positional.json
new file mode 100644
index 000000000..02857730f
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/positional.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::xpath",
+ "case": "positional",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//li[2]/a",
+ "first": true
+ },
+ "ok": {
+ "result": "Banana"
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/preceding_axis_reverse_position.json b/browser/tests/golden/behavior/xpath/preceding_axis_reverse_position.json
new file mode 100644
index 000000000..7f95b3a1a
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/preceding_axis_reverse_position.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "preceding_axis_reverse_position",
+ "request": {
+ "html": "<p id='a'>A</p><p id='b'>B</p><p id='c'>C</p>",
+ "query": "//p[@id='c']/preceding::p[1]/@id"
+ },
+ "ok": {
+ "result": [
+ "b"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/predicate_arithmetic_and_round.json b/browser/tests/golden/behavior/xpath/predicate_arithmetic_and_round.json
new file mode 100644
index 000000000..90780b550
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/predicate_arithmetic_and_round.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "predicate_arithmetic_and_round",
+ "request": {
+ "html": "<i>1</i><i>2</i><i>3</i><i>4</i>",
+ "query": "//i[position() = round(last() div 2)]"
+ },
+ "ok": {
+ "result": [
+ "2"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/predicate_attr_value.json b/browser/tests/golden/behavior/xpath/predicate_attr_value.json
new file mode 100644
index 000000000..3c2216478
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/predicate_attr_value.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::xpath",
+ "case": "predicate_attr_value",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "query": "//div[@class='card']"
+ },
+ "ok": {
+ "result": [
+ "Card One\nfirst card",
+ "Card Two\nsecond card"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/predicate_string_functions.json b/browser/tests/golden/behavior/xpath/predicate_string_functions.json
new file mode 100644
index 000000000..11112e3fa
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/predicate_string_functions.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "predicate_string_functions",
+ "request": {
+ "html": "<p> Alpha beta </p><p>Gamma</p>",
+ "query": "//p[starts-with(normalize-space(.), 'Alpha') and string-length(normalize-space(.)) = 10]"
+ },
+ "ok": {
+ "result": [
+ " Alpha beta "
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/string_scalar_splits_into_text_nodes.json b/browser/tests/golden/behavior/xpath/string_scalar_splits_into_text_nodes.json
new file mode 100644
index 000000000..6d62f1850
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/string_scalar_splits_into_text_nodes.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::xpath",
+ "case": "string_scalar_splits_into_text_nodes",
+ "request": {
+ "html": "<p>Alpha</p>",
+ "query": "string(//p)"
+ },
+ "err": "'str' object has no attribute 'iter'"
+}
diff --git a/browser/tests/golden/behavior/xpath/template_child_step.json b/browser/tests/golden/behavior/xpath/template_child_step.json
new file mode 100644
index 000000000..3dccc6297
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/template_child_step.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "template_child_step",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "query": "//template/p"
+ },
+ "ok": {
+ "result": [
+ "never render this"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/text_runs_body_messy.json b/browser/tests/golden/behavior/xpath/text_runs_body_messy.json
new file mode 100644
index 000000000..01ee62af1
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/text_runs_body_messy.json
@@ -0,0 +1,16 @@
+{
+ "function": "browser::xpath",
+ "case": "text_runs_body_messy",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "query": "//body/text()"
+ },
+ "ok": {
+ "result": [
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/text_runs_main_messy.json b/browser/tests/golden/behavior/xpath/text_runs_main_messy.json
new file mode 100644
index 000000000..6c7204787
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/text_runs_main_messy.json
@@ -0,0 +1,18 @@
+{
+ "function": "browser::xpath",
+ "case": "text_runs_main_messy",
+ "request": {
+ "html": "<html><head><title>Messy Page</title><meta charset=\"utf-8\"></head><body>\n<nav><ul><li><a href=\"/home\">Home</a></li><li><a href=\"/about\">About</a></li></ul></nav>\n<template><p>never render this</p></template>\n<div aria-hidden=\"true\">screen-reader trap</div>\n<div style=\"display:none\">hidden A</div>\n<div style=\"visibility: hidden\">hidden B</div>\n<main>\n <h1>Widget Review</h1>\n <p>Intro paragraph with <em>emphasis</em> and a <a href=\"/w/1\">link</a>.</p>\n <h2>Specs</h2>\n <table><tr><th>Name</th><th>Value</th></tr><tr><td>Weight</td><td>3kg</td></tr></table>\n <ul><li>alpha<ul><li>nested</li></ul></li><li>beta</li></ul>\n <div class=\"card\" data-id=\"1\"><h3>Card One</h3><p>first card</p></div>\n <div class=\"card\" data-id=\"2\"><h3>Card Two</h3><p>second card</p></div>\n <div class=\"card wide\" data-id=\"3\"><h3>Card Three</h3><p>third card</p></div>\n</main>\n<footer><p>© 2026 Example — <span style=\"font-size:0\">invisible</span>fine print</p></footer>\n<script>analytics()</script>\n</body></html>\n",
+ "query": "//main/text()"
+ },
+ "ok": {
+ "result": [
+ "\n ",
+ "\n ",
+ "\n ",
+ "\n ",
+ "\n ",
+ "\n"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/text_terminal.json b/browser/tests/golden/behavior/xpath/text_terminal.json
new file mode 100644
index 000000000..00e7eb742
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/text_terminal.json
@@ -0,0 +1,12 @@
+{
+ "function": "browser::xpath",
+ "case": "text_terminal",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//h1/text()",
+ "first": true
+ },
+ "ok": {
+ "result": "Hello"
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/textarea_blank_body_kept.json b/browser/tests/golden/behavior/xpath/textarea_blank_body_kept.json
new file mode 100644
index 000000000..b78f2968a
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/textarea_blank_body_kept.json
@@ -0,0 +1,13 @@
+{
+ "function": "browser::xpath",
+ "case": "textarea_blank_body_kept",
+ "request": {
+ "html": "<html><head></head><body>\n<div id=\"wrap\" class=\"outer main\">\n <span>CONDITION: <!-- separator -->Excellent</span>\n <p> <b>bold</b>after-bold</p>\n <p>lead<b>mid</b>tail</p>\n <ul><li>one</li><li>two</li><li>three</li></ul>\n <a href=\"/x?a=1&b=2\" data-price=\"10\">A&B</a>\n <input disabled type=\"text\">\n <script>var hidden = \"never\";</script>\n <style>.x { display: none; }</style>\n <p class=\"uni\">Ünïcode — café</p>\n <textarea> </textarea>\n <div>line one\nand two <b>x</b></div>\n <div data-x=\"1\">line oneand two <b>y</b></div>\n</div>\n</body></html>\n",
+ "query": "//textarea/text()"
+ },
+ "ok": {
+ "result": [
+ " "
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/true_scalar_type_error.json b/browser/tests/golden/behavior/xpath/true_scalar_type_error.json
new file mode 100644
index 000000000..17cfa326b
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/true_scalar_type_error.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::xpath",
+ "case": "true_scalar_type_error",
+ "request": {
+ "html": "<p>Alpha</p>",
+ "query": "boolean(//p)"
+ },
+ "err": "'bool' object is not iterable"
+}
diff --git a/browser/tests/golden/behavior/xpath/union_doc_order.json b/browser/tests/golden/behavior/xpath/union_doc_order.json
new file mode 100644
index 000000000..1f553b2d9
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/union_doc_order.json
@@ -0,0 +1,14 @@
+{
+ "function": "browser::xpath",
+ "case": "union_doc_order",
+ "request": {
+ "html": "<html><head></head><body><h1 class=\"t\">Hello</h1><ul><li><a href=\"/a\">Apple</a></li><li><a href=\"/b\">Banana</a></li></ul><p>price 42 usd then 99</p></body></html>\n",
+ "query": "//h1 | //p"
+ },
+ "ok": {
+ "result": [
+ "Hello",
+ "price 42 usd then 99"
+ ]
+ }
+}
diff --git a/browser/tests/golden/behavior/xpath/unknown_function_error.json b/browser/tests/golden/behavior/xpath/unknown_function_error.json
new file mode 100644
index 000000000..ca498550a
--- /dev/null
+++ b/browser/tests/golden/behavior/xpath/unknown_function_error.json
@@ -0,0 +1,9 @@
+{
+ "function": "browser::xpath",
+ "case": "unknown_function_error",
+ "request": {
+ "html": "<p>Alpha</p>",
+ "query": "no-such-function()"
+ },
+ "err": "Invalid XPath selector: no-such-function()"
+}
diff --git a/browser/tests/golden/browser/dynamic-full-png-1.png b/browser/tests/golden/browser/dynamic-full-png-1.png
new file mode 100644
index 000000000..bfbd5df94
Binary files /dev/null and b/browser/tests/golden/browser/dynamic-full-png-1.png differ
diff --git a/browser/tests/golden/browser/dynamic-viewport-png-1.png b/browser/tests/golden/browser/dynamic-viewport-png-1.png
new file mode 100644
index 000000000..6ac53395d
Binary files /dev/null and b/browser/tests/golden/browser/dynamic-viewport-png-1.png differ
diff --git a/browser/tests/golden/browser/manifest.json b/browser/tests/golden/browser/manifest.json
new file mode 100644
index 000000000..c039ff61f
--- /dev/null
+++ b/browser/tests/golden/browser/manifest.json
@@ -0,0 +1,128 @@
+{
+ "cases": [
+ {
+ "case": "dynamic-viewport-png",
+ "request": {
+ "url": "{origin}/visual",
+ "retries": 1,
+ "fetcher": "dynamic",
+ "format": "png",
+ "full_page": false
+ },
+ "response": {
+ "content": [
+ {
+ "type": "image",
+ "mime": "image/png",
+ "file": "dynamic-viewport-png-1.png",
+ "bytes": 3069,
+ "sha256": "9864b884e9e46dc3b367f3ca69677fa411c7cacb7967f01cb690ec6d75b06938",
+ "dimensions": [
+ 1024,
+ 576
+ ]
+ },
+ {
+ "type": "text",
+ "text": "screenshot of {origin}/visual — 1024x576px, 1 tile(s), 3 KB"
+ }
+ ],
+ "url": "{origin}/visual",
+ "mime": "image/png"
+ }
+ },
+ {
+ "case": "dynamic-full-png",
+ "request": {
+ "url": "{origin}/visual",
+ "retries": 1,
+ "fetcher": "dynamic",
+ "format": "png",
+ "full_page": true
+ },
+ "response": {
+ "content": [
+ {
+ "type": "image",
+ "mime": "image/png",
+ "file": "dynamic-full-png-1.png",
+ "bytes": 7554,
+ "sha256": "460c1cd20d3d8b4c231600cf4e25186612b37adc98c3610493e32729256530b6",
+ "dimensions": [
+ 1024,
+ 1440
+ ]
+ },
+ {
+ "type": "text",
+ "text": "screenshot of {origin}/visual — 1024x1440px, 1 tile(s), 7 KB"
+ }
+ ],
+ "url": "{origin}/visual",
+ "mime": "image/png"
+ }
+ },
+ {
+ "case": "stealthy-viewport-png",
+ "request": {
+ "url": "{origin}/visual",
+ "retries": 1,
+ "fetcher": "stealthy",
+ "format": "png",
+ "full_page": false
+ },
+ "response": {
+ "content": [
+ {
+ "type": "image",
+ "mime": "image/png",
+ "file": "stealthy-viewport-png-1.png",
+ "bytes": 3091,
+ "sha256": "24e279ef055905ecdcc441561e27cb2118352dfc6acee3298fcf951b25ec8a82",
+ "dimensions": [
+ 1024,
+ 576
+ ]
+ },
+ {
+ "type": "text",
+ "text": "screenshot of {origin}/visual — 1024x576px, 1 tile(s), 3 KB"
+ }
+ ],
+ "url": "{origin}/visual",
+ "mime": "image/png"
+ }
+ },
+ {
+ "case": "stealthy-full-jpeg",
+ "request": {
+ "url": "{origin}/visual",
+ "retries": 1,
+ "fetcher": "stealthy",
+ "format": "jpeg",
+ "full_page": true
+ },
+ "response": {
+ "content": [
+ {
+ "type": "image",
+ "mime": "image/jpeg",
+ "file": "stealthy-full-jpeg-1.jpg",
+ "bytes": 19067,
+ "sha256": "aee1bf8560648030c76b3052a4a26eb782808fc24ea50315bb7f4ade3a572903",
+ "dimensions": [
+ 1024,
+ 960
+ ]
+ },
+ {
+ "type": "text",
+ "text": "screenshot of {origin}/visual — 1024x960px, 1 tile(s), 19 KB"
+ }
+ ],
+ "url": "{origin}/visual",
+ "mime": "image/jpeg"
+ }
+ }
+ ]
+}
diff --git a/browser/tests/golden/browser/stealthy-full-jpeg-1.jpg b/browser/tests/golden/browser/stealthy-full-jpeg-1.jpg
new file mode 100644
index 000000000..91f6a3e5d
Binary files /dev/null and b/browser/tests/golden/browser/stealthy-full-jpeg-1.jpg differ
diff --git a/browser/tests/golden/browser/stealthy-viewport-png-1.png b/browser/tests/golden/browser/stealthy-viewport-png-1.png
new file mode 100644
index 000000000..20a37712d
Binary files /dev/null and b/browser/tests/golden/browser/stealthy-viewport-png-1.png differ
diff --git a/browser/tests/golden/schemas/browser.act.json b/browser/tests/golden/schemas/browser.act.json
index 09762b3e9..ab11f08bb 100644
--- a/browser/tests/golden/schemas/browser.act.json
+++ b/browser/tests/golden/schemas/browser.act.json
@@ -1,51 +1,57 @@
{
- "description": "Interact with the page: click (left/right/middle, single or double), hover, type, press, or scroll. Address elements with a [ref=eN] handle from browser::snapshot (or a pick), or raw viewport coordinates.",
"function_id": "browser::act",
+ "description": "Interact with the page: click (left/right/middle, single or double), hover, type, press, or scroll. Address elements with a [ref=eN] handle from browser::snapshot (or a pick), or raw viewport coordinates.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ActInput",
+ "type": "object",
+ "required": [
+ "action",
+ "session_id"
+ ],
"properties": {
"action": {
"description": "`click`, `hover`, `type`, `press`, or `scroll`.",
"type": "string"
},
"button": {
- "default": null,
"description": "Mouse button for `click`: `left` (default), `right`, or `middle`.",
+ "default": null,
"type": [
"string",
"null"
]
},
"click_count": {
- "default": null,
"description": "Clicks in the gesture: 2 double-clicks (`click` only, default 1).",
- "format": "uint32",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint32",
+ "minimum": 0.0
},
"delta_y": {
- "default": null,
"description": "Scroll distance in pixels; positive scrolls down (`scroll`).",
- "format": "double",
+ "default": null,
"type": [
"number",
"null"
- ]
+ ],
+ "format": "double"
},
"key": {
- "default": null,
"description": "Key name for `press`: Enter, Tab, Escape, Backspace, Delete, ArrowUp/Down/Left/Right, Home, End, PageUp, PageDown.",
+ "default": null,
"type": [
"string",
"null"
]
},
"ref": {
- "default": null,
"description": "Element ref from `browser::snapshot` (`e3`) or `browser::picked` (`p1`). Refs die on navigation; re-snapshot after.",
+ "default": null,
"type": [
"string",
"null"
@@ -55,41 +61,41 @@
"type": "string"
},
"text": {
- "default": null,
"description": "Text to insert (`type`).",
+ "default": null,
"type": [
"string",
"null"
]
},
"x": {
- "default": null,
"description": "Viewport x, when acting by coordinates instead of ref.",
- "format": "double",
+ "default": null,
"type": [
"number",
"null"
- ]
+ ],
+ "format": "double"
},
"y": {
- "default": null,
"description": "Viewport y, when acting by coordinates instead of ref.",
- "format": "double",
+ "default": null,
"type": [
"number",
"null"
- ]
+ ],
+ "format": "double"
}
- },
- "required": [
- "action",
- "session_id"
- ],
- "title": "ActInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ActOutput",
+ "type": "object",
+ "required": [
+ "detail",
+ "ok"
+ ],
"properties": {
"detail": {
"description": "What was done, for the transcript.",
@@ -98,12 +104,6 @@
"ok": {
"type": "boolean"
}
- },
- "required": [
- "detail",
- "ok"
- ],
- "title": "ActOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.console.read.json b/browser/tests/golden/schemas/browser.console.read.json
index 899f9d4f0..1df35ec53 100644
--- a/browser/tests/golden/schemas/browser.console.read.json
+++ b/browser/tests/golden/schemas/browser.console.read.json
@@ -1,30 +1,35 @@
{
- "description": "Read the session's captured console: console.* calls, uncaught exceptions, and browser-level log entries. Filter with pattern/level and page with since_seq instead of dumping everything.",
"function_id": "browser::console::read",
+ "description": "Read the session's captured console: console.* calls, uncaught exceptions, and browser-level log entries. Filter with pattern/level and page with since_seq instead of dumping everything.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ConsoleReadInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"level": {
- "default": null,
"description": "Only entries at this level: `log`, `info`, `warning`, `error`, `debug`, `exception`. `error` also matches `exception`.",
+ "default": null,
"type": [
"string",
"null"
]
},
"limit": {
- "default": null,
"description": "Maximum entries returned, newest kept (default 100).",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
},
"pattern": {
- "default": null,
"description": "Regex applied to entry text. Use it: dumping an unfiltered console wastes the caller's context.",
+ "default": null,
"type": [
"string",
"null"
@@ -34,27 +39,56 @@
"type": "string"
},
"since_seq": {
- "default": null,
"description": "Only entries with `seq` greater than this; resume from the cursor returned as `last_seq`.",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
}
- },
- "required": [
- "session_id"
- ],
- "title": "ConsoleReadInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ConsoleReadOutput",
+ "type": "object",
+ "required": [
+ "dropped",
+ "entries",
+ "last_seq"
+ ],
+ "properties": {
+ "dropped": {
+ "description": "Entries evicted from the ring buffer since session start.",
+ "type": "integer",
+ "format": "uint64",
+ "minimum": 0.0
+ },
+ "entries": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/ConsoleEntry"
+ }
+ },
+ "last_seq": {
+ "description": "Cursor for the next `since_seq`.",
+ "type": "integer",
+ "format": "uint64",
+ "minimum": 0.0
+ }
+ },
"definitions": {
"ConsoleEntry": {
"description": "One captured console/log/exception entry.",
+ "type": "object",
+ "required": [
+ "level",
+ "seq",
+ "text",
+ "timestamp"
+ ],
"properties": {
"level": {
"description": "`log`, `info`, `warning`, `error`, `debug`, or `exception`.",
@@ -62,9 +96,9 @@
},
"seq": {
"description": "Monotonic per-session cursor; pass back as `since_seq`.",
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"source": {
"description": "`url:line` of the emitting frame, when known.",
@@ -77,45 +111,11 @@
"type": "string"
},
"timestamp": {
- "format": "int64",
- "type": "integer"
+ "type": "integer",
+ "format": "int64"
}
- },
- "required": [
- "level",
- "seq",
- "text",
- "timestamp"
- ],
- "type": "object"
- }
- },
- "properties": {
- "dropped": {
- "description": "Entries evicted from the ring buffer since session start.",
- "format": "uint64",
- "minimum": 0.0,
- "type": "integer"
- },
- "entries": {
- "items": {
- "$ref": "#/definitions/ConsoleEntry"
- },
- "type": "array"
- },
- "last_seq": {
- "description": "Cursor for the next `since_seq`.",
- "format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ }
}
- },
- "required": [
- "dropped",
- "entries",
- "last_seq"
- ],
- "title": "ConsoleReadOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.crawl.json b/browser/tests/golden/schemas/browser.crawl.json
new file mode 100644
index 000000000..7e50287d2
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.crawl.json
@@ -0,0 +1,153 @@
+{
+ "function_id": "browser::crawl",
+ "description": "BFS-crawl from start_urls (follow same-domain links), extract per page, stream items.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "start_urls": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "url": {
+ "type": "string",
+ "description": "single start URL (alternative to start_urls)"
+ },
+ "fetcher": {
+ "type": "string",
+ "enum": [
+ "http",
+ "stealthy",
+ "dynamic"
+ ]
+ },
+ "selectors": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "regex": {
+ "type": "string"
+ },
+ "attr": {
+ "type": "string",
+ "description": "extract this attribute instead of text"
+ },
+ "html": {
+ "type": "boolean",
+ "description": "extract inner HTML instead of text"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "return every match as a list"
+ }
+ },
+ "required": [
+ "name"
+ ]
+ }
+ },
+ "allowed_domains": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "only follow links on these hosts"
+ },
+ "same_domain": {
+ "type": "boolean",
+ "description": "follow only same-host links (default true)"
+ },
+ "max_pages": {
+ "type": "integer"
+ },
+ "max_depth": {
+ "type": "integer"
+ },
+ "concurrency": {
+ "type": "integer"
+ },
+ "download_delay": {
+ "type": "number",
+ "description": "seconds to wait between crawl rounds"
+ },
+ "format": {
+ "type": "string",
+ "enum": [
+ "markdown",
+ "text"
+ ],
+ "description": "render page body to this format"
+ },
+ "main_content_only": {
+ "type": "boolean",
+ "description": "strip nav/scripts/hidden before rendering"
+ },
+ "css_selector": {
+ "type": "string",
+ "description": "scope the render to this CSS subtree (e.g. a page's content div)"
+ },
+ "include_html": {
+ "type": "boolean"
+ },
+ "impersonate": {
+ "type": "string"
+ },
+ "stream_name": {
+ "type": "string",
+ "description": "stream to emit items on (default browser::crawl)"
+ }
+ }
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "stats": {
+ "type": "object",
+ "properties": {
+ "crawled": {
+ "type": "integer"
+ },
+ "items": {
+ "type": "integer"
+ },
+ "errors": {
+ "type": "integer"
+ },
+ "stopped": {
+ "type": "string"
+ }
+ }
+ },
+ "items": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ },
+ "description": "a small sample of streamed items"
+ },
+ "stream": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "group_id": {
+ "type": "string"
+ }
+ },
+ "description": "read the full item stream via stream::on with this name + group_id"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.css.json b/browser/tests/golden/schemas/browser.css.json
new file mode 100644
index 000000000..f08400418
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.css.json
@@ -0,0 +1,59 @@
+{
+ "function_id": "browser::css",
+ "description": "One CSS query over HTML; first-or-all; `attr` pulls an attribute else text.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "query": {
+ "type": "string"
+ },
+ "first": {
+ "type": "boolean"
+ },
+ "attr": {
+ "type": "string"
+ },
+ "identifier": {
+ "type": "string",
+ "description": "stable key for the saved element"
+ },
+ "adaptive": {
+ "type": "boolean",
+ "description": "relocate elements after a site change via saved identities"
+ },
+ "auto_save": {
+ "type": "boolean",
+ "description": "save matched identities (defaults on when adaptive)"
+ },
+ "adaptive_domain": {
+ "type": "string",
+ "description": "page URL/domain that keys saved identities"
+ }
+ },
+ "required": [
+ "html",
+ "query"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "result": {
+ "type": [
+ "array",
+ "string",
+ "null"
+ ],
+ "items": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.describe.json b/browser/tests/golden/schemas/browser.describe.json
new file mode 100644
index 000000000..3ff5b76f9
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.describe.json
@@ -0,0 +1,81 @@
+{
+ "function_id": "browser::describe",
+ "description": "Describe the first css/xpath match: attrs, generated selectors, class list, DOM context.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "query": {
+ "type": "string"
+ },
+ "kind": {
+ "type": "string",
+ "enum": [
+ "css",
+ "xpath"
+ ]
+ }
+ },
+ "required": [
+ "html",
+ "query"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "found": {
+ "type": "boolean"
+ },
+ "element": {
+ "type": "object",
+ "properties": {
+ "tag": {
+ "type": "string"
+ },
+ "text": {
+ "type": "string"
+ },
+ "html": {
+ "type": "string"
+ },
+ "attrs": {
+ "type": "object"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "full_css": {
+ "type": "string"
+ },
+ "full_xpath": {
+ "type": "string"
+ },
+ "classes": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "parent_tag": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "children": {
+ "type": "integer"
+ },
+ "siblings": {
+ "type": "integer"
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.doctor.json b/browser/tests/golden/schemas/browser.doctor.json
index d1dced1d1..b54615ff2 100644
--- a/browser/tests/golden/schemas/browser.doctor.json
+++ b/browser/tests/golden/schemas/browser.doctor.json
@@ -1,6 +1,6 @@
{
- "description": "Read-only environment diagnostics: which Chromium the worker would launch, its version, session capacity, and any degraded capability with how to enable it. Never starts a browser.",
"function_id": "browser::doctor",
+ "description": "Read-only environment diagnostics: which Chromium the worker would launch, its version, session capacity, and any degraded capability with how to enable it. Never starts a browser.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "DoctorInput",
@@ -8,35 +8,29 @@
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
- "definitions": {
- "DoctorIssue": {
- "description": "One degraded capability plus the way to enable it.",
- "properties": {
- "enable_how": {
- "type": "string"
- },
- "what": {
- "type": "string"
- }
- },
- "required": [
- "enable_how",
- "what"
- ],
- "type": "object"
- }
- },
+ "title": "DoctorOutput",
+ "type": "object",
+ "required": [
+ "active_sessions",
+ "allowed_schemes",
+ "attach_enabled",
+ "headless_default",
+ "issues",
+ "max_sessions",
+ "ok",
+ "recording_available"
+ ],
"properties": {
"active_sessions": {
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"allowed_schemes": {
+ "type": "array",
"items": {
"type": "string"
- },
- "type": "array"
+ }
},
"attach_enabled": {
"description": "Whether attach mode is enabled (allow_attach).",
@@ -58,15 +52,15 @@
"type": "boolean"
},
"issues": {
+ "type": "array",
"items": {
"$ref": "#/definitions/DoctorIssue"
- },
- "type": "array"
+ }
},
"max_sessions": {
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"ok": {
"description": "True when sessions can start right now.",
@@ -77,17 +71,23 @@
"type": "boolean"
}
},
- "required": [
- "active_sessions",
- "allowed_schemes",
- "attach_enabled",
- "headless_default",
- "issues",
- "max_sessions",
- "ok",
- "recording_available"
- ],
- "title": "DoctorOutput",
- "type": "object"
+ "definitions": {
+ "DoctorIssue": {
+ "description": "One degraded capability plus the way to enable it.",
+ "type": "object",
+ "required": [
+ "enable_how",
+ "what"
+ ],
+ "properties": {
+ "enable_how": {
+ "type": "string"
+ },
+ "what": {
+ "type": "string"
+ }
+ }
+ }
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.dom.read.json b/browser/tests/golden/schemas/browser.dom.read.json
index 02b2b593a..816afa910 100644
--- a/browser/tests/golden/schemas/browser.dom.read.json
+++ b/browser/tests/golden/schemas/browser.dom.read.json
@@ -1,22 +1,27 @@
{
- "description": "Read the DOM as a tree of tags with id/class and refs. Structure-oriented complement to browser::snapshot; read deep subtrees by passing a ref.",
"function_id": "browser::dom::read",
+ "description": "Read the DOM as a tree of tags with id/class and refs. Structure-oriented complement to browser::snapshot; read deep subtrees by passing a ref.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "DomReadInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"depth": {
- "default": null,
"description": "Levels of children to include (default 3).",
- "format": "uint32",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint32",
+ "minimum": 0.0
},
"ref": {
- "default": null,
"description": "Subtree root from an earlier ref (`e3`/`p1`) or dom node. Omit for the document root.",
+ "default": null,
"type": [
"string",
"null"
@@ -25,30 +30,46 @@
"session_id": {
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "DomReadInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "DomReadOutput",
+ "type": "object",
+ "required": [
+ "root",
+ "truncated"
+ ],
+ "properties": {
+ "root": {
+ "$ref": "#/definitions/DomNode"
+ },
+ "truncated": {
+ "description": "True when the node cap cut the tree short; read a subtree via `ref`.",
+ "type": "boolean"
+ }
+ },
"definitions": {
"DomNode": {
"description": "One DOM node in the outline. `ref` resolves in `browser::act`, `browser::styles::read`, and `browser::styles::write`.",
+ "type": "object",
+ "required": [
+ "child_count",
+ "ref",
+ "tag"
+ ],
"properties": {
"child_count": {
"description": "Total children in the document, which may exceed `children` returned at this depth.",
+ "type": "integer",
"format": "uint32",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"children": {
+ "type": "array",
"items": {
"$ref": "#/definitions/DomNode"
- },
- "type": "array"
+ }
},
"classes": {
"type": [
@@ -76,29 +97,8 @@
"null"
]
}
- },
- "required": [
- "child_count",
- "ref",
- "tag"
- ],
- "type": "object"
+ }
}
- },
- "properties": {
- "root": {
- "$ref": "#/definitions/DomNode"
- },
- "truncated": {
- "description": "True when the node cap cut the tree short; read a subtree via `ref`.",
- "type": "boolean"
- }
- },
- "required": [
- "root",
- "truncated"
- ],
- "title": "DomReadOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.dynamic-fetch.json b/browser/tests/golden/schemas/browser.dynamic-fetch.json
new file mode 100644
index 000000000..54b6a975d
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.dynamic-fetch.json
@@ -0,0 +1,215 @@
+{
+ "function_id": "browser::dynamic-fetch",
+ "description": "Playwright/Chromium fetch: JS render, waits, XHR capture, CDP; extraction + bulk.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "url": {
+ "type": "string"
+ },
+ "urls": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "headless": {
+ "type": "boolean"
+ },
+ "network_idle": {
+ "type": "boolean"
+ },
+ "load_dom": {
+ "type": "boolean"
+ },
+ "timeout": {
+ "type": "number",
+ "description": "milliseconds (browser fetcher)"
+ },
+ "wait": {
+ "type": "number",
+ "description": "extra ms to wait after load"
+ },
+ "wait_selector": {
+ "type": "string"
+ },
+ "wait_selector_state": {
+ "type": "string",
+ "enum": [
+ "attached",
+ "detached",
+ "visible",
+ "hidden"
+ ]
+ },
+ "disable_resources": {
+ "type": "boolean"
+ },
+ "block_ads": {
+ "type": "boolean"
+ },
+ "blocked_domains": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "proxy": {
+ "type": "string"
+ },
+ "useragent": {
+ "type": "string"
+ },
+ "cookies": {
+ "type": "object"
+ },
+ "extra_headers": {
+ "type": "object"
+ },
+ "google_search": {
+ "type": "boolean"
+ },
+ "capture_xhr": {
+ "type": "string"
+ },
+ "locale": {
+ "type": "string"
+ },
+ "timezone_id": {
+ "type": "string"
+ },
+ "dns_over_https": {
+ "type": "boolean"
+ },
+ "extra_flags": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "max_pages": {
+ "type": "integer"
+ },
+ "retries": {
+ "type": "integer"
+ },
+ "retry_delay": {
+ "type": "number"
+ },
+ "real_chrome": {
+ "type": "boolean"
+ },
+ "cdp_url": {
+ "type": "string"
+ },
+ "selectors": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "regex": {
+ "type": "string"
+ },
+ "attr": {
+ "type": "string",
+ "description": "extract this attribute instead of text"
+ },
+ "html": {
+ "type": "boolean",
+ "description": "extract inner HTML instead of text"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "return every match as a list"
+ }
+ },
+ "required": [
+ "name"
+ ]
+ }
+ },
+ "include_html": {
+ "type": "boolean"
+ },
+ "format": {
+ "type": "string",
+ "enum": [
+ "markdown",
+ "text"
+ ],
+ "description": "render page body to this format"
+ },
+ "main_content_only": {
+ "type": "boolean",
+ "description": "strip nav/scripts/hidden before rendering"
+ },
+ "css_selector": {
+ "type": "string",
+ "description": "scope the render to this CSS subtree (e.g. a page's content div)"
+ }
+ }
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "status": {
+ "type": [
+ "integer",
+ "null"
+ ]
+ },
+ "url": {
+ "type": "string"
+ },
+ "headers": {
+ "type": "object"
+ },
+ "cookies": {
+ "type": "object"
+ },
+ "encoding": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "extracted": {
+ "type": "object"
+ },
+ "html": {
+ "type": "string"
+ },
+ "content": {
+ "type": "string",
+ "description": "markdown/text render when `format` requested"
+ },
+ "format": {
+ "type": "string"
+ },
+ "captured_xhr": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "results": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "error": {
+ "type": "string"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.evaluate.json b/browser/tests/golden/schemas/browser.evaluate.json
index 6856f1292..3d9ded16f 100644
--- a/browser/tests/golden/schemas/browser.evaluate.json
+++ b/browser/tests/golden/schemas/browser.evaluate.json
@@ -1,8 +1,14 @@
{
- "description": "Evaluate a JavaScript expression in the page and return its completion value. Use for reads the snapshot can't express; prefer browser::act for interactions.",
"function_id": "browser::evaluate",
+ "description": "Evaluate a JavaScript expression in the page and return its completion value. Use for reads the snapshot can't express; prefer browser::act for interactions.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "EvaluateInput",
+ "type": "object",
+ "required": [
+ "expression",
+ "session_id"
+ ],
"properties": {
"expression": {
"description": "JavaScript expression evaluated in the page. The completion value is returned by value; wrap statements in an IIFE.",
@@ -12,25 +18,24 @@
"type": "string"
},
"timeout_ms": {
- "default": null,
"description": "Upper bound on evaluation; clamped to `max_timeout_ms`.",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
}
- },
- "required": [
- "expression",
- "session_id"
- ],
- "title": "EvaluateInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "EvaluateOutput",
+ "type": "object",
+ "required": [
+ "ok"
+ ],
"properties": {
"error": {
"description": "Exception text when not `ok`.",
@@ -45,11 +50,6 @@
"value": {
"description": "JSON completion value when `ok`."
}
- },
- "required": [
- "ok"
- ],
- "title": "EvaluateOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.execute.json b/browser/tests/golden/schemas/browser.execute.json
index 483750fb8..b1c90c1c6 100644
--- a/browser/tests/golden/schemas/browser.execute.json
+++ b/browser/tests/golden/schemas/browser.execute.json
@@ -1,8 +1,14 @@
{
- "description": "Run a multi-step async JavaScript script in the page: top-level await and return work, with log(...), sleep(ms), waitFor(selector), and a state object that persists across execute calls for the session. One call replaces a chain of act/evaluate round-trips; returns { result, logs, state }.",
"function_id": "browser::execute",
+ "description": "Run a multi-step async JavaScript script in the page: top-level await and return work, with log(...), sleep(ms), waitFor(selector), and a state object that persists across execute calls for the session. One call replaces a chain of act/evaluate round-trips; returns { result, logs, state }.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ExecuteInput",
+ "type": "object",
+ "required": [
+ "code",
+ "session_id"
+ ],
"properties": {
"code": {
"description": "Async JavaScript body run in the page. Top-level `await` and `return` work. In scope: `state` (JSON object persisted across execute calls for the session), `log(...)` (collected into the response), `sleep(ms)`, and `waitFor(selector, { timeout })`. Return plain JSON.",
@@ -12,25 +18,26 @@
"type": "string"
},
"timeout_ms": {
- "default": null,
"description": "Upper bound on the run; clamped to `max_timeout_ms`.",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
}
- },
- "required": [
- "code",
- "session_id"
- ],
- "title": "ExecuteInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ExecuteOutput",
+ "type": "object",
+ "required": [
+ "logs",
+ "ok",
+ "state"
+ ],
"properties": {
"error": {
"description": "Exception text when not `ok`. A \"context destroyed\" error usually means the script navigated; split the script at the navigation.",
@@ -41,10 +48,10 @@
},
"logs": {
"description": "`log(...)` output collected during the run, in order.",
+ "type": "array",
"items": {
"type": "string"
- },
- "type": "array"
+ }
},
"ok": {
"type": "boolean"
@@ -55,13 +62,6 @@
"state": {
"description": "Session state after the run; the next execute call sees this as `state`."
}
- },
- "required": [
- "logs",
- "ok",
- "state"
- ],
- "title": "ExecuteOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.extract.json b/browser/tests/golden/schemas/browser.extract.json
new file mode 100644
index 000000000..946972b23
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.extract.json
@@ -0,0 +1,71 @@
+{
+ "function_id": "browser::extract",
+ "description": "Parse HTML with a selector list (css/xpath/regex, text/attr/html, all-or-first).",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "selectors": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "regex": {
+ "type": "string"
+ },
+ "attr": {
+ "type": "string",
+ "description": "extract this attribute instead of text"
+ },
+ "html": {
+ "type": "boolean",
+ "description": "extract inner HTML instead of text"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "return every match as a list"
+ }
+ },
+ "required": [
+ "name"
+ ]
+ }
+ },
+ "adaptive": {
+ "type": "boolean",
+ "description": "relocate elements after a site change via saved identities"
+ },
+ "auto_save": {
+ "type": "boolean",
+ "description": "save matched identities (defaults on when adaptive)"
+ },
+ "adaptive_domain": {
+ "type": "string",
+ "description": "page URL/domain that keys saved identities"
+ }
+ },
+ "required": [
+ "html",
+ "selectors"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "extracted": {
+ "type": "object"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.fetch.json b/browser/tests/golden/schemas/browser.fetch.json
new file mode 100644
index 000000000..a963922a0
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.fetch.json
@@ -0,0 +1,193 @@
+{
+ "function_id": "browser::fetch",
+ "description": "Fast HTTP fetch, TLS impersonation: get/post/put/delete, inline extraction, bulk `urls`.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "url": {
+ "type": "string"
+ },
+ "urls": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "method": {
+ "type": "string",
+ "enum": [
+ "get",
+ "post",
+ "put",
+ "delete"
+ ]
+ },
+ "headers": {
+ "type": "object"
+ },
+ "params": {
+ "type": "object"
+ },
+ "data": {
+ "type": "object"
+ },
+ "json": {
+ "type": "object"
+ },
+ "cookies": {
+ "type": "object"
+ },
+ "proxy": {
+ "type": "string"
+ },
+ "proxies": {
+ "type": "object",
+ "description": "per-scheme proxies, e.g. {\"https\": \"http://...\"}"
+ },
+ "proxy_auth": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "description": "[user, password]"
+ },
+ "impersonate": {
+ "type": "string",
+ "description": "TLS/UA fingerprint, e.g. 'chrome'"
+ },
+ "timeout": {
+ "type": "number",
+ "description": "seconds (HTTP fetcher)"
+ },
+ "follow_redirects": {
+ "type": "boolean"
+ },
+ "max_redirects": {
+ "type": "integer"
+ },
+ "stealthy_headers": {
+ "type": "boolean"
+ },
+ "http3": {
+ "type": "boolean"
+ },
+ "verify": {
+ "type": "boolean"
+ },
+ "retries": {
+ "type": "integer"
+ },
+ "retry_delay": {
+ "type": "number"
+ },
+ "selectors": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "regex": {
+ "type": "string"
+ },
+ "attr": {
+ "type": "string",
+ "description": "extract this attribute instead of text"
+ },
+ "html": {
+ "type": "boolean",
+ "description": "extract inner HTML instead of text"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "return every match as a list"
+ }
+ },
+ "required": [
+ "name"
+ ]
+ }
+ },
+ "include_html": {
+ "type": "boolean"
+ },
+ "format": {
+ "type": "string",
+ "enum": [
+ "markdown",
+ "text"
+ ],
+ "description": "render page body to this format"
+ },
+ "main_content_only": {
+ "type": "boolean",
+ "description": "strip nav/scripts/hidden before rendering"
+ },
+ "css_selector": {
+ "type": "string",
+ "description": "scope the render to this CSS subtree (e.g. a page's content div)"
+ }
+ }
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "status": {
+ "type": [
+ "integer",
+ "null"
+ ]
+ },
+ "url": {
+ "type": "string"
+ },
+ "headers": {
+ "type": "object"
+ },
+ "cookies": {
+ "type": "object"
+ },
+ "encoding": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "extracted": {
+ "type": "object"
+ },
+ "html": {
+ "type": "string"
+ },
+ "content": {
+ "type": "string",
+ "description": "markdown/text render when `format` requested"
+ },
+ "format": {
+ "type": "string"
+ },
+ "captured_xhr": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "results": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "error": {
+ "type": "string"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.find-by-regex.json b/browser/tests/golden/schemas/browser.find-by-regex.json
new file mode 100644
index 000000000..28b0a83c0
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.find-by-regex.json
@@ -0,0 +1,65 @@
+{
+ "function_id": "browser::find-by-regex",
+ "description": "Find elements whose visible text matches a regex pattern.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "pattern": {
+ "type": "string"
+ },
+ "case_sensitive": {
+ "type": "boolean"
+ },
+ "clean_match": {
+ "type": "boolean"
+ },
+ "first": {
+ "type": "boolean"
+ },
+ "limit": {
+ "type": "integer"
+ }
+ },
+ "required": [
+ "html",
+ "pattern"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "count": {
+ "type": "integer"
+ },
+ "items": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "tag": {
+ "type": "string"
+ },
+ "text": {
+ "type": "string"
+ },
+ "html": {
+ "type": "string"
+ },
+ "attrs": {
+ "type": "object"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.find-by-text.json b/browser/tests/golden/schemas/browser.find-by-text.json
new file mode 100644
index 000000000..545b0a684
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.find-by-text.json
@@ -0,0 +1,70 @@
+{
+ "function_id": "browser::find-by-text",
+ "description": "Find elements whose visible text matches a string (exact or `partial`).",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "text": {
+ "type": "string"
+ },
+ "partial": {
+ "type": "boolean",
+ "description": "match elements that contain the text"
+ },
+ "case_sensitive": {
+ "type": "boolean"
+ },
+ "clean_match": {
+ "type": "boolean",
+ "description": "ignore surrounding/collapsing whitespace"
+ },
+ "first": {
+ "type": "boolean"
+ },
+ "limit": {
+ "type": "integer"
+ }
+ },
+ "required": [
+ "html",
+ "text"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "count": {
+ "type": "integer"
+ },
+ "items": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "tag": {
+ "type": "string"
+ },
+ "text": {
+ "type": "string"
+ },
+ "html": {
+ "type": "string"
+ },
+ "attrs": {
+ "type": "object"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.find-similar.json b/browser/tests/golden/schemas/browser.find-similar.json
new file mode 100644
index 000000000..85f239837
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.find-similar.json
@@ -0,0 +1,75 @@
+{
+ "function_id": "browser::find-similar",
+ "description": "Structural auto-match: given one example element, return it plus similar elements.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "anchor": {
+ "type": "string",
+ "description": "CSS selector to one example element"
+ },
+ "similarity_threshold": {
+ "type": "number"
+ },
+ "match_text": {
+ "type": "boolean"
+ },
+ "selectors": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "regex": {
+ "type": "string"
+ },
+ "attr": {
+ "type": "string",
+ "description": "extract this attribute instead of text"
+ },
+ "html": {
+ "type": "boolean",
+ "description": "extract inner HTML instead of text"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "return every match as a list"
+ }
+ },
+ "required": [
+ "name"
+ ]
+ }
+ }
+ },
+ "required": [
+ "html",
+ "anchor"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "count": {
+ "type": "integer"
+ },
+ "items": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.find.json b/browser/tests/golden/schemas/browser.find.json
new file mode 100644
index 000000000..20dcaa9df
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.find.json
@@ -0,0 +1,73 @@
+{
+ "function_id": "browser::find",
+ "description": "Find elements by tag/attribute filters (+ optional text regex); BeautifulSoup-style.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "tag": {
+ "type": [
+ "string",
+ "array"
+ ],
+ "items": {
+ "type": "string"
+ },
+ "description": "tag name or list of tag names"
+ },
+ "attrs": {
+ "type": "object",
+ "description": "attribute filters, e.g. {\"class\": \"card\"}"
+ },
+ "text_regex": {
+ "type": "string",
+ "description": "keep only elements whose text matches this regex"
+ },
+ "first": {
+ "type": "boolean"
+ },
+ "limit": {
+ "type": "integer"
+ }
+ },
+ "required": [
+ "html"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "count": {
+ "type": "integer"
+ },
+ "items": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "tag": {
+ "type": "string"
+ },
+ "text": {
+ "type": "string"
+ },
+ "html": {
+ "type": "string"
+ },
+ "attrs": {
+ "type": "object"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.frame.json b/browser/tests/golden/schemas/browser.frame.json
index 160670159..b6dbce2b9 100644
--- a/browser/tests/golden/schemas/browser.frame.json
+++ b/browser/tests/golden/schemas/browser.frame.json
@@ -1,31 +1,40 @@
{
- "description": "Internal: newest screencast frame, or nothing when since_frame is still current. No capture round-trip; poll fast. Not an agent function.",
"function_id": "browser::frame",
+ "description": "Internal: newest screencast frame, or nothing when since_frame is still current. No capture round-trip; poll fast. Not an agent function.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "FrameInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"session_id": {
"type": "string"
},
"since_frame": {
- "default": null,
"description": "Frame cursor from the previous read; when the newest frame still has this seq the response omits `frame` (nothing changed, nothing to redraw).",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
}
- },
- "required": [
- "session_id"
- ],
- "title": "FrameInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "FrameOutput",
+ "type": "object",
+ "required": [
+ "active",
+ "frame_seq",
+ "height",
+ "timestamp",
+ "width"
+ ],
"properties": {
"active": {
"description": "False when no screencast is running (call screencast::start first).",
@@ -39,35 +48,26 @@
]
},
"frame_seq": {
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"height": {
"description": "Page-viewport height the frame maps to.",
+ "type": "integer",
"format": "uint32",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"timestamp": {
- "format": "int64",
- "type": "integer"
+ "type": "integer",
+ "format": "int64"
},
"width": {
"description": "Page-viewport width the frame maps to (input coordinate space).",
+ "type": "integer",
"format": "uint32",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
}
- },
- "required": [
- "active",
- "frame_seq",
- "height",
- "timestamp",
- "width"
- ],
- "title": "FrameOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.handoff.confirm.json b/browser/tests/golden/schemas/browser.handoff.confirm.json
index 137e6e0d8..66b9c2bce 100644
--- a/browser/tests/golden/schemas/browser.handoff.confirm.json
+++ b/browser/tests/golden/schemas/browser.handoff.confirm.json
@@ -1,12 +1,14 @@
{
- "description": "Resolve a paused browser::handoff by handoff_id, or the one pending handoff for a session_id. The console calls this when the human confirms outside the page.",
"function_id": "browser::handoff::confirm",
+ "description": "Resolve a paused browser::handoff by handoff_id, or the one pending handoff for a session_id. The console calls this when the human confirms outside the page.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "HandoffConfirmInput",
+ "type": "object",
"properties": {
"handoff_id": {
- "default": null,
"description": "Confirm a specific handoff by id. Omit to confirm the one pending handoff for `session_id`.",
+ "default": null,
"type": [
"string",
"null"
@@ -19,12 +21,15 @@
"null"
]
}
- },
- "title": "HandoffConfirmInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "HandoffConfirmOutput",
+ "type": "object",
+ "required": [
+ "ok"
+ ],
"properties": {
"handoff_id": {
"type": [
@@ -36,11 +41,6 @@
"description": "True when a pending handoff matched and was resolved.",
"type": "boolean"
}
- },
- "required": [
- "ok"
- ],
- "title": "HandoffConfirmOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.handoff.json b/browser/tests/golden/schemas/browser.handoff.json
index 2ab0a9ba1..eb144e85a 100644
--- a/browser/tests/golden/schemas/browser.handoff.json
+++ b/browser/tests/golden/schemas/browser.handoff.json
@@ -1,8 +1,14 @@
{
- "description": "Pause a session for a step only a human can do (CAPTCHA, 2FA, payment): show an in-page continue banner and block until the human clicks it, a browser::handoff::confirm call resolves it, or the timeout elapses. Human acknowledgment is not proof — verify the expected page state after it returns.",
"function_id": "browser::handoff",
+ "description": "Pause a session for a step only a human can do (CAPTCHA, 2FA, payment): show an in-page continue banner and block until the human clicks it, a browser::handoff::confirm call resolves it, or the timeout elapses. Human acknowledgment is not proof — verify the expected page state after it returns.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "HandoffInput",
+ "type": "object",
+ "required": [
+ "instructions",
+ "session_id"
+ ],
"properties": {
"instructions": {
"description": "What the human must do before the call continues. Shown in the in-page banner and the handoff-requested event.",
@@ -12,25 +18,27 @@
"type": "string"
},
"timeout_ms": {
- "default": null,
"description": "Give up after this long and return with `via: \"timeout\"`. Defaults to the config default; clamped to `max_timeout_ms`. Set generously; a human is slow.",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
}
- },
- "required": [
- "instructions",
- "session_id"
- ],
- "title": "HandoffInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "HandoffOutput",
+ "type": "object",
+ "required": [
+ "confirmed",
+ "handoff_id",
+ "url",
+ "via"
+ ],
"properties": {
"confirmed": {
"description": "True when a human confirmed; false when the wait timed out.",
@@ -47,14 +55,6 @@
"description": "How the confirmation arrived: `in_page`, `confirm_call`, or `timeout`.",
"type": "string"
}
- },
- "required": [
- "confirmed",
- "handoff_id",
- "url",
- "via"
- ],
- "title": "HandoffOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.history.json b/browser/tests/golden/schemas/browser.history.json
index 08d6b6a1c..509189a4a 100644
--- a/browser/tests/golden/schemas/browser.history.json
+++ b/browser/tests/golden/schemas/browser.history.json
@@ -1,8 +1,14 @@
{
- "description": "Go back, go forward, or reload the session's page. Back/forward at the history edge is a no-op with moved=false.",
"function_id": "browser::history",
+ "description": "Go back, go forward, or reload the session's page. Back/forward at the history edge is a no-op with moved=false.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "HistoryInput",
+ "type": "object",
+ "required": [
+ "action",
+ "session_id"
+ ],
"properties": {
"action": {
"description": "`back`, `forward`, or `reload`.",
@@ -11,16 +17,17 @@
"session_id": {
"type": "string"
}
- },
- "required": [
- "action",
- "session_id"
- ],
- "title": "HistoryInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "HistoryOutput",
+ "type": "object",
+ "required": [
+ "moved",
+ "ok",
+ "url"
+ ],
"properties": {
"moved": {
"description": "False when back/forward had no entry to move to.",
@@ -33,13 +40,6 @@
"description": "URL after the action. `back`/`forward` at the history edge is a no-op with ok=true.",
"type": "string"
}
- },
- "required": [
- "moved",
- "ok",
- "url"
- ],
- "title": "HistoryOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.navigate.json b/browser/tests/golden/schemas/browser.navigate.json
index 519ca5151..df5be9802 100644
--- a/browser/tests/golden/schemas/browser.navigate.json
+++ b/browser/tests/golden/schemas/browser.navigate.json
@@ -1,36 +1,43 @@
{
- "description": "Navigate a session to a URL and wait for the page to load. Element refs from earlier snapshots are invalidated by navigation.",
"function_id": "browser::navigate",
+ "description": "Navigate a session to a URL and wait for the page to load. Element refs from earlier snapshots are invalidated by navigation.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "NavigateInput",
+ "type": "object",
+ "required": [
+ "session_id",
+ "url"
+ ],
"properties": {
"session_id": {
"type": "string"
},
"timeout_ms": {
- "default": null,
"description": "Upper bound on the navigation wait; clamped to `max_timeout_ms`.",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
},
"url": {
"description": "Absolute URL; scheme must be on the configured allowlist.",
"type": "string"
}
- },
- "required": [
- "session_id",
- "url"
- ],
- "title": "NavigateInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "NavigateOutput",
+ "type": "object",
+ "required": [
+ "ok",
+ "timed_out",
+ "url"
+ ],
"properties": {
"ok": {
"type": "boolean"
@@ -49,13 +56,6 @@
"description": "URL after redirects.",
"type": "string"
}
- },
- "required": [
- "ok",
- "timed_out",
- "url"
- ],
- "title": "NavigateOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.network.read.json b/browser/tests/golden/schemas/browser.network.read.json
index 925ce23c8..de626428e 100644
--- a/browser/tests/golden/schemas/browser.network.read.json
+++ b/browser/tests/golden/schemas/browser.network.read.json
@@ -1,30 +1,35 @@
{
- "description": "Read the session's captured network requests (method, URL, status, failures). failed_only=true is the fast path for 'what broke'.",
"function_id": "browser::network::read",
+ "description": "Read the session's captured network requests (method, URL, status, failures). failed_only=true is the fast path for 'what broke'.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "NetworkReadInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"failed_only": {
- "default": null,
"description": "Only failed requests (network error or status >= 400).",
+ "default": null,
"type": [
"boolean",
"null"
]
},
"limit": {
- "default": null,
"description": "Maximum entries returned, newest kept (default 100).",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
},
"pattern": {
- "default": null,
"description": "Regex applied to the request URL.",
+ "default": null,
"type": [
"string",
"null"
@@ -34,27 +39,57 @@
"type": "string"
},
"since_seq": {
- "default": null,
"description": "Only entries with `seq` greater than this.",
- "format": "uint64",
- "minimum": 0.0,
+ "default": null,
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "uint64",
+ "minimum": 0.0
}
- },
- "required": [
- "session_id"
- ],
- "title": "NetworkReadInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "NetworkReadOutput",
+ "type": "object",
+ "required": [
+ "dropped",
+ "entries",
+ "last_seq"
+ ],
+ "properties": {
+ "dropped": {
+ "description": "Entries evicted from the ring buffer since session start.",
+ "type": "integer",
+ "format": "uint64",
+ "minimum": 0.0
+ },
+ "entries": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/NetworkEntry"
+ }
+ },
+ "last_seq": {
+ "description": "Cursor for the next `since_seq`.",
+ "type": "integer",
+ "format": "uint64",
+ "minimum": 0.0
+ }
+ },
"definitions": {
"NetworkEntry": {
"description": "One captured network request.",
+ "type": "object",
+ "required": [
+ "failed",
+ "method",
+ "seq",
+ "timestamp",
+ "url"
+ ],
"properties": {
"error": {
"type": [
@@ -76,61 +111,26 @@
},
"seq": {
"description": "Monotonic per-session cursor; pass back as `since_seq`.",
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"status": {
- "format": "int64",
"type": [
"integer",
"null"
- ]
+ ],
+ "format": "int64"
},
"timestamp": {
- "format": "int64",
- "type": "integer"
+ "type": "integer",
+ "format": "int64"
},
"url": {
"type": "string"
}
- },
- "required": [
- "failed",
- "method",
- "seq",
- "timestamp",
- "url"
- ],
- "type": "object"
+ }
}
- },
- "properties": {
- "dropped": {
- "description": "Entries evicted from the ring buffer since session start.",
- "format": "uint64",
- "minimum": 0.0,
- "type": "integer"
- },
- "entries": {
- "items": {
- "$ref": "#/definitions/NetworkEntry"
- },
- "type": "array"
- },
- "last_seq": {
- "description": "Cursor for the next `since_seq`.",
- "format": "uint64",
- "minimum": 0.0,
- "type": "integer"
- }
- },
- "required": [
- "dropped",
- "entries",
- "last_seq"
- ],
- "title": "NetworkReadOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.pick.hint.json b/browser/tests/golden/schemas/browser.pick.hint.json
index a55ff68f2..845bc1086 100644
--- a/browser/tests/golden/schemas/browser.pick.hint.json
+++ b/browser/tests/golden/schemas/browser.pick.hint.json
@@ -1,64 +1,41 @@
{
- "description": "Internal: element preview at a viewport point (tag, id, classes, bounds) so the console UI can draw a hover highlight in pick mode. Not an agent function.",
"function_id": "browser::pick::hint",
+ "description": "Internal: element preview at a viewport point (tag, id, classes, bounds) so the console UI can draw a hover highlight in pick mode. Not an agent function.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "PickHintInput",
+ "type": "object",
+ "required": [
+ "session_id",
+ "x",
+ "y"
+ ],
"properties": {
"session_id": {
"type": "string"
},
"x": {
"description": "Viewport x of the cursor.",
- "format": "double",
- "type": "number"
+ "type": "number",
+ "format": "double"
},
"y": {
"description": "Viewport y of the cursor.",
- "format": "double",
- "type": "number"
+ "type": "number",
+ "format": "double"
}
- },
- "required": [
- "session_id",
- "x",
- "y"
- ],
- "title": "PickHintInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
- "definitions": {
- "Bounds": {
- "properties": {
- "height": {
- "format": "double",
- "type": "number"
- },
- "width": {
- "format": "double",
- "type": "number"
- },
- "x": {
- "format": "double",
- "type": "number"
- },
- "y": {
- "format": "double",
- "type": "number"
- }
- },
- "required": [
- "height",
- "width",
- "x",
- "y"
- ],
- "type": "object"
- }
- },
+ "title": "PickHintOutput",
+ "type": "object",
+ "required": [
+ "hit"
+ ],
"properties": {
"bounds": {
+ "description": "Viewport-space box to draw the highlight over.",
"anyOf": [
{
"$ref": "#/definitions/Bounds"
@@ -66,8 +43,7 @@
{
"type": "null"
}
- ],
- "description": "Viewport-space box to draw the highlight over."
+ ]
},
"classes": {
"type": [
@@ -93,10 +69,34 @@
]
}
},
- "required": [
- "hit"
- ],
- "title": "PickHintOutput",
- "type": "object"
+ "definitions": {
+ "Bounds": {
+ "type": "object",
+ "required": [
+ "height",
+ "width",
+ "x",
+ "y"
+ ],
+ "properties": {
+ "height": {
+ "type": "number",
+ "format": "double"
+ },
+ "width": {
+ "type": "number",
+ "format": "double"
+ },
+ "x": {
+ "type": "number",
+ "format": "double"
+ },
+ "y": {
+ "type": "number",
+ "format": "double"
+ }
+ }
+ }
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.pick.resolve.json b/browser/tests/golden/schemas/browser.pick.resolve.json
index dca410ea9..0820d489f 100644
--- a/browser/tests/golden/schemas/browser.pick.resolve.json
+++ b/browser/tests/golden/schemas/browser.pick.resolve.json
@@ -1,43 +1,43 @@
{
- "description": "Internal: resolve the element at a clicked viewport point and emit browser::picked. The console calls this on a pick-mode click. Not an agent function.",
"function_id": "browser::pick::resolve",
+ "description": "Internal: resolve the element at a clicked viewport point and emit browser::picked. The console calls this on a pick-mode click. Not an agent function.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "PickResolveInput",
+ "type": "object",
+ "required": [
+ "session_id",
+ "x",
+ "y"
+ ],
"properties": {
"session_id": {
"type": "string"
},
"x": {
"description": "Viewport x of the click.",
- "format": "double",
- "type": "number"
+ "type": "number",
+ "format": "double"
},
"y": {
"description": "Viewport y of the click.",
- "format": "double",
- "type": "number"
+ "type": "number",
+ "format": "double"
}
- },
- "required": [
- "session_id",
- "x",
- "y"
- ],
- "title": "PickResolveInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "AckOutput",
"description": "Neutral acknowledgement returned by the fire-and-forget internal functions (pick start/stop/resolve, screencast start/stop): they emit their result as a trigger event, so the direct return is just `{ ok }`.",
+ "type": "object",
+ "required": [
+ "ok"
+ ],
"properties": {
"ok": {
"type": "boolean"
}
- },
- "required": [
- "ok"
- ],
- "title": "AckOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.pick.start.json b/browser/tests/golden/schemas/browser.pick.start.json
index 254639d65..460988a99 100644
--- a/browser/tests/golden/schemas/browser.pick.start.json
+++ b/browser/tests/golden/schemas/browser.pick.start.json
@@ -1,31 +1,31 @@
{
- "description": "Internal: enter pick mode so the human can select an element in the console UI. Not an agent function.",
"function_id": "browser::pick::start",
+ "description": "Internal: enter pick mode so the human can select an element in the console UI. Not an agent function.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "PickStartInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"session_id": {
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "PickStartInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "AckOutput",
"description": "Neutral acknowledgement returned by the fire-and-forget internal functions (pick start/stop/resolve, screencast start/stop): they emit their result as a trigger event, so the direct return is just `{ ok }`.",
+ "type": "object",
+ "required": [
+ "ok"
+ ],
"properties": {
"ok": {
"type": "boolean"
}
- },
- "required": [
- "ok"
- ],
- "title": "AckOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.pick.stop.json b/browser/tests/golden/schemas/browser.pick.stop.json
index da66d85c5..719c0cb56 100644
--- a/browser/tests/golden/schemas/browser.pick.stop.json
+++ b/browser/tests/golden/schemas/browser.pick.stop.json
@@ -1,32 +1,32 @@
{
- "description": "Internal: leave DevTools inspect mode without picking. Idempotent. Not an agent function.",
"function_id": "browser::pick::stop",
+ "description": "Internal: leave DevTools inspect mode without picking. Idempotent. Not an agent function.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "PickStopInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"session_id": {
"description": "Cancelling pick mode on an unknown session succeeds.",
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "PickStopInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "AckOutput",
"description": "Neutral acknowledgement returned by the fire-and-forget internal functions (pick start/stop/resolve, screencast start/stop): they emit their result as a trigger event, so the direct return is just `{ ok }`.",
+ "type": "object",
+ "required": [
+ "ok"
+ ],
"properties": {
"ok": {
"type": "boolean"
}
- },
- "required": [
- "ok"
- ],
- "title": "AckOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.recording.start.json b/browser/tests/golden/schemas/browser.recording.start.json
index 1b4fba572..643ee7955 100644
--- a/browser/tests/golden/schemas/browser.recording.start.json
+++ b/browser/tests/golden/schemas/browser.recording.start.json
@@ -1,12 +1,18 @@
{
- "description": "Record a session's live viewport to a video file (webm or mp4) by piping the screencast through ffmpeg. Turns screencast on if needed. Requires ffmpeg on PATH; browser::doctor reports whether it is available.",
"function_id": "browser::recording::start",
+ "description": "Record a session's live viewport to a video file (webm or mp4) by piping the screencast through ffmpeg. Turns screencast on if needed. Requires ffmpeg on PATH; browser::doctor reports whether it is available.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "RecordingStartInput",
+ "type": "object",
+ "required": [
+ "path",
+ "session_id"
+ ],
"properties": {
"format": {
- "default": null,
"description": "`webm` (VP9) or `mp4` (H.264). Defaults to webm.",
+ "default": null,
"type": [
"string",
"null"
@@ -19,16 +25,17 @@
"session_id": {
"type": "string"
}
- },
- "required": [
- "path",
- "session_id"
- ],
- "title": "RecordingStartInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "RecordingStartOutput",
+ "type": "object",
+ "required": [
+ "format",
+ "ok",
+ "path"
+ ],
"properties": {
"format": {
"type": "string"
@@ -39,13 +46,6 @@
"path": {
"type": "string"
}
- },
- "required": [
- "format",
- "ok",
- "path"
- ],
- "title": "RecordingStartOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.recording.stop.json b/browser/tests/golden/schemas/browser.recording.stop.json
index 9cdf3307b..c625d5936 100644
--- a/browser/tests/golden/schemas/browser.recording.stop.json
+++ b/browser/tests/golden/schemas/browser.recording.stop.json
@@ -1,32 +1,39 @@
{
- "description": "Stop a session's recording, finalize the file, and return its path, duration, and frame count. Idempotent: stopping when nothing is recording returns ok=false.",
"function_id": "browser::recording::stop",
+ "description": "Stop a session's recording, finalize the file, and return its path, duration, and frame count. Idempotent: stopping when nothing is recording returns ok=false.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "RecordingStopInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"session_id": {
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "RecordingStopInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "RecordingStopOutput",
+ "type": "object",
+ "required": [
+ "duration_ms",
+ "frames",
+ "ok"
+ ],
"properties": {
"duration_ms": {
"description": "Wall-clock duration captured, milliseconds.",
- "format": "int64",
- "type": "integer"
+ "type": "integer",
+ "format": "int64"
},
"frames": {
"description": "Frames written to the encoder.",
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"ok": {
"description": "False when no recording was running.",
@@ -38,13 +45,6 @@
"null"
]
}
- },
- "required": [
- "duration_ms",
- "frames",
- "ok"
- ],
- "title": "RecordingStopOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.regex.json b/browser/tests/golden/schemas/browser.regex.json
new file mode 100644
index 000000000..c05ec3828
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.regex.json
@@ -0,0 +1,40 @@
+{
+ "function_id": "browser::regex",
+ "description": "Run a regex over the visible text of provided HTML; `first` returns the first match, else all.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "pattern": {
+ "type": "string"
+ },
+ "first": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "html",
+ "pattern"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "result": {
+ "type": [
+ "array",
+ "string",
+ "null"
+ ],
+ "items": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.screencast.start.json b/browser/tests/golden/schemas/browser.screencast.start.json
index 749b11489..d6f6e82d6 100644
--- a/browser/tests/golden/schemas/browser.screencast.start.json
+++ b/browser/tests/golden/schemas/browser.screencast.start.json
@@ -1,31 +1,31 @@
{
- "description": "Internal: start pushing live viewport frames for browser::frame. Console-UI plumbing; agents use browser::screenshot. Not an agent function.",
"function_id": "browser::screencast::start",
+ "description": "Internal: start pushing live viewport frames for browser::frame. Console-UI plumbing; agents use browser::screenshot. Not an agent function.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ScreencastStartInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"session_id": {
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "ScreencastStartInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "AckOutput",
"description": "Neutral acknowledgement returned by the fire-and-forget internal functions (pick start/stop/resolve, screencast start/stop): they emit their result as a trigger event, so the direct return is just `{ ok }`.",
+ "type": "object",
+ "required": [
+ "ok"
+ ],
"properties": {
"ok": {
"type": "boolean"
}
- },
- "required": [
- "ok"
- ],
- "title": "AckOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.screencast.stop.json b/browser/tests/golden/schemas/browser.screencast.stop.json
index 9825564a8..ad204db88 100644
--- a/browser/tests/golden/schemas/browser.screencast.stop.json
+++ b/browser/tests/golden/schemas/browser.screencast.stop.json
@@ -1,32 +1,32 @@
{
- "description": "Internal: stop the live frame push. Idempotent. Not an agent function.",
"function_id": "browser::screencast::stop",
+ "description": "Internal: stop the live frame push. Idempotent. Not an agent function.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ScreencastStopInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"session_id": {
"description": "Stopping the screencast on an unknown session succeeds.",
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "ScreencastStopInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "AckOutput",
"description": "Neutral acknowledgement returned by the fire-and-forget internal functions (pick start/stop/resolve, screencast start/stop): they emit their result as a trigger event, so the direct return is just `{ ok }`.",
+ "type": "object",
+ "required": [
+ "ok"
+ ],
"properties": {
"ok": {
"type": "boolean"
}
- },
- "required": [
- "ok"
- ],
- "title": "AckOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.screenshot-url.json b/browser/tests/golden/schemas/browser.screenshot-url.json
new file mode 100644
index 000000000..d6c3ba22e
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.screenshot-url.json
@@ -0,0 +1,87 @@
+{
+ "function_id": "browser::screenshot-url",
+ "description": "Capture a page screenshot as image content blocks via a browser fetcher (dynamic or stealthy).",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "url": {
+ "type": "string"
+ },
+ "fetcher": {
+ "type": "string",
+ "enum": [
+ "dynamic",
+ "stealthy"
+ ]
+ },
+ "full_page": {
+ "type": "boolean"
+ },
+ "format": {
+ "type": "string",
+ "enum": [
+ "png",
+ "jpeg"
+ ]
+ },
+ "headless": {
+ "type": "boolean"
+ },
+ "network_idle": {
+ "type": "boolean"
+ },
+ "timeout": {
+ "type": "number"
+ },
+ "wait_selector": {
+ "type": "string"
+ },
+ "proxy": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "url"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "content": {
+ "type": "array",
+ "description": "image blocks (one per tile, width<=1024/height<=1536) + a text caption",
+ "items": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "enum": [
+ "image",
+ "text"
+ ]
+ },
+ "mime": {
+ "type": "string"
+ },
+ "data": {
+ "type": "string",
+ "description": "base64 image bytes (image blocks)"
+ },
+ "text": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "type"
+ ]
+ }
+ },
+ "mime": {
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.screenshot.json b/browser/tests/golden/schemas/browser.screenshot.json
index 4e00e2dfa..dade04951 100644
--- a/browser/tests/golden/schemas/browser.screenshot.json
+++ b/browser/tests/golden/schemas/browser.screenshot.json
@@ -1,12 +1,17 @@
{
- "description": "Capture the session viewport as a viewable JPEG. Use browser::snapshot for machine-readable structure; screenshot when layout or rendering matters.",
"function_id": "browser::screenshot",
+ "description": "Capture the session viewport as a viewable JPEG. Use browser::snapshot for machine-readable structure; screenshot when layout or rendering matters.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ScreenshotInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"full_page": {
- "default": null,
"description": "Capture the full scrollable page instead of the viewport.",
+ "default": null,
"type": [
"boolean",
"null"
@@ -15,18 +20,34 @@
"session_id": {
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "ScreenshotInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ScreenshotOutput",
+ "type": "object",
+ "required": [
+ "content",
+ "details"
+ ],
+ "properties": {
+ "content": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/ContentBlock"
+ }
+ },
+ "details": {
+ "$ref": "#/definitions/ScreenshotDetails"
+ }
+ },
"definitions": {
"ContentBlock": {
"description": "One block of a viewable response: an image block plus a text line.",
+ "type": "object",
+ "required": [
+ "type"
+ ],
"properties": {
"data": {
"type": [
@@ -49,18 +70,21 @@
"type": {
"type": "string"
}
- },
- "required": [
- "type"
- ],
- "type": "object"
+ }
},
"ScreenshotDetails": {
+ "type": "object",
+ "required": [
+ "height",
+ "session_id",
+ "url",
+ "width"
+ ],
"properties": {
"height": {
+ "type": "integer",
"format": "uint32",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"session_id": {
"type": "string"
@@ -69,36 +93,12 @@
"type": "string"
},
"width": {
+ "type": "integer",
"format": "uint32",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
}
- },
- "required": [
- "height",
- "session_id",
- "url",
- "width"
- ],
- "type": "object"
+ }
}
- },
- "properties": {
- "content": {
- "items": {
- "$ref": "#/definitions/ContentBlock"
- },
- "type": "array"
- },
- "details": {
- "$ref": "#/definitions/ScreenshotDetails"
- }
- },
- "required": [
- "content",
- "details"
- ],
- "title": "ScreenshotOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.session-close.json b/browser/tests/golden/schemas/browser.session-close.json
new file mode 100644
index 000000000..b0a84fb9d
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.session-close.json
@@ -0,0 +1,23 @@
+{
+ "function_id": "browser::session-close",
+ "description": "Close a session and free its browser/connection.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "session_id": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "session_id"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "closed": {
+ "type": "boolean"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.session-fetch.json b/browser/tests/golden/schemas/browser.session-fetch.json
new file mode 100644
index 000000000..9f218f030
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.session-fetch.json
@@ -0,0 +1,151 @@
+{
+ "function_id": "browser::session-fetch",
+ "description": "Fetch a URL on an open session (reuses its cookies/browser); same page/extraction output.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "session_id": {
+ "type": "string"
+ },
+ "url": {
+ "type": "string"
+ },
+ "method": {
+ "type": "string",
+ "enum": [
+ "get",
+ "post",
+ "put",
+ "delete"
+ ]
+ },
+ "headers": {
+ "type": "object"
+ },
+ "params": {
+ "type": "object"
+ },
+ "data": {
+ "type": "object"
+ },
+ "json": {
+ "type": "object"
+ },
+ "wait_selector": {
+ "type": "string"
+ },
+ "selectors": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "regex": {
+ "type": "string"
+ },
+ "attr": {
+ "type": "string",
+ "description": "extract this attribute instead of text"
+ },
+ "html": {
+ "type": "boolean",
+ "description": "extract inner HTML instead of text"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "return every match as a list"
+ }
+ },
+ "required": [
+ "name"
+ ]
+ }
+ },
+ "include_html": {
+ "type": "boolean"
+ },
+ "format": {
+ "type": "string",
+ "enum": [
+ "markdown",
+ "text"
+ ],
+ "description": "render page body to this format"
+ },
+ "main_content_only": {
+ "type": "boolean",
+ "description": "strip nav/scripts/hidden before rendering"
+ },
+ "css_selector": {
+ "type": "string",
+ "description": "scope the render to this CSS subtree (e.g. a page's content div)"
+ }
+ },
+ "required": [
+ "session_id",
+ "url"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "status": {
+ "type": [
+ "integer",
+ "null"
+ ]
+ },
+ "url": {
+ "type": "string"
+ },
+ "headers": {
+ "type": "object"
+ },
+ "cookies": {
+ "type": "object"
+ },
+ "encoding": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "extracted": {
+ "type": "object"
+ },
+ "html": {
+ "type": "string"
+ },
+ "content": {
+ "type": "string",
+ "description": "markdown/text render when `format` requested"
+ },
+ "format": {
+ "type": "string"
+ },
+ "captured_xhr": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "results": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "error": {
+ "type": "string"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.session-list.json b/browser/tests/golden/schemas/browser.session-list.json
new file mode 100644
index 000000000..e5389b0b6
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.session-list.json
@@ -0,0 +1,46 @@
+{
+ "function_id": "browser::session-list",
+ "description": "List open sessions with their type and idle time.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "enum": [
+ "http",
+ "dynamic",
+ "stealthy"
+ ],
+ "description": "filter by type"
+ }
+ }
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "sessions": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "session_id": {
+ "type": "string"
+ },
+ "type": {
+ "type": "string"
+ },
+ "created_at": {
+ "type": "number"
+ },
+ "last_used": {
+ "type": "number"
+ },
+ "idle_s": {
+ "type": "number"
+ }
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.session-open.json b/browser/tests/golden/schemas/browser.session-open.json
new file mode 100644
index 000000000..523ef3bdb
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.session-open.json
@@ -0,0 +1,60 @@
+{
+ "function_id": "browser::session-open",
+ "description": "Open a persistent HTTP/browser session; returns a session_id that reuses cookies + state.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "type": {
+ "type": "string",
+ "enum": [
+ "http",
+ "dynamic",
+ "stealthy"
+ ],
+ "description": "session engine"
+ },
+ "impersonate": {
+ "type": "string"
+ },
+ "headers": {
+ "type": "object"
+ },
+ "proxy": {
+ "type": "string"
+ },
+ "proxies": {
+ "type": "object"
+ },
+ "headless": {
+ "type": "boolean"
+ },
+ "useragent": {
+ "type": "string"
+ },
+ "solve_cloudflare": {
+ "type": "boolean"
+ },
+ "real_chrome": {
+ "type": "boolean"
+ },
+ "timeout": {
+ "type": "number"
+ },
+ "capture_xhr": {
+ "type": "string",
+ "description": "regex; capture matching XHRs (browser sessions)"
+ }
+ }
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "session_id": {
+ "type": "string"
+ },
+ "type": {
+ "type": "string"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.sessions.attach.json b/browser/tests/golden/schemas/browser.sessions.attach.json
index 9831e6180..158be7ed8 100644
--- a/browser/tests/golden/schemas/browser.sessions.attach.json
+++ b/browser/tests/golden/schemas/browser.sessions.attach.json
@@ -1,12 +1,17 @@
{
- "description": "Attach a session to an already-running browser over CDP (start Chrome with --remote-debugging-port). Opens a fresh tab the session owns, or adopts an existing user tab by URL substring and releases it untouched on stop. Reaches the real profile with its logins; disabled unless allow_attach is set in config.",
"function_id": "browser::sessions::attach",
+ "description": "Attach a session to an already-running browser over CDP (start Chrome with --remote-debugging-port). Opens a fresh tab the session owns, or adopts an existing user tab by URL substring and releases it untouched on stop. Reaches the real profile with its logins; disabled unless allow_attach is set in config.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "AttachInput",
+ "type": "object",
+ "required": [
+ "cdp_url"
+ ],
"properties": {
"adopt_url_substring": {
- "default": null,
"description": "Adopt the existing tab whose URL contains this substring, exclusively, and release it untouched on stop. Omit to open a fresh tab the session owns and closes on stop. Must match exactly one open tab.",
+ "default": null,
"type": [
"string",
"null"
@@ -17,30 +22,33 @@
"type": "string"
},
"read_only": {
- "default": null,
"description": "Inspection-only session; see browser::sessions::start.",
+ "default": null,
"type": [
"boolean",
"null"
]
},
"url": {
- "default": null,
"description": "URL to open in the fresh tab (ignored when adopting). Omit for about:blank.",
+ "default": null,
"type": [
"string",
"null"
]
}
- },
- "required": [
- "cdp_url"
- ],
- "title": "AttachInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "AttachOutput",
+ "type": "object",
+ "required": [
+ "adopted",
+ "read_only",
+ "session_id",
+ "url"
+ ],
"properties": {
"adopted": {
"description": "True when the session adopted an existing user tab (released, not closed, on stop); false when it opened a fresh tab it owns.",
@@ -55,14 +63,6 @@
"url": {
"type": "string"
}
- },
- "required": [
- "adopted",
- "read_only",
- "session_id",
- "url"
- ],
- "title": "AttachOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.sessions.list.json b/browser/tests/golden/schemas/browser.sessions.list.json
index c4f171970..19195e4f7 100644
--- a/browser/tests/golden/schemas/browser.sessions.list.json
+++ b/browser/tests/golden/schemas/browser.sessions.list.json
@@ -1,6 +1,6 @@
{
- "description": "List live browser sessions with their current URL and activity.",
"function_id": "browser::sessions::list",
+ "description": "List live browser sessions with their current URL and activity.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
"title": "ListInput",
@@ -8,24 +8,47 @@
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "ListOutput",
+ "type": "object",
+ "required": [
+ "sessions"
+ ],
+ "properties": {
+ "sessions": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/SessionInfo"
+ }
+ }
+ },
"definitions": {
"SessionInfo": {
+ "type": "object",
+ "required": [
+ "console_entries",
+ "created_ms",
+ "headless",
+ "last_used_ms",
+ "read_only",
+ "session_id",
+ "url"
+ ],
"properties": {
"console_entries": {
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"created_ms": {
- "format": "int64",
- "type": "integer"
+ "type": "integer",
+ "format": "int64"
},
"headless": {
"type": "boolean"
},
"last_used_ms": {
- "format": "int64",
- "type": "integer"
+ "type": "integer",
+ "format": "int64"
},
"read_only": {
"type": "boolean"
@@ -42,31 +65,8 @@
"url": {
"type": "string"
}
- },
- "required": [
- "console_entries",
- "created_ms",
- "headless",
- "last_used_ms",
- "read_only",
- "session_id",
- "url"
- ],
- "type": "object"
+ }
}
- },
- "properties": {
- "sessions": {
- "items": {
- "$ref": "#/definitions/SessionInfo"
- },
- "type": "array"
- }
- },
- "required": [
- "sessions"
- ],
- "title": "ListOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.sessions.start.json b/browser/tests/golden/schemas/browser.sessions.start.json
index 290d0cff5..8c4cd1bfd 100644
--- a/browser/tests/golden/schemas/browser.sessions.start.json
+++ b/browser/tests/golden/schemas/browser.sessions.start.json
@@ -1,39 +1,47 @@
{
- "description": "Start an interactive Chromium session and return its session_id. Sessions keep console and network history; stop them with browser::sessions::stop when done.",
"function_id": "browser::sessions::start",
+ "description": "Start an interactive Chromium session and return its session_id. Sessions keep console and network history; stop them with browser::sessions::stop when done.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "StartInput",
+ "type": "object",
"properties": {
"headful": {
- "default": null,
"description": "Force a visible window for this session, overriding the configured `headless` default.",
+ "default": null,
"type": [
"boolean",
"null"
]
},
"read_only": {
- "default": null,
"description": "Inspection-only session: act, evaluate, execute, and styles::write are rejected while navigation, snapshots, reads, and screenshots work. Immutable for the session's lifetime.",
+ "default": null,
"type": [
"boolean",
"null"
]
},
"url": {
- "default": null,
"description": "URL to open immediately. Omit to start on about:blank.",
+ "default": null,
"type": [
"string",
"null"
]
}
- },
- "title": "StartInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "StartOutput",
+ "type": "object",
+ "required": [
+ "headless",
+ "read_only",
+ "session_id",
+ "url"
+ ],
"properties": {
"headless": {
"type": "boolean"
@@ -48,14 +56,6 @@
"url": {
"type": "string"
}
- },
- "required": [
- "headless",
- "read_only",
- "session_id",
- "url"
- ],
- "title": "StartOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.sessions.stop.json b/browser/tests/golden/schemas/browser.sessions.stop.json
index 3bcd4fd83..8e70bdaa0 100644
--- a/browser/tests/golden/schemas/browser.sessions.stop.json
+++ b/browser/tests/golden/schemas/browser.sessions.stop.json
@@ -1,22 +1,28 @@
{
- "description": "Stop a browser session and its Chromium process. Idempotent: stopping an unknown or already-stopped session succeeds with was_running=false.",
"function_id": "browser::sessions::stop",
+ "description": "Stop a browser session and its Chromium process. Idempotent: stopping an unknown or already-stopped session succeeds with was_running=false.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "StopInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"session_id": {
"description": "Session to stop. Stopping an unknown or already-stopped id succeeds.",
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "StopInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "StopOutput",
+ "type": "object",
+ "required": [
+ "ok",
+ "was_running"
+ ],
"properties": {
"ok": {
"type": "boolean"
@@ -25,12 +31,6 @@
"description": "False when the session was already gone.",
"type": "boolean"
}
- },
- "required": [
- "ok",
- "was_running"
- ],
- "title": "StopOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.snapshot.json b/browser/tests/golden/schemas/browser.snapshot.json
index cfeec70b9..7793beb12 100644
--- a/browser/tests/golden/schemas/browser.snapshot.json
+++ b/browser/tests/golden/schemas/browser.snapshot.json
@@ -1,12 +1,17 @@
{
- "description": "Read the page as an accessibility-tree outline. Lines carry [ref=eN] handles that browser::act accepts; refs stay valid until the next navigation. Prefer this over browser::screenshot; it is cheaper and machine-readable.",
"function_id": "browser::snapshot",
+ "description": "Read the page as an accessibility-tree outline. Lines carry [ref=eN] handles that browser::act accepts; refs stay valid until the next navigation. Prefer this over browser::screenshot; it is cheaper and machine-readable.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "SnapshotInput",
+ "type": "object",
+ "required": [
+ "session_id"
+ ],
"properties": {
"diff": {
- "default": null,
"description": "Return only what changed since this session's previous snapshot instead of the full outline. Falls back to a full snapshot when there is no baseline (first snapshot, or first after a navigation).",
+ "default": null,
"type": [
"boolean",
"null"
@@ -15,47 +20,21 @@
"session_id": {
"type": "string"
}
- },
- "required": [
- "session_id"
- ],
- "title": "SnapshotInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
- "definitions": {
- "SnapshotDiff": {
- "description": "Changes since the previous snapshot. Lines are compared without their `[ref=eN]` suffix (ref names are unique per snapshot); `added` lines carry current refs and are directly actionable.",
- "properties": {
- "added": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "removed": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "unchanged": {
- "format": "uint64",
- "minimum": 0.0,
- "type": "integer"
- }
- },
- "required": [
- "added",
- "removed",
- "unchanged"
- ],
- "type": "object"
- }
- },
+ "title": "SnapshotOutput",
+ "type": "object",
+ "required": [
+ "generation",
+ "tree",
+ "truncated",
+ "url"
+ ],
"properties": {
"diff": {
+ "description": "Present when the caller asked for `diff: true` and a baseline existed. Covers only the emitted nodes of both snapshots; check `truncated` before trusting it as a complete change set.",
"anyOf": [
{
"$ref": "#/definitions/SnapshotDiff"
@@ -63,14 +42,13 @@
{
"type": "null"
}
- ],
- "description": "Present when the caller asked for `diff: true` and a baseline existed. Covers only the emitted nodes of both snapshots; check `truncated` before trusting it as a complete change set."
+ ]
},
"generation": {
"description": "Document generation the refs belong to; navigation advances it and kills every ref from earlier generations.",
+ "type": "integer",
"format": "uint64",
- "minimum": 0.0,
- "type": "integer"
+ "minimum": 0.0
},
"title": {
"type": [
@@ -90,13 +68,35 @@
"type": "string"
}
},
- "required": [
- "generation",
- "tree",
- "truncated",
- "url"
- ],
- "title": "SnapshotOutput",
- "type": "object"
+ "definitions": {
+ "SnapshotDiff": {
+ "description": "Changes since the previous snapshot. Lines are compared without their `[ref=eN]` suffix (ref names are unique per snapshot); `added` lines carry current refs and are directly actionable.",
+ "type": "object",
+ "required": [
+ "added",
+ "removed",
+ "unchanged"
+ ],
+ "properties": {
+ "added": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "removed": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "unchanged": {
+ "type": "integer",
+ "format": "uint64",
+ "minimum": 0.0
+ }
+ }
+ }
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.stealthy-fetch.json b/browser/tests/golden/schemas/browser.stealthy-fetch.json
new file mode 100644
index 000000000..0a6a1d957
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.stealthy-fetch.json
@@ -0,0 +1,221 @@
+{
+ "function_id": "browser::stealthy-fetch",
+ "description": "Camoufox stealth browser: solves Cloudflare, hardens WebRTC/canvas; extraction + bulk.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "url": {
+ "type": "string"
+ },
+ "urls": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "headless": {
+ "type": "boolean"
+ },
+ "network_idle": {
+ "type": "boolean"
+ },
+ "load_dom": {
+ "type": "boolean"
+ },
+ "timeout": {
+ "type": "number",
+ "description": "milliseconds (browser fetcher)"
+ },
+ "wait": {
+ "type": "number",
+ "description": "extra ms to wait after load"
+ },
+ "wait_selector": {
+ "type": "string"
+ },
+ "wait_selector_state": {
+ "type": "string",
+ "enum": [
+ "attached",
+ "detached",
+ "visible",
+ "hidden"
+ ]
+ },
+ "disable_resources": {
+ "type": "boolean"
+ },
+ "block_ads": {
+ "type": "boolean"
+ },
+ "blocked_domains": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "proxy": {
+ "type": "string"
+ },
+ "useragent": {
+ "type": "string"
+ },
+ "cookies": {
+ "type": "object"
+ },
+ "extra_headers": {
+ "type": "object"
+ },
+ "google_search": {
+ "type": "boolean"
+ },
+ "capture_xhr": {
+ "type": "string"
+ },
+ "locale": {
+ "type": "string"
+ },
+ "timezone_id": {
+ "type": "string"
+ },
+ "dns_over_https": {
+ "type": "boolean"
+ },
+ "extra_flags": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "max_pages": {
+ "type": "integer"
+ },
+ "retries": {
+ "type": "integer"
+ },
+ "retry_delay": {
+ "type": "number"
+ },
+ "solve_cloudflare": {
+ "type": "boolean"
+ },
+ "block_webrtc": {
+ "type": "boolean"
+ },
+ "hide_canvas": {
+ "type": "boolean"
+ },
+ "allow_webgl": {
+ "type": "boolean"
+ },
+ "selectors": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "css": {
+ "type": "string"
+ },
+ "xpath": {
+ "type": "string"
+ },
+ "regex": {
+ "type": "string"
+ },
+ "attr": {
+ "type": "string",
+ "description": "extract this attribute instead of text"
+ },
+ "html": {
+ "type": "boolean",
+ "description": "extract inner HTML instead of text"
+ },
+ "all": {
+ "type": "boolean",
+ "description": "return every match as a list"
+ }
+ },
+ "required": [
+ "name"
+ ]
+ }
+ },
+ "include_html": {
+ "type": "boolean"
+ },
+ "format": {
+ "type": "string",
+ "enum": [
+ "markdown",
+ "text"
+ ],
+ "description": "render page body to this format"
+ },
+ "main_content_only": {
+ "type": "boolean",
+ "description": "strip nav/scripts/hidden before rendering"
+ },
+ "css_selector": {
+ "type": "string",
+ "description": "scope the render to this CSS subtree (e.g. a page's content div)"
+ }
+ }
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "status": {
+ "type": [
+ "integer",
+ "null"
+ ]
+ },
+ "url": {
+ "type": "string"
+ },
+ "headers": {
+ "type": "object"
+ },
+ "cookies": {
+ "type": "object"
+ },
+ "encoding": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "extracted": {
+ "type": "object"
+ },
+ "html": {
+ "type": "string"
+ },
+ "content": {
+ "type": "string",
+ "description": "markdown/text render when `format` requested"
+ },
+ "format": {
+ "type": "string"
+ },
+ "captured_xhr": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "results": {
+ "type": "array",
+ "items": {
+ "type": "object"
+ }
+ },
+ "error": {
+ "type": "string"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.styles.read.json b/browser/tests/golden/schemas/browser.styles.read.json
index 3dee4c197..d092df7c2 100644
--- a/browser/tests/golden/schemas/browser.styles.read.json
+++ b/browser/tests/golden/schemas/browser.styles.read.json
@@ -1,19 +1,25 @@
{
- "description": "Read an element's computed styles (curated design set by default, or named properties) plus its inline style attribute.",
"function_id": "browser::styles::read",
+ "description": "Read an element's computed styles (curated design set by default, or named properties) plus its inline style attribute.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "StylesReadInput",
+ "type": "object",
+ "required": [
+ "ref",
+ "session_id"
+ ],
"properties": {
"properties": {
- "default": null,
"description": "Computed property names to return. Omit for a curated design-panel set; pass `[\"*\"]` for every computed property.",
- "items": {
- "type": "string"
- },
+ "default": null,
"type": [
"array",
"null"
- ]
+ ],
+ "items": {
+ "type": "string"
+ }
},
"ref": {
"description": "Element ref from `browser::snapshot`, `browser::dom::read`, or a pick.",
@@ -22,33 +28,16 @@
"session_id": {
"type": "string"
}
- },
- "required": [
- "ref",
- "session_id"
- ],
- "title": "StylesReadInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
- "definitions": {
- "StyleProperty": {
- "properties": {
- "name": {
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- },
- "required": [
- "name",
- "value"
- ],
- "type": "object"
- }
- },
+ "title": "StylesReadOutput",
+ "type": "object",
+ "required": [
+ "properties",
+ "ref"
+ ],
"properties": {
"inline_style": {
"description": "The element's inline `style` attribute, when present.",
@@ -58,20 +47,31 @@
]
},
"properties": {
+ "type": "array",
"items": {
"$ref": "#/definitions/StyleProperty"
- },
- "type": "array"
+ }
},
"ref": {
"type": "string"
}
},
- "required": [
- "properties",
- "ref"
- ],
- "title": "StylesReadOutput",
- "type": "object"
+ "definitions": {
+ "StyleProperty": {
+ "type": "object",
+ "required": [
+ "name",
+ "value"
+ ],
+ "properties": {
+ "name": {
+ "type": "string"
+ },
+ "value": {
+ "type": "string"
+ }
+ }
+ }
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.styles.write.json b/browser/tests/golden/schemas/browser.styles.write.json
index c4ed6a12e..ea94de569 100644
--- a/browser/tests/golden/schemas/browser.styles.write.json
+++ b/browser/tests/golden/schemas/browser.styles.write.json
@@ -1,12 +1,20 @@
{
- "description": "Set one inline CSS property on an element, live in the page. Visual experiment only: the page's source files are untouched, and the edit dies with the next navigation.",
"function_id": "browser::styles::write",
+ "description": "Set one inline CSS property on an element, live in the page. Visual experiment only: the page's source files are untouched, and the edit dies with the next navigation.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "StylesWriteInput",
+ "type": "object",
+ "required": [
+ "property",
+ "ref",
+ "session_id",
+ "value"
+ ],
"properties": {
"important": {
- "default": null,
"description": "Apply with `!important`.",
+ "default": null,
"type": [
"boolean",
"null"
@@ -27,18 +35,16 @@
"description": "CSS value (`#101418`). Empty string removes the inline property.",
"type": "string"
}
- },
- "required": [
- "property",
- "ref",
- "session_id",
- "value"
- ],
- "title": "StylesWriteInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "StylesWriteOutput",
+ "type": "object",
+ "required": [
+ "inline_style",
+ "ok"
+ ],
"properties": {
"inline_style": {
"description": "The element's inline `style` attribute after the edit.",
@@ -47,12 +53,6 @@
"ok": {
"type": "boolean"
}
- },
- "required": [
- "inline_style",
- "ok"
- ],
- "title": "StylesWriteOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.tabs.list.json b/browser/tests/golden/schemas/browser.tabs.list.json
index 39cb55948..23332df8e 100644
--- a/browser/tests/golden/schemas/browser.tabs.list.json
+++ b/browser/tests/golden/schemas/browser.tabs.list.json
@@ -1,25 +1,43 @@
{
- "description": "List the open tabs of a running browser reachable at a CDP endpoint (url, title, and whether a session already adopted each). Read-only; adopt one with browser::sessions::attach.",
"function_id": "browser::tabs::list",
+ "description": "List the open tabs of a running browser reachable at a CDP endpoint (url, title, and whether a session already adopted each). Read-only; adopt one with browser::sessions::attach.",
"request_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "TabsListInput",
+ "type": "object",
+ "required": [
+ "cdp_url"
+ ],
"properties": {
"cdp_url": {
"description": "CDP endpoint of the running browser, as in browser::sessions::attach.",
"type": "string"
}
- },
- "required": [
- "cdp_url"
- ],
- "title": "TabsListInput",
- "type": "object"
+ }
},
"response_schema": {
"$schema": "http://json-schema.org/draft-07/schema#",
+ "title": "TabsListOutput",
+ "type": "object",
+ "required": [
+ "tabs"
+ ],
+ "properties": {
+ "tabs": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/TabInfo"
+ }
+ }
+ },
"definitions": {
"TabInfo": {
"description": "One open tab reported by `browser::tabs::list`.",
+ "type": "object",
+ "required": [
+ "adopted",
+ "url"
+ ],
"properties": {
"adopted": {
"description": "True when a session already adopted this tab; it cannot be adopted again until that session stops.",
@@ -34,26 +52,8 @@
"url": {
"type": "string"
}
- },
- "required": [
- "adopted",
- "url"
- ],
- "type": "object"
- }
- },
- "properties": {
- "tabs": {
- "items": {
- "$ref": "#/definitions/TabInfo"
- },
- "type": "array"
+ }
}
- },
- "required": [
- "tabs"
- ],
- "title": "TabsListOutput",
- "type": "object"
+ }
}
}
diff --git a/browser/tests/golden/schemas/browser.to-markdown.json b/browser/tests/golden/schemas/browser.to-markdown.json
new file mode 100644
index 000000000..0c2ceb2ed
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.to-markdown.json
@@ -0,0 +1,42 @@
+{
+ "function_id": "browser::to-markdown",
+ "description": "Convert HTML to compact Markdown (or text/html); optional CSS scope + main-content clean.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "format": {
+ "type": "string",
+ "enum": [
+ "markdown",
+ "text",
+ "html"
+ ]
+ },
+ "css_selector": {
+ "type": "string",
+ "description": "convert only the subtree matching this CSS selector"
+ },
+ "main_content_only": {
+ "type": "boolean",
+ "description": "strip nav/scripts/hidden nodes first"
+ }
+ },
+ "required": [
+ "html"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "format": {
+ "type": "string"
+ },
+ "content": {
+ "type": "string"
+ }
+ }
+ }
+}
diff --git a/browser/tests/golden/schemas/browser.xpath.json b/browser/tests/golden/schemas/browser.xpath.json
new file mode 100644
index 000000000..bbd9cb999
--- /dev/null
+++ b/browser/tests/golden/schemas/browser.xpath.json
@@ -0,0 +1,59 @@
+{
+ "function_id": "browser::xpath",
+ "description": "One XPath query over HTML; first-or-all; `attr` pulls an attribute else text.",
+ "request_schema": {
+ "type": "object",
+ "properties": {
+ "html": {
+ "type": "string"
+ },
+ "query": {
+ "type": "string"
+ },
+ "first": {
+ "type": "boolean"
+ },
+ "attr": {
+ "type": "string"
+ },
+ "identifier": {
+ "type": "string",
+ "description": "stable key for the saved element"
+ },
+ "adaptive": {
+ "type": "boolean",
+ "description": "relocate elements after a site change via saved identities"
+ },
+ "auto_save": {
+ "type": "boolean",
+ "description": "save matched identities (defaults on when adaptive)"
+ },
+ "adaptive_domain": {
+ "type": "string",
+ "description": "page URL/domain that keys saved identities"
+ }
+ },
+ "required": [
+ "html",
+ "query"
+ ]
+ },
+ "response_schema": {
+ "type": "object",
+ "properties": {
+ "result": {
+ "type": [
+ "array",
+ "string",
+ "null"
+ ],
+ "items": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ }
+ }
+ }
+}
diff --git a/browser/tests/integration.rs b/browser/tests/integration.rs
index b203dbb05..68945ffc5 100644
--- a/browser/tests/integration.rs
+++ b/browser/tests/integration.rs
@@ -2,6 +2,8 @@
//! `browser::*` surface via iii-sdk as a client. Self-skips when `iii` or a
//! Chromium executable is absent, so CI hosts without either stay green.
+use std::net::TcpListener;
+use std::path::PathBuf;
use std::process::{Child, Command, Stdio};
use std::time::Duration;
@@ -10,11 +12,11 @@ use iii_sdk::{register_worker, InitOptions};
use serde_json::json;
use tokio::time::{sleep, timeout};
-const ENGINE_WS: &str = "ws://127.0.0.1:49134";
-
struct Harness {
iii: Child,
worker: Child,
+ engine_ws: String,
+ config_path: PathBuf,
}
impl Drop for Harness {
@@ -23,6 +25,7 @@ impl Drop for Harness {
let _ = self.worker.wait();
let _ = self.iii.kill();
let _ = self.iii.wait();
+ let _ = std::fs::remove_file(&self.config_path);
}
}
@@ -46,8 +49,26 @@ async fn boot() -> Option<Harness> {
return None;
}
+ let port = TcpListener::bind("127.0.0.1:0")
+ .ok()?
+ .local_addr()
+ .ok()?
+ .port();
+ let engine_ws = format!("ws://127.0.0.1:{port}");
+ let config_path = std::env::temp_dir().join(format!(
+ "browser-integration-{}.yaml",
+ uuid::Uuid::new_v4().simple()
+ ));
+ std::fs::write(
+ &config_path,
+ format!(
+ "workers:\n - name: iii-worker-manager\n config:\n host: 127.0.0.1\n port: {port}\nmodules: []\n"
+ ),
+ )
+ .ok()?;
+
let mut iii = Command::new(&iii_bin)
- .arg("--use-default-config")
+ .args(["--config", config_path.to_str()?, "--no-update-check"])
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
@@ -57,7 +78,7 @@ async fn boot() -> Option<Harness> {
let worker = match Command::new(env!("CARGO_BIN_EXE_browser"))
.arg("--url")
- .arg(ENGINE_WS)
+ .arg(&engine_ws)
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
@@ -68,23 +89,29 @@ async fn boot() -> Option<Harness> {
// constructed), so clean up the already-started engine here.
let _ = iii.kill();
let _ = iii.wait();
+ let _ = std::fs::remove_file(config_path);
return None;
}
};
sleep(Duration::from_millis(1500)).await;
- Some(Harness { iii, worker })
+ Some(Harness {
+ iii,
+ worker,
+ engine_ws,
+ config_path,
+ })
}
#[tokio::test]
async fn session_lifecycle_console_and_snapshot() {
- let Some(_h) = boot().await else {
+ let Some(h) = boot().await else {
eprintln!("skipping: `iii` or Chromium not available");
return;
};
- let client = register_worker(ENGINE_WS, InitOptions::default());
+ let client = register_worker(&h.engine_ws, InitOptions::default());
sleep(Duration::from_millis(500)).await;
let call = |function_id: &str, payload: serde_json::Value, timeout_ms: u64| {
@@ -255,7 +282,6 @@ async fn session_lifecycle_console_and_snapshot() {
tabs.is_err(),
"tabs::list must be refused when allow_attach is false: {tabs:?}"
);
-
// stop is idempotent
let stopped = call(
"browser::sessions::stop",
diff --git a/browser/tests/scrapling_schemas.rs b/browser/tests/scrapling_schemas.rs
new file mode 100644
index 000000000..5924f6ab7
--- /dev/null
+++ b/browser/tests/scrapling_schemas.rs
@@ -0,0 +1,90 @@
+//! Wire-schema snapshots for the `browser::*` Scrapling surface: catalog()
+//! vs Python-generated goldens, byte-for-byte.
+//!
+//! These goldens are read-only (see `support::check_golden_readonly`) — they
+//! come from `scripts/gen_goldens.py` running real scrapling 0.4.9, so a pass
+//! means the Rust literals still mirror `scrapling/src/schemas.py`. The
+//! `browser::` id prefix is the one deliberate divergence; the generator
+//! applies it via `wire_id()`.
+
+mod support;
+
+use browser::scrapling::schemas::{catalog, FunctionSpec};
+
+fn spec_to_pretty_json(spec: &FunctionSpec) -> String {
+ let value = serde_json::json!({
+ "function_id": spec.function_id,
+ "description": spec.description,
+ "request_schema": spec.request,
+ "response_schema": spec.response,
+ });
+ let mut pretty = serde_json::to_string_pretty(&value).expect("serializes");
+ pretty.push('\n');
+ pretty
+}
+
+#[test]
+fn catalog_lists_all_scraping_functions_at_browser_root() {
+ let ids: Vec<&str> = catalog().iter().map(|s| s.function_id).collect();
+ assert_eq!(
+ ids,
+ vec![
+ "browser::fetch",
+ "browser::stealthy-fetch",
+ "browser::dynamic-fetch",
+ "browser::screenshot-url",
+ "browser::extract",
+ "browser::css",
+ "browser::xpath",
+ "browser::regex",
+ "browser::find-similar",
+ "browser::find",
+ "browser::find-by-text",
+ "browser::find-by-regex",
+ "browser::describe",
+ "browser::to-markdown",
+ "browser::session-open",
+ "browser::session-fetch",
+ "browser::session-close",
+ "browser::session-list",
+ "browser::crawl",
+ ]
+ );
+}
+
+#[test]
+fn wire_schemas_match_python_goldens_byte_for_byte() {
+ let mut failures = Vec::new();
+ for spec in catalog() {
+ let rel = format!("schemas/{}.json", spec.function_id.replace("::", "."));
+ if let Err(msg) = support::check_golden_readonly(&rel, &spec_to_pretty_json(&spec)) {
+ failures.push(msg);
+ }
+ }
+ assert!(failures.is_empty(), "{}", failures.join("\n\n"));
+}
+
+#[test]
+fn every_schema_is_typed() {
+ for spec in catalog() {
+ support::assert_typed_schema_value(&format!("{} request", spec.function_id), &spec.request);
+ support::assert_typed_schema_value(
+ &format!("{} response", spec.function_id),
+ &spec.response,
+ );
+ }
+}
+
+#[test]
+fn static_ids_are_catalog_plus_guidance_hook() {
+ let mut expected: Vec<&str> = catalog().iter().map(|s| s.function_id).collect();
+ expected.push("browser::inject-guidance");
+ assert_eq!(browser::scrapling::STATIC_IDS, expected.as_slice());
+}
+
+#[test]
+fn registered_wire_ids_do_not_use_the_old_nested_namespace() {
+ assert!(browser::scrapling::STATIC_IDS
+ .iter()
+ .all(|id| !id.starts_with("browser::scrapling::")));
+}
diff --git a/browser/tests/support/mod.rs b/browser/tests/support/mod.rs
index 440e3bf0e..8d42642b6 100644
--- a/browser/tests/support/mod.rs
+++ b/browser/tests/support/mod.rs
@@ -89,6 +89,41 @@ fn diff_hint(rel: &str, expected: &str, actual: &str) -> String {
out
}
+/// Compare against a golden that this repo does NOT write: everything under
+/// `tests/golden/schemas/browser.scrapling.*` and `tests/golden/behavior/` is
+/// produced only by `scripts/gen_goldens.py` running the reference Python
+/// implementation. There is deliberately no `UPDATE_GOLDENS` branch here — a
+/// pass has to mean "Rust agrees with Python", and a writable escape hatch
+/// would let a real divergence be papered over instead of root-caused.
+/// Regenerate with:
+/// ~/.iii/managed/scrapling/usr/local/bin/python3.12 scripts/gen_goldens.py
+pub fn check_golden_readonly(rel: &str, actual: &str) -> Result<(), String> {
+ let path = golden_root().join(rel);
+ let expected = fs::read_to_string(&path).map_err(|e| {
+ format!(
+ "golden {} unreadable ({e}); regenerate with \
+ ~/.iii/managed/scrapling/usr/local/bin/python3.12 scripts/gen_goldens.py",
+ path.display()
+ )
+ })?;
+ if expected == actual {
+ return Ok(());
+ }
+ Err(diff_hint(rel, &expected, actual))
+}
+
+/// `assert_typed_schema` for the scrapling catalog, whose schemas are raw
+/// Python-mirrored `Value` literals rather than schemars output.
+pub fn assert_typed_schema_value(label: &str, schema: &serde_json::Value) {
+ let obj = schema
+ .as_object()
+ .unwrap_or_else(|| panic!("{label}: not an object"));
+ assert!(
+ obj.contains_key("type") || obj.contains_key("properties") || obj.contains_key("$ref"),
+ "{label}: untyped (AnyValue) schema"
+ );
+}
+
/// Assert a schemars-derived request/response schema is a *real* schema and
/// not the permissive `AnyValue` schema a `Value` handler emits (the "unknown"
/// schema this whole convention exists to prevent). A real schema carries at
diff --git a/browser/tests/xmloxide_compat.rs b/browser/tests/xmloxide_compat.rs
new file mode 100644
index 000000000..5de3e692b
--- /dev/null
+++ b/browser/tests/xmloxide_compat.rs
@@ -0,0 +1,92 @@
+use xmloxide::html::{parse_html_with_options, HtmlParseOptions};
+use xmloxide::serial::html::serialize_html_subtree;
+use xmloxide::tree::NodeKind;
+
+fn parse(input: &str) -> xmloxide::Document {
+ parse_html_with_options(
+ input,
+ &HtmlParseOptions::default().recover(true).no_blanks(true),
+ )
+ .unwrap()
+}
+
+fn first(doc: &xmloxide::Document, name: &str) -> xmloxide::NodeId {
+ std::iter::once(doc.root())
+ .chain(doc.descendants(doc.root()))
+ .find(|id| doc.node_name(*id) == Some(name))
+ .unwrap()
+}
+
+#[test]
+fn html_recovery_and_subtree_serialization_match_the_oracle() {
+ let cases = [
+ (
+ "<table><td>A<td>B<div>C",
+ "table",
+ "<table><td>A</td><td>B<div>C</div></td></table>",
+ ),
+ (
+ "<p><b>one<i>two</b>three</i>tail",
+ "body",
+ "<body><p><b>one<i>two</i></b>threetail</p></body>",
+ ),
+ (
+ "<svg viewBox='0 0 1 1'><foreignObject><DIV xlink:href='x'>T</DIV></foreignObject></svg>",
+ "svg",
+ "<svg viewbox=\"0 0 1 1\"><foreignobject><div xlink:href=\"x\">T</div></foreignobject></svg>",
+ ),
+ (
+ "<template><table><td>T</template><p>P",
+ "template",
+ "<template><table><td>T<p>P</p></td></table></template>",
+ ),
+ ];
+ for (input, tag, expected) in cases {
+ let doc = parse(input);
+ assert_eq!(serialize_html_subtree(&doc, first(&doc, tag)), expected);
+ }
+}
+
+#[test]
+fn parser_preserves_attribute_order_and_first_duplicate() {
+ let doc = parse("<input z=1 disabled a='' z=2 checked=checked>");
+ let input = first(&doc, "input");
+ let attrs: Vec<_> = doc
+ .attributes(input)
+ .iter()
+ .map(|attr| (attr.name.as_str(), attr.value.as_str()))
+ .collect();
+ assert_eq!(
+ attrs,
+ [
+ ("z", "1"),
+ ("disabled", "disabled"),
+ ("a", ""),
+ ("checked", "checked")
+ ]
+ );
+ assert_eq!(
+ serialize_html_subtree(&doc, input),
+ "<input z=\"1\" disabled a=\"\" checked>"
+ );
+}
+
+#[test]
+fn parser_can_drop_comments_and_cdata_like_scrapling() {
+ let mut doc = parse("<p>a<!--gone-->b<![CDATA[c]]]]><![CDATA[>d</p>");
+ let removed: Vec<_> = doc
+ .descendants(doc.root())
+ .filter(|id| {
+ matches!(
+ doc.node(*id).kind,
+ NodeKind::Comment { .. } | NodeKind::CData { .. }
+ )
+ })
+ .collect();
+ for id in removed {
+ doc.remove_node(id);
+ }
+ let p = first(&doc, "p");
+ assert_eq!(doc.text_content(p), "abd");
+ assert_eq!(serialize_html_subtree(&doc, p), "<p>abd</p>");
+}
diff --git a/browser/ui/package.json b/browser/ui/package.json
index 2c18f7df1..a1330a2e5 100644
--- a/browser/ui/package.json
+++ b/browser/ui/package.json
@@ -5,6 +5,7 @@
"type": "module",
"scripts": {
"build": "tsc --noEmit && node build.mjs",
+ "test": "vitest run",
"watch": "node build.mjs --watch"
},
"dependencies": {
@@ -14,6 +15,8 @@
"devDependencies": {
"@types/react": "^19.2.14",
"esbuild": "^0.25.0",
- "typescript": "^5.9.2"
+ "react": "^19.2.6",
+ "typescript": "^5.9.2",
+ "vitest": "^4.1.6"
}
}
diff --git a/browser/ui/page.tsx b/browser/ui/page.tsx
index 69cc8c25c..6adde271c 100644
--- a/browser/ui/page.tsx
+++ b/browser/ui/page.tsx
@@ -21,6 +21,7 @@
import type { Host } from '@iii-dev/console-ui'
import { BrowserConfigForm } from './src/configuration'
import { createBrowserRenderer, createBrowserScreenshotRenderer } from './src/function-trigger-message'
+import { createScraplingRenderer } from './src/function-trigger-message/scrapling'
import { BrowserPage } from './src/page'
export default function setup(host: Host) {
@@ -36,5 +37,6 @@ export default function setup(host: Host) {
// renderer first; the general browser renderer still owns errors/running
// states and every other browser::* function.
host.functionTriggers.register(createBrowserScreenshotRenderer())
+ host.functionTriggers.register(createScraplingRenderer(host))
host.functionTriggers.register(createBrowserRenderer(host))
}
diff --git a/browser/ui/src/configuration/index.tsx b/browser/ui/src/configuration/index.tsx
index ea3684d16..f645417cc 100644
--- a/browser/ui/src/configuration/index.tsx
+++ b/browser/ui/src/configuration/index.tsx
@@ -9,7 +9,7 @@ import { type ReactNode, useEffect, useRef, useState } from 'react'
import { ChevronLeftIcon, GlobeIcon, useContainerNarrow } from '../lib/widgets'
type JsonObject = { [key: string]: JsonValue }
-type SectionId = 'launch' | 'viewport' | 'limits' | 'behavior'
+type SectionId = 'launch' | 'viewport' | 'limits' | 'behavior' | 'scraping'
const CONFIG_NARROW_BELOW = 660
const DEFAULTS = {
@@ -46,6 +46,7 @@ const FIELD_SECTION: Record<string, SectionId> = {
max_timeout_ms: 'behavior',
idle_stop_ms: 'behavior',
allowed_schemes: 'behavior',
+ scrapling: 'scraping',
}
function asObject(value: JsonValue | undefined): JsonObject {
@@ -333,6 +334,12 @@ function ConfigNav({
description: 'Timeouts and navigation',
summary: `${formatDuration(timeout)} · idle ${formatDuration(idle)}`,
},
+ {
+ id: 'scraping',
+ label: 'Scraping',
+ description: 'Fetch tiers and agent guidance',
+ summary: `guidance ${booleanValue(asObject(value.scrapling).inject_guidance, true) ? 'on' : 'off'}`,
+ },
]
return (
@@ -452,6 +459,10 @@ function ConfigEditor({
title: 'Runtime behavior',
description: 'Control timeouts, idle cleanup, and allowed destinations.',
},
+ scraping: {
+ title: 'Scraping',
+ description: 'Settings for the browser::* fetch and parse surface.',
+ },
}
return (
@@ -685,6 +696,24 @@ function ConfigEditor({
</section>
</>
) : null}
+
+ {selection === 'scraping' ? (
+ <section className="br-cfg-section">
+ <SectionHeader
+ title="Agent guidance"
+ description="Whether the worker teaches agents its scraping surface via the system prompt."
+ />
+ <CheckField
+ field="scrapling.inject_guidance"
+ label="Inject scraping guidance into agent system prompts"
+ hint="Hot-applies on save: turning this off unbinds the pre-generate hook immediately, no worker restart."
+ checked={booleanValue(asObject(value.scrapling).inject_guidance, true)}
+ onChange={(next) =>
+ onChange({ ...value, scrapling: { ...asObject(value.scrapling), inject_guidance: next } })
+ }
+ />
+ </section>
+ ) : null}
</div>
</section>
)
diff --git a/browser/ui/src/function-trigger-message/index.tsx b/browser/ui/src/function-trigger-message/index.tsx
index a458c528e..43859aeb6 100644
--- a/browser/ui/src/function-trigger-message/index.tsx
+++ b/browser/ui/src/function-trigger-message/index.tsx
@@ -45,7 +45,7 @@ const BROWSER_PAGE_HASH = '#/ext/browser'
* Header label for `browser::*` ids: dims the namespace prefix so the op
* (`navigate`, `act`, …) reads clearly.
*/
-function FunctionIdLabel({ functionId }: { functionId: string }) {
+export function FunctionIdLabel({ functionId }: { functionId: string }) {
if (!functionId.startsWith('browser::')) {
return <span style={{ color: 'var(--color-ink)' }}>{functionId}</span>
}
diff --git a/browser/ui/src/function-trigger-message/scrapling/CrawlView.tsx b/browser/ui/src/function-trigger-message/scrapling/CrawlView.tsx
new file mode 100644
index 000000000..84ad3d96d
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/CrawlView.tsx
@@ -0,0 +1,188 @@
+import { cn } from '../../lib/cn'
+import {
+ ActionLine,
+ Chip,
+ FilterChip,
+ MetaRow,
+ StatusPill,
+} from '../../lib/shared'
+import {
+ type CrawlItem,
+ type CrawlRequest,
+ crawlRequestSchema,
+ crawlResponseSchema,
+ safeParseRequest,
+ safeParseResponse,
+} from './parsers'
+
+const MAX_ITEM_ROWS = 20
+
+function startCount(req: CrawlRequest): number {
+ // ?? only guards null/undefined, so an empty start_urls array must fall
+ // through to the single `url` seed (the worker does the same).
+ if (req.start_urls && req.start_urls.length > 0) return req.start_urls.length
+ return req.url ? 1 : 0
+}
+
+function crawlChips(req: CrawlRequest) {
+ return (
+ <>
+ <Chip>{req.fetcher ?? 'http'}</Chip>
+ <FilterChip label="seeds" value={startCount(req)} />
+ {typeof req.max_pages === 'number' ? (
+ <FilterChip label="max" value={`${req.max_pages}p`} />
+ ) : null}
+ {typeof req.max_depth === 'number' ? (
+ <FilterChip label="depth" value={req.max_depth} />
+ ) : null}
+ {req.selectors?.length ? (
+ <FilterChip label="selectors" value={req.selectors.length} />
+ ) : null}
+ {req.allowed_domains?.length ? (
+ <FilterChip label="domains" value={req.allowed_domains.join(', ')} />
+ ) : req.same_domain === false ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>off-domain</span>
+ </Chip>
+ ) : null}
+ </>
+ )
+}
+
+export function CrawlView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const req = safeParseRequest(crawlRequestSchema, input)
+ if (!req) return null
+
+ if (running) {
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill label="crawling…" variant="default" />
+ {crawlChips(req)}
+ </MetaRow>
+ <div className="br-ui-scrape-running">
+ · walking the site…
+ </div>
+ </div>
+ )
+ }
+
+ const res = safeParseResponse(crawlResponseSchema, output)
+ if (!res) return null
+ const { stats } = res
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill
+ label={`${stats.items} items`}
+ variant={stats.items ? 'accent' : 'warn'}
+ />
+ <FilterChip label="crawled" value={stats.crawled} />
+ {stats.errors > 0 ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>{stats.errors} err</span>
+ </Chip>
+ ) : null}
+ {stats.stopped && stats.stopped !== 'done' ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>{stats.stopped}</span>
+ </Chip>
+ ) : null}
+ {crawlChips(req)}
+ </MetaRow>
+ {res.stream?.name ? (
+ <ActionLine symbol="≈" tone="accent">
+ <span className="br-ui-scrape-detail">
+ stream {res.stream.name}
+ {res.stream.group_id ? ` · ${res.stream.group_id}` : ''}
+ </span>
+ </ActionLine>
+ ) : null}
+ {res.items && res.items.length > 0 ? (
+ <div>
+ <div className="br-ui-scrape-label">
+ sample · {res.items.length}
+ </div>
+ {res.items.slice(0, MAX_ITEM_ROWS).map((item, i) => (
+ // biome-ignore lint/suspicious/noArrayIndexKey: static wire snapshot; rows never reorder and urls may repeat
+ <CrawlRow key={`${i}:${item.url ?? ''}`} item={item} />
+ ))}
+ </div>
+ ) : null}
+ </div>
+ )
+}
+
+function CrawlRow({ item }: { item: CrawlItem }) {
+ const summary = item.error
+ ? item.error
+ : item.extracted
+ ? Object.entries(item.extracted)
+ .map(([k, v]) => `${k}=${valuePreview(v)}`)
+ .join(' ')
+ : ''
+ return (
+ <div className="br-ui-scrape-result-row">
+ <span
+ className={cn(
+ 'br-ui-scrape-row-status',
+ item.error && 'is-warn',
+ )}
+ >
+ {item.error ? '✗' : (item.status ?? '·')}
+ </span>
+ <div className="br-ui-scrape-row-main">
+ <div className="br-ui-scrape-break">{item.url}</div>
+ {summary ? (
+ <div
+ className={cn(
+ 'br-ui-scrape-summary',
+ item.error && 'is-warn',
+ )}
+ >
+ {summary}
+ </div>
+ ) : null}
+ </div>
+ </div>
+ )
+}
+
+function valuePreview(v: unknown): string {
+ if (v == null) return '∅'
+ if (Array.isArray(v)) return `[${v.length}]`
+ return String(v).slice(0, 60)
+}
+
+export function CrawlPreview({ input }: { input: unknown }) {
+ const req = safeParseRequest(crawlRequestSchema, input)
+ if (!req) return null
+ const seeds =
+ req.start_urls && req.start_urls.length > 0
+ ? req.start_urls
+ : req.url
+ ? [req.url]
+ : []
+ return (
+ <div className="br-ui-scrape-section is-preview">
+ <MetaRow>
+ <StatusPill label="permission to crawl" variant="warn" />
+ {crawlChips(req)}
+ </MetaRow>
+ {seeds.slice(0, 5).map((u, i) => (
+ // biome-ignore lint/suspicious/noArrayIndexKey: static wire snapshot; seed list is fixed
+ <ActionLine key={`${i}:${u}`} symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{u}</span>
+ </ActionLine>
+ ))}
+ </div>
+ )
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/FetchView.tsx b/browser/ui/src/function-trigger-message/scrapling/FetchView.tsx
new file mode 100644
index 000000000..4260a4217
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/FetchView.tsx
@@ -0,0 +1,347 @@
+import { JsonHighlight } from '@iii-dev/console-ui'
+import { cn } from '../../lib/cn'
+import {
+ ActionLine,
+ Chip,
+ FilterChip,
+ MetaRow,
+ StatusPill,
+} from '../../lib/shared'
+import {
+ type FetchRequest,
+ fetchEngineLabel,
+ fetchRequestSchema,
+ fetchResponseSchema,
+ formatChars,
+ type PageResult,
+ safeParseRequest,
+ safeParseResponse,
+} from './parsers'
+
+const MAX_TARGET_LINES = 5
+const HTML_PREVIEW_CHARS = 1500
+
+interface FetchViewProps {
+ functionId: string
+ input: unknown
+ output: unknown
+ running?: boolean
+}
+
+/** Shared by `browser::fetch`, `::stealthy-fetch`, and `::dynamic-fetch` —
+ * same page/bulk response shape; only the request chips differ per engine. */
+export function FetchView({
+ functionId,
+ input,
+ output,
+ running,
+}: FetchViewProps) {
+ const req = safeParseRequest(fetchRequestSchema, input)
+ if (!req) return null
+
+ if (running) {
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill label="fetching…" variant="default" />
+ <OptionChips functionId={functionId} req={req} />
+ </MetaRow>
+ <TargetLines urls={targetUrls(req)} />
+ <div className="br-ui-scrape-running">
+ · waiting for page…
+ </div>
+ </div>
+ )
+ }
+
+ const result = safeParseResponse(fetchResponseSchema, output)
+ if (!result) return null
+
+ if ('results' in result) {
+ return (
+ <BulkPane functionId={functionId} req={req} results={result.results} />
+ )
+ }
+ return <SinglePane functionId={functionId} req={req} page={result} />
+}
+
+/** Compact read-only summary shown while the call sits in the approval gate. */
+export function FetchPreview({
+ functionId,
+ input,
+}: {
+ functionId: string
+ input: unknown
+}) {
+ const req = safeParseRequest(fetchRequestSchema, input)
+ if (!req) return null
+ const urls = targetUrls(req)
+ return (
+ <div className="br-ui-scrape-section is-preview">
+ <MetaRow>
+ <StatusPill
+ label={
+ urls.length > 1
+ ? `permission to fetch ${urls.length} urls`
+ : 'permission to fetch'
+ }
+ variant="warn"
+ />
+ <OptionChips functionId={functionId} req={req} />
+ </MetaRow>
+ <TargetLines urls={urls} />
+ </div>
+ )
+}
+
+function targetUrls(req: FetchRequest): string[] {
+ if (req.urls?.length) return req.urls
+ return req.url ? [req.url] : []
+}
+
+function OptionChips({
+ functionId,
+ req,
+}: {
+ functionId: string
+ req: FetchRequest
+}) {
+ const method =
+ functionId === 'browser::fetch'
+ ? (req.method ?? 'get').toUpperCase()
+ : null
+ return (
+ <>
+ <Chip>{fetchEngineLabel(functionId)}</Chip>
+ {method ? <Chip>{method}</Chip> : null}
+ {req.impersonate ? (
+ <FilterChip label="as" value={req.impersonate} />
+ ) : null}
+ {req.solve_cloudflare ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>cloudflare</span>
+ </Chip>
+ ) : null}
+ {req.headless === false ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>headed</span>
+ </Chip>
+ ) : null}
+ {req.real_chrome ? <Chip>real chrome</Chip> : null}
+ {req.cdp_url ? <Chip>cdp</Chip> : null}
+ {req.wait_selector ? (
+ <FilterChip label="wait" value={req.wait_selector} />
+ ) : null}
+ {req.network_idle ? <Chip>network idle</Chip> : null}
+ {/* proxy values can embed credentials — flag presence, never the value */}
+ {req.proxy ? <Chip>proxy</Chip> : null}
+ {req.selectors?.length ? (
+ <FilterChip label="selectors" value={req.selectors.length} />
+ ) : null}
+ {req.format ? <FilterChip label="as" value={req.format} /> : null}
+ {req.main_content_only ? <Chip>main only</Chip> : null}
+ {req.include_html ? <Chip>html</Chip> : null}
+ </>
+ )
+}
+
+function TargetLines({ urls }: { urls: string[] }) {
+ return (
+ <>
+ {urls.slice(0, MAX_TARGET_LINES).map((url, i) => (
+ // biome-ignore lint/suspicious/noArrayIndexKey: static wire snapshot; rows never reorder and urls may repeat
+ <ActionLine key={`${i}:${url}`} symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{url}</span>
+ </ActionLine>
+ ))}
+ {urls.length > MAX_TARGET_LINES ? (
+ <div className="br-ui-scrape-more">
+ +{urls.length - MAX_TARGET_LINES} more urls
+ </div>
+ ) : null}
+ </>
+ )
+}
+
+/* ---------------- single page ---------------- */
+
+function SinglePane({
+ functionId,
+ req,
+ page,
+}: {
+ functionId: string
+ req: FetchRequest
+ page: PageResult
+}) {
+ const status = page.status ?? null
+ const contentType = headerValue(page.headers, 'content-type')
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill
+ label={status != null ? String(status) : 'done'}
+ variant={statusToVariant(status)}
+ />
+ <OptionChips functionId={functionId} req={req} />
+ {contentType ? (
+ <FilterChip label="type" value={contentType.split(';')[0]} />
+ ) : null}
+ {page.captured_xhr?.length ? (
+ <FilterChip label="xhr" value={page.captured_xhr.length} />
+ ) : null}
+ </MetaRow>
+ <ActionLine symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{page.url || req.url || ''}</span>
+ </ActionLine>
+ {page.extracted ? <Extracted extracted={page.extracted} /> : null}
+ {page.content != null ? (
+ <RenderedContent format={page.format} content={page.content} />
+ ) : null}
+ {page.html != null ? <HtmlSnippet html={page.html} /> : null}
+ {!page.extracted && page.content == null && page.html == null ? (
+ <div className="br-ui-scrape-empty">
+ · page fetched — pass `selectors`, `format`, or `include_html` for
+ content
+ </div>
+ ) : null}
+ </div>
+ )
+}
+
+function headerValue(
+ headers: Record<string, unknown> | undefined,
+ name: string,
+): string | null {
+ if (!headers) return null
+ for (const [key, value] of Object.entries(headers)) {
+ if (key.toLowerCase() === name) return String(value)
+ }
+ return null
+}
+
+function statusToVariant(
+ status: number | null,
+): 'accent' | 'default' | 'warn' | 'alert' {
+ if (status == null) return 'default'
+ if (status >= 500) return 'alert'
+ if (status >= 400) return 'warn'
+ if (status >= 200 && status < 300) return 'accent'
+ return 'default'
+}
+
+function Extracted({ extracted }: { extracted: Record<string, unknown> }) {
+ return (
+ <div>
+ <div className="br-ui-scrape-label">
+ extracted · {Object.keys(extracted).length}
+ </div>
+ <JsonHighlight code={JSON.stringify(extracted, null, 2)} wrap />
+ </div>
+ )
+}
+
+function RenderedContent({
+ format,
+ content,
+}: {
+ format?: string
+ content: string
+}) {
+ const truncated = content.length > HTML_PREVIEW_CHARS
+ return (
+ <div>
+ <div className="br-ui-scrape-label">
+ {format ?? 'content'} · {formatChars(content.length)}
+ {truncated ? ' · truncated' : ''}
+ </div>
+ <pre className="br-ui-scrape-pre">
+ <code>
+ {content.slice(0, HTML_PREVIEW_CHARS)}
+ {truncated ? '…' : ''}
+ </code>
+ </pre>
+ </div>
+ )
+}
+
+function HtmlSnippet({ html }: { html: string }) {
+ const truncated = html.length > HTML_PREVIEW_CHARS
+ return (
+ <div>
+ <div className="br-ui-scrape-label">
+ html · {formatChars(html.length)}
+ {truncated ? ' · truncated preview' : ''}
+ </div>
+ <pre className="br-ui-scrape-pre is-muted">
+ <code>
+ {html.slice(0, HTML_PREVIEW_CHARS)}
+ {truncated ? '…' : ''}
+ </code>
+ </pre>
+ </div>
+ )
+}
+
+/* ---------------- bulk ---------------- */
+
+function BulkPane({
+ functionId,
+ req,
+ results,
+}: {
+ functionId: string
+ req: FetchRequest
+ results: PageResult[]
+}) {
+ const failed = results.filter((r) => r.error != null).length
+ const ok = results.length - failed
+ const extractedByUrl: Record<string, unknown> = {}
+ for (const r of results) {
+ if (r.extracted && r.url) extractedByUrl[r.url] = r.extracted
+ }
+ const extractedCount = Object.keys(extractedByUrl).length
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill
+ label={`${ok}/${results.length} ok`}
+ variant={failed ? 'warn' : 'accent'}
+ />
+ <OptionChips functionId={functionId} req={req} />
+ </MetaRow>
+ <div>
+ {results.map((r, i) => (
+ <div
+ // biome-ignore lint/suspicious/noArrayIndexKey: static wire snapshot; rows never reorder and urls may repeat
+ key={`${i}:${r.url ?? ''}`}
+ className="br-ui-scrape-result-row"
+ >
+ <span
+ className={cn(
+ 'br-ui-scrape-row-status',
+ r.error != null && 'is-warn',
+ )}
+ >
+ {r.error != null ? '✗' : (r.status ?? '·')}
+ </span>
+ <span className="br-ui-scrape-row-main br-ui-scrape-break">
+ {r.url ?? ''}
+ </span>
+ {r.error != null ? (
+ <span className="br-ui-scrape-row-error">{r.error}</span>
+ ) : null}
+ </div>
+ ))}
+ </div>
+ {extractedCount > 0 ? (
+ <div>
+ <div className="br-ui-scrape-label">
+ extracted · {extractedCount} page{extractedCount === 1 ? '' : 's'}
+ </div>
+ <JsonHighlight code={JSON.stringify(extractedByUrl, null, 2)} wrap />
+ </div>
+ ) : null}
+ </div>
+ )
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/MarkdownView.tsx b/browser/ui/src/function-trigger-message/scrapling/MarkdownView.tsx
new file mode 100644
index 000000000..f2385a38d
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/MarkdownView.tsx
@@ -0,0 +1,82 @@
+import { Chip, FilterChip, MetaRow, StatusPill } from '../../lib/shared'
+import {
+ formatChars,
+ markdownRequestSchema,
+ markdownResponseSchema,
+ safeParseRequest,
+ safeParseResponse,
+} from './parsers'
+
+const MAX_PREVIEW_CHARS = 4000
+
+export function MarkdownView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const req = safeParseRequest(markdownRequestSchema, input)
+ if (!req) return null
+ const chips = (
+ <>
+ <Chip>{req.format ?? 'markdown'}</Chip>
+ {req.css_selector ? (
+ <FilterChip label="scope" value={req.css_selector} />
+ ) : null}
+ {req.main_content_only ? <Chip>main only</Chip> : null}
+ {req.html != null ? (
+ <FilterChip label="html in" value={formatChars(req.html.length)} />
+ ) : null}
+ </>
+ )
+
+ if (running) {
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill label="converting…" variant="default" />
+ {chips}
+ </MetaRow>
+ <div className="br-ui-scrape-running">
+ · converting…
+ </div>
+ </div>
+ )
+ }
+
+ const res = safeParseResponse(markdownResponseSchema, output)
+ if (!res) return null
+ const truncated = res.content.length > MAX_PREVIEW_CHARS
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill label={res.format} variant="accent" />
+ <Chip>
+ <span className="br-ui-scrape-num">
+ {formatChars(res.content.length)}
+ </span>
+ </Chip>
+ {truncated ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>truncated</span>
+ </Chip>
+ ) : null}
+ </MetaRow>
+ {res.content.length === 0 ? (
+ <div className="br-ui-scrape-empty">
+ · empty
+ </div>
+ ) : (
+ <pre className="br-ui-scrape-pre">
+ <code>
+ {res.content.slice(0, MAX_PREVIEW_CHARS)}
+ {truncated ? '…' : ''}
+ </code>
+ </pre>
+ )}
+ </div>
+ )
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/ParseViews.tsx b/browser/ui/src/function-trigger-message/scrapling/ParseViews.tsx
new file mode 100644
index 000000000..986f94686
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/ParseViews.tsx
@@ -0,0 +1,309 @@
+import { JsonHighlight } from '@iii-dev/console-ui'
+import { Chip, FilterChip, MetaRow, StatusPill } from '../../lib/shared'
+import {
+ extractRequestSchema,
+ extractResponseSchema,
+ findSimilarRequestSchema,
+ findSimilarResponseSchema,
+ formatChars,
+ queryRequestSchema,
+ queryResponseSchema,
+ type SelectorSpec,
+ safeParseRequest,
+ safeParseResponse,
+} from './parsers'
+
+const MAX_RESULT_ROWS = 50
+const MAX_SIMILAR_ITEMS = 20
+
+/** Smart Element Tracking marker — the match survives site redesigns via saved
+ * element identities. */
+function AdaptiveChip({ domain }: { domain?: string }) {
+ return (
+ <Chip className="br-ui-scrape-adaptive">
+ <span>adaptive</span>
+ {domain ? (
+ <span className="br-ui-scrape-chip-value">{domain}</span>
+ ) : null}
+ </Chip>
+ )
+}
+
+function RunningNote({ label }: { label: string }) {
+ return (
+ <div className="br-ui-scrape-running">
+ · {label}
+ </div>
+ )
+}
+
+function SectionShell({ children }: { children: React.ReactNode }) {
+ return <div className="br-ui-scrape-section">{children}</div>
+}
+
+/* ---------------- browser::extract ---------------- */
+
+function selectorSummary(spec: SelectorSpec): string {
+ const query = spec.css
+ ? `css ${spec.css}`
+ : spec.xpath
+ ? `xpath ${spec.xpath}`
+ : spec.regex
+ ? `re ${spec.regex}`
+ : '—'
+ const mods = [
+ spec.attr ? `attr=${spec.attr}` : null,
+ spec.html ? 'html' : null,
+ spec.all ? 'all' : null,
+ ]
+ .filter(Boolean)
+ .join(' · ')
+ return mods ? `${query} · ${mods}` : query
+}
+
+function SelectorRows({ selectors }: { selectors: SelectorSpec[] }) {
+ return (
+ <div className="br-ui-scrape-selector-list">
+ {selectors.map((spec, i) => (
+ <div
+ // biome-ignore lint/suspicious/noArrayIndexKey: static wire snapshot; specs never reorder and names may repeat
+ key={`${i}:${spec.name}`}
+ className="br-ui-scrape-selector-row"
+ >
+ <span className="br-ui-scrape-selector-name">{spec.name}</span>
+ <span className="br-ui-scrape-selector-value">
+ ← {selectorSummary(spec)}
+ </span>
+ </div>
+ ))}
+ </div>
+ )
+}
+
+export function ExtractView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const req = safeParseRequest(extractRequestSchema, input)
+ if (!req) return null
+ const chips = (
+ <>
+ {req.selectors?.length ? (
+ <FilterChip label="selectors" value={req.selectors.length} />
+ ) : null}
+ {req.adaptive ? <AdaptiveChip domain={req.adaptive_domain} /> : null}
+ {req.html != null ? (
+ <FilterChip label="html" value={formatChars(req.html.length)} />
+ ) : null}
+ </>
+ )
+
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="extracting…" variant="default" />
+ {chips}
+ </MetaRow>
+ <RunningNote label="parsing…" />
+ </SectionShell>
+ )
+ }
+
+ const res = safeParseResponse(extractResponseSchema, output)
+ if (!res) return null
+ const fields = Object.keys(res.extracted).length
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill
+ label={`${fields} field${fields === 1 ? '' : 's'}`}
+ variant={fields ? 'accent' : 'warn'}
+ />
+ {chips}
+ </MetaRow>
+ {req.selectors?.length ? (
+ <SelectorRows selectors={req.selectors} />
+ ) : null}
+ <JsonHighlight code={JSON.stringify(res.extracted, null, 2)} wrap />
+ </SectionShell>
+ )
+}
+
+/* ---------------- browser::css / xpath / regex ---------------- */
+
+export function QueryView({
+ functionId,
+ input,
+ output,
+ running,
+}: {
+ functionId: string
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const req = safeParseRequest(queryRequestSchema, input)
+ if (!req) return null
+ const op = functionId.slice('browser::'.length)
+ const query = op === 'regex' ? req.pattern : req.query
+ if (query == null) return null
+ const chips = (
+ <>
+ <FilterChip label={op === 'regex' ? 'pattern' : op} value={query} />
+ {req.attr ? <FilterChip label="attr" value={req.attr} /> : null}
+ {req.first ? <Chip>first</Chip> : null}
+ {req.adaptive ? <AdaptiveChip domain={req.adaptive_domain} /> : null}
+ {req.html != null ? (
+ <FilterChip label="html" value={formatChars(req.html.length)} />
+ ) : null}
+ </>
+ )
+
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label={`${op}…`} variant="default" />
+ {chips}
+ </MetaRow>
+ <RunningNote label="querying…" />
+ </SectionShell>
+ )
+ }
+
+ const res = safeParseResponse(queryResponseSchema, output)
+ if (!res) return null
+ const matches =
+ res.result == null ? 0 : Array.isArray(res.result) ? res.result.length : 1
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill
+ label={
+ matches === 0
+ ? 'no match'
+ : `${matches} match${matches === 1 ? '' : 'es'}`
+ }
+ variant={matches ? 'accent' : 'warn'}
+ />
+ {chips}
+ </MetaRow>
+ <ResultRows result={res.result} />
+ </SectionShell>
+ )
+}
+
+function ResultRows({ result }: { result: string | (string | null)[] | null }) {
+ if (result == null || (Array.isArray(result) && result.length === 0)) {
+ return (
+ <div className="br-ui-scrape-empty">
+ · no match
+ </div>
+ )
+ }
+ const numbered = Array.isArray(result)
+ const rows = numbered ? result : [result]
+ return (
+ <div>
+ {rows.slice(0, MAX_RESULT_ROWS).map((row, i) => (
+ <div
+ // biome-ignore lint/suspicious/noArrayIndexKey: static wire snapshot; matches never reorder and often repeat
+ key={`${i}:${row ?? ''}`}
+ className="br-ui-scrape-result-row"
+ >
+ {numbered ? (
+ <span className="br-ui-scrape-result-number">
+ {i + 1}
+ </span>
+ ) : null}
+ {row == null ? (
+ <span className="br-ui-scrape-dim">∅</span>
+ ) : (
+ <span className="br-ui-scrape-row-main br-ui-scrape-prewrap">
+ {row}
+ </span>
+ )}
+ </div>
+ ))}
+ {rows.length > MAX_RESULT_ROWS ? (
+ <div className="br-ui-scrape-more">
+ +{rows.length - MAX_RESULT_ROWS} more
+ </div>
+ ) : null}
+ </div>
+ )
+}
+
+/* ---------------- browser::find-similar ---------------- */
+
+export function FindSimilarView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const req = safeParseRequest(findSimilarRequestSchema, input)
+ if (!req) return null
+ const chips = (
+ <>
+ {req.anchor ? <FilterChip label="anchor" value={req.anchor} /> : null}
+ {typeof req.similarity_threshold === 'number' ? (
+ <FilterChip label="threshold" value={req.similarity_threshold} />
+ ) : null}
+ {req.match_text ? <Chip>match text</Chip> : null}
+ {req.html != null ? (
+ <FilterChip label="html" value={formatChars(req.html.length)} />
+ ) : null}
+ </>
+ )
+
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="matching…" variant="default" />
+ {chips}
+ </MetaRow>
+ <RunningNote label="scanning structure…" />
+ </SectionShell>
+ )
+ }
+
+ const res = safeParseResponse(findSimilarResponseSchema, output)
+ if (!res) return null
+ const shown = res.items.slice(0, MAX_SIMILAR_ITEMS)
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill
+ label={`${res.count} similar`}
+ variant={res.count ? 'accent' : 'warn'}
+ />
+ {chips}
+ </MetaRow>
+ {res.count === 0 ? (
+ <div className="br-ui-scrape-empty">
+ · no similar elements
+ </div>
+ ) : (
+ <>
+ <JsonHighlight code={JSON.stringify(shown, null, 2)} wrap />
+ {res.items.length > MAX_SIMILAR_ITEMS ? (
+ <div className="br-ui-scrape-more is-separated">
+ +{res.items.length - MAX_SIMILAR_ITEMS} more items
+ </div>
+ ) : null}
+ </>
+ )}
+ </SectionShell>
+ )
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/ScreenshotView.tsx b/browser/ui/src/function-trigger-message/scrapling/ScreenshotView.tsx
new file mode 100644
index 000000000..aedcbc34b
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/ScreenshotView.tsx
@@ -0,0 +1,114 @@
+import {
+ ActionLine,
+ Chip,
+ MetaRow,
+ StatusPill,
+} from '../../lib/shared'
+import {
+ safeParseRequest,
+ safeParseResponse,
+ screenshotRequestSchema,
+ screenshotResponseSchema,
+} from './parsers'
+
+interface ScreenshotViewProps {
+ input: unknown
+ output: unknown
+ running?: boolean
+}
+
+export function ScreenshotView({
+ input,
+ output,
+ running,
+}: ScreenshotViewProps) {
+ const req = safeParseRequest(screenshotRequestSchema, input)
+ if (!req) return null
+
+ if (running) {
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill label="capturing…" variant="default" />
+ <Chip>{req.fetcher ?? 'dynamic'}</Chip>
+ {req.full_page ? <Chip>full page</Chip> : null}
+ {req.proxy ? <Chip>proxy</Chip> : null}
+ </MetaRow>
+ <ActionLine symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{req.url}</span>
+ </ActionLine>
+ <div className="br-ui-scrape-running">
+ · waiting for the browser…
+ </div>
+ </div>
+ )
+ }
+
+ const shot = safeParseResponse(screenshotResponseSchema, output)
+ if (!shot) return null
+
+ const images = shot.content.filter((b) => b.type === 'image' && b.data)
+ const caption = shot.content.find((b) => b.type === 'text')?.text
+ const mime = shot.mime || images[0]?.mime || 'image/png'
+ const url = shot.url || req.url
+ const sizeKb = Math.max(
+ 1,
+ Math.round(
+ (images.reduce((n, b) => n + (b.data?.length ?? 0), 0) * 3) / 4 / 1024,
+ ),
+ )
+ return (
+ <div className="br-ui-scrape-section">
+ <MetaRow>
+ <StatusPill label="screenshot" variant="accent" />
+ <Chip>{req.fetcher ?? 'dynamic'}</Chip>
+ <Chip>{mime.replace('image/', '')}</Chip>
+ {req.full_page ? <Chip>full page</Chip> : null}
+ {req.proxy ? <Chip>proxy</Chip> : null}
+ {images.length > 1 ? <Chip>{images.length} tiles</Chip> : null}
+ <Chip>
+ <span className="br-ui-scrape-num">{sizeKb}</span>
+ <span className="br-ui-scrape-unit">KB</span>
+ </Chip>
+ </MetaRow>
+ <ActionLine symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{url}</span>
+ </ActionLine>
+ <div className="br-ui-scrape-gallery">
+ {images.map((b, i) => (
+ <img
+ key={i}
+ src={`data:${b.mime || mime};base64,${b.data}`}
+ alt={caption || `screenshot of ${url || 'page'}`}
+ loading="lazy"
+ className="br-ui-scrape-image"
+ />
+ ))}
+ {caption ? (
+ <div className="br-ui-scrape-caption">
+ {caption}
+ </div>
+ ) : null}
+ </div>
+ </div>
+ )
+}
+
+export function ScreenshotPreview({ input }: { input: unknown }) {
+ const req = safeParseRequest(screenshotRequestSchema, input)
+ if (!req) return null
+ return (
+ <div className="br-ui-scrape-section is-preview">
+ <MetaRow>
+ <StatusPill label="permission to screenshot" variant="warn" />
+ <Chip>{req.fetcher ?? 'dynamic'}</Chip>
+ {req.format ? <Chip>{req.format}</Chip> : null}
+ {req.full_page ? <Chip>full page</Chip> : null}
+ {req.proxy ? <Chip>proxy</Chip> : null}
+ </MetaRow>
+ <ActionLine symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{req.url}</span>
+ </ActionLine>
+ </div>
+ )
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/SearchViews.tsx b/browser/ui/src/function-trigger-message/scrapling/SearchViews.tsx
new file mode 100644
index 000000000..60ddc604d
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/SearchViews.tsx
@@ -0,0 +1,246 @@
+import { JsonHighlight } from '@iii-dev/console-ui'
+import { Chip, FilterChip, MetaRow, StatusPill } from '../../lib/shared'
+import {
+ describeRequestSchema,
+ describeResponseSchema,
+ elementsResponseSchema,
+ findByRegexRequestSchema,
+ findByTextRequestSchema,
+ findRequestSchema,
+ formatChars,
+ type ScrapedElement,
+ safeParseRequest,
+ safeParseResponse,
+} from './parsers'
+
+const MAX_ROWS = 30
+
+function SectionShell({ children }: { children: React.ReactNode }) {
+ return <div className="br-ui-scrape-section">{children}</div>
+}
+
+function RunningNote({ label }: { label: string }) {
+ return (
+ <div className="br-ui-scrape-running">
+ · {label}
+ </div>
+ )
+}
+
+/* ---------------- find / find-by-text / find-by-regex ---------------- */
+
+function searchChips(functionId: string, input: unknown): React.ReactNode {
+ if (functionId === 'browser::find') {
+ const req = safeParseRequest(findRequestSchema, input)
+ if (!req) return null
+ const tag = Array.isArray(req.tag) ? req.tag.join(', ') : req.tag
+ return (
+ <>
+ {tag ? <FilterChip label="tag" value={tag} /> : null}
+ {req.attrs
+ ? Object.entries(req.attrs).map(([k, v]) => (
+ <FilterChip key={k} label={k} value={String(v)} />
+ ))
+ : null}
+ {req.text_regex ? (
+ <FilterChip label="text~" value={req.text_regex} />
+ ) : null}
+ {req.html != null ? (
+ <FilterChip label="html" value={formatChars(req.html.length)} />
+ ) : null}
+ </>
+ )
+ }
+ if (functionId === 'browser::find-by-text') {
+ const req = safeParseRequest(findByTextRequestSchema, input)
+ if (!req) return null
+ return (
+ <>
+ {req.text ? <FilterChip label="text" value={req.text} /> : null}
+ {req.partial ? <Chip>partial</Chip> : null}
+ {req.case_sensitive ? <Chip>case</Chip> : null}
+ </>
+ )
+ }
+ const req = safeParseRequest(findByRegexRequestSchema, input)
+ if (!req) return null
+ return (
+ <>
+ {req.pattern ? <FilterChip label="pattern" value={req.pattern} /> : null}
+ {req.case_sensitive ? <Chip>case</Chip> : null}
+ </>
+ )
+}
+
+export function ElementsView({
+ functionId,
+ input,
+ output,
+ running,
+}: {
+ functionId: string
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const chips = searchChips(functionId, input)
+ if (chips == null) return null
+
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="searching…" variant="default" />
+ {chips}
+ </MetaRow>
+ <RunningNote label="scanning DOM…" />
+ </SectionShell>
+ )
+ }
+
+ const res = safeParseResponse(elementsResponseSchema, output)
+ if (!res) return null
+ const shown = res.items.slice(0, MAX_ROWS)
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill
+ label={
+ res.count === 0
+ ? 'no match'
+ : `${res.count} element${res.count === 1 ? '' : 's'}`
+ }
+ variant={res.count ? 'accent' : 'warn'}
+ />
+ {chips}
+ </MetaRow>
+ {res.count === 0 ? (
+ <div className="br-ui-scrape-empty">
+ · no elements matched
+ </div>
+ ) : (
+ <>
+ {shown.map((el, i) => (
+ // biome-ignore lint/suspicious/noArrayIndexKey: static wire snapshot; rows never reorder and selectors may repeat
+ <ElementRow key={`${i}:${el.css ?? ''}`} el={el} />
+ ))}
+ {res.items.length > MAX_ROWS ? (
+ <div className="br-ui-scrape-more">
+ +{res.items.length - MAX_ROWS} more
+ </div>
+ ) : null}
+ </>
+ )}
+ </SectionShell>
+ )
+}
+
+function ElementRow({ el }: { el: ScrapedElement }) {
+ return (
+ <div className="br-ui-scrape-element-row">
+ <div className="br-ui-scrape-element-main">
+ {el.tag ? (
+ <span className="br-ui-scrape-element-tag">{el.tag}</span>
+ ) : null}
+ <span className="br-ui-scrape-row-main">{el.text || '—'}</span>
+ </div>
+ {el.css ? (
+ <div className="br-ui-scrape-selector-value">
+ {el.css}
+ </div>
+ ) : null}
+ </div>
+ )
+}
+
+/* ---------------- describe ---------------- */
+
+export function DescribeView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const req = safeParseRequest(describeRequestSchema, input)
+ if (!req) return null
+ const chips = (
+ <FilterChip label={req.kind ?? 'css'} value={req.query ?? ''} />
+ )
+
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="describing…" variant="default" />
+ {chips}
+ </MetaRow>
+ <RunningNote label="locating element…" />
+ </SectionShell>
+ )
+ }
+
+ const res = safeParseResponse(describeResponseSchema, output)
+ if (!res) return null
+ if (!res.found || !res.element) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="no match" variant="warn" />
+ {chips}
+ </MetaRow>
+ <div className="br-ui-scrape-empty">
+ · element not found
+ </div>
+ </SectionShell>
+ )
+ }
+
+ const el = res.element
+ const rows: Array<[string, string]> = [
+ ['tag', el.tag ?? ''],
+ ['css', el.css ?? ''],
+ ['full css', el.full_css ?? ''],
+ ['xpath', el.xpath ?? ''],
+ ['full xpath', el.full_xpath ?? ''],
+ ['classes', (el.classes ?? []).join(' ') || '—'],
+ ['parent', el.parent_tag ?? '—'],
+ ['children', String(el.children ?? 0)],
+ ['siblings', String(el.siblings ?? 0)],
+ ]
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label={el.tag ?? 'element'} variant="accent" />
+ {chips}
+ </MetaRow>
+ {el.text ? (
+ <div className="br-ui-scrape-description">
+ {el.text}
+ </div>
+ ) : null}
+ <div className="br-ui-scrape-table-wrap">
+ <table className="br-ui-scrape-table">
+ <tbody>
+ {rows.map(([k, v]) => (
+ <tr key={k}>
+ <td className="br-ui-scrape-table-key">{k}</td>
+ <td className="br-ui-scrape-table-value">{v}</td>
+ </tr>
+ ))}
+ </tbody>
+ </table>
+ </div>
+ {el.attrs && Object.keys(el.attrs).length > 0 ? (
+ <div>
+ <div className="br-ui-scrape-label is-separated">
+ attributes · {Object.keys(el.attrs).length}
+ </div>
+ <JsonHighlight code={JSON.stringify(el.attrs, null, 2)} wrap />
+ </div>
+ ) : null}
+ </SectionShell>
+ )
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/SessionViews.tsx b/browser/ui/src/function-trigger-message/scrapling/SessionViews.tsx
new file mode 100644
index 000000000..44fa74d84
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/SessionViews.tsx
@@ -0,0 +1,354 @@
+import { JsonHighlight } from '@iii-dev/console-ui'
+import {
+ ActionLine,
+ Chip,
+ FilterChip,
+ MetaRow,
+ StatusPill,
+} from '../../lib/shared'
+import {
+ pageResultSchema,
+ type SessionSummary,
+ safeParseRequest,
+ safeParseResponse,
+ sessionCloseRequestSchema,
+ sessionCloseResponseSchema,
+ sessionFetchRequestSchema,
+ sessionListRequestSchema,
+ sessionListResponseSchema,
+ sessionOpenRequestSchema,
+ sessionOpenResponseSchema,
+} from './parsers'
+
+function shortId(id: string): string {
+ return id.length > 10 ? `${id.slice(0, 10)}…` : id
+}
+
+function SectionShell({ children }: { children: React.ReactNode }) {
+ return <div className="br-ui-scrape-section">{children}</div>
+}
+
+/* ---------------- session-open ---------------- */
+
+function openChips(input: unknown): React.ReactNode {
+ const req = safeParseRequest(sessionOpenRequestSchema, input)
+ if (!req) return null
+ return (
+ <>
+ <Chip>{req.type ?? 'http'}</Chip>
+ {req.impersonate ? (
+ <FilterChip label="as" value={req.impersonate} />
+ ) : null}
+ {req.solve_cloudflare ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>cloudflare</span>
+ </Chip>
+ ) : null}
+ {req.real_chrome ? <Chip>real chrome</Chip> : null}
+ {req.headless === false ? (
+ <Chip className="br-ui-scrape-warning">
+ <span>headed</span>
+ </Chip>
+ ) : null}
+ {req.proxy ? <Chip>proxy</Chip> : null}
+ </>
+ )
+}
+
+export function SessionOpenView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const chips = openChips(input)
+ if (chips == null) return null
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="opening…" variant="default" />
+ {chips}
+ </MetaRow>
+ <div className="br-ui-scrape-running">
+ · starting session…
+ </div>
+ </SectionShell>
+ )
+ }
+ const res = safeParseResponse(sessionOpenResponseSchema, output)
+ if (!res) return null
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="session open" variant="accent" />
+ {chips}
+ </MetaRow>
+ <ActionLine symbol="#" tone="accent">
+ <span className="br-ui-scrape-break">{res.session_id}</span>
+ </ActionLine>
+ </SectionShell>
+ )
+}
+
+export function SessionOpenPreview({ input }: { input: unknown }) {
+ const req = safeParseRequest(sessionOpenRequestSchema, input)
+ if (!req) return null
+ return (
+ <div className="br-ui-scrape-section is-preview">
+ <MetaRow>
+ <StatusPill label="permission to open a session" variant="warn" />
+ {openChips(input)}
+ </MetaRow>
+ </div>
+ )
+}
+
+/* ---------------- session-fetch ---------------- */
+
+function fetchHeader(input: unknown): {
+ sessionId?: string
+ url?: string
+ node: React.ReactNode
+} | null {
+ const req = safeParseRequest(sessionFetchRequestSchema, input)
+ if (!req) return null
+ return {
+ sessionId: req?.session_id,
+ url: req?.url,
+ node: (
+ <>
+ {req?.session_id ? (
+ <FilterChip label="session" value={shortId(req.session_id)} />
+ ) : null}
+ {req?.method ? <Chip>{req.method.toUpperCase()}</Chip> : null}
+ {req?.selectors?.length ? (
+ <FilterChip label="selectors" value={req.selectors.length} />
+ ) : null}
+ {req?.format ? <FilterChip label="as" value={req.format} /> : null}
+ </>
+ ),
+ }
+}
+
+export function SessionFetchView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const header = fetchHeader(input)
+ if (!header) return null
+ const { url, node } = header
+
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="fetching…" variant="default" />
+ {node}
+ </MetaRow>
+ {url ? (
+ <ActionLine symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{url}</span>
+ </ActionLine>
+ ) : null}
+ <div className="br-ui-scrape-running">
+ · waiting for page…
+ </div>
+ </SectionShell>
+ )
+ }
+
+ const page = safeParseResponse(pageResultSchema, output)
+ if (!page) return null
+ const status = page.status ?? null
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill
+ label={status != null ? String(status) : 'done'}
+ variant={
+ status != null && status >= 200 && status < 300
+ ? 'accent'
+ : 'default'
+ }
+ />
+ {node}
+ </MetaRow>
+ <ActionLine symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{page.url || url || ''}</span>
+ </ActionLine>
+ {page.extracted ? (
+ <div>
+ <div className="br-ui-scrape-label">
+ extracted · {Object.keys(page.extracted).length}
+ </div>
+ <JsonHighlight code={JSON.stringify(page.extracted, null, 2)} wrap />
+ </div>
+ ) : null}
+ {page.content != null ? (
+ <pre className="br-ui-scrape-pre is-separated">
+ <code>{page.content.slice(0, 2000)}</code>
+ </pre>
+ ) : null}
+ </SectionShell>
+ )
+}
+
+export function SessionFetchPreview({ input }: { input: unknown }) {
+ const header = fetchHeader(input)
+ if (!header) return null
+ const { url, node } = header
+ return (
+ <div className="br-ui-scrape-section is-preview">
+ <MetaRow>
+ <StatusPill label="permission to fetch" variant="warn" />
+ {node}
+ </MetaRow>
+ {url ? (
+ <ActionLine symbol="→" tone="ink">
+ <span className="br-ui-scrape-break">{url}</span>
+ </ActionLine>
+ ) : null}
+ </div>
+ )
+}
+
+/* ---------------- session-close ---------------- */
+
+function closeChip(input: unknown): React.ReactNode | null {
+ const req = safeParseRequest(sessionCloseRequestSchema, input)
+ if (!req) return null
+ return <FilterChip label="session" value={shortId(req.session_id)} />
+}
+
+export function SessionCloseView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ const chip = closeChip(input)
+ if (!chip) return null
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="closing…" variant="default" />
+ {chip}
+ </MetaRow>
+ <div className="br-ui-scrape-running">· closing session…</div>
+ </SectionShell>
+ )
+ }
+ const res = safeParseResponse(sessionCloseResponseSchema, output)
+ if (!res) return null
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill
+ label={res.closed ? 'closed' : 'not found'}
+ variant={res.closed ? 'accent' : 'warn'}
+ />
+ {chip}
+ </MetaRow>
+ </SectionShell>
+ )
+}
+
+export function SessionClosePreview({ input }: { input: unknown }) {
+ const chip = closeChip(input)
+ if (!chip) return null
+ return (
+ <div className="br-ui-scrape-section is-preview">
+ <MetaRow>
+ <StatusPill label="permission to close a session" variant="warn" />
+ {chip}
+ </MetaRow>
+ </div>
+ )
+}
+
+/* ---------------- session-list ---------------- */
+
+export function SessionListView({
+ input,
+ output,
+ running,
+}: {
+ input: unknown
+ output: unknown
+ running?: boolean
+}) {
+ if (!safeParseRequest(sessionListRequestSchema, input)) return null
+ if (running) {
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill label="listing…" variant="default" />
+ </MetaRow>
+ <div className="br-ui-scrape-running">· listing sessions…</div>
+ </SectionShell>
+ )
+ }
+ const res = safeParseResponse(sessionListResponseSchema, output)
+ if (!res) return null
+ return (
+ <SectionShell>
+ <MetaRow>
+ <StatusPill
+ label={`${res.sessions.length} open`}
+ variant={res.sessions.length ? 'accent' : 'default'}
+ />
+ </MetaRow>
+ {res.sessions.length === 0 ? (
+ <div className="br-ui-scrape-empty">
+ · no open sessions
+ </div>
+ ) : (
+ <div className="br-ui-scrape-table-wrap">
+ <table className="br-ui-scrape-table">
+ <tbody>
+ {res.sessions.map((s) => (
+ <SessionRow key={s.session_id} s={s} />
+ ))}
+ </tbody>
+ </table>
+ </div>
+ )}
+ </SectionShell>
+ )
+}
+
+export function SessionListPreview({ input }: { input: unknown }) {
+ if (!safeParseRequest(sessionListRequestSchema, input)) return null
+ return (
+ <div className="br-ui-scrape-section is-preview">
+ <MetaRow>
+ <StatusPill label="permission to list sessions" variant="warn" />
+ </MetaRow>
+ </div>
+ )
+}
+
+function SessionRow({ s }: { s: SessionSummary }) {
+ return (
+ <tr>
+ <td className="br-ui-scrape-table-type">{s.type ?? 'http'}</td>
+ <td className="br-ui-scrape-table-value">{s.session_id}</td>
+ <td className="br-ui-scrape-table-meta">
+ {typeof s.idle_s === 'number' ? `idle ${s.idle_s}s` : ''}
+ </td>
+ </tr>
+ )
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/index.test.tsx b/browser/ui/src/function-trigger-message/scrapling/index.test.tsx
new file mode 100644
index 000000000..b14e939ee
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/index.test.tsx
@@ -0,0 +1,348 @@
+import type {
+ FunctionTriggerMessage,
+ FunctionTriggerRenderer,
+ Host,
+} from '@iii-dev/console-ui'
+import { describe, expect, it, vi } from 'vitest'
+import setup from '../../../page'
+import { createScraplingRenderer } from './index'
+
+vi.mock('@iii-dev/console-ui', () => ({
+ Badge: () => null,
+ Button: () => null,
+ Input: () => null,
+ JsonHighlight: () => null,
+ StatusDot: () => null,
+}))
+
+const host = {} as Host
+
+describe('scraping renderer', () => {
+ it('owns URL screenshot but not interactive session screenshot', () => {
+ const renderer = createScraplingRenderer(host)
+ expect(renderer.isMatch('browser::screenshot-url')).toBe(true)
+ expect(renderer.isMatch('browser::screenshot')).toBe(false)
+ })
+
+ it('renders approval previews and parse results', () => {
+ const renderer = createScraplingRenderer(host)
+ const preview = {
+ functionId: 'browser::fetch',
+ input: { url: 'https://example.com' },
+ pendingApproval: true,
+ } as FunctionTriggerMessage
+ const result = {
+ functionId: 'browser::css',
+ input: { html: '<p>x</p>', query: 'p' },
+ output: { result: ['x'] },
+ } as FunctionTriggerMessage
+ expect(renderer.tryRenderPreview?.(preview)).not.toBeNull()
+ expect(renderer.tryRender(result)).not.toBeNull()
+ })
+
+ it('redacts proxy-bearing values throughout raw payloads', () => {
+ const renderer = createScraplingRenderer(host)
+ const input = {
+ proxy: 'http://user:pass@example.com',
+ nested: [
+ { proxies: { https: 'http://token@example.com' } },
+ { proxy_auth: { username: 'user', password: 'pass' } },
+ { proxying: 'unchanged' },
+ ],
+ }
+ expect(renderer.redactRaw?.(input)).toEqual({
+ proxy: '[redacted]',
+ nested: [
+ { proxies: '[redacted]' },
+ { proxy_auth: '[redacted]' },
+ { proxying: 'unchanged' },
+ ],
+ })
+ expect(input.proxy).toBe('http://user:pass@example.com')
+ })
+
+ it('marks circular raw payloads without mutating them', () => {
+ const renderer = createScraplingRenderer(host)
+ const input: Record<string, unknown> = { proxy: 'secret' }
+ input.self = input
+ expect(renderer.redactRaw?.(input)).toEqual({
+ proxy: '[redacted]',
+ self: '[circular]',
+ })
+ expect(input.self).toBe(input)
+ })
+
+ it('redacts proxy URL userinfo embedded in raw strings', () => {
+ const renderer = createScraplingRenderer(host)
+ const error =
+ 'proxy is not usable: http://user:pass@proxy.example: invalid endpoint'
+ const redacted =
+ 'proxy is not usable: http://[redacted]@proxy.example: invalid endpoint'
+ expect(renderer.redactRaw?.(error)).toBe(redacted)
+ expect(renderer.redactRaw?.({ nested: { error } })).toEqual({
+ nested: { error: redacted },
+ })
+ expect(renderer.redactRaw?.('request failed for https://example.com/a')).toBe(
+ 'request failed for https://example.com/a',
+ )
+ })
+
+ it('redacts proxy credentials in rich error cards', () => {
+ const renderer = createScraplingRenderer(host)
+ const rendered = renderer.tryRender({
+ functionId: 'browser::fetch',
+ input: { url: 'https://example.com' },
+ output: {
+ error: {
+ kind: 'function_error',
+ message:
+ 'proxy failed: http://user:pass@proxy.example is unavailable',
+ },
+ },
+ } as FunctionTriggerMessage)
+ const serialized = JSON.stringify(rendered)
+ expect(serialized).toContain('[redacted]')
+ expect(serialized).not.toContain('user:pass')
+ })
+
+ it('falls back from empty urls to the single fetch url', () => {
+ const renderer = createScraplingRenderer(host)
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::fetch',
+ input: { url: 'https://example.com', urls: [] },
+ output: { status: 200, url: 'https://example.com' },
+ } as FunctionTriggerMessage),
+ ).not.toBeNull()
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::fetch',
+ input: { urls: [] },
+ output: { status: 200, url: 'https://example.com' },
+ } as FunctionTriggerMessage),
+ ).toBeNull()
+ })
+
+ it('renders approval and running states for close and list sessions', () => {
+ const renderer = createScraplingRenderer(host)
+ const sessionId = '1234567890abcdef'
+ for (const [functionId, input] of [
+ ['browser::session-close', { session_id: sessionId }],
+ ['browser::session-list', {}],
+ ] as const) {
+ const preview = renderer.tryRenderPreview?.({
+ functionId,
+ input,
+ pendingApproval: true,
+ } as FunctionTriggerMessage)
+ const running = renderer.tryRenderRunning?.({
+ functionId,
+ input,
+ running: true,
+ } as FunctionTriggerMessage)
+ expect(preview).not.toBeNull()
+ expect(running).not.toBeNull()
+ if (functionId === 'browser::session-close') {
+ for (const rendered of [preview, running]) {
+ const serialized = JSON.stringify(rendered)
+ expect(serialized).toContain('1234567890…')
+ expect(serialized).not.toContain(sessionId)
+ }
+ }
+ }
+ })
+
+ it('validates terminal close and list session requests', () => {
+ const renderer = createScraplingRenderer(host)
+ for (const [functionId, input, output] of [
+ ['browser::session-close', { session_id: 'session-1' }, { closed: true }],
+ ['browser::session-list', { type: 'http' }, { sessions: [] }],
+ ] as const) {
+ expect(
+ renderer.tryRender({
+ functionId,
+ input,
+ output,
+ } as FunctionTriggerMessage),
+ ).not.toBeNull()
+ }
+
+ for (const [functionId, input, output] of [
+ ['browser::session-close', {}, { closed: true }],
+ ['browser::session-list', { type: 42 }, { sessions: [] }],
+ ] as const) {
+ expect(
+ renderer.tryRender({
+ functionId,
+ input,
+ output,
+ } as unknown as FunctionTriggerMessage),
+ ).toBeNull()
+ }
+ })
+
+ it.each([
+ ['browser::extract', { html: '<p>x</p>' }, { extracted: {} }],
+ [
+ 'browser::find-similar',
+ { html: '<p>x</p>' },
+ { count: 0, items: [] },
+ ],
+ ['browser::find', {}, { count: 0, items: [] }],
+ [
+ 'browser::find-by-text',
+ { html: '<p>x</p>' },
+ { count: 0, items: [] },
+ ],
+ [
+ 'browser::find-by-regex',
+ { html: '<p>x</p>' },
+ { count: 0, items: [] },
+ ],
+ ['browser::describe', { html: '<p>x</p>' }, { found: false }],
+ ['browser::to-markdown', {}, { format: 'markdown', content: '' }],
+ [
+ 'browser::session-fetch',
+ { session_id: 'session-1' },
+ { status: 200, url: 'https://example.com' },
+ ],
+ [
+ 'browser::crawl',
+ {},
+ { stats: { crawled: 0, items: 0, errors: 0 } },
+ ],
+ ])('falls through %s requests missing required fields or targets', (functionId, input, output) => {
+ const renderer = createScraplingRenderer(host)
+ expect(
+ renderer.tryRender({
+ functionId,
+ input,
+ output,
+ } as FunctionTriggerMessage),
+ ).toBeNull()
+ })
+
+ it('falls through empty fetch payloads', () => {
+ const renderer = createScraplingRenderer(host)
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::fetch',
+ input: {},
+ output: {},
+ } as FunctionTriggerMessage),
+ ).toBeNull()
+ })
+
+ it('falls through CSS requests missing required input', () => {
+ const renderer = createScraplingRenderer(host)
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::css',
+ input: { html: '<p>x</p>' },
+ output: { result: ['x'] },
+ } as FunctionTriggerMessage),
+ ).toBeNull()
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::css',
+ input: { query: 'p' },
+ output: { result: ['x'] },
+ } as FunctionTriggerMessage),
+ ).toBeNull()
+ })
+
+ it('falls through screenshots with an invalid request', () => {
+ const renderer = createScraplingRenderer(host)
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::screenshot-url',
+ input: { url: 42 },
+ output: {
+ content: [{ type: 'image', mime: 'image/png', data: 'aGk=' }],
+ url: 'https://example.com',
+ },
+ } as unknown as FunctionTriggerMessage),
+ ).toBeNull()
+ })
+
+ it('shows only proxy presence in screenshot states', () => {
+ const renderer = createScraplingRenderer(host)
+ const input = {
+ url: 'https://example.com',
+ proxy: 'http://user:pass@proxy.example',
+ }
+ const states = [
+ renderer.tryRenderPreview?.({
+ functionId: 'browser::screenshot-url',
+ input,
+ pendingApproval: true,
+ } as FunctionTriggerMessage),
+ renderer.tryRenderRunning?.({
+ functionId: 'browser::screenshot-url',
+ input,
+ running: true,
+ } as FunctionTriggerMessage),
+ renderer.tryRender({
+ functionId: 'browser::screenshot-url',
+ input,
+ output: {
+ content: [{ type: 'image', mime: 'image/png', data: 'aGk=' }],
+ url: 'https://example.com',
+ },
+ } as FunctionTriggerMessage),
+ ]
+ for (const state of states) {
+ const serialized = JSON.stringify(state)
+ expect(serialized).toContain('"proxy"')
+ expect(serialized).not.toContain('user:pass')
+ expect(serialized).not.toContain('proxy.example')
+ }
+ })
+
+ it('falls through screenshot successes without image data', () => {
+ const renderer = createScraplingRenderer(host)
+ for (const content of [
+ [],
+ [{ type: 'text', text: 'Screenshot captured' }],
+ [{ type: 'image', mime: 'image/png', data: '' }],
+ ]) {
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::screenshot-url',
+ input: { url: 'https://example.com' },
+ output: { content, url: 'https://example.com' },
+ } as FunctionTriggerMessage),
+ ).toBeNull()
+ }
+ })
+
+ it('falls through malformed result payloads', () => {
+ const renderer = createScraplingRenderer(host)
+ expect(
+ renderer.tryRender({
+ functionId: 'browser::css',
+ input: { html: '<p>x</p>', query: 'p' },
+ output: { result: 42 },
+ } as unknown as FunctionTriggerMessage),
+ ).toBeNull()
+ })
+
+ it('registers the exact scraping renderer before the broad browser renderer', () => {
+ const renderers: FunctionTriggerRenderer[] = []
+ setup({
+ pages: { register: () => () => {} },
+ configForms: { register: () => () => {} },
+ functionTriggers: {
+ register: (renderer: FunctionTriggerRenderer) => {
+ renderers.push(renderer)
+ return () => {}
+ },
+ },
+ } as unknown as Host)
+ expect(renderers.map((renderer) => renderer.id)).toEqual([
+ 'browser/page.js#screenshot-display',
+ 'browser/page.js#scraping-calls',
+ 'browser/page.js#calls',
+ ])
+ })
+})
diff --git a/browser/ui/src/function-trigger-message/scrapling/index.tsx b/browser/ui/src/function-trigger-message/scrapling/index.tsx
new file mode 100644
index 000000000..0848ac992
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/index.tsx
@@ -0,0 +1,166 @@
+import type {
+ FunctionTriggerMessage,
+ FunctionTriggerRenderer,
+ Host,
+} from '@iii-dev/console-ui'
+import { InfraErrorView, parseInfraErrorDisplay } from '../../lib/errors'
+import { FunctionIdLabel } from '..'
+import { CrawlPreview, CrawlView } from './CrawlView'
+import { FetchPreview, FetchView } from './FetchView'
+import { MarkdownView } from './MarkdownView'
+import { ExtractView, FindSimilarView, QueryView } from './ParseViews'
+import {
+ ELEMENT_SEARCH_FUNCTION_IDS,
+ FETCH_FUNCTION_IDS,
+ isScraplingFunction,
+ SESSION_GATED_FUNCTION_IDS,
+ unwrapEnvelope,
+} from './parsers'
+import { ScreenshotPreview, ScreenshotView } from './ScreenshotView'
+import { DescribeView, ElementsView } from './SearchViews'
+import {
+ SessionClosePreview,
+ SessionCloseView,
+ SessionFetchPreview,
+ SessionFetchView,
+ SessionListPreview,
+ SessionListView,
+ SessionOpenPreview,
+ SessionOpenView,
+} from './SessionViews'
+
+const PROXY_KEYS = new Set(['proxy', 'proxies', 'proxy_auth'])
+const PROXY_URL_USERINFO = /(https?:\/\/)[^\s/?#]*@/gi
+
+function redactProxyValues(
+ value: unknown,
+ seen: WeakSet<object> = new WeakSet(),
+): unknown {
+ if (typeof value === 'string') {
+ return value.replace(PROXY_URL_USERINFO, '$1[redacted]@')
+ }
+ if (value === null || typeof value !== 'object') return value
+ if (seen.has(value)) return '[circular]'
+ seen.add(value)
+ try {
+ if (Array.isArray(value)) {
+ return value.map((entry) => redactProxyValues(entry, seen))
+ }
+ return Object.fromEntries(
+ Object.entries(value as Record<string, unknown>).map(([key, entry]) => [
+ key,
+ PROXY_KEYS.has(key) ? '[redacted]' : redactProxyValues(entry, seen),
+ ]),
+ )
+ } catch {
+ return '[redacted]'
+ } finally {
+ seen.delete(value)
+ }
+}
+
+function tryRender(message: FunctionTriggerMessage): React.ReactNode | null {
+ if (!isScraplingFunction(message.functionId) || message.pendingApproval) {
+ return null
+ }
+
+ const running = !!message.running
+ const rawOutput = message.output
+ const errorDisplay =
+ !running && rawOutput != null
+ ? parseInfraErrorDisplay(redactProxyValues(rawOutput))
+ : null
+ if (errorDisplay) return <InfraErrorView display={errorDisplay} />
+
+ const input = unwrapEnvelope(message.input)
+ const output = rawOutput != null ? unwrapEnvelope(rawOutput) : undefined
+
+ if (FETCH_FUNCTION_IDS.has(message.functionId)) {
+ return FetchView({
+ functionId: message.functionId,
+ input,
+ output,
+ running,
+ })
+ }
+ if (ELEMENT_SEARCH_FUNCTION_IDS.has(message.functionId)) {
+ return ElementsView({
+ functionId: message.functionId,
+ input,
+ output,
+ running,
+ })
+ }
+ switch (message.functionId) {
+ case 'browser::screenshot-url':
+ return ScreenshotView({ input, output, running })
+ case 'browser::extract':
+ return ExtractView({ input, output, running })
+ case 'browser::css':
+ case 'browser::xpath':
+ case 'browser::regex':
+ return QueryView({
+ functionId: message.functionId,
+ input,
+ output,
+ running,
+ })
+ case 'browser::find-similar':
+ return FindSimilarView({ input, output, running })
+ case 'browser::describe':
+ return DescribeView({ input, output, running })
+ case 'browser::to-markdown':
+ return MarkdownView({ input, output, running })
+ case 'browser::session-open':
+ return SessionOpenView({ input, output, running })
+ case 'browser::session-fetch':
+ return SessionFetchView({ input, output, running })
+ case 'browser::session-close':
+ return SessionCloseView({ input, output, running })
+ case 'browser::session-list':
+ return SessionListView({ input, output, running })
+ case 'browser::crawl':
+ return CrawlView({ input, output, running })
+ }
+}
+
+function tryRenderPreview(
+ message: FunctionTriggerMessage,
+): React.ReactNode | null {
+ if (!isScraplingFunction(message.functionId)) return null
+ const input = unwrapEnvelope(message.input)
+ if (FETCH_FUNCTION_IDS.has(message.functionId)) {
+ return FetchPreview({ functionId: message.functionId, input })
+ }
+ if (message.functionId === 'browser::screenshot-url') {
+ return ScreenshotPreview({ input })
+ }
+ if (SESSION_GATED_FUNCTION_IDS.has(message.functionId)) {
+ switch (message.functionId) {
+ case 'browser::session-open':
+ return SessionOpenPreview({ input })
+ case 'browser::session-fetch':
+ return SessionFetchPreview({ input })
+ case 'browser::session-close':
+ return SessionClosePreview({ input })
+ case 'browser::session-list':
+ return SessionListPreview({ input })
+ }
+ }
+ if (message.functionId === 'browser::crawl') return CrawlPreview({ input })
+ return null
+}
+
+export function createScraplingRenderer(
+ _host: Host,
+): FunctionTriggerRenderer {
+ return {
+ id: 'browser/page.js#scraping-calls',
+ isMatch: isScraplingFunction,
+ tryRender,
+ tryRenderRunning: tryRender,
+ tryRenderPreview,
+ FunctionIdLabel,
+ redactRaw: redactProxyValues,
+ }
+}
diff --git a/browser/ui/src/function-trigger-message/scrapling/parsers.test.ts b/browser/ui/src/function-trigger-message/scrapling/parsers.test.ts
new file mode 100644
index 000000000..89bff7618
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/parsers.test.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import {
+ fetchEngineLabel,
+ isScraplingFunction,
+ safeParseResponse,
+ screenshotResponseSchema,
+ SCRAPLING_FUNCTION_IDS,
+} from './parsers'
+
+describe('root browser scraping ids', () => {
+ it('claims all 19 scraping functions without stealing session screenshot', () => {
+ expect(SCRAPLING_FUNCTION_IDS).toEqual([
+ 'browser::fetch',
+ 'browser::stealthy-fetch',
+ 'browser::dynamic-fetch',
+ 'browser::screenshot-url',
+ 'browser::extract',
+ 'browser::css',
+ 'browser::xpath',
+ 'browser::regex',
+ 'browser::find-similar',
+ 'browser::find',
+ 'browser::find-by-text',
+ 'browser::find-by-regex',
+ 'browser::describe',
+ 'browser::to-markdown',
+ 'browser::session-open',
+ 'browser::session-fetch',
+ 'browser::session-close',
+ 'browser::session-list',
+ 'browser::crawl',
+ ])
+ expect(isScraplingFunction('browser::screenshot-url')).toBe(true)
+ expect(isScraplingFunction('browser::screenshot')).toBe(false)
+ expect(isScraplingFunction('browser::scrapling::fetch')).toBe(false)
+ expect(fetchEngineLabel('browser::stealthy-fetch')).toBe('stealth')
+ })
+
+ it('decodes native screenshot tiles from a harness envelope', () => {
+ const parsed = safeParseResponse(screenshotResponseSchema, {
+ content: [{ type: 'text', text: 'caption' }],
+ details: {
+ content: [{ type: 'image', mime: 'image/png', data: 'aGk=' }],
+ mime: 'image/png',
+ url: 'https://example.com',
+ },
+ })
+ expect(parsed?.content[0]?.data).toBe('aGk=')
+ })
+})
diff --git a/browser/ui/src/function-trigger-message/scrapling/parsers.ts b/browser/ui/src/function-trigger-message/scrapling/parsers.ts
new file mode 100644
index 000000000..3b2e5ea98
--- /dev/null
+++ b/browser/ui/src/function-trigger-message/scrapling/parsers.ts
@@ -0,0 +1,448 @@
+/**
+ * Zod schemas + helpers for the browser scraping function family.
+ *
+ * Wire source:
+ * workers/scrapling/src/schemas.py -> FUNCTIONS (request/response schemas)
+ * workers/scrapling/src/core.py -> serialize_page / op_* return shapes
+ *
+ * Fetch responses (fetch / stealthy-fetch / dynamic-fetch) are one of:
+ * single page { status, url, headers, cookies, encoding, extracted?,
+ * captured_xhr?, html? }
+ * bulk { results: [ page | { url, error } ] } (when called with `urls`)
+ *
+ * Schemas are non-strict so additive wire fields don't break the UI.
+ */
+import { z } from 'zod'
+import { decodeBrowserResult } from '../../lib/browser'
+
+export const unwrapEnvelope = decodeBrowserResult
+
+export const SCRAPLING_FUNCTION_IDS = [
+ 'browser::fetch',
+ 'browser::stealthy-fetch',
+ 'browser::dynamic-fetch',
+ 'browser::screenshot-url',
+ 'browser::extract',
+ 'browser::css',
+ 'browser::xpath',
+ 'browser::regex',
+ 'browser::find-similar',
+ 'browser::find',
+ 'browser::find-by-text',
+ 'browser::find-by-regex',
+ 'browser::describe',
+ 'browser::to-markdown',
+ 'browser::session-open',
+ 'browser::session-fetch',
+ 'browser::session-close',
+ 'browser::session-list',
+ 'browser::crawl',
+] as const
+export type ScraplingFunctionId = (typeof SCRAPLING_FUNCTION_IDS)[number]
+
+/** find / find-by-text / find-by-regex all return `{count, items:[element]}`. */
+export const ELEMENT_SEARCH_FUNCTION_IDS: ReadonlySet<string> = new Set([
+ 'browser::find',
+ 'browser::find-by-text',
+ 'browser::find-by-regex',
+])
+
+/** Session operations require approval in the browser worker permissions. */
+export const SESSION_GATED_FUNCTION_IDS: ReadonlySet<string> = new Set([
+ 'browser::session-open',
+ 'browser::session-fetch',
+ 'browser::session-close',
+ 'browser::session-list',
+])
+
+const SCRAPLING_FUNCTION_ID_SET: ReadonlySet<string> = new Set<string>(
+ SCRAPLING_FUNCTION_IDS,
+)
+
+export function isScraplingFunction(id: string): id is ScraplingFunctionId {
+ return SCRAPLING_FUNCTION_ID_SET.has(id)
+}
+
+export const FETCH_FUNCTION_IDS: ReadonlySet<string> = new Set([
+ 'browser::fetch',
+ 'browser::stealthy-fetch',
+ 'browser::dynamic-fetch',
+])
+
+/** Which fetch tier a function runs on — drives the engine chip. */
+export function fetchEngineLabel(functionId: string): string {
+ switch (functionId) {
+ case 'browser::stealthy-fetch':
+ return 'stealth'
+ case 'browser::dynamic-fetch':
+ return 'chromium'
+ default:
+ return 'http'
+ }
+}
+
+/* ---------------- selectors (shared by fetch + parse ops) ---------------- */
+
+export const selectorSpecSchema = z.object({
+ name: z.string(),
+ css: z.string().optional(),
+ xpath: z.string().optional(),
+ regex: z.string().optional(),
+ attr: z.string().optional(),
+ html: z.boolean().optional(),
+ all: z.boolean().optional(),
+})
+export type SelectorSpec = z.infer<typeof selectorSpecSchema>
+
+/* ---------------- fetch / stealthy-fetch / dynamic-fetch ---------------- */
+
+export const fetchRequestSchema = z.object({
+ url: z.string().min(1).optional(),
+ urls: z.array(z.string().min(1)).optional(),
+ method: z.string().optional(),
+ impersonate: z.string().optional(),
+ proxy: z.string().optional(),
+ headless: z.boolean().optional(),
+ network_idle: z.boolean().optional(),
+ solve_cloudflare: z.boolean().optional(),
+ real_chrome: z.boolean().optional(),
+ cdp_url: z.string().optional(),
+ wait_selector: z.string().optional(),
+ timeout: z.number().optional(),
+ selectors: z.array(selectorSpecSchema).optional(),
+ include_html: z.boolean().optional(),
+ format: z.string().optional(),
+ main_content_only: z.boolean().optional(),
+}).refine(
+ (request) =>
+ (request.url?.length ?? 0) > 0 || (request.urls?.length ?? 0) > 0,
+)
+export type FetchRequest = z.infer<typeof fetchRequestSchema>
+
+export const pageResultSchema = z.object({
+ status: z.number().nullable().optional(),
+ url: z.string().optional(),
+ headers: z.record(z.string(), z.unknown()).optional(),
+ cookies: z.record(z.string(), z.unknown()).optional(),
+ encoding: z.string().nullable().optional(),
+ extracted: z.record(z.string(), z.unknown()).optional(),
+ captured_xhr: z.array(z.unknown()).optional(),
+ html: z.string().optional(),
+ /** markdown/text render when `format` was requested */
+ content: z.string().optional(),
+ format: z.string().optional(),
+ /** bulk per-url failure rows are `{ url, error }` */
+ error: z.string().optional(),
+}).refine((result) => Object.keys(result).length > 0)
+export type PageResult = z.infer<typeof pageResultSchema>
+
+export const bulkResponseSchema = z.object({
+ results: z.array(pageResultSchema),
+})
+export type BulkResponse = z.infer<typeof bulkResponseSchema>
+
+/** Bulk first: the loose page schema would match (and strip) a bulk payload. */
+export const fetchResponseSchema = z.union([
+ bulkResponseSchema,
+ pageResultSchema,
+])
+export type FetchResponse = z.infer<typeof fetchResponseSchema>
+
+/* ---------------- screenshot ---------------- */
+
+export const screenshotRequestSchema = z.object({
+ url: z.string(),
+ fetcher: z.string().optional(),
+ proxy: z.string().optional(),
+ full_page: z.boolean().optional(),
+ format: z.string().optional(),
+})
+export type ScreenshotRequest = z.infer<typeof screenshotRequestSchema>
+
+/** Harness content blocks: image tiles + a trailing text caption. */
+const screenshotBlockSchema = z.object({
+ type: z.string(),
+ mime: z.string().optional(),
+ data: z.string().optional(),
+ text: z.string().optional(),
+})
+
+export const screenshotResponseSchema = z
+ .object({
+ content: z.array(screenshotBlockSchema),
+ mime: z.string().optional(),
+ url: z.string().optional(),
+ })
+ .refine((response) =>
+ response.content.some(
+ (block) => block.type === 'image' && (block.data?.length ?? 0) > 0,
+ ),
+ )
+export type ScreenshotResponse = z.infer<typeof screenshotResponseSchema>
+
+/* ---------------- parse-only ops ---------------- */
+
+export const extractRequestSchema = z.object({
+ html: z.string(),
+ selectors: z.array(selectorSpecSchema),
+ adaptive: z.boolean().optional(),
+ adaptive_domain: z.string().optional(),
+})
+export type ExtractRequest = z.infer<typeof extractRequestSchema>
+
+export const extractResponseSchema = z.object({
+ extracted: z.record(z.string(), z.unknown()),
+})
+export type ExtractResponse = z.infer<typeof extractResponseSchema>
+
+export const queryRequestSchema = z.object({
+ html: z.string(),
+ query: z.string().optional(),
+ pattern: z.string().optional(),
+ first: z.boolean().optional(),
+ attr: z.string().optional(),
+ adaptive: z.boolean().optional(),
+ identifier: z.string().optional(),
+ adaptive_domain: z.string().optional(),
+})
+export type QueryRequest = z.infer<typeof queryRequestSchema>
+
+/** `attr` misses inside an `all` list come back as null items. */
+export const queryResponseSchema = z.object({
+ result: z.union([z.array(z.string().nullable()), z.string(), z.null()]),
+})
+export type QueryResponse = z.infer<typeof queryResponseSchema>
+
+export const findSimilarRequestSchema = z.object({
+ html: z.string(),
+ anchor: z.string(),
+ similarity_threshold: z.number().optional(),
+ match_text: z.boolean().optional(),
+ selectors: z.array(selectorSpecSchema).optional(),
+})
+export type FindSimilarRequest = z.infer<typeof findSimilarRequestSchema>
+
+export const findSimilarResponseSchema = z.object({
+ count: z.number(),
+ items: z.array(z.record(z.string(), z.unknown())),
+})
+export type FindSimilarResponse = z.infer<typeof findSimilarResponseSchema>
+
+/* ---------------- element search (find / find-by-text / find-by-regex) ---- */
+
+export const elementSchema = z.object({
+ tag: z.string().optional(),
+ text: z.string().optional(),
+ html: z.string().optional(),
+ attrs: z.record(z.string(), z.unknown()).optional(),
+ css: z.string().optional(),
+ xpath: z.string().optional(),
+})
+export type ScrapedElement = z.infer<typeof elementSchema>
+
+export const elementsResponseSchema = z.object({
+ count: z.number(),
+ items: z.array(elementSchema),
+})
+export type ElementsResponse = z.infer<typeof elementsResponseSchema>
+
+export const findRequestSchema = z.object({
+ html: z.string(),
+ tag: z.union([z.string(), z.array(z.string())]).optional(),
+ attrs: z.record(z.string(), z.unknown()).optional(),
+ text_regex: z.string().optional(),
+ first: z.boolean().optional(),
+ limit: z.number().optional(),
+})
+export type FindRequest = z.infer<typeof findRequestSchema>
+
+export const findByTextRequestSchema = z.object({
+ html: z.string(),
+ text: z.string(),
+ partial: z.boolean().optional(),
+ case_sensitive: z.boolean().optional(),
+ first: z.boolean().optional(),
+})
+export type FindByTextRequest = z.infer<typeof findByTextRequestSchema>
+
+export const findByRegexRequestSchema = z.object({
+ html: z.string(),
+ pattern: z.string(),
+ case_sensitive: z.boolean().optional(),
+ first: z.boolean().optional(),
+})
+export type FindByRegexRequest = z.infer<typeof findByRegexRequestSchema>
+
+/* ---------------- describe ---------------- */
+
+export const describeRequestSchema = z.object({
+ html: z.string(),
+ query: z.string(),
+ kind: z.string().optional(),
+})
+export type DescribeRequest = z.infer<typeof describeRequestSchema>
+
+export const describeElementSchema = elementSchema.extend({
+ full_css: z.string().optional(),
+ full_xpath: z.string().optional(),
+ classes: z.array(z.string()).optional(),
+ parent_tag: z.string().nullable().optional(),
+ children: z.number().optional(),
+ siblings: z.number().optional(),
+})
+export type DescribeElement = z.infer<typeof describeElementSchema>
+
+export const describeResponseSchema = z.object({
+ found: z.boolean(),
+ element: describeElementSchema.optional(),
+})
+export type DescribeResponse = z.infer<typeof describeResponseSchema>
+
+/* ---------------- to-markdown ---------------- */
+
+export const markdownRequestSchema = z.object({
+ html: z.string(),
+ format: z.string().optional(),
+ css_selector: z.string().optional(),
+ main_content_only: z.boolean().optional(),
+})
+export type MarkdownRequest = z.infer<typeof markdownRequestSchema>
+
+export const markdownResponseSchema = z.object({
+ format: z.string(),
+ content: z.string(),
+})
+export type MarkdownResponse = z.infer<typeof markdownResponseSchema>
+
+/* ---------------- sessions ---------------- */
+
+export const sessionOpenRequestSchema = z.object({
+ type: z.string().optional(),
+ impersonate: z.string().optional(),
+ proxy: z.string().optional(),
+ headless: z.boolean().optional(),
+ useragent: z.string().optional(),
+ solve_cloudflare: z.boolean().optional(),
+ real_chrome: z.boolean().optional(),
+})
+export type SessionOpenRequest = z.infer<typeof sessionOpenRequestSchema>
+
+export const sessionOpenResponseSchema = z.object({
+ session_id: z.string(),
+ type: z.string().optional(),
+})
+export type SessionOpenResponse = z.infer<typeof sessionOpenResponseSchema>
+
+export const sessionFetchRequestSchema = z.object({
+ session_id: z.string(),
+ url: z.string(),
+ method: z.string().optional(),
+ selectors: z.array(selectorSpecSchema).optional(),
+ format: z.string().optional(),
+ include_html: z.boolean().optional(),
+})
+export type SessionFetchRequest = z.infer<typeof sessionFetchRequestSchema>
+
+export const sessionCloseResponseSchema = z.object({
+ closed: z.boolean(),
+})
+export type SessionCloseResponse = z.infer<typeof sessionCloseResponseSchema>
+
+export const sessionCloseRequestSchema = z.object({
+ session_id: z.string(),
+})
+export type SessionCloseRequest = z.infer<typeof sessionCloseRequestSchema>
+
+export const sessionSummarySchema = z.object({
+ session_id: z.string(),
+ type: z.string().optional(),
+ created_at: z.number().optional(),
+ last_used: z.number().optional(),
+ idle_s: z.number().optional(),
+})
+export type SessionSummary = z.infer<typeof sessionSummarySchema>
+
+export const sessionListResponseSchema = z.object({
+ sessions: z.array(sessionSummarySchema),
+})
+export type SessionListResponse = z.infer<typeof sessionListResponseSchema>
+
+export const sessionListRequestSchema = z.object({
+ type: z.string().optional(),
+})
+export type SessionListRequest = z.infer<typeof sessionListRequestSchema>
+
+/* ---------------- crawl ---------------- */
+
+export const crawlRequestSchema = z
+ .object({
+ start_urls: z.array(z.string().min(1)).optional(),
+ url: z.string().min(1).optional(),
+ fetcher: z.string().optional(),
+ selectors: z.array(selectorSpecSchema).optional(),
+ allowed_domains: z.array(z.string()).optional(),
+ same_domain: z.boolean().optional(),
+ max_pages: z.number().optional(),
+ max_depth: z.number().optional(),
+ concurrency: z.number().optional(),
+ format: z.string().optional(),
+ stream_name: z.string().optional(),
+ })
+ .refine(
+ (request) =>
+ (request.url?.length ?? 0) > 0 ||
+ (request.start_urls?.length ?? 0) > 0,
+ )
+export type CrawlRequest = z.infer<typeof crawlRequestSchema>
+
+export const crawlItemSchema = z.object({
+ url: z.string().optional(),
+ status: z.number().nullable().optional(),
+ extracted: z.record(z.string(), z.unknown()).optional(),
+ content: z.string().optional(),
+ error: z.string().optional(),
+})
+export type CrawlItem = z.infer<typeof crawlItemSchema>
+
+export const crawlResponseSchema = z.object({
+ stats: z.object({
+ crawled: z.number(),
+ items: z.number(),
+ errors: z.number(),
+ stopped: z.string().optional(),
+ }),
+ items: z.array(crawlItemSchema).optional(),
+ // The worker echoes the caller's stream_name/group_id verbatim, so either
+ // may arrive as a number or boolean (e.g. group_id:3) — accept those, not
+ // just strings, or the whole card fails to parse and renders nothing.
+ stream: z
+ .object({
+ name: z.union([z.string(), z.number(), z.boolean()]).optional(),
+ group_id: z.union([z.string(), z.number(), z.boolean()]).optional(),
+ })
+ .optional(),
+})
+export type CrawlResponse = z.infer<typeof crawlResponseSchema>
+
+/* ---------------- helpers ---------------- */
+
+export function safeParseRequest<T>(
+ schema: z.ZodType<T>,
+ value: unknown,
+): T | null {
+ const parsed = schema.safeParse(value ?? {})
+ return parsed.success ? parsed.data : null
+}
+
+export function safeParseResponse<T>(
+ schema: z.ZodType<T>,
+ value: unknown,
+): T | null {
+ const parsed = schema.safeParse(unwrapEnvelope(value))
+ return parsed.success ? parsed.data : null
+}
+
+export function formatChars(n: number): string {
+ if (n < 1000) return `${n} chars`
+ return `${(n / 1000).toFixed(1)}k chars`
+}
diff --git a/browser/ui/src/lib/shared.tsx b/browser/ui/src/lib/shared.tsx
index 5e5b6e80e..3d42c59f6 100644
--- a/browser/ui/src/lib/shared.tsx
+++ b/browser/ui/src/lib/shared.tsx
@@ -19,6 +19,21 @@ export function Chip({
return <span className={cn('br-ui-chip', className)}>{children}</span>
}
+export function FilterChip({
+ label,
+ value,
+}: {
+ label: string
+ value: ReactNode
+}) {
+ return (
+ <Chip>
+ <span className="br-ui-chip-label">{label}</span>
+ <span>{value}</span>
+ </Chip>
+ )
+}
+
export function MetaRow({ children }: { children: ReactNode }) {
return <div className="br-ui-meta-row">{children}</div>
}
diff --git a/browser/ui/styles.css b/browser/ui/styles.css
index 8d02bdacc..927d183b8 100644
--- a/browser/ui/styles.css
+++ b/browser/ui/styles.css
@@ -2032,6 +2032,9 @@
}
[data-iii-ui="browser"] .br-ui-chip {
display: inline-flex;
+ box-sizing: border-box;
+ min-width: 0;
+ max-width: 100%;
align-items: center;
border: 1px solid var(--color-rule-2);
background: var(--color-paper-2);
@@ -2039,6 +2042,13 @@
padding: 2px 6px;
font-size: 10px;
color: var(--color-ink-faint);
+ white-space: normal;
+ overflow-wrap: anywhere;
+}
+[data-iii-ui="browser"] .br-ui-chip > span:last-child {
+ min-width: 0;
+ white-space: normal;
+ overflow-wrap: anywhere;
}
[data-iii-ui="browser"] .br-ui-chip-accent {
color: var(--color-accent);
@@ -2050,6 +2060,13 @@
color: var(--color-warn);
border-color: color-mix(in srgb, var(--color-warn) 40%, transparent);
}
+[data-iii-ui="browser"] .br-ui-chip-label {
+ margin-right: 4px;
+ flex-shrink: 0;
+ color: var(--color-ink-ghost);
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+}
[data-iii-ui="browser"] .br-ui-action-line {
display: flex;
align-items: flex-start;
@@ -2084,6 +2101,249 @@
color: var(--color-accent);
}
+/* scraping function-trigger views */
+[data-iii-ui="browser"] .br-ui-scrape-section {
+ min-width: 0;
+ overflow: hidden;
+ border-top: 1px solid var(--color-rule-2);
+ background: var(--color-bg);
+ color: var(--color-ink);
+ font-family: var(--font-mono, ui-monospace, monospace);
+}
+[data-iii-ui="browser"] .br-ui-scrape-section.is-preview {
+ border-top: 0;
+ border-bottom: 1px solid var(--color-rule-2);
+}
+[data-iii-ui="browser"] .br-ui-scrape-section pre {
+ max-width: 100%;
+ overflow: auto;
+}
+[data-iii-ui="browser"] .br-ui-scrape-running,
+[data-iii-ui="browser"] .br-ui-scrape-empty {
+ padding: 12px;
+ font-size: 12.5px;
+ color: var(--color-ink-ghost);
+}
+[data-iii-ui="browser"] .br-ui-scrape-label {
+ padding: 6px 12px;
+ border-bottom: 1px solid var(--color-rule-2);
+ background: var(--color-paper-2);
+ color: var(--color-ink-faint);
+ font-size: 10px;
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+}
+[data-iii-ui="browser"] .br-ui-scrape-label.is-separated {
+ border-top: 1px solid var(--color-rule-2);
+}
+[data-iii-ui="browser"] .br-ui-scrape-pre {
+ margin: 0;
+ padding: 8px 12px;
+ font-size: 12px;
+ line-height: 1.55;
+ color: var(--color-ink);
+ white-space: pre-wrap;
+ overflow-wrap: anywhere;
+}
+[data-iii-ui="browser"] .br-ui-scrape-pre.is-muted {
+ color: var(--color-ink-faint);
+ font-size: 11.5px;
+ line-height: 1.5;
+}
+[data-iii-ui="browser"] .br-ui-scrape-pre.is-separated {
+ border-top: 1px solid var(--color-rule-2);
+}
+[data-iii-ui="browser"] .br-ui-scrape-result-row {
+ display: flex;
+ min-width: 0;
+ align-items: flex-start;
+ gap: 8px;
+ padding: 6px 12px;
+ border-bottom: 1px solid var(--color-rule-2);
+ font-size: 12px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-result-row:last-child {
+ border-bottom: 0;
+}
+[data-iii-ui="browser"] .br-ui-scrape-row-status {
+ flex-shrink: 0;
+ color: var(--color-ink-faint);
+ font-variant-numeric: tabular-nums;
+}
+[data-iii-ui="browser"] .br-ui-scrape-row-status.is-warn,
+[data-iii-ui="browser"] .br-ui-scrape-summary.is-warn,
+[data-iii-ui="browser"] .br-ui-scrape-row-error {
+ color: var(--color-warn);
+}
+[data-iii-ui="browser"] .br-ui-scrape-row-main,
+[data-iii-ui="browser"] .br-ui-scrape-row-error {
+ min-width: 0;
+ overflow-wrap: anywhere;
+}
+[data-iii-ui="browser"] .br-ui-scrape-row-main {
+ color: var(--color-ink);
+}
+[data-iii-ui="browser"] .br-ui-scrape-summary {
+ color: var(--color-ink-faint);
+ overflow-wrap: anywhere;
+}
+[data-iii-ui="browser"] .br-ui-scrape-break,
+[data-iii-ui="browser"] .br-ui-scrape-selector-value,
+[data-iii-ui="browser"] .br-ui-scrape-caption,
+[data-iii-ui="browser"] .br-ui-scrape-detail {
+ overflow-wrap: anywhere;
+}
+[data-iii-ui="browser"] .br-ui-scrape-detail,
+[data-iii-ui="browser"] .br-ui-scrape-caption {
+ color: var(--color-ink-faint);
+ font-size: 11.5px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-more {
+ padding: 6px 12px;
+ color: var(--color-ink-ghost);
+ font-size: 11px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-more.is-separated {
+ border-top: 1px solid var(--color-rule-2);
+}
+[data-iii-ui="browser"] .br-ui-scrape-warning {
+ color: var(--color-warn);
+ border-color: color-mix(in srgb, var(--color-warn) 40%, transparent);
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+}
+[data-iii-ui="browser"] .br-ui-scrape-adaptive {
+ color: var(--color-accent);
+ border-color: color-mix(in srgb, var(--color-accent) 40%, transparent);
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+}
+[data-iii-ui="browser"] .br-ui-scrape-chip-value {
+ margin-left: 4px;
+ color: var(--color-ink);
+ text-transform: none;
+ letter-spacing: normal;
+}
+[data-iii-ui="browser"] .br-ui-scrape-selector-list {
+ padding: 2px 0;
+ border-bottom: 1px solid var(--color-rule-2);
+}
+[data-iii-ui="browser"] .br-ui-scrape-selector-row {
+ display: flex;
+ min-width: 0;
+ align-items: flex-start;
+ gap: 8px;
+ padding: 2px 12px;
+ font-size: 11.5px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-selector-name,
+[data-iii-ui="browser"] .br-ui-scrape-element-tag {
+ flex-shrink: 0;
+ color: var(--color-accent);
+}
+[data-iii-ui="browser"] .br-ui-scrape-selector-value {
+ min-width: 0;
+ color: var(--color-ink-faint);
+ font-size: 11px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-result-number {
+ width: 24px;
+ flex-shrink: 0;
+ color: var(--color-ink-ghost);
+ text-align: right;
+ font-variant-numeric: tabular-nums;
+}
+[data-iii-ui="browser"] .br-ui-scrape-dim {
+ color: var(--color-ink-ghost);
+}
+[data-iii-ui="browser"] .br-ui-scrape-prewrap {
+ white-space: pre-wrap;
+}
+[data-iii-ui="browser"] .br-ui-scrape-element-row {
+ display: flex;
+ flex-direction: column;
+ gap: 2px;
+ min-width: 0;
+ padding: 6px 12px;
+ border-bottom: 1px solid var(--color-rule-2);
+}
+[data-iii-ui="browser"] .br-ui-scrape-element-row:last-child {
+ border-bottom: 0;
+}
+[data-iii-ui="browser"] .br-ui-scrape-element-main {
+ display: flex;
+ min-width: 0;
+ align-items: baseline;
+ gap: 8px;
+ font-size: 12px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-description {
+ padding: 8px 12px;
+ border-bottom: 1px solid var(--color-rule-2);
+ color: var(--color-ink);
+ font-size: 12.5px;
+ overflow-wrap: anywhere;
+}
+[data-iii-ui="browser"] .br-ui-scrape-table-wrap {
+ max-width: 100%;
+ overflow-x: auto;
+}
+[data-iii-ui="browser"] .br-ui-scrape-table {
+ width: 100%;
+ border-collapse: collapse;
+ table-layout: fixed;
+ color: var(--color-ink);
+ font-size: 11.5px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-table tr {
+ border-bottom: 1px solid var(--color-rule-2);
+}
+[data-iii-ui="browser"] .br-ui-scrape-table tr:last-child {
+ border-bottom: 0;
+}
+[data-iii-ui="browser"] .br-ui-scrape-table td {
+ padding: 4px 12px;
+ overflow-wrap: anywhere;
+}
+[data-iii-ui="browser"] .br-ui-scrape-table-key {
+ width: 26%;
+ color: var(--color-ink-faint);
+ vertical-align: top;
+}
+[data-iii-ui="browser"] .br-ui-scrape-table-value {
+ color: var(--color-ink);
+}
+[data-iii-ui="browser"] .br-ui-scrape-table-type {
+ width: 22%;
+ color: var(--color-accent);
+}
+[data-iii-ui="browser"] .br-ui-scrape-table-meta {
+ color: var(--color-ink-faint);
+ text-align: right;
+ font-variant-numeric: tabular-nums;
+ white-space: nowrap;
+}
+[data-iii-ui="browser"] .br-ui-scrape-gallery {
+ display: grid;
+ gap: 8px;
+ max-width: 100%;
+ padding: 12px;
+}
+[data-iii-ui="browser"] .br-ui-scrape-image {
+ display: block;
+ max-width: 100%;
+ max-height: 420px;
+ border: 1px solid var(--color-rule-2);
+ background: var(--color-paper-2);
+ object-fit: contain;
+}
+[data-iii-ui="browser"] .br-ui-scrape-num {
+ font-variant-numeric: tabular-nums;
+}
+[data-iii-ui="browser"] .br-ui-scrape-unit {
+ margin-left: 2px;
+}
+
/* snapshot / dom trees */
[data-iii-ui="browser"] .br-ui-tree {
margin: 0;
diff --git a/browser/vendor/SCRAPLING-0.4.9-LICENSE b/browser/vendor/SCRAPLING-0.4.9-LICENSE
new file mode 100644
index 000000000..3abe05c0c
--- /dev/null
+++ b/browser/vendor/SCRAPLING-0.4.9-LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Karim shoair
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/browser/vendor/browserforge-1.2.4/NOTICE b/browser/vendor/browserforge-1.2.4/NOTICE
new file mode 100644
index 000000000..b51c51dd4
--- /dev/null
+++ b/browser/vendor/browserforge-1.2.4/NOTICE
@@ -0,0 +1,10 @@
+BrowserForge 1.2.4 and apify-fingerprint-datapoints 0.15.0 data
+Copyright 2018 Apify Technologies s.r.o.
+
+The input and header Bayesian-network snapshots are redistributed under the
+Apache License, Version 2.0. Their frozen SHA-256 digests are:
+
+ input-network.json 85e51ab98b64f07255da7767c128c9e5f171af1ff2448a0a2e4688ffaa455a3f
+ header-network.json a30900f8cdee234113947630e46417042ac31391dd5dbc505359625899a47052
+
+https://github.com/apify/fingerprint-suite
diff --git a/browser/vendor/browserforge-1.2.4/header-network.json b/browser/vendor/browserforge-1.2.4/header-network.json
new file mode 100644
index 000000000..e4b4fa9c0
--- /dev/null
+++ b/browser/vendor/browserforge-1.2.4/header-network.json
@@ -0,0 +1 @@
+{"nodes":[{"name":"*BROWSER","parentNames":[],"possibleValues":["chrome/147.0.0.0","edge/147.0.0.0","safari/26.4","safari/26.3","chrome/146.0.0.0","firefox/150.0","safari/26.2","safari/18.5","safari/26.0.1","firefox/135.0","chrome/148.0.0.0","chrome/142.0.0.0","safari/18.3","chrome/144.0.0.0","safari/18.2","safari/26.3.1","safari/18.7","edge/129.0.0.0","safari/18.7.4","safari/18.1","safari/18.6","safari/18.7.5","chrome/145.0.0.0","chrome/127.0.0.0","safari/16.6","chrome/141.0.0.0","chrome/121.0.0.0","chrome/143.0.0.0","chrome/128.0.0.0","safari/17.2.1","safari/26.5","chrome/116.0.0.0","chrome/138.0.0.0","safari/26.1","safari/17.6","firefox/151.0","chrome/130.0.0.0","chrome/115.0.0.0","edge/146.0.0.0","chrome/149.0.0.0","chrome/140.0.0.0","safari/16.4","safari/18.1.1","edge/144.0.0.0","edge/128.0.0.0","chrome/109.0.0.0","chrome/139.0.0.0","edge/143.0.0.0","safari/17.4","chrome/131.0.0.0","safari/18.4","safari/18.0.1","chrome/134.0.0.0","safari/16.5.2","safari/26.4.2","chrome/120.0.0.0","chrome/137.0.0.0","safari/26.0","safari/16.6.1","firefox/147.0","edge/145.0.0.0","chrome/135.0.0.0","safari/17.5","chrome/45.0.8909.1591","chrome/91.0.4450.0","safari/17.7","chrome/125.0.0.0","chrome/126.0.0.0","chrome/113.0.0.0","chrome/101.0.4951.54","chrome/108.0.0.0","edge/148.0.0.0","chrome/147.0.7727.56","safari/17.4.1","edge/123.0.0.0","chrome/136.0.0.0","safari/16.6.2","chrome/119.0.0.0","chrome/142.0.7444.138","safari/18.3.1","edge/138.0.0.0","firefox/136.0","chrome/114.0.0.0","safari/16.5","chrome/138.0.7204.235","chrome/59.0.9273.1293","chrome/144.0.7559.95","safari/17.3","edge/142.0.0.0","safari/18.7.3","chrome/138.0.7204.63","firefox/149.0","safari/17.8","safari/15.6.8","safari/17.3.1","chrome/147.0.7727.111","chrome/124.0.0.0","chrome/122.0.0.0","safari/15.6.7","chrome/107.0.0.0","firefox/146.0","edge/122.0.0.0","safari/16.2","chrome/103.0.0.0","chrome/90.0.4430.212","safari/17.1.2","chrome/132.0.0.0","safari/18.0","chrome/130.0.6723.73","chrome/133.0.0.0","firefox/142.0","safari/17.0","safari/17.1","chrome/96.0.4664.110","safari/18.7.7","chrome/147.0.7727.116","safari/18.7.2","safari/15.6.1","safari/17.2","safari/18.4.1","edge/135.0.3179.54","safari/26.4.1","chrome/106.0.0.0","safari/16.1","chrome/91.0.4472.124","chrome/132.0.6788.76","safari/16.3"],"conditionalProbabilities":{"chrome/147.0.0.0":0.6648816234498309,"edge/147.0.0.0":0.06729143179255918,"safari/26.4":0.04594137542277339,"safari/26.3":0.038331454340473504,"chrome/146.0.0.0":0.031426155580608794,"firefox/150.0":0.004086809470124014,"safari/26.2":0.012612739571589628,"safari/18.5":0.0036640360766629085,"safari/26.0.1":0.0024661781285231117,"firefox/135.0":0.0014092446448703494,"chrome/148.0.0.0":0.007116685456595265,"chrome/142.0.0.0":0.007750845546786922,"safari/18.3":0.0017615558060879368,"chrome/144.0.0.0":0.004227733934611048,"safari/18.2":0.0006341600901916572,"safari/26.3.1":0.018602029312288614,"safari/18.7":0.0002818489289740699,"edge/129.0.0.0":0.00021138669673055241,"safari/18.7.4":0.0002818489289740699,"safari/18.1":0.0015501691093573844,"safari/18.6":0.011203494926719279,"safari/18.7.5":0.0031003382187147687,"chrome/145.0.0.0":0.01677001127395716,"chrome/127.0.0.0":0.00021138669673055241,"safari/16.6":0.00042277339346110483,"chrome/141.0.0.0":0.0014092446448703494,"chrome/121.0.0.0":0.0002818489289740699,"chrome/143.0.0.0":0.004086809470124014,"chrome/128.0.0.0":0.0005636978579481398,"safari/17.2.1":0.00007046223224351747,"safari/26.5":0.004368658399098084,"chrome/116.0.0.0":0.00035231116121758736,"chrome/138.0.0.0":0.0042981961668545655,"safari/26.1":0.0034526493799323563,"safari/17.6":0.002395715896279594,"firefox/151.0":0.00014092446448703494,"chrome/130.0.0.0":0.0005636978579481398,"chrome/115.0.0.0":0.00007046223224351747,"edge/146.0.0.0":0.002043404735062007,"chrome/149.0.0.0":0.0007750845546786922,"chrome/140.0.0.0":0.0009864712514092446,"safari/16.4":0.00014092446448703494,"safari/18.1.1":0.00035231116121758736,"edge/144.0.0.0":0.00014092446448703494,"edge/128.0.0.0":0.00007046223224351747,"chrome/109.0.0.0":0.0017615558060879368,"chrome/139.0.0.0":0.0009160090191657271,"edge/143.0.0.0":0.0007750845546786922,"safari/17.4":0.00021138669673055241,"chrome/131.0.0.0":0.0007750845546786922,"safari/18.4":0.00042277339346110483,"safari/18.0.1":0.00007046223224351747,"chrome/134.0.0.0":0.0007046223224351747,"safari/16.5.2":0.00007046223224351747,"safari/26.4.2":0.0005636978579481398,"chrome/120.0.0.0":0.0002818489289740699,"chrome/137.0.0.0":0.0008455467869222097,"safari/26.0":0.0016206313416009018,"safari/16.6.1":0.00021138669673055241,"firefox/147.0":0.0002818489289740699,"edge/145.0.0.0":0.00035231116121758736,"chrome/135.0.0.0":0.0007750845546786922,"safari/17.5":0.0009160090191657271,"chrome/45.0.8909.1591":0.00007046223224351747,"chrome/91.0.4450.0":0.00021138669673055241,"safari/17.7":0.00014092446448703494,"chrome/125.0.0.0":0.0007046223224351747,"chrome/126.0.0.0":0.0006341600901916572,"chrome/113.0.0.0":0.00007046223224351747,"chrome/101.0.4951.54":0.0007046223224351747,"chrome/108.0.0.0":0.00014092446448703494,"edge/148.0.0.0":0.0012683201803833145,"chrome/147.0.7727.56":0.00035231116121758736,"safari/17.4.1":0.00042277339346110483,"edge/123.0.0.0":0.00021138669673055241,"chrome/136.0.0.0":0.00042277339346110483,"safari/16.6.2":0.00035231116121758736,"chrome/119.0.0.0":0.00042277339346110483,"chrome/142.0.7444.138":0.00007046223224351747,"safari/18.3.1":0.0005636978579481398,"edge/138.0.0.0":0.00007046223224351747,"firefox/136.0":0.00007046223224351747,"chrome/114.0.0.0":0.0008455467869222097,"safari/16.5":0.00042277339346110483,"chrome/138.0.7204.235":0.00007046223224351747,"chrome/59.0.9273.1293":0.00007046223224351747,"chrome/144.0.7559.95":0.00014092446448703494,"safari/17.3":0.00021138669673055241,"edge/142.0.0.0":0.00014092446448703494,"safari/18.7.3":0.00021138669673055241,"chrome/138.0.7204.63":0.00007046223224351747,"firefox/149.0":0.0004932356257046223,"safari/17.8":0.00007046223224351747,"safari/15.6.8":0.0008455467869222097,"safari/17.3.1":0.0002818489289740699,"chrome/147.0.7727.111":0.00042277339346110483,"chrome/124.0.0.0":0.00021138669673055241,"chrome/122.0.0.0":0.00035231116121758736,"safari/15.6.7":0.00035231116121758736,"chrome/107.0.0.0":0.00014092446448703494,"firefox/146.0":0.00014092446448703494,"edge/122.0.0.0":0.00007046223224351747,"safari/16.2":0.00007046223224351747,"chrome/103.0.0.0":0.00007046223224351747,"chrome/90.0.4430.212":0.00007046223224351747,"safari/17.1.2":0.00007046223224351747,"chrome/132.0.0.0":0.00021138669673055241,"safari/18.0":0.00035231116121758736,"chrome/130.0.6723.73":0.00007046223224351747,"chrome/133.0.0.0":0.00035231116121758736,"firefox/142.0":0.00014092446448703494,"safari/17.0":0.00007046223224351747,"safari/17.1":0.00014092446448703494,"chrome/96.0.4664.110":0.00007046223224351747,"safari/18.7.7":0.00007046223224351747,"chrome/147.0.7727.116":0.0002818489289740699,"safari/18.7.2":0.00014092446448703494,"safari/15.6.1":0.00007046223224351747,"safari/17.2":0.00007046223224351747,"safari/18.4.1":0.00007046223224351747,"edge/135.0.3179.54":0.00007046223224351747,"safari/26.4.1":0.00007046223224351747,"chrome/106.0.0.0":0.00014092446448703494,"safari/16.1":0.00007046223224351747,"chrome/91.0.4472.124":0.0002818489289740699,"chrome/132.0.6788.76":0.00007046223224351747,"safari/16.3":0.00007046223224351747}},{"name":"*OPERATING_SYSTEM","parentNames":[],"possibleValues":["macos","windows","ios","android","linux","*MISSING_VALUE*"],"conditionalProbabilities":{"macos":0.28734498308906425,"windows":0.5926578354002254,"ios":0.07278748590755355,"android":0.023322998872604285,"linux":0.02290022547914318,"*MISSING_VALUE*":0.0009864712514092446}},{"name":"*DEVICE","parentNames":[],"possibleValues":["desktop","mobile"],"conditionalProbabilities":{"desktop":0.9038895152198422,"mobile":0.09611048478015784}},{"name":"*HTTP_VERSION","parentNames":[],"possibleValues":["_2.0_","_1.1_"],"conditionalProbabilities":{"_2.0_":0.9921786922209695,"_1.1_":0.00782130777903044}},{"name":"sec-ch-ua-mobile","parentNames":["*HTTP_VERSION","*DEVICE","*OPERATING_SYSTEM","*BROWSER"],"possibleValues":["?0","*MISSING_VALUE*","?1"],"conditionalProbabilities":{"deeper":{"_2.0_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"?0":0.9977548271216884,"*MISSING_VALUE*":0.00224517287831163},"edge/147.0.0.0":{"?0":1},"safari/26.4":{"*MISSING_VALUE*":1},"safari/26.3":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"?0":1},"firefox/150.0":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1},"safari/26.0.1":{"*MISSING_VALUE*":1},"firefox/135.0":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"?0":1},"chrome/142.0.0.0":{"?0":1},"safari/18.3":{"*MISSING_VALUE*":1},"chrome/144.0.0.0":{"?0":1},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"safari/18.1":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"chrome/145.0.0.0":{"?0":1},"chrome/127.0.0.0":{"?0":1},"safari/16.6":{"*MISSING_VALUE*":1},"chrome/141.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/128.0.0.0":{"?0":1},"safari/17.2.1":{"*MISSING_VALUE*":1},"safari/26.5":{"*MISSING_VALUE*":1},"chrome/116.0.0.0":{"?0":1},"chrome/138.0.0.0":{"?0":1},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"firefox/151.0":{"*MISSING_VALUE*":1},"chrome/130.0.0.0":{"?0":1},"chrome/115.0.0.0":{"?0":1},"chrome/149.0.0.0":{"?0":1},"chrome/140.0.0.0":{"?0":1},"safari/16.4":{"*MISSING_VALUE*":1},"safari/18.1.1":{"*MISSING_VALUE*":1},"chrome/139.0.0.0":{"?0":1},"safari/17.4":{"*MISSING_VALUE*":1},"chrome/131.0.0.0":{"?0":1},"safari/18.4":{"*MISSING_VALUE*":1},"safari/18.0.1":{"*MISSING_VALUE*":1},"safari/16.5.2":{"*MISSING_VALUE*":1},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"firefox/147.0":{"*MISSING_VALUE*":1},"chrome/135.0.0.0":{"?0":1},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/91.0.4450.0":{"*MISSING_VALUE*":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"safari/18.3.1":{"*MISSING_VALUE*":1},"chrome/114.0.0.0":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/138.0.7204.235":{"*MISSING_VALUE*":1},"safari/17.3":{"*MISSING_VALUE*":1},"firefox/149.0":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"safari/17.3.1":{"*MISSING_VALUE*":1},"chrome/107.0.0.0":{"?0":1},"chrome/103.0.0.0":{"?0":1},"safari/17.1.2":{"*MISSING_VALUE*":1},"safari/18.0":{"*MISSING_VALUE*":1},"safari/17.0":{"*MISSING_VALUE*":1},"safari/17.1":{"*MISSING_VALUE*":1},"safari/15.6.1":{"*MISSING_VALUE*":1},"safari/17.2":{"*MISSING_VALUE*":1},"safari/16.1":{"*MISSING_VALUE*":1},"safari/16.3":{"*MISSING_VALUE*":1}},"skip":{"?0":0.6797047970479705,"*MISSING_VALUE*":0.3202952029520295}},"windows":{"deeper":{"chrome/147.0.0.0":{"?0":1},"edge/147.0.0.0":{"?0":1},"chrome/146.0.0.0":{"?0":0.9910714285714286,"*MISSING_VALUE*":0.008928571428571428},"firefox/150.0":{"*MISSING_VALUE*":1},"firefox/135.0":{"*MISSING_VALUE*":0.9473684210526315,"?0":0.05263157894736842},"chrome/148.0.0.0":{"?0":1},"chrome/142.0.0.0":{"?0":1},"chrome/144.0.0.0":{"?0":1},"edge/129.0.0.0":{"?0":1},"chrome/145.0.0.0":{"?0":1},"chrome/127.0.0.0":{"?0":1},"chrome/141.0.0.0":{"?0":1},"chrome/121.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/128.0.0.0":{"?0":1},"chrome/138.0.0.0":{"?0":1},"chrome/130.0.0.0":{"?0":1},"edge/146.0.0.0":{"?0":1},"chrome/149.0.0.0":{"?0":1},"chrome/140.0.0.0":{"?0":1},"edge/144.0.0.0":{"?0":1},"edge/128.0.0.0":{"?0":1},"chrome/109.0.0.0":{"?0":1},"chrome/139.0.0.0":{"?0":1},"edge/143.0.0.0":{"?0":1},"chrome/131.0.0.0":{"?0":1},"chrome/134.0.0.0":{"?0":1},"chrome/120.0.0.0":{"?0":1},"chrome/137.0.0.0":{"?0":1},"firefox/147.0":{"*MISSING_VALUE*":1},"edge/145.0.0.0":{"?0":1},"chrome/135.0.0.0":{"?0":1},"chrome/125.0.0.0":{"?0":1},"chrome/126.0.0.0":{"?0":1},"chrome/113.0.0.0":{"?0":1},"chrome/108.0.0.0":{"?0":1},"edge/148.0.0.0":{"?0":1},"chrome/147.0.7727.56":{"?0":1},"edge/123.0.0.0":{"?0":1},"chrome/136.0.0.0":{"?0":1},"edge/138.0.0.0":{"?0":1},"edge/142.0.0.0":{"?0":1},"firefox/149.0":{"*MISSING_VALUE*":1},"chrome/124.0.0.0":{"?0":1},"chrome/122.0.0.0":{"?0":1},"edge/122.0.0.0":{"?0":1},"chrome/132.0.0.0":{"?0":1},"chrome/133.0.0.0":{"?0":1},"edge/135.0.3179.54":{"?0":1},"chrome/106.0.0.0":{"?0":1},"chrome/91.0.4472.124":{"*MISSING_VALUE*":1},"chrome/132.0.6788.76":{"?0":1}},"skip":{"?0":0.9953113729261842,"*MISSING_VALUE*":0.004688627073815821}},"linux":{"deeper":{"chrome/147.0.0.0":{"?0":1},"edge/147.0.0.0":{"?0":1},"chrome/146.0.0.0":{"?0":1},"firefox/150.0":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"?0":1},"chrome/142.0.0.0":{"?0":1},"chrome/144.0.0.0":{"?0":1},"chrome/145.0.0.0":{"?0":1},"chrome/141.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/138.0.0.0":{"?0":1},"chrome/130.0.0.0":{"?0":1},"chrome/149.0.0.0":{"?0":1},"chrome/140.0.0.0":{"?0":1},"edge/143.0.0.0":{"?0":1},"chrome/131.0.0.0":{"?0":1},"chrome/134.0.0.0":{"?0":1},"chrome/137.0.0.0":{"?0":1},"edge/145.0.0.0":{"?0":1},"chrome/135.0.0.0":{"?0":1},"chrome/126.0.0.0":{"?0":1},"chrome/101.0.4951.54":{"*MISSING_VALUE*":1},"chrome/136.0.0.0":{"?0":1},"firefox/149.0":{"*MISSING_VALUE*":1},"firefox/146.0":{"*MISSING_VALUE*":1},"chrome/90.0.4430.212":{"*MISSING_VALUE*":1},"firefox/142.0":{"*MISSING_VALUE*":1}},"skip":{"?0":0.9065420560747663,"*MISSING_VALUE*":0.09345794392523364}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"?0":1},"chrome/146.0.0.0":{"?0":1},"chrome/144.0.0.0":{"?0":1},"chrome/126.0.0.0":{"?0":1}},"skip":{"?0":1}}},"skip":{"deeper":{"chrome/147.0.0.0":{"?0":0.9994513332601778,"*MISSING_VALUE*":0.000548666739822232},"edge/147.0.0.0":{"?0":1},"safari/26.4":{"*MISSING_VALUE*":1},"safari/26.3":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"?0":0.9977116704805492,"*MISSING_VALUE*":0.002288329519450801},"firefox/150.0":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1},"safari/26.0.1":{"*MISSING_VALUE*":1},"firefox/135.0":{"*MISSING_VALUE*":0.95,"?0":0.05},"chrome/148.0.0.0":{"?0":1},"chrome/142.0.0.0":{"?0":1},"safari/18.3":{"*MISSING_VALUE*":1},"chrome/144.0.0.0":{"?0":1},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"edge/129.0.0.0":{"?0":1},"safari/18.1":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"chrome/145.0.0.0":{"?0":1},"chrome/127.0.0.0":{"?0":1},"safari/16.6":{"*MISSING_VALUE*":1},"chrome/141.0.0.0":{"?0":1},"chrome/121.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/128.0.0.0":{"?0":1},"safari/17.2.1":{"*MISSING_VALUE*":1},"safari/26.5":{"*MISSING_VALUE*":1},"chrome/116.0.0.0":{"?0":1},"chrome/138.0.0.0":{"?0":1},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"firefox/151.0":{"*MISSING_VALUE*":1},"chrome/130.0.0.0":{"?0":1},"chrome/115.0.0.0":{"?0":1},"edge/146.0.0.0":{"?0":1},"chrome/149.0.0.0":{"?0":1},"chrome/140.0.0.0":{"?0":1},"safari/16.4":{"*MISSING_VALUE*":1},"safari/18.1.1":{"*MISSING_VALUE*":1},"edge/144.0.0.0":{"?0":1},"edge/128.0.0.0":{"?0":1},"chrome/109.0.0.0":{"?0":1},"chrome/139.0.0.0":{"?0":1},"edge/143.0.0.0":{"?0":1},"safari/17.4":{"*MISSING_VALUE*":1},"chrome/131.0.0.0":{"?0":1},"safari/18.4":{"*MISSING_VALUE*":1},"safari/18.0.1":{"*MISSING_VALUE*":1},"chrome/134.0.0.0":{"?0":1},"safari/16.5.2":{"*MISSING_VALUE*":1},"chrome/120.0.0.0":{"?0":1},"chrome/137.0.0.0":{"?0":1},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"firefox/147.0":{"*MISSING_VALUE*":1},"edge/145.0.0.0":{"?0":1},"chrome/135.0.0.0":{"?0":1},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/91.0.4450.0":{"*MISSING_VALUE*":1},"chrome/125.0.0.0":{"?0":1},"chrome/126.0.0.0":{"?0":1},"chrome/113.0.0.0":{"?0":1},"chrome/101.0.4951.54":{"*MISSING_VALUE*":1},"chrome/108.0.0.0":{"?0":1},"edge/148.0.0.0":{"?0":1},"chrome/147.0.7727.56":{"?0":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"edge/123.0.0.0":{"?0":1},"chrome/136.0.0.0":{"?0":1},"safari/18.3.1":{"*MISSING_VALUE*":1},"edge/138.0.0.0":{"?0":1},"chrome/114.0.0.0":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/138.0.7204.235":{"*MISSING_VALUE*":1},"safari/17.3":{"*MISSING_VALUE*":1},"edge/142.0.0.0":{"?0":1},"firefox/149.0":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"safari/17.3.1":{"*MISSING_VALUE*":1},"chrome/124.0.0.0":{"?0":1},"chrome/122.0.0.0":{"?0":1},"chrome/107.0.0.0":{"?0":1},"firefox/146.0":{"*MISSING_VALUE*":1},"edge/122.0.0.0":{"?0":1},"chrome/103.0.0.0":{"?0":1},"chrome/90.0.4430.212":{"*MISSING_VALUE*":1},"safari/17.1.2":{"*MISSING_VALUE*":1},"chrome/132.0.0.0":{"?0":1},"safari/18.0":{"*MISSING_VALUE*":1},"chrome/133.0.0.0":{"?0":1},"firefox/142.0":{"*MISSING_VALUE*":1},"safari/17.0":{"*MISSING_VALUE*":1},"safari/17.1":{"*MISSING_VALUE*":1},"safari/15.6.1":{"*MISSING_VALUE*":1},"safari/17.2":{"*MISSING_VALUE*":1},"edge/135.0.3179.54":{"?0":1},"chrome/106.0.0.0":{"?0":1},"safari/16.1":{"*MISSING_VALUE*":1},"chrome/91.0.4472.124":{"*MISSING_VALUE*":1},"chrome/132.0.6788.76":{"?0":1},"safari/16.3":{"*MISSING_VALUE*":1}},"skip":{"?0":0.8921915546119368,"*MISSING_VALUE*":0.10780844538806322}}},"mobile":{"deeper":{"ios":{"deeper":{"safari/26.4":{"*MISSING_VALUE*":0.9964285714285714,"?0":0.0035714285714285713},"safari/26.3":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"?0":0.07692307692307693,"*MISSING_VALUE*":0.9230769230769231},"safari/26.0.1":{"*MISSING_VALUE*":1},"safari/18.3":{"*MISSING_VALUE*":1},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"safari/18.7":{"*MISSING_VALUE*":1},"safari/18.7.4":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"safari/18.7.5":{"*MISSING_VALUE*":1},"safari/26.5":{"*MISSING_VALUE*":1},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"safari/18.4":{"*MISSING_VALUE*":1},"safari/26.4.2":{"*MISSING_VALUE*":1},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/45.0.8909.1591":{"*MISSING_VALUE*":1},"safari/17.7":{"*MISSING_VALUE*":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"safari/16.6.2":{"*MISSING_VALUE*":1},"safari/18.3.1":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/144.0.7559.95":{"*MISSING_VALUE*":1},"safari/18.7.3":{"*MISSING_VALUE*":1},"safari/17.8":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"safari/15.6.7":{"*MISSING_VALUE*":1},"safari/16.2":{"*MISSING_VALUE*":1},"safari/18.0":{"*MISSING_VALUE*":1},"safari/18.7.7":{"*MISSING_VALUE*":1},"safari/18.7.2":{"*MISSING_VALUE*":1},"safari/18.4.1":{"*MISSING_VALUE*":1},"safari/26.4.1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.9980638915779284,"?0":0.001936108422071636}},"android":{"deeper":{"chrome/147.0.0.0":{"?1":0.984251968503937,"?0":0.015748031496062992},"edge/147.0.0.0":{"?1":1},"chrome/146.0.0.0":{"?1":0.3333333333333333,"?0":0.6666666666666666},"firefox/150.0":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"?1":1},"chrome/144.0.0.0":{"?1":1},"chrome/145.0.0.0":{"?1":1},"chrome/143.0.0.0":{"?1":1},"chrome/138.0.0.0":{"?1":1},"edge/143.0.0.0":{"?1":1},"chrome/134.0.0.0":{"?1":1},"chrome/120.0.0.0":{"?1":1},"chrome/137.0.0.0":{"?1":1},"chrome/119.0.0.0":{"?1":1},"chrome/142.0.7444.138":{"?1":1},"firefox/136.0":{"*MISSING_VALUE*":1},"chrome/59.0.9273.1293":{"*MISSING_VALUE*":1},"chrome/138.0.7204.63":{"*MISSING_VALUE*":1},"chrome/147.0.7727.111":{"?1":0.16666666666666666,"*MISSING_VALUE*":0.8333333333333334},"chrome/130.0.6723.73":{"?1":1}},"skip":{"?1":0.9244712990936556,"*MISSING_VALUE*":0.05740181268882175,"?0":0.01812688821752266}}},"skip":{"deeper":{"chrome/147.0.0.0":{"?1":0.984251968503937,"?0":0.015748031496062992},"edge/147.0.0.0":{"?1":1},"safari/26.4":{"*MISSING_VALUE*":0.9964285714285714,"?0":0.0035714285714285713},"safari/26.3":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"?1":0.3333333333333333,"?0":0.6666666666666666},"firefox/150.0":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"?0":0.07692307692307693,"*MISSING_VALUE*":0.9230769230769231},"safari/26.0.1":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"?1":1},"safari/18.3":{"*MISSING_VALUE*":1},"chrome/144.0.0.0":{"?1":1},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"safari/18.7":{"*MISSING_VALUE*":1},"safari/18.7.4":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"safari/18.7.5":{"*MISSING_VALUE*":1},"chrome/145.0.0.0":{"?1":1},"chrome/143.0.0.0":{"?1":1},"safari/26.5":{"*MISSING_VALUE*":1},"chrome/138.0.0.0":{"?1":1},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"edge/143.0.0.0":{"?1":1},"safari/18.4":{"*MISSING_VALUE*":1},"chrome/134.0.0.0":{"?1":1},"safari/26.4.2":{"*MISSING_VALUE*":1},"chrome/120.0.0.0":{"?1":1},"chrome/137.0.0.0":{"?1":1},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/45.0.8909.1591":{"*MISSING_VALUE*":1},"safari/17.7":{"*MISSING_VALUE*":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"safari/16.6.2":{"*MISSING_VALUE*":1},"chrome/119.0.0.0":{"?1":1},"chrome/142.0.7444.138":{"?1":1},"safari/18.3.1":{"*MISSING_VALUE*":1},"firefox/136.0":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/59.0.9273.1293":{"*MISSING_VALUE*":1},"chrome/144.0.7559.95":{"*MISSING_VALUE*":1},"safari/18.7.3":{"*MISSING_VALUE*":1},"chrome/138.0.7204.63":{"*MISSING_VALUE*":1},"safari/17.8":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"chrome/147.0.7727.111":{"?1":0.16666666666666666,"*MISSING_VALUE*":0.8333333333333334},"safari/15.6.7":{"*MISSING_VALUE*":1},"safari/16.2":{"*MISSING_VALUE*":1},"safari/18.0":{"*MISSING_VALUE*":1},"chrome/130.0.6723.73":{"?1":1},"safari/18.7.7":{"*MISSING_VALUE*":1},"safari/18.7.2":{"*MISSING_VALUE*":1},"safari/18.4.1":{"*MISSING_VALUE*":1},"safari/26.4.1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.7697947214076246,"?1":0.22434017595307917,"?0":0.005865102639296188}}}}},"_1.1_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"?0":1},"safari/26.4":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.23076923076923078,"?0":0.7692307692307693}},"windows":{"deeper":{"chrome/147.0.0.0":{"?0":1},"edge/147.0.0.0":{"?0":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"chrome/146.0.0.0":{"?0":1},"chrome/142.0.0.0":{"?0":1},"chrome/145.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"?0":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1}},"skip":{"?0":0.967741935483871,"*MISSING_VALUE*":0.03225806451612903}},"linux":{"deeper":{"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"?0":1}},"skip":{"?0":1}}},"skip":{"deeper":{"chrome/147.0.0.0":{"?0":1},"edge/147.0.0.0":{"?0":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"safari/26.4":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"?0":1},"safari/18.5":{"*MISSING_VALUE*":1},"chrome/142.0.0.0":{"?0":1},"chrome/145.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"?0":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1},"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"?0":0.9099099099099099,"*MISSING_VALUE*":0.09009009009009009}}}},"skip":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"?0":1},"safari/26.4":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.23076923076923078,"?0":0.7692307692307693}},"windows":{"deeper":{"chrome/147.0.0.0":{"?0":1},"edge/147.0.0.0":{"?0":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"chrome/146.0.0.0":{"?0":1},"chrome/142.0.0.0":{"?0":1},"chrome/145.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"?0":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1}},"skip":{"?0":0.967741935483871,"*MISSING_VALUE*":0.03225806451612903}},"linux":{"deeper":{"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"?0":1}},"skip":{"?0":1}}},"skip":{"deeper":{"chrome/147.0.0.0":{"?0":1},"edge/147.0.0.0":{"?0":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"safari/26.4":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"?0":1},"safari/18.5":{"*MISSING_VALUE*":1},"chrome/142.0.0.0":{"?0":1},"chrome/145.0.0.0":{"?0":1},"chrome/143.0.0.0":{"?0":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"?0":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1},"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"?0":0.9099099099099099,"*MISSING_VALUE*":0.09009009009009009}}}}}}},{"name":"sec-ch-ua-platform","parentNames":["*HTTP_VERSION","*DEVICE","*OPERATING_SYSTEM","*BROWSER"],"possibleValues":["\"macOS\"","\"Windows\"","*MISSING_VALUE*","\"Android\"","\"iOS\"","\"Linux\"","\"Chrome OS\""],"conditionalProbabilities":{"deeper":{"_2.0_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"\"macOS\"":0.9977548271216884,"*MISSING_VALUE*":0.00224517287831163},"edge/147.0.0.0":{"\"macOS\"":1},"safari/26.4":{"*MISSING_VALUE*":1},"safari/26.3":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"\"macOS\"":1},"firefox/150.0":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1},"safari/26.0.1":{"*MISSING_VALUE*":1},"firefox/135.0":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"\"macOS\"":1},"chrome/142.0.0.0":{"\"macOS\"":1},"safari/18.3":{"*MISSING_VALUE*":1},"chrome/144.0.0.0":{"\"macOS\"":1},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"safari/18.1":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"chrome/145.0.0.0":{"\"macOS\"":1},"chrome/127.0.0.0":{"\"macOS\"":1},"safari/16.6":{"*MISSING_VALUE*":1},"chrome/141.0.0.0":{"\"macOS\"":1},"chrome/143.0.0.0":{"\"macOS\"":1},"chrome/128.0.0.0":{"\"macOS\"":1},"safari/17.2.1":{"*MISSING_VALUE*":1},"safari/26.5":{"*MISSING_VALUE*":1},"chrome/116.0.0.0":{"\"macOS\"":1},"chrome/138.0.0.0":{"\"macOS\"":1},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"firefox/151.0":{"*MISSING_VALUE*":1},"chrome/130.0.0.0":{"\"macOS\"":1},"chrome/115.0.0.0":{"\"macOS\"":1},"chrome/149.0.0.0":{"\"macOS\"":1},"chrome/140.0.0.0":{"\"macOS\"":1},"safari/16.4":{"*MISSING_VALUE*":1},"safari/18.1.1":{"*MISSING_VALUE*":1},"chrome/139.0.0.0":{"\"macOS\"":1},"safari/17.4":{"*MISSING_VALUE*":1},"chrome/131.0.0.0":{"\"macOS\"":1},"safari/18.4":{"*MISSING_VALUE*":1},"safari/18.0.1":{"*MISSING_VALUE*":1},"safari/16.5.2":{"*MISSING_VALUE*":1},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"firefox/147.0":{"*MISSING_VALUE*":1},"chrome/135.0.0.0":{"\"macOS\"":1},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/91.0.4450.0":{"*MISSING_VALUE*":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"safari/18.3.1":{"*MISSING_VALUE*":1},"chrome/114.0.0.0":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/138.0.7204.235":{"*MISSING_VALUE*":1},"safari/17.3":{"*MISSING_VALUE*":1},"firefox/149.0":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"safari/17.3.1":{"*MISSING_VALUE*":1},"chrome/107.0.0.0":{"\"Linux\"":1},"chrome/103.0.0.0":{"\"macOS\"":1},"safari/17.1.2":{"*MISSING_VALUE*":1},"safari/18.0":{"*MISSING_VALUE*":1},"safari/17.0":{"*MISSING_VALUE*":1},"safari/17.1":{"*MISSING_VALUE*":1},"safari/15.6.1":{"*MISSING_VALUE*":1},"safari/17.2":{"*MISSING_VALUE*":1},"safari/16.1":{"*MISSING_VALUE*":1},"safari/16.3":{"*MISSING_VALUE*":1}},"skip":{"\"macOS\"":0.6792127921279213,"*MISSING_VALUE*":0.3202952029520295,"\"Linux\"":0.0004920049200492004}},"windows":{"deeper":{"chrome/147.0.0.0":{"\"Windows\"":1},"edge/147.0.0.0":{"\"Windows\"":1},"chrome/146.0.0.0":{"\"Windows\"":0.9910714285714286,"*MISSING_VALUE*":0.008928571428571428},"firefox/150.0":{"*MISSING_VALUE*":1},"firefox/135.0":{"*MISSING_VALUE*":0.9473684210526315,"\"Windows\"":0.05263157894736842},"chrome/148.0.0.0":{"\"Windows\"":1},"chrome/142.0.0.0":{"\"Windows\"":1},"chrome/144.0.0.0":{"\"Windows\"":1},"edge/129.0.0.0":{"\"Windows\"":1},"chrome/145.0.0.0":{"\"Windows\"":1},"chrome/127.0.0.0":{"\"Windows\"":1},"chrome/141.0.0.0":{"\"Windows\"":1},"chrome/121.0.0.0":{"\"Windows\"":1},"chrome/143.0.0.0":{"\"Windows\"":1},"chrome/128.0.0.0":{"\"Windows\"":1},"chrome/138.0.0.0":{"\"Windows\"":1},"chrome/130.0.0.0":{"\"Windows\"":1},"edge/146.0.0.0":{"\"Windows\"":1},"chrome/149.0.0.0":{"\"Windows\"":1},"chrome/140.0.0.0":{"\"Windows\"":1},"edge/144.0.0.0":{"\"Windows\"":1},"edge/128.0.0.0":{"\"Windows\"":1},"chrome/109.0.0.0":{"\"Windows\"":1},"chrome/139.0.0.0":{"\"Windows\"":1},"edge/143.0.0.0":{"\"Windows\"":1},"chrome/131.0.0.0":{"\"Windows\"":1},"chrome/134.0.0.0":{"\"Windows\"":1},"chrome/120.0.0.0":{"\"Windows\"":1},"chrome/137.0.0.0":{"\"Windows\"":1},"firefox/147.0":{"*MISSING_VALUE*":1},"edge/145.0.0.0":{"\"Windows\"":1},"chrome/135.0.0.0":{"\"Windows\"":1},"chrome/125.0.0.0":{"\"Windows\"":1},"chrome/126.0.0.0":{"\"Windows\"":1},"chrome/113.0.0.0":{"\"Windows\"":1},"chrome/108.0.0.0":{"\"Windows\"":1},"edge/148.0.0.0":{"\"Windows\"":1},"chrome/147.0.7727.56":{"\"Windows\"":1},"edge/123.0.0.0":{"\"Windows\"":1},"chrome/136.0.0.0":{"\"Windows\"":1},"edge/138.0.0.0":{"\"Windows\"":1},"edge/142.0.0.0":{"\"Windows\"":1},"firefox/149.0":{"*MISSING_VALUE*":1},"chrome/124.0.0.0":{"\"Windows\"":1},"chrome/122.0.0.0":{"\"Windows\"":1},"edge/122.0.0.0":{"\"Windows\"":1},"chrome/132.0.0.0":{"\"Windows\"":1},"chrome/133.0.0.0":{"\"Windows\"":1},"edge/135.0.3179.54":{"\"Windows\"":1},"chrome/106.0.0.0":{"\"Windows\"":1},"chrome/91.0.4472.124":{"*MISSING_VALUE*":1},"chrome/132.0.6788.76":{"\"Windows\"":1}},"skip":{"\"Windows\"":0.9953113729261842,"*MISSING_VALUE*":0.004688627073815821}},"linux":{"deeper":{"chrome/147.0.0.0":{"\"Linux\"":1},"edge/147.0.0.0":{"\"Linux\"":1},"chrome/146.0.0.0":{"\"Linux\"":1},"firefox/150.0":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"\"Linux\"":1},"chrome/142.0.0.0":{"\"Linux\"":1},"chrome/144.0.0.0":{"\"Linux\"":1},"chrome/145.0.0.0":{"\"Linux\"":1},"chrome/141.0.0.0":{"\"Linux\"":1},"chrome/143.0.0.0":{"\"Linux\"":1},"chrome/138.0.0.0":{"\"Linux\"":1},"chrome/130.0.0.0":{"\"Linux\"":1},"chrome/149.0.0.0":{"\"Linux\"":1},"chrome/140.0.0.0":{"\"Linux\"":1},"edge/143.0.0.0":{"\"Linux\"":1},"chrome/131.0.0.0":{"\"Linux\"":1},"chrome/134.0.0.0":{"\"Linux\"":1},"chrome/137.0.0.0":{"\"Linux\"":1},"edge/145.0.0.0":{"\"Linux\"":1},"chrome/135.0.0.0":{"\"Linux\"":1},"chrome/126.0.0.0":{"\"Linux\"":1},"chrome/101.0.4951.54":{"*MISSING_VALUE*":1},"chrome/136.0.0.0":{"\"Linux\"":1},"firefox/149.0":{"*MISSING_VALUE*":1},"firefox/146.0":{"*MISSING_VALUE*":1},"chrome/90.0.4430.212":{"*MISSING_VALUE*":1},"firefox/142.0":{"*MISSING_VALUE*":1}},"skip":{"\"Linux\"":0.9065420560747663,"*MISSING_VALUE*":0.09345794392523364}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"\"Chrome OS\"":1},"chrome/146.0.0.0":{"\"Chrome OS\"":1},"chrome/144.0.0.0":{"\"Chrome OS\"":1},"chrome/126.0.0.0":{"\"Chrome OS\"":1}},"skip":{"\"Chrome OS\"":1}}},"skip":{"deeper":{"chrome/147.0.0.0":{"\"macOS\"":0.2438274991769999,"\"Windows\"":0.734993964665862,"\"Linux\"":0.01975200263360035,"\"Chrome OS\"":0.0008778667837155712,"*MISSING_VALUE*":0.000548666739822232},"edge/147.0.0.0":{"\"Windows\"":0.9763694951664876,"\"macOS\"":0.022556390977443608,"\"Linux\"":0.0010741138560687433},"safari/26.4":{"*MISSING_VALUE*":1},"safari/26.3":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"\"macOS\"":0.6407322654462243,"\"Linux\"":0.09839816933638444,"\"Windows\"":0.2540045766590389,"*MISSING_VALUE*":0.002288329519450801,"\"Chrome OS\"":0.004576659038901602},"firefox/150.0":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1},"safari/26.0.1":{"*MISSING_VALUE*":1},"firefox/135.0":{"*MISSING_VALUE*":0.95,"\"Windows\"":0.05},"chrome/148.0.0.0":{"\"Windows\"":0.7142857142857143,"\"Linux\"":0.02040816326530612,"\"macOS\"":0.2653061224489796},"chrome/142.0.0.0":{"\"Windows\"":0.944954128440367,"\"Linux\"":0.01834862385321101,"\"macOS\"":0.03669724770642202},"safari/18.3":{"*MISSING_VALUE*":1},"chrome/144.0.0.0":{"\"macOS\"":0.46153846153846156,"\"Windows\"":0.3269230769230769,"\"Linux\"":0.19230769230769232,"\"Chrome OS\"":0.019230769230769232},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"edge/129.0.0.0":{"\"Windows\"":1},"safari/18.1":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"chrome/145.0.0.0":{"\"Linux\"":0.09523809523809523,"\"Windows\"":0.46320346320346323,"\"macOS\"":0.44155844155844154},"chrome/127.0.0.0":{"\"Windows\"":0.3333333333333333,"\"macOS\"":0.6666666666666666},"safari/16.6":{"*MISSING_VALUE*":1},"chrome/141.0.0.0":{"\"Windows\"":0.75,"\"macOS\"":0.2,"\"Linux\"":0.05},"chrome/121.0.0.0":{"\"Windows\"":1},"chrome/143.0.0.0":{"\"macOS\"":0.4716981132075472,"\"Windows\"":0.4339622641509434,"\"Linux\"":0.09433962264150944},"chrome/128.0.0.0":{"\"macOS\"":0.625,"\"Windows\"":0.375},"safari/17.2.1":{"*MISSING_VALUE*":1},"safari/26.5":{"*MISSING_VALUE*":1},"chrome/116.0.0.0":{"\"macOS\"":1},"chrome/138.0.0.0":{"\"macOS\"":0.5957446808510638,"\"Windows\"":0.3404255319148936,"\"Linux\"":0.06382978723404255},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"firefox/151.0":{"*MISSING_VALUE*":1},"chrome/130.0.0.0":{"\"Linux\"":0.25,"\"Windows\"":0.5,"\"macOS\"":0.25},"chrome/115.0.0.0":{"\"macOS\"":1},"edge/146.0.0.0":{"\"Windows\"":1},"chrome/149.0.0.0":{"\"macOS\"":0.18181818181818182,"\"Windows\"":0.6363636363636364,"\"Linux\"":0.18181818181818182},"chrome/140.0.0.0":{"\"Windows\"":0.5714285714285714,"\"Linux\"":0.21428571428571427,"\"macOS\"":0.21428571428571427},"safari/16.4":{"*MISSING_VALUE*":1},"safari/18.1.1":{"*MISSING_VALUE*":1},"edge/144.0.0.0":{"\"Windows\"":1},"edge/128.0.0.0":{"\"Windows\"":1},"chrome/109.0.0.0":{"\"Windows\"":1},"chrome/139.0.0.0":{"\"Windows\"":0.8461538461538461,"\"macOS\"":0.15384615384615385},"edge/143.0.0.0":{"\"Windows\"":0.8888888888888888,"\"Linux\"":0.1111111111111111},"safari/17.4":{"*MISSING_VALUE*":1},"chrome/131.0.0.0":{"\"Windows\"":0.36363636363636365,"\"Linux\"":0.45454545454545453,"\"macOS\"":0.18181818181818182},"safari/18.4":{"*MISSING_VALUE*":1},"safari/18.0.1":{"*MISSING_VALUE*":1},"chrome/134.0.0.0":{"\"Windows\"":0.75,"\"Linux\"":0.25},"safari/16.5.2":{"*MISSING_VALUE*":1},"chrome/120.0.0.0":{"\"Windows\"":1},"chrome/137.0.0.0":{"\"Windows\"":0.8,"\"Linux\"":0.2},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"firefox/147.0":{"*MISSING_VALUE*":1},"edge/145.0.0.0":{"\"Windows\"":0.8,"\"Linux\"":0.2},"chrome/135.0.0.0":{"\"Windows\"":0.8181818181818182,"\"macOS\"":0.09090909090909091,"\"Linux\"":0.09090909090909091},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/91.0.4450.0":{"*MISSING_VALUE*":1},"chrome/125.0.0.0":{"\"Windows\"":1},"chrome/126.0.0.0":{"\"Windows\"":0.5555555555555556,"\"Linux\"":0.2222222222222222,"\"Chrome OS\"":0.2222222222222222},"chrome/113.0.0.0":{"\"Windows\"":1},"chrome/101.0.4951.54":{"*MISSING_VALUE*":1},"chrome/108.0.0.0":{"\"Windows\"":1},"edge/148.0.0.0":{"\"Windows\"":1},"chrome/147.0.7727.56":{"\"Windows\"":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"edge/123.0.0.0":{"\"Windows\"":1},"chrome/136.0.0.0":{"\"Windows\"":0.8333333333333334,"\"Linux\"":0.16666666666666666},"safari/18.3.1":{"*MISSING_VALUE*":1},"edge/138.0.0.0":{"\"Windows\"":1},"chrome/114.0.0.0":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/138.0.7204.235":{"*MISSING_VALUE*":1},"safari/17.3":{"*MISSING_VALUE*":1},"edge/142.0.0.0":{"\"Windows\"":1},"firefox/149.0":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"safari/17.3.1":{"*MISSING_VALUE*":1},"chrome/124.0.0.0":{"\"Windows\"":1},"chrome/122.0.0.0":{"\"Windows\"":1},"chrome/107.0.0.0":{"\"Linux\"":1},"firefox/146.0":{"*MISSING_VALUE*":1},"edge/122.0.0.0":{"\"Windows\"":1},"chrome/103.0.0.0":{"\"macOS\"":1},"chrome/90.0.4430.212":{"*MISSING_VALUE*":1},"safari/17.1.2":{"*MISSING_VALUE*":1},"chrome/132.0.0.0":{"\"Windows\"":1},"safari/18.0":{"*MISSING_VALUE*":1},"chrome/133.0.0.0":{"\"Windows\"":1},"firefox/142.0":{"*MISSING_VALUE*":1},"safari/17.0":{"*MISSING_VALUE*":1},"safari/17.1":{"*MISSING_VALUE*":1},"safari/15.6.1":{"*MISSING_VALUE*":1},"safari/17.2":{"*MISSING_VALUE*":1},"edge/135.0.3179.54":{"\"Windows\"":1},"chrome/106.0.0.0":{"\"Windows\"":1},"safari/16.1":{"*MISSING_VALUE*":1},"chrome/91.0.4472.124":{"*MISSING_VALUE*":1},"chrome/132.0.6788.76":{"\"Windows\"":1},"safari/16.3":{"*MISSING_VALUE*":1}},"skip":{"\"macOS\"":0.21711095384131476,"\"Windows\"":0.6510183219312731,"*MISSING_VALUE*":0.10780844538806322,"\"Linux\"":0.023040025163167412,"\"Chrome OS\"":0.0010222536761814894}}},"mobile":{"deeper":{"ios":{"deeper":{"safari/26.4":{"*MISSING_VALUE*":0.9964285714285714,"\"iOS\"":0.0035714285714285713},"safari/26.3":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"\"iOS\"":0.07692307692307693,"*MISSING_VALUE*":0.9230769230769231},"safari/26.0.1":{"*MISSING_VALUE*":1},"safari/18.3":{"*MISSING_VALUE*":1},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"safari/18.7":{"*MISSING_VALUE*":1},"safari/18.7.4":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"safari/18.7.5":{"*MISSING_VALUE*":1},"safari/26.5":{"*MISSING_VALUE*":1},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"safari/18.4":{"*MISSING_VALUE*":1},"safari/26.4.2":{"*MISSING_VALUE*":1},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/45.0.8909.1591":{"*MISSING_VALUE*":1},"safari/17.7":{"*MISSING_VALUE*":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"safari/16.6.2":{"*MISSING_VALUE*":1},"safari/18.3.1":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/144.0.7559.95":{"*MISSING_VALUE*":1},"safari/18.7.3":{"*MISSING_VALUE*":1},"safari/17.8":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"safari/15.6.7":{"*MISSING_VALUE*":1},"safari/16.2":{"*MISSING_VALUE*":1},"safari/18.0":{"*MISSING_VALUE*":1},"safari/18.7.7":{"*MISSING_VALUE*":1},"safari/18.7.2":{"*MISSING_VALUE*":1},"safari/18.4.1":{"*MISSING_VALUE*":1},"safari/26.4.1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.9980638915779284,"\"iOS\"":0.001936108422071636}},"android":{"deeper":{"chrome/147.0.0.0":{"\"Android\"":1},"edge/147.0.0.0":{"\"Android\"":1},"chrome/146.0.0.0":{"\"Android\"":1},"firefox/150.0":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"\"Android\"":1},"chrome/144.0.0.0":{"\"Android\"":1},"chrome/145.0.0.0":{"\"Android\"":1},"chrome/143.0.0.0":{"\"Android\"":1},"chrome/138.0.0.0":{"\"Android\"":1},"edge/143.0.0.0":{"\"Android\"":1},"chrome/134.0.0.0":{"\"Android\"":1},"chrome/120.0.0.0":{"\"Android\"":1},"chrome/137.0.0.0":{"\"Android\"":1},"chrome/119.0.0.0":{"\"Android\"":1},"chrome/142.0.7444.138":{"\"Android\"":1},"firefox/136.0":{"*MISSING_VALUE*":1},"chrome/59.0.9273.1293":{"*MISSING_VALUE*":1},"chrome/138.0.7204.63":{"*MISSING_VALUE*":1},"chrome/147.0.7727.111":{"\"Android\"":0.16666666666666666,"*MISSING_VALUE*":0.8333333333333334},"chrome/130.0.6723.73":{"\"Android\"":1}},"skip":{"\"Android\"":0.9425981873111783,"*MISSING_VALUE*":0.05740181268882175}}},"skip":{"deeper":{"chrome/147.0.0.0":{"\"Android\"":1},"edge/147.0.0.0":{"\"Android\"":1},"safari/26.4":{"*MISSING_VALUE*":0.9964285714285714,"\"iOS\"":0.0035714285714285713},"safari/26.3":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"\"Android\"":1},"firefox/150.0":{"*MISSING_VALUE*":1},"safari/26.2":{"*MISSING_VALUE*":1},"safari/18.5":{"\"iOS\"":0.07692307692307693,"*MISSING_VALUE*":0.9230769230769231},"safari/26.0.1":{"*MISSING_VALUE*":1},"chrome/148.0.0.0":{"\"Android\"":1},"safari/18.3":{"*MISSING_VALUE*":1},"chrome/144.0.0.0":{"\"Android\"":1},"safari/18.2":{"*MISSING_VALUE*":1},"safari/26.3.1":{"*MISSING_VALUE*":1},"safari/18.7":{"*MISSING_VALUE*":1},"safari/18.7.4":{"*MISSING_VALUE*":1},"safari/18.6":{"*MISSING_VALUE*":1},"safari/18.7.5":{"*MISSING_VALUE*":1},"chrome/145.0.0.0":{"\"Android\"":1},"chrome/143.0.0.0":{"\"Android\"":1},"safari/26.5":{"*MISSING_VALUE*":1},"chrome/138.0.0.0":{"\"Android\"":1},"safari/26.1":{"*MISSING_VALUE*":1},"safari/17.6":{"*MISSING_VALUE*":1},"edge/143.0.0.0":{"\"Android\"":1},"safari/18.4":{"*MISSING_VALUE*":1},"chrome/134.0.0.0":{"\"Android\"":1},"safari/26.4.2":{"*MISSING_VALUE*":1},"chrome/120.0.0.0":{"\"Android\"":1},"chrome/137.0.0.0":{"\"Android\"":1},"safari/26.0":{"*MISSING_VALUE*":1},"safari/16.6.1":{"*MISSING_VALUE*":1},"safari/17.5":{"*MISSING_VALUE*":1},"chrome/45.0.8909.1591":{"*MISSING_VALUE*":1},"safari/17.7":{"*MISSING_VALUE*":1},"safari/17.4.1":{"*MISSING_VALUE*":1},"safari/16.6.2":{"*MISSING_VALUE*":1},"chrome/119.0.0.0":{"\"Android\"":1},"chrome/142.0.7444.138":{"\"Android\"":1},"safari/18.3.1":{"*MISSING_VALUE*":1},"firefox/136.0":{"*MISSING_VALUE*":1},"safari/16.5":{"*MISSING_VALUE*":1},"chrome/59.0.9273.1293":{"*MISSING_VALUE*":1},"chrome/144.0.7559.95":{"*MISSING_VALUE*":1},"safari/18.7.3":{"*MISSING_VALUE*":1},"chrome/138.0.7204.63":{"*MISSING_VALUE*":1},"safari/17.8":{"*MISSING_VALUE*":1},"safari/15.6.8":{"*MISSING_VALUE*":1},"chrome/147.0.7727.111":{"\"Android\"":0.16666666666666666,"*MISSING_VALUE*":0.8333333333333334},"safari/15.6.7":{"*MISSING_VALUE*":1},"safari/16.2":{"*MISSING_VALUE*":1},"safari/18.0":{"*MISSING_VALUE*":1},"chrome/130.0.6723.73":{"\"Android\"":1},"safari/18.7.7":{"*MISSING_VALUE*":1},"safari/18.7.2":{"*MISSING_VALUE*":1},"safari/18.4.1":{"*MISSING_VALUE*":1},"safari/26.4.1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.7697947214076246,"\"Android\"":0.2287390029325513,"\"iOS\"":0.001466275659824047}}}}},"_1.1_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"\"macOS\"":1},"safari/26.4":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.23076923076923078,"\"macOS\"":0.7692307692307693}},"windows":{"deeper":{"chrome/147.0.0.0":{"\"Windows\"":1},"edge/147.0.0.0":{"\"Windows\"":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"chrome/146.0.0.0":{"\"Windows\"":1},"chrome/142.0.0.0":{"\"Windows\"":1},"chrome/145.0.0.0":{"\"Windows\"":1},"chrome/143.0.0.0":{"\"Windows\"":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"\"Windows\"":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1}},"skip":{"\"Windows\"":0.967741935483871,"*MISSING_VALUE*":0.03225806451612903}},"linux":{"deeper":{"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"\"Chrome OS\"":1}},"skip":{"\"Chrome OS\"":1}}},"skip":{"deeper":{"chrome/147.0.0.0":{"\"Windows\"":0.8405797101449275,"\"Chrome OS\"":0.014492753623188406,"\"macOS\"":0.14492753623188406},"edge/147.0.0.0":{"\"Windows\"":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"safari/26.4":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"\"Windows\"":1},"safari/18.5":{"*MISSING_VALUE*":1},"chrome/142.0.0.0":{"\"Windows\"":1},"chrome/145.0.0.0":{"\"Windows\"":1},"chrome/143.0.0.0":{"\"Windows\"":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"\"Windows\"":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1},"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"\"Windows\"":0.8108108108108109,"\"Chrome OS\"":0.009009009009009009,"*MISSING_VALUE*":0.09009009009009009,"\"macOS\"":0.09009009009009009}}}},"skip":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"\"macOS\"":1},"safari/26.4":{"*MISSING_VALUE*":1},"safari/18.5":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.23076923076923078,"\"macOS\"":0.7692307692307693}},"windows":{"deeper":{"chrome/147.0.0.0":{"\"Windows\"":1},"edge/147.0.0.0":{"\"Windows\"":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"chrome/146.0.0.0":{"\"Windows\"":1},"chrome/142.0.0.0":{"\"Windows\"":1},"chrome/145.0.0.0":{"\"Windows\"":1},"chrome/143.0.0.0":{"\"Windows\"":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"\"Windows\"":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1}},"skip":{"\"Windows\"":0.967741935483871,"*MISSING_VALUE*":0.03225806451612903}},"linux":{"deeper":{"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"\"Chrome OS\"":1}},"skip":{"\"Chrome OS\"":1}}},"skip":{"deeper":{"chrome/147.0.0.0":{"\"Windows\"":0.8405797101449275,"\"Chrome OS\"":0.014492753623188406,"\"macOS\"":0.14492753623188406},"edge/147.0.0.0":{"\"Windows\"":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555},"safari/26.4":{"*MISSING_VALUE*":1},"chrome/146.0.0.0":{"\"Windows\"":1},"safari/18.5":{"*MISSING_VALUE*":1},"chrome/142.0.0.0":{"\"Windows\"":1},"chrome/145.0.0.0":{"\"Windows\"":1},"chrome/143.0.0.0":{"\"Windows\"":1},"chrome/116.0.0.0":{"*MISSING_VALUE*":1},"edge/146.0.0.0":{"\"Windows\"":1},"chrome/96.0.4664.110":{"*MISSING_VALUE*":1},"chrome/147.0.7727.116":{"*MISSING_VALUE*":1}},"skip":{"\"Windows\"":0.8108108108108109,"\"Chrome OS\"":0.009009009009009009,"*MISSING_VALUE*":0.09009009009009009,"\"macOS\"":0.09009009009009009}}}}}}},{"name":"user-agent","parentNames":["*HTTP_VERSION","*DEVICE","*OPERATING_SYSTEM","*BROWSER","sec-ch-ua-mobile"],"possibleValues":["Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15","*MISSING_VALUE*","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36","Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0","Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15","Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0","Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0","Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0","Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15","Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0","Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36","Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36","Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0","Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15","Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179","Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1","Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36","Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15","Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15","Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36","Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15","Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36","Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0","Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1","Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1","Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36","Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15","Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"],"conditionalProbabilities":{"deeper":{"_2.0_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":1}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":1}},"firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":1}},"chrome/148.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":1}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":1}},"safari/18.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"chrome/127.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":1}},"safari/16.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"chrome/128.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":1}},"safari/17.2.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":1}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":1}},"chrome/116.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":1}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":1}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":1}},"firefox/151.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":1}},"chrome/115.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":1}},"chrome/140.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":1}},"safari/16.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":1}},"safari/18.1.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":1}},"chrome/139.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":1}},"safari/17.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":1}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":1}},"safari/18.0.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":1}},"safari/16.5.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":1}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":1}},"firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":1}},"chrome/135.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":1}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":1}},"chrome/91.0.4450.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":1}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":1}},"chrome/114.0.0.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":1}},"chrome/138.0.7204.235":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":1}},"safari/17.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":1}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":1}},"safari/17.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":1}},"chrome/107.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":1}},"chrome/103.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":1}},"safari/17.1.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":1}},"safari/17.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":1}},"safari/17.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":1}},"safari/15.6.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":1}},"safari/17.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":1}},"safari/16.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":1}},"safari/16.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.8041983351429606,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.10133912414042708,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.008686210640608035,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.03691639522258415,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.009410061527325372,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.009048136083966703,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.0018096272167933405,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.0014477017734346724,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.010133912414042706,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":0.0003619254433586681,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.0007238508867173362,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.00760043431053203,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.0014477017734346724,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":0.0007238508867173362,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.0014477017734346724,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":0.0003619254433586681,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.0007238508867173362,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.0007238508867173362,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.0010857763300760044,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.0003619254433586681,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.0007238508867173362,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.0007238508867173362},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.2849462365591398,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":0.017665130568356373,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":0.08294930875576037,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":0.08602150537634409,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":0.020737327188940093,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":0.014592933947772658,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":0.0038402457757296467,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":0.19738863287250383,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":0.016897081413210446,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":0.10215053763440861,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":0.004608294930875576,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.028417818740399385,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":0.018433179723502304,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":0.0015360983102918587,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":0.020737327188940093,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":0.0015360983102918587,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":0.0038402457757296467,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":0.016897081413210446,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":0.002304147465437788,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":0.013824884792626729,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":0.0015360983102918587,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":0.0015360983102918587,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":0.009216589861751152,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":0.002304147465437788,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":0.0038402457757296467,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":0.002304147465437788,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.0038402457757296467,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":0.009216589861751152,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":0.0030721966205837174,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":0.002304147465437788,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":0.0030721966205837174,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":0.0030721966205837174,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":0.0030721966205837174,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":0.0015360983102918587,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":0.0015360983102918587,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":0.0007680491551459293,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":0.0007680491551459293}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5478474784747848,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.09126691266912669,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.06888068880688807,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":0.005658056580565805,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":0.026568265682656828,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":0.02755227552275523,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":0.006642066420664207,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":0.004674046740467405,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.005904059040590406,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":0.0012300123001230013,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":0.06322263222632227,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":0.005412054120541206,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":0.032718327183271834,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.025092250922509225,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.0063960639606396065,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":0.0014760147601476014,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.009102091020910209,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.006150061500615006,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.0012300123001230013,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.0009840098400984009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.006888068880688807,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":0.005904059040590406,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":0.006642066420664207,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":0.0012300123001230013,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":0.005412054120541206,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":0.0007380073800738007,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.0051660516605166054,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":0.004428044280442804,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":0.002952029520295203,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":0.0007380073800738007,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":0.0012300123001230013,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":0.0007380073800738007,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":0.002952029520295203,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":0.0009840098400984009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.0009840098400984009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":0.0007380073800738007,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":0.0009840098400984009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.0009840098400984009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":0.0009840098400984009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":0.0009840098400984009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.0007380073800738007,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.0004920049200492004,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":0.0002460024600246002,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":0.0002460024600246002}}},"windows":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.990990990990991,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.009009009009009009},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.9910714285714286,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.008928571428571428}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":1}},"firefox/135.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":1}},"chrome/148.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"edge/129.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"chrome/127.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":1}},"chrome/121.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"chrome/128.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":1}},"edge/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":1}},"chrome/140.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":1}},"edge/144.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":1}},"edge/128.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":1}},"chrome/109.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":1}},"chrome/139.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":1}},"edge/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":1}},"chrome/134.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":1}},"chrome/120.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":1}},"chrome/137.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":1}},"firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":1}},"edge/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":1}},"chrome/135.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":1}},"chrome/125.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":1}},"chrome/113.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":1}},"chrome/108.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":1}},"edge/148.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":1}},"chrome/147.0.7727.56":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":1}},"edge/123.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":1}},"chrome/136.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":1}},"edge/138.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":1}},"edge/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":1}},"chrome/124.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":1}},"chrome/122.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":1}},"edge/122.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":1}},"chrome/132.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":1}},"chrome/133.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":1}},"edge/135.0.3179.54":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":1}},"chrome/106.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":1}},"chrome/91.0.4472.124":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":1}},"chrome/132.0.6788.76":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.8090349075975359,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.10979586906631236,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.008455127430849136,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.012441116076820873,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":0.0003623626041792487,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.013286628819905786,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.012924266215726538,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.0018118130208962435,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":0.0004831501389056649,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.0030196883681604058,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.0019326005556226597,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.0009663002778113298,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":0.00024157506945283246,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":0.0030196883681604058,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.0013286628819905786,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.0009663002778113298,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.0004831501389056649,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.0007247252083584974,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.0004831501389056649,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":0.0003623626041792487,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.0009663002778113298,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.0004831501389056649,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.001087087812537746,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.0027781132987075735,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.002053388090349076,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":0.0012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.0006039376736320811,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":0.00024157506945283246,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":0.002174175625075492,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":0.0006039376736320811,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":0.0003623626041792487,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.0006039376736320811,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.0008455127430849137,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":0.00024157506945283246,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":0.0003623626041792487,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":0.0006039376736320811,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":0.0003623626041792487,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":0.0006039376736320811,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.0003623626041792487,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":0.00012078753472641623,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":0.00024157506945283246,"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":0.00012078753472641623},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.46153846153846156,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.02564102564102564,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":0.3076923076923077,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":0.05128205128205128,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":0.05128205128205128,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":0.10256410256410256}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.805241644626112,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.10928107718201491,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.0022842029333974513,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.008415484491464294,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.012382784323154605,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":0.0003606636210627555,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.013344553979321952,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.00012022120702091849,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.012863669151238278,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.0018033181053137774,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":0.00048088482808367395,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.0030055301755229622,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.0019235393123346958,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.0009617696561673479,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":0.00024044241404183698,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":0.00012022120702091849,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":0.0030055301755229622,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.0013224332772301035,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.0009617696561673479,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.00048088482808367395,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.000721327242125511,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.00048088482808367395,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":0.0003606636210627555,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.0009617696561673479,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.00048088482808367395,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.0010819908631882664,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.0027650877614811254,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.0020437605193556144,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":0.0012022120702091848,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.0006011060351045924,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":0.00012022120702091849,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":0.00024044241404183698,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":0.002163981726376533,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":0.0006011060351045924,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":0.0003606636210627555,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.0006011060351045924,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.0008415484491464295,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":0.00012022120702091849,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":0.00024044241404183698,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":0.001442654484251022,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":0.0003606636210627555,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":0.0006011060351045924,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.00012022120702091849,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":0.00012022120702091849,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":0.00024044241404183698,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":0.0003606636210627555,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":0.0006011060351045924,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.0003606636210627555,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":0.00012022120702091849,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":0.00024044241404183698,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":0.00024044241404183698,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":0.00048088482808367395,"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":0.00012022120702091849}}},"linux":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.8333333333333334,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.16666666666666666}},"skip":{"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.8333333333333334,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.16666666666666666}},"chrome/148.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":1}},"chrome/140.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":1}},"edge/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":1}},"chrome/134.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":1}},"chrome/137.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":1}},"edge/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":1}},"chrome/135.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":1}},"chrome/101.0.4951.54":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":1}},"chrome/136.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":1}},"firefox/146.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":1}},"chrome/90.0.4430.212":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":1}},"firefox/142.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6185567010309279,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.14776632302405499,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.006872852233676976,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.07560137457044673,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.006872852233676976,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.010309278350515464,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.01718213058419244,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.006872852233676976,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.03436426116838488,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.003436426116838488,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.006872852233676976,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.006872852233676976,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.003436426116838488,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.01718213058419244,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.006872852233676976,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.006872852233676976,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.003436426116838488,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.003436426116838488,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.003436426116838488,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.010309278350515464,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.003436426116838488},"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":0.3333333333333333,"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.3333333333333333,"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":0.1,"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":0.06666666666666667,"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":0.03333333333333333,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.06666666666666667,"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":0.06666666666666667}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5607476635514018,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.13395638629283488,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.06853582554517133,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.009345794392523364,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.01557632398753894,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":0.03115264797507788,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.03115264797507788,"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.03115264797507788,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.003115264797507788,"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":0.009345794392523364,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":0.006230529595015576,"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":0.003115264797507788,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.003115264797507788,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.01557632398753894,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":0.006230529595015576,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.003115264797507788,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.003115264797507788,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.003115264797507788,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.009345794392523364,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.003115264797507788}}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6153846153846154,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.15384615384615385,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.15384615384615385,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.07692307692307693}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6153846153846154,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.15384615384615385,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.15384615384615385,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.07692307692307693}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.24396135265700483,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.7353974527887571,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.019762845849802372,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.000878348704435661},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.24437616591682212,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.734993964665862,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.01975200263360035,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.0008778667837155712}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.9763694951664876,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.022556390977443608,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.0010741138560687433}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.9763694951664876,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.022556390977443608,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.0010741138560687433}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.6422018348623854,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.09862385321100918,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.25229357798165136,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.0022935779816513763,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.0045871559633027525},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.6407322654462243,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.09839816933638444,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.2540045766590389,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.002288329519450801,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.004576659038901602}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":0.48936170212765956,"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.2127659574468085,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":0.2553191489361702,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.0425531914893617}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":0.48936170212765956,"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.2127659574468085,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":0.2553191489361702,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.0425531914893617}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":1}},"firefox/135.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.9473684210526315,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":0.05263157894736842}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.95,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":0.05}},"chrome/148.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.7142857142857143,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.02040816326530612,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.2653061224489796}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.7142857142857143,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.02040816326530612,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.2653061224489796}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.944954128440367,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.01834862385321101,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.03669724770642202}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.944954128440367,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.01834862385321101,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.03669724770642202}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.46153846153846156,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.3269230769230769,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.19230769230769232,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.019230769230769232}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.46153846153846156,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.3269230769230769,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.19230769230769232,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.019230769230769232}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":1}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":1}},"edge/129.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":1}},"safari/18.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.09523809523809523,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.46320346320346323,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.44155844155844154}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.09523809523809523,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.46320346320346323,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.44155844155844154}},"chrome/127.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.3333333333333333,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.6666666666666666}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.3333333333333333,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.6666666666666666}},"safari/16.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.75,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.2,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.05}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.75,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.2,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.05}},"chrome/121.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.4716981132075472,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.4339622641509434,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.09433962264150944}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.4716981132075472,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.4339622641509434,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.09433962264150944}},"chrome/128.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.625,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.375}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.625,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.375}},"safari/17.2.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":1}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":1}},"chrome/116.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.5957446808510638,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.3404255319148936,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.06382978723404255}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.5957446808510638,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.3404255319148936,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.06382978723404255}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":1}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":1}},"firefox/151.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.25,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.5,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.25}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.25,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.5,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.25}},"chrome/115.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":1}},"edge/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.18181818181818182,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.6363636363636364,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.18181818181818182}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.18181818181818182,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.6363636363636364,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.18181818181818182}},"chrome/140.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.5714285714285714,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.21428571428571427,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.21428571428571427}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.5714285714285714,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.21428571428571427,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.21428571428571427}},"safari/16.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":1}},"safari/18.1.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":1}},"edge/144.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":1}},"edge/128.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":1}},"chrome/109.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":1}},"chrome/139.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.8461538461538461,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.15384615384615385}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.8461538461538461,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.15384615384615385}},"edge/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.8888888888888888,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.1111111111111111}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.8888888888888888,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.1111111111111111}},"safari/17.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.36363636363636365,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.45454545454545453,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.18181818181818182}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.36363636363636365,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.45454545454545453,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.18181818181818182}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":1}},"safari/18.0.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":1}},"chrome/134.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.75,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.25}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.75,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.25}},"safari/16.5.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":1}},"chrome/120.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":1}},"chrome/137.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.8,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.2}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.8,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.2}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":1}},"firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":0.5,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":0.5}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":0.5,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":0.5}},"edge/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.8,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.2}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.8,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.2}},"chrome/135.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.8181818181818182,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.09090909090909091,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.09090909090909091}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.8181818181818182,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.09090909090909091,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.09090909090909091}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":1}},"chrome/91.0.4450.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":1}},"chrome/125.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.5555555555555556,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.2222222222222222,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.2222222222222222}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.5555555555555556,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.2222222222222222,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.2222222222222222}},"chrome/113.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":1}},"chrome/101.0.4951.54":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":1}},"chrome/108.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":1}},"edge/148.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":1}},"chrome/147.0.7727.56":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":1}},"edge/123.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":1}},"chrome/136.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.8333333333333334,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.16666666666666666}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.8333333333333334,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.16666666666666666}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":1}},"edge/138.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":1}},"chrome/114.0.0.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":1}},"chrome/138.0.7204.235":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":1}},"safari/17.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":1}},"edge/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":0.42857142857142855,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":0.2857142857142857,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":0.2857142857142857}},"skip":{"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":0.42857142857142855,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":0.2857142857142857,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":0.2857142857142857}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":1}},"safari/17.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":1}},"chrome/124.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":1}},"chrome/122.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":1}},"chrome/107.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":1}},"firefox/146.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":1}},"edge/122.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":1}},"chrome/103.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":1}},"chrome/90.0.4430.212":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":1}},"safari/17.1.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":1}},"chrome/132.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":1}},"chrome/133.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":1}},"firefox/142.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":1}},"safari/17.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":1}},"safari/17.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":1}},"safari/15.6.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":1}},"safari/17.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":1}},"edge/135.0.3179.54":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":1}},"chrome/106.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":1}},"safari/16.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":1}},"chrome/91.0.4472.124":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":1}},"chrome/132.0.6788.76":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":1}},"safari/16.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.1958399435924555,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5903402080028204,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.08011634056054998,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.024678300722721664,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.015864621893178214,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.003789881896703684,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.006169575180680416,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.009078089194429755,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.0021152829190904283,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":0.00026441036488630354,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.009695046712497797,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.0019390093424995593,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.009430636347611493,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.008989952406134321,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.0022915564956812974,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.0013220518244315177,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":0.00035254715318173806,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.002203419707385863,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.00035254715318173806,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.0024678300722721664,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.002203419707385863,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.0014101886127269522,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.0007050943063634761,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":0.00008813678829543451,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":0.002203419707385863,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.0009695046712497797,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.0007050943063634761,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.00035254715318173806,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.0018508725542041248,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.0005288207297726071,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.00035254715318173806,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":0.00026441036488630354,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.0007050943063634761,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.00026441036488630354,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.00035254715318173806,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.0007932310946589106,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.002027146130794994,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.0014983254010223867,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":0.0008813678829543451,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.0008813678829543451,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.0007050943063634761,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":0.0015864621893178213,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":0.00026441036488630354,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.0006169575180680416,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":0.00008813678829543451,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.00008813678829543451,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.00035254715318173806,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":0.00017627357659086903,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":0.00026441036488630354,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.00008813678829543451,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.00035254715318173806,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":0.00008813678829543451,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":0.00026441036488630354,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":0.00044068394147717257,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.00026441036488630354,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.00026441036488630354,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":0.00008813678829543451,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.00008813678829543451,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.00008813678829543451,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.00008813678829543451,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":0.00017627357659086903,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.00026441036488630354,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.00008813678829543451,"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":0.00008813678829543451},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.27060539752005836,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":0.016776075857038657,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":0.0787746170678337,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":0.08169219547775347,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":0.019693654266958426,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.01312910284463895,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":0.013858497447118891,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":0.0036469730123997084,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":0.187454412837345,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":0.016046681254558718,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":0.09700948212983224,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":0.00437636761487965,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.02698760029175784,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":0.0175054704595186,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":0.019693654266958426,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":0.0036469730123997084,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":0.016046681254558718,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":0.002188183807439825,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":0.01312910284463895,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":0.0087527352297593,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":0.002188183807439825,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":0.007293946024799417,"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":0.0036469730123997084,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":0.002188183807439825,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.0036469730123997084,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":0.0087527352297593,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":0.0029175784099197666,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":0.002188183807439825,"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":0.002188183807439825,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.0007293946024799417,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":0.0087527352297593,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":0.0029175784099197666,"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":0.0029175784099197666,"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.0014587892049598833,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":0.0029175784099197666,"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":0.0014587892049598833,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":0.0007293946024799417,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":0.0029175784099197666,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":0.0007293946024799417}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.1751199182197059,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5266965479279704,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.07147912243453644,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.02917354722025635,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.022017771486985926,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":0.0018086026578595581,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":0.008492569002123142,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":0.00880710859479437,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":0.0021231422505307855,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.014154281670205236,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.0033813006212156955,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":0.0014940630651883305,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.0055044428717464814,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.008099394511284108,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":0.0014940630651883305,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.001887237556027365,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":0.0003931744908390344,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":0.020209168829126368,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":0.00023590469450342062,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":0.0017299677596917511,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.008728473696626562,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":0.010458441456318314,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.0017299677596917511,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.008413934103955335,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.008020759613116301,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":0.0020445073523629787,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":0.00047180938900684123,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.0029094912322088543,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.0011795234725171032,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":0.0003145395926712275,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.001965872454195172,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.0003145395926712275,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.0022017771486985923,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":0.001887237556027365,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":0.0021231422505307855,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.001965872454195172,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.00125815837068491,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.000629079185342455,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":0.0003931744908390344,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":0.0017299677596917511,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":0.00007863489816780687,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":0.001965872454195172,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.0008649838798458756,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.000629079185342455,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":0.00023590469450342062,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.0003145395926712275,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.0016513328615239443,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.00047180938900684123,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.0003145395926712275,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":0.00023590469450342062,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.000629079185342455,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":0.0014154281670205238,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.00023590469450342062,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.0003145395926712275,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.0007077140835102619,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.0018086026578595581,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":0.0009436187780136825,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.0013367932688527167,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":0.00023590469450342062,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":0.0007863489816780688,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":0.0007863489816780688,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.0007863489816780688,"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.0007863489816780688,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.000629079185342455,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":0.0014154281670205238,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":0.0003931744908390344,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":0.00007863489816780687,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":0.00023590469450342062,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.0005504442871746481,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":0.00023590469450342062,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":0.0009436187780136825,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":0.0003145395926712275,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.0003145395926712275,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":0.00023590469450342062,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":0.00023590469450342062,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":0.0009436187780136825,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":0.0003145395926712275,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":0.00023590469450342062,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.0003145395926712275,"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":0.0003145395926712275,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":0.00023590469450342062,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":0.0003145395926712275,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":0.0003931744908390344,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":0.00023590469450342062,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":0.00023590469450342062,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":0.00007863489816780687,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":0.00015726979633561374,"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":0.00015726979633561374,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":0.00007863489816780687,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":0.00023590469450342062,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":0.00007863489816780687,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":0.0003145395926712275,"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":0.00007863489816780687,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":0.00007863489816780687}}}},"mobile":{"deeper":{"ios":{"deeper":{"safari/26.4":{"deeper":{"?0":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":1},"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.992831541218638,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.007168458781362007}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.9928571428571429,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.007142857142857143}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":0.9953703703703703,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":0.0023148148148148147,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":0.0023148148148148147}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":0.9953703703703703,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":0.0023148148148148147,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":0.0023148148148148147}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":0.971830985915493,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":0.028169014084507043}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":0.971830985915493,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":0.028169014084507043}},"safari/18.5":{"deeper":{"?0":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":1},"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":1}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":1}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.25}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.25}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":0.2857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":0.5714285714285714,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":0.14285714285714285}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":0.2857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":0.5714285714285714,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":0.14285714285714285}},"safari/18.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.25}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.25}},"safari/18.7.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.8846153846153846,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.07692307692307693,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.038461538461538464}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.8846153846153846,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.07692307692307693,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.038461538461538464}},"safari/18.7.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":1}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.9428571428571428,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.05714285714285714}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.9428571428571428,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.05714285714285714}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":0.8888888888888888,"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":0.1111111111111111}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":0.8888888888888888,"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":0.1111111111111111}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":1}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.6666666666666666,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.3333333333333333}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.6666666666666666,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.3333333333333333}},"safari/26.4.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":0.125,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":0.125}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":0.125,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":0.125}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":1}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":1}},"chrome/45.0.8909.1591":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":1}},"safari/17.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":1}},"safari/16.6.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":1}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":1}},"chrome/144.0.7559.95":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":1}},"safari/18.7.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":1}},"safari/17.8":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":1}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":1}},"safari/15.6.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":1}},"safari/16.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":1}},"safari/18.7.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":1}},"safari/18.7.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":1}},"safari/18.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":1}},"safari/26.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":0.5,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.5},"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":0.41707080504364696,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.26867119301648884,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.002909796314258002,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":0.0038797284190106693,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":0.06692531522793405,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":0.04267701260911736,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":0.005819592628516004,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.03200775945683802,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":0.023278370514064017,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.02230843840931135,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":0.009699321047526674,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":0.011639185257032008,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.002909796314258002,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":0.002909796314258002,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":0.004849660523763337,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":0.0038797284190106693,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":0.002909796314258002,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":0.004849660523763337,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":0.004849660523763337,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":0.0038797284190106693,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":0.007759456838021339,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":0.002909796314258002,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":0.002909796314258002,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":0.0019398642095053346,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":0.01066925315227934,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":0.0009699321047526673,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":0.0009699321047526673}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":0.41626331074540174,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.2691190706679574,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":0.012584704743465635,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.002904162633107454,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":0.003872216844143272,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":0.06679574056147145,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":0.04259438528557599,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":0.005808325266214908,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.031945788964181994,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":0.023233301064859633,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.022265246853823813,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":0.00968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.002904162633107454,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":0.002904162633107454,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":0.00484027105517909,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":0.003872216844143272,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":0.002904162633107454,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":0.00484027105517909,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":0.00484027105517909,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":0.003872216844143272,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":0.007744433688286544,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":0.002904162633107454,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":0.002904162633107454,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":0.001936108422071636,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":0.010648596321393998,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":0.000968054211035818,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":0.000968054211035818}}},"android":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1},"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.996,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.004}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.9803149606299213,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.003937007874015748,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.015748031496062992}},"edge/147.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":0.16666666666666666,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":0.8333333333333334}},"skip":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":0.16666666666666666,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":0.8333333333333334}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1},"?1":{"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":0.3333333333333333,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.6666666666666666}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":1}},"skip":{"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":1}},"chrome/148.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":1}},"chrome/144.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":1}},"chrome/145.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.25,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.75}},"skip":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.25,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.75}},"chrome/138.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":1}},"edge/143.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":1}},"chrome/134.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":1}},"chrome/120.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":1}},"chrome/137.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":1}},"chrome/119.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":1}},"chrome/142.0.7444.138":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":1}},"firefox/136.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":1}},"skip":{"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":1}},"chrome/59.0.9273.1293":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":1}},"chrome/138.0.7204.63":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":1}},"chrome/147.0.7727.111":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":1},"?1":{"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.16666666666666666,"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.8333333333333334}},"chrome/130.0.6723.73":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6666666666666666,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.3333333333333333},"*MISSING_VALUE*":{"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":0.5789473684210527,"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":0.05263157894736842,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":0.05263157894736842,"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":0.05263157894736842,"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.2631578947368421},"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.8137254901960784,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":0.0457516339869281,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":0.016339869281045753,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":0.006535947712418301,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":0.0196078431372549,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":0.013071895424836602,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":0.006535947712418301,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":0.026143790849673203,"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.00980392156862745,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":0.006535947712418301,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":0.00980392156862745,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":0.0032679738562091504}}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1},"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.996,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.004}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.9803149606299213,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.003937007874015748,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.015748031496062992}},"edge/147.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":0.16666666666666666,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":0.8333333333333334}},"skip":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":0.16666666666666666,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":0.8333333333333334}},"safari/26.4":{"deeper":{"?0":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":1},"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.992831541218638,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.007168458781362007}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.9928571428571429,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.007142857142857143}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":0.9953703703703703,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":0.0023148148148148147,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":0.0023148148148148147}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":0.9953703703703703,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":0.0023148148148148147,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":0.0023148148148148147}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1},"?1":{"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":0.3333333333333333,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.6666666666666666}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":1}},"skip":{"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":1}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":0.971830985915493,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":0.028169014084507043}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":0.971830985915493,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":0.028169014084507043}},"safari/18.5":{"deeper":{"?0":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":1},"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":1}},"chrome/148.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":1}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":1}},"chrome/144.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":1}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.25}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.25}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":0.2857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":0.5714285714285714,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":0.14285714285714285}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":0.2857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":0.5714285714285714,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":0.14285714285714285}},"safari/18.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.25}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.75,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.25}},"safari/18.7.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.8846153846153846,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.07692307692307693,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.038461538461538464}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.8846153846153846,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.07692307692307693,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.038461538461538464}},"safari/18.7.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":1}},"chrome/145.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.25,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.75}},"skip":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.25,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.75}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.9428571428571428,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.05714285714285714}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.9428571428571428,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.05714285714285714}},"chrome/138.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":1}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":0.8888888888888888,"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":0.1111111111111111}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":0.8888888888888888,"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":0.1111111111111111}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":1}},"edge/143.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":1}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.6666666666666666,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.3333333333333333}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.6666666666666666,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.3333333333333333}},"chrome/134.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":1}},"safari/26.4.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":0.125,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":0.125}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":0.125,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":0.375,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":0.125}},"chrome/120.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":1}},"chrome/137.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":1}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":1}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":1}},"chrome/45.0.8909.1591":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":1}},"safari/17.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":1}},"safari/16.6.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":1}},"chrome/119.0.0.0":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":1}},"chrome/142.0.7444.138":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":1}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":1}},"firefox/136.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":1}},"skip":{"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":1}},"chrome/59.0.9273.1293":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":1}},"chrome/144.0.7559.95":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":1}},"safari/18.7.3":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":1}},"chrome/138.0.7204.63":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":1}},"safari/17.8":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":1}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":1}},"chrome/147.0.7727.111":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":1},"?1":{"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.16666666666666666,"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.8333333333333334}},"safari/15.6.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":1}},"safari/16.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":1}},"chrome/130.0.6723.73":{"deeper":{"?1":{"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":1}},"skip":{"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":1}},"safari/18.7.7":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":1}},"safari/18.7.2":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":1}},"safari/18.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":1}},"safari/26.4.1":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":1}},"skip":{"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":0.125,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.125,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.25},"*MISSING_VALUE*":{"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":0.4095238095238095,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.2638095238095238,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.002857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":0.0038095238095238095,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":0.06571428571428571,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":0.0419047619047619,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":0.005714285714285714,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.03142857142857143,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":0.022857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.021904761904761906,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":0.009523809523809525,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":0.011428571428571429,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.002857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":0.002857142857142857,"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":0.010476190476190476,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":0.004761904761904762,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":0.0038095238095238095,"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":0.002857142857142857,"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":0.004761904761904762,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":0.004761904761904762,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":0.0038095238095238095,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":0.007619047619047619,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":0.002857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":0.002857142857142857,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":0.0019047619047619048,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.004761904761904762,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":0.010476190476190476,"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":0.0009523809523809524,"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":0.0009523809523809524},"?1":{"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.8137254901960784,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":0.0457516339869281,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":0.016339869281045753,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":0.006535947712418301,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":0.0196078431372549,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":0.013071895424836602,"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":0.006535947712418301,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":0.026143790849673203,"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":0.0032679738562091504,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":0.00980392156862745,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":0.006535947712418301,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":0.00980392156862745,"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":0.0032679738562091504}}}}}}},"_1.1_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"windows":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":0.6666666666666666,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.3333333333333333}},"skip":{"*MISSING_VALUE*":0.989247311827957,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.010752688172043012}}},"linux":{"deeper":{"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}},"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":0.9,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.1}},"skip":{"*MISSING_VALUE*":0.990990990990991,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.009009009009009009}}}}},"skip":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"windows":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":0.6666666666666666,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.3333333333333333}},"skip":{"*MISSING_VALUE*":0.989247311827957,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.010752688172043012}}},"linux":{"deeper":{"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":1}},"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":0.9,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.1}},"skip":{"*MISSING_VALUE*":0.990990990990991,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":0.009009009009009009}}}}}}}},{"name":"User-Agent","parentNames":["*HTTP_VERSION","*DEVICE","*OPERATING_SYSTEM","*BROWSER","sec-ch-ua-mobile"],"possibleValues":["*MISSING_VALUE*","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36","Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36"],"conditionalProbabilities":{"deeper":{"_2.0_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/148.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/127.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/128.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.2.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/116.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/151.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/115.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/140.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.1.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/139.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.0.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.5.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/135.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/91.0.4450.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/114.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.7204.235":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/107.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/103.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.1.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"windows":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/135.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/148.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/129.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/127.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/121.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/128.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/140.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/144.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/128.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/109.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/139.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/134.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/120.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/137.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/135.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/125.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/113.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/108.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/148.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/147.0.7727.56":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/123.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/136.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/138.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/124.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/122.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/122.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/132.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/133.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/135.0.3179.54":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/106.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/91.0.4472.124":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/132.0.6788.76":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"linux":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/148.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/140.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/134.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/137.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/135.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/101.0.4951.54":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/136.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/146.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/90.0.4430.212":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/142.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/135.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/148.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/129.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/127.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/141.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/121.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/128.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.2.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/116.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/151.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/130.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/115.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/149.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/140.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.1.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/144.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/128.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/109.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/139.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/143.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/131.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.0.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/134.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.5.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/120.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/137.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/145.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/135.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/91.0.4450.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/125.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/126.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/113.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/101.0.4951.54":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/108.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/148.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/147.0.7727.56":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/123.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/136.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/138.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/114.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.7204.235":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/142.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/124.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/122.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/107.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/146.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/122.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/103.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/90.0.4430.212":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.1.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/132.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/133.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/142.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/135.0.3179.54":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/106.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/91.0.4472.124":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/132.0.6788.76":{"deeper":{"?0":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}}},"mobile":{"deeper":{"ios":{"deeper":{"safari/26.4":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/45.0.8909.1591":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.7559.95":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.8":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"android":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/148.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/143.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/134.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/120.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/137.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/119.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.7444.138":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/136.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/59.0.9273.1293":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.7204.63":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/147.0.7727.111":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/130.0.6723.73":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/147.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.5":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/148.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/145.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/143.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.6":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"edge/143.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.4":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/134.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/120.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/137.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/45.0.8909.1591":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.6.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/119.0.0.0":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/142.0.7444.138":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.3.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"firefox/136.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.5":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/59.0.9273.1293":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/144.0.7559.95":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.3":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/138.0.7204.63":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/17.8":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.8":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/147.0.7727.111":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/15.6.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/16.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/130.0.6723.73":{"deeper":{"?1":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.7":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.7.2":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/18.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"safari/26.4.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"?1":{"*MISSING_VALUE*":1}}}}}}},"_1.1_":{"deeper":{"desktop":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.3333333333333333,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.6666666666666666}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.07692307692307693,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.7692307692307693,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.15384615384615385}}},"windows":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"edge/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6444444444444445,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.18888888888888888,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.044444444444444446,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.011111111111111112,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.03333333333333333,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.011111111111111112,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.06666666666666667},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.3333333333333333,"*MISSING_VALUE*":0.3333333333333333,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.3333333333333333}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6236559139784946,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.1935483870967742,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.043010752688172046,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.010752688172043012,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.03225806451612903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.010752688172043012,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.06451612903225806,"*MISSING_VALUE*":0.010752688172043012,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.010752688172043012}}},"linux":{"deeper":{"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.8405797101449275,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.014492753623188406,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.14492753623188406}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.8405797101449275,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.014492753623188406,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.14492753623188406}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"edge/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5742574257425742,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.009900990099009901,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.16831683168316833,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.039603960396039604,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.009900990099009901,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.09900990099009901,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.0297029702970297,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.009900990099009901,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.0594059405940594},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.1,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.1,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.2,"*MISSING_VALUE*":0.1,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":0.4,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5225225225225225,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.009009009009009009,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.16216216216216217,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.036036036036036036,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.009009009009009009,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.009009009009009009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.09009009009009009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.018018018018018018,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.02702702702702703,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.009009009009009009,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.05405405405405406,"*MISSING_VALUE*":0.009009009009009009,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":0.036036036036036036,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.009009009009009009}}}}},"skip":{"deeper":{"macos":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.3333333333333333,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.6666666666666666}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.07692307692307693,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.7692307692307693,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.15384615384615385}}},"windows":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"edge/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6444444444444445,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.18888888888888888,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.044444444444444446,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.011111111111111112,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.03333333333333333,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.011111111111111112,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.06666666666666667},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.3333333333333333,"*MISSING_VALUE*":0.3333333333333333,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.3333333333333333}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.6236559139784946,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.1935483870967742,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.043010752688172046,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.010752688172043012,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.03225806451612903,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.010752688172043012,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.06451612903225806,"*MISSING_VALUE*":0.010752688172043012,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.010752688172043012}}},"linux":{"deeper":{"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}}},"*MISSING_VALUE*":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":1}}}},"skip":{"deeper":{"chrome/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.8405797101449275,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.014492753623188406,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.14492753623188406}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.8405797101449275,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.014492753623188406,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.14492753623188406}},"edge/147.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1},"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":1}},"safari/26.4":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":1}},"chrome/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":1}},"safari/18.5":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"skip":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":1}},"chrome/142.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":1}},"chrome/145.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":1}},"chrome/143.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":1}},"chrome/116.0.0.0":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":1}},"edge/146.0.0.0":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":1}},"chrome/96.0.4664.110":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"chrome/147.0.7727.116":{"deeper":{"*MISSING_VALUE*":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}},"skip":{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":1}}},"skip":{"deeper":{"?0":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5742574257425742,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.009900990099009901,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.16831683168316833,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.039603960396039604,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.009900990099009901,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.09900990099009901,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.0297029702970297,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.009900990099009901,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.0594059405940594},"*MISSING_VALUE*":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.1,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.1,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.2,"*MISSING_VALUE*":0.1,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":0.4,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.1}},"skip":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.5225225225225225,"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.009009009009009009,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":0.16216216216216217,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":0.036036036036036036,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":0.009009009009009009,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":0.009009009009009009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":0.09009009009009009,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":0.018018018018018018,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":0.02702702702702703,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":0.009009009009009009,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":0.05405405405405406,"*MISSING_VALUE*":0.009009009009009009,"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":0.036036036036036036,"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":0.009009009009009009}}}}}}}},{"name":"accept-encoding","parentNames":["user-agent"],"possibleValues":["gzip, deflate, br, zstd","gzip, deflate, br","*MISSING_VALUE*","gzip"],"conditionalProbabilities":{"deeper":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":0.9977548271216884,"gzip, deflate, br":0.00224517287831163},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":0.9914899970140341,"gzip, deflate, br":0.00851000298596596},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"gzip, deflate, br, zstd":0.9878987898789879,"gzip, deflate, br":0.0121012101210121},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"gzip, deflate, br, zstd":0.9272237196765498,"gzip, deflate, br":0.07008086253369272,"*MISSING_VALUE*":0.0026954177897574125},"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":{"gzip, deflate, br, zstd":0.8839285714285714,"gzip, deflate, br":0.11607142857142858},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":0.07692307692307693,"gzip, deflate, br":0.9230769230769231},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":{"gzip, deflate, br, zstd":0.9961089494163424,"gzip, deflate, br":0.0038910505836575876},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":{"gzip, deflate, br, zstd":0.9259259259259259,"gzip, deflate, br":0.07407407407407407},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":{"gzip, deflate, br":0.8888888888888888,"gzip, deflate, br, zstd":0.1111111111111111},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":{"gzip, deflate, br":0.1,"gzip, deflate, br, zstd":0.9},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":{"gzip":0.9166666666666666,"gzip, deflate, br, zstd":0.08333333333333333},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":{"gzip, deflate, br":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1}}}},{"name":"Accept-Encoding","parentNames":["User-Agent"],"possibleValues":["*MISSING_VALUE*","gzip, deflate, br","gzip, deflate, br, zstd","gzip, deflate","gzip, deflate, zstd","gzip, deflate, br, identity","gzip"],"conditionalProbabilities":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br":0.08620689655172414,"gzip, deflate, br, zstd":0.5689655172413793,"gzip, deflate":0.1724137931034483,"gzip, deflate, zstd":0.10344827586206896,"gzip, deflate, br, identity":0.06896551724137931},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"gzip, deflate, br, zstd":0.8888888888888888,"gzip, deflate, br":0.1111111111111111},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"gzip, deflate, br":0.25,"gzip, deflate, br, zstd":0.75},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":0.8,"gzip, deflate, zstd":0.1,"gzip, deflate, br":0.1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"gzip, deflate, zstd":0.6666666666666666,"gzip, deflate, br, zstd":0.3333333333333333},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"gzip, deflate, br, zstd":0.6666666666666666,"gzip, deflate, br":0.3333333333333333},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":{"gzip, deflate, br":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"gzip":1}}}},{"name":"accept","parentNames":["user-agent"],"possibleValues":["text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7","text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8","text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8","*MISSING_VALUE*","text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7","text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9","text/html,application/xhtml+xml,application/xml;q=0.9,image/heif,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7","text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9"],"conditionalProbabilities":{"deeper":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.8693309384822632,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.13022002694207455,"text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.000449034575662326},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.8884741713944461,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.11152582860555389},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.7028112449799196,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.2971887550200803},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.8035714285714286,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.19642857142857142},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":0.9964028776978417,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.0035971223021582736},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.07692307692307693,"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":0.9230769230769231},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.37777777777777777,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.6222222222222222},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.7674418604651163,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.23255813953488372},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":0.9473684210526315,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.05263157894736842},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.5,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.5},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.963963963963964,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.036036036036036036},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.8636363636363636,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.13636363636363635},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.8333333333333334,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.16666666666666666},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.9333333333333333,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.06666666666666667},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.84,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.16},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.875,"text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.125},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.75,"text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.25},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.9565217391304348,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.043478260869565216},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/heif,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.5,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.5},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.8823529411764706,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.11764705882352941},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/heif,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.6,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.4},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/jxl,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.6,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.4},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9":0.6,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.4},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.9,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.1},"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.75,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.25},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/heif,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.5,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.5},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.75,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.25},"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":1},"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":1}}}},{"name":"Accept","parentNames":["User-Agent"],"possibleValues":["*MISSING_VALUE*","text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7","text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8","text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"],"conditionalProbabilities":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.9655172413793104,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.034482758620689655},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":0.9,"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8":0.1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7":1}}}},{"name":"dnt","parentNames":["user-agent"],"possibleValues":["*MISSING_VALUE*","1"],"conditionalProbabilities":{"deeper":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.08576560395150426,"*MISSING_VALUE*":0.9142343960484958},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.074499850701702,"*MISSING_VALUE*":0.925500149298298},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"1":0.10121012101210121,"*MISSING_VALUE*":0.8987898789878987},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"1":0.1566265060240964,"*MISSING_VALUE*":0.8433734939759037},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":0.060714285714285714,"*MISSING_VALUE*":0.9392857142857143},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.13333333333333333,"*MISSING_VALUE*":0.8666666666666667},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":0.09302325581395349,"*MISSING_VALUE*":0.9069767441860465},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":{"1":0.42105263157894735,"*MISSING_VALUE*":0.5789473684210527},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"1":0.1,"*MISSING_VALUE*":0.9},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"1":0.041666666666666664,"*MISSING_VALUE*":0.9583333333333334},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":0.05405405405405406,"*MISSING_VALUE*":0.9459459459459459},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"1":0.04672897196261682,"*MISSING_VALUE*":0.9532710280373832},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"1":0.049019607843137254,"*MISSING_VALUE*":0.9509803921568627},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"1":0.038461538461538464,"*MISSING_VALUE*":0.9615384615384616},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"1":0.06666666666666667,"*MISSING_VALUE*":0.9333333333333333},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"1":0.12,"*MISSING_VALUE*":0.88},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"1":0.10714285714285714,"*MISSING_VALUE*":0.8928571428571429},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"1":0.125,"*MISSING_VALUE*":0.875},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":{"1":0.2,"*MISSING_VALUE*":0.8},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"1":0.09090909090909091,"*MISSING_VALUE*":0.9090909090909091},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"1":0.38095238095238093,"*MISSING_VALUE*":0.6190476190476191},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"1":0.25,"*MISSING_VALUE*":0.75},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":{"1":1},"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":{"1":0.2,"*MISSING_VALUE*":0.8},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"1":0.1111111111111111,"*MISSING_VALUE*":0.8888888888888888},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"1":0.13043478260869565,"*MISSING_VALUE*":0.8695652173913043},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.25,"*MISSING_VALUE*":0.75},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"1":0.058823529411764705,"*MISSING_VALUE*":0.9411764705882353},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"1":0.6,"*MISSING_VALUE*":0.4},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"1":0.5,"*MISSING_VALUE*":0.5},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.125,"*MISSING_VALUE*":0.875},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":{"1":0.1111111111111111,"*MISSING_VALUE*":0.8888888888888888},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"1":0.5714285714285714,"*MISSING_VALUE*":0.42857142857142855},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":{"1":1},"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"1":0.5,"*MISSING_VALUE*":0.5},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"1":0.25,"*MISSING_VALUE*":0.75},"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"1":0.3333333333333333,"*MISSING_VALUE*":0.6666666666666666},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1}}}},{"name":"DNT","parentNames":["User-Agent"],"possibleValues":["*MISSING_VALUE*","1"],"conditionalProbabilities":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.06896551724137931,"*MISSING_VALUE*":0.9310344827586207},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"1":0.05555555555555555,"*MISSING_VALUE*":0.9444444444444444},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"1":0.75,"*MISSING_VALUE*":0.25},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1}}}},{"name":"sec-ch-ua","parentNames":["user-agent","User-Agent","sec-ch-ua-mobile"],"possibleValues":["\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"","\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"","\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"","*MISSING_VALUE*","\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"","\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"","\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"","\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"","\"Chromium\";v=\"147\", \"Not:A-Brand\";v=\"8\", \"Google Chrome\";v=\"147\"","\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"","\"Not_A Brand\";v=\"99\", \"Chromium\";v=\"142\"","\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"","\"Microsoft Edge\";v=\"129\", \"Not=A?Brand\";v=\"8\", \"Chromium\";v=\"129\"","\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"","\"Not)A;Brand\";v=\"99\", \"Google Chrome\";v=\"127\", \"Chromium\";v=\"127\"","\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"","\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"","\"Not A(Brand\";v=\"99\", \"Google Chrome\";v=\"121\", \"Chromium\";v=\"121\"","\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"","\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"","\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"","\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"","\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"","\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"","\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"","\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"","\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"","\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"","\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\"","\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Microsoft Edge\";v=\"144\"","\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Microsoft Edge\";v=\"128\"","\"Not_A Brand\";v=\"99\", \"Google Chrome\";v=\"109\", \"Chromium\";v=\"109\"","\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"","\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"","\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"","\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"","\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"","\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"","\"Chromium\";v=\"130\", \"Google Chrome\";v=\"130\", \"Not?A_Brand\";v=\"99\"","\"HeadlessChrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"","\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"","\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"","\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"","\"Google Chrome\";v=\"144\", \"Chromium\";v=\"144\", \"Not(A:Brand\";v=\"99\"","\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \" Not;A Brand\";v=\"24\"","\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\"","\"Google Chrome\";v=\"113\", \"Chromium\";v=\"113\", \"Not-A.Brand\";v=\"24\"","\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"","\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"","\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"","\"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"108\", \"Google Chrome\";v=\"108\"","\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \"Not.A/Brand\";v=\"24\"","\"Chromium\";v=\"148\", \"Microsoft Edge\";v=\"148\", \"Not/A)Brand\";v=\"99\"","\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"147\", \"Google Chrome\";v=\"147\"","\"Microsoft Edge\";v=\"123\", \"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"123\"","\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"","\"Google Chrome\";v=\"119\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"","\"Chromium\";v=\"142\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"142\"","\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Microsoft Edge\";v=\"138\"","\"Chromium\";v=\"146\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"146\"","\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"","\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"","\"Chromium\";v=\"142\", \"Microsoft Edge\";v=\"142\", \"Not_A Brand\";v=\"99\"","\"Chromium\";v=\"143\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"143\"","\"Not:A-Brand\";v=\"24\", \"Chromium\";v=\"134\"","\"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\", \"Chromium\";v=\"146\", \"Vivaldi\";v=\"7.9\"","\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"","\"Chromium\";v=\"124\", \"Google Chrome\";v=\"124\", \"Not-A.Brand\";v=\"99\"","\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Google Chrome\";v=\"122\"","\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"CCleaner Browser\";v=\"146\"","\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Microsoft Edge\";v=\"122\"","\".Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"103\", \"Chromium\";v=\"103\"","\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Vivaldi\";v=\"7.9\"","\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"","\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"","\"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\", \"Not_A Brand\";v=\"24\"","\"Chromium\";v=\"130\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"130\"","\"Not(A:Brand\";v=\"99\", \"Google Chrome\";v=\"133\", \"Chromium\";v=\"133\"","\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"","\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\", \"DuckDuckGo\";v=\"146\"","\"Chromium\";v=\"142\", \"Brave\";v=\"142\", \"Not_A Brand\";v=\"99\"","\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"WaveBrowser\";v=\"138\"","\"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"","\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"","\"Chromium\";v=\"127\", \"Not)A;Brand\";v=\"99\"","\"Chromium\";v=\"106\", \"Atom\";v=\"26\", \"Not;A=Brand\";v=\"99\"","\"Not A(Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"","\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"","\"Tabbit\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"","\"Island\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\""],"conditionalProbabilities":{"deeper":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8222322232223223,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.04590459045904591,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.13051305130513052,"\"Tabbit\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.0009000900090009,"\"Island\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.00045004500450045},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8203861697350696,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.04580152671755725,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.13022002694207455,"*MISSING_VALUE*":0.00224517287831163,"\"Tabbit\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.000898069151324652,"\"Island\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.000449034575662326}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8222322232223223,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.04590459045904591,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.13051305130513052,"\"Tabbit\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.0009000900090009,"\"Island\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.00045004500450045},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8203861697350696,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.04580152671755725,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.13022002694207455,"*MISSING_VALUE*":0.00224517287831163,"\"Tabbit\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.000898069151324652,"\"Island\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.000449034575662326}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8865332935204538,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.1113765303075545,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.0020901761719916393}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8865332935204538,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.1113765303075545,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.0020901761719916393}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8865332935204538,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.1113765303075545,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.0020901761719916393}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.8865332935204538,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.1113765303075545,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.0020901761719916393}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"*MISSING_VALUE*":{"deeper":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.9655172413793104,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.034482758620689655}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.9655172413793104,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.034482758620689655}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.9444444444444444,"*MISSING_VALUE*":0.05555555555555555}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"?0":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.9,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.9,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":1}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"?0":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.6534653465346535,"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.16831683168316833,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.0297029702970297,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":0.039603960396039604,"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.009900990099009901,"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.0297029702970297,"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.009900990099009901,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.0594059405940594},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.6,"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.15454545454545454,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.02727272727272727,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":0.03636363636363636,"*MISSING_VALUE*":0.08181818181818182,"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.00909090909090909,"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.02727272727272727,"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.00909090909090909,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.05454545454545454}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.6746987951807228,"\"Chromium\";v=\"147\", \"Not:A-Brand\";v=\"8\", \"Google Chrome\";v=\"147\"":0.024096385542168676,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.2971887550200803,"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.004016064257028112}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.6746987951807228,"\"Chromium\";v=\"147\", \"Not:A-Brand\";v=\"8\", \"Google Chrome\";v=\"147\"":0.024096385542168676,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.2971887550200803,"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.004016064257028112}}},"skip":{"deeper":{"?1":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.6746987951807228,"\"Chromium\";v=\"147\", \"Not:A-Brand\";v=\"8\", \"Google Chrome\";v=\"147\"":0.024096385542168676,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.2971887550200803,"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.004016064257028112}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.6746987951807228,"\"Chromium\";v=\"147\", \"Not:A-Brand\";v=\"8\", \"Google Chrome\";v=\"147\"":0.024096385542168676,"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.2971887550200803,"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.004016064257028112}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7607142857142857,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.19642857142857142,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.04285714285714286}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7607142857142857,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.19642857142857142,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.04285714285714286}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7607142857142857,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.19642857142857142,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.04285714285714286}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7607142857142857,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.19642857142857142,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.04285714285714286}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.9964028776978417,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.0035971223021582736}}},"skip":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.9964028776978417,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.0035971223021582736}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.07692307692307693,"*MISSING_VALUE*":0.9230769230769231}}},"skip":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.07692307692307693,"*MISSING_VALUE*":0.9230769230769231}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.37777777777777777,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5777777777777777,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.03888888888888889,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.005555555555555556}},"skip":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.37777777777777777,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5777777777777777,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.03888888888888889,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.005555555555555556}}},"skip":{"deeper":{"?0":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.37777777777777777,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5777777777777777,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.03888888888888889,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.005555555555555556}},"skip":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.37777777777777777,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5777777777777777,"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":0.03888888888888889,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.005555555555555556}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7441860465116279,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.23255813953488372,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.023255813953488372}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7441860465116279,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.23255813953488372,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.023255813953488372}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7441860465116279,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.23255813953488372,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.023255813953488372}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.7441860465116279,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.23255813953488372,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.023255813953488372}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.9473684210526315,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.05263157894736842}}},"skip":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":0.9473684210526315,"\"HeadlessChrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.05263157894736842}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not_A Brand\";v=\"99\", \"Chromium\";v=\"142\"":0.9223300970873787,"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.07766990291262135}},"skip":{"\"Not_A Brand\";v=\"99\", \"Chromium\";v=\"142\"":0.9223300970873787,"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.07766990291262135}}},"skip":{"deeper":{"?0":{"\"Not_A Brand\";v=\"99\", \"Chromium\";v=\"142\"":0.9223300970873787,"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.07766990291262135}},"skip":{"\"Not_A Brand\";v=\"99\", \"Chromium\";v=\"142\"":0.9223300970873787,"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.07766990291262135}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.5,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.4583333333333333,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.041666666666666664}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.5,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.4583333333333333,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.041666666666666664}}},"skip":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.5,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.4583333333333333,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.041666666666666664}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.5,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.4583333333333333,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.041666666666666664}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"129\", \"Not=A?Brand\";v=\"8\", \"Chromium\";v=\"129\"":1}},"skip":{"\"Microsoft Edge\";v=\"129\", \"Not=A?Brand\";v=\"8\", \"Chromium\";v=\"129\"":1}}},"skip":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"129\", \"Not=A?Brand\";v=\"8\", \"Chromium\";v=\"129\"":1}},"skip":{"\"Microsoft Edge\";v=\"129\", \"Not=A?Brand\";v=\"8\", \"Chromium\";v=\"129\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.8818181818181818,"\"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\", \"Chromium\";v=\"146\", \"Vivaldi\";v=\"7.9\"":0.00909090909090909,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Vivaldi\";v=\"7.9\"":0.01818181818181818,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.03636363636363636,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\", \"DuckDuckGo\";v=\"146\"":0.03636363636363636,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.01818181818181818},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.8738738738738738,"*MISSING_VALUE*":0.009009009009009009,"\"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\", \"Chromium\";v=\"146\", \"Vivaldi\";v=\"7.9\"":0.009009009009009009,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Vivaldi\";v=\"7.9\"":0.018018018018018018,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.036036036036036036,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\", \"DuckDuckGo\";v=\"146\"":0.036036036036036036,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.018018018018018018}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.8818181818181818,"\"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\", \"Chromium\";v=\"146\", \"Vivaldi\";v=\"7.9\"":0.00909090909090909,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Vivaldi\";v=\"7.9\"":0.01818181818181818,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.03636363636363636,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\", \"DuckDuckGo\";v=\"146\"":0.03636363636363636,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.01818181818181818},"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":0.8738738738738738,"*MISSING_VALUE*":0.009009009009009009,"\"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\", \"Chromium\";v=\"146\", \"Vivaldi\";v=\"7.9\"":0.009009009009009009,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Vivaldi\";v=\"7.9\"":0.018018018018018018,"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":0.036036036036036036,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\", \"DuckDuckGo\";v=\"146\"":0.036036036036036036,"\"Not-A.Brand\";v=\"24\", \"Chromium\";v=\"146\"":0.018018018018018018}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.8636363636363636,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.13636363636363635}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.8636363636363636,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.13636363636363635}}},"skip":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.8636363636363636,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.13636363636363635}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.8636363636363636,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.13636363636363635}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"99\", \"Google Chrome\";v=\"127\", \"Chromium\";v=\"127\"":1}},"skip":{"\"Not)A;Brand\";v=\"99\", \"Google Chrome\";v=\"127\", \"Chromium\";v=\"127\"":1}}},"skip":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"99\", \"Google Chrome\";v=\"127\", \"Chromium\";v=\"127\"":1}},"skip":{"\"Not)A;Brand\";v=\"99\", \"Google Chrome\";v=\"127\", \"Chromium\";v=\"127\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":1}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":1}}},"skip":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":1}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.7647058823529411,"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":0.06862745098039216,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.16666666666666666}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.7647058823529411,"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":0.06862745098039216,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.16666666666666666}}},"skip":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.7647058823529411,"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":0.06862745098039216,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.16666666666666666}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.7647058823529411,"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":0.06862745098039216,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.16666666666666666}}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?1":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}},"skip":{"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}},"skip":{"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not A(Brand\";v=\"99\", \"Google Chrome\";v=\"121\", \"Chromium\";v=\"121\"":1}},"skip":{"\"Not A(Brand\";v=\"99\", \"Google Chrome\";v=\"121\", \"Chromium\";v=\"121\"":1}}},"skip":{"deeper":{"?0":{"\"Not A(Brand\";v=\"99\", \"Google Chrome\";v=\"121\", \"Chromium\";v=\"121\"":1}},"skip":{"\"Not A(Brand\";v=\"99\", \"Google Chrome\";v=\"121\", \"Chromium\";v=\"121\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.84,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.16}},"skip":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.84,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.16}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.84,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.16}},"skip":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.84,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.16}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}},"skip":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}},"skip":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"":1}},"skip":{"\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"":1}},"skip":{"\"Chromium\";v=\"116\", \"Not)A;Brand\";v=\"24\", \"Google Chrome\";v=\"116\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}}},"skip":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}},"skip":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}}},"skip":{"deeper":{"?0":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}},"skip":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"":1}},"skip":{"\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"":1}}},"skip":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"":1}},"skip":{"\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Microsoft Edge\";v=\"146\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":0.8125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\"":0.125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"WaveBrowser\";v=\"138\"":0.0625}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":0.8125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\"":0.125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"WaveBrowser\";v=\"138\"":0.0625}}},"skip":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":0.8125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\"":0.125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"WaveBrowser\";v=\"138\"":0.0625}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":0.8125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\"":0.125,"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"WaveBrowser\";v=\"138\"":0.0625}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}},"skip":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}},"skip":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Microsoft Edge\";v=\"144\"":1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Microsoft Edge\";v=\"144\"":1}}},"skip":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Microsoft Edge\";v=\"144\"":1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Microsoft Edge\";v=\"144\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Microsoft Edge\";v=\"128\"":1}},"skip":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Microsoft Edge\";v=\"128\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Microsoft Edge\";v=\"128\"":1}},"skip":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Microsoft Edge\";v=\"128\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}}},"skip":{"deeper":{"?1":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not_A Brand\";v=\"99\", \"Google Chrome\";v=\"109\", \"Chromium\";v=\"109\"":1}},"skip":{"\"Not_A Brand\";v=\"99\", \"Google Chrome\";v=\"109\", \"Chromium\";v=\"109\"":1}}},"skip":{"deeper":{"?0":{"\"Not_A Brand\";v=\"99\", \"Google Chrome\";v=\"109\", \"Chromium\";v=\"109\"":1}},"skip":{"\"Not_A Brand\";v=\"99\", \"Google Chrome\";v=\"109\", \"Chromium\";v=\"109\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}},"skip":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}}},"skip":{"deeper":{"?0":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}},"skip":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"":0.75,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.25}},"skip":{"\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"":0.75,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.25}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"":0.75,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.25}},"skip":{"\"Google Chrome\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"":0.75,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.25}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}},"skip":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}},"skip":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?1":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"130\", \"Google Chrome\";v=\"130\", \"Not?A_Brand\";v=\"99\"":0.75,"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":0.25}},"skip":{"\"Chromium\";v=\"130\", \"Google Chrome\";v=\"130\", \"Not?A_Brand\";v=\"99\"":0.75,"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":0.25}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"130\", \"Google Chrome\";v=\"130\", \"Not?A_Brand\";v=\"99\"":0.75,"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":0.25}},"skip":{"\"Chromium\";v=\"130\", \"Google Chrome\";v=\"130\", \"Not?A_Brand\";v=\"99\"":0.75,"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":0.25}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6666666666666666,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.3333333333333333}},"skip":{"\"HeadlessChrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6666666666666666,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.3333333333333333}}},"skip":{"deeper":{"?0":{"\"HeadlessChrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6666666666666666,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.3333333333333333}},"skip":{"\"HeadlessChrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6666666666666666,"\"Not:A-Brand\";v=\"99\", \"HeadlessChrome\";v=\"145\", \"Chromium\";v=\"145\"":0.3333333333333333}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":0.875,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.125}},"skip":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":0.875,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.125}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":0.875,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.125}},"skip":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":0.875,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.125}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}},"skip":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}},"skip":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?1":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}}},"skip":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":0.6666666666666666,"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":0.3333333333333333}},"skip":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":0.6666666666666666,"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":0.3333333333333333}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":0.6666666666666666,"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":0.3333333333333333}},"skip":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":0.6666666666666666,"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":0.3333333333333333}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.9565217391304348,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.043478260869565216}},"skip":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.9565217391304348,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.043478260869565216}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.9565217391304348,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.043478260869565216}},"skip":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.9565217391304348,"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.043478260869565216}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5}},"skip":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5}}},"skip":{"deeper":{"?0":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5}},"skip":{"\"Brave\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.5}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"144\", \"Chromium\";v=\"144\", \"Not(A:Brand\";v=\"99\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.7058823529411765,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.058823529411764705}},"skip":{"\"Google Chrome\";v=\"144\", \"Chromium\";v=\"144\", \"Not(A:Brand\";v=\"99\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.7058823529411765,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.058823529411764705}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"144\", \"Chromium\";v=\"144\", \"Not(A:Brand\";v=\"99\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.7058823529411765,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.058823529411764705}},"skip":{"\"Google Chrome\";v=\"144\", \"Chromium\";v=\"144\", \"Not(A:Brand\";v=\"99\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.7058823529411765,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.11764705882352941,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.058823529411764705}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?1":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \" Not;A Brand\";v=\"24\"":0.2,"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \"Not.A/Brand\";v=\"24\"":0.4,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.4}},"skip":{"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \" Not;A Brand\";v=\"24\"":0.2,"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \"Not.A/Brand\";v=\"24\"":0.4,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.4}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \" Not;A Brand\";v=\"24\"":0.2,"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \"Not.A/Brand\";v=\"24\"":0.4,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.4}},"skip":{"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \" Not;A Brand\";v=\"24\"":0.2,"\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \"Not.A/Brand\";v=\"24\"":0.4,"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":0.4}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6,"\"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.4}},"skip":{"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6,"\"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.4}}},"skip":{"deeper":{"?0":{"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6,"\"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.4}},"skip":{"\"Brave\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.6,"\"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":0.4}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\"":0.6,"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":0.4}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\"":0.6,"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":0.4}}},"skip":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\"":0.6,"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":0.4}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\"":0.6,"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":0.4}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"113\", \"Chromium\";v=\"113\", \"Not-A.Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"113\", \"Chromium\";v=\"113\", \"Not-A.Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"113\", \"Chromium\";v=\"113\", \"Not-A.Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"113\", \"Chromium\";v=\"113\", \"Not-A.Brand\";v=\"24\"":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.8,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.1,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.8,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.1,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.1}}},"skip":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.8,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.1,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":0.8,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\"":0.1,"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":0.1}}},"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Google Chrome\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"108\", \"Google Chrome\";v=\"108\"":1}},"skip":{"\"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"108\", \"Google Chrome\";v=\"108\"":1}}},"skip":{"deeper":{"?0":{"\"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"108\", \"Google Chrome\";v=\"108\"":1}},"skip":{"\"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"108\", \"Google Chrome\";v=\"108\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Microsoft Edge\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Microsoft Edge\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"148\", \"Microsoft Edge\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Microsoft Edge\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"147\", \"Google Chrome\";v=\"147\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"147\", \"Google Chrome\";v=\"147\"":1}}},"skip":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"147\", \"Google Chrome\";v=\"147\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"147\", \"Google Chrome\";v=\"147\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"123\", \"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"123\"":1}},"skip":{"\"Microsoft Edge\";v=\"123\", \"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"123\"":1}}},"skip":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"123\", \"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"123\"":1}},"skip":{"\"Microsoft Edge\";v=\"123\", \"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"123\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Google Chrome\";v=\"119\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"119\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?1":{"\"Google Chrome\";v=\"119\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"119\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Chromium\";v=\"142\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"142\"":1}},"skip":{"\"Chromium\";v=\"142\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"142\"":1}}},"skip":{"deeper":{"?1":{"\"Chromium\";v=\"142\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"142\"":1}},"skip":{"\"Chromium\";v=\"142\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"142\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Microsoft Edge\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Microsoft Edge\";v=\"138\"":1}}},"skip":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Microsoft Edge\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Microsoft Edge\";v=\"138\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Chromium\";v=\"146\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}}},"skip":{"deeper":{"?1":{"\"Chromium\";v=\"146\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.75,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.25}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.75,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.25}}},"skip":{"deeper":{"?1":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.75,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.25}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"145\", \"Chromium\";v=\"145\"":0.75,"\"Not:A-Brand\";v=\"99\", \"Brave\";v=\"145\", \"Chromium\";v=\"145\"":0.25}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5,"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5}},"skip":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5,"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5}}},"skip":{"deeper":{"?0":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5,"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5}},"skip":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5,"\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":0.5}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"142\", \"Microsoft Edge\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"142\", \"Microsoft Edge\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"142\", \"Microsoft Edge\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"142\", \"Microsoft Edge\";v=\"142\", \"Not_A Brand\";v=\"99\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Chromium\";v=\"143\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"143\"":1}},"skip":{"\"Chromium\";v=\"143\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"143\"":1}}},"skip":{"deeper":{"?1":{"\"Chromium\";v=\"143\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"143\"":1}},"skip":{"\"Chromium\";v=\"143\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"143\"":1}}},"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"24\", \"Chromium\";v=\"134\"":0.5,"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":0.5}},"skip":{"\"Not:A-Brand\";v=\"24\", \"Chromium\";v=\"134\"":0.5,"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":0.5}}},"skip":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"24\", \"Chromium\";v=\"134\"":0.5,"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":0.5}},"skip":{"\"Not:A-Brand\";v=\"24\", \"Chromium\";v=\"134\"":0.5,"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":0.5}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?1":{"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Android WebView\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"124\", \"Google Chrome\";v=\"124\", \"Not-A.Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"124\", \"Google Chrome\";v=\"124\", \"Not-A.Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"124\", \"Google Chrome\";v=\"124\", \"Not-A.Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"124\", \"Google Chrome\";v=\"124\", \"Not-A.Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Google Chrome\";v=\"122\"":1}},"skip":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Google Chrome\";v=\"122\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Google Chrome\";v=\"122\"":1}},"skip":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Google Chrome\";v=\"122\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"CCleaner Browser\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"CCleaner Browser\";v=\"146\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"CCleaner Browser\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"CCleaner Browser\";v=\"146\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":1}},"skip":{"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":1}},"skip":{"\"Chromium\";v=\"147\", \"Not.A/Brand\";v=\"8\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.75,"\"Chromium\";v=\"142\", \"Brave\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.25}},"skip":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.75,"\"Chromium\";v=\"142\", \"Brave\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.25}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.75,"\"Chromium\";v=\"142\", \"Brave\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.25}},"skip":{"\"Chromium\";v=\"142\", \"Google Chrome\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.75,"\"Chromium\";v=\"142\", \"Brave\";v=\"142\", \"Not_A Brand\";v=\"99\"":0.25}}},"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Microsoft Edge\";v=\"122\"":1}},"skip":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Microsoft Edge\";v=\"122\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Microsoft Edge\";v=\"122\"":1}},"skip":{"\"Chromium\";v=\"122\", \"Not(A:Brand\";v=\"24\", \"Microsoft Edge\";v=\"122\"":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}},"skip":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}}},"skip":{"deeper":{"?1":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}},"skip":{"\"Chromium\";v=\"134\", \"Not:A-Brand\";v=\"24\", \"Google Chrome\";v=\"134\"":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":1}}},"skip":{"deeper":{"?1":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Brave\";v=\"144\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\".Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"103\", \"Chromium\";v=\"103\"":1}},"skip":{"\".Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"103\", \"Chromium\";v=\"103\"":1}}},"skip":{"deeper":{"?0":{"\".Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"103\", \"Chromium\";v=\"103\"":1}},"skip":{"\".Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"103\", \"Chromium\";v=\"103\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}}},"skip":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}},"skip":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}}},"skip":{"deeper":{"?0":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}},"skip":{"\"Brave\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"":1}}},"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}},"skip":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}},"skip":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}},"skip":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}},"skip":{"\"Chromium\";v=\"131\", \"Google Chrome\";v=\"131\", \"Not_A Brand\";v=\"24\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\", \"Not_A Brand\";v=\"24\"":0.3333333333333333,"\"Not A(Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":0.6666666666666666}},"skip":{"\"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\", \"Not_A Brand\";v=\"24\"":0.3333333333333333,"\"Not A(Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":0.6666666666666666}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\", \"Not_A Brand\";v=\"24\"":0.3333333333333333,"\"Not A(Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":0.6666666666666666}},"skip":{"\"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\", \"Not_A Brand\";v=\"24\"":0.3333333333333333,"\"Not A(Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":0.6666666666666666}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Chromium\";v=\"130\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"130\"":1}},"skip":{"\"Chromium\";v=\"130\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"130\"":1}}},"skip":{"deeper":{"?1":{"\"Chromium\";v=\"130\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"130\"":1}},"skip":{"\"Chromium\";v=\"130\", \"Not:A-Brand\";v=\"99\", \"Google Chrome\";v=\"130\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}},"skip":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}}},"skip":{"deeper":{"?0":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}},"skip":{"\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"99\", \"Google Chrome\";v=\"133\", \"Chromium\";v=\"133\"":1}},"skip":{"\"Not(A:Brand\";v=\"99\", \"Google Chrome\";v=\"133\", \"Chromium\";v=\"133\"":1}}},"skip":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"99\", \"Google Chrome\";v=\"133\", \"Chromium\";v=\"133\"":1}},"skip":{"\"Not(A:Brand\";v=\"99\", \"Google Chrome\";v=\"133\", \"Chromium\";v=\"133\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}},"skip":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}},"skip":{"\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?1":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"149\", \"Chromium\";v=\"149\", \"Not)A;Brand\";v=\"24\"":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?1":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}},"skip":{"\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?1":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"148\", \"Google Chrome\";v=\"148\", \"Not/A)Brand\";v=\"99\"":1}}},"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":1}},"skip":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":1}},"skip":{"\"Chromium\";v=\"135\", \"Not-A.Brand\";v=\"8\"":1}}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}}},"skip":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"126\", \"Google Chrome\";v=\"126\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}},"skip":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}},"skip":{"\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":1}},"skip":{"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":1}}},"skip":{"deeper":{"?0":{"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":1}},"skip":{"\"Google Chrome\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"145\", \"Not:A-Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}},"skip":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}}},"skip":{"deeper":{"?0":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}},"skip":{"\"Not?A_Brand\";v=\"99\", \"Chromium\";v=\"130\"":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?1":{"\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"":1}},"skip":{"\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"":1}}},"skip":{"deeper":{"?1":{"\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"":1}},"skip":{"\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Google Chrome\";v=\"120\"":1}}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":1}}},"skip":{"deeper":{"?0":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":1}},"skip":{"\"Not(A:Brand\";v=\"8\", \"Chromium\";v=\"144\", \"Google Chrome\";v=\"144\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}}},"skip":{"deeper":{"?0":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}},"skip":{"\"Not:A-Brand\";v=\"99\", \"Microsoft Edge\";v=\"145\", \"Chromium\";v=\"145\"":1}}},"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"skip":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}},"skip":{"\"Microsoft Edge\";v=\"147\", \"Not.A/Brand\";v=\"8\", \"Chromium\";v=\"147\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"127\", \"Not)A;Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"127\", \"Not)A;Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"127\", \"Not)A;Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"127\", \"Not)A;Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"106\", \"Atom\";v=\"26\", \"Not;A=Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"106\", \"Atom\";v=\"26\", \"Not;A=Brand\";v=\"99\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"106\", \"Atom\";v=\"26\", \"Not;A=Brand\";v=\"99\"":1}},"skip":{"\"Chromium\";v=\"106\", \"Atom\";v=\"26\", \"Not;A=Brand\";v=\"99\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}}},"skip":{"deeper":{"?0":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}},"skip":{"\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"":1}}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"skip":{"deeper":{"?0":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}},"skip":{"\"Microsoft Edge\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"":1}}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":1}}},"skip":{"deeper":{"?0":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":1}},"skip":{"\"Not/A)Brand\";v=\"8\", \"Chromium\";v=\"132\", \"Google Chrome\";v=\"132\"":1}}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"skip":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":1}}},"skip":{"deeper":{"?0":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":1}},"skip":{"\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Brave\";v=\"146\"":1}}}}}},{"name":"Connection","parentNames":["user-agent","User-Agent"],"possibleValues":["*MISSING_VALUE*","keep-alive"],"conditionalProbabilities":{"deeper":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"*MISSING_VALUE*":{"deeper":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"keep-alive":0.9655172413793104,"*MISSING_VALUE*":0.034482758620689655},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"keep-alive":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"keep-alive":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"keep-alive":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"keep-alive":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"keep-alive":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"keep-alive":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"keep-alive":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"keep-alive":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"keep-alive":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"keep-alive":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":{"keep-alive":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1}},"skip":{"keep-alive":0.9727272727272728,"*MISSING_VALUE*":0.02727272727272727}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}}}},{"name":"te","parentNames":["user-agent","User-Agent"],"possibleValues":["*MISSING_VALUE*","trailers"],"conditionalProbabilities":{"deeper":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"*MISSING_VALUE*":{"deeper":{"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"trailers":0.9473684210526315,"*MISSING_VALUE*":0.05263157894736842}},"skip":{"trailers":0.9473684210526315,"*MISSING_VALUE*":0.05263157894736842}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":{"deeper":{"*MISSING_VALUE*":{"trailers":1}},"skip":{"trailers":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1}},"skip":{"*MISSING_VALUE*":1}}}}},{"name":"upgrade-insecure-requests","parentNames":["user-agent"],"possibleValues":["1","*MISSING_VALUE*"],"conditionalProbabilities":{"deeper":{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"*MISSING_VALUE*":{"1":0.01818181818181818,"*MISSING_VALUE*":0.9818181818181818},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"1":0.0035971223021582736,"*MISSING_VALUE*":0.9964028776978417},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1":{"1":0.07692307692307693,"*MISSING_VALUE*":0.9230769230769231},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 Edg/147.0.0.0":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:147.0) Gecko/20100101 Firefox/147.0":{"1":1},"Mozilla/5.0 (Android 16; Mobile; rv:150.0) Gecko/150.0 Firefox/150.0":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36 EdgA/147.0.0.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.8909.1591 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4450.0 Safari/537.36 LarkUrl":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 EdgA/143.0.0.0":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1 GrokApp/1.3.71":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36 Edg/148.0.0.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.56 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36 Edg/123.0.0.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_15 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.7444.138 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Android 13; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0":{"1":1},"Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.235 Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.9273.1293 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/144.0.7559.95 Mobile/15E148 Safari/604.1":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Mobile/23D127 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 Edg/142.0.0.0":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.3 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 12; X16DzOXpOQ; U; en) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.7204.63 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64; rv:149.0) Gecko/20100101 Firefox/149.0":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_7_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.8 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 15; SM-G991W Build/AP3A.240905.015.A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 CCleaner/146.0.34394.179":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64; rv:146.0) Gecko/20100101 Firefox/146.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_7_14 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 16_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.2 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 15; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.6723.73 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/23D8133 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/23E261 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64; rv:142.0) Gecko/20100101 Firefox/142.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPad; CPU OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.1 Mobile/15E148 Safari/604.1 Brave":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:149.0) Gecko/20100101 Firefox/149.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.7 Mobile/22H340 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7.2 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_8) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.4.1 Mobile/22E252 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.3179.54":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0":{"1":1},"Mozilla/5.0 (Linux; Android 16; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.7727.111 Mobile Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3 Safari/605.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.7 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.8 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Atom/26.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (iPhone; CPU iPhone OS 26_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.3.1 Mobile/15E148 Safari/604.1":{"*MISSING_VALUE*":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; WOW64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.6788.76 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15":{"1":1},"Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":1}}}},{"name":"Upgrade-Insecure-Requests","parentNames":["User-Agent"],"possibleValues":["*MISSING_VALUE*","1"],"conditionalProbabilities":{"deeper":{"*MISSING_VALUE*":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.9827586206896551,"*MISSING_VALUE*":0.017241379310344827},"Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.4 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36":{"1":0.9,"*MISSING_VALUE*":0.1},"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15":{"*MISSING_VALUE*":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36":{"1":1},"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko; compatible; pageburst) Chrome/147.0.7727.116 Safari/537.36":{"1":1},"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36":{"1":1}}}}]}
\ No newline at end of file
diff --git a/browser/vendor/browserforge-1.2.4/input-network.json b/browser/vendor/browserforge-1.2.4/input-network.json
new file mode 100644
index 000000000..1e997517f
--- /dev/null
+++ b/browser/vendor/browserforge-1.2.4/input-network.json
@@ -0,0 +1 @@
+{"nodes":[{"name":"*DEVICE","parentNames":[],"possibleValues":["desktop","mobile"],"conditionalProbabilities":{"desktop":0.9038895152198422,"mobile":0.09611048478015784}},{"name":"*OPERATING_SYSTEM","parentNames":["*DEVICE"],"possibleValues":["macos","windows","ios","android","linux","*MISSING_VALUE*"],"conditionalProbabilities":{"deeper":{"desktop":{"macos":0.3178983473651388,"windows":0.6556750857499221,"linux":0.025335204240723417,"*MISSING_VALUE*":0.001091362644215778},"mobile":{"ios":0.7573313782991202,"android":0.24266862170087977}}}},{"name":"*BROWSER_HTTP","parentNames":["*OPERATING_SYSTEM","*DEVICE"],"possibleValues":["chrome/147.0.0.0|2","edge/147.0.0.0|2","safari/26.4|2","chrome/147.0.0.0|1","safari/26.3|2","chrome/146.0.0.0|2","firefox/150.0|2","safari/26.2|2","safari/18.5|2","safari/26.0.1|2","firefox/135.0|2","chrome/148.0.0.0|2","chrome/142.0.0.0|2","safari/18.3|2","chrome/144.0.0.0|2","safari/18.2|2","safari/26.3.1|2","safari/18.7|2","edge/129.0.0.0|2","safari/18.7.4|2","safari/18.1|2","safari/18.6|2","safari/18.7.5|2","chrome/145.0.0.0|2","chrome/127.0.0.0|2","safari/16.6|2","chrome/141.0.0.0|2","edge/147.0.0.0|1","chrome/121.0.0.0|2","chrome/143.0.0.0|2","chrome/128.0.0.0|2","safari/17.2.1|2","safari/26.5|2","chrome/116.0.0.0|2","chrome/138.0.0.0|2","safari/26.1|2","safari/17.6|2","firefox/151.0|2","chrome/130.0.0.0|2","chrome/115.0.0.0|2","edge/146.0.0.0|2","chrome/149.0.0.0|2","chrome/140.0.0.0|2","safari/16.4|2","safari/18.1.1|2","edge/144.0.0.0|2","edge/128.0.0.0|2","chrome/109.0.0.0|2","chrome/139.0.0.0|2","edge/143.0.0.0|2","edge/146.0.0.0|1","safari/26.4|1","safari/17.4|2","chrome/143.0.0.0|1","chrome/131.0.0.0|2","safari/18.4|2","safari/18.0.1|2","chrome/134.0.0.0|2","safari/16.5.2|2","safari/26.4.2|2","chrome/120.0.0.0|2","chrome/137.0.0.0|2","safari/26.0|2","safari/16.6.1|2","firefox/147.0|2","edge/145.0.0.0|2","chrome/135.0.0.0|2","safari/18.5|1","safari/17.5|2","chrome/45.0.8909.1591|2","chrome/145.0.0.0|1","chrome/91.0.4450.0|2","safari/17.7|2","chrome/125.0.0.0|2","chrome/126.0.0.0|2","chrome/113.0.0.0|2","chrome/101.0.4951.54|2","chrome/108.0.0.0|2","edge/148.0.0.0|2","chrome/142.0.0.0|1","chrome/147.0.7727.56|2","safari/17.4.1|2","edge/123.0.0.0|2","chrome/136.0.0.0|2","safari/16.6.2|2","chrome/119.0.0.0|2","chrome/142.0.7444.138|2","safari/18.3.1|2","edge/138.0.0.0|2","chrome/146.0.0.0|1","firefox/136.0|2","chrome/114.0.0.0|2","safari/16.5|2","chrome/138.0.7204.235|2","chrome/59.0.9273.1293|2","chrome/144.0.7559.95|2","safari/17.3|2","edge/142.0.0.0|2","safari/18.7.3|2","chrome/138.0.7204.63|2","firefox/149.0|2","safari/17.8|2","safari/15.6.8|2","safari/17.3.1|2","chrome/147.0.7727.111|2","chrome/124.0.0.0|2","chrome/122.0.0.0|2","safari/15.6.7|2","chrome/107.0.0.0|2","firefox/146.0|2","edge/122.0.0.0|2","safari/16.2|2","chrome/103.0.0.0|2","chrome/90.0.4430.212|2","safari/17.1.2|2","chrome/132.0.0.0|2","safari/18.0|2","chrome/130.0.6723.73|2","chrome/133.0.0.0|2","firefox/142.0|2","safari/17.0|2","safari/17.1|2","chrome/96.0.4664.110|1","safari/18.7.7|2","chrome/147.0.7727.116|1","safari/18.7.2|2","safari/15.6.1|2","chrome/116.0.0.0|1","safari/17.2|2","safari/18.4.1|2","edge/135.0.3179.54|2","safari/26.4.1|2","chrome/106.0.0.0|2","safari/16.1|2","chrome/91.0.4472.124|2","chrome/132.0.6788.76|2","safari/16.3|2"],"conditionalProbabilities":{"deeper":{"macos":{"deeper":{"desktop":{"chrome/147.0.0.0|2":0.5461010299166258,"safari/26.4|2":0.09097596861206474,"chrome/146.0.0.0|2":0.06866110838646396,"firefox/150.0|2":0.005640019617459539,"safari/26.2|2":0.026483570377636097,"safari/26.3|2":0.02746444335458558,"safari/26.0.1|2":0.006620892594409024,"safari/18.3|2":0.004659146640510054,"chrome/144.0.0.0|2":0.005885237861696911,"safari/18.2|2":0.0012260912211868563,"safari/26.3.1|2":0.06302108876900442,"safari/18.1|2":0.005394801373222168,"safari/18.6|2":0.032614026483570376,"chrome/145.0.0.0|2":0.02501226091221187,"chrome/148.0.0.0|2":0.0063756743501716525,"safari/16.6|2":0.0014713094654242277,"safari/18.5|2":0.009073075036782736,"chrome/143.0.0.0|2":0.006130456105934282,"chrome/128.0.0.0|2":0.0012260912211868563,"safari/17.2.1|2":0.0002452182442373713,"chrome/116.0.0.0|2":0.000980872976949485,"chrome/138.0.0.0|2":0.006866110838646395,"safari/17.6|2":0.005885237861696911,"firefox/151.0|2":0.0004904364884747426,"chrome/115.0.0.0|2":0.0002452182442373713,"safari/26.5|2":0.006620892594409024,"chrome/149.0.0.0|2":0.0004904364884747426,"safari/16.4|2":0.0004904364884747426,"safari/18.1.1|2":0.0012260912211868563,"safari/26.1|2":0.005394801373222168,"safari/26.4|1":0.0002452182442373713,"safari/17.4|2":0.0007356547327121138,"chrome/147.0.0.0|1":0.0024521824423737125,"safari/18.0.1|2":0.0002452182442373713,"edge/147.0.0.0|2":0.005149583128984796,"safari/16.5.2|2":0.0002452182442373713,"safari/26.0|2":0.004413928396272682,"safari/16.6.1|2":0.0004904364884747426,"firefox/147.0|2":0.0004904364884747426,"safari/18.5|1":0.0004904364884747426,"safari/17.5|2":0.0029426189308484553,"chrome/91.0.4450.0|2":0.0007356547327121138,"safari/17.4.1|2":0.0012260912211868563,"firefox/135.0|2":0.0002452182442373713,"safari/18.4|2":0.0007356547327121138,"chrome/114.0.0.0|2":0.0029426189308484553,"safari/18.3.1|2":0.000980872976949485,"chrome/138.0.7204.235|2":0.0002452182442373713,"chrome/141.0.0.0|2":0.000980872976949485,"safari/17.3|2":0.0007356547327121138,"safari/15.6.8|2":0.0002452182442373713,"safari/17.3.1|2":0.000980872976949485,"chrome/107.0.0.0|2":0.0004904364884747426,"chrome/142.0.0.0|2":0.000980872976949485,"safari/16.5|2":0.000980872976949485,"chrome/103.0.0.0|2":0.0002452182442373713,"safari/17.1.2|2":0.0002452182442373713,"chrome/131.0.0.0|2":0.0004904364884747426,"safari/18.0|2":0.000980872976949485,"chrome/139.0.0.0|2":0.0004904364884747426,"chrome/140.0.0.0|2":0.0007356547327121138,"safari/17.0|2":0.0002452182442373713,"safari/17.1|2":0.0004904364884747426,"chrome/135.0.0.0|2":0.0002452182442373713,"firefox/149.0|2":0.0004904364884747426,"safari/15.6.1|2":0.0002452182442373713,"safari/17.2|2":0.0002452182442373713,"chrome/130.0.0.0|2":0.0004904364884747426,"chrome/127.0.0.0|2":0.0004904364884747426,"safari/16.1|2":0.0002452182442373713,"safari/16.3|2":0.0002452182442373713}},"skip":{"chrome/147.0.0.0|2":0.5461010299166258,"safari/26.4|2":0.09097596861206474,"chrome/146.0.0.0|2":0.06866110838646396,"firefox/150.0|2":0.005640019617459539,"safari/26.2|2":0.026483570377636097,"safari/26.3|2":0.02746444335458558,"safari/26.0.1|2":0.006620892594409024,"safari/18.3|2":0.004659146640510054,"chrome/144.0.0.0|2":0.005885237861696911,"safari/18.2|2":0.0012260912211868563,"safari/26.3.1|2":0.06302108876900442,"safari/18.1|2":0.005394801373222168,"safari/18.6|2":0.032614026483570376,"chrome/145.0.0.0|2":0.02501226091221187,"chrome/148.0.0.0|2":0.0063756743501716525,"safari/16.6|2":0.0014713094654242277,"safari/18.5|2":0.009073075036782736,"chrome/143.0.0.0|2":0.006130456105934282,"chrome/128.0.0.0|2":0.0012260912211868563,"safari/17.2.1|2":0.0002452182442373713,"chrome/116.0.0.0|2":0.000980872976949485,"chrome/138.0.0.0|2":0.006866110838646395,"safari/17.6|2":0.005885237861696911,"firefox/151.0|2":0.0004904364884747426,"chrome/115.0.0.0|2":0.0002452182442373713,"safari/26.5|2":0.006620892594409024,"chrome/149.0.0.0|2":0.0004904364884747426,"safari/16.4|2":0.0004904364884747426,"safari/18.1.1|2":0.0012260912211868563,"safari/26.1|2":0.005394801373222168,"safari/26.4|1":0.0002452182442373713,"safari/17.4|2":0.0007356547327121138,"chrome/147.0.0.0|1":0.0024521824423737125,"safari/18.0.1|2":0.0002452182442373713,"edge/147.0.0.0|2":0.005149583128984796,"safari/16.5.2|2":0.0002452182442373713,"safari/26.0|2":0.004413928396272682,"safari/16.6.1|2":0.0004904364884747426,"firefox/147.0|2":0.0004904364884747426,"safari/18.5|1":0.0004904364884747426,"safari/17.5|2":0.0029426189308484553,"chrome/91.0.4450.0|2":0.0007356547327121138,"safari/17.4.1|2":0.0012260912211868563,"firefox/135.0|2":0.0002452182442373713,"safari/18.4|2":0.0007356547327121138,"chrome/114.0.0.0|2":0.0029426189308484553,"safari/18.3.1|2":0.000980872976949485,"chrome/138.0.7204.235|2":0.0002452182442373713,"chrome/141.0.0.0|2":0.000980872976949485,"safari/17.3|2":0.0007356547327121138,"safari/15.6.8|2":0.0002452182442373713,"safari/17.3.1|2":0.000980872976949485,"chrome/107.0.0.0|2":0.0004904364884747426,"chrome/142.0.0.0|2":0.000980872976949485,"safari/16.5|2":0.000980872976949485,"chrome/103.0.0.0|2":0.0002452182442373713,"safari/17.1.2|2":0.0002452182442373713,"chrome/131.0.0.0|2":0.0004904364884747426,"safari/18.0|2":0.000980872976949485,"chrome/139.0.0.0|2":0.0004904364884747426,"chrome/140.0.0.0|2":0.0007356547327121138,"safari/17.0|2":0.0002452182442373713,"safari/17.1|2":0.0004904364884747426,"chrome/135.0.0.0|2":0.0002452182442373713,"firefox/149.0|2":0.0004904364884747426,"safari/15.6.1|2":0.0002452182442373713,"safari/17.2|2":0.0002452182442373713,"chrome/130.0.0.0|2":0.0004904364884747426,"chrome/127.0.0.0|2":0.0004904364884747426,"safari/16.1|2":0.0002452182442373713,"safari/16.3|2":0.0002452182442373713}},"windows":{"deeper":{"desktop":{"chrome/147.0.0.0|2":0.7963381286410652,"edge/147.0.0.0|2":0.10807276185946975,"chrome/147.0.0.0|1":0.006895731779812151,"firefox/135.0|2":0.0022589466175246702,"chrome/148.0.0.0|2":0.008322434906669837,"chrome/142.0.0.0|2":0.012245868505528475,"edge/129.0.0.0|2":0.0003566757817144216,"chrome/146.0.0.0|2":0.013315895850671739,"chrome/127.0.0.0|2":0.00011889192723814053,"chrome/145.0.0.0|2":0.012721436214481036,"chrome/141.0.0.0|2":0.001783378908572108,"edge/147.0.0.0|1":0.0021400546902865295,"chrome/121.0.0.0|2":0.0004755677089525621,"edge/146.0.0.0|2":0.0029722981809535134,"chrome/138.0.0.0|2":0.0019022708358102484,"chrome/140.0.0.0|2":0.0009511354179051242,"edge/144.0.0.0|2":0.00023778385447628106,"edge/128.0.0.0|2":0.00011889192723814053,"chrome/109.0.0.0|2":0.0029722981809535134,"chrome/139.0.0.0|2":0.0013078111996195458,"edge/143.0.0.0|2":0.0009511354179051242,"edge/146.0.0.0|1":0.0004755677089525621,"chrome/143.0.0.0|1":0.00011889192723814053,"chrome/131.0.0.0|2":0.0004755677089525621,"chrome/134.0.0.0|2":0.0007133515634288432,"chrome/130.0.0.0|2":0.0004755677089525621,"chrome/120.0.0.0|2":0.0003566757817144216,"chrome/137.0.0.0|2":0.0009511354179051242,"edge/145.0.0.0|2":0.0004755677089525621,"chrome/135.0.0.0|2":0.0010700273451432648,"chrome/143.0.0.0|2":0.0027345143264772324,"chrome/145.0.0.0|1":0.0003566757817144216,"chrome/144.0.0.0|2":0.002021162763048389,"chrome/125.0.0.0|2":0.0011889192723814053,"chrome/126.0.0.0|2":0.0005944596361907026,"chrome/113.0.0.0|2":0.00011889192723814053,"chrome/108.0.0.0|2":0.00023778385447628106,"edge/148.0.0.0|2":0.0021400546902865295,"chrome/142.0.0.0|1":0.00011889192723814053,"chrome/147.0.7727.56|2":0.0005944596361907026,"edge/123.0.0.0|2":0.0003566757817144216,"chrome/136.0.0.0|2":0.0005944596361907026,"chrome/149.0.0.0|2":0.0008322434906669837,"edge/138.0.0.0|2":0.00011889192723814053,"chrome/146.0.0.0|1":0.0007133515634288432,"edge/142.0.0.0|2":0.00023778385447628106,"firefox/150.0|2":0.0014267031268576863,"chrome/124.0.0.0|2":0.0003566757817144216,"chrome/122.0.0.0|2":0.0005944596361907026,"edge/122.0.0.0|2":0.00011889192723814053,"firefox/149.0|2":0.00023778385447628106,"chrome/132.0.0.0|2":0.0003566757817144216,"chrome/133.0.0.0|2":0.0005944596361907026,"chrome/96.0.4664.110|1":0.00011889192723814053,"chrome/128.0.0.0|2":0.0003566757817144216,"chrome/116.0.0.0|1":0.00011889192723814053,"edge/135.0.3179.54|2":0.00011889192723814053,"chrome/106.0.0.0|2":0.00023778385447628106,"firefox/147.0|2":0.00023778385447628106,"chrome/91.0.4472.124|2":0.0004755677089525621,"chrome/132.0.6788.76|2":0.00011889192723814053}},"skip":{"chrome/147.0.0.0|2":0.7963381286410652,"edge/147.0.0.0|2":0.10807276185946975,"chrome/147.0.0.0|1":0.006895731779812151,"firefox/135.0|2":0.0022589466175246702,"chrome/148.0.0.0|2":0.008322434906669837,"chrome/142.0.0.0|2":0.012245868505528475,"edge/129.0.0.0|2":0.0003566757817144216,"chrome/146.0.0.0|2":0.013315895850671739,"chrome/127.0.0.0|2":0.00011889192723814053,"chrome/145.0.0.0|2":0.012721436214481036,"chrome/141.0.0.0|2":0.001783378908572108,"edge/147.0.0.0|1":0.0021400546902865295,"chrome/121.0.0.0|2":0.0004755677089525621,"edge/146.0.0.0|2":0.0029722981809535134,"chrome/138.0.0.0|2":0.0019022708358102484,"chrome/140.0.0.0|2":0.0009511354179051242,"edge/144.0.0.0|2":0.00023778385447628106,"edge/128.0.0.0|2":0.00011889192723814053,"chrome/109.0.0.0|2":0.0029722981809535134,"chrome/139.0.0.0|2":0.0013078111996195458,"edge/143.0.0.0|2":0.0009511354179051242,"edge/146.0.0.0|1":0.0004755677089525621,"chrome/143.0.0.0|1":0.00011889192723814053,"chrome/131.0.0.0|2":0.0004755677089525621,"chrome/134.0.0.0|2":0.0007133515634288432,"chrome/130.0.0.0|2":0.0004755677089525621,"chrome/120.0.0.0|2":0.0003566757817144216,"chrome/137.0.0.0|2":0.0009511354179051242,"edge/145.0.0.0|2":0.0004755677089525621,"chrome/135.0.0.0|2":0.0010700273451432648,"chrome/143.0.0.0|2":0.0027345143264772324,"chrome/145.0.0.0|1":0.0003566757817144216,"chrome/144.0.0.0|2":0.002021162763048389,"chrome/125.0.0.0|2":0.0011889192723814053,"chrome/126.0.0.0|2":0.0005944596361907026,"chrome/113.0.0.0|2":0.00011889192723814053,"chrome/108.0.0.0|2":0.00023778385447628106,"edge/148.0.0.0|2":0.0021400546902865295,"chrome/142.0.0.0|1":0.00011889192723814053,"chrome/147.0.7727.56|2":0.0005944596361907026,"edge/123.0.0.0|2":0.0003566757817144216,"chrome/136.0.0.0|2":0.0005944596361907026,"chrome/149.0.0.0|2":0.0008322434906669837,"edge/138.0.0.0|2":0.00011889192723814053,"chrome/146.0.0.0|1":0.0007133515634288432,"edge/142.0.0.0|2":0.00023778385447628106,"firefox/150.0|2":0.0014267031268576863,"chrome/124.0.0.0|2":0.0003566757817144216,"chrome/122.0.0.0|2":0.0005944596361907026,"edge/122.0.0.0|2":0.00011889192723814053,"firefox/149.0|2":0.00023778385447628106,"chrome/132.0.0.0|2":0.0003566757817144216,"chrome/133.0.0.0|2":0.0005944596361907026,"chrome/96.0.4664.110|1":0.00011889192723814053,"chrome/128.0.0.0|2":0.0003566757817144216,"chrome/116.0.0.0|1":0.00011889192723814053,"edge/135.0.3179.54|2":0.00011889192723814053,"chrome/106.0.0.0|2":0.00023778385447628106,"firefox/147.0|2":0.00023778385447628106,"chrome/91.0.4472.124|2":0.0004755677089525621,"chrome/132.0.6788.76|2":0.00011889192723814053}},"ios":{"deeper":{"mobile":{"safari/26.3|2":0.4181994191674734,"safari/26.4|2":0.271055179090029,"safari/18.5|2":0.012584704743465635,"safari/18.7|2":0.003872216844143272,"safari/18.7.4|2":0.003872216844143272,"safari/26.2|2":0.06873184898354308,"safari/18.7.5|2":0.04259438528557599,"safari/18.3|2":0.005808325266214908,"safari/26.3.1|2":0.006776379477250726,"safari/26.5|2":0.03388189738625363,"safari/26.1|2":0.026137463697967087,"safari/18.6|2":0.02516940948693127,"safari/17.6|2":0.00968054211035818,"safari/18.2|2":0.003872216844143272,"safari/18.4|2":0.002904162633107454,"safari/26.4.2|2":0.007744433688286544,"chrome/45.0.8909.1591|2":0.000968054211035818,"safari/17.7|2":0.001936108422071636,"safari/16.6.2|2":0.00484027105517909,"safari/18.3.1|2":0.003872216844143272,"safari/16.5|2":0.001936108422071636,"chrome/144.0.7559.95|2":0.001936108422071636,"safari/18.7.3|2":0.002904162633107454,"safari/26.0|2":0.00484027105517909,"safari/17.8|2":0.000968054211035818,"safari/15.6.7|2":0.00484027105517909,"safari/16.6.1|2":0.000968054211035818,"safari/16.2|2":0.000968054211035818,"safari/17.4.1|2":0.000968054211035818,"safari/26.0.1|2":0.007744433688286544,"safari/18.7.7|2":0.000968054211035818,"safari/18.7.2|2":0.001936108422071636,"safari/18.4.1|2":0.000968054211035818,"safari/18.0|2":0.000968054211035818,"safari/15.6.8|2":0.010648596321393998,"safari/17.5|2":0.000968054211035818,"safari/26.4.1|2":0.000968054211035818}},"skip":{"safari/26.3|2":0.4181994191674734,"safari/26.4|2":0.271055179090029,"safari/18.5|2":0.012584704743465635,"safari/18.7|2":0.003872216844143272,"safari/18.7.4|2":0.003872216844143272,"safari/26.2|2":0.06873184898354308,"safari/18.7.5|2":0.04259438528557599,"safari/18.3|2":0.005808325266214908,"safari/26.3.1|2":0.006776379477250726,"safari/26.5|2":0.03388189738625363,"safari/26.1|2":0.026137463697967087,"safari/18.6|2":0.02516940948693127,"safari/17.6|2":0.00968054211035818,"safari/18.2|2":0.003872216844143272,"safari/18.4|2":0.002904162633107454,"safari/26.4.2|2":0.007744433688286544,"chrome/45.0.8909.1591|2":0.000968054211035818,"safari/17.7|2":0.001936108422071636,"safari/16.6.2|2":0.00484027105517909,"safari/18.3.1|2":0.003872216844143272,"safari/16.5|2":0.001936108422071636,"chrome/144.0.7559.95|2":0.001936108422071636,"safari/18.7.3|2":0.002904162633107454,"safari/26.0|2":0.00484027105517909,"safari/17.8|2":0.000968054211035818,"safari/15.6.7|2":0.00484027105517909,"safari/16.6.1|2":0.000968054211035818,"safari/16.2|2":0.000968054211035818,"safari/17.4.1|2":0.000968054211035818,"safari/26.0.1|2":0.007744433688286544,"safari/18.7.7|2":0.000968054211035818,"safari/18.7.2|2":0.001936108422071636,"safari/18.4.1|2":0.000968054211035818,"safari/18.0|2":0.000968054211035818,"safari/15.6.8|2":0.010648596321393998,"safari/17.5|2":0.000968054211035818,"safari/26.4.1|2":0.000968054211035818}},"android":{"deeper":{"mobile":{"chrome/147.0.0.0|2":0.7673716012084593,"chrome/138.0.0.0|2":0.04229607250755287,"edge/147.0.0.0|2":0.01812688821752266,"firefox/150.0|2":0.03323262839879154,"edge/143.0.0.0|2":0.006042296072507553,"chrome/119.0.0.0|2":0.01812688821752266,"chrome/142.0.7444.138|2":0.0030211480362537764,"firefox/136.0|2":0.0030211480362537764,"chrome/146.0.0.0|2":0.00906344410876133,"chrome/145.0.0.0|2":0.012084592145015106,"chrome/59.0.9273.1293|2":0.0030211480362537764,"chrome/143.0.0.0|2":0.012084592145015106,"chrome/138.0.7204.63|2":0.0030211480362537764,"chrome/147.0.7727.111|2":0.01812688821752266,"chrome/134.0.0.0|2":0.006042296072507553,"chrome/144.0.0.0|2":0.02416918429003021,"chrome/130.0.6723.73|2":0.0030211480362537764,"chrome/137.0.0.0|2":0.006042296072507553,"chrome/148.0.0.0|2":0.00906344410876133,"chrome/120.0.0.0|2":0.0030211480362537764}},"skip":{"chrome/147.0.0.0|2":0.7673716012084593,"chrome/138.0.0.0|2":0.04229607250755287,"edge/147.0.0.0|2":0.01812688821752266,"firefox/150.0|2":0.03323262839879154,"edge/143.0.0.0|2":0.006042296072507553,"chrome/119.0.0.0|2":0.01812688821752266,"chrome/142.0.7444.138|2":0.0030211480362537764,"firefox/136.0|2":0.0030211480362537764,"chrome/146.0.0.0|2":0.00906344410876133,"chrome/145.0.0.0|2":0.012084592145015106,"chrome/59.0.9273.1293|2":0.0030211480362537764,"chrome/143.0.0.0|2":0.012084592145015106,"chrome/138.0.7204.63|2":0.0030211480362537764,"chrome/147.0.7727.111|2":0.01812688821752266,"chrome/134.0.0.0|2":0.006042296072507553,"chrome/144.0.0.0|2":0.02416918429003021,"chrome/130.0.6723.73|2":0.0030211480362537764,"chrome/137.0.0.0|2":0.006042296072507553,"chrome/148.0.0.0|2":0.00906344410876133,"chrome/120.0.0.0|2":0.0030211480362537764}},"linux":{"deeper":{"desktop":{"chrome/147.0.0.0|2":0.5538461538461539,"chrome/146.0.0.0|2":0.13230769230769232,"chrome/148.0.0.0|2":0.006153846153846154,"chrome/145.0.0.0|2":0.06769230769230769,"chrome/130.0.0.0|2":0.006153846153846154,"chrome/140.0.0.0|2":0.009230769230769232,"chrome/143.0.0.0|2":0.015384615384615385,"chrome/142.0.0.0|2":0.006153846153846154,"chrome/101.0.4951.54|2":0.03076923076923077,"chrome/144.0.0.0|2":0.03076923076923077,"firefox/150.0|2":0.036923076923076927,"chrome/136.0.0.0|2":0.003076923076923077,"firefox/149.0|2":0.009230769230769232,"chrome/134.0.0.0|2":0.006153846153846154,"firefox/146.0|2":0.006153846153846154,"chrome/90.0.4430.212|2":0.003076923076923077,"chrome/126.0.0.0|2":0.006153846153846154,"chrome/141.0.0.0|2":0.003076923076923077,"chrome/131.0.0.0|2":0.015384615384615385,"chrome/149.0.0.0|2":0.006153846153846154,"chrome/137.0.0.0|2":0.006153846153846154,"firefox/142.0|2":0.006153846153846154,"chrome/135.0.0.0|2":0.003076923076923077,"chrome/147.0.7727.116|1":0.012307692307692308,"edge/145.0.0.0|2":0.003076923076923077,"edge/147.0.0.0|2":0.003076923076923077,"chrome/138.0.0.0|2":0.009230769230769232,"edge/143.0.0.0|2":0.003076923076923077}},"skip":{"chrome/147.0.0.0|2":0.5538461538461539,"chrome/146.0.0.0|2":0.13230769230769232,"chrome/148.0.0.0|2":0.006153846153846154,"chrome/145.0.0.0|2":0.06769230769230769,"chrome/130.0.0.0|2":0.006153846153846154,"chrome/140.0.0.0|2":0.009230769230769232,"chrome/143.0.0.0|2":0.015384615384615385,"chrome/142.0.0.0|2":0.006153846153846154,"chrome/101.0.4951.54|2":0.03076923076923077,"chrome/144.0.0.0|2":0.03076923076923077,"firefox/150.0|2":0.036923076923076927,"chrome/136.0.0.0|2":0.003076923076923077,"firefox/149.0|2":0.009230769230769232,"chrome/134.0.0.0|2":0.006153846153846154,"firefox/146.0|2":0.006153846153846154,"chrome/90.0.4430.212|2":0.003076923076923077,"chrome/126.0.0.0|2":0.006153846153846154,"chrome/141.0.0.0|2":0.003076923076923077,"chrome/131.0.0.0|2":0.015384615384615385,"chrome/149.0.0.0|2":0.006153846153846154,"chrome/137.0.0.0|2":0.006153846153846154,"firefox/142.0|2":0.006153846153846154,"chrome/135.0.0.0|2":0.003076923076923077,"chrome/147.0.7727.116|1":0.012307692307692308,"edge/145.0.0.0|2":0.003076923076923077,"edge/147.0.0.0|2":0.003076923076923077,"chrome/138.0.0.0|2":0.009230769230769232,"edge/143.0.0.0|2":0.003076923076923077}},"*MISSING_VALUE*":{"deeper":{"desktop":{"chrome/147.0.0.0|1":0.07142857142857142,"chrome/147.0.0.0|2":0.5714285714285714,"chrome/146.0.0.0|2":0.14285714285714285,"chrome/126.0.0.0|2":0.14285714285714285,"chrome/144.0.0.0|2":0.07142857142857142}},"skip":{"chrome/147.0.0.0|1":0.07142857142857142,"chrome/147.0.0.0|2":0.5714285714285714,"chrome/146.0.0.0|2":0.14285714285714285,"chrome/126.0.0.0|2":0.14285714285714285,"chrome/144.0.0.0|2":0.07142857142857142}}}}},{"name":"*HTTP_VERSION","parentNames":["*BROWSER_HTTP"],"possibleValues":["_2.0_","_1.1_"],"conditionalProbabilities":{"deeper":{"chrome/147.0.0.0|2":{"_2.0_":1},"edge/147.0.0.0|2":{"_2.0_":1},"safari/26.4|2":{"_2.0_":1},"chrome/147.0.0.0|1":{"_1.1_":1},"safari/26.3|2":{"_2.0_":1},"chrome/146.0.0.0|2":{"_2.0_":1},"firefox/150.0|2":{"_2.0_":1},"safari/26.2|2":{"_2.0_":1},"safari/18.5|2":{"_2.0_":1},"safari/26.0.1|2":{"_2.0_":1},"firefox/135.0|2":{"_2.0_":1},"chrome/148.0.0.0|2":{"_2.0_":1},"chrome/142.0.0.0|2":{"_2.0_":1},"safari/18.3|2":{"_2.0_":1},"chrome/144.0.0.0|2":{"_2.0_":1},"safari/18.2|2":{"_2.0_":1},"safari/26.3.1|2":{"_2.0_":1},"safari/18.7|2":{"_2.0_":1},"edge/129.0.0.0|2":{"_2.0_":1},"safari/18.7.4|2":{"_2.0_":1},"safari/18.1|2":{"_2.0_":1},"safari/18.6|2":{"_2.0_":1},"safari/18.7.5|2":{"_2.0_":1},"chrome/145.0.0.0|2":{"_2.0_":1},"chrome/127.0.0.0|2":{"_2.0_":1},"safari/16.6|2":{"_2.0_":1},"chrome/141.0.0.0|2":{"_2.0_":1},"edge/147.0.0.0|1":{"_1.1_":1},"chrome/121.0.0.0|2":{"_2.0_":1},"chrome/143.0.0.0|2":{"_2.0_":1},"chrome/128.0.0.0|2":{"_2.0_":1},"safari/17.2.1|2":{"_2.0_":1},"safari/26.5|2":{"_2.0_":1},"chrome/116.0.0.0|2":{"_2.0_":1},"chrome/138.0.0.0|2":{"_2.0_":1},"safari/26.1|2":{"_2.0_":1},"safari/17.6|2":{"_2.0_":1},"firefox/151.0|2":{"_2.0_":1},"chrome/130.0.0.0|2":{"_2.0_":1},"chrome/115.0.0.0|2":{"_2.0_":1},"edge/146.0.0.0|2":{"_2.0_":1},"chrome/149.0.0.0|2":{"_2.0_":1},"chrome/140.0.0.0|2":{"_2.0_":1},"safari/16.4|2":{"_2.0_":1},"safari/18.1.1|2":{"_2.0_":1},"edge/144.0.0.0|2":{"_2.0_":1},"edge/128.0.0.0|2":{"_2.0_":1},"chrome/109.0.0.0|2":{"_2.0_":1},"chrome/139.0.0.0|2":{"_2.0_":1},"edge/143.0.0.0|2":{"_2.0_":1},"edge/146.0.0.0|1":{"_1.1_":1},"safari/26.4|1":{"_1.1_":1},"safari/17.4|2":{"_2.0_":1},"chrome/143.0.0.0|1":{"_1.1_":1},"chrome/131.0.0.0|2":{"_2.0_":1},"safari/18.4|2":{"_2.0_":1},"safari/18.0.1|2":{"_2.0_":1},"chrome/134.0.0.0|2":{"_2.0_":1},"safari/16.5.2|2":{"_2.0_":1},"safari/26.4.2|2":{"_2.0_":1},"chrome/120.0.0.0|2":{"_2.0_":1},"chrome/137.0.0.0|2":{"_2.0_":1},"safari/26.0|2":{"_2.0_":1},"safari/16.6.1|2":{"_2.0_":1},"firefox/147.0|2":{"_2.0_":1},"edge/145.0.0.0|2":{"_2.0_":1},"chrome/135.0.0.0|2":{"_2.0_":1},"safari/18.5|1":{"_1.1_":1},"safari/17.5|2":{"_2.0_":1},"chrome/45.0.8909.1591|2":{"_2.0_":1},"chrome/145.0.0.0|1":{"_1.1_":1},"chrome/91.0.4450.0|2":{"_2.0_":1},"safari/17.7|2":{"_2.0_":1},"chrome/125.0.0.0|2":{"_2.0_":1},"chrome/126.0.0.0|2":{"_2.0_":1},"chrome/113.0.0.0|2":{"_2.0_":1},"chrome/101.0.4951.54|2":{"_2.0_":1},"chrome/108.0.0.0|2":{"_2.0_":1},"edge/148.0.0.0|2":{"_2.0_":1},"chrome/142.0.0.0|1":{"_1.1_":1},"chrome/147.0.7727.56|2":{"_2.0_":1},"safari/17.4.1|2":{"_2.0_":1},"edge/123.0.0.0|2":{"_2.0_":1},"chrome/136.0.0.0|2":{"_2.0_":1},"safari/16.6.2|2":{"_2.0_":1},"chrome/119.0.0.0|2":{"_2.0_":1},"chrome/142.0.7444.138|2":{"_2.0_":1},"safari/18.3.1|2":{"_2.0_":1},"edge/138.0.0.0|2":{"_2.0_":1},"chrome/146.0.0.0|1":{"_1.1_":1},"firefox/136.0|2":{"_2.0_":1},"chrome/114.0.0.0|2":{"_2.0_":1},"safari/16.5|2":{"_2.0_":1},"chrome/138.0.7204.235|2":{"_2.0_":1},"chrome/59.0.9273.1293|2":{"_2.0_":1},"chrome/144.0.7559.95|2":{"_2.0_":1},"safari/17.3|2":{"_2.0_":1},"edge/142.0.0.0|2":{"_2.0_":1},"safari/18.7.3|2":{"_2.0_":1},"chrome/138.0.7204.63|2":{"_2.0_":1},"firefox/149.0|2":{"_2.0_":1},"safari/17.8|2":{"_2.0_":1},"safari/15.6.8|2":{"_2.0_":1},"safari/17.3.1|2":{"_2.0_":1},"chrome/147.0.7727.111|2":{"_2.0_":1},"chrome/124.0.0.0|2":{"_2.0_":1},"chrome/122.0.0.0|2":{"_2.0_":1},"safari/15.6.7|2":{"_2.0_":1},"chrome/107.0.0.0|2":{"_2.0_":1},"firefox/146.0|2":{"_2.0_":1},"edge/122.0.0.0|2":{"_2.0_":1},"safari/16.2|2":{"_2.0_":1},"chrome/103.0.0.0|2":{"_2.0_":1},"chrome/90.0.4430.212|2":{"_2.0_":1},"safari/17.1.2|2":{"_2.0_":1},"chrome/132.0.0.0|2":{"_2.0_":1},"safari/18.0|2":{"_2.0_":1},"chrome/130.0.6723.73|2":{"_2.0_":1},"chrome/133.0.0.0|2":{"_2.0_":1},"firefox/142.0|2":{"_2.0_":1},"safari/17.0|2":{"_2.0_":1},"safari/17.1|2":{"_2.0_":1},"chrome/96.0.4664.110|1":{"_1.1_":1},"safari/18.7.7|2":{"_2.0_":1},"chrome/147.0.7727.116|1":{"_1.1_":1},"safari/18.7.2|2":{"_2.0_":1},"safari/15.6.1|2":{"_2.0_":1},"chrome/116.0.0.0|1":{"_1.1_":1},"safari/17.2|2":{"_2.0_":1},"safari/18.4.1|2":{"_2.0_":1},"edge/135.0.3179.54|2":{"_2.0_":1},"safari/26.4.1|2":{"_2.0_":1},"chrome/106.0.0.0|2":{"_2.0_":1},"safari/16.1|2":{"_2.0_":1},"chrome/91.0.4472.124|2":{"_2.0_":1},"chrome/132.0.6788.76|2":{"_2.0_":1},"safari/16.3|2":{"_2.0_":1}}}},{"name":"*BROWSER","parentNames":["*BROWSER_HTTP"],"possibleValues":["chrome/147.0.0.0","edge/147.0.0.0","safari/26.4","safari/26.3","chrome/146.0.0.0","firefox/150.0","safari/26.2","safari/18.5","safari/26.0.1","firefox/135.0","chrome/148.0.0.0","chrome/142.0.0.0","safari/18.3","chrome/144.0.0.0","safari/18.2","safari/26.3.1","safari/18.7","edge/129.0.0.0","safari/18.7.4","safari/18.1","safari/18.6","safari/18.7.5","chrome/145.0.0.0","chrome/127.0.0.0","safari/16.6","chrome/141.0.0.0","chrome/121.0.0.0","chrome/143.0.0.0","chrome/128.0.0.0","safari/17.2.1","safari/26.5","chrome/116.0.0.0","chrome/138.0.0.0","safari/26.1","safari/17.6","firefox/151.0","chrome/130.0.0.0","chrome/115.0.0.0","edge/146.0.0.0","chrome/149.0.0.0","chrome/140.0.0.0","safari/16.4","safari/18.1.1","edge/144.0.0.0","edge/128.0.0.0","chrome/109.0.0.0","chrome/139.0.0.0","edge/143.0.0.0","safari/17.4","chrome/131.0.0.0","safari/18.4","safari/18.0.1","chrome/134.0.0.0","safari/16.5.2","safari/26.4.2","chrome/120.0.0.0","chrome/137.0.0.0","safari/26.0","safari/16.6.1","firefox/147.0","edge/145.0.0.0","chrome/135.0.0.0","safari/17.5","chrome/45.0.8909.1591","chrome/91.0.4450.0","safari/17.7","chrome/125.0.0.0","chrome/126.0.0.0","chrome/113.0.0.0","chrome/101.0.4951.54","chrome/108.0.0.0","edge/148.0.0.0","chrome/147.0.7727.56","safari/17.4.1","edge/123.0.0.0","chrome/136.0.0.0","safari/16.6.2","chrome/119.0.0.0","chrome/142.0.7444.138","safari/18.3.1","edge/138.0.0.0","firefox/136.0","chrome/114.0.0.0","safari/16.5","chrome/138.0.7204.235","chrome/59.0.9273.1293","chrome/144.0.7559.95","safari/17.3","edge/142.0.0.0","safari/18.7.3","chrome/138.0.7204.63","firefox/149.0","safari/17.8","safari/15.6.8","safari/17.3.1","chrome/147.0.7727.111","chrome/124.0.0.0","chrome/122.0.0.0","safari/15.6.7","chrome/107.0.0.0","firefox/146.0","edge/122.0.0.0","safari/16.2","chrome/103.0.0.0","chrome/90.0.4430.212","safari/17.1.2","chrome/132.0.0.0","safari/18.0","chrome/130.0.6723.73","chrome/133.0.0.0","firefox/142.0","safari/17.0","safari/17.1","chrome/96.0.4664.110","safari/18.7.7","chrome/147.0.7727.116","safari/18.7.2","safari/15.6.1","safari/17.2","safari/18.4.1","edge/135.0.3179.54","safari/26.4.1","chrome/106.0.0.0","safari/16.1","chrome/91.0.4472.124","chrome/132.0.6788.76","safari/16.3"],"conditionalProbabilities":{"deeper":{"chrome/147.0.0.0|2":{"chrome/147.0.0.0":1},"edge/147.0.0.0|2":{"edge/147.0.0.0":1},"safari/26.4|2":{"safari/26.4":1},"chrome/147.0.0.0|1":{"chrome/147.0.0.0":1},"safari/26.3|2":{"safari/26.3":1},"chrome/146.0.0.0|2":{"chrome/146.0.0.0":1},"firefox/150.0|2":{"firefox/150.0":1},"safari/26.2|2":{"safari/26.2":1},"safari/18.5|2":{"safari/18.5":1},"safari/26.0.1|2":{"safari/26.0.1":1},"firefox/135.0|2":{"firefox/135.0":1},"chrome/148.0.0.0|2":{"chrome/148.0.0.0":1},"chrome/142.0.0.0|2":{"chrome/142.0.0.0":1},"safari/18.3|2":{"safari/18.3":1},"chrome/144.0.0.0|2":{"chrome/144.0.0.0":1},"safari/18.2|2":{"safari/18.2":1},"safari/26.3.1|2":{"safari/26.3.1":1},"safari/18.7|2":{"safari/18.7":1},"edge/129.0.0.0|2":{"edge/129.0.0.0":1},"safari/18.7.4|2":{"safari/18.7.4":1},"safari/18.1|2":{"safari/18.1":1},"safari/18.6|2":{"safari/18.6":1},"safari/18.7.5|2":{"safari/18.7.5":1},"chrome/145.0.0.0|2":{"chrome/145.0.0.0":1},"chrome/127.0.0.0|2":{"chrome/127.0.0.0":1},"safari/16.6|2":{"safari/16.6":1},"chrome/141.0.0.0|2":{"chrome/141.0.0.0":1},"edge/147.0.0.0|1":{"edge/147.0.0.0":1},"chrome/121.0.0.0|2":{"chrome/121.0.0.0":1},"chrome/143.0.0.0|2":{"chrome/143.0.0.0":1},"chrome/128.0.0.0|2":{"chrome/128.0.0.0":1},"safari/17.2.1|2":{"safari/17.2.1":1},"safari/26.5|2":{"safari/26.5":1},"chrome/116.0.0.0|2":{"chrome/116.0.0.0":1},"chrome/138.0.0.0|2":{"chrome/138.0.0.0":1},"safari/26.1|2":{"safari/26.1":1},"safari/17.6|2":{"safari/17.6":1},"firefox/151.0|2":{"firefox/151.0":1},"chrome/130.0.0.0|2":{"chrome/130.0.0.0":1},"chrome/115.0.0.0|2":{"chrome/115.0.0.0":1},"edge/146.0.0.0|2":{"edge/146.0.0.0":1},"chrome/149.0.0.0|2":{"chrome/149.0.0.0":1},"chrome/140.0.0.0|2":{"chrome/140.0.0.0":1},"safari/16.4|2":{"safari/16.4":1},"safari/18.1.1|2":{"safari/18.1.1":1},"edge/144.0.0.0|2":{"edge/144.0.0.0":1},"edge/128.0.0.0|2":{"edge/128.0.0.0":1},"chrome/109.0.0.0|2":{"chrome/109.0.0.0":1},"chrome/139.0.0.0|2":{"chrome/139.0.0.0":1},"edge/143.0.0.0|2":{"edge/143.0.0.0":1},"edge/146.0.0.0|1":{"edge/146.0.0.0":1},"safari/26.4|1":{"safari/26.4":1},"safari/17.4|2":{"safari/17.4":1},"chrome/143.0.0.0|1":{"chrome/143.0.0.0":1},"chrome/131.0.0.0|2":{"chrome/131.0.0.0":1},"safari/18.4|2":{"safari/18.4":1},"safari/18.0.1|2":{"safari/18.0.1":1},"chrome/134.0.0.0|2":{"chrome/134.0.0.0":1},"safari/16.5.2|2":{"safari/16.5.2":1},"safari/26.4.2|2":{"safari/26.4.2":1},"chrome/120.0.0.0|2":{"chrome/120.0.0.0":1},"chrome/137.0.0.0|2":{"chrome/137.0.0.0":1},"safari/26.0|2":{"safari/26.0":1},"safari/16.6.1|2":{"safari/16.6.1":1},"firefox/147.0|2":{"firefox/147.0":1},"edge/145.0.0.0|2":{"edge/145.0.0.0":1},"chrome/135.0.0.0|2":{"chrome/135.0.0.0":1},"safari/18.5|1":{"safari/18.5":1},"safari/17.5|2":{"safari/17.5":1},"chrome/45.0.8909.1591|2":{"chrome/45.0.8909.1591":1},"chrome/145.0.0.0|1":{"chrome/145.0.0.0":1},"chrome/91.0.4450.0|2":{"chrome/91.0.4450.0":1},"safari/17.7|2":{"safari/17.7":1},"chrome/125.0.0.0|2":{"chrome/125.0.0.0":1},"chrome/126.0.0.0|2":{"chrome/126.0.0.0":1},"chrome/113.0.0.0|2":{"chrome/113.0.0.0":1},"chrome/101.0.4951.54|2":{"chrome/101.0.4951.54":1},"chrome/108.0.0.0|2":{"chrome/108.0.0.0":1},"edge/148.0.0.0|2":{"edge/148.0.0.0":1},"chrome/142.0.0.0|1":{"chrome/142.0.0.0":1},"chrome/147.0.7727.56|2":{"chrome/147.0.7727.56":1},"safari/17.4.1|2":{"safari/17.4.1":1},"edge/123.0.0.0|2":{"edge/123.0.0.0":1},"chrome/136.0.0.0|2":{"chrome/136.0.0.0":1},"safari/16.6.2|2":{"safari/16.6.2":1},"chrome/119.0.0.0|2":{"chrome/119.0.0.0":1},"chrome/142.0.7444.138|2":{"chrome/142.0.7444.138":1},"safari/18.3.1|2":{"safari/18.3.1":1},"edge/138.0.0.0|2":{"edge/138.0.0.0":1},"chrome/146.0.0.0|1":{"chrome/146.0.0.0":1},"firefox/136.0|2":{"firefox/136.0":1},"chrome/114.0.0.0|2":{"chrome/114.0.0.0":1},"safari/16.5|2":{"safari/16.5":1},"chrome/138.0.7204.235|2":{"chrome/138.0.7204.235":1},"chrome/59.0.9273.1293|2":{"chrome/59.0.9273.1293":1},"chrome/144.0.7559.95|2":{"chrome/144.0.7559.95":1},"safari/17.3|2":{"safari/17.3":1},"edge/142.0.0.0|2":{"edge/142.0.0.0":1},"safari/18.7.3|2":{"safari/18.7.3":1},"chrome/138.0.7204.63|2":{"chrome/138.0.7204.63":1},"firefox/149.0|2":{"firefox/149.0":1},"safari/17.8|2":{"safari/17.8":1},"safari/15.6.8|2":{"safari/15.6.8":1},"safari/17.3.1|2":{"safari/17.3.1":1},"chrome/147.0.7727.111|2":{"chrome/147.0.7727.111":1},"chrome/124.0.0.0|2":{"chrome/124.0.0.0":1},"chrome/122.0.0.0|2":{"chrome/122.0.0.0":1},"safari/15.6.7|2":{"safari/15.6.7":1},"chrome/107.0.0.0|2":{"chrome/107.0.0.0":1},"firefox/146.0|2":{"firefox/146.0":1},"edge/122.0.0.0|2":{"edge/122.0.0.0":1},"safari/16.2|2":{"safari/16.2":1},"chrome/103.0.0.0|2":{"chrome/103.0.0.0":1},"chrome/90.0.4430.212|2":{"chrome/90.0.4430.212":1},"safari/17.1.2|2":{"safari/17.1.2":1},"chrome/132.0.0.0|2":{"chrome/132.0.0.0":1},"safari/18.0|2":{"safari/18.0":1},"chrome/130.0.6723.73|2":{"chrome/130.0.6723.73":1},"chrome/133.0.0.0|2":{"chrome/133.0.0.0":1},"firefox/142.0|2":{"firefox/142.0":1},"safari/17.0|2":{"safari/17.0":1},"safari/17.1|2":{"safari/17.1":1},"chrome/96.0.4664.110|1":{"chrome/96.0.4664.110":1},"safari/18.7.7|2":{"safari/18.7.7":1},"chrome/147.0.7727.116|1":{"chrome/147.0.7727.116":1},"safari/18.7.2|2":{"safari/18.7.2":1},"safari/15.6.1|2":{"safari/15.6.1":1},"chrome/116.0.0.0|1":{"chrome/116.0.0.0":1},"safari/17.2|2":{"safari/17.2":1},"safari/18.4.1|2":{"safari/18.4.1":1},"edge/135.0.3179.54|2":{"edge/135.0.3179.54":1},"safari/26.4.1|2":{"safari/26.4.1":1},"chrome/106.0.0.0|2":{"chrome/106.0.0.0":1},"safari/16.1|2":{"safari/16.1":1},"chrome/91.0.4472.124|2":{"chrome/91.0.4472.124":1},"chrome/132.0.6788.76|2":{"chrome/132.0.6788.76":1},"safari/16.3|2":{"safari/16.3":1}}}}]}
\ No newline at end of file
diff --git a/browser/vendor/cssselect/Cargo.toml b/browser/vendor/cssselect/Cargo.toml
new file mode 100644
index 000000000..588d551e3
--- /dev/null
+++ b/browser/vendor/cssselect/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "cssselect"
+version = "0.2.0"
+edition = "2021"
+license = "BSD-3-Clause"
+description = "Repository-owned Scrapling compatibility fork of cssselect"
+
+[features]
+default = ["std"]
+std = []
+
+[lib]
+path = "src/lib.rs"
+
+[dev-dependencies]
+sxd-document = "0.3"
+sxd-xpath = "0.4"
diff --git a/browser/vendor/cssselect/LICENSE b/browser/vendor/cssselect/LICENSE
new file mode 100644
index 000000000..98531f7f2
--- /dev/null
+++ b/browser/vendor/cssselect/LICENSE
@@ -0,0 +1,32 @@
+Copyright (c) 2007-2012 Ian Bicking and contributors. See AUTHORS for
+more details.
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms of the software as well
+as documentation, with or without modification, are permitted provided
+that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+* The names of the contributors may not be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+
+THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
+NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
diff --git a/browser/vendor/cssselect/README.md b/browser/vendor/cssselect/README.md
new file mode 100644
index 000000000..7e8eadf21
--- /dev/null
+++ b/browser/vendor/cssselect/README.md
@@ -0,0 +1,62 @@
+# cssselect
+
+Translate CSS3 selectors into XPath 1.0 expression strings.
+
+This crate parses a CSS group of selectors and emits XPath 1.0 strings. It does
+no DOM matching and no I/O. The whole library is a pure string to string
+transformation. It needs `alloc` but not `std`, so it builds for `no_std` and
+`wasm32` targets with zero runtime dependencies.
+
+## Installation
+
+```toml
+[dependencies]
+cssselect = "0.1"
+```
+
+## Usage
+
+```rust
+use cssselect::GenericTranslator;
+
+let xpath = GenericTranslator::new()
+ .css_to_xpath("a#bar")
+ .unwrap();
+assert_eq!(xpath, "descendant-or-self::a[@id = 'bar']");
+```
+
+`GenericTranslator` targets generic XML. `HtmlTranslator` targets (X)HTML with
+case-insensitive names and HTML-aware results for `:checked`, `:disabled`,
+`:enabled`, `:link`, and `:lang()`.
+
+Call `parse` directly when you need the parsed tree, the canonical CSS form, or
+the specificity:
+
+```rust
+use cssselect::parse;
+
+let selector = &parse(":is(.foo, #bar)").unwrap()[0];
+assert_eq!(selector.canonical(), ":is(.foo, #bar)");
+assert_eq!(selector.specificity(), (1, 0, 0));
+```
+
+## Supported selectors
+
+Type, universal, namespace, class, id, and attribute selectors with the `=`,
+`~=`, `|=`, `^=`, `$=`, `*=`, and `!=` operators. Structural pseudo-classes
+including the `:nth-*` family, `:not()`, `:is()`, `:matches()`, `:where()`,
+`:has()`, and `:scope`. Pseudo-elements with one or two colons. The four
+combinators: descendant, `>`, `+`, and `~`.
+
+## Tests
+
+`cargo test` runs the string-parity suite with no dependencies. The optional
+selection tier runs generated XPath against a real engine:
+
+```sh
+cargo test --features xpath-engine-tests
+```
+
+## License
+
+Licensed under the [BSD 3-Clause license](LICENSE).
diff --git a/browser/vendor/cssselect/src/error.rs b/browser/vendor/cssselect/src/error.rs
new file mode 100644
index 000000000..77a46bfa9
--- /dev/null
+++ b/browser/vendor/cssselect/src/error.rs
@@ -0,0 +1,29 @@
+//! Error type for parsing and translation.
+
+use alloc::string::String;
+use core::fmt;
+
+/// Failure from parsing a selector or translating it to XPath.
+///
+/// `Syntax` comes from the parser when the grammar is wrong. `Expression`
+/// comes from the translator when a selector is valid but cannot be expressed
+/// in XPath 1.0 or names an unknown pseudo-class.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SelectorError {
+ /// A parse-time grammar error. The message matches the parser output.
+ Syntax(String),
+ /// A translate-time error. The message matches the translator output.
+ Expression(String),
+}
+
+impl fmt::Display for SelectorError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ SelectorError::Syntax(msg) => f.write_str(msg),
+ SelectorError::Expression(msg) => f.write_str(msg),
+ }
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SelectorError {}
diff --git a/browser/vendor/cssselect/src/html.rs b/browser/vendor/cssselect/src/html.rs
new file mode 100644
index 000000000..059b128e4
--- /dev/null
+++ b/browser/vendor/cssselect/src/html.rs
@@ -0,0 +1,88 @@
+//! (X)HTML translator.
+//!
+//! This translator reuses the generic engine with HTML-specific settings. It
+//! folds element and attribute names to lower case unless built for XHTML, uses
+//! the `lang` attribute for `:lang()`, and gives HTML-aware results for
+//! `:checked`, `:disabled`, `:enabled`, and `:link`.
+
+use alloc::string::String;
+
+use crate::error::SelectorError;
+use crate::parser::Selector;
+use crate::xpath::{css_to_xpath, selector_to_xpath, Config, PseudoElements};
+
+/// Translator that targets (X)HTML.
+///
+/// Folds element and attribute names to lower case unless built for XHTML.
+#[derive(Debug, Clone)]
+pub struct HtmlTranslator {
+ config: Config,
+ xhtml: bool,
+}
+
+impl Default for HtmlTranslator {
+ fn default() -> Self {
+ HtmlTranslator::new()
+ }
+}
+
+impl HtmlTranslator {
+ /// Create an HTML translator. Element and attribute names fold to lower case.
+ pub fn new() -> Self {
+ HtmlTranslator::with_xhtml(false)
+ }
+
+ /// Create a translator with the XHTML flag set as given.
+ ///
+ /// With `xhtml = true`, names stay case sensitive.
+ pub fn with_xhtml(xhtml: bool) -> Self {
+ HtmlTranslator {
+ config: Config::html(xhtml),
+ xhtml,
+ }
+ }
+
+ /// Whether this translator treats input as XHTML.
+ pub fn is_xhtml(&self) -> bool {
+ self.xhtml
+ }
+
+ /// Translate a CSS group of selectors to an XPath string.
+ ///
+ /// The default prefix scopes selectors to the context node's subtree.
+ pub fn css_to_xpath(&self, css: &str) -> Result<String, SelectorError> {
+ css_to_xpath(&self.config, css, "descendant-or-self::")
+ }
+
+ /// Translate a CSS group of selectors using an explicit prefix.
+ pub fn css_to_xpath_with_prefix(
+ &self,
+ css: &str,
+ prefix: &str,
+ ) -> Result<String, SelectorError> {
+ css_to_xpath(&self.config, css, prefix)
+ }
+
+ /// Translate a single parsed selector to an XPath string.
+ ///
+ /// The pseudo-element is ignored.
+ pub fn selector_to_xpath(&self, selector: &Selector) -> Result<String, SelectorError> {
+ selector_to_xpath(
+ &self.config,
+ selector,
+ "descendant-or-self::",
+ PseudoElements::Ignore,
+ )
+ }
+
+ /// Translate a single parsed selector with an explicit prefix and
+ /// pseudo-element handling.
+ pub fn selector_to_xpath_with(
+ &self,
+ selector: &Selector,
+ prefix: &str,
+ pseudo_elements: PseudoElements,
+ ) -> Result<String, SelectorError> {
+ selector_to_xpath(&self.config, selector, prefix, pseudo_elements)
+ }
+}
diff --git a/browser/vendor/cssselect/src/lib.rs b/browser/vendor/cssselect/src/lib.rs
new file mode 100644
index 000000000..030bb2b26
--- /dev/null
+++ b/browser/vendor/cssselect/src/lib.rs
@@ -0,0 +1,52 @@
+//! Translate CSS3 selectors into XPath 1.0 expression strings.
+//!
+//! This crate parses a CSS group of selectors into an abstract syntax tree and
+//! translates each selector into an XPath 1.0 string. It does no DOM matching
+//! and no I/O. The whole library is a pure string to string transformation.
+//!
+//! Two translators are available. [`GenericTranslator`] targets generic XML and
+//! is fully case sensitive. [`HtmlTranslator`] targets (X)HTML, folds element
+//! and attribute names to lower case unless built with `xhtml = true`, and gives
+//! HTML aware results for `:checked`, `:disabled`, `:enabled`, `:link`, and
+//! `:lang()`.
+//!
+//! # Example
+//!
+//! ```
+//! use cssselect::GenericTranslator;
+//!
+//! let xpath = GenericTranslator::new()
+//! .css_to_xpath("div.foo > a#bar")
+//! .unwrap();
+//! assert_eq!(
+//! xpath,
+//! "descendant-or-self::div[@class and contains(\
+//! concat(' ', normalize-space(@class), ' '), ' foo ')]/a[@id = 'bar']"
+//! );
+//! ```
+//!
+//! The crate is `no_std` friendly. It needs `alloc` but not `std`. Build with
+//! `--no-default-features` to drop the `std` feature.
+#![no_std]
+#![forbid(unsafe_code)]
+#![warn(missing_docs)]
+
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+pub mod error;
+pub mod html;
+pub mod parser;
+pub mod tokenizer;
+mod util;
+pub mod xpath;
+
+pub use error::SelectorError;
+pub use html::HtmlTranslator;
+pub use parser::{
+ parse, parse_series, FunctionalPseudoElement, PseudoElement, Selector, Specificity, Tree,
+};
+pub use tokenizer::{tokenize, Token, TokenType};
+pub use xpath::{xpath_literal, Config, GenericTranslator, PseudoElements, XpathExpr};
diff --git a/browser/vendor/cssselect/src/parser.rs b/browser/vendor/cssselect/src/parser.rs
new file mode 100644
index 000000000..5eebd698d
--- /dev/null
+++ b/browser/vendor/cssselect/src/parser.rs
@@ -0,0 +1,1181 @@
+//! Tokenizer-driven parser, the AST node types, and the `parse` entry point.
+//!
+//! The parser turns a CSS group of selectors into a list of [`Selector`]
+//! values. Each selector wraps a [`Tree`] and an optional pseudo-element. The
+//! tree nodes carry the `repr`, `canonical`, and `specificity` behavior the
+//! tests pin.
+
+use alloc::boxed::Box;
+use alloc::format;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+
+use crate::error::SelectorError;
+use crate::tokenizer::{tokenize, Token, TokenType};
+
+/// A specificity triple `(a, b, c)`: IDs, then classes and attributes and
+/// pseudo-classes, then types and pseudo-elements.
+pub type Specificity = (u32, u32, u32);
+
+/// A pseudo-element on a selector: a plain identifier or a functional form.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PseudoElement {
+ /// A plain pseudo-element identifier such as `before`.
+ Ident(String),
+ /// A functional pseudo-element such as `attr(name)`.
+ Functional(FunctionalPseudoElement),
+}
+
+/// A functional pseudo-element such as `::name(args)`.
+///
+/// The name is ASCII lower-cased. The arguments are the raw tokens between the
+/// parentheses.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FunctionalPseudoElement {
+ /// The pseudo-element name, ASCII lower-cased.
+ pub name: String,
+ /// The argument tokens.
+ pub arguments: Vec<Token>,
+}
+
+impl FunctionalPseudoElement {
+ /// Build a functional pseudo-element, lower-casing the name.
+ pub fn new(name: &str, arguments: Vec<Token>) -> FunctionalPseudoElement {
+ FunctionalPseudoElement {
+ name: name.to_ascii_lowercase(),
+ arguments,
+ }
+ }
+
+ /// The type names of the argument tokens.
+ pub fn argument_types(&self) -> Vec<&'static str> {
+ self.arguments.iter().map(|t| t.ty.name()).collect()
+ }
+
+ /// The CSS serialization, such as `attr(name)`.
+ pub fn canonical(&self) -> String {
+ let args: String = self.arguments.iter().map(|t| t.to_css()).collect();
+ format!("{}({})", self.name, args)
+ }
+
+ /// The Python `repr` form used inside selector `repr` output.
+ pub fn repr(&self) -> String {
+ format!(
+ "FunctionalPseudoElement[::{}({})]",
+ self.name,
+ repr_token_values(&self.arguments)
+ )
+ }
+}
+
+/// Render a token-value list the way Python renders `[t.value for t in args]`.
+fn repr_token_values(tokens: &[Token]) -> String {
+ let mut out = String::from("[");
+ for (i, t) in tokens.iter().enumerate() {
+ if i > 0 {
+ out.push_str(", ");
+ }
+ out.push_str(&crate::util::py_repr(t.value_str()));
+ }
+ out.push(']');
+ out
+}
+
+/// A parsed selector tree node.
+///
+/// The variants cover every selector construct the grammar accepts. Each node
+/// answers `repr`, `canonical`, and `specificity`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Tree {
+ /// `namespace|element`, with `None` element meaning the universal `*`.
+ Element {
+ /// The namespace prefix, if any.
+ namespace: Option<String>,
+ /// The element name, or `None` for `*`.
+ element: Option<String>,
+ },
+ /// `selector#id`.
+ Hash {
+ /// The selector this hash applies to.
+ selector: Box<Tree>,
+ /// The id value.
+ id: String,
+ },
+ /// `selector.class_name`.
+ Class {
+ /// The selector this class applies to.
+ selector: Box<Tree>,
+ /// The class name.
+ class_name: String,
+ },
+ /// `selector[ns|attrib op value]`.
+ Attrib {
+ /// The selector this attribute test applies to.
+ selector: Box<Tree>,
+ /// The attribute namespace, if any.
+ namespace: Option<String>,
+ /// The attribute name.
+ attrib: String,
+ /// The operator, such as `=`, `^=`, or `exists`.
+ operator: String,
+ /// The value token, or `None` for the `exists` operator.
+ value: Option<Token>,
+ },
+ /// `selector:ident`.
+ Pseudo {
+ /// The selector this pseudo-class applies to.
+ selector: Box<Tree>,
+ /// The pseudo-class identifier, ASCII lower-cased.
+ ident: String,
+ },
+ /// `selector:name(args)`.
+ Function {
+ /// The selector this functional pseudo-class applies to.
+ selector: Box<Tree>,
+ /// The function name, ASCII lower-cased.
+ name: String,
+ /// The argument tokens.
+ arguments: Vec<Token>,
+ },
+ /// `selector:not(subselector)`.
+ Negation {
+ /// The selector being negated against.
+ selector: Box<Tree>,
+ /// The negated subselector.
+ subselector: Box<Tree>,
+ },
+ /// `selector:has(subselector)`.
+ Relation {
+ /// The selector this relation applies to.
+ selector: Box<Tree>,
+ /// The combinator token.
+ combinator: Token,
+ /// The relative subselector.
+ subselector: Box<Selector>,
+ },
+ /// `selector:is(selector_list)`, also `:matches`.
+ Matching {
+ /// The selector this match applies to.
+ selector: Box<Tree>,
+ /// The selector list.
+ selector_list: Vec<Tree>,
+ },
+ /// `selector:where(selector_list)`.
+ SpecificityAdjustment {
+ /// The selector this adjustment applies to.
+ selector: Box<Tree>,
+ /// The selector list.
+ selector_list: Vec<Tree>,
+ },
+ /// `selector combinator subselector`.
+ Combined {
+ /// The left selector.
+ selector: Box<Tree>,
+ /// The combinator, one of `" "`, `">"`, `"+"`, `"~"`.
+ combinator: String,
+ /// The right selector.
+ subselector: Box<Tree>,
+ },
+}
+
+impl Tree {
+ /// The Python `repr` of this node.
+ pub fn repr(&self) -> String {
+ match self {
+ Tree::Element { .. } => format!("Element[{}]", self.canonical()),
+ Tree::Hash { selector, id } => format!("Hash[{}#{}]", selector.repr(), id),
+ Tree::Class {
+ selector,
+ class_name,
+ } => format!("Class[{}.{}]", selector.repr(), class_name),
+ Tree::Attrib {
+ selector,
+ namespace,
+ attrib,
+ operator,
+ value,
+ } => {
+ let attr = match namespace {
+ Some(ns) => format!("{ns}|{attrib}"),
+ None => attrib.clone(),
+ };
+ if operator == "exists" {
+ format!("Attrib[{}[{}]]", selector.repr(), attr)
+ } else {
+ let v = value.as_ref().map(|t| t.value_str()).unwrap_or("");
+ format!(
+ "Attrib[{}[{} {} {}]]",
+ selector.repr(),
+ attr,
+ operator,
+ crate::util::py_repr(v)
+ )
+ }
+ }
+ Tree::Pseudo { selector, ident } => {
+ format!("Pseudo[{}:{}]", selector.repr(), ident)
+ }
+ Tree::Function {
+ selector,
+ name,
+ arguments,
+ } => format!(
+ "Function[{}:{}({})]",
+ selector.repr(),
+ name,
+ repr_token_values(arguments)
+ ),
+ Tree::Negation {
+ selector,
+ subselector,
+ } => format!("Negation[{}:not({})]", selector.repr(), subselector.repr()),
+ Tree::Relation {
+ selector,
+ subselector,
+ ..
+ } => format!("Relation[{}:has({})]", selector.repr(), subselector.repr()),
+ Tree::Matching {
+ selector,
+ selector_list,
+ } => {
+ let inner = join_reprs(selector_list);
+ format!("Matching[{}:is({})]", selector.repr(), inner)
+ }
+ Tree::SpecificityAdjustment {
+ selector,
+ selector_list,
+ } => {
+ let inner = join_reprs(selector_list);
+ format!(
+ "SpecificityAdjustment[{}:where({})]",
+ selector.repr(),
+ inner
+ )
+ }
+ Tree::Combined {
+ selector,
+ combinator,
+ subselector,
+ } => {
+ let comb = if combinator == " " {
+ "<followed>"
+ } else {
+ combinator.as_str()
+ };
+ format!(
+ "CombinedSelector[{} {} {}]",
+ selector.repr(),
+ comb,
+ subselector.repr()
+ )
+ }
+ }
+ }
+
+ /// The CSS serialization of this node.
+ pub fn canonical(&self) -> String {
+ match self {
+ Tree::Element { namespace, element } => {
+ let el = element.as_deref().unwrap_or("*");
+ match namespace {
+ Some(ns) => format!("{ns}|{el}"),
+ None => el.to_string(),
+ }
+ }
+ Tree::Hash { selector, id } => format!("{}#{}", selector.canonical(), id),
+ Tree::Class {
+ selector,
+ class_name,
+ } => format!("{}.{}", selector.canonical(), class_name),
+ Tree::Attrib {
+ selector,
+ namespace,
+ attrib,
+ operator,
+ value,
+ } => {
+ let attr = match namespace {
+ Some(ns) => format!("{ns}|{attrib}"),
+ None => attrib.clone(),
+ };
+ let op = if operator == "exists" {
+ attr
+ } else {
+ let v = value.as_ref().map(|t| t.to_css()).unwrap_or_default();
+ format!("{attr}{operator}{v}")
+ };
+ format!("{}[{}]", selector.canonical(), op)
+ }
+ Tree::Pseudo { selector, ident } => {
+ format!("{}:{}", selector.canonical(), ident)
+ }
+ Tree::Function {
+ selector,
+ name,
+ arguments,
+ } => {
+ let args: String = arguments.iter().map(|t| t.to_css()).collect();
+ format!("{}:{}({})", selector.canonical(), name, args)
+ }
+ Tree::Negation {
+ selector,
+ subselector,
+ } => {
+ let mut subsel = subselector.canonical();
+ if subsel.chars().count() > 1 {
+ subsel = lstrip_star(&subsel);
+ }
+ format!("{}:not({})", selector.canonical(), subsel)
+ }
+ Tree::Relation {
+ selector,
+ subselector,
+ ..
+ } => {
+ let mut subsel = subselector.canonical();
+ if subsel.chars().count() > 1 {
+ subsel = lstrip_star(&subsel);
+ }
+ format!("{}:has({})", selector.canonical(), subsel)
+ }
+ Tree::Matching {
+ selector,
+ selector_list,
+ } => {
+ let inner = join_canonical_stripped(selector_list);
+ format!("{}:is({})", selector.canonical(), inner)
+ }
+ Tree::SpecificityAdjustment {
+ selector,
+ selector_list,
+ } => {
+ let inner = join_canonical_stripped(selector_list);
+ format!("{}:where({})", selector.canonical(), inner)
+ }
+ Tree::Combined {
+ selector,
+ combinator,
+ subselector,
+ } => {
+ let mut subsel = subselector.canonical();
+ if subsel.chars().count() > 1 {
+ subsel = lstrip_star(&subsel);
+ }
+ format!("{} {} {}", selector.canonical(), combinator, subsel)
+ }
+ }
+ }
+
+ /// The specificity triple of this node.
+ pub fn specificity(&self) -> Specificity {
+ match self {
+ Tree::Element { element, .. } => {
+ if element.is_some() {
+ (0, 0, 1)
+ } else {
+ (0, 0, 0)
+ }
+ }
+ Tree::Hash { selector, .. } => {
+ let (a, b, c) = selector.specificity();
+ (a + 1, b, c)
+ }
+ Tree::Class { selector, .. }
+ | Tree::Attrib { selector, .. }
+ | Tree::Pseudo { selector, .. }
+ | Tree::Function { selector, .. } => {
+ let (a, b, c) = selector.specificity();
+ (a, b + 1, c)
+ }
+ Tree::Negation {
+ selector,
+ subselector,
+ } => add_spec(selector.specificity(), subselector.specificity()),
+ Tree::Relation {
+ selector,
+ subselector,
+ ..
+ } => add_spec(
+ selector.specificity(),
+ subselector.parsed_tree.specificity(),
+ ),
+ Tree::Matching {
+ selector,
+ selector_list,
+ } => add_spec(selector.specificity(), max_spec(selector_list)),
+ Tree::SpecificityAdjustment { selector, .. } => selector.specificity(),
+ Tree::Combined {
+ selector,
+ subselector,
+ ..
+ } => add_spec(selector.specificity(), subselector.specificity()),
+ }
+ }
+}
+
+/// Strip leading `*` characters, matching Python `str.lstrip("*")`.
+fn lstrip_star(s: &str) -> String {
+ s.trim_start_matches('*').to_string()
+}
+
+/// Component-wise sum of two specificity triples.
+fn add_spec(x: Specificity, y: Specificity) -> Specificity {
+ (x.0 + y.0, x.1 + y.1, x.2 + y.2)
+}
+
+/// Lexicographic maximum of a selector list's specificity triples.
+fn max_spec(list: &[Tree]) -> Specificity {
+ list.iter()
+ .map(|t| t.specificity())
+ .max()
+ .unwrap_or((0, 0, 0))
+}
+
+/// Join the `repr` of each tree with `, `.
+fn join_reprs(list: &[Tree]) -> String {
+ let mut out = String::new();
+ for (i, t) in list.iter().enumerate() {
+ if i > 0 {
+ out.push_str(", ");
+ }
+ out.push_str(&t.repr());
+ }
+ out
+}
+
+/// Join each tree's canonical form with `, `, stripping a leading `*` from each.
+fn join_canonical_stripped(list: &[Tree]) -> String {
+ let mut out = String::new();
+ for (i, t) in list.iter().enumerate() {
+ if i > 0 {
+ out.push_str(", ");
+ }
+ out.push_str(&lstrip_star(&t.canonical()));
+ }
+ out
+}
+
+/// A parsed selector: a tree plus an optional pseudo-element.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Selector {
+ /// The parsed selector tree.
+ pub parsed_tree: Tree,
+ /// The pseudo-element, if any.
+ pub pseudo_element: Option<PseudoElement>,
+}
+
+impl Selector {
+ /// Build a selector, ASCII lower-casing a plain pseudo-element name.
+ pub fn new(tree: Tree, pseudo_element: Option<PseudoElement>) -> Selector {
+ let pseudo_element = pseudo_element.map(|pe| match pe {
+ PseudoElement::Ident(name) => PseudoElement::Ident(name.to_ascii_lowercase()),
+ other => other,
+ });
+ Selector {
+ parsed_tree: tree,
+ pseudo_element,
+ }
+ }
+
+ /// The Python `repr` of this selector.
+ pub fn repr(&self) -> String {
+ let pe = match &self.pseudo_element {
+ Some(PseudoElement::Functional(f)) => f.repr(),
+ Some(PseudoElement::Ident(name)) if !name.is_empty() => format!("::{name}"),
+ _ => String::new(),
+ };
+ format!("Selector[{}{}]", self.parsed_tree.repr(), pe)
+ }
+
+ /// The CSS serialization of this selector.
+ ///
+ /// A leading `*` is stripped when the result is longer than one character.
+ pub fn canonical(&self) -> String {
+ let pe = match &self.pseudo_element {
+ Some(PseudoElement::Functional(f)) => format!("::{}", f.canonical()),
+ Some(PseudoElement::Ident(name)) if !name.is_empty() => format!("::{name}"),
+ _ => String::new(),
+ };
+ let mut res = format!("{}{}", self.parsed_tree.canonical(), pe);
+ if res.chars().count() > 1 {
+ res = lstrip_star(&res);
+ }
+ res
+ }
+
+ /// The specificity of this selector. A pseudo-element adds one to `c`.
+ pub fn specificity(&self) -> Specificity {
+ let (a, b, mut c) = self.parsed_tree.specificity();
+ if self.pseudo_element.is_some() {
+ c += 1;
+ }
+ (a, b, c)
+ }
+}
+
+/// Parse the arguments for `:nth-child()` and friends into an `(a, b)` pair.
+///
+/// Returns an error when a string token appears or a coefficient does not parse
+/// as an integer. The caller turns the error into an expression error.
+pub fn parse_series(tokens: &[Token]) -> Result<(i64, i64), SelectorError> {
+ for t in tokens {
+ if t.ty == TokenType::String {
+ return Err(SelectorError::Syntax(
+ "String tokens not allowed in series.".to_string(),
+ ));
+ }
+ }
+ let joined: String = tokens.iter().map(|t| t.value_str()).collect();
+ let s = joined.trim();
+ match s {
+ "odd" => return Ok((2, 1)),
+ "even" => return Ok((2, 0)),
+ "n" => return Ok((1, 0)),
+ _ => {}
+ }
+ if !s.contains('n') {
+ let b = parse_int(s)?;
+ return Ok((0, b));
+ }
+ let idx = s
+ .find('n')
+ .expect("series text contains 'n' on this branch");
+ let a_part = &s[..idx];
+ let b_part = &s[idx + 1..];
+ let a = if a_part.is_empty() {
+ 1
+ } else if a_part == "-" || a_part == "+" {
+ parse_int(&format!("{a_part}1"))?
+ } else {
+ parse_int(a_part)?
+ };
+ let b = if b_part.is_empty() {
+ 0
+ } else {
+ parse_int(b_part)?
+ };
+ Ok((a, b))
+}
+
+/// Parse a signed integer with the same acceptance as Python `int(str)`.
+///
+/// A single leading `+` or `-` is allowed, then digits. No surrounding
+/// whitespace, since the series text was already trimmed. A value that does not
+/// fit in `i64` returns a series error rather than overflowing, so a long digit
+/// run in an `:nth-*` argument cannot panic the translator.
+fn parse_int(s: &str) -> Result<i64, SelectorError> {
+ let digits = match s.as_bytes().first() {
+ Some(b'+') | Some(b'-') => &s[1..],
+ _ => s,
+ };
+ if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
+ return Err(series_error());
+ }
+ s.parse::<i64>().map_err(|_| series_error())
+}
+
+/// The error raised when a series coefficient does not parse.
+fn series_error() -> SelectorError {
+ SelectorError::Syntax("Invalid series".to_string())
+}
+
+/// The token stream the parser reads from.
+///
+/// `used` records consumed tokens. The `:scope` placement guard and the
+/// "Expected selector" check both depend on its length. Peeking does not add to
+/// `used`.
+struct TokenStream {
+ tokens: Vec<Token>,
+ index: usize,
+ used: Vec<Token>,
+}
+
+impl TokenStream {
+ fn new(tokens: Vec<Token>) -> TokenStream {
+ TokenStream {
+ tokens,
+ index: 0,
+ used: Vec::new(),
+ }
+ }
+
+ /// Consume and return the next token, recording it in `used`.
+ fn next(&mut self) -> Token {
+ let token = self.peek_token();
+ self.index += 1;
+ self.used.push(token.clone());
+ token
+ }
+
+ /// Look at the next token without consuming it.
+ fn peek(&self) -> Token {
+ self.peek_token()
+ }
+
+ /// The next token, clamped to the final EOF token.
+ fn peek_token(&self) -> Token {
+ if self.index < self.tokens.len() {
+ self.tokens[self.index].clone()
+ } else {
+ self.tokens[self.tokens.len() - 1].clone()
+ }
+ }
+
+ /// Consume an identifier or report an error.
+ fn next_ident(&mut self) -> Result<String, SelectorError> {
+ let t = self.next();
+ if t.ty != TokenType::Ident {
+ return Err(SelectorError::Syntax(format!("Expected ident, got {t}")));
+ }
+ Ok(t.value_str().to_string())
+ }
+
+ /// Consume an identifier or `*`, returning `None` for `*`.
+ fn next_ident_or_star(&mut self) -> Result<Option<String>, SelectorError> {
+ let t = self.next();
+ if t.ty == TokenType::Ident {
+ Ok(Some(t.value_str().to_string()))
+ } else if t.matches(TokenType::Delim, "*") {
+ Ok(None)
+ } else {
+ Err(SelectorError::Syntax(format!(
+ "Expected ident or '*', got {t}"
+ )))
+ }
+ }
+
+ /// Skip a single whitespace token if present.
+ fn skip_whitespace(&mut self) {
+ if self.peek().ty == TokenType::S {
+ self.next();
+ }
+ }
+}
+
+/// Parse a CSS group of selectors into one [`Selector`] per comma-separated part.
+///
+/// Returns a [`SelectorError::Syntax`] on an invalid selector.
+pub fn parse(css: &str) -> Result<Vec<Selector>, SelectorError> {
+ // Fast paths for the most common simple selectors. They produce the same
+ // trees as the full parser but skip tokenizing and never error on the
+ // whitespace-padded forms.
+ if let Some(el) = fast_element(css) {
+ return Ok(alloc::vec![Selector::new(
+ Tree::Element {
+ namespace: None,
+ element: Some(el),
+ },
+ None
+ )]);
+ }
+ if let Some((el, id)) = fast_hash(css) {
+ let element = if el.is_empty() { None } else { Some(el) };
+ return Ok(alloc::vec![Selector::new(
+ Tree::Hash {
+ selector: Box::new(Tree::Element {
+ namespace: None,
+ element,
+ }),
+ id,
+ },
+ None
+ )]);
+ }
+ if let Some((el, class)) = fast_class(css) {
+ let element = if el.is_empty() { None } else { Some(el) };
+ return Ok(alloc::vec![Selector::new(
+ Tree::Class {
+ selector: Box::new(Tree::Element {
+ namespace: None,
+ element,
+ }),
+ class_name: class,
+ },
+ None
+ )]);
+ }
+
+ let tokens = tokenize(css)?;
+ let mut stream = TokenStream::new(tokens);
+ parse_selector_group(&mut stream)
+}
+
+/// Match the `_el_re` fast path: optional whitespace, ASCII letters, whitespace.
+fn fast_element(css: &str) -> Option<String> {
+ let body = css.trim_matches(is_fast_ws);
+ if !body.is_empty() && body.bytes().all(|b| b.is_ascii_alphabetic()) {
+ Some(body.to_string())
+ } else {
+ None
+ }
+}
+
+/// Match the `_id_re` fast path: `[a-zA-Z]*#[a-zA-Z0-9_-]+`.
+fn fast_hash(css: &str) -> Option<(String, String)> {
+ let body = css.trim_matches(is_fast_ws);
+ let hash = body.find('#')?;
+ let el = &body[..hash];
+ let id = &body[hash + 1..];
+ if el.bytes().all(|b| b.is_ascii_alphabetic()) && !id.is_empty() && id.bytes().all(is_id_char) {
+ Some((el.to_string(), id.to_string()))
+ } else {
+ None
+ }
+}
+
+/// Match the `_class_re` fast path: `[a-zA-Z]*\.[a-zA-Z][a-zA-Z0-9_-]*`.
+fn fast_class(css: &str) -> Option<(String, String)> {
+ let body = css.trim_matches(is_fast_ws);
+ let dot = body.find('.')?;
+ let el = &body[..dot];
+ let class = &body[dot + 1..];
+ let cb = class.as_bytes();
+ if el.bytes().all(|b| b.is_ascii_alphabetic())
+ && !class.is_empty()
+ && cb[0].is_ascii_alphabetic()
+ && class.bytes().all(is_id_char)
+ {
+ Some((el.to_string(), class.to_string()))
+ } else {
+ None
+ }
+}
+
+/// Whitespace characters the fast-path regexes trim.
+fn is_fast_ws(c: char) -> bool {
+ matches!(c, ' ' | '\t' | '\r' | '\n' | '\u{0c}')
+}
+
+/// Characters allowed in the id and class fast paths after the first.
+fn is_id_char(b: u8) -> bool {
+ b.is_ascii_alphanumeric() || b == b'_' || b == b'-'
+}
+
+/// Parse a comma-separated group of selectors.
+fn parse_selector_group(stream: &mut TokenStream) -> Result<Vec<Selector>, SelectorError> {
+ let mut selectors = Vec::new();
+ stream.skip_whitespace();
+ loop {
+ let (tree, pseudo) = parse_selector(stream)?;
+ selectors.push(Selector::new(tree, pseudo));
+ if stream.peek().matches(TokenType::Delim, ",") {
+ stream.next();
+ stream.skip_whitespace();
+ } else {
+ break;
+ }
+ }
+ Ok(selectors)
+}
+
+/// Parse one selector, including combinators.
+fn parse_selector(
+ stream: &mut TokenStream,
+) -> Result<(Tree, Option<PseudoElement>), SelectorError> {
+ let (mut result, mut pseudo_element) = parse_simple_selector(stream, false)?;
+ loop {
+ stream.skip_whitespace();
+ let peek = stream.peek();
+ if peek.matches(TokenType::Eof, "") || peek.matches(TokenType::Delim, ",") {
+ break;
+ }
+ if let Some(pe) = &pseudo_element {
+ return Err(not_at_end_error(pe));
+ }
+ let combinator = if peek.is_delim(&["+", ">", "~"]) {
+ let c = stream.next().value_str().to_string();
+ stream.skip_whitespace();
+ c
+ } else {
+ " ".to_string()
+ };
+ let (next_selector, next_pseudo) = parse_simple_selector(stream, false)?;
+ pseudo_element = next_pseudo;
+ result = Tree::Combined {
+ selector: Box::new(result),
+ combinator,
+ subselector: Box::new(next_selector),
+ };
+ }
+ Ok((result, pseudo_element))
+}
+
+/// The error for a pseudo-element that is not at the end of a selector.
+fn not_at_end_error(pe: &PseudoElement) -> SelectorError {
+ SelectorError::Syntax(format!(
+ "Got pseudo-element ::{} not at the end of a selector",
+ pseudo_element_name(pe)
+ ))
+}
+
+/// The display name of a pseudo-element for error messages.
+fn pseudo_element_name(pe: &PseudoElement) -> String {
+ match pe {
+ PseudoElement::Ident(name) => name.clone(),
+ PseudoElement::Functional(f) => f.repr(),
+ }
+}
+
+/// Parse a simple selector: an optional type or universal selector followed by
+/// any number of qualifiers (hash, class, attribute, pseudo-class).
+fn parse_simple_selector(
+ stream: &mut TokenStream,
+ inside_negation: bool,
+) -> Result<(Tree, Option<PseudoElement>), SelectorError> {
+ stream.skip_whitespace();
+ let selector_start = stream.used.len();
+ let peek = stream.peek();
+
+ let (mut namespace, mut element): (Option<String>, Option<String>) =
+ if peek.ty == TokenType::Ident || peek.matches(TokenType::Delim, "*") {
+ let ns = if peek.ty == TokenType::Ident {
+ Some(stream.next().value_str().to_string())
+ } else {
+ stream.next();
+ None
+ };
+ if stream.peek().matches(TokenType::Delim, "|") {
+ stream.next();
+ let el = stream.next_ident_or_star()?;
+ (ns, el)
+ } else {
+ (None, ns)
+ }
+ } else {
+ (None, None)
+ };
+
+ let mut result = Tree::Element {
+ namespace: namespace.take(),
+ element: element.take(),
+ };
+ let mut pseudo_element: Option<PseudoElement> = None;
+
+ loop {
+ let peek = stream.peek();
+ if peek.ty == TokenType::S
+ || peek.ty == TokenType::Eof
+ || peek.is_delim(&[",", "+", ">", "~"])
+ || (inside_negation && peek.matches(TokenType::Delim, ")"))
+ {
+ break;
+ }
+ if let Some(pe) = &pseudo_element {
+ return Err(not_at_end_error(pe));
+ }
+ if peek.ty == TokenType::Hash {
+ let id = stream.next().value_str().to_string();
+ result = Tree::Hash {
+ selector: Box::new(result),
+ id,
+ };
+ } else if peek.matches(TokenType::Delim, ".") {
+ stream.next();
+ let class_name = stream.next_ident()?;
+ result = Tree::Class {
+ selector: Box::new(result),
+ class_name,
+ };
+ } else if peek.matches(TokenType::Delim, "|") {
+ stream.next();
+ let el = stream.next_ident()?;
+ result = Tree::Element {
+ namespace: None,
+ element: Some(el),
+ };
+ } else if peek.matches(TokenType::Delim, "[") {
+ stream.next();
+ result = parse_attrib(result, stream)?;
+ } else if peek.matches(TokenType::Delim, ":") {
+ stream.next();
+ if stream.peek().matches(TokenType::Delim, ":") {
+ stream.next();
+ let name = stream.next_ident()?;
+ if stream.peek().matches(TokenType::Delim, "(") {
+ stream.next();
+ let args = parse_arguments(stream)?;
+ pseudo_element = Some(PseudoElement::Functional(FunctionalPseudoElement::new(
+ &name, args,
+ )));
+ } else {
+ pseudo_element = Some(PseudoElement::Ident(name));
+ }
+ continue;
+ }
+ let ident = stream.next_ident()?;
+ let lowered = ident.to_ascii_lowercase();
+ if matches!(
+ lowered.as_str(),
+ "first-line" | "first-letter" | "before" | "after"
+ ) {
+ pseudo_element = Some(PseudoElement::Ident(ident));
+ continue;
+ }
+ if !stream.peek().matches(TokenType::Delim, "(") {
+ result = Tree::Pseudo {
+ selector: Box::new(result),
+ ident: lowered.clone(),
+ };
+ if result.repr() == "Pseudo[Element[*]:scope]" && !scope_allowed(stream) {
+ return Err(SelectorError::Syntax(
+ "Got immediate child pseudo-element \":scope\" not at the start of a selector"
+ .to_string(),
+ ));
+ }
+ continue;
+ }
+ stream.next();
+ stream.skip_whitespace();
+ match lowered.as_str() {
+ "not" => {
+ if inside_negation {
+ return Err(SelectorError::Syntax("Got nested :not()".to_string()));
+ }
+ let (argument, arg_pseudo) = parse_simple_selector(stream, true)?;
+ let next_ = stream.next();
+ if let Some(pe) = &arg_pseudo {
+ return Err(SelectorError::Syntax(format!(
+ "Got pseudo-element ::{} inside :not() at {}",
+ pseudo_element_name(pe),
+ next_.pos
+ )));
+ }
+ if !next_.matches(TokenType::Delim, ")") {
+ return Err(SelectorError::Syntax(format!("Expected ')', got {next_}")));
+ }
+ result = Tree::Negation {
+ selector: Box::new(result),
+ subselector: Box::new(argument),
+ };
+ }
+ "has" => {
+ let (combinator, arguments) = parse_relative_selector(stream)?;
+ result = Tree::Relation {
+ selector: Box::new(result),
+ combinator,
+ subselector: Box::new(arguments),
+ };
+ }
+ "matches" | "is" => {
+ let selectors = parse_simple_selector_arguments(stream)?;
+ result = Tree::Matching {
+ selector: Box::new(result),
+ selector_list: selectors,
+ };
+ }
+ "where" => {
+ let selectors = parse_simple_selector_arguments(stream)?;
+ result = Tree::SpecificityAdjustment {
+ selector: Box::new(result),
+ selector_list: selectors,
+ };
+ }
+ _ => {
+ let args = parse_arguments(stream)?;
+ result = Tree::Function {
+ selector: Box::new(result),
+ name: lowered,
+ arguments: args,
+ };
+ }
+ }
+ } else {
+ return Err(SelectorError::Syntax(format!(
+ "Expected selector, got {peek}"
+ )));
+ }
+ }
+
+ if stream.used.len() == selector_start {
+ return Err(SelectorError::Syntax(format!(
+ "Expected selector, got {}",
+ stream.peek()
+ )));
+ }
+ Ok((result, pseudo_element))
+}
+
+/// Check the `:scope` placement rule against the consumed-token list.
+///
+/// `:scope` is allowed only at the very start of a selector or right after a
+/// comma. The patterns match the grammar guard exactly.
+fn scope_allowed(stream: &TokenStream) -> bool {
+ let used = &stream.used;
+ let n = used.len();
+ if n == 2 {
+ return true;
+ }
+ if n == 3 && used[0].ty == TokenType::S {
+ return true;
+ }
+ if n >= 3 && used[n - 3].is_delim(&[","]) {
+ return true;
+ }
+ if n >= 4 && used[n - 3].ty == TokenType::S && used[n - 4].is_delim(&[","]) {
+ return true;
+ }
+ false
+}
+
+/// Collect tokens for a generic functional pseudo-class until the closing paren.
+fn parse_arguments(stream: &mut TokenStream) -> Result<Vec<Token>, SelectorError> {
+ let mut arguments = Vec::new();
+ loop {
+ stream.skip_whitespace();
+ let next_ = stream.next();
+ if matches!(
+ next_.ty,
+ TokenType::Ident | TokenType::String | TokenType::Number
+ ) || next_.is_delim(&["+", "-"])
+ {
+ arguments.push(next_);
+ } else if next_.matches(TokenType::Delim, ")") {
+ return Ok(arguments);
+ } else {
+ return Err(SelectorError::Syntax(format!(
+ "Expected an argument, got {next_}"
+ )));
+ }
+ }
+}
+
+/// Parse the relative selector inside `:has()`.
+///
+/// The accumulated text is re-parsed through [`parse`] and the first selector is
+/// returned. The combinator defaults to a space delimiter token.
+fn parse_relative_selector(stream: &mut TokenStream) -> Result<(Token, Selector), SelectorError> {
+ stream.skip_whitespace();
+ let mut subselector = String::new();
+ let mut next_ = stream.next();
+
+ let combinator = if next_.is_delim(&["+", "-", ">", "~"]) {
+ let c = next_.clone();
+ stream.skip_whitespace();
+ next_ = stream.next();
+ c
+ } else {
+ Token::new(TokenType::Delim, " ", 0)
+ };
+
+ loop {
+ if matches!(
+ next_.ty,
+ TokenType::Ident | TokenType::String | TokenType::Number
+ ) || next_.is_delim(&[".", "*"])
+ {
+ subselector.push_str(next_.value_str());
+ } else if next_.matches(TokenType::Delim, ")") {
+ let result = parse(&subselector)?;
+ let first = result
+ .into_iter()
+ .next()
+ .expect("parse yields at least one selector or errors");
+ return Ok((combinator, first));
+ } else {
+ return Err(SelectorError::Syntax(format!(
+ "Expected an argument, got {next_}"
+ )));
+ }
+ next_ = stream.next();
+ }
+}
+
+/// Parse the selector list inside `:is()`, `:matches()`, or `:where()`.
+fn parse_simple_selector_arguments(stream: &mut TokenStream) -> Result<Vec<Tree>, SelectorError> {
+ let mut arguments = Vec::new();
+ loop {
+ let (result, pseudo_element) = parse_simple_selector(stream, true)?;
+ if let Some(pe) = &pseudo_element {
+ return Err(SelectorError::Syntax(format!(
+ "Got pseudo-element ::{} inside function",
+ pseudo_element_name(pe)
+ )));
+ }
+ stream.skip_whitespace();
+ let next_ = stream.next();
+ if next_.matches(TokenType::Eof, "") || next_.matches(TokenType::Delim, ",") {
+ stream.skip_whitespace();
+ arguments.push(result);
+ } else if next_.matches(TokenType::Delim, ")") {
+ arguments.push(result);
+ break;
+ } else {
+ return Err(SelectorError::Syntax(format!(
+ "Expected an argument, got {next_}"
+ )));
+ }
+ }
+ Ok(arguments)
+}
+
+/// Parse the body of an attribute selector after the opening bracket.
+fn parse_attrib(selector: Tree, stream: &mut TokenStream) -> Result<Tree, SelectorError> {
+ stream.skip_whitespace();
+ let mut attrib = stream.next_ident_or_star()?;
+ if attrib.is_none() && !stream.peek().matches(TokenType::Delim, "|") {
+ return Err(SelectorError::Syntax(format!(
+ "Expected '|', got {}",
+ stream.peek()
+ )));
+ }
+ let mut namespace: Option<String> = None;
+ let mut op: Option<String> = None;
+ if stream.peek().matches(TokenType::Delim, "|") {
+ stream.next();
+ if stream.peek().matches(TokenType::Delim, "=") {
+ namespace = None;
+ stream.next();
+ op = Some("|=".to_string());
+ } else {
+ namespace = attrib.take();
+ attrib = Some(stream.next_ident()?);
+ op = None;
+ }
+ }
+
+ if op.is_none() {
+ stream.skip_whitespace();
+ let next_ = stream.next();
+ if next_.matches(TokenType::Delim, "]") {
+ return Ok(Tree::Attrib {
+ selector: Box::new(selector),
+ namespace,
+ attrib: attrib.unwrap_or_default(),
+ operator: "exists".to_string(),
+ value: None,
+ });
+ }
+ if next_.matches(TokenType::Delim, "=") {
+ op = Some("=".to_string());
+ } else if next_.is_delim(&["^", "$", "*", "~", "|", "!"])
+ && stream.peek().matches(TokenType::Delim, "=")
+ {
+ op = Some(format!("{}=", next_.value_str()));
+ stream.next();
+ } else {
+ return Err(SelectorError::Syntax(format!(
+ "Operator expected, got {next_}"
+ )));
+ }
+ }
+
+ stream.skip_whitespace();
+ let value = stream.next();
+ if !matches!(value.ty, TokenType::Ident | TokenType::String) {
+ return Err(SelectorError::Syntax(format!(
+ "Expected string or ident, got {value}"
+ )));
+ }
+ stream.skip_whitespace();
+ let next_ = stream.next();
+ if !next_.matches(TokenType::Delim, "]") {
+ return Err(SelectorError::Syntax(format!("Expected ']', got {next_}")));
+ }
+ Ok(Tree::Attrib {
+ selector: Box::new(selector),
+ namespace,
+ attrib: attrib.unwrap_or_default(),
+ operator: op.expect("an operator was set before reaching the value"),
+ value: Some(value),
+ })
+}
diff --git a/browser/vendor/cssselect/src/tokenizer.rs b/browser/vendor/cssselect/src/tokenizer.rs
new file mode 100644
index 000000000..447c7db9e
--- /dev/null
+++ b/browser/vendor/cssselect/src/tokenizer.rs
@@ -0,0 +1,479 @@
+//! CSS tokenizer and the token stream the parser reads from.
+//!
+//! The tokenizer walks the input once and emits [`Token`] values. It mirrors
+//! the CSS syntax grammar for identifiers, hashes, strings, numbers, comments,
+//! whitespace, and single-character delimiters. Escapes (`\HHHHHH` unicode
+//! escapes and `\X` simple escapes) are decoded as the tokens are produced.
+
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::fmt;
+
+use crate::error::SelectorError;
+
+/// The kind of a token.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TokenType {
+ /// An identifier.
+ Ident,
+ /// A hash, such as `#foo`. The value drops the leading `#`.
+ Hash,
+ /// A quoted string. The value drops the quotes and decodes escapes.
+ String,
+ /// A run of whitespace, collapsed to a single space value.
+ S,
+ /// A number kept as its raw text, such as `-3.7`.
+ Number,
+ /// A single delimiter character that did not start another token.
+ Delim,
+ /// End of input.
+ Eof,
+}
+
+impl TokenType {
+ /// The short name used in token `repr` output and parser error messages.
+ pub(crate) fn name(self) -> &'static str {
+ match self {
+ TokenType::Ident => "IDENT",
+ TokenType::Hash => "HASH",
+ TokenType::String => "STRING",
+ TokenType::S => "S",
+ TokenType::Number => "NUMBER",
+ TokenType::Delim => "DELIM",
+ TokenType::Eof => "EOF",
+ }
+ }
+}
+
+/// A single token with its source position.
+///
+/// Equality through [`Token::matches`] compares only the type and value. The
+/// position is carried for error messages and the `:scope` placement guard but
+/// is ignored when matching against expected `(type, value)` pairs.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Token {
+ /// The token kind.
+ pub ty: TokenType,
+ /// The decoded value. `None` only for the end-of-input token.
+ pub value: Option<String>,
+ /// The zero-based character index where the token starts.
+ pub pos: usize,
+}
+
+impl Token {
+ /// Build a token with a value.
+ pub fn new(ty: TokenType, value: impl Into<String>, pos: usize) -> Token {
+ Token {
+ ty,
+ value: Some(value.into()),
+ pos,
+ }
+ }
+
+ /// Build the end-of-input token.
+ pub fn eof(pos: usize) -> Token {
+ Token {
+ ty: TokenType::Eof,
+ value: None,
+ pos,
+ }
+ }
+
+ /// The decoded value as a string slice. Empty for the EOF token.
+ pub fn value_str(&self) -> &str {
+ self.value.as_deref().unwrap_or("")
+ }
+
+ /// True when this token is a delimiter whose value is in `values`.
+ pub fn is_delim(&self, values: &[&str]) -> bool {
+ self.ty == TokenType::Delim && values.contains(&self.value_str())
+ }
+
+ /// True when type and value match the given pair. Position is ignored.
+ pub fn matches(&self, ty: TokenType, value: &str) -> bool {
+ self.ty == ty && self.value_str() == value
+ }
+
+ /// The CSS serialization of the token value, used by `canonical()`.
+ ///
+ /// Strings are rendered with Python-style `repr`. Every other type returns
+ /// its raw value.
+ pub fn to_css(&self) -> String {
+ if self.ty == TokenType::String {
+ crate::util::py_repr(self.value_str())
+ } else {
+ String::from(self.value_str())
+ }
+ }
+}
+
+impl fmt::Display for Token {
+ /// Render the token the way Python `repr(Token)` does.
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if self.ty == TokenType::Eof {
+ write!(f, "<EOF at {}>", self.pos)
+ } else {
+ write!(
+ f,
+ "<{} '{}' at {}>",
+ self.ty.name(),
+ self.value_str(),
+ self.pos
+ )
+ }
+ }
+}
+
+/// Test whether a character is CSS whitespace.
+fn is_ws(c: char) -> bool {
+ matches!(c, ' ' | '\t' | '\r' | '\n' | '\u{0c}')
+}
+
+/// Test whether a character can start an identifier (`nmstart` minus escapes).
+fn is_nmstart(c: char) -> bool {
+ c == '_' || c.is_ascii_alphabetic() || (c as u32) > 0x7F
+}
+
+/// Test whether a character can continue an identifier (`nmchar` minus escapes).
+fn is_nmchar(c: char) -> bool {
+ c == '_' || c == '-' || c.is_ascii_alphanumeric() || (c as u32) > 0x7F
+}
+
+/// Tokenize a selector string into a token vector ending in an EOF token.
+///
+/// Returns a syntax error only for an unterminated or malformed string. Every
+/// other byte folds into some token.
+pub fn tokenize(s: &str) -> Result<Vec<Token>, SelectorError> {
+ let chars: Vec<char> = s.chars().collect();
+ let len = chars.len();
+ let mut pos = 0usize;
+ let mut tokens = Vec::new();
+
+ while pos < len {
+ let c = chars[pos];
+
+ // 1. Whitespace.
+ if is_ws(c) {
+ let start = pos;
+ while pos < len && is_ws(chars[pos]) {
+ pos += 1;
+ }
+ tokens.push(Token::new(TokenType::S, " ", start));
+ continue;
+ }
+
+ // 2. Identifier. A leading '-' is allowed when followed by an nmstart
+ // character or an escape.
+ if let Some(end) = match_ident(&chars, pos) {
+ let raw: String = chars[pos..end].iter().collect();
+ let value = unescape_ident(&raw);
+ tokens.push(Token::new(TokenType::Ident, value, pos));
+ pos = end;
+ continue;
+ }
+
+ // 3. Hash.
+ if c == '#' {
+ if let Some(end) = match_hash(&chars, pos) {
+ let raw: String = chars[pos + 1..end].iter().collect();
+ let value = unescape_ident(&raw);
+ tokens.push(Token::new(TokenType::Hash, value, pos));
+ pos = end;
+ continue;
+ }
+ }
+
+ // 4. String.
+ if c == '\'' || c == '"' {
+ let quote = c;
+ let end = match_string_body(&chars, pos + 1, quote);
+ if end == len {
+ return Err(SelectorError::Syntax(alloc::format!(
+ "Unclosed string at {pos}"
+ )));
+ }
+ if chars[end] != quote {
+ return Err(SelectorError::Syntax(alloc::format!(
+ "Invalid string at {pos}"
+ )));
+ }
+ let raw: String = chars[pos + 1..end].iter().collect();
+ let value = unescape_string(&raw);
+ tokens.push(Token::new(TokenType::String, value, pos));
+ pos = end + 1;
+ continue;
+ }
+
+ // 5. Number.
+ if let Some(end) = match_number(&chars, pos) {
+ let raw: String = chars[pos..end].iter().collect();
+ tokens.push(Token::new(TokenType::Number, raw, pos));
+ pos = end;
+ continue;
+ }
+
+ // 6. Comment. An unterminated comment consumes to end of input.
+ if c == '/' && pos + 1 < len && chars[pos + 1] == '*' {
+ let mut search = pos + 2;
+ let mut found = None;
+ while search + 1 < len {
+ if chars[search] == '*' && chars[search + 1] == '/' {
+ found = Some(search + 2);
+ break;
+ }
+ search += 1;
+ }
+ pos = found.unwrap_or(len);
+ continue;
+ }
+
+ // 7. Otherwise a single-character delimiter.
+ tokens.push(Token::new(TokenType::Delim, c, pos));
+ pos += 1;
+ }
+
+ tokens.push(Token::eof(len));
+ Ok(tokens)
+}
+
+/// Length of an escape sequence starting at `chars[i]` (where `chars[i]` is the
+/// backslash), or `None` when the backslash does not begin a valid escape.
+///
+/// A unicode escape is a backslash, one to six hex digits, and an optional
+/// trailing whitespace character (with `\r\n` counted as one). A simple escape
+/// is a backslash and one character that is not a newline or hex digit.
+fn escape_len(chars: &[char], i: usize) -> Option<usize> {
+ if chars.get(i) != Some(&'\\') {
+ return None;
+ }
+ let after = i + 1;
+ let next = chars.get(after)?;
+ if next.is_ascii_hexdigit() {
+ let mut j = after;
+ let mut count = 0;
+ while j < chars.len() && count < 6 && chars[j].is_ascii_hexdigit() {
+ j += 1;
+ count += 1;
+ }
+ // Optional single trailing whitespace, with \r\n consumed as a pair.
+ if j + 1 < chars.len() && chars[j] == '\r' && chars[j + 1] == '\n' {
+ j += 2;
+ } else if j < chars.len() && is_ws(chars[j]) {
+ j += 1;
+ }
+ Some(j - i)
+ } else if matches!(next, '\n' | '\r' | '\u{0c}') {
+ // Not a valid simple escape: backslash followed by a newline.
+ None
+ } else {
+ // Simple escape consumes the backslash and one character.
+ Some(2)
+ }
+}
+
+/// Match an identifier starting at `pos`. Returns the end index, exclusive.
+fn match_ident(chars: &[char], pos: usize) -> Option<usize> {
+ let len = chars.len();
+ let mut i = pos;
+ if i < len && chars[i] == '-' {
+ i += 1;
+ }
+ // First piece must be an nmstart or an escape.
+ if i < len && is_nmstart(chars[i]) {
+ i += 1;
+ } else {
+ let step = escape_len(chars, i)?;
+ i += step;
+ }
+ // Remaining nmchar pieces.
+ loop {
+ if i < len && is_nmchar(chars[i]) {
+ i += 1;
+ } else if let Some(step) = escape_len(chars, i) {
+ i += step;
+ } else {
+ break;
+ }
+ }
+ Some(i)
+}
+
+/// Match a hash starting at `pos` (the `#`). Returns the end index, exclusive.
+fn match_hash(chars: &[char], pos: usize) -> Option<usize> {
+ let len = chars.len();
+ let mut i = pos + 1;
+ let start = i;
+ loop {
+ if i < len && is_nmchar(chars[i]) {
+ i += 1;
+ } else if let Some(step) = escape_len(chars, i) {
+ i += step;
+ } else {
+ break;
+ }
+ }
+ if i == start {
+ None
+ } else {
+ Some(i)
+ }
+}
+
+/// Match a number starting at `pos`. Returns the end index, exclusive.
+///
+/// The pattern is an optional sign, then either digits, a dot, and digits, or a
+/// plain run of digits.
+fn match_number(chars: &[char], pos: usize) -> Option<usize> {
+ let len = chars.len();
+ let mut i = pos;
+ if i < len && (chars[i] == '+' || chars[i] == '-') {
+ i += 1;
+ }
+ let int_start = i;
+ while i < len && chars[i].is_ascii_digit() {
+ i += 1;
+ }
+ let had_int = i > int_start;
+ if i < len && chars[i] == '.' {
+ let dot = i;
+ i += 1;
+ let frac_start = i;
+ while i < len && chars[i].is_ascii_digit() {
+ i += 1;
+ }
+ if i > frac_start {
+ return Some(i);
+ }
+ // A dot with no following digits is only valid if integer digits ran.
+ i = dot;
+ }
+ if had_int {
+ Some(i)
+ } else {
+ None
+ }
+}
+
+/// Find where a string body ends starting at `pos` (just past the open quote).
+///
+/// Returns the index of the closing quote, or the input length when the string
+/// runs to end of input. The body allows escapes, including line-continuation
+/// escapes, and forbids raw newlines.
+fn match_string_body(chars: &[char], pos: usize, quote: char) -> usize {
+ let len = chars.len();
+ let mut i = pos;
+ while i < len {
+ let c = chars[i];
+ if c == quote {
+ return i;
+ }
+ if matches!(c, '\n' | '\r' | '\u{0c}') {
+ return i;
+ }
+ if c == '\\' {
+ // Line continuation: backslash then a newline form.
+ if i + 1 < len {
+ if chars[i + 1] == '\r' && i + 2 < len && chars[i + 2] == '\n' {
+ i += 3;
+ continue;
+ }
+ if matches!(chars[i + 1], '\n' | '\r' | '\u{0c}') {
+ i += 2;
+ continue;
+ }
+ }
+ if let Some(step) = escape_len(chars, i) {
+ i += step;
+ continue;
+ }
+ // A trailing lone backslash.
+ i += 1;
+ continue;
+ }
+ i += 1;
+ }
+ len
+}
+
+/// Decode the unicode and simple escapes in an identifier or hash value.
+pub fn unescape_ident(value: &str) -> String {
+ let chars: Vec<char> = value.chars().collect();
+ decode_escapes(&chars, false)
+}
+
+/// Decode the escapes in a string value, including line continuations.
+fn unescape_string(value: &str) -> String {
+ let chars: Vec<char> = value.chars().collect();
+ decode_escapes(&chars, true)
+}
+
+/// Shared escape decoder.
+///
+/// When `strip_newlines` is set, a backslash before a newline form is dropped
+/// (line continuation). A unicode escape maps to its code point. Two ranges map
+/// to U+FFFD instead: code points above U+10FFFF, and the surrogate range
+/// U+D800 through U+DFFF. A Rust string cannot hold a surrogate, so the decoder
+/// folds it to the replacement character. Simple escapes drop the backslash.
+fn decode_escapes(chars: &[char], strip_newlines: bool) -> String {
+ let len = chars.len();
+ let mut out = String::with_capacity(len);
+ let mut i = 0;
+ while i < len {
+ if chars[i] != '\\' {
+ out.push(chars[i]);
+ i += 1;
+ continue;
+ }
+ let after = i + 1;
+ if after >= len {
+ out.push('\\');
+ i += 1;
+ continue;
+ }
+ let next = chars[after];
+ if strip_newlines {
+ if next == '\r' && after + 1 < len && chars[after + 1] == '\n' {
+ i = after + 2;
+ continue;
+ }
+ if matches!(next, '\n' | '\r' | '\u{0c}') {
+ i = after + 1;
+ continue;
+ }
+ }
+ if next.is_ascii_hexdigit() {
+ let mut j = after;
+ let mut count = 0;
+ let mut cp: u32 = 0;
+ while j < len && count < 6 && chars[j].is_ascii_hexdigit() {
+ cp = cp * 16
+ + chars[j]
+ .to_digit(16)
+ .expect("hex digit checked by the loop guard");
+ j += 1;
+ count += 1;
+ }
+ // Eat one optional trailing whitespace, with \r\n as a pair.
+ if j + 1 < len && chars[j] == '\r' && chars[j + 1] == '\n' {
+ j += 2;
+ } else if j < len && is_ws(chars[j]) {
+ j += 1;
+ }
+ // Above the Unicode maximum folds to U+FFFD. A surrogate code point
+ // also folds here, since `char::from_u32` rejects the surrogate
+ // range and a Rust string cannot store one.
+ let decoded = if cp > 0x10FFFF {
+ '\u{FFFD}'
+ } else {
+ char::from_u32(cp).unwrap_or('\u{FFFD}')
+ };
+ out.push(decoded);
+ i = j;
+ } else {
+ // Simple escape: drop the backslash, keep the character.
+ out.push(next);
+ i = after + 1;
+ }
+ }
+ out
+}
diff --git a/browser/vendor/cssselect/src/util.rs b/browser/vendor/cssselect/src/util.rs
new file mode 100644
index 000000000..a7fcbeb65
--- /dev/null
+++ b/browser/vendor/cssselect/src/util.rs
@@ -0,0 +1,99 @@
+//! Python-style string repr used by canonical serialization.
+
+use alloc::string::String;
+use core::fmt::Write as _;
+
+/// Render a string the way CPython `repr()` does.
+///
+/// The canonical form of a selector embeds string tokens through this function,
+/// so the output must match CPython byte for byte. The rules:
+///
+/// - Prefer single quotes. Switch to double quotes only when the string holds a
+/// single quote but no double quote.
+/// - Escape the backslash and the active quote.
+/// - Escape `\t`, `\n`, `\r` with their short forms.
+/// - Escape other non-printable code points with `\xNN`, `\uNNNN`, or
+/// `\UNNNNNNNN` depending on width.
+///
+/// "Printable" follows Python's `str.isprintable`: a character is printable
+/// unless it sits in an "Other" or "Separator" Unicode category, with the space
+/// U+0020 kept as printable.
+pub(crate) fn py_repr(s: &str) -> String {
+ let has_single = s.contains('\'');
+ let has_double = s.contains('"');
+ let quote = if has_single && !has_double { '"' } else { '\'' };
+
+ let mut out = String::with_capacity(s.len() + 2);
+ out.push(quote);
+ for ch in s.chars() {
+ match ch {
+ '\\' => out.push_str("\\\\"),
+ '\t' => out.push_str("\\t"),
+ '\n' => out.push_str("\\n"),
+ '\r' => out.push_str("\\r"),
+ c if c == quote => {
+ out.push('\\');
+ out.push(c);
+ }
+ c if is_py_printable(c) => out.push(c),
+ c => {
+ let cp = c as u32;
+ if cp <= 0xFF {
+ let _ = write!(out, "\\x{cp:02x}");
+ } else if cp <= 0xFFFF {
+ let _ = write!(out, "\\u{cp:04x}");
+ } else {
+ let _ = write!(out, "\\U{cp:08x}");
+ }
+ }
+ }
+ }
+ out.push(quote);
+ out
+}
+
+/// Match CPython `str.isprintable` for a single character.
+///
+/// Printable means not in an "Other" (C*) or "Separator" (Z*) Unicode category.
+/// The ASCII space U+0020 is the one separator Python still treats as
+/// printable.
+fn is_py_printable(c: char) -> bool {
+ if c == ' ' {
+ return true;
+ }
+ !is_other_or_separator(c)
+}
+
+/// True when the character sits in a Unicode "Other" or "Separator" category.
+///
+/// Python excludes Cc, Cf, Cs, Co, Cn, Zl, Zp, and Zs from `isprintable`. This
+/// crate carries no Unicode database, so the check covers the control and
+/// separator ranges that appear in CSS selector strings. Characters outside
+/// these ranges count as printable, which matches Python for every input the
+/// test suite and real selectors produce.
+fn is_other_or_separator(c: char) -> bool {
+ let cp = c as u32;
+ // C0 and C1 control characters (Cc).
+ if cp <= 0x1F || (0x7F..=0x9F).contains(&cp) {
+ return true;
+ }
+ matches!(
+ cp,
+ // Separators (Zs, Zl, Zp) and common format or other characters (Cf, Cn).
+ 0x00A0 // no-break space (Zs)
+ | 0x00AD // soft hyphen (Cf)
+ | 0x0600..=0x0605
+ | 0x061C
+ | 0x06DD
+ | 0x070F
+ | 0x1680 // ogham space mark (Zs)
+ | 0x180E // mongolian vowel separator
+ | 0x2000..=0x200F // spaces (Zs) and Cf marks
+ | 0x2028..=0x202F // line and paragraph separators and Cf marks
+ | 0x205F..=0x2064 // medium math space (Zs) and Cf marks
+ | 0x206A..=0x206F
+ | 0x3000 // ideographic space (Zs)
+ | 0xFEFF // zero width no-break space (Cf)
+ | 0xFFF9..=0xFFFB
+ )
+}
diff --git a/browser/vendor/cssselect/src/xpath.rs b/browser/vendor/cssselect/src/xpath.rs
new file mode 100644
index 000000000..ac98af1d3
--- /dev/null
+++ b/browser/vendor/cssselect/src/xpath.rs
@@ -0,0 +1,1072 @@
+//! XPath string builder and the translators.
+//!
+//! [`XpathExpr`] assembles an XPath 1.0 expression from a path, an element
+//! test, and a condition. The translation engine walks a parsed [`Tree`] and
+//! produces one expression per selector. [`GenericTranslator`] targets generic
+//! XML. The HTML variant lives in [`crate::html`] and reuses this engine with a
+//! different [`Config`].
+
+use alloc::format;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+
+use crate::error::SelectorError;
+use crate::parser::{parse, parse_series, PseudoElement, Selector, Tree};
+use crate::tokenizer::TokenType;
+
+/// An XPath 1.0 expression under construction.
+///
+/// The string form is `path + element`, plus `[condition]` when a condition is
+/// present. Conditions chain through [`XpathExpr::add_condition`], which wraps
+/// each side in parentheses.
+///
+/// The parts are private so the type stays consistent. The condition never
+/// carries its own brackets, and the path and element stay well formed. Build
+/// and read the expression through the methods.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct XpathExpr {
+ /// The location path prefix.
+ path: String,
+ /// The element or node test.
+ element: String,
+ /// The predicate condition, without the surrounding brackets.
+ condition: String,
+}
+
+impl XpathExpr {
+ /// Build an expression from its parts.
+ pub fn new(path: &str, element: &str, condition: &str) -> XpathExpr {
+ XpathExpr {
+ path: path.to_string(),
+ element: element.to_string(),
+ condition: condition.to_string(),
+ }
+ }
+
+ /// Build an expression with only the element test set.
+ fn element(element: &str) -> XpathExpr {
+ XpathExpr::new("", element, "")
+ }
+
+ /// The string form: `path + element`, plus `[condition]` when present.
+ pub fn to_xpath(&self) -> String {
+ let mut out = format!("{}{}", self.path, self.element);
+ if !self.condition.is_empty() {
+ out.push('[');
+ out.push_str(&self.condition);
+ out.push(']');
+ }
+ out
+ }
+
+ /// Add a predicate condition, joined with `and` by default.
+ ///
+ /// When a condition already exists, both sides are wrapped in parentheses.
+ pub fn add_condition(&mut self, condition: &str, conjunction: &str) -> &mut Self {
+ if self.condition.is_empty() {
+ self.condition = condition.to_string();
+ } else {
+ self.condition = format!("({}) {} ({})", self.condition, conjunction, condition);
+ }
+ self
+ }
+
+ /// Add an `and`-joined condition. Shorthand for the common case.
+ fn and_condition(&mut self, condition: &str) -> &mut Self {
+ self.add_condition(condition, "and")
+ }
+
+ /// Fold a non-universal element test into a `name()` condition.
+ fn add_name_test(&mut self) {
+ if self.element == "*" {
+ return;
+ }
+ let mut parts = self.element.splitn(2, ':');
+ let prefix = parts.next().unwrap_or("");
+ let local = parts.next();
+ let safe =
+ is_safe_name(prefix) && local.is_none_or(|value| value == "*" || is_safe_name(value));
+ let cond = if safe {
+ format!("self::{}", self.element)
+ } else {
+ format!("name() = {}", xpath_literal(&self.element))
+ };
+ self.and_condition(&cond);
+ self.element = "*".to_string();
+ }
+
+ /// Join this expression to another with a combiner string.
+ ///
+ /// Shorthand for [`XpathExpr::join_full`] with no closing combiner and no
+ /// inner condition folding.
+ pub fn join(&mut self, combiner: &str, other: &XpathExpr) -> &mut Self {
+ self.join_full(combiner, other, None, false)
+ }
+
+ /// Join this expression to another with full control.
+ ///
+ /// When `has_inner_condition` is set, the other expression's condition is
+ /// folded into the element test rather than kept separate. The optional
+ /// closing combiner is appended to the element test.
+ pub fn join_full(
+ &mut self,
+ combiner: &str,
+ other: &XpathExpr,
+ closing_combiner: Option<&str>,
+ has_inner_condition: bool,
+ ) -> &mut Self {
+ let mut path = format!("{}{}", self.to_xpath(), combiner);
+ if other.path != "*/" {
+ path.push_str(&other.path);
+ }
+ self.path = path;
+ if !has_inner_condition {
+ self.element = match closing_combiner {
+ Some(cc) => format!("{}{}", other.element, cc),
+ None => other.element.clone(),
+ };
+ self.condition = other.condition.clone();
+ } else {
+ self.element = other.element.clone();
+ if !other.condition.is_empty() {
+ self.element = format!("{}[{}]", self.element, other.condition);
+ }
+ if let Some(cc) = closing_combiner {
+ self.element.push_str(cc);
+ }
+ }
+ self
+ }
+}
+
+/// Render a value as an XPath 1.0 string literal.
+///
+/// XPath 1.0 has no string escapes, so a value with both quote kinds is built
+/// with `concat(...)`.
+pub fn xpath_literal(s: &str) -> String {
+ if !s.contains('\'') {
+ format!("'{s}'")
+ } else if !s.contains('"') {
+ format!("\"{s}\"")
+ } else {
+ let parts = split_at_single_quotes(s);
+ let mut quoted: Vec<String> = Vec::new();
+ for part in parts {
+ if part.is_empty() {
+ continue;
+ }
+ if part.contains('\'') {
+ quoted.push(format!("\"{part}\""));
+ } else {
+ quoted.push(format!("'{part}'"));
+ }
+ }
+ format!("concat({})", quoted.join(","))
+ }
+}
+
+/// Split a string keeping runs of single quotes as separate parts.
+///
+/// This mirrors Python `re.split("('+)", s)`, where the capturing group keeps
+/// the separator runs. Empty parts can appear and are dropped by the caller.
+fn split_at_single_quotes(s: &str) -> Vec<String> {
+ let mut parts: Vec<String> = Vec::new();
+ let mut current = String::new();
+ let mut chars = s.chars().peekable();
+ while let Some(&c) = chars.peek() {
+ if c == '\'' {
+ parts.push(core::mem::take(&mut current));
+ let mut run = String::new();
+ while let Some(&c2) = chars.peek() {
+ if c2 == '\'' {
+ run.push('\'');
+ chars.next();
+ } else {
+ break;
+ }
+ }
+ parts.push(run);
+ } else {
+ current.push(c);
+ chars.next();
+ }
+ }
+ parts.push(current);
+ parts
+}
+
+/// True when a name is safe to drop straight into an XPath name position.
+fn is_safe_name(name: &str) -> bool {
+ let mut chars = name.chars();
+ match chars.next() {
+ Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
+ _ => return false,
+ }
+ chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '_' | '.' | '-'))
+}
+
+/// True when a value is non-empty and holds no whitespace.
+fn is_non_whitespace(value: &str) -> bool {
+ !value.is_empty()
+ && !value
+ .chars()
+ .any(|c| matches!(c, ' ' | '\t' | '\r' | '\n' | '\u{0c}'))
+}
+
+/// Case-folding and document-language settings for a translator.
+///
+/// Build one with [`Config::generic`] or [`Config::html`]. The fields are
+/// crate-internal so a caller cannot mix settings into an invalid state, such
+/// as the HTML pseudo-classes paired with the XML `lang` attribute.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Config {
+ /// The attribute name used by `:lang()`.
+ pub(crate) lang_attribute: &'static str,
+ /// Whether to fold element names to lower case.
+ pub(crate) lower_case_element_names: bool,
+ /// Whether to fold attribute names to lower case.
+ pub(crate) lower_case_attribute_names: bool,
+ /// Whether to fold attribute values to lower case.
+ pub(crate) lower_case_attribute_values: bool,
+ /// Whether to apply the HTML-specific pseudo-class implementations.
+ pub(crate) html: bool,
+}
+
+impl Config {
+ /// The generic XML configuration: fully case sensitive, `xml:lang`.
+ pub fn generic() -> Config {
+ Config {
+ lang_attribute: "xml:lang",
+ lower_case_element_names: false,
+ lower_case_attribute_names: false,
+ lower_case_attribute_values: false,
+ html: false,
+ }
+ }
+
+ /// The HTML configuration. With `xhtml`, names stay case sensitive.
+ pub fn html(xhtml: bool) -> Config {
+ Config {
+ lang_attribute: "lang",
+ lower_case_element_names: !xhtml,
+ lower_case_attribute_names: !xhtml,
+ lower_case_attribute_values: false,
+ html: true,
+ }
+ }
+}
+
+/// Translate a parsed group of selectors to an XPath string.
+///
+/// Per-selector results are joined with `" | "`. Pseudo-elements are translated
+/// here, which raises an expression error in the built-in translators.
+pub(crate) fn css_to_xpath(cfg: &Config, css: &str, prefix: &str) -> Result<String, SelectorError> {
+ let selectors = parse(css)?;
+ let mut parts: Vec<String> = Vec::with_capacity(selectors.len());
+ for selector in &selectors {
+ parts.push(selector_to_xpath(
+ cfg,
+ selector,
+ prefix,
+ PseudoElements::Translate,
+ )?);
+ }
+ Ok(parts.join(" | "))
+}
+
+/// How a translator handles a selector's pseudo-element.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PseudoElements {
+ /// Translate the pseudo-element. The built-in translators reject it with an
+ /// expression error, since XPath has no equivalent.
+ Translate,
+ /// Ignore the pseudo-element and translate the rest of the selector.
+ Ignore,
+}
+
+/// Translate a single parsed selector to an XPath string.
+///
+/// With [`PseudoElements::Ignore`], the selector's pseudo-element is dropped.
+pub(crate) fn selector_to_xpath(
+ cfg: &Config,
+ selector: &Selector,
+ prefix: &str,
+ pseudo_elements: PseudoElements,
+) -> Result<String, SelectorError> {
+ let mut xpath = xpath_tree(cfg, &selector.parsed_tree)?;
+ if pseudo_elements == PseudoElements::Translate {
+ if let Some(pe) = &selector.pseudo_element {
+ xpath = xpath_pseudo_element(xpath, pe)?;
+ }
+ }
+ Ok(format!("{}{}", prefix, xpath.to_xpath()))
+}
+
+/// Scrapling's two Parsel-compatible pseudo-elements.
+fn xpath_pseudo_element(
+ xpath: XpathExpr,
+ pseudo_element: &PseudoElement,
+) -> Result<XpathExpr, SelectorError> {
+ let mut path = xpath.to_xpath();
+ match pseudo_element {
+ PseudoElement::Ident(name) if name == "text" => {
+ if path == "*" {
+ path = "text()".to_string();
+ } else if path.ends_with("::*/*") {
+ path.truncate(path.len() - 3);
+ path.push_str("text()");
+ } else {
+ path.push_str("/text()");
+ }
+ }
+ PseudoElement::Functional(function)
+ if function.name == "attr"
+ && function.arguments.len() == 1
+ && matches!(
+ function.arguments[0].ty,
+ TokenType::String | TokenType::Ident
+ ) =>
+ {
+ if path.ends_with("::*/*") {
+ path.truncate(path.len() - 2);
+ }
+ path.push_str("/@");
+ path.push_str(function.arguments[0].value_str());
+ }
+ PseudoElement::Functional(function) if function.name == "attr" => {
+ return Err(SelectorError::Expression(format!(
+ "Expected a single string or ident for ::attr(), got {:?}",
+ function.arguments
+ )));
+ }
+ PseudoElement::Functional(function) => {
+ return Err(SelectorError::Expression(format!(
+ "The functional pseudo-element ::{}() is unknown",
+ function.name
+ )));
+ }
+ PseudoElement::Ident(name) => {
+ return Err(SelectorError::Expression(format!(
+ "The pseudo-element ::{name} is unknown"
+ )));
+ }
+ }
+ Ok(XpathExpr::new("", &path, ""))
+}
+
+/// Dispatch a parsed tree node to its translator.
+fn xpath_tree(cfg: &Config, tree: &Tree) -> Result<XpathExpr, SelectorError> {
+ match tree {
+ Tree::Element { namespace, element } => Ok(xpath_element(cfg, namespace, element)),
+ Tree::Hash { selector, id } => {
+ let mut xpath = xpath_tree(cfg, selector)?;
+ xpath.and_condition(&format!("@id = {}", xpath_literal(id)));
+ Ok(xpath)
+ }
+ Tree::Class {
+ selector,
+ class_name,
+ } => {
+ let mut xpath = xpath_tree(cfg, selector)?;
+ attrib_includes(&mut xpath, "@class", Some(class_name));
+ Ok(xpath)
+ }
+ Tree::Attrib { .. } => xpath_attrib(cfg, tree),
+ Tree::Pseudo { selector, ident } => {
+ let xpath = xpath_tree(cfg, selector)?;
+ xpath_pseudo(cfg, xpath, ident)
+ }
+ Tree::Function {
+ selector,
+ name,
+ arguments,
+ } => {
+ let xpath = xpath_tree(cfg, selector)?;
+ xpath_function(cfg, xpath, name, arguments)
+ }
+ Tree::Negation {
+ selector,
+ subselector,
+ } => {
+ let mut xpath = xpath_tree(cfg, selector)?;
+ let mut sub = xpath_tree(cfg, subselector)?;
+ sub.add_name_test();
+ if !sub.condition.is_empty() {
+ xpath.and_condition(&format!("not({})", sub.condition));
+ } else {
+ xpath.and_condition("0");
+ }
+ Ok(xpath)
+ }
+ Tree::Relation {
+ selector,
+ combinator,
+ subselector,
+ } => {
+ let xpath = xpath_tree(cfg, selector)?;
+ let right = xpath_tree(cfg, &subselector.parsed_tree)?;
+ xpath_relation(xpath, combinator.value_str(), right)
+ }
+ Tree::Matching {
+ selector,
+ selector_list,
+ }
+ | Tree::SpecificityAdjustment {
+ selector,
+ selector_list,
+ } => {
+ let mut xpath = xpath_tree(cfg, selector)?;
+ let mut alternatives = Vec::new();
+ for sel in selector_list {
+ let mut e = xpath_tree(cfg, sel)?;
+ e.add_name_test();
+ alternatives.push(if e.condition.is_empty() {
+ "1".to_string()
+ } else {
+ e.condition
+ });
+ }
+ if alternatives.is_empty() {
+ xpath.and_condition("0");
+ } else if alternatives.len() == 1 {
+ xpath.and_condition(&alternatives[0]);
+ } else {
+ xpath.and_condition(&format!("({})", alternatives.join(") or (")));
+ }
+ Ok(xpath)
+ }
+ Tree::Combined {
+ selector,
+ combinator,
+ subselector,
+ } => {
+ let left = xpath_tree(cfg, selector)?;
+ let right = xpath_tree(cfg, subselector)?;
+ xpath_combinator(combinator, left, right)
+ }
+ }
+}
+
+/// Translate a type or universal selector.
+fn xpath_element(cfg: &Config, namespace: &Option<String>, element: &Option<String>) -> XpathExpr {
+ let mut safe;
+ let mut name;
+ match element {
+ None => {
+ name = "*".to_string();
+ safe = true;
+ }
+ Some(el) => {
+ name = el.clone();
+ safe = is_safe_name(&name);
+ if cfg.lower_case_element_names {
+ name = name.to_ascii_lowercase();
+ }
+ }
+ }
+ if let Some(ns) = namespace {
+ name = format!("{ns}:{name}");
+ safe = safe && is_safe_name(ns);
+ }
+ let mut xpath = XpathExpr::element(&name);
+ if !safe {
+ xpath.add_name_test();
+ }
+ xpath
+}
+
+/// Translate an attribute selector.
+fn xpath_attrib(cfg: &Config, tree: &Tree) -> Result<XpathExpr, SelectorError> {
+ let (selector, namespace, attrib, operator, value) = match tree {
+ Tree::Attrib {
+ selector,
+ namespace,
+ attrib,
+ operator,
+ value,
+ } => (selector, namespace, attrib, operator, value),
+ _ => unreachable!("xpath_attrib called on a non-Attrib tree"),
+ };
+
+ let mut name = if cfg.lower_case_attribute_names {
+ attrib.to_ascii_lowercase()
+ } else {
+ attrib.clone()
+ };
+ let mut safe = is_safe_name(&name);
+ if let Some(ns) = namespace {
+ name = format!("{ns}:{name}");
+ safe = safe && is_safe_name(ns);
+ }
+ let attrib_xpath = if safe {
+ format!("@{name}")
+ } else {
+ format!("attribute::*[name() = {}]", xpath_literal(&name))
+ };
+
+ let value_str: Option<String> = match value {
+ None => None,
+ Some(token) => {
+ if cfg.lower_case_attribute_values {
+ Some(token.value_str().to_ascii_lowercase())
+ } else {
+ Some(token.value_str().to_string())
+ }
+ }
+ };
+
+ let mut xpath = xpath_tree(cfg, selector)?;
+ apply_attrib_operator(&mut xpath, operator, &attrib_xpath, value_str.as_deref())?;
+ Ok(xpath)
+}
+
+/// Apply the named attribute operator to the expression.
+fn apply_attrib_operator(
+ xpath: &mut XpathExpr,
+ operator: &str,
+ name: &str,
+ value: Option<&str>,
+) -> Result<(), SelectorError> {
+ match operator {
+ "exists" => {
+ xpath.and_condition(name);
+ }
+ "=" => {
+ xpath.and_condition(&format!(
+ "{} = {}",
+ name,
+ xpath_literal(value.unwrap_or(""))
+ ));
+ }
+ "!=" => {
+ let v = value.unwrap_or("");
+ if !v.is_empty() {
+ xpath.and_condition(&format!("not({name}) or {name} != {}", xpath_literal(v)));
+ } else {
+ xpath.and_condition(&format!("{name} != {}", xpath_literal(v)));
+ }
+ }
+ "~=" => attrib_includes(xpath, name, value),
+ "|=" => {
+ let v = value.unwrap_or("");
+ let arg = xpath_literal(v);
+ let arg_dash = xpath_literal(&format!("{v}-"));
+ xpath.and_condition(&format!(
+ "{name} and ({name} = {arg} or starts-with({name}, {arg_dash}))"
+ ));
+ }
+ "^=" => {
+ let v = value.unwrap_or("");
+ if !v.is_empty() {
+ xpath.and_condition(&format!(
+ "{name} and starts-with({name}, {})",
+ xpath_literal(v)
+ ));
+ } else {
+ xpath.and_condition("0");
+ }
+ }
+ "$=" => {
+ let v = value.unwrap_or("");
+ if !v.is_empty() {
+ let len = v.chars().count() as i64 - 1;
+ xpath.and_condition(&format!(
+ "{name} and substring({name}, string-length({name})-{len}) = {}",
+ xpath_literal(v)
+ ));
+ } else {
+ xpath.and_condition("0");
+ }
+ }
+ "*=" => {
+ let v = value.unwrap_or("");
+ if !v.is_empty() {
+ xpath.and_condition(&format!(
+ "{name} and contains({name}, {})",
+ xpath_literal(v)
+ ));
+ } else {
+ xpath.and_condition("0");
+ }
+ }
+ other => {
+ return Err(SelectorError::Expression(format!(
+ "Unknown attribute operator: {other}"
+ )));
+ }
+ }
+ Ok(())
+}
+
+/// The `~=` includes operator, shared by class selectors and `[a~=b]`.
+fn attrib_includes(xpath: &mut XpathExpr, name: &str, value: Option<&str>) {
+ let v = value.unwrap_or("");
+ if !v.is_empty() && is_non_whitespace(v) {
+ let arg = xpath_literal(&format!(" {v} "));
+ xpath.and_condition(&format!(
+ "{name} and contains(concat(' ', normalize-space({name}), ' '), {arg})"
+ ));
+ } else {
+ xpath.and_condition("0");
+ }
+}
+
+/// Translate a combinator between a left and right expression.
+fn xpath_combinator(
+ combinator: &str,
+ mut left: XpathExpr,
+ right: XpathExpr,
+) -> Result<XpathExpr, SelectorError> {
+ match combinator {
+ " " => {
+ left.join_full("/descendant-or-self::*/", &right, None, false);
+ }
+ ">" => {
+ left.join_full("/", &right, None, false);
+ }
+ "+" => {
+ left.join_full("/following-sibling::", &right, None, false);
+ left.add_name_test();
+ left.and_condition("position() = 1");
+ }
+ "~" => {
+ left.join_full("/following-sibling::", &right, None, false);
+ }
+ other => {
+ return Err(SelectorError::Expression(format!(
+ "Unknown combinator: {other}"
+ )));
+ }
+ }
+ Ok(left)
+}
+
+/// Translate a `:has()` relation by its combinator.
+fn xpath_relation(
+ mut left: XpathExpr,
+ combinator: &str,
+ mut right: XpathExpr,
+) -> Result<XpathExpr, SelectorError> {
+ match combinator {
+ " " => {
+ left.join_full("[descendant::", &right, Some("]"), true);
+ }
+ ">" => {
+ left.join_full("[./", &right, Some("]"), true);
+ }
+ "+" => {
+ right.add_name_test();
+ right.and_condition("position() = 1");
+ left.and_condition(&format!(
+ "following-sibling::{}[{}]",
+ right.element, right.condition
+ ));
+ }
+ "~" => {
+ left.join_full("[following-sibling::", &right, Some("]"), true);
+ }
+ other => {
+ return Err(SelectorError::Expression(format!(
+ "Unknown combinator: {other}"
+ )));
+ }
+ }
+ Ok(left)
+}
+
+/// Translate a functional pseudo-class.
+fn xpath_function(
+ cfg: &Config,
+ xpath: XpathExpr,
+ name: &str,
+ arguments: &[crate::tokenizer::Token],
+) -> Result<XpathExpr, SelectorError> {
+ match name {
+ "nth-child" => nth_child(xpath, arguments, false, true),
+ "nth-last-child" => nth_child(xpath, arguments, true, true),
+ "nth-of-type" => {
+ if xpath.element == "*" {
+ return Err(SelectorError::Expression(
+ "*:nth-of-type() is not implemented".to_string(),
+ ));
+ }
+ nth_child(xpath, arguments, false, false)
+ }
+ "nth-last-of-type" => {
+ if xpath.element == "*" {
+ return Err(SelectorError::Expression(
+ "*:nth-of-type() is not implemented".to_string(),
+ ));
+ }
+ nth_child(xpath, arguments, true, false)
+ }
+ "contains" => contains_function(xpath, arguments),
+ "lang" => lang_function(cfg, xpath, arguments),
+ other => Err(SelectorError::Expression(format!(
+ "The pseudo-class :{other}() is unknown"
+ ))),
+ }
+}
+
+/// The `:nth-*` core algorithm.
+fn nth_child(
+ mut xpath: XpathExpr,
+ arguments: &[crate::tokenizer::Token],
+ last: bool,
+ add_name_test: bool,
+) -> Result<XpathExpr, SelectorError> {
+ let invalid_series =
+ || SelectorError::Expression(format!("Invalid series: '{}'", repr_token_list(arguments)));
+ let (a, b) = match parse_series(arguments) {
+ Ok(pair) => pair,
+ Err(_) => return Err(invalid_series()),
+ };
+ let b_min_1 = match b.checked_sub(1) {
+ Some(value) => value,
+ None if a == 1 => return Ok(xpath),
+ None if a <= 0 => {
+ xpath.and_condition("0");
+ return Ok(xpath);
+ }
+ None => return Err(invalid_series()),
+ };
+ if a == 1 && b_min_1 <= 0 {
+ return Ok(xpath);
+ }
+ if a < 0 && b_min_1 < 0 {
+ xpath.and_condition("0");
+ return Ok(xpath);
+ }
+ let nodetest = if add_name_test {
+ "*".to_string()
+ } else {
+ xpath.element.clone()
+ };
+ let siblings_count = if !last {
+ format!("count(preceding-sibling::{nodetest})")
+ } else {
+ format!("count(following-sibling::{nodetest})")
+ };
+ if a == 0 {
+ xpath.and_condition(&format!("{siblings_count} = {b_min_1}"));
+ return Ok(xpath);
+ }
+ let mut expressions: Vec<String> = Vec::new();
+ if a > 0 {
+ if b_min_1 > 0 {
+ expressions.push(format!("{siblings_count} >= {b_min_1}"));
+ }
+ } else {
+ expressions.push(format!("{siblings_count} <= {b_min_1}"));
+ }
+ let a_abs = match a.checked_abs() {
+ Some(value) => value,
+ None if b_min_1 < 0 => {
+ xpath.and_condition("0");
+ return Ok(xpath);
+ }
+ None => {
+ xpath.and_condition(&format!("{siblings_count} = {b_min_1}"));
+ return Ok(xpath);
+ }
+ };
+ if a_abs != 1 {
+ let mut left = siblings_count.clone();
+ let b_neg = (-(b_min_1 as i128)).rem_euclid(a_abs as i128);
+ if b_neg != 0 {
+ left = format!("({left} +{b_neg})");
+ }
+ expressions.push(format!("{left} mod {a} = 0"));
+ }
+ let condition = if expressions.len() > 1 {
+ expressions
+ .iter()
+ .map(|e| format!("({e})"))
+ .collect::<Vec<_>>()
+ .join(" and ")
+ } else {
+ expressions.join(" and ")
+ };
+ xpath.and_condition(&condition);
+ Ok(xpath)
+}
+
+/// Translate `:contains()`.
+fn contains_function(
+ mut xpath: XpathExpr,
+ arguments: &[crate::tokenizer::Token],
+) -> Result<XpathExpr, SelectorError> {
+ let types = arg_types(arguments);
+ if types != ["STRING"] && types != ["IDENT"] {
+ return Err(SelectorError::Expression(format!(
+ "Expected a single string or ident for :contains(), got {}",
+ repr_token_list(arguments)
+ )));
+ }
+ let value = arguments[0].value_str();
+ xpath.and_condition(&format!("contains(., {})", xpath_literal(value)));
+ Ok(xpath)
+}
+
+/// Translate `:lang()` for the generic translator.
+fn lang_function(
+ cfg: &Config,
+ mut xpath: XpathExpr,
+ arguments: &[crate::tokenizer::Token],
+) -> Result<XpathExpr, SelectorError> {
+ let types = arg_types(arguments);
+ if types != ["STRING"] && types != ["IDENT"] {
+ return Err(SelectorError::Expression(format!(
+ "Expected a single string or ident for :lang(), got {}",
+ repr_token_list(arguments)
+ )));
+ }
+ let value = arguments[0].value_str();
+ if cfg.html {
+ let arg = xpath_literal(&format!("{}-", value.to_ascii_lowercase()));
+ xpath.and_condition(&format!(
+ "ancestor-or-self::*[@lang][1][starts-with(concat(translate(@{}, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '-'), {})]",
+ cfg.lang_attribute, arg
+ ));
+ } else {
+ xpath.and_condition(&format!("lang({})", xpath_literal(value)));
+ }
+ Ok(xpath)
+}
+
+/// The argument-type names for a token slice.
+fn arg_types(arguments: &[crate::tokenizer::Token]) -> Vec<&'static str> {
+ arguments.iter().map(|t| t.ty.name()).collect()
+}
+
+/// Render a token list the way a list of token reprs prints: `[<..>, <..>]`.
+///
+/// The expression errors echo the offending argument tokens, so the text has to
+/// match the repr of the argument list character for character.
+fn repr_token_list(arguments: &[crate::tokenizer::Token]) -> String {
+ let mut out = String::from("[");
+ for (i, t) in arguments.iter().enumerate() {
+ if i > 0 {
+ out.push_str(", ");
+ }
+ out.push_str(&format!("{t}"));
+ }
+ out.push(']');
+ out
+}
+
+/// Translate a simple pseudo-class.
+fn xpath_pseudo(
+ cfg: &Config,
+ mut xpath: XpathExpr,
+ ident: &str,
+) -> Result<XpathExpr, SelectorError> {
+ match ident {
+ "root" => {
+ xpath.and_condition("not(parent::*)");
+ }
+ "scope" => {
+ xpath.and_condition("1");
+ }
+ "first-child" => {
+ xpath.and_condition("count(preceding-sibling::*) = 0");
+ }
+ "last-child" => {
+ xpath.and_condition("count(following-sibling::*) = 0");
+ }
+ "first-of-type" => {
+ if xpath.element == "*" {
+ return Err(SelectorError::Expression(
+ "*:first-of-type is not implemented".to_string(),
+ ));
+ }
+ let cond = format!("count(preceding-sibling::{}) = 0", xpath.element);
+ xpath.and_condition(&cond);
+ }
+ "last-of-type" => {
+ if xpath.element == "*" {
+ return Err(SelectorError::Expression(
+ "*:last-of-type is not implemented".to_string(),
+ ));
+ }
+ let cond = format!("count(following-sibling::{}) = 0", xpath.element);
+ xpath.and_condition(&cond);
+ }
+ "only-child" => {
+ xpath.and_condition("count(parent::*/child::*) = 1");
+ }
+ "only-of-type" => {
+ if xpath.element == "*" {
+ return Err(SelectorError::Expression(
+ "*:only-of-type is not implemented".to_string(),
+ ));
+ }
+ let cond = format!("count(parent::*/child::{}) = 1", xpath.element);
+ xpath.and_condition(&cond);
+ }
+ "empty" => {
+ xpath.and_condition("not(*) and not(string-length())");
+ }
+ "link" => {
+ if cfg.html {
+ xpath.and_condition(
+ "@href and (name(.) = 'a' or name(.) = 'link' or name(.) = 'area')",
+ );
+ } else {
+ xpath.and_condition("0");
+ }
+ }
+ "checked" => {
+ if cfg.html {
+ xpath.and_condition(
+ "(@selected and name(.) = 'option') or (@checked and (name(.) = 'input' or name(.) = 'command')and (@type = 'checkbox' or @type = 'radio'))",
+ );
+ } else {
+ xpath.and_condition("0");
+ }
+ }
+ "disabled" => {
+ if cfg.html {
+ xpath.and_condition(HTML_DISABLED);
+ } else {
+ xpath.and_condition("0");
+ }
+ }
+ "enabled" => {
+ if cfg.html {
+ xpath.and_condition(HTML_ENABLED);
+ } else {
+ xpath.and_condition("0");
+ }
+ }
+ "visited" | "hover" | "active" | "focus" | "target" => {
+ xpath.and_condition("0");
+ }
+ other => {
+ return Err(SelectorError::Expression(format!(
+ "The pseudo-class :{other} is unknown"
+ )));
+ }
+ }
+ Ok(xpath)
+}
+
+/// The `:disabled` condition for HTML, byte-for-byte with the document order.
+const HTML_DISABLED: &str = "
+ (
+ @disabled and
+ (
+ (name(.) = 'input' and @type != 'hidden') or
+ name(.) = 'button' or
+ name(.) = 'select' or
+ name(.) = 'textarea' or
+ name(.) = 'command' or
+ name(.) = 'fieldset' or
+ name(.) = 'optgroup' or
+ name(.) = 'option'
+ )
+ ) or (
+ (
+ (name(.) = 'input' and @type != 'hidden') or
+ name(.) = 'button' or
+ name(.) = 'select' or
+ name(.) = 'textarea'
+ )
+ and ancestor::fieldset[@disabled]
+ )
+ ";
+
+/// The `:enabled` condition for HTML, byte-for-byte with the document order.
+const HTML_ENABLED: &str = "
+ (
+ @href and (
+ name(.) = 'a' or
+ name(.) = 'link' or
+ name(.) = 'area'
+ )
+ ) or (
+ (
+ name(.) = 'command' or
+ name(.) = 'fieldset' or
+ name(.) = 'optgroup'
+ )
+ and not(@disabled)
+ ) or (
+ (
+ (name(.) = 'input' and @type != 'hidden') or
+ name(.) = 'button' or
+ name(.) = 'select' or
+ name(.) = 'textarea' or
+ name(.) = 'keygen'
+ )
+ and not (@disabled or ancestor::fieldset[@disabled])
+ ) or (
+ name(.) = 'option' and not(
+ @disabled or ancestor::optgroup[@disabled]
+ )
+ )
+ ";
+
+/// Translator that targets generic XML. Fully case sensitive.
+#[derive(Debug, Clone)]
+pub struct GenericTranslator {
+ config: Config,
+}
+
+impl Default for GenericTranslator {
+ fn default() -> Self {
+ GenericTranslator::new()
+ }
+}
+
+impl GenericTranslator {
+ /// Create a translator with default settings.
+ pub fn new() -> Self {
+ GenericTranslator {
+ config: Config::generic(),
+ }
+ }
+
+ /// Translate a CSS group of selectors to an XPath string.
+ ///
+ /// The default prefix scopes selectors to the context node's subtree. Per
+ /// selector results join with `" | "`.
+ pub fn css_to_xpath(&self, css: &str) -> Result<String, SelectorError> {
+ css_to_xpath(&self.config, css, "descendant-or-self::")
+ }
+
+ /// Translate a CSS group of selectors using an explicit prefix.
+ ///
+ /// An empty prefix yields an XPath with no leading axis.
+ pub fn css_to_xpath_with_prefix(
+ &self,
+ css: &str,
+ prefix: &str,
+ ) -> Result<String, SelectorError> {
+ css_to_xpath(&self.config, css, prefix)
+ }
+
+ /// Translate a single parsed selector to an XPath string.
+ ///
+ /// The pseudo-element is ignored. The default prefix scopes the selector to
+ /// the context node's subtree.
+ pub fn selector_to_xpath(&self, selector: &Selector) -> Result<String, SelectorError> {
+ selector_to_xpath(
+ &self.config,
+ selector,
+ "descendant-or-self::",
+ PseudoElements::Ignore,
+ )
+ }
+
+ /// Translate a single parsed selector with an explicit prefix and
+ /// pseudo-element handling.
+ pub fn selector_to_xpath_with(
+ &self,
+ selector: &Selector,
+ prefix: &str,
+ pseudo_elements: PseudoElements,
+ ) -> Result<String, SelectorError> {
+ selector_to_xpath(&self.config, selector, prefix, pseudo_elements)
+ }
+}
diff --git a/browser/vendor/cssselect/tests/canonical.rs b/browser/vendor/cssselect/tests/canonical.rs
new file mode 100644
index 000000000..b30ceb385
--- /dev/null
+++ b/browser/vendor/cssselect/tests/canonical.rs
@@ -0,0 +1,78 @@
+//! Canonical CSS serialization round-trips.
+
+use cssselect::parse;
+
+/// Parse `css` and assert its canonical form equals `expected`.
+fn css2css(css: &str, expected: &str) {
+ let selectors = parse(css).unwrap();
+ assert_eq!(selectors.len(), 1, "expected one selector for {css:?}");
+ assert_eq!(selectors[0].canonical(), expected, "for {css:?}");
+}
+
+#[test]
+fn normalizations() {
+ css2css("*", "*");
+ css2css(" foo", "foo");
+ css2css("Foo", "Foo");
+ css2css(":empty ", ":empty");
+ css2css(":before", "::before");
+ css2css(":beFOre", "::before");
+ css2css("*:before", "::before");
+ css2css(":nth-child(2)", ":nth-child(2)");
+ css2css(".bar", ".bar");
+ css2css("[baz]", "[baz]");
+ css2css("[baz=\"4\"]", "[baz='4']");
+ css2css("[baz^=\"4\"]", "[baz^='4']");
+ css2css("[ns|attr='4']", "[ns|attr='4']");
+ css2css("#lipsum", "#lipsum");
+}
+
+#[test]
+fn logical_pseudos() {
+ css2css(":not(*)", ":not(*)");
+ css2css(":not(foo)", ":not(foo)");
+ css2css(":not(*.foo)", ":not(.foo)");
+ css2css(":not(*[foo])", ":not([foo])");
+ css2css(":not(:empty)", ":not(:empty)");
+ css2css(":not(#foo)", ":not(#foo)");
+ css2css(":has(*)", ":has(*)");
+ css2css(":has(foo)", ":has(foo)");
+ css2css(":has(*.foo)", ":has(.foo)");
+ css2css(":is(#bar, .foo)", ":is(#bar, .foo)");
+ css2css(":is(a,b)", ":is(a, b)");
+ css2css(":is(:focused, :visited)", ":is(:focused, :visited)");
+ css2css(":where(:focused, :visited)", ":where(:focused, :visited)");
+}
+
+#[test]
+fn pseudo_elements_and_combinators() {
+ css2css("foo:empty", "foo:empty");
+ css2css("foo::before", "foo::before");
+ css2css("foo:empty::before", "foo:empty::before");
+ css2css("::name(arg + \"val\" - 3)", "::name(arg+'val'-3)");
+ css2css(
+ "#lorem + foo#ipsum:first-child > bar::first-line",
+ "#lorem + foo#ipsum:first-child > bar::first-line",
+ );
+ css2css("foo > *", "foo > *");
+}
+
+#[test]
+fn string_value_escaping() {
+ // The value repr emits short escapes for tab and newline.
+ css2css("[a=\"\\9 tab\"]", "[a='\\ttab']");
+ css2css("[a=\"line\\a break\"]", "[a='line\\nbreak']");
+ // The quote choice flips to double quotes when the value holds a single
+ // quote and no double quote.
+ css2css("[a='it\\'s']", "[a=\"it's\"]");
+ css2css("[a=\"b\\\"c\"]", "[a='b\"c']");
+}
+
+#[test]
+fn matching_aliases_and_collapses() {
+ // `:matches` canonicalizes to `:is`.
+ css2css(":matches(a, b)", ":is(a, b)");
+ // A universal-only `:where` collapses its argument to empty.
+ css2css(":where(*)", ":where()");
+ css2css(":is(div, .a, #b)", ":is(div, .a, #b)");
+}
diff --git a/browser/vendor/cssselect/tests/fixtures/html_ids.html b/browser/vendor/cssselect/tests/fixtures/html_ids.html
new file mode 100644
index 000000000..155eb5648
--- /dev/null
+++ b/browser/vendor/cssselect/tests/fixtures/html_ids.html
@@ -0,0 +1,49 @@
+
+<html id="html"><head>
+ <link id="link-href" href="foo" />
+ <link id="link-nohref" />
+</head><body>
+<div id="outer-div">
+ <a id="name-anchor" name="foo"></a>
+ <a id="tag-anchor" rel="tag" href="http://localhost/foo">link</a>
+ <a id="nofollow-anchor" rel="nofollow" href="https://example.org">
+ link</a>
+ <ol id="first-ol" class="a b c">
+ <li id="first-li">content</li>
+ <li id="second-li" lang="En-us">
+ <div id="li-div">
+ </div>
+ </li>
+ <li id="third-li" class="ab c"></li>
+ <li id="fourth-li" class="ab
+c"></li>
+ <li id="fifth-li"></li>
+ <li id="sixth-li"></li>
+ <li id="seventh-li"> </li>
+ </ol>
+ <p id="paragraph">
+ <b id="p-b">hi</b> <em id="p-em">there</em>
+ <b id="p-b2">guy</b>
+ <input type="checkbox" id="checkbox-unchecked" />
+ <input type="checkbox" id="checkbox-disabled" disabled="" />
+ <input type="text" id="text-checked" checked="checked" />
+ <input type="hidden" />
+ <input type="hidden" disabled="disabled" />
+ <input type="checkbox" id="checkbox-checked" checked="checked" />
+ <input type="checkbox" id="checkbox-disabled-checked"
+ disabled="disabled" checked="checked" />
+ <fieldset id="fieldset" disabled="disabled">
+ <input type="checkbox" id="checkbox-fieldset-disabled" />
+ <input type="hidden" />
+ </fieldset>
+ </p>
+ <ol id="second-ol">
+ </ol>
+ <map name="dummymap">
+ <area shape="circle" coords="200,250,25" href="foo.html" id="area-href" />
+ <area shape="default" id="area-nohref" />
+ </map>
+</div>
+<div id="foobar-div" foobar="ab bc
+cde"><span id="foobar-span"></span></div>
+</body></html>
diff --git a/browser/vendor/cssselect/tests/fixtures/operator_precedence.xml b/browser/vendor/cssselect/tests/fixtures/operator_precedence.xml
new file mode 100644
index 000000000..630820b13
--- /dev/null
+++ b/browser/vendor/cssselect/tests/fixtures/operator_precedence.xml
@@ -0,0 +1,6 @@
+
+<html>
+ <a id="first"></a>
+ <a id="second" href="#"></a>
+ <a id="third" href="#"></a>
+</html>
diff --git a/browser/vendor/cssselect/tests/fixtures/shakespeare.html b/browser/vendor/cssselect/tests/fixtures/shakespeare.html
new file mode 100644
index 000000000..bec4d97a9
--- /dev/null
+++ b/browser/vendor/cssselect/tests/fixtures/shakespeare.html
@@ -0,0 +1,309 @@
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en" debug="true">
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+</head>
+<body>
+ <div id="test">
+ <div class="dialog">
+ <h2>As You Like It</h2>
+ <div id="playwright">
+ by William Shakespeare
+ </div>
+ <div class="dialog scene thirdClass" id="scene1">
+ <h3>ACT I, SCENE III. A room in the palace.</h3>
+ <div class="dialog">
+ <div class="direction">Enter CELIA and ROSALIND</div>
+ </div>
+ <div id="speech1" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.1">Why, cousin! why, Rosalind! Cupid have mercy! not a word?</div>
+ </div>
+ <div id="speech2" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.2">Not one to throw at a dog.</div>
+ </div>
+ <div id="speech3" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.3">No, thy words are too precious to be cast away upon</div>
+ <div id="scene1.3.4">curs; throw some of them at me; come, lame me with reasons.</div>
+ </div>
+ <div id="speech4" class="character">ROSALIND</div>
+ <div id="speech5" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.8">But is all this for your father?</div>
+ </div>
+ <div class="dialog">
+ <div id="scene1.3.5">Then there were two cousins laid up; when the one</div>
+ <div id="scene1.3.6">should be lamed with reasons and the other mad</div>
+ <div id="scene1.3.7">without any.</div>
+ </div>
+ <div id="speech6" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.9">No, some of it is for my child's father. O, how</div>
+ <div id="scene1.3.10">full of briers is this working-day world!</div>
+ </div>
+ <div id="speech7" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.11">They are but burs, cousin, thrown upon thee in</div>
+ <div id="scene1.3.12">holiday foolery: if we walk not in the trodden</div>
+ <div id="scene1.3.13">paths our very petticoats will catch them.</div>
+ </div>
+ <div id="speech8" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.14">I could shake them off my coat: these burs are in my heart.</div>
+ </div>
+ <div id="speech9" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.15">Hem them away.</div>
+ </div>
+ <div id="speech10" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.16">I would try, if I could cry 'hem' and have him.</div>
+ </div>
+ <div id="speech11" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.17">Come, come, wrestle with thy affections.</div>
+ </div>
+ <div id="speech12" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.18">O, they take the part of a better wrestler than myself!</div>
+ </div>
+ <div id="speech13" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.19">O, a good wish upon you! you will try in time, in</div>
+ <div id="scene1.3.20">despite of a fall. But, turning these jests out of</div>
+ <div id="scene1.3.21">service, let us talk in good earnest: is it</div>
+ <div id="scene1.3.22">possible, on such a sudden, you should fall into so</div>
+ <div id="scene1.3.23">strong a liking with old Sir Rowland's youngest son?</div>
+ </div>
+ <div id="speech14" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.24">The duke my father loved his father dearly.</div>
+ </div>
+ <div id="speech15" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.25">Doth it therefore ensue that you should love his son</div>
+ <div id="scene1.3.26">dearly? By this kind of chase, I should hate him,</div>
+ <div id="scene1.3.27">for my father hated his father dearly; yet I hate</div>
+ <div id="scene1.3.28">not Orlando.</div>
+ </div>
+ <div id="speech16" class="character">ROSALIND</div>
+ <div title="wtf" class="dialog">
+ <div id="scene1.3.29">No, faith, hate him not, for my sake.</div>
+ </div>
+ <div id="speech17" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.30">Why should I not? doth he not deserve well?</div>
+ </div>
+ <div id="speech18" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.31">Let me love him for that, and do you love him</div>
+ <div id="scene1.3.32">because I do. Look, here comes the duke.</div>
+ </div>
+ <div id="speech19" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.33">With his eyes full of anger.</div>
+ <div class="direction">Enter DUKE FREDERICK, with Lords</div>
+ </div>
+ <div id="speech20" class="character">DUKE FREDERICK</div>
+ <div class="dialog">
+ <div id="scene1.3.34">Mistress, dispatch you with your safest haste</div>
+ <div id="scene1.3.35">And get you from our court.</div>
+ </div>
+ <div id="speech21" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.36">Me, uncle?</div>
+ </div>
+ <div id="speech22" class="character">DUKE FREDERICK</div>
+ <div class="dialog">
+ <div id="scene1.3.37">You, cousin</div>
+ <div id="scene1.3.38">Within these ten days if that thou be'st found</div>
+ <div id="scene1.3.39">So near our public court as twenty miles,</div>
+ <div id="scene1.3.40">Thou diest for it.</div>
+ </div>
+ <div id="speech23" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.41"> I do beseech your grace,</div>
+ <div id="scene1.3.42">Let me the knowledge of my fault bear with me:</div>
+ <div id="scene1.3.43">If with myself I hold intelligence</div>
+ <div id="scene1.3.44">Or have acquaintance with mine own desires,</div>
+ <div id="scene1.3.45">If that I do not dream or be not frantic,--</div>
+ <div id="scene1.3.46">As I do trust I am not--then, dear uncle,</div>
+ <div id="scene1.3.47">Never so much as in a thought unborn</div>
+ <div id="scene1.3.48">Did I offend your highness.</div>
+ </div>
+ <div id="speech24" class="character">DUKE FREDERICK</div>
+ <div class="dialog">
+ <div id="scene1.3.49">Thus do all traitors:</div>
+ <div id="scene1.3.50">If their purgation did consist in words,</div>
+ <div id="scene1.3.51">They are as innocent as grace itself:</div>
+ <div id="scene1.3.52">Let it suffice thee that I trust thee not.</div>
+ </div>
+ <div id="speech25" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.53">Yet your mistrust cannot make me a traitor:</div>
+ <div id="scene1.3.54">Tell me whereon the likelihood depends.</div>
+ </div>
+ <div id="speech26" class="character">DUKE FREDERICK</div>
+ <div class="dialog">
+ <div id="scene1.3.55">Thou art thy father's daughter; there's enough.</div>
+ </div>
+ <div id="speech27" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.56">So was I when your highness took his dukedom;</div>
+ <div id="scene1.3.57">So was I when your highness banish'd him:</div>
+ <div id="scene1.3.58">Treason is not inherited, my lord;</div>
+ <div id="scene1.3.59">Or, if we did derive it from our friends,</div>
+ <div id="scene1.3.60">What's that to me? my father was no traitor:</div>
+ <div id="scene1.3.61">Then, good my liege, mistake me not so much</div>
+ <div id="scene1.3.62">To think my poverty is treacherous.</div>
+ </div>
+ <div id="speech28" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.63">Dear sovereign, hear me speak.</div>
+ </div>
+ <div id="speech29" class="character">DUKE FREDERICK</div>
+ <div class="dialog">
+ <div id="scene1.3.64">Ay, Celia; we stay'd her for your sake,</div>
+ <div id="scene1.3.65">Else had she with her father ranged along.</div>
+ </div>
+ <div id="speech30" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.66">I did not then entreat to have her stay;</div>
+ <div id="scene1.3.67">It was your pleasure and your own remorse:</div>
+ <div id="scene1.3.68">I was too young that time to value her;</div>
+ <div id="scene1.3.69">But now I know her: if she be a traitor,</div>
+ <div id="scene1.3.70">Why so am I; we still have slept together,</div>
+ <div id="scene1.3.71">Rose at an instant, learn'd, play'd, eat together,</div>
+ <div id="scene1.3.72">And wheresoever we went, like Juno's swans,</div>
+ <div id="scene1.3.73">Still we went coupled and inseparable.</div>
+ </div>
+ <div id="speech31" class="character">DUKE FREDERICK</div>
+ <div class="dialog">
+ <div id="scene1.3.74">She is too subtle for thee; and her smoothness,</div>
+ <div id="scene1.3.75">Her very silence and her patience</div>
+ <div id="scene1.3.76">Speak to the people, and they pity her.</div>
+ <div id="scene1.3.77">Thou art a fool: she robs thee of thy name;</div>
+ <div id="scene1.3.78">And thou wilt show more bright and seem more virtuous</div>
+ <div id="scene1.3.79">When she is gone. Then open not thy lips:</div>
+ <div id="scene1.3.80">Firm and irrevocable is my doom</div>
+ <div id="scene1.3.81">Which I have pass'd upon her; she is banish'd.</div>
+ </div>
+ <div id="speech32" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.82">Pronounce that sentence then on me, my liege:</div>
+ <div id="scene1.3.83">I cannot live out of her company.</div>
+ </div>
+ <div id="speech33" class="character">DUKE FREDERICK</div>
+ <div class="dialog">
+ <div id="scene1.3.84">You are a fool. You, niece, provide yourself:</div>
+ <div id="scene1.3.85">If you outstay the time, upon mine honour,</div>
+ <div id="scene1.3.86">And in the greatness of my word, you die.</div>
+ <div class="direction">Exeunt DUKE FREDERICK and Lords</div>
+ </div>
+ <div id="speech34" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.87">O my poor Rosalind, whither wilt thou go?</div>
+ <div id="scene1.3.88">Wilt thou change fathers? I will give thee mine.</div>
+ <div id="scene1.3.89">I charge thee, be not thou more grieved than I am.</div>
+ </div>
+ <div id="speech35" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.90">I have more cause.</div>
+ </div>
+ <div id="speech36" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.91"> Thou hast not, cousin;</div>
+ <div id="scene1.3.92">Prithee be cheerful: know'st thou not, the duke</div>
+ <div id="scene1.3.93">Hath banish'd me, his daughter?</div>
+ </div>
+ <div id="speech37" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.94">That he hath not.</div>
+ </div>
+ <div id="speech38" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.95">No, hath not? Rosalind lacks then the love</div>
+ <div id="scene1.3.96">Which teacheth thee that thou and I am one:</div>
+ <div id="scene1.3.97">Shall we be sunder'd? shall we part, sweet girl?</div>
+ <div id="scene1.3.98">No: let my father seek another heir.</div>
+ <div id="scene1.3.99">Therefore devise with me how we may fly,</div>
+ <div id="scene1.3.100">Whither to go and what to bear with us;</div>
+ <div id="scene1.3.101">And do not seek to take your change upon you,</div>
+ <div id="scene1.3.102">To bear your griefs yourself and leave me out;</div>
+ <div id="scene1.3.103">For, by this heaven, now at our sorrows pale,</div>
+ <div id="scene1.3.104">Say what thou canst, I'll go along with thee.</div>
+ </div>
+ <div id="speech39" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.105">Why, whither shall we go?</div>
+ </div>
+ <div id="speech40" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.106">To seek my uncle in the forest of Arden.</div>
+ </div>
+ <div id="speech41" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.107">Alas, what danger will it be to us,</div>
+ <div id="scene1.3.108">Maids as we are, to travel forth so far!</div>
+ <div id="scene1.3.109">Beauty provoketh thieves sooner than gold.</div>
+ </div>
+ <div id="speech42" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.110">I'll put myself in poor and mean attire</div>
+ <div id="scene1.3.111">And with a kind of umber smirch my face;</div>
+ <div id="scene1.3.112">The like do you: so shall we pass along</div>
+ <div id="scene1.3.113">And never stir assailants.</div>
+ </div>
+ <div id="speech43" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.114">Were it not better,</div>
+ <div id="scene1.3.115">Because that I am more than common tall,</div>
+ <div id="scene1.3.116">That I did suit me all points like a man?</div>
+ <div id="scene1.3.117">A gallant curtle-axe upon my thigh,</div>
+ <div id="scene1.3.118">A boar-spear in my hand; and--in my heart</div>
+ <div id="scene1.3.119">Lie there what hidden woman's fear there will--</div>
+ <div id="scene1.3.120">We'll have a swashing and a martial outside,</div>
+ <div id="scene1.3.121">As many other mannish cowards have</div>
+ <div id="scene1.3.122">That do outface it with their semblances.</div>
+ </div>
+ <div id="speech44" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.123">What shall I call thee when thou art a man?</div>
+ </div>
+ <div id="speech45" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.124">I'll have no worse a name than Jove's own page;</div>
+ <div id="scene1.3.125">And therefore look you call me Ganymede.</div>
+ <div id="scene1.3.126">But what will you be call'd?</div>
+ </div>
+ <div id="speech46" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.127">Something that hath a reference to my state</div>
+ <div id="scene1.3.128">No longer Celia, but Aliena.</div>
+ </div>
+ <div id="speech47" class="character">ROSALIND</div>
+ <div class="dialog">
+ <div id="scene1.3.129">But, cousin, what if we assay'd to steal</div>
+ <div id="scene1.3.130">The clownish fool out of your father's court?</div>
+ <div id="scene1.3.131">Would he not be a comfort to our travel?</div>
+ </div>
+ <div id="speech48" class="character">CELIA</div>
+ <div class="dialog">
+ <div id="scene1.3.132">He'll go along o'er the wide world with me;</div>
+ <div id="scene1.3.133">Leave me alone to woo him. Let's away,</div>
+ <div id="scene1.3.134">And get our jewels and our wealth together,</div>
+ <div id="scene1.3.135">Devise the fittest time and safest way</div>
+ <div id="scene1.3.136">To hide us from pursuit that will be made</div>
+ <div id="scene1.3.137">After my flight. Now go we in content</div>
+ <div id="scene1.3.138">To liberty and not to banishment.</div>
+ <div class="direction">Exeunt</div>
+ </div>
+ </div>
+ </div>
+</div>
+</body>
+</html>
diff --git a/browser/vendor/cssselect/tests/fixtures/xmllang.xml b/browser/vendor/cssselect/tests/fixtures/xmllang.xml
new file mode 100644
index 000000000..a52a43395
--- /dev/null
+++ b/browser/vendor/cssselect/tests/fixtures/xmllang.xml
@@ -0,0 +1,12 @@
+
+<test>
+ <a id="first" xml:lang="en">a</a>
+ <b id="second" xml:lang="en-US">b</b>
+ <c id="third" xml:lang="en-Nz">c</c>
+ <d id="fourth" xml:lang="En-us">d</d>
+ <e id="fifth" xml:lang="fr">e</e>
+ <f id="sixth" xml:lang="ru">f</f>
+ <g id="seventh" xml:lang="de">
+ <h id="eighth" xml:lang="zh"/>
+ </g>
+</test>
diff --git a/browser/vendor/cssselect/tests/html_translator.rs b/browser/vendor/cssselect/tests/html_translator.rs
new file mode 100644
index 000000000..26395342b
--- /dev/null
+++ b/browser/vendor/cssselect/tests/html_translator.rs
@@ -0,0 +1,75 @@
+//! HTML translator output: case folding, the `lang` attribute, and the
+//! HTML-specific pseudo-class blocks.
+
+use cssselect::{GenericTranslator, HtmlTranslator};
+
+/// Translate with the HTML translator and an empty prefix.
+fn html(css: &str) -> String {
+ HtmlTranslator::new()
+ .css_to_xpath_with_prefix(css, "")
+ .unwrap()
+}
+
+/// Translate with the XHTML translator and an empty prefix.
+fn xhtml(css: &str) -> String {
+ HtmlTranslator::with_xhtml(true)
+ .css_to_xpath_with_prefix(css, "")
+ .unwrap()
+}
+
+#[test]
+fn element_names_fold_to_lower_case() {
+ assert_eq!(html("DIV"), "div");
+ assert_eq!(html("A[NAme]"), "a[@name]");
+ // XHTML keeps names as written.
+ assert_eq!(xhtml("DIV"), "DIV");
+ assert_eq!(xhtml("A[NAme]"), "A[@NAme]");
+}
+
+#[test]
+fn link_pseudo() {
+ assert_eq!(
+ html(":link"),
+ "*[@href and (name(.) = 'a' or name(.) = 'link' or name(.) = 'area')]"
+ );
+ // The generic translator never matches :link.
+ assert_eq!(
+ GenericTranslator::new()
+ .css_to_xpath_with_prefix(":link", "")
+ .unwrap(),
+ "*[0]"
+ );
+}
+
+#[test]
+fn visited_pseudo_never_matches() {
+ assert_eq!(html(":visited"), "*[0]");
+}
+
+#[test]
+fn checked_pseudo() {
+ assert_eq!(
+ html(":checked"),
+ "*[(@selected and name(.) = 'option') or (@checked and (name(.) = 'input' or name(.) = 'command')and (@type = 'checkbox' or @type = 'radio'))]"
+ );
+}
+
+#[test]
+fn lang_function_uses_lang_attribute() {
+ assert_eq!(
+ html(":lang(en)"),
+ "*[ancestor-or-self::*[@lang][1][starts-with(concat(translate(@lang, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), '-'), 'en-')]]"
+ );
+}
+
+#[test]
+fn disabled_pseudo_block() {
+ let expected = "*[\n (\n @disabled and\n (\n (name(.) = 'input' and @type != 'hidden') or\n name(.) = 'button' or\n name(.) = 'select' or\n name(.) = 'textarea' or\n name(.) = 'command' or\n name(.) = 'fieldset' or\n name(.) = 'optgroup' or\n name(.) = 'option'\n )\n ) or (\n (\n (name(.) = 'input' and @type != 'hidden') or\n name(.) = 'button' or\n name(.) = 'select' or\n name(.) = 'textarea'\n )\n and ancestor::fieldset[@disabled]\n )\n ]";
+ assert_eq!(html(":disabled"), expected);
+}
+
+#[test]
+fn enabled_pseudo_block() {
+ let expected = "*[\n (\n @href and (\n name(.) = 'a' or\n name(.) = 'link' or\n name(.) = 'area'\n )\n ) or (\n (\n name(.) = 'command' or\n name(.) = 'fieldset' or\n name(.) = 'optgroup'\n )\n and not(@disabled)\n ) or (\n (\n (name(.) = 'input' and @type != 'hidden') or\n name(.) = 'button' or\n name(.) = 'select' or\n name(.) = 'textarea' or\n name(.) = 'keygen'\n )\n and not (@disabled or ancestor::fieldset[@disabled])\n ) or (\n name(.) = 'option' and not(\n @disabled or ancestor::optgroup[@disabled]\n )\n )\n ]";
+ assert_eq!(html(":enabled"), expected);
+}
diff --git a/browser/vendor/cssselect/tests/parse_errors.rs b/browser/vendor/cssselect/tests/parse_errors.rs
new file mode 100644
index 000000000..e81ab7aea
--- /dev/null
+++ b/browser/vendor/cssselect/tests/parse_errors.rs
@@ -0,0 +1,117 @@
+//! Exact `SelectorSyntaxError` message strings.
+
+use cssselect::{parse, SelectorError};
+
+/// The error message for `css`, or `None` when it parses.
+fn get_error(css: &str) -> Option<String> {
+ match parse(css) {
+ Err(SelectorError::Syntax(msg)) => Some(msg),
+ Err(other) => panic!("expected syntax error for {css:?}, got {other:?}"),
+ Ok(_) => None,
+ }
+}
+
+/// Assert the error for `css` equals `expected`.
+fn assert_error(css: &str, expected: &str) {
+ assert_eq!(get_error(css).as_deref(), Some(expected), "for {css:?}");
+}
+
+#[test]
+fn structural_errors() {
+ assert_error(
+ "attributes(href)/html/body/a",
+ "Expected selector, got <DELIM '(' at 10>",
+ );
+ assert_error(
+ "attributes(href)",
+ "Expected selector, got <DELIM '(' at 10>",
+ );
+ assert_error("html/body/a", "Expected selector, got <DELIM '/' at 4>");
+ assert_error(" ", "Expected selector, got <EOF at 1>");
+ assert_error("div, ", "Expected selector, got <EOF at 5>");
+ assert_error(" , div", "Expected selector, got <DELIM ',' at 1>");
+ assert_error("p, , div", "Expected selector, got <DELIM ',' at 3>");
+ assert_error("div > ", "Expected selector, got <EOF at 6>");
+ assert_error(" > div", "Expected selector, got <DELIM '>' at 2>");
+}
+
+#[test]
+fn name_and_attribute_errors() {
+ assert_error("foo|#bar", "Expected ident or '*', got <HASH 'bar' at 4>");
+ assert_error("#.foo", "Expected selector, got <DELIM '#' at 0>");
+ assert_error(".#foo", "Expected ident, got <HASH 'foo' at 1>");
+ assert_error(":#foo", "Expected ident, got <HASH 'foo' at 1>");
+ assert_error("[*]", "Expected '|', got <DELIM ']' at 2>");
+ assert_error("[foo|]", "Expected ident, got <DELIM ']' at 5>");
+ assert_error("[#]", "Expected ident or '*', got <DELIM '#' at 1>");
+ assert_error("[foo=#]", "Expected string or ident, got <DELIM '#' at 5>");
+ assert_error("[href]a", "Expected selector, got <IDENT 'a' at 6>");
+ assert_eq!(get_error("[rel=stylesheet]"), None);
+ assert_error(
+ "[rel:stylesheet]",
+ "Operator expected, got <DELIM ':' at 4>",
+ );
+ assert_error("[rel=stylesheet", "Expected ']', got <EOF at 15>");
+}
+
+#[test]
+fn function_and_string_errors() {
+ assert_eq!(get_error(":lang(fr)"), None);
+ assert_error(":lang(fr", "Expected an argument, got <EOF at 8>");
+ assert_error(":contains(\"foo", "Unclosed string at 10");
+ assert_error("foo!", "Expected selector, got <DELIM '!' at 3>");
+}
+
+#[test]
+fn misplaced_pseudo_elements() {
+ assert_error(
+ "a:before:empty",
+ "Got pseudo-element ::before not at the end of a selector",
+ );
+ assert_error(
+ "li:before a",
+ "Got pseudo-element ::before not at the end of a selector",
+ );
+ assert_error(
+ ":not(:before)",
+ "Got pseudo-element ::before inside :not() at 12",
+ );
+ assert_error(":not(:not(a))", "Got nested :not()");
+ assert_error(
+ ":is(:before)",
+ "Got pseudo-element ::before inside function",
+ );
+ assert_error(":is(a b)", "Expected an argument, got <IDENT 'b' at 6>");
+ assert_error(
+ ":where(:before)",
+ "Got pseudo-element ::before inside function",
+ );
+ assert_error(":where(a b)", "Expected an argument, got <IDENT 'b' at 9>");
+}
+
+#[test]
+fn scope_placement() {
+ assert_error(
+ ":scope > div :scope header",
+ "Got immediate child pseudo-element \":scope\" not at the start of a selector",
+ );
+ assert_error(
+ "div :scope header",
+ "Got immediate child pseudo-element \":scope\" not at the start of a selector",
+ );
+ assert_error("> div p", "Expected selector, got <DELIM '>' at 0>");
+}
+
+#[test]
+fn has_arity() {
+ assert_error(":has(a, b)", "Expected an argument, got <DELIM ',' at 6>");
+ assert_error(":has()", "Expected selector, got <EOF at 0>");
+}
+
+#[test]
+fn is_where_empty_and_comma_edges() {
+ assert_error(":is()", "Expected selector, got <DELIM ')' at 4>");
+ assert_error(":where()", "Expected selector, got <DELIM ')' at 7>");
+ assert_error(":is(a,)", "Expected selector, got <DELIM ')' at 6>");
+ assert_error(":is(,a)", "Expected selector, got <DELIM ',' at 4>");
+}
diff --git a/browser/vendor/cssselect/tests/parser_repr.rs b/browser/vendor/cssselect/tests/parser_repr.rs
new file mode 100644
index 000000000..1c558852c
--- /dev/null
+++ b/browser/vendor/cssselect/tests/parser_repr.rs
@@ -0,0 +1,210 @@
+//! Parse-tree `repr` output and fast-path equivalence.
+
+use cssselect::parse;
+
+/// The `repr` of each parsed tree, asserting every pseudo-element is absent.
+fn repr_parse(css: &str) -> Vec<String> {
+ let selectors = parse(css).unwrap();
+ for s in &selectors {
+ assert!(
+ s.pseudo_element.is_none(),
+ "unexpected pseudo-element in {css:?}"
+ );
+ }
+ selectors.iter().map(|s| s.parsed_tree.repr()).collect()
+}
+
+/// Assert every spelling parses to the same tree reprs as the first.
+fn parse_many(first: &str, others: &[&str]) -> Vec<String> {
+ let result = repr_parse(first);
+ for other in others {
+ assert_eq!(repr_parse(other), result, "mismatch for {other:?}");
+ }
+ result
+}
+
+#[test]
+fn universal_and_namespaces() {
+ assert_eq!(parse_many("*", &["*|*"]), vec!["Element[*]"]);
+ assert_eq!(parse_many("*|foo", &["|foo"]), vec!["Element[foo]"]);
+ assert_eq!(parse_many("foo|*", &[]), vec!["Element[foo|*]"]);
+ assert_eq!(parse_many("foo|bar", &[]), vec!["Element[foo|bar]"]);
+}
+
+#[test]
+fn stacked_hash() {
+ assert_eq!(
+ parse_many("#foo#bar", &[]),
+ vec!["Hash[Hash[Element[*]#foo]#bar]"]
+ );
+}
+
+#[test]
+fn combinator_whitespace_equivalence() {
+ assert_eq!(
+ parse_many(
+ "div>.foo",
+ &[
+ "div> .foo",
+ "div >.foo",
+ "div > .foo",
+ "div \n> \t \t .foo",
+ "div\r>\n\n\n.foo",
+ "div\u{0c}>\u{0c}.foo",
+ ],
+ ),
+ vec!["CombinedSelector[Element[div] > Class[Element[*].foo]]"]
+ );
+}
+
+#[test]
+fn selector_groups() {
+ assert_eq!(
+ parse_many(
+ "td.foo,.bar",
+ &["td.foo, .bar", "td.foo\t\r\n\u{0c} ,\t\r\n\u{0c} .bar"]
+ ),
+ vec!["Class[Element[td].foo]", "Class[Element[*].bar]"]
+ );
+ assert_eq!(
+ parse_many("div, td.foo, div.bar span", &[]),
+ vec![
+ "Element[div]",
+ "Class[Element[td].foo]",
+ "CombinedSelector[Class[Element[div].bar] <followed> Element[span]]",
+ ]
+ );
+}
+
+#[test]
+fn attributes() {
+ assert_eq!(
+ parse_many("a[name]", &["a[ name\t]"]),
+ vec!["Attrib[Element[a][name]]"]
+ );
+ assert_eq!(
+ parse_many("a [name]", &[]),
+ vec!["CombinedSelector[Element[a] <followed> Attrib[Element[*][name]]]"]
+ );
+ assert_eq!(
+ parse_many("a[rel=\"include\"]", &["a[rel = include]"]),
+ vec!["Attrib[Element[a][rel = 'include']]"]
+ );
+ assert_eq!(
+ parse_many("a[hreflang |= 'en']", &["a[hreflang|=en]"]),
+ vec!["Attrib[Element[a][hreflang |= 'en']]"]
+ );
+}
+
+#[test]
+fn functions_and_pseudos() {
+ assert_eq!(
+ parse_many("div:nth-child(10)", &[]),
+ vec!["Function[Element[div]:nth-child(['10'])]"]
+ );
+ assert_eq!(
+ parse_many(":nth-child(2n+2)", &[]),
+ vec!["Function[Element[*]:nth-child(['2', 'n', '+2'])]"]
+ );
+ assert_eq!(
+ parse_many("div:nth-of-type(10)", &[]),
+ vec!["Function[Element[div]:nth-of-type(['10'])]"]
+ );
+ assert_eq!(
+ parse_many("div div:nth-of-type(10) .aclass", &[]),
+ vec![
+ "CombinedSelector[CombinedSelector[Element[div] <followed> \
+Function[Element[div]:nth-of-type(['10'])]] <followed> Class[Element[*].aclass]]"
+ ]
+ );
+ assert_eq!(
+ parse_many("label:only", &[]),
+ vec!["Pseudo[Element[label]:only]"]
+ );
+ assert_eq!(
+ parse_many("a:lang(fr)", &[]),
+ vec!["Function[Element[a]:lang(['fr'])]"]
+ );
+ assert_eq!(
+ parse_many("div:contains(\"foo\")", &[]),
+ vec!["Function[Element[div]:contains(['foo'])]"]
+ );
+ assert_eq!(
+ parse_many("div#foobar", &[]),
+ vec!["Hash[Element[div]#foobar]"]
+ );
+ assert_eq!(
+ parse_many("td:first", &[]),
+ vec!["Pseudo[Element[td]:first]"]
+ );
+ assert_eq!(
+ parse_many("td :first", &[]),
+ vec!["CombinedSelector[Element[td] <followed> Pseudo[Element[*]:first]]"]
+ );
+}
+
+#[test]
+fn logical_combinators() {
+ assert_eq!(
+ parse_many("div:not(div.foo)", &[]),
+ vec!["Negation[Element[div]:not(Class[Element[div].foo])]"]
+ );
+ assert_eq!(
+ parse_many("div:has(div.foo)", &[]),
+ vec!["Relation[Element[div]:has(Selector[Class[Element[div].foo]])]"]
+ );
+ assert_eq!(
+ parse_many("div:is(.foo, #bar)", &[]),
+ vec!["Matching[Element[div]:is(Class[Element[*].foo], Hash[Element[*]#bar])]"]
+ );
+ assert_eq!(
+ parse_many(":is(:hover, :visited)", &[]),
+ vec!["Matching[Element[*]:is(Pseudo[Element[*]:hover], Pseudo[Element[*]:visited])]"]
+ );
+ assert_eq!(
+ parse_many(":where(:hover, :visited)", &[]),
+ vec!["SpecificityAdjustment[Element[*]:where(Pseudo[Element[*]:hover], Pseudo[Element[*]:visited])]"]
+ );
+ assert_eq!(
+ parse_many("td ~ th", &[]),
+ vec!["CombinedSelector[Element[td] ~ Element[th]]"]
+ );
+}
+
+#[test]
+fn scope_placement() {
+ assert_eq!(
+ parse_many(":scope > foo", &[" :scope > foo"]),
+ vec!["CombinedSelector[Pseudo[Element[*]:scope] > Element[foo]]"]
+ );
+ assert_eq!(
+ parse_many(":scope > foo bar > div", &[]),
+ vec![
+ "CombinedSelector[CombinedSelector[CombinedSelector[Pseudo[Element[*]:scope] > \
+Element[foo]] <followed> Element[bar]] > Element[div]]"
+ ]
+ );
+ assert_eq!(
+ parse_many(":scope > #foo #bar", &[]),
+ vec![
+ "CombinedSelector[CombinedSelector[Pseudo[Element[*]:scope] > \
+Hash[Element[*]#foo]] <followed> Hash[Element[*]#bar]]"
+ ]
+ );
+}
+
+#[test]
+fn fast_path_matches_slow_path() {
+ // The fast-path regexes must yield the same trees as the tokenizer route.
+ assert_eq!(repr_parse("foo"), repr_parse(" foo "));
+ assert_eq!(repr_parse("#bar"), repr_parse(" #bar "));
+ assert_eq!(repr_parse("foo#bar"), repr_parse(" foo#bar "));
+ assert_eq!(repr_parse(".bar"), repr_parse(" .bar "));
+ assert_eq!(repr_parse("foo.bar"), repr_parse(" foo.bar "));
+
+ assert_eq!(repr_parse("foo"), vec!["Element[foo]"]);
+ assert_eq!(repr_parse("#bar"), vec!["Hash[Element[*]#bar]"]);
+ assert_eq!(repr_parse("foo#bar"), vec!["Hash[Element[foo]#bar]"]);
+ assert_eq!(repr_parse(".bar"), vec!["Class[Element[*].bar]"]);
+ assert_eq!(repr_parse("foo.bar"), vec!["Class[Element[foo].bar]"]);
+}
diff --git a/browser/vendor/cssselect/tests/pseudo_elements.rs b/browser/vendor/cssselect/tests/pseudo_elements.rs
new file mode 100644
index 000000000..968a32696
--- /dev/null
+++ b/browser/vendor/cssselect/tests/pseudo_elements.rs
@@ -0,0 +1,199 @@
+//! Pseudo-element parsing, `repr`, and default translation behavior.
+
+use cssselect::{parse, GenericTranslator, PseudoElement, PseudoElements, SelectorError};
+
+/// The tree `repr` and the pseudo-element as a display string for each selector.
+fn parse_pseudo(css: &str) -> Vec<(String, Option<String>)> {
+ parse(css)
+ .unwrap()
+ .iter()
+ .map(|s| {
+ let pe = s.pseudo_element.as_ref().map(pe_display);
+ (s.parsed_tree.repr(), pe)
+ })
+ .collect()
+}
+
+/// The display form of a pseudo-element: the ident, or the functional repr.
+fn pe_display(pe: &PseudoElement) -> String {
+ match pe {
+ PseudoElement::Ident(name) => name.clone(),
+ PseudoElement::Functional(f) => f.repr(),
+ }
+}
+
+/// Parse one selector and return its (tree repr, pseudo-element) pair.
+fn parse_one(css: &str) -> (String, Option<String>) {
+ let result = parse_pseudo(css);
+ assert_eq!(result.len(), 1, "expected one selector for {css:?}");
+ result.into_iter().next().unwrap()
+}
+
+#[test]
+fn pseudo_classes_have_no_pseudo_element() {
+ assert_eq!(parse_one("foo"), ("Element[foo]".into(), None));
+ assert_eq!(parse_one("*"), ("Element[*]".into(), None));
+ assert_eq!(
+ parse_one(":empty"),
+ ("Pseudo[Element[*]:empty]".into(), None)
+ );
+ assert_eq!(
+ parse_one(":scope"),
+ ("Pseudo[Element[*]:scope]".into(), None)
+ );
+}
+
+#[test]
+fn css21_single_colon_pseudo_elements() {
+ assert_eq!(
+ parse_one(":BEfore"),
+ ("Element[*]".into(), Some("before".into()))
+ );
+ assert_eq!(
+ parse_one(":aftER"),
+ ("Element[*]".into(), Some("after".into()))
+ );
+ assert_eq!(
+ parse_one(":First-Line"),
+ ("Element[*]".into(), Some("first-line".into()))
+ );
+ assert_eq!(
+ parse_one(":First-Letter"),
+ ("Element[*]".into(), Some("first-letter".into()))
+ );
+
+ assert_eq!(
+ parse_one("::befoRE"),
+ ("Element[*]".into(), Some("before".into()))
+ );
+ assert_eq!(
+ parse_one("::AFter"),
+ ("Element[*]".into(), Some("after".into()))
+ );
+ assert_eq!(
+ parse_one("::firsT-linE"),
+ ("Element[*]".into(), Some("first-line".into()))
+ );
+ assert_eq!(
+ parse_one("::firsT-letteR"),
+ ("Element[*]".into(), Some("first-letter".into()))
+ );
+}
+
+#[test]
+fn arbitrary_pseudo_elements() {
+ assert_eq!(
+ parse_one("::text-content"),
+ ("Element[*]".into(), Some("text-content".into()))
+ );
+ assert_eq!(
+ parse_one("::attr(name)"),
+ (
+ "Element[*]".into(),
+ Some("FunctionalPseudoElement[::attr(['name'])]".into())
+ )
+ );
+ assert_eq!(
+ parse_one("::Selection"),
+ ("Element[*]".into(), Some("selection".into()))
+ );
+ assert_eq!(
+ parse_one("foo:after"),
+ ("Element[foo]".into(), Some("after".into()))
+ );
+ assert_eq!(
+ parse_one("foo::selection"),
+ ("Element[foo]".into(), Some("selection".into()))
+ );
+}
+
+#[test]
+fn pseudo_element_at_end_of_chain() {
+ assert_eq!(
+ parse_one("lorem#ipsum ~ a#b.c[href]:empty::selection"),
+ (
+ "CombinedSelector[Hash[Element[lorem]#ipsum] ~ \
+Pseudo[Attrib[Class[Hash[Element[a]#b].c][href]]:empty]]"
+ .into(),
+ Some("selection".into())
+ )
+ );
+}
+
+#[test]
+fn per_selector_in_group() {
+ assert_eq!(
+ parse_pseudo(":scope > div, foo bar"),
+ vec![
+ (
+ "CombinedSelector[Pseudo[Element[*]:scope] > Element[div]]".into(),
+ None
+ ),
+ (
+ "CombinedSelector[Element[foo] <followed> Element[bar]]".into(),
+ None
+ ),
+ ]
+ );
+ assert_eq!(
+ parse_pseudo("foo:before, bar, baz:after"),
+ vec![
+ ("Element[foo]".into(), Some("before".into())),
+ ("Element[bar]".into(), None),
+ ("Element[baz]".into(), Some("after".into())),
+ ]
+ );
+}
+
+#[test]
+fn css21_pseudo_elements_ignored_by_default() {
+ for pseudo in ["after", "before", "first-line", "first-letter"] {
+ let css = alloc_format(pseudo);
+ let selectors = parse(&css).unwrap();
+ assert_eq!(selectors.len(), 1);
+ let sel = &selectors[0];
+ assert_eq!(pe_display(sel.pseudo_element.as_ref().unwrap()), pseudo);
+ assert_eq!(
+ GenericTranslator::new()
+ .selector_to_xpath_with(sel, "", PseudoElements::Ignore)
+ .unwrap(),
+ "e"
+ );
+ }
+}
+
+/// Build `e:<pseudo>`.
+fn alloc_format(pseudo: &str) -> String {
+ let mut s = String::from("e:");
+ s.push_str(pseudo);
+ s
+}
+
+#[test]
+fn pseudo_elements_unsupported_when_translated() {
+ let tr = GenericTranslator::new();
+ let selectors = parse("e::foo").unwrap();
+ let sel = &selectors[0];
+ assert_eq!(pe_display(sel.pseudo_element.as_ref().unwrap()), "foo");
+ assert_eq!(
+ tr.selector_to_xpath_with(sel, "", PseudoElements::Ignore)
+ .unwrap(),
+ "e"
+ );
+ match tr.selector_to_xpath_with(sel, "descendant-or-self::", PseudoElements::Translate) {
+ Err(SelectorError::Expression(_)) => {}
+ other => panic!("expected ExpressionError, got {other:?}"),
+ }
+}
+
+#[test]
+fn unicode_repr_regression() {
+ // The dotted capital I is preserved. ASCII lowercasing leaves it alone.
+ let selectors = parse(":fİrst-child").unwrap();
+ assert_eq!(
+ selectors[0].parsed_tree.repr(),
+ "Pseudo[Element[*]:fİrst-child]"
+ );
+ let scope = parse(":scope").unwrap();
+ assert_eq!(scope[0].parsed_tree.repr(), "Pseudo[Element[*]:scope]");
+}
diff --git a/browser/vendor/cssselect/tests/quoting.rs b/browser/vendor/cssselect/tests/quoting.rs
new file mode 100644
index 000000000..77c0ddc34
--- /dev/null
+++ b/browser/vendor/cssselect/tests/quoting.rs
@@ -0,0 +1,96 @@
+//! XPath string-literal quoting, unicode survival, and unicode escapes.
+
+use cssselect::GenericTranslator;
+
+/// Translate with the default prefix.
+fn xpath(css: &str) -> String {
+ GenericTranslator::new().css_to_xpath(css).unwrap()
+}
+
+#[test]
+fn unicode_class_survives() {
+ let css = ".a\u{c1}b";
+ let result = xpath(css);
+ assert!(result.contains("a\u{c1}b"));
+ // The ASCII transcription uses XML character references for non-ASCII.
+ let ascii = ascii_xmlcharref(&result);
+ assert_eq!(
+ ascii,
+ "descendant-or-self::*[@class and contains(\
+concat(' ', normalize-space(@class), ' '), ' aÁb ')]"
+ );
+}
+
+/// Replace every non-ASCII character with its `&#N;` XML character reference.
+fn ascii_xmlcharref(s: &str) -> String {
+ let mut out = String::new();
+ for c in s.chars() {
+ if c.is_ascii() {
+ out.push(c);
+ } else {
+ out.push_str(&format!("&#{};", c as u32));
+ }
+ }
+ out
+}
+
+#[test]
+fn quote_selection() {
+ assert_eq!(
+ xpath("*[aval=\"'\"]"),
+ "descendant-or-self::*[@aval = \"'\"]"
+ );
+ assert_eq!(
+ xpath("*[aval=\"'''\"]"),
+ "descendant-or-self::*[@aval = \"'''\"]"
+ );
+ assert_eq!(xpath("*[aval='\"']"), "descendant-or-self::*[@aval = '\"']");
+ assert_eq!(
+ xpath("*[aval='\"\"\"']"),
+ "descendant-or-self::*[@aval = '\"\"\"']"
+ );
+ assert_eq!(
+ xpath(":scope > div[dataimg=\"<testmessage>\"]"),
+ "descendant-or-self::*[1]/div[@dataimg = '<testmessage>']"
+ );
+}
+
+#[test]
+fn unicode_escapes() {
+ // \22 is a double quote, \20 is a space.
+ assert_eq!(
+ xpath(r#"*[aval="\'\22\'"]"#),
+ "descendant-or-self::*[@aval = concat(\"'\",'\"',\"'\")]"
+ );
+ assert_eq!(
+ xpath(r#"*[aval="\'\22 2\'"]"#),
+ "descendant-or-self::*[@aval = concat(\"'\",'\"2',\"'\")]"
+ );
+ assert_eq!(
+ xpath(r#"*[aval="\'\20 \'"]"#),
+ "descendant-or-self::*[@aval = \"' '\"]"
+ );
+ assert_eq!(
+ xpath("*[aval=\"'\\20\r\n '\"]"),
+ "descendant-or-self::*[@aval = \"' '\"]"
+ );
+}
+
+/// Translate with an empty prefix.
+fn xpath_bare(css: &str) -> String {
+ GenericTranslator::new()
+ .css_to_xpath_with_prefix(css, "")
+ .unwrap()
+}
+
+#[test]
+fn both_quotes_force_concat() {
+ // A value with both quote kinds builds a concat() through the real
+ // attribute-equals path, not only the helper.
+ assert_eq!(
+ xpath_bare("*[a=\"it's a \\\"q\\\"\"]"),
+ "*[@a = concat('it',\"'\",'s a \"q\"')]"
+ );
+ // The same split feeds :contains().
+ assert_eq!(xpath_bare("*:contains(\"a'b\")"), "*[contains(., \"a'b\")]");
+}
diff --git a/browser/vendor/cssselect/tests/select.rs b/browser/vendor/cssselect/tests/select.rs
new file mode 100644
index 000000000..672ea75aa
--- /dev/null
+++ b/browser/vendor/cssselect/tests/select.rs
@@ -0,0 +1,114 @@
+//! Selection tier: run the generated XPath against a real engine.
+//!
+//! These cases confirm the generated XPath selects the right nodes, not only
+//! that the string matches a golden. They run against the clean XML fixtures,
+//! which a standard XML parser accepts. Build with
+//! `--features xpath-engine-tests` to include this file.
+
+use cssselect::GenericTranslator;
+use sxd_document::parser;
+use sxd_xpath::{Context, Factory, Value};
+
+const OPERATOR_PRECEDENCE: &str = include_str!("fixtures/operator_precedence.xml");
+
+/// A small clean-XML corpus for structural and attribute selection. The engine
+/// here lacks the XPath `lang()` function, so the generic `:lang()` cases live
+/// in the string-parity tests instead.
+const CORPUS: &str = r#"
+<root>
+ <ol id="list" class="a b c">
+ <li id="one">first</li>
+ <li id="two" class="x">second</li>
+ <li id="three" class="x y">third</li>
+ <li id="four"></li>
+ </ol>
+ <p id="para">text</p>
+ <a id="link" href="http://example.org/page" hreflang="en-US">link</a>
+</root>
+"#;
+
+/// Run a CSS selector against an XML fixture and return the matched `id`s in
+/// document order.
+fn select_ids(fixture: &str, selector: &str) -> Vec<String> {
+ let package = parser::parse(fixture).expect("fixture parses as XML");
+ let document = package.as_document();
+ let xpath_str = GenericTranslator::new()
+ .css_to_xpath(selector)
+ .expect("selector translates");
+
+ let factory = Factory::new();
+ let xpath = factory
+ .build(&xpath_str)
+ .expect("xpath compiles")
+ .expect("xpath is not empty");
+ let context = Context::new();
+ let value = xpath
+ .evaluate(&context, document.root())
+ .expect("xpath evaluates");
+
+ let mut ids = Vec::new();
+ if let Value::Nodeset(nodes) = value {
+ for node in nodes.document_order() {
+ if let Some(element) = node.element() {
+ let id = element.attribute_value("id").unwrap_or("nil").to_string();
+ ids.push(id);
+ }
+ }
+ }
+ ids
+}
+
+#[test]
+fn structural_selection() {
+ assert_eq!(select_ids(CORPUS, "li"), ["one", "two", "three", "four"]);
+ assert_eq!(select_ids(CORPUS, "li:first-child"), ["one"]);
+ assert_eq!(select_ids(CORPUS, "li:last-child"), ["four"]);
+ assert_eq!(select_ids(CORPUS, "li:nth-child(2)"), ["two"]);
+ assert_eq!(select_ids(CORPUS, "li:nth-child(odd)"), ["one", "three"]);
+ assert_eq!(select_ids(CORPUS, "li:empty"), ["four"]);
+ assert_eq!(select_ids(CORPUS, "ol > li:nth-of-type(3)"), ["three"]);
+}
+
+#[test]
+fn attribute_and_class_selection() {
+ assert_eq!(select_ids(CORPUS, ".x"), ["two", "three"]);
+ assert_eq!(select_ids(CORPUS, "li.x.y"), ["three"]);
+ assert_eq!(select_ids(CORPUS, "[href]"), ["link"]);
+ assert_eq!(select_ids(CORPUS, "[href^=\"http\"]"), ["link"]);
+ assert_eq!(select_ids(CORPUS, "[href$=\"page\"]"), ["link"]);
+ assert_eq!(select_ids(CORPUS, "[href*=\"example\"]"), ["link"]);
+ assert_eq!(select_ids(CORPUS, "[class~=\"y\"]"), ["three"]);
+ assert_eq!(select_ids(CORPUS, "[hreflang|=\"en\"]"), ["link"]);
+ assert!(select_ids(CORPUS, "[hreflang|=\"e\"]").is_empty());
+ assert!(select_ids(CORPUS, "[href*=\"\"]").is_empty());
+}
+
+#[test]
+fn combinator_selection() {
+ assert_eq!(select_ids(CORPUS, "li + li"), ["two", "three", "four"]);
+ assert_eq!(select_ids(CORPUS, "li ~ li"), ["two", "three", "four"]);
+ assert_eq!(
+ select_ids(CORPUS, "ol > li"),
+ ["one", "two", "three", "four"]
+ );
+ assert_eq!(select_ids(CORPUS, "ol li:not(.x)"), ["one", "four"]);
+ assert_eq!(select_ids(CORPUS, "ol:has(li.y)"), ["list"]);
+ assert_eq!(select_ids(CORPUS, "li:is(#one, #four)"), ["one", "four"]);
+}
+
+#[test]
+fn operator_precedence() {
+ // `:first-or-second` is not a built-in pseudo-class. Use plain selectors
+ // that the engine can evaluate and check the selected ids.
+ assert_eq!(
+ select_with_id_predicate(":has(*)", "a"),
+ Vec::<String>::new()
+ );
+ assert_eq!(select_with_id_predicate("[href]", "a"), ["second", "third"]);
+}
+
+/// Select `tag` elements that match `selector`, returning their ids.
+fn select_with_id_predicate(selector: &str, tag: &str) -> Vec<String> {
+ let combined = format!("{tag}{selector}");
+ select_ids(OPERATOR_PRECEDENCE, &combined)
+}
diff --git a/browser/vendor/cssselect/tests/series.rs b/browser/vendor/cssselect/tests/series.rs
new file mode 100644
index 000000000..f796c3480
--- /dev/null
+++ b/browser/vendor/cssselect/tests/series.rs
@@ -0,0 +1,78 @@
+//! Direct `parse_series` results on `:nth-child` arguments.
+
+use cssselect::{parse, parse_series, Token, TokenType, Tree};
+
+/// Parse `:nth-child(<css>)` and run `parse_series` on its arguments.
+fn series(css: &str) -> Option<(i64, i64)> {
+ let input = alloc_nth(css);
+ let selectors = parse(&input).unwrap();
+ let arguments = match &selectors[0].parsed_tree {
+ Tree::Function { arguments, .. } => arguments.clone(),
+ other => panic!("expected a function tree, got {other:?}"),
+ };
+ parse_series(&arguments).ok()
+}
+
+/// Build `:nth-child(<css>)`.
+fn alloc_nth(css: &str) -> String {
+ let mut s = String::from(":nth-child(");
+ s.push_str(css);
+ s.push(')');
+ s
+}
+
+#[test]
+fn positive_b() {
+ assert_eq!(series("1n+3"), Some((1, 3)));
+ assert_eq!(series("1n +3"), Some((1, 3)));
+ assert_eq!(series("1n + 3"), Some((1, 3)));
+ assert_eq!(series("1n+ 3"), Some((1, 3)));
+}
+
+#[test]
+fn negative_b() {
+ assert_eq!(series("1n-3"), Some((1, -3)));
+ assert_eq!(series("1n -3"), Some((1, -3)));
+ assert_eq!(series("1n - 3"), Some((1, -3)));
+ assert_eq!(series("1n- 3"), Some((1, -3)));
+ assert_eq!(series("n-5"), Some((1, -5)));
+}
+
+#[test]
+fn keywords_and_coefficients() {
+ assert_eq!(series("odd"), Some((2, 1)));
+ assert_eq!(series("even"), Some((2, 0)));
+ assert_eq!(series("3n"), Some((3, 0)));
+ assert_eq!(series("n"), Some((1, 0)));
+ assert_eq!(series("+n"), Some((1, 0)));
+ assert_eq!(series("-n"), Some((-1, 0)));
+ assert_eq!(series("5"), Some((0, 5)));
+}
+
+#[test]
+fn signed_coefficients() {
+ assert_eq!(series("-n-2"), Some((-1, -2)));
+ assert_eq!(series("-2n+4"), Some((-2, 4)));
+ assert_eq!(series("10n-10"), Some((10, -10)));
+ assert_eq!(series("2n-1"), Some((2, -1)));
+ assert_eq!(series("0"), Some((0, 0)));
+ assert_eq!(series("-0"), Some((0, 0)));
+ assert_eq!(series("+5"), Some((0, 5)));
+ assert_eq!(series("-5"), Some((0, -5)));
+ assert_eq!(series("n+0"), Some((1, 0)));
+}
+
+#[test]
+fn invalid() {
+ assert_eq!(series("foo"), None);
+ assert_eq!(series("n+"), None);
+ assert_eq!(series("n-"), None);
+ assert_eq!(series("-n+"), None);
+}
+
+#[test]
+fn string_token_is_rejected() {
+ // A string token anywhere in a series is an error.
+ let tokens = vec![Token::new(TokenType::String, "2", 0)];
+ assert!(parse_series(&tokens).is_err());
+}
diff --git a/browser/vendor/cssselect/tests/specificity.rs b/browser/vendor/cssselect/tests/specificity.rs
new file mode 100644
index 000000000..740e581bf
--- /dev/null
+++ b/browser/vendor/cssselect/tests/specificity.rs
@@ -0,0 +1,69 @@
+//! Specificity triples for a range of selectors.
+
+use cssselect::{parse, Specificity};
+
+/// The specificity of a single-selector input.
+fn specificity(css: &str) -> Specificity {
+ let selectors = parse(css).unwrap();
+ assert_eq!(selectors.len(), 1, "expected one selector for {css:?}");
+ selectors[0].specificity()
+}
+
+#[test]
+fn simple_selectors() {
+ assert_eq!(specificity("*"), (0, 0, 0));
+ assert_eq!(specificity(" foo"), (0, 0, 1));
+ assert_eq!(specificity(":empty "), (0, 1, 0));
+ assert_eq!(specificity(":before"), (0, 0, 1));
+ assert_eq!(specificity("*:before"), (0, 0, 1));
+ assert_eq!(specificity(":nth-child(2)"), (0, 1, 0));
+ assert_eq!(specificity(".bar"), (0, 1, 0));
+ assert_eq!(specificity("[baz]"), (0, 1, 0));
+ assert_eq!(specificity("[baz=\"4\"]"), (0, 1, 0));
+ assert_eq!(specificity("[baz^=\"4\"]"), (0, 1, 0));
+ assert_eq!(specificity("#lipsum"), (1, 0, 0));
+ assert_eq!(specificity("::attr(name)"), (0, 0, 1));
+}
+
+#[test]
+fn negation_passes_through() {
+ assert_eq!(specificity(":not(*)"), (0, 0, 0));
+ assert_eq!(specificity(":not(foo)"), (0, 0, 1));
+ assert_eq!(specificity(":not(.foo)"), (0, 1, 0));
+ assert_eq!(specificity(":not([foo])"), (0, 1, 0));
+ assert_eq!(specificity(":not(:empty)"), (0, 1, 0));
+ assert_eq!(specificity(":not(#foo)"), (1, 0, 0));
+}
+
+#[test]
+fn has_relation() {
+ assert_eq!(specificity(":has(*)"), (0, 0, 0));
+ assert_eq!(specificity(":has(foo)"), (0, 0, 1));
+ assert_eq!(specificity(":has(.foo)"), (0, 1, 0));
+ assert_eq!(specificity(":has(> foo)"), (0, 0, 1));
+}
+
+#[test]
+fn matching_and_where() {
+ assert_eq!(specificity(":is(.foo, #bar)"), (1, 0, 0));
+ assert_eq!(specificity(":is(:hover, :visited)"), (0, 1, 0));
+ assert_eq!(specificity(":where(:hover, :visited)"), (0, 0, 0));
+ assert_eq!(specificity("div:is(.x)"), (0, 1, 1));
+ assert_eq!(specificity("div:where(.x)"), (0, 0, 1));
+}
+
+#[test]
+fn pseudo_element_bump() {
+ assert_eq!(specificity("foo:empty"), (0, 1, 1));
+ assert_eq!(specificity("foo:before"), (0, 0, 2));
+ assert_eq!(specificity("foo::before"), (0, 0, 2));
+ assert_eq!(specificity("foo:empty::before"), (0, 1, 2));
+}
+
+#[test]
+fn combined() {
+ assert_eq!(
+ specificity("#lorem + foo#ipsum:first-child > bar:first-line"),
+ (2, 1, 3)
+ );
+}
diff --git a/browser/vendor/cssselect/tests/tokenizer.rs b/browser/vendor/cssselect/tests/tokenizer.rs
new file mode 100644
index 000000000..25a65c5aa
--- /dev/null
+++ b/browser/vendor/cssselect/tests/tokenizer.rs
@@ -0,0 +1,116 @@
+//! Tokenizer output and escape handling.
+
+use cssselect::{tokenize, SelectorError};
+
+/// Render a token list as their `Display` (Python `repr`) strings.
+fn token_strs(css: &str) -> Vec<String> {
+ tokenize(css)
+ .unwrap()
+ .iter()
+ .map(|t| t.to_string())
+ .collect()
+}
+
+#[test]
+fn rich_case() {
+ // The byte between `f` and `[` is a no-break space U+00A0, not a regular
+ // space. CSS does not treat it as whitespace, so it folds into the ident.
+ let input = "E\\ é > f\u{a0}[a~=\"y\\\"x\"]:nth(/* fu /]* */-3.7)";
+ let tokens = token_strs(input);
+ assert_eq!(
+ tokens,
+ vec![
+ "<IDENT 'E é' at 0>",
+ "<S ' ' at 4>",
+ "<DELIM '>' at 5>",
+ "<S ' ' at 6>",
+ // the no-break space is not whitespace in CSS
+ "<IDENT 'f\u{a0}' at 7>",
+ "<DELIM '[' at 9>",
+ "<IDENT 'a' at 10>",
+ "<DELIM '~' at 11>",
+ "<DELIM '=' at 12>",
+ "<STRING 'y\"x' at 13>",
+ "<DELIM ']' at 19>",
+ "<DELIM ':' at 20>",
+ "<IDENT 'nth' at 21>",
+ "<DELIM '(' at 24>",
+ "<NUMBER '-3.7' at 37>",
+ "<DELIM ')' at 41>",
+ "<EOF at 42>",
+ ]
+ );
+}
+
+#[test]
+fn unclosed_string() {
+ match tokenize("'foo") {
+ Err(SelectorError::Syntax(msg)) => assert_eq!(msg, "Unclosed string at 0"),
+ other => panic!("expected unclosed string error, got {other:?}"),
+ }
+}
+
+#[test]
+fn unicode_escape_over_max() {
+ // A code point above the Unicode maximum clamps to U+FFFD.
+ let tokens = tokenize(r"\110000").unwrap();
+ assert_eq!(tokens[0].value_str(), "\u{FFFD}");
+}
+
+#[test]
+fn negative_ident_vs_number() {
+ // `-foo` is an identifier, `-3` is a number.
+ assert_eq!(tokenize("-foo").unwrap()[0].value_str(), "-foo");
+ assert_eq!(tokenize("-3").unwrap()[0].value_str(), "-3");
+}
+
+#[test]
+fn unterminated_comment_consumes_to_end() {
+ // A `/*` with no close swallows the rest and leaves only EOF.
+ let tokens = tokenize("a /* unterminated").unwrap();
+ assert_eq!(tokens.last().unwrap().to_string(), "<EOF at 17>");
+}
+
+#[test]
+fn surrogate_escape_folds_to_replacement() {
+ // A lone surrogate escape cannot live in a Rust string, so it folds to
+ // U+FFFD, the same value an over-max escape produces.
+ assert_eq!(tokenize(r"\D800").unwrap()[0].value_str(), "\u{FFFD}");
+ assert_eq!(tokenize(r"\DFFF").unwrap()[0].value_str(), "\u{FFFD}");
+ // A zero escape still maps to the null character.
+ assert_eq!(tokenize(r"\0").unwrap()[0].value_str(), "\u{0}");
+}
+
+#[test]
+fn comment_between_idents_is_skipped() {
+ // The comment splits two idents and contributes no token.
+ let tokens = token_strs("a/* c */b");
+ assert_eq!(
+ tokens,
+ vec!["<IDENT 'a' at 0>", "<IDENT 'b' at 8>", "<EOF at 9>"]
+ );
+}
+
+#[test]
+fn line_continuation_in_string_is_removed() {
+ // A backslash before a newline inside a string drops both characters.
+ let value = tokenize("'line\\\na end'").unwrap()[0]
+ .value_str()
+ .to_string();
+ assert_eq!(value, "linea end");
+}
+
+#[test]
+fn hex_escape_in_ident() {
+ // `\41` is the hex escape for 'A'.
+ assert_eq!(tokenize(r"foo\41").unwrap()[0].value_str(), "fooA");
+}
+
+#[test]
+fn leading_dot_and_signed_numbers() {
+ // The number matcher accepts a leading dot and an optional sign.
+ assert_eq!(tokenize("+.5").unwrap()[0].value_str(), "+.5");
+ assert_eq!(tokenize("-.5").unwrap()[0].value_str(), "-.5");
+ assert_eq!(tokenize(".5").unwrap()[0].value_str(), ".5");
+ assert_eq!(tokenize("12.5").unwrap()[0].value_str(), "12.5");
+}
diff --git a/browser/vendor/cssselect/tests/translation.rs b/browser/vendor/cssselect/tests/translation.rs
new file mode 100644
index 000000000..ce71a75c2
--- /dev/null
+++ b/browser/vendor/cssselect/tests/translation.rs
@@ -0,0 +1,374 @@
+//! CSS to XPath translation strings produced by the generic translator.
+//!
+//! Each case asserts the exact XPath string with an empty prefix, pinning the
+//! output character for character.
+
+use cssselect::{GenericTranslator, SelectorError};
+
+/// Translate with an empty prefix.
+fn xpath(css: &str) -> String {
+ GenericTranslator::new()
+ .css_to_xpath_with_prefix(css, "")
+ .unwrap()
+}
+
+/// Translate and expect an expression error.
+fn err(css: &str) {
+ match GenericTranslator::new().css_to_xpath_with_prefix(css, "") {
+ Err(SelectorError::Expression(_)) => {}
+ other => panic!("expected ExpressionError for {css:?}, got {other:?}"),
+ }
+}
+
+/// Translate and return the expression error text.
+fn err_text(css: &str) -> String {
+ match GenericTranslator::new().css_to_xpath_with_prefix(css, "") {
+ Err(SelectorError::Expression(msg)) => msg,
+ other => panic!("expected ExpressionError for {css:?}, got {other:?}"),
+ }
+}
+
+#[test]
+fn elements_and_namespaces() {
+ assert_eq!(xpath("*"), "*");
+ assert_eq!(xpath("e"), "e");
+ assert_eq!(xpath("*|e"), "e");
+ assert_eq!(xpath("e|f"), "e:f");
+}
+
+#[test]
+fn attribute_operators() {
+ assert_eq!(xpath("e[foo]"), "e[@foo]");
+ assert_eq!(xpath("e[foo|bar]"), "e[@foo:bar]");
+ assert_eq!(xpath("e[foo=\"bar\"]"), "e[@foo = 'bar']");
+ assert_eq!(
+ xpath("e[foo~=\"bar\"]"),
+ "e[@foo and contains(concat(' ', normalize-space(@foo), ' '), ' bar ')]"
+ );
+ assert_eq!(
+ xpath("e[foo^=\"bar\"]"),
+ "e[@foo and starts-with(@foo, 'bar')]"
+ );
+ assert_eq!(
+ xpath("e[foo$=\"bar\"]"),
+ "e[@foo and substring(@foo, string-length(@foo)-2) = 'bar']"
+ );
+ assert_eq!(
+ xpath("e[foo*=\"bar\"]"),
+ "e[@foo and contains(@foo, 'bar')]"
+ );
+ assert_eq!(
+ xpath("e[hreflang|=\"en\"]"),
+ "e[@hreflang and (@hreflang = 'en' or starts-with(@hreflang, 'en-'))]"
+ );
+}
+
+#[test]
+fn attribute_different_operator() {
+ assert_eq!(xpath("e[foo!=\"bar\"]"), "e[not(@foo) or @foo != 'bar']");
+ assert_eq!(xpath("e[foo!=\"\"]"), "e[@foo != '']");
+}
+
+#[test]
+fn matching_keeps_the_outer_selector_conjunctive() {
+ assert_eq!(
+ xpath("#root:is(.a, .b)"),
+ "*[(@id = 'root') and ((@class and contains(concat(' ', normalize-space(@class), ' '), ' a ')) or (@class and contains(concat(' ', normalize-space(@class), ' '), ' b ')))]"
+ );
+}
+
+#[test]
+fn nth_child_family() {
+ assert_eq!(
+ xpath("e:nth-child(1)"),
+ "e[count(preceding-sibling::*) = 0]"
+ );
+ assert_eq!(xpath("e:nth-child(n)"), "e");
+ assert_eq!(xpath("e:nth-child(n+1)"), "e");
+ assert_eq!(xpath("e:nth-child(n-10)"), "e");
+ assert_eq!(
+ xpath("e:nth-child(n+2)"),
+ "e[count(preceding-sibling::*) >= 1]"
+ );
+ assert_eq!(xpath("e:nth-child(-n)"), "e[0]");
+ assert_eq!(
+ xpath("e:nth-child(-n+1)"),
+ "e[count(preceding-sibling::*) <= 0]"
+ );
+ assert_eq!(
+ xpath("e:nth-child(3n+2)"),
+ "e[(count(preceding-sibling::*) >= 1) and ((count(preceding-sibling::*) +2) mod 3 = 0)]"
+ );
+ assert_eq!(
+ xpath("e:nth-child(3n-2)"),
+ "e[count(preceding-sibling::*) mod 3 = 0]"
+ );
+ assert_eq!(
+ xpath("e:nth-child(-n+6)"),
+ "e[count(preceding-sibling::*) <= 5]"
+ );
+}
+
+#[test]
+fn nth_child_negative_step() {
+ // A negative `a` keeps its sign in the emitted `mod` and uses a
+ // non-negative offset.
+ assert_eq!(
+ xpath("e:nth-child(-3n+2)"),
+ "e[(count(preceding-sibling::*) <= 1) and ((count(preceding-sibling::*) +2) mod -3 = 0)]"
+ );
+ assert_eq!(
+ xpath("e:nth-child(-2n+4)"),
+ "e[(count(preceding-sibling::*) <= 3) and ((count(preceding-sibling::*) +1) mod -2 = 0)]"
+ );
+ // A negative step with a negative offset can never match.
+ assert_eq!(xpath("e:nth-child(-3n-2)"), "e[0]");
+ assert_eq!(
+ xpath("e:nth-child(10n+5)"),
+ "e[(count(preceding-sibling::*) >= 4) and ((count(preceding-sibling::*) +6) mod 10 = 0)]"
+ );
+ assert_eq!(
+ xpath("e:nth-child(2n-1)"),
+ "e[count(preceding-sibling::*) mod 2 = 0]"
+ );
+}
+
+#[test]
+fn nth_child_minimum_index_does_not_panic() {
+ assert_eq!(xpath("p:nth-child(-9223372036854775808)"), "p[0]");
+}
+
+#[test]
+fn nth_child_minimum_step_does_not_panic() {
+ assert_eq!(
+ xpath("p:nth-child(-9223372036854775808n+1)"),
+ "p[count(preceding-sibling::*) = 0]"
+ );
+}
+
+#[test]
+fn suffix_match_unicode_offset() {
+ // The offset is the code-point length minus one, not the byte length.
+ assert_eq!(
+ xpath("e[foo$=\"é\"]"),
+ "e[@foo and substring(@foo, string-length(@foo)-0) = 'é']"
+ );
+ assert_eq!(
+ xpath("e[foo$=\"ab\"]"),
+ "e[@foo and substring(@foo, string-length(@foo)-1) = 'ab']"
+ );
+ assert_eq!(
+ xpath("e[foo$=\"résumé\"]"),
+ "e[@foo and substring(@foo, string-length(@foo)-5) = 'résumé']"
+ );
+}
+
+#[test]
+fn generic_lang_output() {
+ // The generic translator emits the XPath `lang()` function.
+ assert_eq!(xpath(":lang(fr)"), "*[lang('fr')]");
+ assert_eq!(xpath(":lang(\"en-US\")"), "*[lang('en-US')]");
+}
+
+#[test]
+fn nth_last_child_family() {
+ assert_eq!(
+ xpath("e:nth-last-child(1)"),
+ "e[count(following-sibling::*) = 0]"
+ );
+ assert_eq!(
+ xpath("e:nth-last-child(2n)"),
+ "e[(count(following-sibling::*) +1) mod 2 = 0]"
+ );
+ assert_eq!(
+ xpath("e:nth-last-child(2n+1)"),
+ "e[count(following-sibling::*) mod 2 = 0]"
+ );
+ assert_eq!(
+ xpath("e:nth-last-child(2n+2)"),
+ "e[(count(following-sibling::*) >= 1) and ((count(following-sibling::*) +1) mod 2 = 0)]"
+ );
+ assert_eq!(
+ xpath("e:nth-last-child(3n+1)"),
+ "e[count(following-sibling::*) mod 3 = 0]"
+ );
+ assert_eq!(
+ xpath("e:nth-last-child(-n+2)"),
+ "e[count(following-sibling::*) <= 1]"
+ );
+}
+
+#[test]
+fn nth_of_type() {
+ assert_eq!(
+ xpath("e:nth-of-type(1)"),
+ "e[count(preceding-sibling::e) = 0]"
+ );
+ assert_eq!(
+ xpath("e:nth-last-of-type(1)"),
+ "e[count(following-sibling::e) = 0]"
+ );
+ assert_eq!(
+ xpath("div e:nth-last-of-type(1) .aclass"),
+ "div/descendant-or-self::*/e[count(following-sibling::e) = 0]\
+/descendant-or-self::*/*[@class and contains(\
+concat(' ', normalize-space(@class), ' '), ' aclass ')]"
+ );
+}
+
+#[test]
+fn structural_pseudos() {
+ assert_eq!(xpath("e:first-child"), "e[count(preceding-sibling::*) = 0]");
+ assert_eq!(xpath("e:last-child"), "e[count(following-sibling::*) = 0]");
+ assert_eq!(
+ xpath("e:first-of-type"),
+ "e[count(preceding-sibling::e) = 0]"
+ );
+ assert_eq!(
+ xpath("e:last-of-type"),
+ "e[count(following-sibling::e) = 0]"
+ );
+ assert_eq!(xpath("e:only-child"), "e[count(parent::*/child::*) = 1]");
+ assert_eq!(xpath("e:only-of-type"), "e[count(parent::*/child::e) = 1]");
+ assert_eq!(xpath("e:empty"), "e[not(*) and not(string-length())]");
+ assert_eq!(xpath("e:EmPTY"), "e[not(*) and not(string-length())]");
+ assert_eq!(xpath("e:root"), "e[not(parent::*)]");
+ assert_eq!(xpath("e:hover"), "e[0]");
+}
+
+#[test]
+fn has_relations() {
+ assert_eq!(
+ xpath("div:has(bar.foo)"),
+ "div[descendant::bar[@class and contains(concat(' ', normalize-space(@class), ' '), ' foo ')]]"
+ );
+ assert_eq!(xpath("e:has(> f)"), "e[./f]");
+ assert_eq!(
+ xpath("e:has(> f.foo)"),
+ "e[./f[@class and contains(concat(' ', normalize-space(@class), ' '), ' foo ')]]"
+ );
+ assert_eq!(xpath("e:has(f)"), "e[descendant::f]");
+ assert_eq!(xpath("e:has(~ f)"), "e[following-sibling::f]");
+ assert_eq!(
+ xpath("e:has(~ f.foo)"),
+ "e[following-sibling::f[@class and contains(concat(' ', normalize-space(@class), ' '), ' foo ')]]"
+ );
+ assert_eq!(
+ xpath("e:has(+ f)"),
+ "e[following-sibling::*[(self::f) and (position() = 1)]]"
+ );
+ assert_eq!(
+ xpath("e:has(+ f.foo)"),
+ "e[following-sibling::*[((@class and contains(concat(' ', normalize-space(@class), ' '), ' foo ')) and (self::f)) and (position() = 1)]]"
+ );
+ assert_eq!(
+ xpath("e:has(+ .foo)"),
+ "e[following-sibling::*[(@class and contains(concat(' ', normalize-space(@class), ' '), ' foo ')) and (position() = 1)]]"
+ );
+}
+
+#[test]
+fn contains_class_and_id() {
+ assert_eq!(xpath("e:contains(\"foo\")"), "e[contains(., 'foo')]");
+ assert_eq!(xpath("e:ConTains(foo)"), "e[contains(., 'foo')]");
+ assert_eq!(
+ xpath("e.warning"),
+ "e[@class and contains(concat(' ', normalize-space(@class), ' '), ' warning ')]"
+ );
+ assert_eq!(xpath("e#myid"), "e[@id = 'myid']");
+}
+
+#[test]
+fn negation() {
+ assert_eq!(
+ xpath("e:not(:nth-child(odd))"),
+ "e[not(count(preceding-sibling::*) mod 2 = 0)]"
+ );
+ assert_eq!(xpath("e:nOT(*)"), "e[0]");
+}
+
+#[test]
+fn combinators() {
+ assert_eq!(xpath("e f"), "e/descendant-or-self::*/f");
+ assert_eq!(xpath("e > f"), "e/f");
+ assert_eq!(
+ xpath("e + f"),
+ "e/following-sibling::*[(self::f) and (position() = 1)]"
+ );
+ assert_eq!(xpath("e ~ f"), "e/following-sibling::f");
+ assert_eq!(
+ xpath("e ~ f:nth-child(3)"),
+ "e/following-sibling::f[count(preceding-sibling::*) = 2]"
+ );
+ assert_eq!(
+ xpath("div#container p"),
+ "div[@id = 'container']/descendant-or-self::*/p"
+ );
+}
+
+#[test]
+fn where_matching() {
+ assert_eq!(xpath("e:where(foo)"), "e[self::foo]");
+ assert_eq!(xpath("e:where(foo, bar)"), "e[(self::foo) or (self::bar)]");
+}
+
+#[test]
+fn unsafe_xpath_names() {
+ assert_eq!(xpath(r"di\a0 v"), "*[name() = 'di\u{a0}v']");
+ assert_eq!(xpath(r"di\[v"), "*[name() = 'di[v']");
+ assert_eq!(
+ xpath(r"[h\a0 ref]"),
+ "*[attribute::*[name() = 'h\u{a0}ref']]"
+ );
+ assert_eq!(xpath(r"[h\]ref]"), "*[attribute::*[name() = 'h]ref']]");
+}
+
+#[test]
+fn expression_errors() {
+ err(":fİrst-child");
+ err(":first-of-type");
+ err(":only-of-type");
+ err(":last-of-type");
+ err(":nth-of-type(1)");
+ err(":nth-last-of-type(1)");
+ err(":nth-child(n-)");
+ err(":after");
+ err(":lorem-ipsum");
+ err(":lorem(ipsum)");
+ err("::lorem-ipsum");
+}
+
+#[test]
+fn expression_error_text_echoes_tokens() {
+ // The three expression errors that quote their argument tokens must keep
+ // the token list character for character.
+ assert_eq!(
+ err_text(":nth-child(n-)"),
+ "Invalid series: '[<IDENT 'n-' at 11>]'"
+ );
+ assert_eq!(
+ err_text(":contains(1)"),
+ "Expected a single string or ident for :contains(), got [<NUMBER '1' at 10>]"
+ );
+ assert_eq!(
+ err_text(":lang(1)"),
+ "Expected a single string or ident for :lang(), got [<NUMBER '1' at 6>]"
+ );
+}
+
+#[test]
+fn large_nth_child_coefficient_does_not_panic() {
+ // A coefficient too large for i64 must error, not overflow.
+ match GenericTranslator::new().css_to_xpath("p:nth-child(99999999999999999999n+1)") {
+ Err(SelectorError::Expression(_)) => {}
+ other => panic!("expected an expression error, got {other:?}"),
+ }
+}
+
+#[test]
+fn default_prefix() {
+ assert_eq!(
+ GenericTranslator::new().css_to_xpath("e").unwrap(),
+ "descendant-or-self::e"
+ );
+}
diff --git a/browser/vendor/cssselect/tests/xpath_expr.rs b/browser/vendor/cssselect/tests/xpath_expr.rs
new file mode 100644
index 000000000..005681afd
--- /dev/null
+++ b/browser/vendor/cssselect/tests/xpath_expr.rs
@@ -0,0 +1,87 @@
+//! Direct `XpathExpr` building, `argument_types`, and pseudo-element repr.
+//!
+//! Custom pseudo-element handlers are not part of this crate's public API, so
+//! the cases here cover the building blocks such handlers rely on: `join`,
+//! `add_condition` precedence, and the functional pseudo-element accessors.
+
+use cssselect::{parse, xpath_literal, FunctionalPseudoElement, PseudoElement, XpathExpr};
+
+#[test]
+fn str_form_of_bare_condition() {
+ let expr = XpathExpr::new("", "", "@href");
+ assert_eq!(expr.to_xpath(), "[@href]");
+}
+
+#[test]
+fn add_condition_precedence() {
+ let mut expr = XpathExpr::new("", "*", "@id = 'first' or @id = 'second'");
+ expr.add_condition("@href", "and");
+ assert_eq!(
+ expr.to_xpath(),
+ "*[(@id = 'first' or @id = 'second') and (@href)]"
+ );
+}
+
+#[test]
+fn join_builds_path() {
+ let mut left = XpathExpr::new("", "*", "");
+ let other = XpathExpr::new("@href", "", "");
+ left.join("/", &other);
+ assert_eq!(left.to_xpath(), "*/@href");
+}
+
+#[test]
+fn literal_quoting() {
+ assert_eq!(xpath_literal("plain"), "'plain'");
+ assert_eq!(xpath_literal("it's"), "\"it's\"");
+ assert_eq!(xpath_literal("a'b\"c"), "concat('a',\"'\",'b\"c')");
+}
+
+#[test]
+fn functional_pseudo_element_argument_types() {
+ let cases: [(&str, &[&str]); 4] = [
+ ("", &[]),
+ ("ident", &["IDENT"]),
+ ("\"string\"", &["STRING"]),
+ ("1", &["NUMBER"]),
+ ];
+ for (arg, expected) in cases {
+ let css = build_pe(arg);
+ let selectors = parse(&css).unwrap();
+ let pe = selectors[0].pseudo_element.as_ref().unwrap();
+ let f = match pe {
+ PseudoElement::Functional(f) => f,
+ other => panic!("expected functional pseudo-element, got {other:?}"),
+ };
+ assert_eq!(f.argument_types(), expected.to_vec(), "for arg {arg:?}");
+ }
+}
+
+/// Build `::pseudo_element(<arg>)`.
+fn build_pe(arg: &str) -> String {
+ let mut s = String::from("::pseudo_element(");
+ s.push_str(arg);
+ s.push(')');
+ s
+}
+
+#[test]
+fn functional_pseudo_element_canonical() {
+ let f = FunctionalPseudoElement::new("ATTR", parse("::x(name)").unwrap()[0].pseudo_args());
+ assert_eq!(f.name, "attr");
+ assert_eq!(f.canonical(), "attr(name)");
+}
+
+/// Helper to expose a parsed functional pseudo-element's arguments.
+trait PseudoArgs {
+ fn pseudo_args(&self) -> Vec<cssselect::Token>;
+}
+
+impl PseudoArgs for cssselect::Selector {
+ fn pseudo_args(&self) -> Vec<cssselect::Token> {
+ match &self.pseudo_element {
+ Some(PseudoElement::Functional(f)) => f.arguments.clone(),
+ _ => Vec::new(),
+ }
+ }
+}
diff --git a/browser/vendor/curl_impersonate_sys/.gitignore b/browser/vendor/curl_impersonate_sys/.gitignore
new file mode 100644
index 000000000..a3f9dd866
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/.gitignore
@@ -0,0 +1,3 @@
+/artifacts/
+/target/
+/Cargo.lock
diff --git a/browser/vendor/curl_impersonate_sys/Cargo.toml b/browser/vendor/curl_impersonate_sys/Cargo.toml
new file mode 100644
index 000000000..297ffd677
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "curl_impersonate_sys"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+links = "curl-impersonate"
+build = "build.rs"
+publish = false
+
+[features]
+default = []
+certified = []
+
diff --git a/browser/vendor/curl_impersonate_sys/README.md b/browser/vendor/curl_impersonate_sys/README.md
new file mode 100644
index 000000000..f3ee5e8e1
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/README.md
@@ -0,0 +1,74 @@
+# curl_impersonate_sys
+
+Repository-owned, minimal raw Rust bindings for the native engine frozen by
+curl-cffi 0.16.0. The browser worker links it only when its
+`scrapling-compat` feature is explicitly enabled; normal safe builds retain
+the artifact-free reqwest engine.
+
+## Frozen upstream
+
+- curl-cffi [`v0.16.0`](https://github.com/lexiforest/curl_cffi/releases/tag/v0.16.0)
+ says its packaged engine is curl 8.21 with curl-impersonate 2.0.
+- Its tagged
+ [`Makefile`](https://github.com/lexiforest/curl_cffi/blob/v0.16.0/Makefile)
+ pins `VERSION := 2.0.0` and `CURL_VERSION := curl-8_21_0`.
+- curl-impersonate [`v2.0.0`](https://github.com/lexiforest/curl-impersonate/releases/tag/v2.0.0)
+ publishes official `libcurl-impersonate` GNU/Linux archives for both Tier-1
+ architectures. The release states that curl was updated to 8.21.0.
+- The easy-handle surface follows curl's official
+ [libcurl easy interface](https://curl.se/libcurl/c/libcurl-easy.html). The
+ extra `curl_easy_impersonate` declaration comes from the v2.0.0 patched
+ `include/curl/easy.h` shipped in each verified archive.
+
+`artifacts.manifest` records the immutable GitHub release asset URLs, byte
+lengths, and GitHub-published SHA-256 digests:
+
+| Rust target | Bytes | SHA-256 |
+| --- | ---: | --- |
+| `x86_64-unknown-linux-gnu` | 26,572,973 | `d8a98bc123fae4f04bb6a7584ff486333a334b3b08edaba1867929ae8d6ebb4d` |
+| `aarch64-unknown-linux-gnu` | 25,595,976 | `12708019a6c1c3a7a7a40a8a379d12aaca127fcd13bda60b06fdb0e013f6433f` |
+
+The archives contain a monolithic `libcurl-impersonate.a`, the matching curl
+headers, and shared-library variants. They therefore provide the frozen
+BoringSSL/nghttp2/ngtcp2/nghttp3-enabled build instead of relying on ambient
+system curl packages.
+
+## Artifact workflow
+
+Normal safe builds need no native artifact and do not link libcurl:
+
+```sh
+cargo test --manifest-path vendor/curl_impersonate_sys/Cargo.toml
+```
+
+Artifact acquisition is explicit and separate from Cargo:
+
+```sh
+scripts/fetch_curl_impersonate_artifacts.sh x86_64-unknown-linux-gnu
+scripts/fetch_curl_impersonate_artifacts.sh --verify x86_64-unknown-linux-gnu
+```
+
+Set `CURL_IMPERSONATE_ARTIFACT_DIR` to use a shared CI/release cache. Its
+layout is `<cache>/<target>/<archive>` plus `<cache>/<target>/root/`.
+
+A certified build never downloads. `build.rs` requires a supported Tier-1
+target, checks the archive byte length and SHA-256 again, checks the extracted
+static library/header, then links the static archive. Missing, corrupt, or
+unsupported inputs fail the build:
+
+```sh
+cargo test --manifest-path vendor/curl_impersonate_sys/Cargo.toml \
+ --features certified
+```
+
+The FFI is deliberately raw and small: global/easy lifecycle, option/info
+varargs, list headers, impersonation, transfer callbacks, and the socket-open
+callback used by the safe-mode egress gate. Higher-level request, ownership,
+callback-unwind, and session policy belong in the integrating crate.
+
+## Licensing
+
+The bindings are MIT licensed. curl-impersonate's upstream MIT license is
+included as `UPSTREAM_LICENSE`. Release artifacts also aggregate curl and its
+native dependencies; a binary redistribution must preserve all notices from
+the corresponding upstream source release.
diff --git a/browser/vendor/curl_impersonate_sys/UPSTREAM_LICENSE b/browser/vendor/curl_impersonate_sys/UPSTREAM_LICENSE
new file mode 100644
index 000000000..7475f58f6
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/UPSTREAM_LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 curl_cffi developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/browser/vendor/curl_impersonate_sys/artifacts.manifest b/browser/vendor/curl_impersonate_sys/artifacts.manifest
new file mode 100644
index 000000000..8f820fab5
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/artifacts.manifest
@@ -0,0 +1,3 @@
+# target|archive|bytes|sha256|official_url
+x86_64-unknown-linux-gnu|libcurl-impersonate-v2.0.0.x86_64-linux-gnu.tar.gz|26572973|d8a98bc123fae4f04bb6a7584ff486333a334b3b08edaba1867929ae8d6ebb4d|https://github.com/lexiforest/curl-impersonate/releases/download/v2.0.0/libcurl-impersonate-v2.0.0.x86_64-linux-gnu.tar.gz
+aarch64-unknown-linux-gnu|libcurl-impersonate-v2.0.0.aarch64-linux-gnu.tar.gz|25595976|12708019a6c1c3a7a7a40a8a379d12aaca127fcd13bda60b06fdb0e013f6433f|https://github.com/lexiforest/curl-impersonate/releases/download/v2.0.0/libcurl-impersonate-v2.0.0.aarch64-linux-gnu.tar.gz
diff --git a/browser/vendor/curl_impersonate_sys/build.rs b/browser/vendor/curl_impersonate_sys/build.rs
new file mode 100644
index 000000000..14c7f92ae
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/build.rs
@@ -0,0 +1,168 @@
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+const UNWINDER_SYMBOLS: &[&str] = &[
+ "_Unwind_DeleteException",
+ "_Unwind_ForcedUnwind",
+ "_Unwind_GetGR",
+ "_Unwind_GetIP",
+ "_Unwind_GetLanguageSpecificData",
+ "_Unwind_GetRegionStart",
+ "_Unwind_RaiseException",
+ "_Unwind_Resume",
+ "_Unwind_SetGR",
+ "_Unwind_SetIP",
+ "__unw_add_dynamic_eh_frame_section",
+ "__unw_add_dynamic_fde",
+ "__unw_get_fpreg",
+ "__unw_get_proc_info",
+ "__unw_get_proc_name",
+ "__unw_get_reg",
+ "__unw_getcontext",
+ "__unw_init_local",
+ "__unw_is_fpreg",
+ "__unw_is_signal_frame",
+ "__unw_iterate_dwarf_unwind_cache",
+ "__unw_regname",
+ "__unw_remove_dynamic_eh_frame_section",
+ "__unw_remove_dynamic_fde",
+ "__unw_resume",
+ "__unw_set_fpreg",
+ "__unw_set_reg",
+ "__unw_step",
+ "__unw_step_stage2",
+];
+
+#[derive(Debug)]
+struct Artifact<'a> {
+ target: &'a str,
+ archive: &'a str,
+ bytes: u64,
+ sha256: &'a str,
+}
+
+fn artifact_for_target<'a>(manifest: &'a str, target: &str) -> Option<Artifact<'a>> {
+ manifest
+ .lines()
+ .filter(|line| !line.is_empty() && !line.starts_with('#'))
+ .find_map(|line| {
+ let mut fields = line.split('|');
+ let artifact = Artifact {
+ target: fields.next()?,
+ archive: fields.next()?,
+ bytes: fields.next()?.parse().ok()?,
+ sha256: fields.next()?,
+ };
+ (artifact.target == target).then_some(artifact)
+ })
+}
+
+fn sha256(path: &Path) -> Result<String, String> {
+ let output = Command::new("sha256sum")
+ .arg(path)
+ .output()
+ .map_err(|error| format!("cannot run sha256sum: {error}"))?;
+ if !output.status.success() {
+ return Err(format!(
+ "sha256sum failed for {}: {}",
+ path.display(),
+ String::from_utf8_lossy(&output.stderr).trim()
+ ));
+ }
+ String::from_utf8(output.stdout)
+ .map_err(|error| format!("sha256sum returned non-UTF-8 output: {error}"))?
+ .split_whitespace()
+ .next()
+ .map(str::to_owned)
+ .ok_or_else(|| "sha256sum returned empty output".to_string())
+}
+
+fn certified_artifact_dir(manifest_dir: &Path, target: &str) -> PathBuf {
+ env::var_os("CURL_IMPERSONATE_ARTIFACT_DIR")
+ .map(PathBuf::from)
+ .unwrap_or_else(|| manifest_dir.join("artifacts"))
+ .join(target)
+}
+
+fn main() {
+ println!("cargo:rustc-check-cfg=cfg(curl_impersonate_linked)");
+ println!("cargo:rerun-if-changed=artifacts.manifest");
+ println!("cargo:rerun-if-env-changed=CURL_IMPERSONATE_ARTIFACT_DIR");
+
+ // Safe/default builds compile the bindings and their tests without a
+ // native artifact. Certified compat builds explicitly opt into linking.
+ if env::var_os("CARGO_FEATURE_CERTIFIED").is_none() {
+ return;
+ }
+
+ let target = env::var("TARGET").expect("Cargo always sets TARGET");
+ let manifest = include_str!("artifacts.manifest");
+ let artifact = artifact_for_target(manifest, &target).unwrap_or_else(|| {
+ panic!(
+ "curl-impersonate certified mode is unsupported for target {target}; \
+ supported targets are x86_64-unknown-linux-gnu and aarch64-unknown-linux-gnu"
+ )
+ });
+ let manifest_dir = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
+ let artifact_dir = certified_artifact_dir(&manifest_dir, &target);
+ let archive = artifact_dir.join(artifact.archive);
+ let root = artifact_dir.join("root");
+ let library = root.join("libcurl-impersonate.a");
+ let header = root.join("include/curl/curl.h");
+
+ let metadata = fs::metadata(&archive).unwrap_or_else(|_| {
+ panic!(
+ "certified curl-impersonate artifact is absent: {}; run scripts/fetch_curl_impersonate_artifacts.sh {target}",
+ archive.display()
+ )
+ });
+ assert_eq!(
+ metadata.len(),
+ artifact.bytes,
+ "certified curl-impersonate artifact has wrong byte length: {}",
+ archive.display()
+ );
+ let actual = sha256(&archive).unwrap_or_else(|error| panic!("{error}"));
+ assert_eq!(
+ actual,
+ artifact.sha256,
+ "certified curl-impersonate artifact checksum mismatch: {}",
+ archive.display()
+ );
+ assert!(
+ library.is_file() && header.is_file(),
+ "certified artifact was verified but not extracted under {}; run the artifact fetch script",
+ root.display()
+ );
+
+ // The official monolithic static archive includes LLVM libunwind. Leaving
+ // those symbols global replaces Rust's process unwinder and makes error
+ // backtraces segfault. Keep curl's internal references local while letting
+ // the binary use its normal libgcc unwinder.
+ let link_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap()).join("native");
+ fs::create_dir_all(&link_dir).expect("create native link directory");
+ let sanitized = link_dir.join("libcurl-impersonate.a");
+ fs::copy(&library, &sanitized).expect("copy verified curl archive");
+ let mut objcopy = Command::new("objcopy");
+ for symbol in UNWINDER_SYMBOLS {
+ objcopy.arg(format!("--localize-symbol={symbol}"));
+ }
+ let output = objcopy
+ .arg(&sanitized)
+ .output()
+ .expect("certified builds require GNU objcopy");
+ assert!(
+ output.status.success(),
+ "objcopy failed to isolate curl's bundled unwinder: {}",
+ String::from_utf8_lossy(&output.stderr).trim()
+ );
+
+ println!("cargo:rustc-link-search=native={}", link_dir.display());
+ println!("cargo:rustc-link-lib=static=curl-impersonate");
+ println!("cargo:rustc-link-lib=pthread");
+ println!("cargo:rustc-link-lib=dl");
+ println!("cargo:rustc-link-lib=m");
+ println!("cargo:rustc-cfg=curl_impersonate_linked");
+}
diff --git a/browser/vendor/curl_impersonate_sys/src/lib.rs b/browser/vendor/curl_impersonate_sys/src/lib.rs
new file mode 100644
index 000000000..2c87d5dcf
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/src/lib.rs
@@ -0,0 +1,202 @@
+//! Minimal raw bindings for the frozen curl-cffi 0.16.0 native engine.
+//!
+//! The crate does not download at build time. Enable `certified` only after
+//! populating the verified Tier-1 artifact cache described in the README.
+
+#![allow(non_camel_case_types)]
+
+use std::ffi::{c_char, c_int, c_long, c_uint, c_void};
+
+pub const CURL_CFFI_VERSION: &str = "0.16.0";
+pub const CURL_IMPERSONATE_VERSION: &str = "2.0.0";
+pub const LIBCURL_VERSION: &str = "8.21.0-IMPERSONATE";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Artifact<'a> {
+ pub target: &'a str,
+ pub archive: &'a str,
+ pub bytes: u64,
+ pub sha256: &'a str,
+ pub url: &'a str,
+}
+
+pub fn artifact_for_target(target: &str) -> Option<Artifact<'static>> {
+ include_str!("../artifacts.manifest")
+ .lines()
+ .filter(|line| !line.is_empty() && !line.starts_with('#'))
+ .find_map(|line| {
+ let mut fields = line.split('|');
+ let artifact = Artifact {
+ target: fields.next()?,
+ archive: fields.next()?,
+ bytes: fields.next()?.parse().ok()?,
+ sha256: fields.next()?,
+ url: fields.next()?,
+ };
+ (artifact.target == target).then_some(artifact)
+ })
+}
+
+pub type CURL = c_void;
+pub type CURLcode = c_uint;
+pub type CURLoption = c_uint;
+pub type CURLINFO = c_uint;
+pub type curl_socket_t = c_int;
+pub type curl_off_t = i64;
+
+#[repr(C)]
+pub struct curl_slist {
+ pub data: *mut c_char,
+ pub next: *mut curl_slist,
+}
+
+#[repr(C)]
+pub struct curl_sockaddr {
+ pub family: c_int,
+ pub socktype: c_int,
+ pub protocol: c_int,
+ pub addrlen: c_uint,
+ pub addr: sockaddr,
+}
+
+// Linux `struct sockaddr`; `curl_sockaddr.addrlen` says how many bytes are
+// valid when a callback views `addr` as sockaddr_in/sockaddr_in6.
+#[repr(C)]
+pub struct sockaddr {
+ pub sa_family: u16,
+ pub sa_data: [u8; 14],
+}
+
+pub type curl_write_callback =
+ Option<unsafe extern "C" fn(*mut c_char, usize, usize, *mut c_void) -> usize>;
+pub type curl_read_callback =
+ Option<unsafe extern "C" fn(*mut c_char, usize, usize, *mut c_void) -> usize>;
+pub type curl_opensocket_callback =
+ Option<unsafe extern "C" fn(*mut c_void, c_int, *mut curl_sockaddr) -> curl_socket_t>;
+
+pub const CURLE_OK: CURLcode = 0;
+pub const CURL_GLOBAL_SSL: c_long = 1;
+pub const CURL_GLOBAL_WIN32: c_long = 2;
+pub const CURL_GLOBAL_DEFAULT: c_long = CURL_GLOBAL_SSL | CURL_GLOBAL_WIN32;
+pub const CURL_SOCKET_BAD: curl_socket_t = -1;
+pub const CURLAUTH_BASIC: c_long = 1;
+pub const CURL_HTTP_VERSION_3ONLY: c_long = 31;
+pub const CURLFOLLOW_SAFE: c_long = 4;
+
+pub const CURLOPT_WRITEDATA: CURLoption = 10_001;
+pub const CURLOPT_URL: CURLoption = 10_002;
+pub const CURLOPT_PROXY: CURLoption = 10_004;
+pub const CURLOPT_USERPWD: CURLoption = 10_005;
+pub const CURLOPT_PROXYUSERPWD: CURLoption = 10_006;
+pub const CURLOPT_READDATA: CURLoption = 10_009;
+pub const CURLOPT_ERRORBUFFER: CURLoption = 10_010;
+pub const CURLOPT_WRITEFUNCTION: CURLoption = 20_011;
+pub const CURLOPT_READFUNCTION: CURLoption = 20_012;
+pub const CURLOPT_TIMEOUT: CURLoption = 13;
+pub const CURLOPT_POSTFIELDS: CURLoption = 10_015;
+pub const CURLOPT_REFERER: CURLoption = 10_016;
+pub const CURLOPT_USERAGENT: CURLoption = 10_018;
+pub const CURLOPT_COOKIE: CURLoption = 10_022;
+pub const CURLOPT_HTTPHEADER: CURLoption = 10_023;
+pub const CURLOPT_HEADERDATA: CURLoption = 10_029;
+pub const CURLOPT_COOKIEFILE: CURLoption = 10_031;
+pub const CURLOPT_CUSTOMREQUEST: CURLoption = 10_036;
+pub const CURLOPT_NOBODY: CURLoption = 44;
+pub const CURLOPT_POST: CURLoption = 47;
+pub const CURLOPT_FOLLOWLOCATION: CURLoption = 52;
+pub const CURLOPT_POSTFIELDSIZE: CURLoption = 60;
+pub const CURLOPT_SSL_VERIFYPEER: CURLoption = 64;
+pub const CURLOPT_MAXREDIRS: CURLoption = 68;
+pub const CURLOPT_CONNECTTIMEOUT: CURLoption = 78;
+pub const CURLOPT_HEADERFUNCTION: CURLoption = 20_079;
+pub const CURLOPT_HTTPGET: CURLoption = 80;
+pub const CURLOPT_SSL_VERIFYHOST: CURLoption = 81;
+pub const CURLOPT_COOKIEJAR: CURLoption = 10_082;
+pub const CURLOPT_HTTP_VERSION: CURLoption = 84;
+pub const CURLOPT_NOSIGNAL: CURLoption = 99;
+pub const CURLOPT_ACCEPT_ENCODING: CURLoption = 10_102;
+pub const CURLOPT_PRIVATE: CURLoption = 10_103;
+pub const CURLOPT_HTTPAUTH: CURLoption = 107;
+pub const CURLOPT_PROXYAUTH: CURLoption = 111;
+pub const CURLOPT_COOKIELIST: CURLoption = 10_135;
+pub const CURLOPT_TIMEOUT_MS: CURLoption = 155;
+pub const CURLOPT_CONNECTTIMEOUT_MS: CURLoption = 156;
+pub const CURLOPT_OPENSOCKETFUNCTION: CURLoption = 20_163;
+pub const CURLOPT_OPENSOCKETDATA: CURLoption = 10_164;
+
+pub const CURLINFO_EFFECTIVE_URL: CURLINFO = 0x10_0001;
+pub const CURLINFO_RESPONSE_CODE: CURLINFO = 0x20_0002;
+pub const CURLINFO_TOTAL_TIME: CURLINFO = 0x30_0003;
+pub const CURLINFO_CONTENT_TYPE: CURLINFO = 0x10_0012;
+pub const CURLINFO_REDIRECT_COUNT: CURLINFO = 0x20_0014;
+pub const CURLINFO_REDIRECT_URL: CURLINFO = 0x10_001f;
+/// curl-cffi's patched libcurl reports accepted cookie mutations here.
+pub const CURLINFO_COOKIECHANGES: CURLINFO = 0x40_03e8;
+
+#[cfg(curl_impersonate_linked)]
+extern "C" {
+ pub fn curl_global_init(flags: c_long) -> CURLcode;
+ pub fn curl_global_cleanup();
+ pub fn curl_version() -> *const c_char;
+ pub fn curl_easy_init() -> *mut CURL;
+ pub fn curl_easy_duphandle(curl: *mut CURL) -> *mut CURL;
+ pub fn curl_easy_cleanup(curl: *mut CURL);
+ pub fn curl_easy_reset(curl: *mut CURL);
+ pub fn curl_easy_perform(curl: *mut CURL) -> CURLcode;
+ pub fn curl_easy_setopt(curl: *mut CURL, option: CURLoption, ...) -> CURLcode;
+ pub fn curl_easy_getinfo(curl: *mut CURL, info: CURLINFO, ...) -> CURLcode;
+ pub fn curl_easy_strerror(code: CURLcode) -> *const c_char;
+ pub fn curl_easy_impersonate(
+ curl: *mut CURL,
+ target: *const c_char,
+ default_headers: c_int,
+ ) -> CURLcode;
+ pub fn curl_slist_append(list: *mut curl_slist, value: *const c_char) -> *mut curl_slist;
+ pub fn curl_slist_free_all(list: *mut curl_slist);
+}
+
+#[cfg(all(test, feature = "certified", curl_impersonate_linked))]
+mod linked_tests {
+ use super::*;
+ use std::ffi::{CStr, CString};
+
+ #[test]
+ fn linked_archive_reports_the_frozen_libcurl() {
+ let version = unsafe { CStr::from_ptr(curl_version()) }.to_str().unwrap();
+ assert!(
+ version.starts_with("libcurl/8.21.0-IMPERSONATE "),
+ "{version}"
+ );
+ for component in [
+ "BoringSSL",
+ "nghttp2/1.63.0",
+ "ngtcp2/1.20.0",
+ "nghttp3/1.15.0",
+ ] {
+ assert!(
+ version.contains(component),
+ "missing {component}: {version}"
+ );
+ }
+ }
+
+ #[test]
+ fn linked_archive_exports_easy_impersonation() {
+ unsafe {
+ assert_eq!(curl_global_init(CURL_GLOBAL_DEFAULT), CURLE_OK);
+ let easy = curl_easy_init();
+ assert!(!easy.is_null());
+ let target = CString::new("chrome136").unwrap();
+ let result = curl_easy_impersonate(easy, target.as_ptr(), 1);
+ curl_easy_cleanup(easy);
+ curl_global_cleanup();
+ assert_eq!(result, CURLE_OK);
+ }
+ }
+
+ #[test]
+ fn linked_archive_does_not_replace_the_process_unwinder() {
+ let trace = std::backtrace::Backtrace::force_capture().to_string();
+ assert!(!trace.is_empty());
+ }
+}
diff --git a/browser/vendor/curl_impersonate_sys/tests/manifest.rs b/browser/vendor/curl_impersonate_sys/tests/manifest.rs
new file mode 100644
index 000000000..16fdf55a2
--- /dev/null
+++ b/browser/vendor/curl_impersonate_sys/tests/manifest.rs
@@ -0,0 +1,34 @@
+use curl_impersonate_sys::{artifact_for_target, CURL_CFFI_VERSION, CURL_IMPERSONATE_VERSION};
+
+#[test]
+fn frozen_engine_and_tier_one_artifacts_are_exact() {
+ assert_eq!(CURL_CFFI_VERSION, "0.16.0");
+ assert_eq!(CURL_IMPERSONATE_VERSION, "2.0.0");
+
+ let x86 = artifact_for_target("x86_64-unknown-linux-gnu").unwrap();
+ assert_eq!(x86.bytes, 26_572_973);
+ assert_eq!(
+ x86.sha256,
+ "d8a98bc123fae4f04bb6a7584ff486333a334b3b08edaba1867929ae8d6ebb4d"
+ );
+
+ let arm = artifact_for_target("aarch64-unknown-linux-gnu").unwrap();
+ assert_eq!(arm.bytes, 25_595_976);
+ assert_eq!(
+ arm.sha256,
+ "12708019a6c1c3a7a7a40a8a379d12aaca127fcd13bda60b06fdb0e013f6433f"
+ );
+
+ assert!(artifact_for_target("x86_64-unknown-linux-musl").is_none());
+}
+
+#[test]
+fn ffi_constants_match_the_frozen_header() {
+ use curl_impersonate_sys::*;
+
+ assert_eq!(CURLOPT_URL, 10_002);
+ assert_eq!(CURLOPT_WRITEFUNCTION, 20_011);
+ assert_eq!(CURLOPT_FOLLOWLOCATION, 52);
+ assert_eq!(CURLINFO_RESPONSE_CODE, 0x20_0002);
+ assert_eq!(CURL_GLOBAL_DEFAULT, 3);
+}
diff --git a/browser/vendor/markdownify-1.2.3-beautifulsoup-4.15.0.NOTICE b/browser/vendor/markdownify-1.2.3-beautifulsoup-4.15.0.NOTICE
new file mode 100644
index 000000000..1708bb570
--- /dev/null
+++ b/browser/vendor/markdownify-1.2.3-beautifulsoup-4.15.0.NOTICE
@@ -0,0 +1,59 @@
+The compatibility implementation in src/scrapling/markdown.rs is derived from
+markdownify 1.2.3 and reproduces the observable tree behavior of Beautiful
+Soup 4.15.0's html.parser builder.
+
+Frozen source hashes:
+
+- markdownify/__init__.py: 281bca0e2ab84a21825376f82d07d95455f41a6b0392bf95950bf29aac540b40
+- bs4/__init__.py: 90e007f82a9fc5bcf22a8df3b395b7bc5245e54d65cd68fd51ca12a414718d4e
+
+markdownify license
+-------------------
+
+The MIT License (MIT)
+
+Copyright 2012-2018 Matthew Tretter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Beautiful Soup license
+----------------------
+
+Copyright (c) Leonard Richardson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Beautiful Soup incorporates html5lib code, also under the MIT license,
+Copyright (c) James Graham and other contributors.
diff --git a/browser/vendor/rustpython-sre_engine/Cargo.lock b/browser/vendor/rustpython-sre_engine/Cargo.lock
new file mode 100644
index 000000000..17984f680
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/Cargo.lock
@@ -0,0 +1,328 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "ascii"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"
+
+[[package]]
+name = "bitflags"
+version = "2.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+
+[[package]]
+name = "bstr"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f"
+dependencies = [
+ "memchr",
+ "regex-automata",
+ "serde_core",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "either"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "num_enum"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "optional"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978aa494585d3ca4ad74929863093e87cac9790d81fe7aba2b3dc2890643a0fc"
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+
+[[package]]
+name = "rustpython-sre_engine"
+version = "0.5.0"
+dependencies = [
+ "bitflags",
+ "num_enum",
+ "optional",
+ "rustpython-wtf8",
+ "unicode-ident",
+ "unicode_names2",
+]
+
+[[package]]
+name = "rustpython-wtf8"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ada88d2f69ff5516d69e0f3294e9db2ff8ee71a15291b8f3f8584f07ad1ca28d"
+dependencies = [
+ "ascii",
+ "bstr",
+ "itertools",
+ "memchr",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "siphasher"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode_names2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d189085656ca1203291e965444e7f6a2723fbdd1dd9f34f8482e79bafd8338a0"
+dependencies = [
+ "phf",
+ "unicode_names2_generator",
+]
+
+[[package]]
+name = "unicode_names2_generator"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1262662dc96937c71115228ce2e1d30f41db71a7a45d3459e98783ef94052214"
+dependencies = [
+ "phf_codegen",
+ "rand",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
diff --git a/browser/vendor/rustpython-sre_engine/Cargo.toml b/browser/vendor/rustpython-sre_engine/Cargo.toml
new file mode 100644
index 000000000..c598db0a1
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "rustpython-sre_engine"
+version = "0.5.0"
+edition = "2024"
+rust-version = "1.93"
+license = "MIT"
+repository = "https://github.com/RustPython/RustPython"
+description = "Repository-owned Scrapling compatibility fork of RustPython's SRE engine"
+
+[dependencies]
+bitflags = "2.11"
+num_enum = { version = "0.7", default-features = false }
+optional = "0.5"
+rustpython-wtf8 = "0.5.0"
+unicode-ident = "1"
+unicode_names2 = "2"
diff --git a/browser/vendor/rustpython-sre_engine/Cargo.toml.orig b/browser/vendor/rustpython-sre_engine/Cargo.toml.orig
new file mode 100644
index 000000000..4f899e6b3
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/Cargo.toml.orig
@@ -0,0 +1,27 @@
+[package]
+name = "rustpython-sre_engine"
+authors = ["Kangzhi Shi <shikangzhi@gmail.com>", "RustPython Team"]
+description = "A low-level implementation of Python's SRE regex engine"
+keywords = ["regex"]
+include = ["LICENSE", "src/**/*.rs"]
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[[bench]]
+name = "benches"
+harness = false
+
+[dependencies]
+rustpython-wtf8 = { workspace = true }
+num_enum = { workspace = true }
+bitflags = { workspace = true }
+optional = { workspace = true }
+
+[dev-dependencies]
+criterion = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/browser/vendor/rustpython-sre_engine/LICENSE b/browser/vendor/rustpython-sre_engine/LICENSE
new file mode 100644
index 000000000..e2aa2ed95
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RustPython Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/browser/vendor/rustpython-sre_engine/README.md b/browser/vendor/rustpython-sre_engine/README.md
new file mode 100644
index 000000000..e09f7bfc6
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/README.md
@@ -0,0 +1,8 @@
+# rustpython-sre_engine compatibility fork
+
+Forked from `rustpython-sre_engine` 0.5.0 for the browser worker's frozen
+CPython 3.12 regular-expression contract. Upstream source is MIT licensed;
+see `LICENSE`.
+
+The local `compiler` module is the worker-owned Rust port of the matching
+parts of CPython 3.12's `Lib/re/_parser.py` and `Lib/re/_compiler.py`.
diff --git a/browser/vendor/rustpython-sre_engine/examples/differential_driver.rs b/browser/vendor/rustpython-sre_engine/examples/differential_driver.rs
new file mode 100644
index 000000000..11bf4b5ff
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/examples/differential_driver.rs
@@ -0,0 +1,89 @@
+use std::io::{self, BufRead, Write};
+
+use rustpython_sre_engine::compiler;
+use rustpython_sre_engine::{Request, SearchIter, State, StrDrive};
+
+fn decode_hex(value: &str) -> Result<String, String> {
+ if !value.len().is_multiple_of(2) {
+ return Err("odd hex input".to_string());
+ }
+ let bytes = (0..value.len())
+ .step_by(2)
+ .map(|index| u8::from_str_radix(&value[index..index + 2], 16))
+ .collect::<Result<Vec<_>, _>>()
+ .map_err(|error| error.to_string())?;
+ String::from_utf8(bytes).map_err(|error| error.to_string())
+}
+
+fn encode_hex(value: &str) -> String {
+ value
+ .as_bytes()
+ .iter()
+ .map(|byte| format!("{byte:02x}"))
+ .collect()
+}
+
+fn findall(pattern: &str, text: &str, ignore_case: bool) -> Result<Vec<Vec<String>>, String> {
+ let compiled = compiler::compile(pattern, ignore_case).map_err(|error| error.to_string())?;
+ let req = Request::new(text, 0, text.count(), &compiled.codes, false);
+ let mut iter = SearchIter {
+ req,
+ state: State::default(),
+ };
+ let chars: Vec<char> = text.chars().collect();
+ let mut matches = Vec::new();
+ while iter.next().is_some() {
+ let mut groups = Vec::new();
+ if compiled.groups == 0 {
+ groups.push(
+ chars[iter.state.start..iter.state.cursor.position]
+ .iter()
+ .collect(),
+ );
+ } else {
+ for group in 0..compiled.groups {
+ let (start, end) = iter.state.marks.get(group);
+ groups.push(match (start.into_option(), end.into_option()) {
+ (Some(start), Some(end)) => chars[start..end].iter().collect(),
+ _ => String::new(),
+ });
+ }
+ }
+ matches.push(groups);
+ }
+ Ok(matches)
+}
+
+fn encode_matches(matches: &[Vec<String>]) -> String {
+ let mut encoded = matches.len().to_string();
+ for groups in matches {
+ encoded.push('\t');
+ encoded.push_str(&groups.len().to_string());
+ for group in groups {
+ encoded.push(':');
+ encoded.push_str(&encode_hex(group));
+ }
+ }
+ encoded
+}
+
+fn main() {
+ let stdin = io::stdin();
+ let mut stdout = io::BufWriter::new(io::stdout().lock());
+ for line in stdin.lock().lines() {
+ let line = line.expect("stdin");
+ let mut fields = line.split('\t');
+ let ignore_case = fields.next() == Some("1");
+ let pattern = fields.next().and_then(|value| decode_hex(value).ok());
+ let text = fields.next().and_then(|value| decode_hex(value).ok());
+ let result = match (pattern, text) {
+ (Some(pattern), Some(text)) => match findall(&pattern, &text, ignore_case) {
+ Ok(matches) => format!("OK\t{}", encode_matches(&matches)),
+ Err(error) => format!("ERR\t{}", encode_hex(&error)),
+ },
+ _ => format!("ERR\t{}", encode_hex("invalid differential input")),
+ };
+ writeln!(stdout, "{result}").expect("stdout");
+ stdout.flush().expect("stdout flush");
+ }
+}
diff --git a/browser/vendor/rustpython-sre_engine/src/compiler.rs b/browser/vendor/rustpython-sre_engine/src/compiler.rs
new file mode 100644
index 000000000..d438b5e0b
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/src/compiler.rs
@@ -0,0 +1,1645 @@
+//! CPython 3.12 `re` parser/compiler compatibility layer.
+//!
+//! The matcher in this crate consumes CPython SRE bytecode. Upstream leaves
+//! parsing and compilation to Python's `Lib/re`; this module ports that
+//! observable subset directly so the browser worker does not embed Python.
+
+use crate::{MAXGROUPS, MAXREPEAT, SreAtCode, SreCatCode, SreOpcode};
+use alloc::{
+ collections::BTreeMap,
+ format,
+ string::{String, ToString},
+ vec,
+ vec::Vec,
+};
+use core::fmt;
+
+const FLAG_TEMPLATE: u16 = 1;
+const FLAG_IGNORECASE: u16 = 2;
+const FLAG_LOCALE: u16 = 4;
+const FLAG_MULTILINE: u16 = 8;
+const FLAG_DOTALL: u16 = 16;
+const FLAG_UNICODE: u16 = 32;
+const FLAG_VERBOSE: u16 = 64;
+const FLAG_DEBUG: u16 = 128;
+const FLAG_ASCII: u16 = 256;
+const TYPE_FLAGS: u16 = FLAG_ASCII | FLAG_LOCALE | FLAG_UNICODE;
+const GLOBAL_FLAGS: u16 = FLAG_DEBUG | FLAG_TEMPLATE;
+const MAX_WIDTH: u64 = u64::MAX;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+ message: String,
+ position: Option<usize>,
+}
+
+impl Error {
+ fn at(message: impl Into<String>, position: usize) -> Self {
+ Self {
+ message: message.into(),
+ position: Some(position),
+ }
+ }
+
+ fn plain(message: impl Into<String>) -> Self {
+ Self {
+ message: message.into(),
+ position: None,
+ }
+ }
+}
+
+impl fmt::Display for Error {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str(&self.message)?;
+ if let Some(position) = self.position {
+ write!(f, " at position {position}")?;
+ }
+ Ok(())
+ }
+}
+
+#[derive(Clone, Debug)]
+pub struct Compiled {
+ pub codes: Vec<u32>,
+ pub groups: usize,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum Op {
+ Literal(u32),
+ NotLiteral(u32),
+ Set(Vec<SetOp>),
+ Any,
+ Repeat {
+ kind: RepeatKind,
+ min: usize,
+ max: usize,
+ body: Pattern,
+ },
+ Subpattern {
+ group: Option<usize>,
+ add_flags: u16,
+ del_flags: u16,
+ body: Pattern,
+ },
+ Atomic(Pattern),
+ Assert {
+ negative: bool,
+ behind: bool,
+ body: Pattern,
+ },
+ At(u32),
+ Branch(Vec<Pattern>),
+ GroupRef(usize),
+ GroupRefExists {
+ group: usize,
+ yes: Pattern,
+ no: Option<Pattern>,
+ },
+}
+
+type Pattern = Vec<Op>;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum RepeatKind {
+ Greedy,
+ Lazy,
+ Possessive,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+enum SetOp {
+ Literal(u32),
+ Range(u32, u32),
+ Category(u32),
+ Negate,
+}
+
+#[derive(Default)]
+struct ParseState {
+ flags: u16,
+ group_names: BTreeMap<String, usize>,
+ group_widths: Vec<Option<(u64, u64)>>,
+ lookbehind_groups: Option<usize>,
+ forward_group_refs: BTreeMap<usize, usize>,
+}
+
+impl ParseState {
+ fn new(flags: u16) -> Self {
+ Self {
+ flags,
+ group_widths: vec![None],
+ ..Self::default()
+ }
+ }
+
+ fn open_group(&mut self, name: Option<String>) -> Result<usize, Error> {
+ let group = self.group_widths.len();
+ self.group_widths.push(None);
+ if self.group_widths.len() > MAXGROUPS {
+ return Err(Error::plain("too many groups"));
+ }
+ if let Some(name) = name {
+ if let Some(previous) = self.group_names.get(&name) {
+ return Err(Error::plain(format!(
+ "redefinition of group name '{name}' as group {group}; was group {previous}"
+ )));
+ }
+ self.group_names.insert(name, group);
+ }
+ Ok(group)
+ }
+
+ fn group_is_closed(&self, group: usize) -> bool {
+ self.group_widths.get(group).is_some_and(Option::is_some)
+ }
+
+ fn check_lookbehind_group(&self, group: usize, position: usize) -> Result<(), Error> {
+ if let Some(first_lookbehind_group) = self.lookbehind_groups {
+ if !self.group_is_closed(group) {
+ return Err(Error::at("cannot refer to an open group", position));
+ }
+ if group >= first_lookbehind_group {
+ return Err(Error::at(
+ "cannot refer to group defined in the same lookbehind subpattern",
+ position,
+ ));
+ }
+ }
+ Ok(())
+ }
+}
+
+#[derive(Clone)]
+struct Tokenizer {
+ chars: Vec<char>,
+ position: usize,
+}
+
+impl Tokenizer {
+ fn new(pattern: &str) -> Self {
+ Self {
+ chars: pattern.chars().collect(),
+ position: 0,
+ }
+ }
+
+ fn token(&self) -> Result<Option<String>, Error> {
+ let Some(&ch) = self.chars.get(self.position) else {
+ return Ok(None);
+ };
+ if ch != '\\' {
+ return Ok(Some(ch.into()));
+ }
+ let Some(&escaped) = self.chars.get(self.position + 1) else {
+ return Err(Error::at("bad escape (end of pattern)", self.position));
+ };
+ Ok(Some(format!("\\{escaped}")))
+ }
+
+ fn get(&mut self) -> Result<Option<String>, Error> {
+ let token = self.token()?;
+ if let Some(token) = &token {
+ self.position += token.chars().count();
+ }
+ Ok(token)
+ }
+
+ fn matches(&mut self, expected: &str) -> Result<bool, Error> {
+ if self.token()?.as_deref() == Some(expected) {
+ self.get()?;
+ Ok(true)
+ } else {
+ Ok(false)
+ }
+ }
+
+ fn tell(&self) -> usize {
+ self.position
+ }
+
+ fn seek(&mut self, position: usize) {
+ self.position = position;
+ }
+
+ fn get_while(&mut self, limit: usize, allowed: fn(char) -> bool) -> Result<String, Error> {
+ let mut out = String::new();
+ for _ in 0..limit {
+ let Some(token) = self.token()? else { break };
+ let mut chars = token.chars();
+ let ch = chars.next().expect("nonempty token");
+ if chars.next().is_some() || !allowed(ch) {
+ break;
+ }
+ out.push(ch);
+ self.get()?;
+ }
+ Ok(out)
+ }
+
+ fn get_until(&mut self, terminator: &str, name: &str) -> Result<String, Error> {
+ let mut out = String::new();
+ loop {
+ let position = self.tell();
+ let Some(token) = self.get()? else {
+ let message = if out.is_empty() {
+ format!("missing {name}")
+ } else {
+ format!("missing {terminator}, unterminated name")
+ };
+ return Err(Error::at(
+ message,
+ position.saturating_sub(out.chars().count()),
+ ));
+ };
+ if token == terminator {
+ if out.is_empty() {
+ return Err(Error::at(format!("missing {name}"), position));
+ }
+ return Ok(out);
+ }
+ out.push_str(&token);
+ }
+ }
+}
+
+pub fn compile(pattern: &str, case_insensitive: bool) -> Result<Compiled, Error> {
+ let flags = if case_insensitive { FLAG_IGNORECASE } else { 0 };
+ let mut parser = Parser {
+ source: Tokenizer::new(pattern),
+ state: ParseState::new(flags),
+ };
+ let parsed = parser.parse_sub(false, 0)?;
+ parser.state.flags = fix_flags(parser.state.flags)?;
+ if parser.source.token()?.is_some() {
+ return Err(Error::at("unbalanced parenthesis", parser.source.tell()));
+ }
+ for (&group, &position) in &parser.state.forward_group_refs {
+ if group >= parser.state.group_widths.len() {
+ return Err(Error::at(
+ format!("invalid group reference {group}"),
+ position,
+ ));
+ }
+ }
+
+ let mut codes = Vec::new();
+ let (min, max) = width(&parsed, &parser.state);
+ emit(&mut codes, SreOpcode::INFO);
+ let info_skip = codes.len();
+ codes.extend([
+ 0,
+ 0,
+ min.min(u32::MAX as u64) as u32,
+ max.min(u32::MAX as u64) as u32,
+ ]);
+ if min != 0
+ && let Some(set) = first_charset(&parsed)
+ {
+ codes[info_skip + 1] = crate::SreInfo::CHARSET.bits();
+ let mut compiled_set = Vec::new();
+ compile_set(set, parser.state.flags, &mut compiled_set);
+ codes.extend_from_slice(&compiled_set[2..]);
+ }
+ codes[info_skip] = (codes.len() - info_skip) as u32;
+ compile_pattern(&parsed, parser.state.flags, &parser.state, &mut codes)?;
+ emit(&mut codes, SreOpcode::SUCCESS);
+ Ok(Compiled {
+ codes,
+ groups: parser.state.group_widths.len() - 1,
+ })
+}
+
+struct Parser {
+ source: Tokenizer,
+ state: ParseState,
+}
+
+impl Parser {
+ fn error(&self, message: impl Into<String>, offset: usize) -> Error {
+ Error::at(message, self.source.tell().saturating_sub(offset))
+ }
+
+ fn parse_sub(&mut self, verbose: bool, nested: usize) -> Result<Pattern, Error> {
+ let mut branches = Vec::new();
+ loop {
+ let first = nested == 0 && branches.is_empty();
+ branches.push(self.parse_sequence(verbose, nested + 1, first)?);
+ if !self.source.matches("|")? {
+ break;
+ }
+ }
+ if branches.len() == 1 {
+ Ok(branches.pop().expect("one branch"))
+ } else {
+ Ok(vec![Op::Branch(branches)])
+ }
+ }
+
+ fn parse_sequence(
+ &mut self,
+ mut verbose: bool,
+ nested: usize,
+ first: bool,
+ ) -> Result<Pattern, Error> {
+ let mut out = Vec::new();
+ while let Some(token) = self.source.token()? {
+ if token == "|" || token == ")" {
+ break;
+ }
+ self.source.get()?;
+
+ if verbose {
+ let ch = one_char(&token);
+ if ch.is_some_and(is_verbose_whitespace) {
+ continue;
+ }
+ if token == "#" {
+ loop {
+ match self.source.get()? {
+ None => break,
+ Some(value) if value == "\n" => break,
+ _ => {}
+ }
+ }
+ continue;
+ }
+ }
+
+ if token.starts_with('\\') {
+ out.push(self.parse_escape(&token, false)?);
+ continue;
+ }
+ if !".\\[{()*+?^$|".contains(&token) {
+ out.push(Op::Literal(one_char(&token).expect("literal") as u32));
+ continue;
+ }
+ match token.as_str() {
+ "[" => out.push(self.parse_set()?),
+ "*" | "+" | "?" | "{" => self.parse_repeat(&mut out, &token)?,
+ "." => out.push(Op::Any),
+ "(" => {
+ if let Some(op) = self.parse_group(&out, &mut verbose, nested, first)? {
+ out.push(op);
+ }
+ }
+ "^" => out.push(Op::At(SreAtCode::BEGINNING as u32)),
+ "$" => out.push(Op::At(SreAtCode::END as u32)),
+ _ => unreachable!("special token {token}"),
+ }
+ }
+ Ok(out)
+ }
+
+ fn parse_set(&mut self) -> Result<Op, Error> {
+ let start = self.source.tell() - 1;
+ let negate = self.source.matches("^")?;
+ let mut items = Vec::new();
+ loop {
+ let Some(token) = self.source.get()? else {
+ return Err(Error::at("unterminated character set", start));
+ };
+ if token == "]" && !items.is_empty() {
+ break;
+ }
+ let first = self.parse_set_atom(&token)?;
+ if self.source.matches("-")? {
+ let Some(second_token) = self.source.get()? else {
+ return Err(Error::at("unterminated character set", start));
+ };
+ if second_token == "]" {
+ items.push(first);
+ items.push(SetOp::Literal('-' as u32));
+ break;
+ }
+ let second = self.parse_set_atom(&second_token)?;
+ let (SetOp::Literal(low), SetOp::Literal(high)) = (&first, &second) else {
+ return Err(self.error(
+ format!("bad character range {token}-{second_token}"),
+ token.chars().count() + 1 + second_token.chars().count(),
+ ));
+ };
+ if high < low {
+ return Err(self.error(
+ format!("bad character range {token}-{second_token}"),
+ token.chars().count() + 1 + second_token.chars().count(),
+ ));
+ }
+ items.push(SetOp::Range(*low, *high));
+ } else {
+ items.push(first);
+ }
+ }
+ dedup_set(&mut items);
+ if items.len() == 1
+ && let SetOp::Literal(value) = items[0]
+ {
+ return Ok(if negate {
+ Op::NotLiteral(value)
+ } else {
+ Op::Literal(value)
+ });
+ }
+ if negate {
+ items.insert(0, SetOp::Negate);
+ }
+ Ok(Op::Set(items))
+ }
+
+ fn parse_set_atom(&mut self, token: &str) -> Result<SetOp, Error> {
+ if token.starts_with('\\') {
+ match self.parse_escape(token, true)? {
+ Op::Literal(value) => Ok(SetOp::Literal(value)),
+ Op::Set(mut values) if values.len() == 1 => Ok(values.remove(0)),
+ _ => unreachable!("class escape shape"),
+ }
+ } else {
+ Ok(SetOp::Literal(one_char(token).expect("set token") as u32))
+ }
+ }
+
+ fn parse_repeat(&mut self, out: &mut Pattern, token: &str) -> Result<(), Error> {
+ let here = self.source.tell();
+ let (mut min, mut max) = match token {
+ "?" => (0, 1),
+ "*" => (0, MAXREPEAT),
+ "+" => (1, MAXREPEAT),
+ "{" => {
+ if self.source.matches("}")? {
+ out.push(Op::Literal('{' as u32));
+ return Ok(());
+ }
+ let low = self.source.get_while(usize::MAX, is_digit)?;
+ let high = if self.source.matches(",")? {
+ self.source.get_while(usize::MAX, is_digit)?
+ } else {
+ low.clone()
+ };
+ if !self.source.matches("}")? {
+ out.push(Op::Literal('{' as u32));
+ self.source.seek(here);
+ return Ok(());
+ }
+ let min = parse_repeat_bound(&low)?.unwrap_or(0);
+ let max = parse_repeat_bound(&high)?.unwrap_or(MAXREPEAT);
+ if max < min {
+ return Err(self.error(
+ "min repeat greater than max repeat",
+ self.source.tell() - here,
+ ));
+ }
+ (min, max)
+ }
+ _ => unreachable!(),
+ };
+ // Keep the names mutable to mirror the parser's bound handling while
+ // letting rustc prove both values are initialized.
+ min = min.min(MAXREPEAT);
+ max = max.min(MAXREPEAT);
+ let Some(previous) = out.pop() else {
+ return Err(self.error("nothing to repeat", self.source.tell() - here + token.len()));
+ };
+ if matches!(previous, Op::At(_)) {
+ out.push(previous);
+ return Err(self.error("nothing to repeat", self.source.tell() - here + token.len()));
+ }
+ if matches!(previous, Op::Repeat { .. }) {
+ out.push(previous);
+ return Err(self.error("multiple repeat", self.source.tell() - here + token.len()));
+ }
+ let kind = if self.source.matches("?")? {
+ RepeatKind::Lazy
+ } else if self.source.matches("+")? {
+ RepeatKind::Possessive
+ } else {
+ RepeatKind::Greedy
+ };
+ out.push(Op::Repeat {
+ kind,
+ min,
+ max,
+ body: vec![previous],
+ });
+ Ok(())
+ }
+
+ fn parse_group(
+ &mut self,
+ prefix: &Pattern,
+ verbose: &mut bool,
+ nested: usize,
+ first: bool,
+ ) -> Result<Option<Op>, Error> {
+ let start = self.source.tell() - 1;
+ let mut capture = true;
+ let mut atomic = false;
+ let mut name = None;
+ let mut add_flags = 0;
+ let mut del_flags = 0;
+ if self.source.matches("?")? {
+ let Some(mut extension) = self.source.get()? else {
+ return Err(self.error("unexpected end of pattern", 0));
+ };
+ match extension.as_str() {
+ "P" => {
+ if self.source.matches("<")? {
+ let group_name = self.source.get_until(">", "group name")?;
+ self.check_group_name(&group_name, 1)?;
+ name = Some(group_name);
+ } else if self.source.matches("=")? {
+ let group_name = self.source.get_until(")", "group name")?;
+ self.check_group_name(&group_name, 1)?;
+ let Some(&group) = self.state.group_names.get(&group_name) else {
+ return Err(self.error(
+ format!("unknown group name '{group_name}'"),
+ group_name.chars().count() + 1,
+ ));
+ };
+ if !self.state.group_is_closed(group) {
+ return Err(
+ self.error("cannot refer to an open group", group_name.len() + 1)
+ );
+ }
+ self.state
+ .check_lookbehind_group(group, self.source.tell())?;
+ return Ok(Some(Op::GroupRef(group)));
+ } else {
+ let suffix = self.source.get()?.unwrap_or_default();
+ return Err(self.error(
+ format!("unknown extension ?P{suffix}"),
+ suffix.chars().count() + 2,
+ ));
+ }
+ }
+ ":" => capture = false,
+ "#" => {
+ loop {
+ match self.source.get()? {
+ Some(value) if value == ")" => break,
+ Some(_) => {}
+ None => {
+ return Err(Error::at("missing ), unterminated comment", start));
+ }
+ }
+ }
+ return Ok(None);
+ }
+ "=" | "!" | "<" => {
+ let mut behind = false;
+ if extension == "<" {
+ extension = self
+ .source
+ .get()?
+ .ok_or_else(|| self.error("unexpected end of pattern", 0))?;
+ if extension != "=" && extension != "!" {
+ return Err(self.error(
+ format!("unknown extension ?<{extension}"),
+ extension.chars().count() + 2,
+ ));
+ }
+ behind = true;
+ }
+ let previous_lookbehind = self.state.lookbehind_groups;
+ if behind && previous_lookbehind.is_none() {
+ self.state.lookbehind_groups = Some(self.state.group_widths.len());
+ }
+ let body = self.parse_sub(*verbose, nested + 1)?;
+ if behind && previous_lookbehind.is_none() {
+ self.state.lookbehind_groups = None;
+ }
+ if !self.source.matches(")")? {
+ return Err(Error::at("missing ), unterminated subpattern", start));
+ }
+ return Ok(Some(Op::Assert {
+ negative: extension == "!",
+ behind,
+ body,
+ }));
+ }
+ "(" => {
+ let condition = self.source.get_until(")", "group name")?;
+ let group = if condition.chars().all(|c| c.is_ascii_digit()) {
+ let group: usize = condition.parse().unwrap_or(usize::MAX);
+ if group == 0 {
+ return Err(self.error("bad group number", condition.len() + 1));
+ }
+ if group >= MAXGROUPS {
+ return Err(self.error(
+ format!("invalid group reference {group}"),
+ condition.len() + 1,
+ ));
+ }
+ self.state
+ .forward_group_refs
+ .entry(group)
+ .or_insert(self.source.tell().saturating_sub(condition.len() + 1));
+ group
+ } else {
+ self.check_group_name(&condition, 1)?;
+ *self.state.group_names.get(&condition).ok_or_else(|| {
+ self.error(
+ format!("unknown group name '{condition}'"),
+ condition.chars().count() + 1,
+ )
+ })?
+ };
+ self.state
+ .check_lookbehind_group(group, self.source.tell())?;
+ let yes = self.parse_sequence(*verbose, nested + 1, false)?;
+ let no = if self.source.matches("|")? {
+ let branch = self.parse_sequence(*verbose, nested + 1, false)?;
+ if self.source.token()?.as_deref() == Some("|") {
+ return Err(
+ self.error("conditional backref with more than two branches", 0)
+ );
+ }
+ Some(branch)
+ } else {
+ None
+ };
+ if !self.source.matches(")")? {
+ return Err(Error::at("missing ), unterminated subpattern", start));
+ }
+ return Ok(Some(Op::GroupRefExists { group, yes, no }));
+ }
+ ">" => {
+ capture = false;
+ atomic = true;
+ }
+ value if flag_for(value).is_some() || value == "-" => {
+ let flags = self.parse_flags(value)?;
+ if let Some((add, del)) = flags {
+ add_flags = add;
+ del_flags = del;
+ capture = false;
+ } else {
+ if !first || !prefix.is_empty() {
+ return Err(Error::at(
+ "global flags not at the start of the expression",
+ start,
+ ));
+ }
+ *verbose = self.state.flags & FLAG_VERBOSE != 0;
+ return Ok(None);
+ }
+ }
+ _ => {
+ return Err(self.error(
+ format!("unknown extension ?{extension}"),
+ extension.chars().count() + 1,
+ ));
+ }
+ }
+ }
+
+ let group = if capture {
+ let error_position = name
+ .as_ref()
+ .map(|value| self.source.tell().saturating_sub(value.chars().count() + 1))
+ .unwrap_or(start);
+ Some(
+ self.state
+ .open_group(name)
+ .map_err(|error| Error::at(error.message, error_position))?,
+ )
+ } else {
+ None
+ };
+ let sub_verbose =
+ (*verbose || add_flags & FLAG_VERBOSE != 0) && del_flags & FLAG_VERBOSE == 0;
+ let body = self.parse_sub(sub_verbose, nested + 1)?;
+ if !self.source.matches(")")? {
+ return Err(Error::at("missing ), unterminated subpattern", start));
+ }
+ if let Some(group) = group {
+ self.state.group_widths[group] = Some(width(&body, &self.state));
+ }
+ Ok(Some(if atomic {
+ Op::Atomic(body)
+ } else {
+ Op::Subpattern {
+ group,
+ add_flags,
+ del_flags,
+ body,
+ }
+ }))
+ }
+
+ fn parse_flags(&mut self, initial: &str) -> Result<Option<(u16, u16)>, Error> {
+ let mut token = initial.to_string();
+ let mut add = 0;
+ let mut del = 0;
+ if token != "-" {
+ loop {
+ let flag = flag_for(&token).expect("caller checked flag");
+ if token == "L" {
+ return Err(self.error(
+ "bad inline flags: cannot use 'L' flag with a str pattern",
+ 0,
+ ));
+ }
+ add |= flag;
+ if flag & TYPE_FLAGS != 0 && add & TYPE_FLAGS != flag {
+ return Err(self.error(
+ "bad inline flags: flags 'a', 'u' and 'L' are incompatible",
+ 0,
+ ));
+ }
+ token = self
+ .source
+ .get()?
+ .ok_or_else(|| self.error("missing -, : or )", 0))?;
+ if matches!(token.as_str(), ")" | "-" | ":") {
+ break;
+ }
+ if flag_for(&token).is_none() {
+ return Err(self.error(
+ if one_char(&token).is_some_and(char::is_alphabetic) {
+ "unknown flag"
+ } else {
+ "missing -, : or )"
+ },
+ token.chars().count(),
+ ));
+ }
+ }
+ }
+ if token == ")" {
+ self.state.flags |= add;
+ return Ok(None);
+ }
+ if add & GLOBAL_FLAGS != 0 {
+ return Err(self.error("bad inline flags: cannot turn on global flag", 1));
+ }
+ if token == "-" {
+ token = self
+ .source
+ .get()?
+ .ok_or_else(|| self.error("missing flag", 0))?;
+ loop {
+ let Some(flag) = flag_for(&token) else {
+ return Err(self.error(
+ if one_char(&token).is_some_and(char::is_alphabetic) {
+ "unknown flag"
+ } else {
+ "missing flag"
+ },
+ token.chars().count(),
+ ));
+ };
+ if flag & TYPE_FLAGS != 0 {
+ return Err(self.error(
+ "bad inline flags: cannot turn off flags 'a', 'u' and 'L'",
+ 0,
+ ));
+ }
+ del |= flag;
+ token = self
+ .source
+ .get()?
+ .ok_or_else(|| self.error("missing :", 0))?;
+ if token == ":" {
+ break;
+ }
+ }
+ }
+ if add & del != 0 {
+ return Err(self.error("bad inline flags: flag turned on and off", 1));
+ }
+ Ok(Some((add, del)))
+ }
+
+ fn check_group_name(&self, name: &str, offset: usize) -> Result<(), Error> {
+ let mut chars = name.chars();
+ let valid = chars
+ .next()
+ .is_some_and(|ch| ch == '_' || unicode_ident::is_xid_start(ch))
+ && chars.all(|ch| ch == '_' || unicode_ident::is_xid_continue(ch));
+ if valid {
+ Ok(())
+ } else {
+ Err(self.error(
+ format!("bad character in group name '{name}'"),
+ name.chars().count() + offset,
+ ))
+ }
+ }
+
+ fn parse_escape(&mut self, token: &str, in_set: bool) -> Result<Op, Error> {
+ if let Some(value) = simple_escape(token, in_set) {
+ return Ok(value);
+ }
+ let code = token.chars().nth(1).expect("escape token");
+ match code {
+ 'x' | 'u' | 'U' => {
+ let count = match code {
+ 'x' => 2,
+ 'u' => 4,
+ _ => 8,
+ };
+ let digits = self.source.get_while(count, is_hex)?;
+ let whole = format!("{token}{digits}");
+ if digits.len() != count {
+ return Err(self.error(format!("incomplete escape {whole}"), whole.len()));
+ }
+ let value = u32::from_str_radix(&digits, 16).expect("hex checked");
+ if char::from_u32(value).is_none() {
+ return Err(self.error(format!("bad escape {whole}"), whole.len()));
+ }
+ Ok(Op::Literal(value))
+ }
+ 'N' => {
+ if !self.source.matches("{")? {
+ return Err(self.error("missing {", 0));
+ }
+ let name = self.source.get_until("}", "character name")?;
+ let value = unicode_names2::character(&name).ok_or_else(|| {
+ self.error(
+ format!("undefined character name '{name}'"),
+ name.chars().count() + 4,
+ )
+ })?;
+ Ok(Op::Literal(value as u32))
+ }
+ '0' if !in_set => {
+ let extra = self.source.get_while(2, is_octal)?;
+ Ok(Op::Literal(
+ u32::from_str_radix(&format!("0{extra}"), 8).unwrap(),
+ ))
+ }
+ c if c.is_ascii_digit() => self.parse_numeric_escape(token, in_set),
+ c if c.is_ascii_alphabetic() => {
+ Err(self.error(format!("bad escape {token}"), token.chars().count()))
+ }
+ c => Ok(Op::Literal(c as u32)),
+ }
+ }
+
+ fn parse_numeric_escape(&mut self, token: &str, in_set: bool) -> Result<Op, Error> {
+ let mut digits = token[1..].to_string();
+ if in_set {
+ digits.push_str(&self.source.get_while(2, is_octal)?);
+ let value = u32::from_str_radix(&digits, 8)
+ .map_err(|_| self.error(format!("bad escape \\{digits}"), digits.len() + 1))?;
+ if value > 0o377 {
+ return Err(self.error(
+ format!("octal escape value \\{digits} outside of range 0-0o377"),
+ digits.len() + 1,
+ ));
+ }
+ return Ok(Op::Literal(value));
+ }
+
+ if self
+ .source
+ .token()?
+ .as_deref()
+ .is_some_and(|s| s.chars().all(|c| c.is_ascii_digit()))
+ {
+ digits.push_str(&self.source.get()?.expect("peeked token"));
+ if digits.chars().take(2).all(is_octal)
+ && self
+ .source
+ .token()?
+ .as_deref()
+ .is_some_and(|s| s.chars().all(is_octal))
+ {
+ digits.push_str(&self.source.get()?.expect("peeked token"));
+ let value = u32::from_str_radix(&digits, 8).unwrap();
+ if value > 0o377 {
+ return Err(self.error(
+ format!("octal escape value \\{digits} outside of range 0-0o377"),
+ digits.len() + 1,
+ ));
+ }
+ return Ok(Op::Literal(value));
+ }
+ }
+ let group: usize = digits.parse().unwrap_or(usize::MAX);
+ if group < self.state.group_widths.len() {
+ if !self.state.group_is_closed(group) {
+ return Err(self.error("cannot refer to an open group", digits.len() + 1));
+ }
+ self.state
+ .check_lookbehind_group(group, self.source.tell())?;
+ Ok(Op::GroupRef(group))
+ } else {
+ Err(self.error(format!("invalid group reference {group}"), digits.len()))
+ }
+ }
+}
+
+fn one_char(token: &str) -> Option<char> {
+ let mut chars = token.chars();
+ let ch = chars.next()?;
+ chars.next().is_none().then_some(ch)
+}
+
+fn is_digit(ch: char) -> bool {
+ ch.is_ascii_digit()
+}
+fn is_octal(ch: char) -> bool {
+ matches!(ch, '0'..='7')
+}
+fn is_hex(ch: char) -> bool {
+ ch.is_ascii_hexdigit()
+}
+fn is_verbose_whitespace(ch: char) -> bool {
+ matches!(ch, ' ' | '\t' | '\n' | '\r' | '\u{b}' | '\u{c}')
+}
+
+fn parse_repeat_bound(value: &str) -> Result<Option<usize>, Error> {
+ if value.is_empty() {
+ return Ok(None);
+ }
+ let value = value
+ .parse::<u64>()
+ .map_err(|_| Error::plain("the repetition number is too large"))?;
+ if value >= MAXREPEAT as u64 {
+ Err(Error::plain("the repetition number is too large"))
+ } else {
+ Ok(Some(value as usize))
+ }
+}
+
+fn simple_escape(token: &str, in_set: bool) -> Option<Op> {
+ let literal = match token {
+ "\\a" => Some('\u{7}'),
+ "\\b" if in_set => Some('\u{8}'),
+ "\\f" => Some('\u{c}'),
+ "\\n" => Some('\n'),
+ "\\r" => Some('\r'),
+ "\\t" => Some('\t'),
+ "\\v" => Some('\u{b}'),
+ "\\\\" => Some('\\'),
+ _ => None,
+ };
+ if let Some(value) = literal {
+ return Some(Op::Literal(value as u32));
+ }
+ let category = match token {
+ "\\d" => Some(SreCatCode::DIGIT as u32),
+ "\\D" => Some(SreCatCode::NOT_DIGIT as u32),
+ "\\s" => Some(SreCatCode::SPACE as u32),
+ "\\S" => Some(SreCatCode::NOT_SPACE as u32),
+ "\\w" => Some(SreCatCode::WORD as u32),
+ "\\W" => Some(SreCatCode::NOT_WORD as u32),
+ _ => None,
+ };
+ if let Some(category) = category {
+ return Some(Op::Set(vec![SetOp::Category(category)]));
+ }
+ if in_set {
+ return None;
+ }
+ Some(match token {
+ "\\A" => Op::At(SreAtCode::BEGINNING_STRING as u32),
+ "\\b" => Op::At(SreAtCode::BOUNDARY as u32),
+ "\\B" => Op::At(SreAtCode::NON_BOUNDARY as u32),
+ "\\Z" => Op::At(SreAtCode::END_STRING as u32),
+ _ => return None,
+ })
+}
+
+fn flag_for(token: &str) -> Option<u16> {
+ Some(match token {
+ "i" => FLAG_IGNORECASE,
+ "L" => FLAG_LOCALE,
+ "m" => FLAG_MULTILINE,
+ "s" => FLAG_DOTALL,
+ "x" => FLAG_VERBOSE,
+ "a" => FLAG_ASCII,
+ "t" => FLAG_TEMPLATE,
+ "u" => FLAG_UNICODE,
+ _ => return None,
+ })
+}
+
+fn fix_flags(mut flags: u16) -> Result<u16, Error> {
+ if flags & FLAG_LOCALE != 0 {
+ return Err(Error::plain("cannot use LOCALE flag with a str pattern"));
+ }
+ if flags & FLAG_ASCII == 0 {
+ flags |= FLAG_UNICODE;
+ } else if flags & FLAG_UNICODE != 0 {
+ return Err(Error::plain("ASCII and UNICODE flags are incompatible"));
+ }
+ Ok(flags)
+}
+
+fn dedup_set(items: &mut Vec<SetOp>) {
+ let mut unique = Vec::with_capacity(items.len());
+ for item in items.drain(..) {
+ if !unique.contains(&item) {
+ unique.push(item);
+ }
+ }
+ *items = unique;
+}
+
+fn width(pattern: &Pattern, state: &ParseState) -> (u64, u64) {
+ let (mut low, mut high) = (0u64, 0u64);
+ for op in pattern {
+ let (item_low, item_high) = match op {
+ Op::Branch(branches) => branches.iter().map(|branch| width(branch, state)).fold(
+ (MAX_WIDTH, 0),
+ |(low, high), (branch_low, branch_high)| {
+ (low.min(branch_low), high.max(branch_high))
+ },
+ ),
+ Op::Atomic(body) | Op::Subpattern { body, .. } => width(body, state),
+ Op::Repeat { min, max, body, .. } => {
+ let (body_low, body_high) = width(body, state);
+ let low = body_low.saturating_mul(*min as u64);
+ let high = if *max == MAXREPEAT && body_high != 0 {
+ MAX_WIDTH
+ } else {
+ body_high.saturating_mul(*max as u64)
+ };
+ (low, high)
+ }
+ Op::Literal(_) | Op::NotLiteral(_) | Op::Set(_) | Op::Any => (1, 1),
+ Op::GroupRef(group) => state.group_widths[*group].unwrap_or((0, MAX_WIDTH)),
+ Op::GroupRefExists { yes, no, .. } => {
+ let (yes_low, yes_high) = width(yes, state);
+ let (no_low, no_high) = no.as_ref().map_or((0, 0), |body| width(body, state));
+ (yes_low.min(no_low), yes_high.max(no_high))
+ }
+ Op::Assert { .. } | Op::At(_) => (0, 0),
+ };
+ low = low.saturating_add(item_low);
+ high = high.saturating_add(item_high);
+ }
+ (low, high)
+}
+
+fn emit(codes: &mut Vec<u32>, opcode: SreOpcode) {
+ codes.push(opcode as u32);
+}
+
+fn combine_flags(mut flags: u16, add: u16, del: u16) -> u16 {
+ if add & TYPE_FLAGS != 0 {
+ flags &= !TYPE_FLAGS;
+ }
+ (flags | add) & !del
+}
+
+// Mirrors CPython 3.12's `_get_charset_prefix`: scoped type flags affect the
+// real opcode but the INFO search charset is compiled with the outer flags.
+// That observable quirk is why `(?a:\W)` search differs from fullmatch.
+fn first_charset(pattern: &Pattern) -> Option<&[SetOp]> {
+ let first = pattern.first()?;
+ match first {
+ Op::Set(items) => Some(items),
+ Op::Subpattern { body, .. } => first_charset(body),
+ _ => None,
+ }
+}
+
+fn compile_pattern(
+ pattern: &Pattern,
+ flags: u16,
+ state: &ParseState,
+ codes: &mut Vec<u32>,
+) -> Result<(), Error> {
+ for op in pattern {
+ match op {
+ Op::Literal(value) => compile_literal(*value, false, flags, codes),
+ Op::NotLiteral(value) => compile_literal(*value, true, flags, codes),
+ Op::Set(items) => compile_set(items, flags, codes),
+ Op::Any => emit(
+ codes,
+ if flags & FLAG_DOTALL != 0 {
+ SreOpcode::ANY_ALL
+ } else {
+ SreOpcode::ANY
+ },
+ ),
+ Op::Repeat {
+ kind,
+ min,
+ max,
+ body,
+ } => {
+ let simple = is_simple(body);
+ let opcode = match (kind, simple) {
+ (RepeatKind::Greedy, true) => SreOpcode::REPEAT_ONE,
+ (RepeatKind::Lazy, true) => SreOpcode::MIN_REPEAT_ONE,
+ (RepeatKind::Possessive, true) => SreOpcode::POSSESSIVE_REPEAT_ONE,
+ (RepeatKind::Greedy | RepeatKind::Lazy, false) => SreOpcode::REPEAT,
+ (RepeatKind::Possessive, false) => SreOpcode::POSSESSIVE_REPEAT,
+ };
+ emit(codes, opcode);
+ let skip = codes.len();
+ codes.extend([0, *min as u32, *max as u32]);
+ compile_pattern(body, flags, state, codes)?;
+ match (kind, simple) {
+ (RepeatKind::Greedy, false) => {
+ codes[skip] = (codes.len() - skip) as u32;
+ emit(codes, SreOpcode::MAX_UNTIL);
+ }
+ (RepeatKind::Lazy, false) => {
+ codes[skip] = (codes.len() - skip) as u32;
+ emit(codes, SreOpcode::MIN_UNTIL);
+ }
+ _ => {
+ emit(codes, SreOpcode::SUCCESS);
+ codes[skip] = (codes.len() - skip) as u32;
+ }
+ }
+ }
+ Op::Subpattern {
+ group,
+ add_flags,
+ del_flags,
+ body,
+ } => {
+ if let Some(group) = group {
+ emit(codes, SreOpcode::MARK);
+ codes.push(((group - 1) * 2) as u32);
+ }
+ compile_pattern(
+ body,
+ combine_flags(flags, *add_flags, *del_flags),
+ state,
+ codes,
+ )?;
+ if let Some(group) = group {
+ emit(codes, SreOpcode::MARK);
+ codes.push(((group - 1) * 2 + 1) as u32);
+ }
+ }
+ Op::Atomic(body) => {
+ emit(codes, SreOpcode::ATOMIC_GROUP);
+ let skip = codes.len();
+ codes.push(0);
+ compile_pattern(body, flags, state, codes)?;
+ emit(codes, SreOpcode::SUCCESS);
+ codes[skip] = (codes.len() - skip) as u32;
+ }
+ Op::Assert {
+ negative,
+ behind,
+ body,
+ } => {
+ emit(
+ codes,
+ if *negative {
+ SreOpcode::ASSERT_NOT
+ } else {
+ SreOpcode::ASSERT
+ },
+ );
+ let skip = codes.len();
+ codes.push(0);
+ if *behind {
+ let (low, high) = width(body, state);
+ if low != high {
+ return Err(Error::plain("look-behind requires fixed-width pattern"));
+ }
+ codes.push(low as u32);
+ } else {
+ codes.push(0);
+ }
+ compile_pattern(body, flags, state, codes)?;
+ emit(codes, SreOpcode::SUCCESS);
+ codes[skip] = (codes.len() - skip) as u32;
+ }
+ Op::At(value) => {
+ emit(codes, SreOpcode::AT);
+ codes.push(map_at(*value, flags));
+ }
+ Op::Branch(branches) => {
+ emit(codes, SreOpcode::BRANCH);
+ let mut tails = Vec::new();
+ for branch in branches {
+ let skip = codes.len();
+ codes.push(0);
+ compile_pattern(branch, flags, state, codes)?;
+ emit(codes, SreOpcode::JUMP);
+ tails.push(codes.len());
+ codes.push(0);
+ codes[skip] = (codes.len() - skip) as u32;
+ }
+ emit(codes, SreOpcode::FAILURE);
+ let end = codes.len();
+ for tail in tails {
+ codes[tail] = (end - tail) as u32;
+ }
+ }
+ Op::GroupRef(group) => {
+ emit(
+ codes,
+ match ignore_mode(flags) {
+ IgnoreMode::None => SreOpcode::GROUPREF,
+ IgnoreMode::Ascii => SreOpcode::GROUPREF_IGNORE,
+ IgnoreMode::Unicode => SreOpcode::GROUPREF_UNI_IGNORE,
+ },
+ );
+ codes.push((group - 1) as u32);
+ }
+ Op::GroupRefExists { group, yes, no } => {
+ emit(codes, SreOpcode::GROUPREF_EXISTS);
+ codes.push((group - 1) as u32);
+ let skip_yes = codes.len();
+ codes.push(0);
+ compile_pattern(yes, flags, state, codes)?;
+ if let Some(no) = no {
+ emit(codes, SreOpcode::JUMP);
+ let skip_no = codes.len();
+ codes.push(0);
+ codes[skip_yes] = (codes.len() - skip_yes + 1) as u32;
+ compile_pattern(no, flags, state, codes)?;
+ codes[skip_no] = (codes.len() - skip_no) as u32;
+ } else {
+ codes[skip_yes] = (codes.len() - skip_yes + 1) as u32;
+ }
+ }
+ }
+ }
+ Ok(())
+}
+
+fn is_simple(pattern: &Pattern) -> bool {
+ if pattern.len() != 1 {
+ return false;
+ }
+ match &pattern[0] {
+ Op::Literal(_) | Op::NotLiteral(_) | Op::Set(_) | Op::Any => true,
+ Op::Subpattern {
+ group: None, body, ..
+ } => is_simple(body),
+ _ => false,
+ }
+}
+
+#[derive(Clone, Copy)]
+enum IgnoreMode {
+ None,
+ Ascii,
+ Unicode,
+}
+
+fn ignore_mode(flags: u16) -> IgnoreMode {
+ if flags & FLAG_IGNORECASE == 0 {
+ IgnoreMode::None
+ } else if flags & FLAG_ASCII != 0 {
+ IgnoreMode::Ascii
+ } else {
+ IgnoreMode::Unicode
+ }
+}
+
+fn compile_literal(value: u32, negate: bool, flags: u16, codes: &mut Vec<u32>) {
+ match ignore_mode(flags) {
+ IgnoreMode::None => {
+ emit(
+ codes,
+ if negate {
+ SreOpcode::NOT_LITERAL
+ } else {
+ SreOpcode::LITERAL
+ },
+ );
+ codes.push(value);
+ }
+ IgnoreMode::Ascii => {
+ emit(
+ codes,
+ if negate {
+ SreOpcode::NOT_LITERAL_IGNORE
+ } else {
+ SreOpcode::LITERAL_IGNORE
+ },
+ );
+ codes.push(crate::string::lower_ascii(value));
+ }
+ IgnoreMode::Unicode => {
+ let lower = crate::string::lower_unicode(value);
+ let extras = extra_cases(lower);
+ if extras.is_empty() {
+ emit(
+ codes,
+ if negate {
+ SreOpcode::NOT_LITERAL_UNI_IGNORE
+ } else {
+ SreOpcode::LITERAL_UNI_IGNORE
+ },
+ );
+ codes.push(lower);
+ } else {
+ emit(codes, SreOpcode::IN_UNI_IGNORE);
+ let skip = codes.len();
+ codes.push(0);
+ if negate {
+ emit(codes, SreOpcode::NEGATE);
+ }
+ for value in core::iter::once(lower).chain(extras.iter().copied()) {
+ emit(codes, SreOpcode::LITERAL);
+ codes.push(value);
+ }
+ emit(codes, SreOpcode::FAILURE);
+ codes[skip] = (codes.len() - skip) as u32;
+ }
+ }
+ }
+}
+
+fn compile_set(items: &[SetOp], flags: u16, codes: &mut Vec<u32>) {
+ emit(
+ codes,
+ match ignore_mode(flags) {
+ IgnoreMode::None => SreOpcode::IN,
+ IgnoreMode::Ascii => SreOpcode::IN_IGNORE,
+ IgnoreMode::Unicode => SreOpcode::IN_UNI_IGNORE,
+ },
+ );
+ let skip = codes.len();
+ codes.push(0);
+ for item in items {
+ match item {
+ SetOp::Negate => emit(codes, SreOpcode::NEGATE),
+ SetOp::Literal(value) => {
+ let lower = match ignore_mode(flags) {
+ IgnoreMode::None => *value,
+ IgnoreMode::Ascii => crate::string::lower_ascii(*value),
+ IgnoreMode::Unicode => crate::string::lower_unicode(*value),
+ };
+ emit(codes, SreOpcode::LITERAL);
+ codes.push(lower);
+ if matches!(ignore_mode(flags), IgnoreMode::Unicode) {
+ for extra in extra_cases(lower) {
+ emit(codes, SreOpcode::LITERAL);
+ codes.push(*extra);
+ }
+ }
+ }
+ SetOp::Range(low, high) => {
+ emit(
+ codes,
+ if matches!(ignore_mode(flags), IgnoreMode::Unicode) {
+ SreOpcode::RANGE_UNI_IGNORE
+ } else {
+ SreOpcode::RANGE
+ },
+ );
+ codes.extend([*low, *high]);
+ }
+ SetOp::Category(value) => {
+ emit(codes, SreOpcode::CATEGORY);
+ codes.push(map_category(*value, flags));
+ }
+ }
+ }
+ emit(codes, SreOpcode::FAILURE);
+ codes[skip] = (codes.len() - skip) as u32;
+}
+
+fn map_at(value: u32, flags: u16) -> u32 {
+ if flags & FLAG_MULTILINE != 0 {
+ if value == SreAtCode::BEGINNING as u32 {
+ return SreAtCode::BEGINNING_LINE as u32;
+ }
+ if value == SreAtCode::END as u32 {
+ return SreAtCode::END_LINE as u32;
+ }
+ }
+ if flags & FLAG_UNICODE != 0 {
+ if value == SreAtCode::BOUNDARY as u32 {
+ return SreAtCode::UNI_BOUNDARY as u32;
+ }
+ if value == SreAtCode::NON_BOUNDARY as u32 {
+ return SreAtCode::UNI_NON_BOUNDARY as u32;
+ }
+ }
+ value
+}
+
+fn map_category(value: u32, flags: u16) -> u32 {
+ if flags & FLAG_UNICODE == 0 {
+ return value;
+ }
+ match value {
+ x if x == SreCatCode::DIGIT as u32 => SreCatCode::UNI_DIGIT as u32,
+ x if x == SreCatCode::NOT_DIGIT as u32 => SreCatCode::UNI_NOT_DIGIT as u32,
+ x if x == SreCatCode::SPACE as u32 => SreCatCode::UNI_SPACE as u32,
+ x if x == SreCatCode::NOT_SPACE as u32 => SreCatCode::UNI_NOT_SPACE as u32,
+ x if x == SreCatCode::WORD as u32 => SreCatCode::UNI_WORD as u32,
+ x if x == SreCatCode::NOT_WORD as u32 => SreCatCode::UNI_NOT_WORD as u32,
+ x if x == SreCatCode::LINEBREAK as u32 => SreCatCode::UNI_LINEBREAK as u32,
+ x if x == SreCatCode::NOT_LINEBREAK as u32 => SreCatCode::UNI_NOT_LINEBREAK as u32,
+ _ => value,
+ }
+}
+
+fn extra_cases(value: u32) -> &'static [u32] {
+ match value {
+ 0x0069 => &[0x0131],
+ 0x0073 => &[0x017f],
+ 0x00b5 => &[0x03bc],
+ 0x0131 => &[0x0069],
+ 0x017f => &[0x0073],
+ 0x0345 => &[0x03b9, 0x1fbe],
+ 0x0390 => &[0x1fd3],
+ 0x03b0 => &[0x1fe3],
+ 0x03b2 => &[0x03d0],
+ 0x03b5 => &[0x03f5],
+ 0x03b8 => &[0x03d1],
+ 0x03b9 => &[0x0345, 0x1fbe],
+ 0x03ba => &[0x03f0],
+ 0x03bc => &[0x00b5],
+ 0x03c0 => &[0x03d6],
+ 0x03c1 => &[0x03f1],
+ 0x03c2 => &[0x03c3],
+ 0x03c3 => &[0x03c2],
+ 0x03c6 => &[0x03d5],
+ 0x03d0 => &[0x03b2],
+ 0x03d1 => &[0x03b8],
+ 0x03d5 => &[0x03c6],
+ 0x03d6 => &[0x03c0],
+ 0x03f0 => &[0x03ba],
+ 0x03f1 => &[0x03c1],
+ 0x03f5 => &[0x03b5],
+ 0x0432 => &[0x1c80],
+ 0x0434 => &[0x1c81],
+ 0x043e => &[0x1c82],
+ 0x0441 => &[0x1c83],
+ 0x0442 => &[0x1c84, 0x1c85],
+ 0x044a => &[0x1c86],
+ 0x0463 => &[0x1c87],
+ 0x1c80 => &[0x0432],
+ 0x1c81 => &[0x0434],
+ 0x1c82 => &[0x043e],
+ 0x1c83 => &[0x0441],
+ 0x1c84 => &[0x0442, 0x1c85],
+ 0x1c85 => &[0x0442, 0x1c84],
+ 0x1c86 => &[0x044a],
+ 0x1c87 => &[0x0463],
+ 0x1c88 => &[0xa64b],
+ 0x1e61 => &[0x1e9b],
+ 0x1e9b => &[0x1e61],
+ 0x1fbe => &[0x0345, 0x03b9],
+ 0x1fd3 => &[0x0390],
+ 0x1fe3 => &[0x03b0],
+ 0xa64b => &[0x1c88],
+ 0xfb05 => &[0xfb06],
+ 0xfb06 => &[0xfb05],
+ _ => &[],
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{Request, SearchIter, State, StrDrive};
+
+ fn findall(pattern: &str, text: &str, ignore_case: bool) -> Vec<Vec<String>> {
+ let compiled = compile(pattern, ignore_case).unwrap();
+ let req = Request::new(text, 0, text.count(), &compiled.codes, false);
+ let mut iter = SearchIter {
+ req,
+ state: State::default(),
+ };
+ let chars: Vec<char> = text.chars().collect();
+ let mut matches = Vec::new();
+ while iter.next().is_some() {
+ let mut groups = Vec::new();
+ if compiled.groups == 0 {
+ groups.push(
+ chars[iter.state.start..iter.state.cursor.position]
+ .iter()
+ .collect(),
+ );
+ } else {
+ for group in 0..compiled.groups {
+ let (start, end) = iter.state.marks.get(group);
+ groups.push(match (start.into_option(), end.into_option()) {
+ (Some(start), Some(end)) => chars[start..end].iter().collect(),
+ _ => String::new(),
+ });
+ }
+ }
+ matches.push(groups);
+ }
+ matches
+ }
+
+ #[test]
+ fn compiles_cpython_312_constructs() {
+ for pattern in [
+ r"\d+",
+ r"(a)|(b)",
+ r"apple(?= pie)",
+ r"(?P<x>a)(?P=x)",
+ r"(?<=abc)def",
+ r"(?>x)++x",
+ r"(a)?(?(1)b|c)",
+ r"\N{EM DASH}",
+ ] {
+ let compiled = compile(pattern, pattern.contains("apple")).unwrap();
+ assert_eq!(compiled.codes[0], SreOpcode::INFO as u32);
+ assert_eq!(*compiled.codes.last().unwrap(), SreOpcode::SUCCESS as u32);
+ }
+ }
+
+ #[test]
+ fn maps_cpython_312_errors() {
+ for (pattern, error) in [
+ ("(", "missing ), unterminated subpattern at position 0"),
+ ("[", "unterminated character set at position 0"),
+ ("*", "nothing to repeat at position 0"),
+ (r"\x", r"incomplete escape \x at position 0"),
+ (
+ "a(?i)b",
+ "global flags not at the start of the expression at position 1",
+ ),
+ ("(?<=a*)b", "look-behind requires fixed-width pattern"),
+ (r"\1", "invalid group reference 1 at position 1"),
+ ("[z-a]", "bad character range z-a at position 1"),
+ ("a{4,2}", "min repeat greater than max repeat at position 2"),
+ ] {
+ assert_eq!(
+ compile(pattern, false).unwrap_err().to_string(),
+ error,
+ "{pattern}"
+ );
+ }
+ }
+
+ #[test]
+ fn executes_cpython_312_findall_semantics() {
+ assert_eq!(
+ findall(r"\d+", "price 42 then 99", false),
+ vec![vec![String::from("42")], vec![String::from("99")]]
+ );
+ assert_eq!(
+ findall(r"(a)|(b)", "ab", false),
+ vec![
+ vec![String::from("a"), String::new()],
+ vec![String::new(), String::from("b")]
+ ]
+ );
+ assert_eq!(
+ findall(r"apple(?= pie)", "APPLE PIE apple tart", true),
+ vec![vec![String::from("APPLE")]]
+ );
+ assert_eq!(
+ findall(r"(?P<x>a)(?P=x)", "zaa", false),
+ vec![vec![String::from("a")]]
+ );
+ assert_eq!(
+ findall(r"price (\d+)", "price 42 then price 99", false),
+ vec![vec![String::from("42")], vec![String::from("99")]]
+ );
+ assert_eq!(
+ findall(r"(\w+)=(\d+)", "a=1 b=2", false),
+ vec![
+ vec![String::from("a"), String::from("1")],
+ vec![String::from("b"), String::from("2")]
+ ]
+ );
+ assert_eq!(
+ findall(r"(?<=abc)def", "abcdef", false),
+ vec![vec![String::from("def")]]
+ );
+ assert_eq!(
+ findall(r"\N{EM DASH}", "x—y", false),
+ vec![vec![String::from("—")]]
+ );
+ }
+
+ #[test]
+ fn minimized_cpython_312_differential_regressions() {
+ assert_eq!(findall(r"\d", "٣", false), vec![vec![String::from("٣")]]);
+ assert_eq!(
+ findall("[a-z]", "İıſK", true),
+ vec![
+ vec![String::from("İ")],
+ vec![String::from("ı")],
+ vec![String::from("ſ")],
+ vec![String::from("K")],
+ ]
+ );
+
+ // CPython 3.12 compiles a scoped ASCII set correctly for matching,
+ // but its INFO search charset uses the outer Unicode flags.
+ assert!(findall(r"(?a:\W)", "Ω", false).is_empty());
+
+ assert_eq!(
+ findall(r"(?:a?)*", "a", false),
+ vec![vec![String::from("a")], vec![String::new()]]
+ );
+ assert_eq!(
+ findall(r"(?=(a+))", "aa", false),
+ vec![vec![String::from("aa")], vec![String::from("a")]]
+ );
+ assert!(findall(r"a*+a", "aaa", false).is_empty());
+
+ assert_eq!(
+ compile("(?P<x>a)(?P<x>b)", false).unwrap_err().to_string(),
+ "redefinition of group name 'x' as group 2; was group 1 at position 12"
+ );
+ }
+}
diff --git a/browser/vendor/rustpython-sre_engine/src/constants.rs b/browser/vendor/rustpython-sre_engine/src/constants.rs
new file mode 100644
index 000000000..b38ecb109
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/src/constants.rs
@@ -0,0 +1,130 @@
+/*
+ * Secret Labs' Regular Expression Engine
+ *
+ * regular expression matching engine
+ *
+ * Auto-generated by scripts/generate_sre_constants.py from
+ * Lib/re/_constants.py.
+ *
+ * Copyright (c) 1997-2001 by Secret Labs AB. All rights reserved.
+ *
+ * See the sre.c file for information on usage and redistribution.
+ */
+
+use bitflags::bitflags;
+
+pub const SRE_MAGIC: usize = 20230612;
+
+#[allow(non_camel_case_types, clippy::upper_case_acronyms)]
+#[derive(num_enum::TryFromPrimitive, Copy, Clone, Debug, PartialEq, Eq)]
+#[repr(u32)]
+pub enum SreOpcode {
+ FAILURE = 0,
+ SUCCESS = 1,
+ ANY = 2,
+ ANY_ALL = 3,
+ ASSERT = 4,
+ ASSERT_NOT = 5,
+ AT = 6,
+ BRANCH = 7,
+ CATEGORY = 8,
+ CHARSET = 9,
+ BIGCHARSET = 10,
+ GROUPREF = 11,
+ GROUPREF_EXISTS = 12,
+ IN = 13,
+ INFO = 14,
+ JUMP = 15,
+ LITERAL = 16,
+ MARK = 17,
+ MAX_UNTIL = 18,
+ MIN_UNTIL = 19,
+ NOT_LITERAL = 20,
+ NEGATE = 21,
+ RANGE = 22,
+ REPEAT = 23,
+ REPEAT_ONE = 24,
+ SUBPATTERN = 25,
+ MIN_REPEAT_ONE = 26,
+ ATOMIC_GROUP = 27,
+ POSSESSIVE_REPEAT = 28,
+ POSSESSIVE_REPEAT_ONE = 29,
+ GROUPREF_IGNORE = 30,
+ IN_IGNORE = 31,
+ LITERAL_IGNORE = 32,
+ NOT_LITERAL_IGNORE = 33,
+ GROUPREF_LOC_IGNORE = 34,
+ IN_LOC_IGNORE = 35,
+ LITERAL_LOC_IGNORE = 36,
+ NOT_LITERAL_LOC_IGNORE = 37,
+ GROUPREF_UNI_IGNORE = 38,
+ IN_UNI_IGNORE = 39,
+ LITERAL_UNI_IGNORE = 40,
+ NOT_LITERAL_UNI_IGNORE = 41,
+ RANGE_UNI_IGNORE = 42,
+}
+
+#[allow(non_camel_case_types, clippy::upper_case_acronyms)]
+#[derive(num_enum::TryFromPrimitive, Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(u32)]
+pub enum SreAtCode {
+ BEGINNING = 0,
+ BEGINNING_LINE = 1,
+ BEGINNING_STRING = 2,
+ BOUNDARY = 3,
+ NON_BOUNDARY = 4,
+ END = 5,
+ END_LINE = 6,
+ END_STRING = 7,
+ LOC_BOUNDARY = 8,
+ LOC_NON_BOUNDARY = 9,
+ UNI_BOUNDARY = 10,
+ UNI_NON_BOUNDARY = 11,
+}
+
+#[allow(non_camel_case_types, clippy::upper_case_acronyms)]
+#[derive(num_enum::TryFromPrimitive, Clone, Copy, Debug)]
+#[repr(u32)]
+pub enum SreCatCode {
+ DIGIT = 0,
+ NOT_DIGIT = 1,
+ SPACE = 2,
+ NOT_SPACE = 3,
+ WORD = 4,
+ NOT_WORD = 5,
+ LINEBREAK = 6,
+ NOT_LINEBREAK = 7,
+ LOC_WORD = 8,
+ LOC_NOT_WORD = 9,
+ UNI_DIGIT = 10,
+ UNI_NOT_DIGIT = 11,
+ UNI_SPACE = 12,
+ UNI_NOT_SPACE = 13,
+ UNI_WORD = 14,
+ UNI_NOT_WORD = 15,
+ UNI_LINEBREAK = 16,
+ UNI_NOT_LINEBREAK = 17,
+}
+
+bitflags! {
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+ pub struct SreFlag: u16 {
+ const IGNORECASE = 2;
+ const LOCALE = 4;
+ const MULTILINE = 8;
+ const DOTALL = 16;
+ const UNICODE = 32;
+ const VERBOSE = 64;
+ const DEBUG = 128;
+ const ASCII = 256;
+ }
+}
+
+bitflags! {
+ #[derive(Clone, Copy)]
+ pub struct SreInfo: u32 {
+ const PREFIX = 1;
+ const LITERAL = 2;
+ const CHARSET = 4;
+ }
+}
diff --git a/browser/vendor/rustpython-sre_engine/src/engine.rs b/browser/vendor/rustpython-sre_engine/src/engine.rs
new file mode 100644
index 000000000..759744c77
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/src/engine.rs
@@ -0,0 +1,1423 @@
+// good luck to those that follow; here be dragons
+
+use crate::string::{
+ is_digit, is_linebreak, is_loc_word, is_space, is_uni_digit, is_uni_linebreak, is_uni_space,
+ is_uni_word, is_word, lower_ascii, lower_locate, lower_unicode, upper_locate, upper_unicode,
+};
+
+use super::{MAXREPEAT, SreAtCode, SreCatCode, SreInfo, SreOpcode, StrDrive, StringCursor};
+use alloc::{vec, vec::Vec};
+use core::{convert::TryFrom, ptr::null};
+use optional::Optioned;
+
+#[derive(Debug, Clone, Copy)]
+pub struct Request<'a, S> {
+ pub string: S,
+ pub start: usize,
+ pub end: usize,
+ pub pattern_codes: &'a [u32],
+ pub match_all: bool,
+ pub must_advance: bool,
+}
+
+impl<'a, S: StrDrive> Request<'a, S> {
+ pub fn new(
+ string: S,
+ start: usize,
+ end: usize,
+ pattern_codes: &'a [u32],
+ match_all: bool,
+ ) -> Self {
+ let end = core::cmp::min(end, string.count());
+ let start = core::cmp::min(start, end);
+
+ Self {
+ string,
+ start,
+ end,
+ pattern_codes,
+ match_all,
+ must_advance: false,
+ }
+ }
+}
+
+#[derive(Debug)]
+pub struct Marks {
+ last_index: isize,
+ marks: Vec<Optioned<usize>>,
+ marks_stack: Vec<(Vec<Optioned<usize>>, isize)>,
+}
+
+impl Default for Marks {
+ fn default() -> Self {
+ Self {
+ last_index: -1,
+ marks: Vec::new(),
+ marks_stack: Vec::new(),
+ }
+ }
+}
+
+impl Marks {
+ pub fn get(&self, group_index: usize) -> (Optioned<usize>, Optioned<usize>) {
+ let marks_index = 2 * group_index;
+ if marks_index + 1 < self.marks.len() {
+ (self.marks[marks_index], self.marks[marks_index + 1])
+ } else {
+ (Optioned::none(), Optioned::none())
+ }
+ }
+
+ pub const fn last_index(&self) -> isize {
+ self.last_index
+ }
+
+ pub fn raw(&self) -> &[Optioned<usize>] {
+ self.marks.as_slice()
+ }
+
+ fn set(&mut self, mark_nr: usize, position: usize) {
+ if mark_nr & 1 != 0 {
+ self.last_index = mark_nr as isize / 2 + 1;
+ }
+ if mark_nr >= self.marks.len() {
+ self.marks.resize(mark_nr + 1, Optioned::none());
+ }
+ self.marks[mark_nr] = Optioned::some(position);
+ }
+
+ fn push(&mut self) {
+ self.marks_stack.push((self.marks.clone(), self.last_index));
+ }
+
+ fn pop(&mut self) {
+ let (marks, last_index) = self.marks_stack.pop().unwrap();
+ self.marks = marks;
+ self.last_index = last_index;
+ }
+
+ fn pop_keep(&mut self) {
+ let (marks, last_index) = self.marks_stack.last().unwrap().clone();
+ self.marks = marks;
+ self.last_index = last_index;
+ }
+
+ fn pop_discard(&mut self) {
+ self.marks_stack.pop();
+ }
+
+ fn clear(&mut self) {
+ self.last_index = -1;
+ self.marks.clear();
+ self.marks_stack.clear();
+ }
+}
+
+#[derive(Debug, Default)]
+pub struct State {
+ pub start: usize,
+ pub marks: Marks,
+ pub cursor: StringCursor,
+ repeat_stack: Vec<RepeatContext>,
+}
+
+impl State {
+ pub fn reset<S: StrDrive>(&mut self, req: &Request<'_, S>, start: usize) {
+ self.marks.clear();
+ self.repeat_stack.clear();
+ self.start = start;
+ req.string.adjust_cursor(&mut self.cursor, start);
+ }
+
+ pub fn py_match<S: StrDrive>(&mut self, req: &Request<'_, S>) -> bool {
+ self.start = req.start;
+ req.string.adjust_cursor(&mut self.cursor, self.start);
+
+ let ctx = MatchContext {
+ cursor: self.cursor,
+ code_position: 0,
+ toplevel: true,
+ jump: Jump::OpCode,
+ repeat_ctx_id: usize::MAX,
+ count: -1,
+ };
+ _match(req, self, ctx)
+ }
+
+ pub fn search<S: StrDrive>(&mut self, mut req: Request<'_, S>) -> bool {
+ self.start = req.start;
+ req.string.adjust_cursor(&mut self.cursor, self.start);
+
+ if req.start > req.end {
+ return false;
+ }
+
+ let mut end = req.end;
+
+ let mut ctx = MatchContext {
+ cursor: self.cursor,
+ code_position: 0,
+ toplevel: true,
+ jump: Jump::OpCode,
+ repeat_ctx_id: usize::MAX,
+ count: -1,
+ };
+
+ if ctx.peek_code(&req, 0) == SreOpcode::INFO as u32 {
+ /* optimization info block */
+ /* <INFO> <1=skip> <2=flags> <3=min> <4=max> <5=prefix info> */
+ let min = ctx.peek_code(&req, 3) as usize;
+
+ if ctx.remaining_chars(&req) < min {
+ return false;
+ }
+
+ if min > 1 {
+ /* adjust end point (but make sure we leave at least one
+ character in there, so literal search will work) */
+ // no overflow can happen as remaining chars >= min
+ end -= min - 1;
+
+ // adjust ctx position
+ if end < ctx.cursor.position {
+ let skip = end - self.cursor.position;
+ S::skip(&mut self.cursor, skip);
+ }
+ }
+
+ let flags = SreInfo::from_bits_truncate(ctx.peek_code(&req, 2));
+
+ if flags.contains(SreInfo::PREFIX) {
+ if flags.contains(SreInfo::LITERAL) {
+ return search_info_literal::<true, S>(&mut req, self, ctx);
+ } else {
+ return search_info_literal::<false, S>(&mut req, self, ctx);
+ }
+ } else if flags.contains(SreInfo::CHARSET) {
+ return search_info_charset(&mut req, self, ctx);
+ }
+ // fallback to general search
+ // skip OP INFO
+ ctx.skip_code_from(&req, 1);
+ }
+
+ if _match(&req, self, ctx) {
+ return true;
+ }
+
+ if ctx.try_peek_code_as::<SreOpcode, _>(&req, 0).unwrap() == SreOpcode::AT
+ && (ctx.try_peek_code_as::<SreAtCode, _>(&req, 1).unwrap() == SreAtCode::BEGINNING
+ || ctx.try_peek_code_as::<SreAtCode, _>(&req, 1).unwrap()
+ == SreAtCode::BEGINNING_STRING)
+ {
+ self.cursor.position = req.end;
+ self.cursor.ptr = null();
+ // self.reset(&req, req.end);
+ return false;
+ }
+
+ req.must_advance = false;
+ ctx.toplevel = false;
+ while req.start < end {
+ req.start += 1;
+ self.reset(&req, req.start);
+ ctx.cursor = self.cursor;
+
+ if _match(&req, self, ctx) {
+ return true;
+ }
+ }
+ false
+ }
+}
+
+pub struct SearchIter<'a, S: StrDrive> {
+ pub req: Request<'a, S>,
+ pub state: State,
+}
+
+impl<S: StrDrive> Iterator for SearchIter<'_, S> {
+ type Item = ();
+
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.req.start > self.req.end {
+ return None;
+ }
+
+ self.state.reset(&self.req, self.req.start);
+ if !self.state.search(self.req) {
+ return None;
+ }
+
+ self.req.must_advance = self.state.cursor.position == self.state.start;
+ self.req.start = self.state.cursor.position;
+
+ Some(())
+ }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum Jump {
+ OpCode,
+ Assert1,
+ AssertNot1,
+ Branch1,
+ Branch2,
+ Repeat1,
+ UntilBacktrace,
+ MaxUntil2,
+ MaxUntil3,
+ MinUntil1,
+ RepeatOne1,
+ RepeatOne2,
+ MinRepeatOne1,
+ MinRepeatOne2,
+ AtomicGroup1,
+ PossessiveRepeat1,
+ PossessiveRepeat2,
+ PossessiveRepeat3,
+ PossessiveRepeat4,
+}
+
+fn _match<S: StrDrive>(req: &Request<'_, S>, state: &mut State, mut ctx: MatchContext) -> bool {
+ let mut context_stack = vec![];
+ let mut popped_result = false;
+
+ #[allow(
+ clippy::never_loop,
+ reason = "'result loop is not an actual loop but break label"
+ )]
+ 'coro: loop {
+ popped_result = 'result: loop {
+ let yielded = 'context: loop {
+ match ctx.jump {
+ Jump::OpCode => {}
+ Jump::Assert1 => {
+ if popped_result {
+ ctx.skip_code_from(req, 1);
+ } else {
+ break 'result false;
+ }
+ }
+ Jump::AssertNot1 => {
+ if popped_result {
+ break 'result false;
+ }
+ state.marks.pop();
+ ctx.skip_code_from(req, 1);
+ }
+ Jump::Branch1 => {
+ let branch_offset = ctx.count as usize;
+ let next_length = ctx.peek_code(req, branch_offset) as isize;
+ if next_length == 0 {
+ state.marks.pop_discard();
+ break 'result false;
+ }
+ state.cursor = ctx.cursor;
+ let next_ctx = ctx.next_offset(branch_offset + 1, Jump::Branch2);
+ ctx.count += next_length;
+ break 'context next_ctx;
+ }
+ Jump::Branch2 => {
+ if popped_result {
+ break 'result true;
+ }
+ state.marks.pop_keep();
+ ctx.jump = Jump::Branch1;
+ continue 'context;
+ }
+ Jump::Repeat1 => {
+ state.repeat_stack.pop();
+ break 'result popped_result;
+ }
+ Jump::UntilBacktrace => {
+ if !popped_result {
+ state.repeat_stack[ctx.repeat_ctx_id].count -= 1;
+ state.cursor = ctx.cursor;
+ }
+ break 'result popped_result;
+ }
+ Jump::MaxUntil2 => {
+ let save_last_position = ctx.count as usize;
+ let repeat_ctx = &mut state.repeat_stack[ctx.repeat_ctx_id];
+ repeat_ctx.last_position = save_last_position;
+
+ if popped_result {
+ state.marks.pop_discard();
+ break 'result true;
+ }
+
+ state.marks.pop();
+ repeat_ctx.count -= 1;
+ state.cursor = ctx.cursor;
+
+ /* cannot match more repeated items here. make sure the
+ tail matches */
+ let mut next_ctx = ctx.next_offset(1, Jump::MaxUntil3);
+ next_ctx.repeat_ctx_id = repeat_ctx.prev_id;
+ break 'context next_ctx;
+ }
+ Jump::MaxUntil3 => {
+ if !popped_result {
+ state.cursor = ctx.cursor;
+ }
+ break 'result popped_result;
+ }
+ Jump::MinUntil1 => {
+ if popped_result {
+ break 'result true;
+ }
+ ctx.repeat_ctx_id = ctx.count as usize;
+ let repeat_ctx = &mut state.repeat_stack[ctx.repeat_ctx_id];
+ state.cursor = ctx.cursor;
+ state.marks.pop();
+
+ // match more until tail matches
+ if repeat_ctx.count as usize >= repeat_ctx.max_count
+ && repeat_ctx.max_count != MAXREPEAT
+ || state.cursor.position == repeat_ctx.last_position
+ {
+ repeat_ctx.count -= 1;
+ break 'result false;
+ }
+
+ /* zero-width match protection */
+ repeat_ctx.last_position = state.cursor.position;
+
+ break 'context ctx
+ .next_at(repeat_ctx.code_position + 4, Jump::UntilBacktrace);
+ }
+ Jump::RepeatOne1 => {
+ let min_count = ctx.peek_code(req, 2) as isize;
+ let next_code = ctx.peek_code(req, ctx.peek_code(req, 1) as usize + 1);
+ if next_code == SreOpcode::LITERAL as u32 {
+ // Special case: Tail starts with a literal. Skip positions where
+ // the rest of the pattern cannot possibly match.
+ let c = ctx.peek_code(req, ctx.peek_code(req, 1) as usize + 2);
+ while ctx.at_end(req) || ctx.peek_char::<S>() != c {
+ if ctx.count <= min_count {
+ state.marks.pop_discard();
+ break 'result false;
+ }
+ ctx.back_advance_char::<S>();
+ ctx.count -= 1;
+ }
+ }
+
+ state.cursor = ctx.cursor;
+ // General case: backtracking
+ break 'context ctx.next_peek_from(1, req, Jump::RepeatOne2);
+ }
+ Jump::RepeatOne2 => {
+ if popped_result {
+ break 'result true;
+ }
+
+ let min_count = ctx.peek_code(req, 2) as isize;
+ if ctx.count <= min_count {
+ state.marks.pop_discard();
+ break 'result false;
+ }
+
+ ctx.back_advance_char::<S>();
+ ctx.count -= 1;
+
+ state.marks.pop_keep();
+ ctx.jump = Jump::RepeatOne1;
+ continue 'context;
+ }
+ Jump::MinRepeatOne1 => {
+ let max_count = ctx.peek_code(req, 3) as usize;
+ if max_count == MAXREPEAT || ctx.count as usize <= max_count {
+ state.cursor = ctx.cursor;
+ break 'context ctx.next_peek_from(1, req, Jump::MinRepeatOne2);
+ } else {
+ state.marks.pop_discard();
+ break 'result false;
+ }
+ }
+ Jump::MinRepeatOne2 => {
+ if popped_result {
+ break 'result true;
+ }
+
+ state.cursor = ctx.cursor;
+
+ let mut count_ctx = ctx;
+ count_ctx.skip_code(4);
+ if _count(req, state, &mut count_ctx, 1) == 0 {
+ state.marks.pop_discard();
+ break 'result false;
+ }
+
+ ctx.advance_char::<S>();
+ ctx.count += 1;
+ state.marks.pop_keep();
+ ctx.jump = Jump::MinRepeatOne1;
+ continue 'context;
+ }
+ Jump::AtomicGroup1 => {
+ if popped_result {
+ ctx.skip_code_from(req, 1);
+ ctx.cursor = state.cursor;
+ // dispatch opcode
+ } else {
+ state.cursor = ctx.cursor;
+ break 'result false;
+ }
+ }
+ Jump::PossessiveRepeat1 => {
+ let min_count = ctx.peek_code(req, 2) as isize;
+ if ctx.count < min_count {
+ // modified next.toplevel from inherited to false
+ let mut next = ctx.next_offset(4, Jump::PossessiveRepeat2);
+ next.toplevel = false;
+ break 'context next;
+ }
+ // zero match protection
+ ctx.cursor.position = usize::MAX;
+ ctx.jump = Jump::PossessiveRepeat3;
+ continue 'context;
+ }
+ Jump::PossessiveRepeat2 => {
+ if popped_result {
+ ctx.count += 1;
+ ctx.jump = Jump::PossessiveRepeat1;
+ continue 'context;
+ } else {
+ state.cursor = ctx.cursor;
+ break 'result false;
+ }
+ }
+ Jump::PossessiveRepeat3 => {
+ let max_count = ctx.peek_code(req, 3) as usize;
+ if ((ctx.count as usize) < max_count || max_count == MAXREPEAT)
+ && ctx.cursor.position != state.cursor.position
+ {
+ state.marks.push();
+ ctx.cursor = state.cursor;
+ let mut next = ctx.next_offset(4, Jump::PossessiveRepeat4);
+ next.toplevel = false; // modified next.toplevel from inherited to false
+ break 'context next;
+ }
+ ctx.cursor = state.cursor;
+ ctx.skip_code_from(req, 1);
+ ctx.skip_code(1);
+ }
+ Jump::PossessiveRepeat4 => {
+ if popped_result {
+ state.marks.pop_discard();
+ ctx.count += 1;
+ ctx.jump = Jump::PossessiveRepeat3;
+ continue 'context;
+ }
+ state.marks.pop();
+ state.cursor = ctx.cursor;
+ ctx.skip_code_from(req, 1);
+ ctx.skip_code(1);
+ }
+ }
+ ctx.jump = Jump::OpCode;
+
+ loop {
+ macro_rules! general_op_literal {
+ ($f:expr) => {{
+ #[allow(clippy::redundant_closure_call)]
+ if ctx.at_end(req) || !$f(ctx.peek_code(req, 1), ctx.peek_char::<S>()) {
+ break 'result false;
+ }
+ ctx.skip_code(2);
+ ctx.advance_char::<S>();
+ }};
+ }
+
+ macro_rules! general_op_in {
+ ($f:expr) => {{
+ #[allow(clippy::redundant_closure_call)]
+ if ctx.at_end(req) || !$f(&ctx.pattern(req)[2..], ctx.peek_char::<S>())
+ {
+ break 'result false;
+ }
+ ctx.skip_code_from(req, 1);
+ ctx.advance_char::<S>();
+ }};
+ }
+
+ macro_rules! general_op_groupref {
+ ($f:expr) => {{
+ let (group_start, group_end) =
+ state.marks.get(ctx.peek_code(req, 1) as usize);
+ let (group_start, group_end) = if group_start.is_some()
+ && group_end.is_some()
+ && group_start.unpack() <= group_end.unpack()
+ {
+ (group_start.unpack(), group_end.unpack())
+ } else {
+ break 'result false;
+ };
+
+ let mut g_ctx = MatchContext {
+ cursor: req.string.create_cursor(group_start),
+ ..ctx
+ };
+
+ for _ in group_start..group_end {
+ #[allow(clippy::redundant_closure_call)]
+ if ctx.at_end(req)
+ || $f(ctx.peek_char::<S>()) != $f(g_ctx.peek_char::<S>())
+ {
+ break 'result false;
+ }
+ ctx.advance_char::<S>();
+ g_ctx.advance_char::<S>();
+ }
+
+ ctx.skip_code(2);
+ }};
+ }
+
+ if ctx.remaining_codes(req) == 0 {
+ break 'result false;
+ }
+ let opcode = ctx.peek_code(req, 0);
+ let opcode = SreOpcode::try_from(opcode).unwrap();
+
+ match opcode {
+ SreOpcode::FAILURE => break 'result false,
+ SreOpcode::SUCCESS => {
+ if ctx.can_success(req) {
+ state.cursor = ctx.cursor;
+ break 'result true;
+ }
+ break 'result false;
+ }
+ SreOpcode::ANY => {
+ if ctx.at_end(req) || ctx.at_linebreak(req) {
+ break 'result false;
+ }
+ ctx.skip_code(1);
+ ctx.advance_char::<S>();
+ }
+ SreOpcode::ANY_ALL => {
+ if ctx.at_end(req) {
+ break 'result false;
+ }
+ ctx.skip_code(1);
+ ctx.advance_char::<S>();
+ }
+ /* <ASSERT> <skip> <back> <pattern> */
+ SreOpcode::ASSERT => {
+ let back = ctx.peek_code(req, 2) as usize;
+ if ctx.cursor.position < back {
+ break 'result false;
+ }
+
+ let mut next_ctx = ctx.next_offset(3, Jump::Assert1);
+ next_ctx.toplevel = false;
+ next_ctx.back_skip_char::<S>(back);
+ state.cursor = next_ctx.cursor;
+ break 'context next_ctx;
+ }
+ /* <ASSERT_NOT> <skip> <back> <pattern> */
+ SreOpcode::ASSERT_NOT => {
+ let back = ctx.peek_code(req, 2) as usize;
+ if ctx.cursor.position < back {
+ ctx.skip_code_from(req, 1);
+ continue;
+ }
+ state.marks.push();
+
+ let mut next_ctx = ctx.next_offset(3, Jump::AssertNot1);
+ next_ctx.toplevel = false;
+ next_ctx.back_skip_char::<S>(back);
+ state.cursor = next_ctx.cursor;
+ break 'context next_ctx;
+ }
+ SreOpcode::AT => {
+ let at_code = SreAtCode::try_from(ctx.peek_code(req, 1)).unwrap();
+ if at(req, &ctx, at_code) {
+ ctx.skip_code(2);
+ } else {
+ break 'result false;
+ }
+ }
+ // <BRANCH> <0=skip> code <JUMP> ... <NULL>
+ SreOpcode::BRANCH => {
+ state.marks.push();
+ ctx.count = 1;
+ ctx.jump = Jump::Branch1;
+ continue 'context;
+ }
+ SreOpcode::CATEGORY => {
+ let cat_code = SreCatCode::try_from(ctx.peek_code(req, 1)).unwrap();
+ if ctx.at_end(req) || !category(cat_code, ctx.peek_char::<S>()) {
+ break 'result false;
+ }
+ ctx.skip_code(2);
+ ctx.advance_char::<S>();
+ }
+ SreOpcode::IN => general_op_in!(charset),
+ SreOpcode::IN_IGNORE => {
+ general_op_in!(|set, c| charset(set, lower_ascii(c)))
+ }
+ SreOpcode::IN_UNI_IGNORE => {
+ general_op_in!(|set, c| charset(set, lower_unicode(c)))
+ }
+ SreOpcode::IN_LOC_IGNORE => general_op_in!(charset_loc_ignore),
+ SreOpcode::MARK => {
+ state
+ .marks
+ .set(ctx.peek_code(req, 1) as usize, ctx.cursor.position);
+ ctx.skip_code(2);
+ }
+ SreOpcode::INFO | SreOpcode::JUMP => ctx.skip_code_from(req, 1),
+ /* <REPEAT> <skip> <1=min> <2=max> item <UNTIL> tail */
+ SreOpcode::REPEAT => {
+ let repeat_ctx = RepeatContext {
+ count: -1,
+ min_count: ctx.peek_code(req, 2) as usize,
+ max_count: ctx.peek_code(req, 3) as usize,
+ code_position: ctx.code_position,
+ last_position: usize::MAX,
+ prev_id: ctx.repeat_ctx_id,
+ };
+ state.repeat_stack.push(repeat_ctx);
+ let repeat_ctx_id = state.repeat_stack.len() - 1;
+ state.cursor = ctx.cursor;
+ let mut next_ctx = ctx.next_peek_from(1, req, Jump::Repeat1);
+ next_ctx.repeat_ctx_id = repeat_ctx_id;
+ break 'context next_ctx;
+ }
+ SreOpcode::MAX_UNTIL => {
+ let repeat_ctx = &mut state.repeat_stack[ctx.repeat_ctx_id];
+ state.cursor = ctx.cursor;
+ repeat_ctx.count += 1;
+
+ if (repeat_ctx.count as usize) < repeat_ctx.min_count {
+ // not enough matches
+ break 'context ctx
+ .next_at(repeat_ctx.code_position + 4, Jump::UntilBacktrace);
+ }
+
+ if ((repeat_ctx.count as usize) < repeat_ctx.max_count
+ || repeat_ctx.max_count == MAXREPEAT)
+ && state.cursor.position != repeat_ctx.last_position
+ {
+ /* we may have enough matches, but if we can
+ match another item, do so */
+ state.marks.push();
+ ctx.count = repeat_ctx.last_position as isize;
+ repeat_ctx.last_position = state.cursor.position;
+
+ break 'context ctx
+ .next_at(repeat_ctx.code_position + 4, Jump::MaxUntil2);
+ }
+
+ /* cannot match more repeated items here. make sure the
+ tail matches */
+ let mut next_ctx = ctx.next_offset(1, Jump::MaxUntil3);
+ next_ctx.repeat_ctx_id = repeat_ctx.prev_id;
+ break 'context next_ctx;
+ }
+ SreOpcode::MIN_UNTIL => {
+ let repeat_ctx = state.repeat_stack.last_mut().unwrap();
+ state.cursor = ctx.cursor;
+ repeat_ctx.count += 1;
+
+ if (repeat_ctx.count as usize) < repeat_ctx.min_count {
+ // not enough matches
+ break 'context ctx
+ .next_at(repeat_ctx.code_position + 4, Jump::UntilBacktrace);
+ }
+
+ state.marks.push();
+ ctx.count = ctx.repeat_ctx_id as isize;
+ let mut next_ctx = ctx.next_offset(1, Jump::MinUntil1);
+ next_ctx.repeat_ctx_id = repeat_ctx.prev_id;
+ break 'context next_ctx;
+ }
+ /* <REPEAT_ONE> <skip> <1=min> <2=max> item <SUCCESS> tail */
+ SreOpcode::REPEAT_ONE => {
+ let min_count = ctx.peek_code(req, 2) as usize;
+ let max_count = ctx.peek_code(req, 3) as usize;
+
+ if ctx.remaining_chars(req) < min_count {
+ break 'result false;
+ }
+
+ state.cursor = ctx.cursor;
+
+ let mut count_ctx = ctx;
+ count_ctx.skip_code(4);
+ let count = _count(req, state, &mut count_ctx, max_count);
+ if count < min_count {
+ break 'result false;
+ }
+ ctx.cursor = count_ctx.cursor;
+
+ let next_code = ctx.peek_code(req, ctx.peek_code(req, 1) as usize + 1);
+ if next_code == SreOpcode::SUCCESS as u32 && ctx.can_success(req) {
+ // tail is empty. we're finished
+ state.cursor = ctx.cursor;
+ break 'result true;
+ }
+
+ state.marks.push();
+ ctx.count = count as isize;
+ ctx.jump = Jump::RepeatOne1;
+ continue 'context;
+ }
+ /* <MIN_REPEAT_ONE> <skip> <1=min> <2=max> item <SUCCESS> tail */
+ SreOpcode::MIN_REPEAT_ONE => {
+ let min_count = ctx.peek_code(req, 2) as usize;
+ if ctx.remaining_chars(req) < min_count {
+ break 'result false;
+ }
+
+ state.cursor = ctx.cursor;
+ ctx.count = if min_count == 0 {
+ 0
+ } else {
+ let mut count_ctx = ctx;
+ count_ctx.skip_code(4);
+ let count = _count(req, state, &mut count_ctx, min_count);
+ if count < min_count {
+ break 'result false;
+ }
+ ctx.cursor = count_ctx.cursor;
+ count as isize
+ };
+
+ let next_code = ctx.peek_code(req, ctx.peek_code(req, 1) as usize + 1);
+ if next_code == SreOpcode::SUCCESS as u32 && ctx.can_success(req) {
+ // tail is empty. we're finished
+ state.cursor = ctx.cursor;
+ break 'result true;
+ }
+
+ state.marks.push();
+ ctx.jump = Jump::MinRepeatOne1;
+ continue 'context;
+ }
+ SreOpcode::LITERAL => general_op_literal!(|code, c| code == c),
+ SreOpcode::NOT_LITERAL => general_op_literal!(|code, c| code != c),
+ SreOpcode::LITERAL_IGNORE => {
+ general_op_literal!(|code, c| code == lower_ascii(c))
+ }
+ SreOpcode::NOT_LITERAL_IGNORE => {
+ general_op_literal!(|code, c| code != lower_ascii(c))
+ }
+ SreOpcode::LITERAL_UNI_IGNORE => {
+ general_op_literal!(|code, c| code == lower_unicode(c))
+ }
+ SreOpcode::NOT_LITERAL_UNI_IGNORE => {
+ general_op_literal!(|code, c| code != lower_unicode(c))
+ }
+ SreOpcode::LITERAL_LOC_IGNORE => general_op_literal!(char_loc_ignore),
+ SreOpcode::NOT_LITERAL_LOC_IGNORE => {
+ general_op_literal!(|code, c| !char_loc_ignore(code, c))
+ }
+ SreOpcode::GROUPREF => general_op_groupref!(|x| x),
+ SreOpcode::GROUPREF_IGNORE => general_op_groupref!(lower_ascii),
+ SreOpcode::GROUPREF_LOC_IGNORE => general_op_groupref!(lower_locate),
+ SreOpcode::GROUPREF_UNI_IGNORE => general_op_groupref!(lower_unicode),
+ SreOpcode::GROUPREF_EXISTS => {
+ let (group_start, group_end) =
+ state.marks.get(ctx.peek_code(req, 1) as usize);
+ if group_start.is_some()
+ && group_end.is_some()
+ && group_start.unpack() <= group_end.unpack()
+ {
+ ctx.skip_code(3);
+ } else {
+ ctx.skip_code_from(req, 2)
+ }
+ }
+ /* <ATOMIC_GROUP> <skip> pattern <SUCCESS> tail */
+ SreOpcode::ATOMIC_GROUP => {
+ state.cursor = ctx.cursor;
+ let mut next_ctx = ctx.next_offset(2, Jump::AtomicGroup1);
+ next_ctx.toplevel = false; // modified next.toplevel from inherited to false
+ break 'context next_ctx;
+ }
+ /* <POSSESSIVE_REPEAT> <skip> <1=min> <2=max> pattern
+ <SUCCESS> tail */
+ SreOpcode::POSSESSIVE_REPEAT => {
+ state.cursor = ctx.cursor;
+ ctx.count = 0;
+ ctx.jump = Jump::PossessiveRepeat1;
+ continue 'context;
+ }
+ /* <POSSESSIVE_REPEAT_ONE> <skip> <1=min> <2=max> item <SUCCESS>
+ tail */
+ SreOpcode::POSSESSIVE_REPEAT_ONE => {
+ let min_count = ctx.peek_code(req, 2) as usize;
+ let max_count = ctx.peek_code(req, 3) as usize;
+ if ctx.remaining_chars(req) < min_count {
+ break 'result false;
+ }
+ state.cursor = ctx.cursor;
+ let mut count_ctx = ctx;
+ count_ctx.skip_code(4);
+ let count = _count(req, state, &mut count_ctx, max_count);
+ if count < min_count {
+ break 'result false;
+ }
+ ctx.cursor = count_ctx.cursor;
+ ctx.skip_code_from(req, 1);
+ }
+ SreOpcode::CHARSET
+ | SreOpcode::BIGCHARSET
+ | SreOpcode::NEGATE
+ | SreOpcode::RANGE
+ | SreOpcode::RANGE_UNI_IGNORE
+ | SreOpcode::SUBPATTERN => {
+ unreachable!("unexpected opcode on main dispatch")
+ }
+ }
+ }
+ };
+ context_stack.push(ctx);
+ ctx = yielded;
+ continue 'coro;
+ };
+ if let Some(popped_ctx) = context_stack.pop() {
+ ctx = popped_ctx;
+ } else {
+ break;
+ }
+ }
+ popped_result
+}
+
+fn search_info_literal<const LITERAL: bool, S: StrDrive>(
+ req: &mut Request<'_, S>,
+ state: &mut State,
+ mut ctx: MatchContext,
+) -> bool {
+ /* pattern starts with a known prefix */
+ /* <length> <skip> <prefix data> <overlap data> */
+ let len = ctx.peek_code(req, 5) as usize;
+ let skip = ctx.peek_code(req, 6) as usize;
+ let prefix = &ctx.pattern(req)[7..7 + len];
+ let overlap = &ctx.pattern(req)[7 + len - 1..7 + len * 2];
+
+ // code_position ready for tail match
+ ctx.skip_code_from(req, 1);
+ ctx.skip_code(2 * skip);
+
+ req.must_advance = false;
+
+ if len == 1 {
+ // pattern starts with a literal character
+ let c = prefix[0];
+
+ while !ctx.at_end(req) {
+ // find the next matched literal
+ while ctx.peek_char::<S>() != c {
+ ctx.advance_char::<S>();
+ if ctx.at_end(req) {
+ return false;
+ }
+ }
+
+ req.start = ctx.cursor.position;
+ state.start = req.start;
+ state.cursor = ctx.cursor;
+ S::skip(&mut state.cursor, skip);
+
+ // literal only
+ if LITERAL {
+ return true;
+ }
+
+ let mut next_ctx = ctx;
+ next_ctx.skip_char::<S>(skip);
+
+ if _match(req, state, next_ctx) {
+ return true;
+ }
+
+ ctx.advance_char::<S>();
+ state.marks.clear();
+ }
+ } else {
+ while !ctx.at_end(req) {
+ let c = prefix[0];
+ while ctx.peek_char::<S>() != c {
+ ctx.advance_char::<S>();
+ if ctx.at_end(req) {
+ return false;
+ }
+ }
+ ctx.advance_char::<S>();
+ if ctx.at_end(req) {
+ return false;
+ }
+
+ let mut i = 1;
+ loop {
+ if ctx.peek_char::<S>() == prefix[i] {
+ i += 1;
+ if i != len {
+ ctx.advance_char::<S>();
+ if ctx.at_end(req) {
+ return false;
+ }
+ continue;
+ }
+
+ req.start = ctx.cursor.position - (len - 1);
+ state.reset(req, req.start);
+ S::skip(&mut state.cursor, skip);
+ // state.start = req.start;
+ // state.cursor = req.string.create_cursor(req.start + skip);
+
+ // literal only
+ if LITERAL {
+ return true;
+ }
+
+ let mut next_ctx = ctx;
+ if skip != 0 {
+ next_ctx.advance_char::<S>();
+ } else {
+ next_ctx.cursor = state.cursor;
+ }
+
+ if _match(req, state, next_ctx) {
+ return true;
+ }
+
+ ctx.advance_char::<S>();
+ if ctx.at_end(req) {
+ return false;
+ }
+ state.marks.clear();
+ }
+
+ i = overlap[i] as usize;
+ if i == 0 {
+ break;
+ }
+ }
+ }
+ }
+ false
+}
+
+fn search_info_charset<S: StrDrive>(
+ req: &mut Request<'_, S>,
+ state: &mut State,
+ mut ctx: MatchContext,
+) -> bool {
+ let set = &ctx.pattern(req)[5..];
+
+ ctx.skip_code_from(req, 1);
+
+ req.must_advance = false;
+
+ loop {
+ while !ctx.at_end(req) && !charset(set, ctx.peek_char::<S>()) {
+ ctx.advance_char::<S>();
+ }
+ if ctx.at_end(req) {
+ return false;
+ }
+
+ req.start = ctx.cursor.position;
+ state.start = ctx.cursor.position;
+ state.cursor = ctx.cursor;
+
+ if _match(req, state, ctx) {
+ return true;
+ }
+
+ ctx.advance_char::<S>();
+ state.marks.clear();
+ }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct RepeatContext {
+ count: isize,
+ min_count: usize,
+ max_count: usize,
+ code_position: usize,
+ last_position: usize,
+ prev_id: usize,
+}
+
+#[derive(Clone, Copy)]
+struct MatchContext {
+ cursor: StringCursor,
+ code_position: usize,
+ toplevel: bool,
+ jump: Jump,
+ repeat_ctx_id: usize,
+ count: isize,
+}
+
+impl MatchContext {
+ fn pattern<'a, S>(&self, req: &Request<'a, S>) -> &'a [u32] {
+ &req.pattern_codes[self.code_position..]
+ }
+
+ const fn remaining_codes<S>(&self, req: &Request<'_, S>) -> usize {
+ req.pattern_codes.len() - self.code_position
+ }
+
+ const fn remaining_chars<S>(&self, req: &Request<'_, S>) -> usize {
+ req.end - self.cursor.position
+ }
+
+ fn peek_char<S: StrDrive>(&self) -> u32 {
+ S::peek(&self.cursor)
+ }
+
+ fn skip_char<S: StrDrive>(&mut self, skip: usize) {
+ S::skip(&mut self.cursor, skip);
+ }
+
+ fn advance_char<S: StrDrive>(&mut self) -> u32 {
+ S::advance(&mut self.cursor)
+ }
+
+ fn back_peek_char<S: StrDrive>(&self) -> u32 {
+ S::back_peek(&self.cursor)
+ }
+
+ fn back_skip_char<S: StrDrive>(&mut self, skip: usize) {
+ S::back_skip(&mut self.cursor, skip);
+ }
+
+ fn back_advance_char<S: StrDrive>(&mut self) -> u32 {
+ S::back_advance(&mut self.cursor)
+ }
+
+ fn peek_code<S>(&self, req: &Request<'_, S>, peek: usize) -> u32 {
+ req.pattern_codes[self.code_position + peek]
+ }
+
+ fn try_peek_code_as<T, S>(&self, req: &Request<'_, S>, peek: usize) -> Result<T, T::Error>
+ where
+ T: TryFrom<u32>,
+ {
+ self.peek_code(req, peek).try_into()
+ }
+
+ const fn skip_code(&mut self, skip: usize) {
+ self.code_position += skip;
+ }
+
+ fn skip_code_from<S>(&mut self, req: &Request<'_, S>, peek: usize) {
+ self.skip_code(self.peek_code(req, peek) as usize + 1);
+ }
+
+ const fn at_beginning(&self) -> bool {
+ // self.ctx().string_position == self.state().start
+ self.cursor.position == 0
+ }
+
+ const fn at_end<S>(&self, req: &Request<'_, S>) -> bool {
+ self.cursor.position == req.end
+ }
+
+ fn at_linebreak<S: StrDrive>(&self, req: &Request<'_, S>) -> bool {
+ !self.at_end(req) && is_linebreak(self.peek_char::<S>())
+ }
+
+ fn at_boundary<S: StrDrive, F: FnMut(u32) -> bool>(
+ &self,
+ req: &Request<'_, S>,
+ mut word_checker: F,
+ ) -> bool {
+ if self.at_beginning() && self.at_end(req) {
+ return false;
+ }
+ let that = !self.at_beginning() && word_checker(self.back_peek_char::<S>());
+ let this = !self.at_end(req) && word_checker(self.peek_char::<S>());
+ this != that
+ }
+
+ fn at_non_boundary<S: StrDrive, F: FnMut(u32) -> bool>(
+ &self,
+ req: &Request<'_, S>,
+ mut word_checker: F,
+ ) -> bool {
+ if self.at_beginning() && self.at_end(req) {
+ return false;
+ }
+ let that = !self.at_beginning() && word_checker(self.back_peek_char::<S>());
+ let this = !self.at_end(req) && word_checker(self.peek_char::<S>());
+ this == that
+ }
+
+ const fn can_success<S>(&self, req: &Request<'_, S>) -> bool {
+ if !self.toplevel {
+ return true;
+ }
+ if req.match_all && !self.at_end(req) {
+ return false;
+ }
+ if req.must_advance && self.cursor.position == req.start {
+ return false;
+ }
+ true
+ }
+
+ #[must_use]
+ fn next_peek_from<S>(&mut self, peek: usize, req: &Request<'_, S>, jump: Jump) -> Self {
+ self.next_offset(self.peek_code(req, peek) as usize + 1, jump)
+ }
+
+ #[must_use]
+ const fn next_offset(&mut self, offset: usize, jump: Jump) -> Self {
+ self.next_at(self.code_position + offset, jump)
+ }
+
+ #[must_use]
+ const fn next_at(&mut self, code_position: usize, jump: Jump) -> Self {
+ self.jump = jump;
+ Self {
+ code_position,
+ jump: Jump::OpCode,
+ count: -1,
+ ..*self
+ }
+ }
+}
+
+fn at<S: StrDrive>(req: &Request<'_, S>, ctx: &MatchContext, at_code: SreAtCode) -> bool {
+ match at_code {
+ SreAtCode::BEGINNING | SreAtCode::BEGINNING_STRING => ctx.at_beginning(),
+ SreAtCode::BEGINNING_LINE => ctx.at_beginning() || is_linebreak(ctx.back_peek_char::<S>()),
+ SreAtCode::BOUNDARY => ctx.at_boundary(req, is_word),
+ SreAtCode::NON_BOUNDARY => ctx.at_non_boundary(req, is_word),
+ SreAtCode::END => {
+ (ctx.remaining_chars(req) == 1 && ctx.at_linebreak(req)) || ctx.at_end(req)
+ }
+ SreAtCode::END_LINE => ctx.at_linebreak(req) || ctx.at_end(req),
+ SreAtCode::END_STRING => ctx.at_end(req),
+ SreAtCode::LOC_BOUNDARY => ctx.at_boundary(req, is_loc_word),
+ SreAtCode::LOC_NON_BOUNDARY => ctx.at_non_boundary(req, is_loc_word),
+ SreAtCode::UNI_BOUNDARY => ctx.at_boundary(req, is_uni_word),
+ SreAtCode::UNI_NON_BOUNDARY => ctx.at_non_boundary(req, is_uni_word),
+ }
+}
+
+fn char_loc_ignore(code: u32, c: u32) -> bool {
+ code == c || code == lower_locate(c) || code == upper_locate(c)
+}
+
+fn charset_loc_ignore(set: &[u32], c: u32) -> bool {
+ let lo = lower_locate(c);
+ if charset(set, c) {
+ return true;
+ }
+ let up = upper_locate(c);
+ up != lo && charset(set, up)
+}
+
+fn category(cat_code: SreCatCode, c: u32) -> bool {
+ match cat_code {
+ SreCatCode::DIGIT => is_digit(c),
+ SreCatCode::NOT_DIGIT => !is_digit(c),
+ SreCatCode::SPACE => is_space(c),
+ SreCatCode::NOT_SPACE => !is_space(c),
+ SreCatCode::WORD => is_word(c),
+ SreCatCode::NOT_WORD => !is_word(c),
+ SreCatCode::LINEBREAK => is_linebreak(c),
+ SreCatCode::NOT_LINEBREAK => !is_linebreak(c),
+ SreCatCode::LOC_WORD => is_loc_word(c),
+ SreCatCode::LOC_NOT_WORD => !is_loc_word(c),
+ SreCatCode::UNI_DIGIT => is_uni_digit(c),
+ SreCatCode::UNI_NOT_DIGIT => !is_uni_digit(c),
+ SreCatCode::UNI_SPACE => is_uni_space(c),
+ SreCatCode::UNI_NOT_SPACE => !is_uni_space(c),
+ SreCatCode::UNI_WORD => is_uni_word(c),
+ SreCatCode::UNI_NOT_WORD => !is_uni_word(c),
+ SreCatCode::UNI_LINEBREAK => is_uni_linebreak(c),
+ SreCatCode::UNI_NOT_LINEBREAK => !is_uni_linebreak(c),
+ }
+}
+
+fn charset(set: &[u32], ch: u32) -> bool {
+ /* check if character is a member of the given set */
+ let mut ok = true;
+ let mut i = 0;
+ while i < set.len() {
+ let opcode = match SreOpcode::try_from(set[i]) {
+ Ok(code) => code,
+ Err(_) => {
+ break;
+ }
+ };
+ match opcode {
+ SreOpcode::FAILURE => {
+ return !ok;
+ }
+ SreOpcode::CATEGORY => {
+ /* <CATEGORY> <code> */
+ let cat_code = match SreCatCode::try_from(set[i + 1]) {
+ Ok(code) => code,
+ Err(_) => {
+ break;
+ }
+ };
+ if category(cat_code, ch) {
+ return ok;
+ }
+ i += 2;
+ }
+ SreOpcode::CHARSET => {
+ /* <CHARSET> <bitmap> */
+ let set = &set[i + 1..];
+ if ch < 256 && ((set[(ch >> 5) as usize] & (1u32 << (ch & 31))) != 0) {
+ return ok;
+ }
+ i += 1 + 8;
+ }
+ SreOpcode::BIGCHARSET => {
+ /* <BIGCHARSET> <block_count> <256 block_indices> <blocks> */
+ let count = set[i + 1] as usize;
+ if ch < 0x10000 {
+ let set = &set[i + 2..];
+ let block_index = ch >> 8;
+ let (_, block_indices, _) = unsafe { set.align_to::<u8>() };
+ let blocks = &set[64..];
+ let block = block_indices[block_index as usize];
+ if blocks[((block as u32 * 256 + (ch & 255)) / 32) as usize]
+ & (1u32 << (ch & 31))
+ != 0
+ {
+ return ok;
+ }
+ }
+ i += 2 + 64 + count * 8;
+ }
+ SreOpcode::LITERAL => {
+ /* <LITERAL> <code> */
+ if ch == set[i + 1] {
+ return ok;
+ }
+ i += 2;
+ }
+ SreOpcode::NEGATE => {
+ ok = !ok;
+ i += 1;
+ }
+ SreOpcode::RANGE => {
+ /* <RANGE> <lower> <upper> */
+ if set[i + 1] <= ch && ch <= set[i + 2] {
+ return ok;
+ }
+ i += 3;
+ }
+ SreOpcode::RANGE_UNI_IGNORE => {
+ /* <RANGE_UNI_IGNORE> <lower> <upper> */
+ if set[i + 1] <= ch && ch <= set[i + 2] {
+ return ok;
+ }
+ // CPython's Unicode ignore-case ranges include the extra
+ // one-code-point folds (notably dotless i and long s).
+ let ch = lower_unicode(upper_unicode(ch));
+ if set[i + 1] <= ch && ch <= set[i + 2] {
+ return ok;
+ }
+ i += 3;
+ }
+ _ => {
+ break;
+ }
+ }
+ }
+ /* internal error -- there's not much we can do about it
+ here, so let's just pretend it didn't match... */
+ false
+}
+
+fn _count<S: StrDrive>(
+ req: &Request<'_, S>,
+ state: &mut State,
+ ctx: &mut MatchContext,
+ max_count: usize,
+) -> usize {
+ let max_count = core::cmp::min(max_count, ctx.remaining_chars(req));
+ let end = ctx.cursor.position + max_count;
+ let opcode = SreOpcode::try_from(ctx.peek_code(req, 0)).unwrap();
+
+ match opcode {
+ SreOpcode::ANY => {
+ while ctx.cursor.position < end && !ctx.at_linebreak(req) {
+ ctx.advance_char::<S>();
+ }
+ }
+ SreOpcode::ANY_ALL => {
+ ctx.skip_char::<S>(max_count);
+ }
+ SreOpcode::IN => {
+ while ctx.cursor.position < end && charset(&ctx.pattern(req)[2..], ctx.peek_char::<S>())
+ {
+ ctx.advance_char::<S>();
+ }
+ }
+ SreOpcode::LITERAL => {
+ general_count_literal(req, ctx, end, |code, c| code == c);
+ }
+ SreOpcode::NOT_LITERAL => {
+ general_count_literal(req, ctx, end, |code, c| code != c);
+ }
+ SreOpcode::LITERAL_IGNORE => {
+ general_count_literal(req, ctx, end, |code, c| code == lower_ascii(c));
+ }
+ SreOpcode::NOT_LITERAL_IGNORE => {
+ general_count_literal(req, ctx, end, |code, c| code != lower_ascii(c));
+ }
+ SreOpcode::LITERAL_LOC_IGNORE => {
+ general_count_literal(req, ctx, end, char_loc_ignore);
+ }
+ SreOpcode::NOT_LITERAL_LOC_IGNORE => {
+ general_count_literal(req, ctx, end, |code, c| !char_loc_ignore(code, c));
+ }
+ SreOpcode::LITERAL_UNI_IGNORE => {
+ general_count_literal(req, ctx, end, |code, c| code == lower_unicode(c));
+ }
+ SreOpcode::NOT_LITERAL_UNI_IGNORE => {
+ general_count_literal(req, ctx, end, |code, c| code != lower_unicode(c));
+ }
+ _ => {
+ /* General case */
+ ctx.toplevel = false;
+ ctx.jump = Jump::OpCode;
+ ctx.repeat_ctx_id = usize::MAX;
+ ctx.count = -1;
+
+ let mut sub_state = State {
+ marks: Marks::default(),
+ repeat_stack: vec![],
+ ..*state
+ };
+
+ while ctx.cursor.position < end && _match(req, &mut sub_state, *ctx) {
+ ctx.advance_char::<S>();
+ }
+ }
+ }
+
+ // TODO: return offset
+ ctx.cursor.position - state.cursor.position
+}
+
+fn general_count_literal<S: StrDrive, F: FnMut(u32, u32) -> bool>(
+ req: &Request<'_, S>,
+ ctx: &mut MatchContext,
+ end: usize,
+ mut f: F,
+) {
+ let ch = ctx.peek_code(req, 1);
+ while ctx.cursor.position < end && f(ch, ctx.peek_char::<S>()) {
+ ctx.advance_char::<S>();
+ }
+}
diff --git a/browser/vendor/rustpython-sre_engine/src/lib.rs b/browser/vendor/rustpython-sre_engine/src/lib.rs
new file mode 100644
index 000000000..e72716d38
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/src/lib.rs
@@ -0,0 +1,24 @@
+#![no_std]
+
+extern crate alloc;
+
+pub mod compiler;
+pub mod constants;
+pub mod engine;
+pub mod string;
+
+pub use constants::{SRE_MAGIC, SreAtCode, SreCatCode, SreFlag, SreInfo, SreOpcode};
+pub use engine::{Request, SearchIter, State};
+pub use string::{StrDrive, StringCursor};
+
+pub const CODESIZE: usize = 4;
+
+#[cfg(target_pointer_width = "32")]
+pub const MAXREPEAT: usize = usize::MAX - 1;
+#[cfg(target_pointer_width = "64")]
+pub const MAXREPEAT: usize = u32::MAX as usize;
+
+#[cfg(target_pointer_width = "32")]
+pub const MAXGROUPS: usize = MAXREPEAT / 4 / 2;
+#[cfg(target_pointer_width = "64")]
+pub const MAXGROUPS: usize = MAXREPEAT / 2;
diff --git a/browser/vendor/rustpython-sre_engine/src/string.rs b/browser/vendor/rustpython-sre_engine/src/string.rs
new file mode 100644
index 000000000..61bf575d2
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/src/string.rs
@@ -0,0 +1,531 @@
+use rustpython_wtf8::Wtf8;
+
+#[derive(Debug, Clone, Copy)]
+pub struct StringCursor {
+ pub(crate) ptr: *const u8,
+ pub position: usize,
+}
+
+impl Default for StringCursor {
+ fn default() -> Self {
+ Self {
+ ptr: core::ptr::null(),
+ position: 0,
+ }
+ }
+}
+
+pub trait StrDrive: Copy {
+ fn count(&self) -> usize;
+ fn create_cursor(&self, n: usize) -> StringCursor;
+ fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize);
+ fn advance(cursor: &mut StringCursor) -> u32;
+ fn peek(cursor: &StringCursor) -> u32;
+ fn skip(cursor: &mut StringCursor, n: usize);
+ fn back_advance(cursor: &mut StringCursor) -> u32;
+ fn back_peek(cursor: &StringCursor) -> u32;
+ fn back_skip(cursor: &mut StringCursor, n: usize);
+}
+
+impl StrDrive for &[u8] {
+ #[inline]
+ fn count(&self) -> usize {
+ self.len()
+ }
+
+ #[inline]
+ fn create_cursor(&self, n: usize) -> StringCursor {
+ StringCursor {
+ ptr: self[n..].as_ptr(),
+ position: n,
+ }
+ }
+
+ #[inline]
+ fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
+ cursor.position = n;
+ cursor.ptr = self[n..].as_ptr();
+ }
+
+ #[inline]
+ fn advance(cursor: &mut StringCursor) -> u32 {
+ cursor.position += 1;
+ unsafe { cursor.ptr = cursor.ptr.add(1) };
+ unsafe { *cursor.ptr as u32 }
+ }
+
+ #[inline]
+ fn peek(cursor: &StringCursor) -> u32 {
+ unsafe { *cursor.ptr as u32 }
+ }
+
+ #[inline]
+ fn skip(cursor: &mut StringCursor, n: usize) {
+ cursor.position += n;
+ unsafe { cursor.ptr = cursor.ptr.add(n) };
+ }
+
+ #[inline]
+ fn back_advance(cursor: &mut StringCursor) -> u32 {
+ cursor.position -= 1;
+ unsafe { cursor.ptr = cursor.ptr.sub(1) };
+ unsafe { *cursor.ptr as u32 }
+ }
+
+ #[inline]
+ fn back_peek(cursor: &StringCursor) -> u32 {
+ unsafe { *cursor.ptr.offset(-1) as u32 }
+ }
+
+ #[inline]
+ fn back_skip(cursor: &mut StringCursor, n: usize) {
+ cursor.position -= n;
+ unsafe { cursor.ptr = cursor.ptr.sub(n) };
+ }
+}
+
+impl StrDrive for &str {
+ #[inline]
+ fn count(&self) -> usize {
+ self.chars().count()
+ }
+
+ #[inline]
+ fn create_cursor(&self, n: usize) -> StringCursor {
+ let mut cursor = StringCursor {
+ ptr: self.as_ptr(),
+ position: 0,
+ };
+ Self::skip(&mut cursor, n);
+ cursor
+ }
+
+ #[inline]
+ fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
+ if cursor.ptr.is_null() || cursor.position > n {
+ *cursor = Self::create_cursor(self, n);
+ } else if cursor.position < n {
+ Self::skip(cursor, n - cursor.position);
+ }
+ }
+
+ #[inline]
+ fn advance(cursor: &mut StringCursor) -> u32 {
+ cursor.position += 1;
+ unsafe { next_code_point(&mut cursor.ptr) }
+ }
+
+ #[inline]
+ fn peek(cursor: &StringCursor) -> u32 {
+ let mut ptr = cursor.ptr;
+ unsafe { next_code_point(&mut ptr) }
+ }
+
+ #[inline]
+ fn skip(cursor: &mut StringCursor, n: usize) {
+ cursor.position += n;
+ for _ in 0..n {
+ unsafe { next_code_point(&mut cursor.ptr) };
+ }
+ }
+
+ #[inline]
+ fn back_advance(cursor: &mut StringCursor) -> u32 {
+ cursor.position -= 1;
+ unsafe { next_code_point_reverse(&mut cursor.ptr) }
+ }
+
+ #[inline]
+ fn back_peek(cursor: &StringCursor) -> u32 {
+ let mut ptr = cursor.ptr;
+ unsafe { next_code_point_reverse(&mut ptr) }
+ }
+
+ #[inline]
+ fn back_skip(cursor: &mut StringCursor, n: usize) {
+ cursor.position -= n;
+ for _ in 0..n {
+ unsafe { next_code_point_reverse(&mut cursor.ptr) };
+ }
+ }
+}
+
+impl StrDrive for &Wtf8 {
+ #[inline]
+ fn count(&self) -> usize {
+ self.code_points().count()
+ }
+
+ #[inline]
+ fn create_cursor(&self, n: usize) -> StringCursor {
+ let mut cursor = StringCursor {
+ ptr: self.as_bytes().as_ptr(),
+ position: 0,
+ };
+ Self::skip(&mut cursor, n);
+ cursor
+ }
+
+ #[inline]
+ fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
+ if cursor.ptr.is_null() || cursor.position > n {
+ *cursor = Self::create_cursor(self, n);
+ } else if cursor.position < n {
+ Self::skip(cursor, n - cursor.position);
+ }
+ }
+
+ #[inline]
+ fn advance(cursor: &mut StringCursor) -> u32 {
+ cursor.position += 1;
+ unsafe { next_code_point(&mut cursor.ptr) }
+ }
+
+ #[inline]
+ fn peek(cursor: &StringCursor) -> u32 {
+ let mut ptr = cursor.ptr;
+ unsafe { next_code_point(&mut ptr) }
+ }
+
+ #[inline]
+ fn skip(cursor: &mut StringCursor, n: usize) {
+ cursor.position += n;
+ for _ in 0..n {
+ unsafe { next_code_point(&mut cursor.ptr) };
+ }
+ }
+
+ #[inline]
+ fn back_advance(cursor: &mut StringCursor) -> u32 {
+ cursor.position -= 1;
+ unsafe { next_code_point_reverse(&mut cursor.ptr) }
+ }
+
+ #[inline]
+ fn back_peek(cursor: &StringCursor) -> u32 {
+ let mut ptr = cursor.ptr;
+ unsafe { next_code_point_reverse(&mut ptr) }
+ }
+
+ #[inline]
+ fn back_skip(cursor: &mut StringCursor, n: usize) {
+ cursor.position -= n;
+ for _ in 0..n {
+ unsafe { next_code_point_reverse(&mut cursor.ptr) };
+ }
+ }
+}
+
+/// Reads the next code point out of a byte iterator (assuming a
+/// UTF-8-like encoding).
+///
+/// # Safety
+///
+/// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string
+#[inline]
+const unsafe fn next_code_point(ptr: &mut *const u8) -> u32 {
+ // Decode UTF-8
+ let x = unsafe { **ptr };
+ *ptr = unsafe { ptr.offset(1) };
+
+ if x < 128 {
+ return x as u32;
+ }
+
+ // Multibyte case follows
+ // Decode from a byte combination out of: [[[x y] z] w]
+ // NOTE: Performance is sensitive to the exact formulation here
+ let init = utf8_first_byte(x, 2);
+ // SAFETY: `bytes` produces an UTF-8-like string,
+ // so the iterator must produce a value here.
+ let y = unsafe { **ptr };
+ *ptr = unsafe { ptr.offset(1) };
+ let mut ch = utf8_acc_cont_byte(init, y);
+ if x >= 0xE0 {
+ // [[x y z] w] case
+ // 5th bit in 0xE0 .. 0xEF is always clear, so `init` is still valid
+ // SAFETY: `bytes` produces an UTF-8-like string,
+ // so the iterator must produce a value here.
+ let z = unsafe { **ptr };
+ *ptr = unsafe { ptr.offset(1) };
+ let y_z = utf8_acc_cont_byte((y & CONT_MASK) as u32, z);
+ ch = (init << 12) | y_z;
+ if x >= 0xF0 {
+ // [x y z w] case
+ // use only the lower 3 bits of `init`
+ // SAFETY: `bytes` produces an UTF-8-like string,
+ // so the iterator must produce a value here.
+ let w = unsafe { **ptr };
+ *ptr = unsafe { ptr.offset(1) };
+ ch = ((init & 7) << 18) | utf8_acc_cont_byte(y_z, w);
+ }
+ }
+
+ ch
+}
+
+/// Reads the last code point out of a byte iterator (assuming a
+/// UTF-8-like encoding).
+///
+/// # Safety
+///
+/// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string
+#[inline]
+const unsafe fn next_code_point_reverse(ptr: &mut *const u8) -> u32 {
+ // Decode UTF-8
+ *ptr = unsafe { ptr.offset(-1) };
+ let w = match unsafe { **ptr } {
+ next_byte if next_byte < 128 => return next_byte as u32,
+ back_byte => back_byte,
+ };
+
+ // Multibyte case follows
+ // Decode from a byte combination out of: [x [y [z w]]]
+ let mut ch;
+ // SAFETY: `bytes` produces an UTF-8-like string,
+ // so the iterator must produce a value here.
+ *ptr = unsafe { ptr.offset(-1) };
+ let z = unsafe { **ptr };
+ ch = utf8_first_byte(z, 2);
+ if utf8_is_cont_byte(z) {
+ // SAFETY: `bytes` produces an UTF-8-like string,
+ // so the iterator must produce a value here.
+ *ptr = unsafe { ptr.offset(-1) };
+ let y = unsafe { **ptr };
+ ch = utf8_first_byte(y, 3);
+ if utf8_is_cont_byte(y) {
+ // SAFETY: `bytes` produces an UTF-8-like string,
+ // so the iterator must produce a value here.
+ *ptr = unsafe { ptr.offset(-1) };
+ let x = unsafe { **ptr };
+ ch = utf8_first_byte(x, 4);
+ ch = utf8_acc_cont_byte(ch, y);
+ }
+ ch = utf8_acc_cont_byte(ch, z);
+ }
+ ch = utf8_acc_cont_byte(ch, w);
+
+ ch
+}
+
+/// Returns the initial codepoint accumulator for the first byte.
+/// The first byte is special, only want bottom 5 bits for width 2, 4 bits
+/// for width 3, and 3 bits for width 4.
+#[inline]
+const fn utf8_first_byte(byte: u8, width: u32) -> u32 {
+ (byte & (0x7F >> width)) as u32
+}
+
+/// Returns the value of `ch` updated with continuation byte `byte`.
+#[inline]
+const fn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 {
+ (ch << 6) | (byte & CONT_MASK) as u32
+}
+
+/// Checks whether the byte is a UTF-8 continuation byte (i.e., starts with the
+/// bits `10`).
+#[inline]
+const fn utf8_is_cont_byte(byte: u8) -> bool {
+ (byte as i8) < -64
+}
+
+/// Mask of the value bits of a continuation byte.
+const CONT_MASK: u8 = 0b0011_1111;
+
+const fn is_py_ascii_whitespace(b: u8) -> bool {
+ matches!(b, b'\t' | b'\n' | b'\x0C' | b'\r' | b' ' | b'\x0B')
+}
+
+#[inline]
+pub(crate) fn is_word(ch: u32) -> bool {
+ ch == '_' as u32
+ || u8::try_from(ch)
+ .map(|x| x.is_ascii_alphanumeric())
+ .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_space(ch: u32) -> bool {
+ u8::try_from(ch)
+ .map(is_py_ascii_whitespace)
+ .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_digit(ch: u32) -> bool {
+ u8::try_from(ch)
+ .map(|x| x.is_ascii_digit())
+ .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_loc_alnum(ch: u32) -> bool {
+ // FIXME: Ignore the locales
+ u8::try_from(ch)
+ .map(|x| x.is_ascii_alphanumeric())
+ .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_loc_word(ch: u32) -> bool {
+ ch == '_' as u32 || is_loc_alnum(ch)
+}
+#[inline]
+pub(crate) const fn is_linebreak(ch: u32) -> bool {
+ ch == '\n' as u32
+}
+#[inline]
+pub fn lower_ascii(ch: u32) -> u32 {
+ u8::try_from(ch)
+ .map(|x| x.to_ascii_lowercase() as u32)
+ .unwrap_or(ch)
+}
+#[inline]
+pub(crate) fn lower_locate(ch: u32) -> u32 {
+ // FIXME: Ignore the locales
+ lower_ascii(ch)
+}
+#[inline]
+pub(crate) fn upper_locate(ch: u32) -> u32 {
+ // FIXME: Ignore the locales
+ u8::try_from(ch)
+ .map(|x| x.to_ascii_uppercase() as u32)
+ .unwrap_or(ch)
+}
+#[inline]
+pub(crate) fn is_uni_digit(ch: u32) -> bool {
+ const DECIMAL_RANGES: &[(u32, u32)] = &[
+ (0x0030, 0x0039),
+ (0x0660, 0x0669),
+ (0x06F0, 0x06F9),
+ (0x07C0, 0x07C9),
+ (0x0966, 0x096F),
+ (0x09E6, 0x09EF),
+ (0x0A66, 0x0A6F),
+ (0x0AE6, 0x0AEF),
+ (0x0B66, 0x0B6F),
+ (0x0BE6, 0x0BEF),
+ (0x0C66, 0x0C6F),
+ (0x0CE6, 0x0CEF),
+ (0x0D66, 0x0D6F),
+ (0x0DE6, 0x0DEF),
+ (0x0E50, 0x0E59),
+ (0x0ED0, 0x0ED9),
+ (0x0F20, 0x0F29),
+ (0x1040, 0x1049),
+ (0x1090, 0x1099),
+ (0x17E0, 0x17E9),
+ (0x1810, 0x1819),
+ (0x1946, 0x194F),
+ (0x19D0, 0x19D9),
+ (0x1A80, 0x1A89),
+ (0x1A90, 0x1A99),
+ (0x1B50, 0x1B59),
+ (0x1BB0, 0x1BB9),
+ (0x1C40, 0x1C49),
+ (0x1C50, 0x1C59),
+ (0xA620, 0xA629),
+ (0xA8D0, 0xA8D9),
+ (0xA900, 0xA909),
+ (0xA9D0, 0xA9D9),
+ (0xA9F0, 0xA9F9),
+ (0xAA50, 0xAA59),
+ (0xABF0, 0xABF9),
+ (0xFF10, 0xFF19),
+ (0x104A0, 0x104A9),
+ (0x10D30, 0x10D39),
+ (0x11066, 0x1106F),
+ (0x110F0, 0x110F9),
+ (0x11136, 0x1113F),
+ (0x111D0, 0x111D9),
+ (0x112F0, 0x112F9),
+ (0x11450, 0x11459),
+ (0x114D0, 0x114D9),
+ (0x11650, 0x11659),
+ (0x116C0, 0x116C9),
+ (0x11730, 0x11739),
+ (0x118E0, 0x118E9),
+ (0x11950, 0x11959),
+ (0x11C50, 0x11C59),
+ (0x11D50, 0x11D59),
+ (0x11DA0, 0x11DA9),
+ (0x11F50, 0x11F59),
+ (0x16A60, 0x16A69),
+ (0x16AC0, 0x16AC9),
+ (0x16B50, 0x16B59),
+ (0x1D7CE, 0x1D7FF),
+ (0x1E140, 0x1E149),
+ (0x1E2F0, 0x1E2F9),
+ (0x1E4F0, 0x1E4F9),
+ (0x1E950, 0x1E959),
+ (0x1FBF0, 0x1FBF9),
+ ];
+ DECIMAL_RANGES
+ .iter()
+ .any(|&(start, end)| start <= ch && ch <= end)
+}
+#[inline]
+pub(crate) fn is_uni_space(ch: u32) -> bool {
+ // TODO: check with cpython
+ is_space(ch)
+ || matches!(
+ ch,
+ 0x0009
+ | 0x000A
+ | 0x000B
+ | 0x000C
+ | 0x000D
+ | 0x001C
+ | 0x001D
+ | 0x001E
+ | 0x001F
+ | 0x0020
+ | 0x0085
+ | 0x00A0
+ | 0x1680
+ | 0x2000
+ | 0x2001
+ | 0x2002
+ | 0x2003
+ | 0x2004
+ | 0x2005
+ | 0x2006
+ | 0x2007
+ | 0x2008
+ | 0x2009
+ | 0x200A
+ | 0x2028
+ | 0x2029
+ | 0x202F
+ | 0x205F
+ | 0x3000
+ )
+}
+#[inline]
+pub(crate) const fn is_uni_linebreak(ch: u32) -> bool {
+ matches!(
+ ch,
+ 0x000A | 0x000B | 0x000C | 0x000D | 0x001C | 0x001D | 0x001E | 0x0085 | 0x2028 | 0x2029
+ )
+}
+#[inline]
+pub(crate) fn is_uni_alnum(ch: u32) -> bool {
+ // TODO: check with cpython
+ char::try_from(ch)
+ .map(|x| x.is_alphanumeric())
+ .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_uni_word(ch: u32) -> bool {
+ ch == '_' as u32 || is_uni_alnum(ch)
+}
+#[inline]
+pub fn lower_unicode(ch: u32) -> u32 {
+ // TODO: check with cpython
+ char::try_from(ch)
+ .map(|x| x.to_lowercase().next().unwrap() as u32)
+ .unwrap_or(ch)
+}
+#[inline]
+pub fn upper_unicode(ch: u32) -> u32 {
+ // TODO: check with cpython
+ char::try_from(ch)
+ .map(|x| x.to_uppercase().next().unwrap() as u32)
+ .unwrap_or(ch)
+}
diff --git a/browser/vendor/rustpython-sre_engine/tests/differential.py b/browser/vendor/rustpython-sre_engine/tests/differential.py
new file mode 100644
index 000000000..a20100278
--- /dev/null
+++ b/browser/vendor/rustpython-sre_engine/tests/differential.py
@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""Deterministic CPython 3.12 differential corpus for the compatibility fork."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+SEED = 0x31213
+
+ATOMS = [
+ "a", "b", ".", "[ab]", "[^x]", "[a-z]", "\\d", "\\D", "\\s",
+ "\\S", "\\w", "\\W", "\\b", "\\B", "^", "$", "é", "Ω", "中",
+]
+TEXTS = [
+ "", "a", "b", "ab", "aba", "aaab", "123", "a1 b2", " ", "\n",
+ "éÉè", "ΩωΩ", "İıſK", "中a_9", "x\ny", "word-word", "١٢٣", "\u2003",
+]
+VALID_TEMPLATES = [
+ "{}", "(?:{})", "({})", "{}*", "{}+", "{}?", "{}*?", "{}+?", "{}??",
+ "{}{{0}}", "{}{{1}}", "{}{{0,2}}", "{}{{1,3}}", "(?={})", "(?!{})",
+ "{}|b", "a|{}", "(?:{}a)?", "(?i:{})", "(?a:{})", "(?s:{})", "(?m:{})",
+]
+STRUCTURED = [
+ "(a)?(?(1)b|c)", "(?P<x>a)(?P=x)", "(?<=ab)c", "(?<!ab)c",
+ "(?=(a+))a", "(a*)(b?)", "((ab)+)", "(?:a?)*", "(?:a*)*",
+ "(?>a*)a", "a*+a", "(?i)[a-z]+", "(?i)k", "(?i)s", "(?i)i",
+ "(?i)σ", "(?i)ß", "\\A.*\\Z", "^.*$", "(?:|a)", "(?:a|)",
+]
+ERRORS = [
+ "(", "[", "*", "+", "?", "a**", "a++?", "a{4,2}", "(?", "(?P)",
+ "(?P<>)", "(?P<x>a)(?P<x>b)", "(?P=x)", "(?<x)", "(?<=a*)", "(?<!a+)",
+ "(?i", "a(?i)b", "(?L)", "(?au)", "(?i-i:a)", "(?-a:a)", "(?z:a)",
+ "\\", "\\x", "\\x0", "\\u123", "\\U00110000", "\\N", "\\N{}",
+ "\\N{NO SUCH NAME}", "\\1", "(a)\\2", "[z-a]", "[\\w-a]", "[a-\\d]",
+ "(?(0)a|b)", "(?(99)a|b)", "(a)(?(1)b|c|d)", ")", "a)", "{1}",
+]
+
+
+def valid_cases(rng: random.Random, count: int):
+ cases: list[tuple[str, str, bool]] = []
+ for atom in ATOMS:
+ for template in VALID_TEMPLATES:
+ pattern = template.format(atom)
+ for text in TEXTS:
+ cases.append((pattern, text, False))
+ cases.append((pattern, text, True))
+ for pattern in STRUCTURED:
+ for text in TEXTS:
+ cases.append((pattern, text, False))
+ cases.append((pattern, text, True))
+ rng.shuffle(cases)
+ while len(cases) < count:
+ left = rng.choice(ATOMS[:16])
+ right = rng.choice(ATOMS[:16])
+ pattern = rng.choice([
+ f"(?:{left}{right}){{0,3}}", f"({left})({right})", f"(?={left}){right}",
+ f"(?:{left}|{right})+", f"(?i:{left})(?a:{right})",
+ ])
+ cases.append((pattern, rng.choice(TEXTS), bool(rng.getrandbits(1))))
+ return cases[:count]
+
+
+def error_cases(rng: random.Random, count: int):
+ cases: list[tuple[str, str, bool]] = []
+ suffixes = ["", "a", "Ω", "(?:b)", "{2}"]
+ for pattern in ERRORS:
+ for suffix in suffixes:
+ cases.append((pattern + suffix, rng.choice(TEXTS), bool(rng.getrandbits(1))))
+ while len(cases) < count:
+ pattern = rng.choice(ERRORS)
+ cases.append((pattern, rng.choice(TEXTS), bool(rng.getrandbits(1))))
+ rng.shuffle(cases)
+ return cases[:count]
+
+
+def encode_matches(pattern: re.Pattern[str], text: str) -> str:
+ values = pattern.findall(text)
+ rows: list[list[str]] = []
+ for value in values:
+ if pattern.groups == 0:
+ rows.append([value])
+ elif pattern.groups == 1:
+ rows.append([value])
+ else:
+ rows.append(list(value))
+ fields = [str(len(rows))]
+ fields.extend(str(len(row)) + "".join(":" + item.encode().hex() for item in row) for row in rows)
+ return "OK\t" + "\t".join(fields)
+
+
+def oracle(pattern: str, text: str, ignore_case: bool) -> str:
+ try:
+ compiled = re.compile(pattern, re.I if ignore_case else 0)
+ except re.error as error:
+ return "ERR\t" + str(error).encode().hex()
+ return encode_matches(compiled, text)
+
+
+def minimize(pattern: str, text: str, ignore_case: bool, driver) -> tuple[str, str]:
+ expected = oracle(pattern, text, ignore_case)
+
+ def differs(pat: str, value: str) -> bool:
+ return query(driver, pat, value, ignore_case) != oracle(pat, value, ignore_case)
+
+ changed = True
+ while changed:
+ changed = False
+ for target, value in (("pattern", pattern), ("text", text)):
+ for index in range(len(value)):
+ candidate = value[:index] + value[index + 1 :]
+ pat, subject = (candidate, text) if target == "pattern" else (pattern, candidate)
+ if differs(pat, subject):
+ pattern, text = pat, subject
+ changed = True
+ break
+ if changed:
+ break
+ return pattern, text
+
+
+def query(driver: subprocess.Popen[str], pattern: str, text: str, ignore_case: bool) -> str:
+ assert driver.stdin and driver.stdout
+ driver.stdin.write(f"{int(ignore_case)}\t{pattern.encode().hex()}\t{text.encode().hex()}\n")
+ driver.stdin.flush()
+ response = driver.stdout.readline().rstrip("\n")
+ if not response:
+ raise RuntimeError("Rust differential driver stopped")
+ return response
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--cases", type=int, default=10_000)
+ parser.add_argument("--max-mismatches", type=int, default=20)
+ args = parser.parse_args()
+ if sys.version_info[:3] != (3, 12, 13):
+ parser.error(f"requires frozen CPython 3.12.13, got {sys.version.split()[0]}")
+
+ root = Path(__file__).resolve().parents[1]
+ subprocess.run(["cargo", "build", "--quiet", "--example", "differential_driver"], cwd=root, check=True)
+ metadata = json.loads(
+ subprocess.check_output(["cargo", "metadata", "--format-version=1", "--no-deps"], cwd=root)
+ )
+ executable = Path(metadata["target_directory"]) / "debug/examples/differential_driver"
+ driver = subprocess.Popen(
+ [executable],
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True,
+ )
+ rng = random.Random(SEED)
+ valid_count = args.cases * 4 // 5
+ cases = valid_cases(rng, valid_count) + error_cases(rng, args.cases - valid_count)
+ mismatches = []
+ try:
+ for index, (pattern, text, ignore_case) in enumerate(cases, 1):
+ expected = oracle(pattern, text, ignore_case)
+ actual = query(driver, pattern, text, ignore_case)
+ if actual != expected:
+ minimized = minimize(pattern, text, ignore_case, driver)
+ mismatch = (index, pattern, text, ignore_case, expected, actual, *minimized)
+ if mismatch[6:] not in [item[6:] for item in mismatches]:
+ mismatches.append(mismatch)
+ if len(mismatches) >= args.max_mismatches:
+ break
+ finally:
+ driver.terminate()
+ driver.wait()
+
+ for item in mismatches:
+ index, pattern, text, ignore_case, expected, actual, min_pattern, min_text = item
+ print(f"case={index} ignore_case={ignore_case} pattern={pattern!r} text={text!r}")
+ print(f" expected={expected}")
+ print(f" actual ={actual}")
+ print(f" minimized pattern={min_pattern!r} text={min_text!r}")
+ if mismatches:
+ print(f"FAILED: {len(mismatches)} distinct mismatches", file=sys.stderr)
+ return 1
+ print(f"PASS: {len(cases)} cases (seed={SEED:#x}, valid={valid_count}, errors={len(cases)-valid_count})")
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/browser/vendor/scrapling-0.4.9-ad-domains.NOTICE b/browser/vendor/scrapling-0.4.9-ad-domains.NOTICE
new file mode 100644
index 000000000..5fd07349c
--- /dev/null
+++ b/browser/vendor/scrapling-0.4.9-ad-domains.NOTICE
@@ -0,0 +1,6 @@
+Scrapling 0.4.9 ad/tracker domain snapshot
+
+Source file: scrapling/engines/toolbelt/ad_domains.py
+Source data: Peter Lowe's ad and tracking server list
+Vendored list SHA-256: c05053529fa5d626774e178359db20a7628030d94075d2c12cb63957c785d387
+License: BSD-3-Clause; see SCRAPLING-0.4.9-LICENSE
diff --git a/browser/vendor/scrapling-0.4.9-ad-domains.txt b/browser/vendor/scrapling-0.4.9-ad-domains.txt
new file mode 100644
index 000000000..d62b13a30
--- /dev/null
+++ b/browser/vendor/scrapling-0.4.9-ad-domains.txt
@@ -0,0 +1,3529 @@
+# Frozen Scrapling 0.4.9 ad/tracker domains.
+# Upstream data: Peter Lowe's list, frozen through Scrapling under BSD-3-Clause.
+101com.com
+180hits.de
+180searchassistant.com
+1rx.io
+2020mustang.com
+207.net
+247media.com
+24log.com
+24pm-affiliation.com
+2linkpath.com
+2mdn.net
+2o7.net
+2znp09oa.com
+30ads.com
+3337723.com
+33across.com
+360yield.com
+3lift.com
+3o9s.short.gy
+4d5.net
+4info.com
+4jnzhl0d0.com
+50websads.com
+518ad.com
+6sc.co
+777partner.com
+77tracking.com
+7bpeople.com
+7cnq.net
+82o9v830.com
+a-ads.com
+a.mktw.net
+a.muloqot.uz
+a.sakh.com
+a.ucoz.net
+a.ucoz.ru
+a.vartoken.com
+a.vdo.ai
+a.vfghd.com
+a.vfgtb.com
+a.xanga.com
+a11.click
+a135.wftv.com
+a5.overclockers.ua
+aa-metrics.beauty.hotpepper.jp
+aa-metrics.recruit-card.jp
+aa-metrics.trip-ai.jp
+aaddzz.com
+aax-eu-dub.amazon.com
+aaxads.com
+abacho.net
+abc-ads.com
+ablink.comms.trainline.com
+ablink.info.wise.com
+ablink.news.emails-puregym.com
+ablinks.mail.hinge.co
+aboardlevel.com
+absolutering.com
+absorbingband.com
+abstractedauthority.com
+abtasty.com
+ac.rnm.ca
+accountsdoor.com
+acebunny.com
+acemlnb.com
+acobt.tech
+acridtwist.com
+actionsplash.com
+actonsoftware.com
+actualdeals.com
+actuallysheep.com
+actuallysnake.com
+acuityads.com
+acuityplatform.com
+acustomizedgift.com
+ad-balancer.at
+ad-balancer.net
+ad-cupid.com
+ad-delivery.net
+ad-pay.de
+ad-rotator.com
+ad-score.com
+ad-server.gulasidorna.se
+ad-space.net
+ad-up.com
+ad.71i.de
+ad.a8.net
+ad.abcnews.com
+ad.abctv.com
+ad.aboutwebservices.com
+ad.abum.com
+ad.admitad.com
+ad.allboxing.ru
+ad.altervista.org
+ad.amgdgt.com
+ad.anuntis.com
+ad.auditude.com
+ad.bitmedia.io
+ad.bizo.com
+ad.bondage.com
+ad.centrum.cz
+ad.cgi.cz
+ad.choiceradio.com
+ad.cooks.com
+ad.digitallook.com
+ad.dnoticias.pt
+ad.domainfactory.de
+ad.exyws.org
+ad.grafika.cz
+ad.gt
+ad.hbv.de
+ad.hyena.cz
+ad.iinfo.cz
+ad.infoseek.com
+ad.intl.xiaomi.com
+ad.jetsoftware.com
+ad.keenspace.com
+ad.lgappstv.com
+ad.liveinternet.ru
+ad.lupa.cz
+ad.mediastorm.hu
+ad.mg
+ad.missena.io
+ad.musicmatch.com
+ad.myapple.pl
+ad.mynetreklam.com.streamprovider.net
+ad.nachtagenten.de
+ad.nettvservices.com
+ad.nttnavi.co.jp
+ad.nwt.cz
+ad.period-calendar.com
+ad.profiwin.de
+ad.prv.pl
+ad.reachlocal.com
+ad.simgames.net
+ad.style
+ad.technoratimedia.com
+ad.tv2.no
+ad.universcine.com
+ad.usatoday.com
+ad.virtual-nights.com
+ad.wavu.hu
+ad.weatherbug.com
+ad.wsod.com
+ad.wz.cz
+ad.xiaomi.com
+ad.xmovies8.si
+ad.xrea.com
+ad.ztylez.com
+ad0.bigmir.net
+ad01.mediacorpsingapore.com
+ad1.emule-project.org
+ad1.kde.cz
+ad2.iinfo.cz
+ad2.lupa.cz
+ad2.netriota.hu
+ad2.nmm.de
+ad2.xrea.com
+ad3.iinfo.cz
+ad3.xrea.com
+ad4game.com
+ad4mat.com
+ad4mat.de
+ad4mat.net
+adabra.com
+adaction.de
+adadvisor.net
+adalliance.io
+adap.tv
+adapt.tv
+adbilty.me
+adblade.com
+adblade.org
+adblockanalytics.com
+adbooth.net
+adbot.com
+adbrite.com
+adbroker.de
+adbutler.com
+adbuyer3.lycos.com
+adcampo.com
+adcannyads.com
+adcash.com
+adcast.deviantart.com
+adcel.co
+adcell.de
+adcenter.net
+adclick.com
+adclient1.tucows.com
+adclixx.net
+adcolony.com
+adcomplete.com
+adconion.com
+adcontent.gamespy.com
+adcovery.com
+adcycle.com
+add.newmedia.cz
+addfreestats.com
+addme.com
+addressfriend.com
+ade.clmbtech.com
+adecn.com
+adeimptrck.com
+ademails.com
+adengage.com
+adetracking.com
+adexchangegate.com
+adexchangeprediction.com
+adexpose.com
+adext.inkclub.com
+adf.ly
+adfeed.marchex.com
+adflight.com
+adforce.com
+adform.com
+adform.net
+adformdsp.net
+adhaven.com
+adhese.be
+adhese.com
+adhigh.net
+adhub.media
+adhunter.media
+adimage.guardian.co.uk
+adimages.been.com
+adimages.carsoup.com
+adimages.go.com
+adimages.homestore.com
+adimages.omroepzeeland.nl
+adimages.sanomawsoy.fi
+adimg.com.com
+adimg.uimserv.net
+adimg1.chosun.com
+adimgs.sapo.pt
+adingo.jp
+adinjector.net
+adinterax.com
+adisfy.com
+adition.com
+adition.de
+adition.net
+adizio.com
+adjix.com
+adjug.com
+adjuggler.com
+adjuggler.yourdictionary.com
+adjust.com
+adjustnetwork.com
+adk2.com
+adland.ru
+adlegend.com
+adlightning.com
+adlog.com.com
+adloox.com
+adlooxtracking.com
+adlure.net
+adm.fwmrm.net
+admailtiser.com
+adman.gr
+adman.otenet.gr
+admanagement.ch
+admanager.btopenworld.com
+admanager.carsoup.com
+admanmedia.com
+admantx.com
+admarketplace.net
+admarvel.com
+admaster.com.cn
+admatchly.com
+admedia.com
+admeld.com
+admeridianads.com
+admex.com
+admidadsp.com
+adminder.com
+adminshop.com
+admixer.net
+admized.com
+admob.com
+admonitor.com
+adn.lrb.co.uk
+adnami.io
+adnet.asahi.com
+adnet.biz
+adnet.de
+adnet.ru
+adnetasia.com
+adnetwork.net
+adnetworkperformance.com
+adnews.maddog2000.de
+adnium.com
+adnxs-simple.com
+adnxs.com
+adocean.pl
+adonspot.com
+adopsboost.com
+adoptum.net
+adoric-om.com
+adorigin.com
+adotmob.com
+adpepper.dk
+adpepper.nl
+adperium.com
+adpia.vn
+adplxmd.com
+adprofits.ru
+adpushup.com
+adrazzi.com
+adreactor.com
+adrecover.com
+adrecreate.com
+adremedy.com
+adreporting.com
+adrevolver.com
+adriver.ru
+adrolays.de
+adrotate.de
+adrotic.girlonthenet.com
+adrta.com
+ads-backend.chaincliq.com
+ads-bilek.com
+ads-dev.pinterest.com
+ads-game-187f4.firebaseapp.com
+ads-img.mozilla.org
+ads-portal-cdn.vidaatv.net
+ads-twitter.com
+ads.365.mk
+ads.5ci.lt
+ads.73dpi.com
+ads.aavv.com
+ads.abovetopsecret.com
+ads.aceweb.net
+ads.acpc.cat
+ads.acrosspf.com
+ads.activestate.com
+ads.adfox.ru
+ads.administrator.de
+ads.adred.de
+ads.adstream.com.ro
+ads.adultfriendfinder.com
+ads.advance.net
+ads.adverline.com
+ads.alive.com
+ads.alt.com
+ads.amdmb.com
+ads.amigos.com
+ads.annabac.com
+ads.apn.co.nz
+ads.appsgeyser.com
+ads.as4x.tmcs.net
+ads.as4x.tmcs.ticketmaster.com
+ads.asiafriendfinder.com
+ads.avazu.net
+ads.bb59.ru
+ads.betfair.com
+ads.bigchurch.com
+ads.bigfoot.com
+ads.bing.com
+ads.bittorrent.com
+ads.blog.com
+ads.bluemountain.com
+ads.boerding.com
+ads.boylesports.com
+ads.canalblog.com
+ads.casinocity.com
+ads.casumoaffiliates.com
+ads.cbc.ca
+ads.cc
+ads.cc-dt.com
+ads.centraliprom.com
+ads.channel4.com
+ads.cheabit.com
+ads.citymagazine.si
+ads.clasificadox.com
+ads.co.com
+ads.colombiaonline.com
+ads.com.com
+ads.comeon.com
+ads.creative-serving.com
+ads.cybersales.cz
+ads.dada.it
+ads.dailycamera.com
+ads.deltha.hu
+ads.dennisnet.co.uk
+ads.desmoinesregister.com
+ads.deviantart.com
+ads.devmates.com
+ads.digital-digest.com
+ads.digitalmedianet.com
+ads.digitalpoint.com
+ads.doit.com.cn
+ads.domeus.com
+ads.eagletribune.com
+ads.easy-forex.com
+ads.economist.com
+ads.elcarado.com
+ads.electrocelt.com
+ads.elitetrader.com
+ads.emdee.ca
+ads.emirates.net.ae
+ads.epi.sk
+ads.epltalk.com
+ads.eu.msn.com
+ads.fairfax.com.au
+ads.fastcomgroup.it
+ads.femmefab.nl
+ads.ferianc.com
+ads.filmup.com
+ads.financialcontent.com
+ads.flooble.com
+ads.fool.com
+ads.footymad.net
+ads.forbes.net
+ads.formit.cz
+ads.fortunecity.com
+ads.fotosidan.se
+ads.friendfinder.com
+ads.gamecity.net
+ads.gamespyid.com
+ads.gamigo.de
+ads.gaming-universe.de
+ads.gaming1.com
+ads.getlucky.com
+ads.gld.dk
+ads.gmodules.com
+ads.goyk.com
+ads.gradfinder.com
+ads.grindinggears.com
+ads.gsm-exchange.com
+ads.gsmexchange.com
+ads.guardian.co.uk
+ads.guardianunlimited.co.uk
+ads.hbv.de
+ads.hearstmags.com
+ads.heartlight.org
+ads.hollywood.com
+ads.horsehero.com
+ads.hsoub.com
+ads.ibest.com.br
+ads.ibryte.com
+ads.icq.com
+ads.ign.com
+ads.imagistica.com
+ads.imgur.com
+ads.independent.com.mt
+ads.infi.net
+ads.internic.co.il
+ads.ipowerweb.com
+ads.itv.com
+ads.jewishfriendfinder.com
+ads.jobsite.co.uk
+ads.justhungry.com
+ads.kabooaffiliates.com
+ads.kaktuz.net
+ads.kelbymediagroup.com
+ads.kinxxx.com
+ads.kompass.com
+ads.krawall.de
+ads.leovegas.com
+ads.lesbianpersonals.com
+ads.liberte.pl
+ads.linkedin.com
+ads.livenation.com
+ads.ma7.tv
+ads.mail.bg
+ads.massinfra.nl
+ads.mcafee.com
+ads.mediaodyssey.com
+ads.mediasmart.es
+ads.medienhaus.de
+ads.meetcelebs.com
+ads.mgnetwork.com
+ads.miarroba.com
+ads.mic.com
+ads.mmania.com
+ads.mobilebet.com
+ads.mozilla.org
+ads.msn.com
+ads.multimania.lycos.fr
+ads.muslimehelfen.org
+ads.mvscoelho.com
+ads.myadv.org
+ads.ndtv1.com
+ads.networksolutions.com
+ads.newgrounds.com
+ads.newmedia.cz
+ads.newsint.co.uk
+ads.newsquest.co.uk
+ads.nj.com
+ads.nola.com
+ads.nordichardware.com
+ads.nordichardware.se
+ads.nyi.net
+ads.nytimes.com
+ads.nyx.cz
+ads.nzcity.co.nz
+ads.o2.pl
+ads.oddschecker.com
+ads.okcimg.com
+ads.ole.com
+ads.oneplace.com
+ads.opensubtitles.org
+ads.optusnet.com.au
+ads.outpersonals.com
+ads.oxyshop.cz
+ads.passion.com
+ads.paymonex.net
+ads.pexi.nl
+ads.pfl.ua
+ads.phpclasses.org
+ads.pinterest.com
+ads.planet.nl
+ads.pni.com
+ads.pof.com
+ads.powweb.com
+ads.printscr.com
+ads.prisacom.com
+ads.prod.webservices.mozgcp.net
+ads.program3.com
+ads.psd2html.com
+ads.pubmatic.com
+ads.quoka.de
+ads.radio1.lv
+ads.recoletos.es
+ads.rediff.com
+ads.redlightcenter.com
+ads.revjet.com
+ads.reward-hunt.com
+ads.samsung.com
+ads.saymedia.com
+ads.schmoozecom.net
+ads.scifi.com
+ads.seniorfriendfinder.com
+ads.servebom.com
+ads.shizmoo.com
+ads.shopstyle.com
+ads.sift.co.uk
+ads.sjon.info
+ads.smartclick.com
+ads.socialtheater.com
+ads.soft32.com
+ads.soweb.gr
+ads.space.com
+ads.sun.com
+ads.suomiautomaatti.com
+ads.supplyframe.com
+ads.syscdn.de
+ads.themovienation.com
+ads.thestar.com
+ads.thrillsaffiliates.com
+ads.tiktok.com
+ads.tmcs.net
+ads.todoti.com.br
+ads.toplayaffiliates.com
+ads.townhall.com
+ads.travelaudience.com
+ads.trinitymirror.co.uk
+ads.tripod.com
+ads.tripod.lycos.co.uk
+ads.tripod.lycos.es
+ads.tripod.lycos.it
+ads.tripod.lycos.nl
+ads.tso.dennisnet.co.uk
+ads.twitter.com
+ads.twojatv.info
+ads.ultimate-guitar.com
+ads.uncrate.com
+ads.unison.bg
+ads.usatoday.com
+ads.uxs.at
+ads.v-lazer.com
+ads.verticalresponse.com
+ads.vgchartz.com
+ads.virtual-nights.com
+ads.virtuopolitan.com
+ads.vnumedia.com
+ads.walkiberia.com
+ads.watson.ch
+ads.weather.ca
+ads.web.de
+ads.webinak.sk
+ads.webmasterpoint.org
+ads.whoishostingthis.com
+ads.wiezoekje.nl
+ads.wikia.nocookie.net
+ads.wineenthusiast.com
+ads.wwe.biz
+ads.xhamster.com
+ads.xtra.co.nz
+ads.yahoo.com
+ads.yimg.com
+ads.yldmgrimg.net
+ads.youtube.com
+ads.yumenetworks.com
+ads1-adnow.com
+ads1.msn.com
+ads1.virtual-nights.com
+ads10.speedbit.com
+ads180.com
+ads2.brazzers.com
+ads2.contentabc.com
+ads2.femmefab.nl
+ads2.gamecity.net
+ads2.hsoub.com
+ads2.virtual-nights.com
+ads2.xnet.cz
+ads2004.treiberupdate.de
+ads24h.net
+ads3-adnow.com
+ads3.contentabc.com
+ads3.gamecity.net
+ads3.virtual-nights.com
+ads4.gamecity.net
+ads4.virtual-nights.com
+ads4homes.com
+ads5.virtual-nights.com
+ads6.gamecity.net
+ads7.gamecity.net
+adsafeprotected.com
+adsatt.abc.starwave.com
+adsatt.abcnews.starwave.com
+adsatt.espn.go.com
+adsatt.espn.starwave.com
+adsatt.go.starwave.com
+adsby.bidtheatre.com
+adsbydelema.com
+adscale.de
+adscholar.com
+adscience.nl
+adsco.re
+adscpm.com
+adsdaq.com
+adsdk.yandex.ru
+adsend.de
+adsensecustomsearchads.com
+adserve.ams.rhythmxchange.com
+adserve.gkeurope.de
+adserve.io
+adserve.jbs.org
+adserver.71i.de
+adserver.adultfriendfinder.com
+adserver.adverty.com
+adserver.anawe.cz
+adserver.ariase.org
+adserver.bdoce.cl
+adserver.betandwin.de
+adserver.bing.com
+adserver.bizedge.com
+adserver.bizhat.com
+adserver.break-even.it
+adserver.cams.com
+adserver.cdnstream.com
+adserver.cherryfind.co.uk
+adserver.com
+adserver.diariodosertao.com.br
+adserver.digitoday.com
+adserver.echdk.pl
+adserver.friendfinder.com
+adserver.generationiron.com
+adserver.hwupgrade.it
+adserver.ilango.de
+adserver.industryarena.com
+adserver.info7.mx
+adserver.irishwebmasterforum.com
+adserver.janes.com
+adserver.kontent.com
+adserver.mobi
+adserver.news.com.au
+adserver.nydailynews.com
+adserver.o2.pl
+adserver.oddschecker.com
+adserver.omroepzeeland.nl
+adserver.otthonom.hu
+adserver.pampa.com.br
+adserver.piksel.mk
+adserver.pl
+adserver.portugalmail.net
+adserver.pressboard.ca
+adserver.sanomawsoy.fi
+adserver.sciflicks.com
+adserver.scr.sk
+adserver.smgfiles.com
+adserver.trojaner-info.de
+adserver.tupolska.com
+adserver.twitpic.com
+adserver.virginmedia.com
+adserver.waggonerguide.com
+adserver01.de
+adserverplus.com
+adserverpub.com
+adserversolutions.com
+adserverxxl.de
+adservice.google.com
+adservice.google.com.mt
+adserving.unibet.com
+adservingfront.com
+adservrs.com
+adservrs.com.edgekey.net
+adsfac.eu
+adsfac.net
+adsfac.us
+adsflowprime.top
+adshrink.it
+adside.com
+adsiduous.com
+adskeeper.co.uk
+adskeeper.com
+adsklick.de
+adsmart.net
+adsmartracker.com
+adsmetadata.startappservice.com
+adsmogo.com
+adsnative.com
+adsoftware.com
+adsolut.in
+adspeed.net
+adspirit.de
+adsponse.de
+adspredictiv.com
+adspsp.com
+adsroller.com
+adsrv.deviantart.com
+adsrv.eacdn.com
+adsrv.iol.co.za
+adsrv.kobi.tv
+adsrv.moebelmarkt.tv
+adsrv2.swidnica24.pl
+adsrvr.org
+adstacks.in
+adstanding.com
+adstat.4u.pl
+adstest.weather.com
+adstub.net
+adsupply.com
+adswizz.com
+adsxyz.com
+adsynergy.com
+adsys.townnews.com
+adsystem.simplemachines.org
+adt598.com
+adtech.com
+adtech.de
+adtechjp.com
+adtechus.com
+adtegrity.net
+adthis.com
+adthrive.com
+adtiger.de
+adtilt.com
+adtng.com
+adtology.com
+adtoma.com
+adtrace.org
+adtrack.voicestar.com
+adtraction.com
+adtrade.net
+adultadvertising.com
+adv-adserver.com
+adv.donejty.pl
+adv.freeonline.it
+adv.hwupgrade.it
+adv.mpvc.it
+adv.nexthardware.com
+adv.webmd.com
+adv.wp.pl
+adv.yo.cz
+advangelists.com
+advariant.com
+adventory.com
+adventurousamount.com
+advert.bayarea.com
+advert.dyna.ultraweb.hu
+adverticum.com
+adverticum.net
+advertipros.com
+advertise.com
+advertiserurl.com
+advertising.com
+advertisingbanners.com
+advertisingbox.com
+advertmarket.com
+advertmedia.de
+advertpro.ya.com
+advertserve.com
+advertwizard.com
+advideo.uimserv.net
+adview.com
+advisormedia.cz
+adviva.net
+advnt.com
+adwebone.com
+adwhirl.com
+adworldnetwork.com
+adworx.at
+adworx.nl
+adx.gayboy.at
+adxpansion.com
+adxpose.com
+adyoulike.com
+adz.rashflash.com
+adzbazar.com
+adzerk.net
+adzerk.s3.amazonaws.com
+adzestocp.com
+aerialapps.com
+aerserv.com
+af-ad.co.uk
+affec.tv
+affectionknit.com
+affili.net
+affiliate.1800flowers.com
+affiliate.dtiserv.com
+affiliate.travelnow.com
+affiliate.treated.com
+affiliatefuture.com
+affiliates.allposters.com
+affiliates.babylon.com
+affiliates.globat.com
+affiliates.streamray.com
+affiliates.thinkhost.net
+affiliates.thrixxx.com
+affiliates.ultrahosting.com
+affiliatetracking.com
+affiliatetracking.net
+affiliatewindow.com
+afflnx.com
+afftracking.justanswer.com
+afraidlanguage.com
+agencysignals.com
+agkn.com
+ah-ha.com
+ahalogy.com
+aheadday.com
+aim4media.com
+airplanecoffee.com
+airpush.com
+aistat.net
+ak0gsh40.com
+alchemist.go2cloud.org
+alclick.com
+alenty.com
+alexa-sitestats.s3.amazonaws.com
+algorix.co
+aliasanvil.com
+alikeaddition.com
+alipromo.com
+alluringbucket.com
+aloofmetal.com
+aloofvest.com
+alphonso.tv
+als-svc.nytimes.com
+amazingcounters.com
+amazon-adsystem.com
+americash.com
+amidsttruly.com
+amung.us
+analytics-production.hapyak.com
+analytics.adpost.org
+analytics.algoepico.net
+analytics.bitrix.info
+analytics.cloudron.io
+analytics.ext.go-tellm.com
+analytics.google.com
+analytics.htmedia.in
+analytics.icons8.com
+analytics.inlinemanual.com
+analytics.jst.ai
+analytics.justuno.com
+analytics.lucid.app
+analytics.mailmunch.co
+analytics.mobile.yandex.net
+analytics.momentum-institut.at
+analytics.myfinance.com
+analytics.ostr.io
+analytics.phando.com
+analytics.picsart.com
+analytics.pinterest.com
+analytics.pointdrive.linkedin.com
+analytics.poolshool.com
+analytics.posttv.com
+analytics.santander.co.uk
+analytics.swiggy.com
+analytics.tiktok.com
+analytics.xelondigital.com
+analytics.yahoo.com
+analyticsapi.happypancake.net
+ancientact.com
+androiddownload.net
+aniview.com
+annonser.dagbladet.no
+annoyedairport.com
+annoyingacoustics.com
+anrdoezrs.net
+anstrex.com
+anxiousapples.com
+api.affiliations.site
+api.amplitude.com
+api.appmetrica.yandex.ru
+api.eu.amplitude.com
+api.intensifier.de
+api.iterable.com
+api.kameleoon.com
+api.lab.amplitude.com
+api.rudderlabs.com
+api.swetrix.com
+api2.amplitude.com
+apolloprogram.io
+app-analytics-v2.snapchat.com
+app-analytics.snapchat.com
+app-measurement.com
+app.pendo.io
+app2.salesmanago.pl
+appboycdn.com
+applovin.com
+appsflyer.com
+aps.hearstnp.com
+apsalar.com
+aptabase.com
+apture.com
+apu.samsungelectronics.com
+aquaticowl.com
+aralego.com
+arc1.msn.com
+archswimming.com
+ard.xxxblackbook.com
+aromamirror.com
+as.webmd.com
+as2.adserverhd.com
+aserv.motorsgate.com
+asewlfjqwlflkew.com
+askdriver.com
+aso1.net
+assets1.exgfnetwork.com
+assoc-amazon.com
+aswpapius.com
+aswpsdkus.com
+async.gsyndication.com
+at-adserver.alltop.com
+at-o.net
+atdmt.com
+athena-ads.wikia.com
+ato.mx
+attractionbanana.com
+attribution.report
+atwola.com
+auctionads.com
+auctionads.net
+aud.pubmatic.com
+audience.media
+audience2media.com
+audienceinsights.com
+audio.ad
+audit.median.hu
+audit.webinform.hu
+augur.io
+auto-bannertausch.de
+avalonalbum.com
+avazutracking.net
+avenuea.com
+avocet.io
+awempire.com
+awin1.com
+awstrack.me
+awzbijw.com
+axonix.com
+ay.delivery
+ayads.co
+b-s.tercept.com
+b.videoamp.com
+b3.videoamp.com
+ba.afl.rakuten.co.jp
+backbeatmedia.com
+bagsurprise.com
+banik.redigy.cz
+banner.ambercoastcasino.com
+banner.buempliz-online.ch
+banner.cotedazurpalace.com
+banner.easyspace.com
+banner.elisa.net
+banner.finzoom.ro
+banner.goldenpalace.com
+banner.inyourpocket.com
+banner.linux.se
+banner.media-system.de
+banner.nixnet.cz
+banner.noblepoker.com
+banner.northsky.com
+banner.reinstil.de
+banner.tanto.de
+banner.titan-dsl.de
+banner10.zetasystem.dk
+bannerads.de
+bannerboxes.com
+bannerconnect.com
+bannerconnect.net
+bannergrabber.internet.gr
+bannerimage.com
+bannermall.com
+bannermanager.bnr.bg
+bannerpower.com
+banners.adultfriendfinder.com
+banners.amigos.com
+banners.asiafriendfinder.com
+banners.babylon-x.com
+banners.bol.com.br
+banners.cams.com
+banners.czi.cz
+banners.dine.com
+banners.direction-x.com
+banners.freett.com
+banners.friendfinder.com
+banners.getiton.com
+banners.iq.pl
+banners.passion.com
+banners.payserve.com
+banners.resultonline.com
+banners.sys-con.com
+banners.thomsonlocal.com
+banners.virtuagirlhd.com
+bannerserver.com
+bannershotlink.perfectgonzo.com
+bannersng.yell.com
+bannerspace.com
+bannerswap.com
+bannertrack.net
+bannery.cz
+bannieres.wdmedia.net
+bans.bride.ru
+baremetrics.com
+barnesandnoble.bfast.com
+basebanner.com
+basketballbelieve.com
+baskettexture.com
+bastingart.com
+bat.bing.com
+bbelements.com
+bbn.img.com.ua
+beachfront.com
+beacon.gu-web.net
+beacon.netflix.com
+beacons.gcp.gvt2.com
+beacons.gvt2.com
+bebi.com
+beemray.com
+begun.ru
+behavioralengine.com
+belstat.com
+belstat.nl
+benefits.sovendus.com
+benfly.net
+berp.com
+bespoke.iln8.net
+bestboundary.com
+bestbuy.7tiv.net
+bewilderedblade.com
+bfmio.com
+bhcumsc.com
+bid.pubmatic.com
+bidbarrel.cbsnews.com
+bidclix.com
+bidclix.net
+bidpapers.com
+bidr.io
+bidsopt.com
+bidswitch.net
+bidtellect.com
+bidvertiser.com
+big-bang-ads.com
+bigbangmedia.com
+bigclicks.com
+bigfishapparel.com
+bigreal.org
+bigworldfashion.com
+billboard.cz
+billtable.com
+birthdaybelief.com
+bitmedianetwork.com
+bizible.com
+bizographics.com
+bizrate.com
+bizzclick.com
+bkrtx.com
+bleachbubble.com
+blingbucks.com
+blis.com
+blockadblock.com
+blogads.com
+blogcounter.de
+blogherads.com
+blogtoplist.se
+blogtopsites.com
+blueconic.com
+blueconic.net
+bluekai.com
+bluelithium.com
+bluenest.net
+bluewhaleweb.com
+blushingbeast.com
+blushingbread.com
+bm.annonce.cz
+bn.bfast.com
+bnrs.ilm.ee
+boffoadsapi.com
+boilingbeetle.com
+boilingmadsoup.com
+bongacash.com
+boomads.com
+boomtrain.com
+boredcrown.com
+boudja.com
+bounceads.net
+bounceexchange.com
+bowie-cdn.fathomdns.com
+box.anchorfree.net
+bpath.com
+bpu.samsungelectronics.com
+braincash.com
+brand-display.com
+brandreachsys.com
+brandybison.com
+braze.eu
+breadbalance.com
+breakableinsurance.com
+breaktime.com.tw
+brealtime.com
+bridgetrack.com
+brightcom.com
+brightinfo.com
+brightmountainmedia.com
+broadcastbed.com
+broadstreetads.com
+browser-http-intake.logs.datadoghq.com
+browser-http-intake.logs.datadoghq.eu
+bs.yandex.ru
+btglss.net
+btrll.com
+bttrack.com
+bubblyaction.com
+buddycanvas.com
+buysellads.com
+buzzonclick.com
+bwp.download.com
+c.bigmir.net
+c1exchange.com
+c212.net
+cakesdrum.com
+calculatingcircle.com
+calculatorstatement.com
+call-ad-network-api.marchex.com
+callousbrake.com
+callrail.com
+calmcactus.com
+calypsocapsule.com
+campaign.bharatmatrimony.com
+caniamedia.com
+capriciouscorn.com
+captainbicycle.com
+captainstick.com
+carambo.la
+carbonads.com
+carbonads.net
+cardmethod.com
+caringcast.com
+carsarace.com
+cartstack.com
+carvecakes.com
+casalemedia.com
+casalmedia.com
+cash4members.com
+cash4popup.de
+cashcrate.com
+cashengines.com
+cashfiesta.com
+cashpartner.com
+cashstaging.me
+casinopays.com
+casinorewards.com
+casinotraffic.com
+cattlecommittee.com
+causecherry.com
+cautiouscredit.com
+cbanners.virtuagirlhd.com
+cbzxy.com
+cdn.bannerflow.com
+cdn.branch.io
+cdn.freshmarketer.com
+cdn.heapanalytics.com
+cdn.keywee.co
+cdn.mouseflow.com
+cdn.onesignal.com
+cdn.scarabresearch.com
+cdn.segment.com
+cdnondemand.org
+cedato.com
+celtra.com
+centerpointmedia.com
+cetrk.com
+cgicounter.puretec.de
+chairscrack.com
+channelintelligence.com
+chargecracker.com
+chart.dk
+chartbeat.com
+chartbeat.net
+chartboost.com
+checkstat.nl
+cherriescare.com
+childlikecrowd.com
+chubbycreature.com
+citrusad.net
+cityads.telus.net
+cj.com
+cjbmanagement.com
+cjlog.com
+cl.turkishairlines.com
+cl0udh0st1ng.com
+clck.ru
+clevernt.com
+click-1.pl
+click.airmalta-mail.com
+click.aliexpress.com
+click.allkeyshop.com
+click.bkdpt.com
+click.cartsguru.io
+click.ccg.nintendo.com
+click.cision.com
+click.classmates.com
+click.comm.rcibank.co.uk
+click.crm.ba.com
+click.digital.metaquestmail.com
+click.discord.com
+click.e.bbcmail.co.uk
+click.e.progressive.com
+click.e.zoom.us
+click.em.blizzard.com
+click.email.bbc.com
+click.email.lhh.com
+click.email.microsoftemail.com
+click.email.sonos.com
+click.emails.argos.co.uk
+click.emails.tuclothing.sainsburys.co.uk
+click.fool.com
+click.hookupinyourcity.com
+click.hooligapps.com
+click.i.southwesternrailway.com
+click.infoblox.com
+click.justwatch.com
+click.kmindex.ru
+click.liftoff.io
+click.mail.hotels.com
+click.mail.salesforce.com
+click.mailing.ticketmaster.com
+click.mkt.grab.com
+click.news.vans.com
+click.nl.npr.org
+click.nvgaming.nvidia.com
+click.redditmail.com
+click.uber.com
+click.v.visionlab.es
+click2freemoney.com
+click360v2-ingest.azurewebsites.net
+click4.pro
+clickadddilla.com
+clickadz.com
+clickagents.com
+clickbank.com
+clickbooth.com
+clickboothlnk.com
+clickbrokers.com
+clickcease.com
+clickcompare.co.uk
+clickdensity.com
+clickedyclick.com
+clickfuse.com
+clickhereforcellphones.com
+clickngo.pro
+clickngo.top
+clickonometrics.pl
+clicks.checkatrade.com
+clicks.deliveroo.co.uk
+clicks.equantum.com
+clicks.eventbrite.com
+clicks.monzo.com
+clickserve.cc-dt.com
+clicksinfo.thefork.co.uk
+clicktag.de
+clickthruserver.com
+clickthrutraffic.com
+clicktrack.pubmatic.com
+clicktrack.ziyu.net
+clicktracks.com
+clicktrade.com
+clickxchange.com
+clickyab.com
+clickz.com
+clientgear.com
+clientmetrics-pa.googleapis.com
+clikerz.net
+cliksolution.com
+clixgalore.com
+clk1005.com
+clk1011.com
+clk1015.com
+clkrev.com
+clksite.com
+cloudflareinsights.com
+cloudguppy.com
+clrstm.com
+cluster.adultworld.com
+clustrmaps.com
+cmp.dmgmediaprivacy.co.uk
+cmvrclicks000.com
+cnomy.com
+cnt1.pocitadlo.cz
+cnvlink.com
+cny.yoyo.org
+codeadnetwork.com
+cognitiv.ai
+cointraffic.io
+coldbalance.com
+collector-dev.cdp-dev.cnn.com
+collector.cdp.cnn.com
+colonize.com
+colorfulpet.com
+coloroptimizer.com
+comfortablecheese.com
+commissionmonster.com
+communications.melitaltd.com
+compactbanner.com
+comparereaction.com
+compilework.com
+comprabanner.it
+conditionchange.com
+conductrics.com
+confiant-integrations.net
+confidencetalks.com
+configv2.unityads.unity3d.com
+connatix.com
+connectad.io
+connextra.com
+consciouscheese.com
+consensad.com
+consensu.org
+contadores.miarroba.com
+content.acc-hd.de
+content.ad
+content22.online.citi.com
+contextweb.com
+contrack.link
+converge-digital.com
+conversantmedia.com
+conversionbet.com
+conversionruler.com
+convertingtraffic.com
+convrse.media
+cookies.cmpnet.com
+coolkidsdistrict.com
+cootlogix.com
+copperstills.net
+copycarpenter.com
+copyrightaccesscontrols.com
+coremetrics.com
+cosmosjackson.com
+count.rin.ru
+count.west263.com
+counted.com
+counter.bloke.com
+counter.cnw.cz
+counter.cz
+counter.dreamhost.com
+counter.mirohost.net
+counter.mojgorod.ru
+counter.rambler.ru
+counter.search.bg
+counter.snackly.co
+counting.kmindex.ru
+coupling-media.de
+cowbelltime.com
+coxmt.com
+cozyhillside.com
+cpalead.com
+cpays.com
+cpmstar.com
+cpu.samsungelectronics.com
+cpx.to
+cpxinteractive.com
+cqcounter.com
+crabbychin.com
+craktraffic.com
+crashchance.com
+crashlytics.com
+crashlyticsreports-pa.googleapis.com
+cratecamera.com
+crawlability.com
+crazyegg.com
+crazypopups.com
+creatives.livejasmin.com
+creatopy.net
+crimsonmeadow.com
+criteo.com
+criteo.net
+critictruck.com
+crowdedmass.com
+crowdgravity.com
+crsspxl.com
+crta.dailymail.co.uk
+crtv.mate1.com
+crwdcntrl.net
+crypto-loot.org
+crystalboulevard.com
+cs.co
+curbminers.com
+curiousmetal.com
+curtaincows.com
+curveshore.com
+cushiondrum.com
+customad.cnn.com
+customads.co
+customerevents.netflix.com
+customers.kameleoon.com
+cutechin.com
+cxense.com
+cyberbounty.com
+cyclinghere.com
+d-collect.jennifersoft.com
+d-collector.jennifersoft.com
+d.adroll.com
+d1f0tbk1v3e25u.cloudfront.net
+d2cmedia.ca
+d81mfvml8p5ml.cloudfront.net
+dabiaozhi.com
+dacdn.visualwebsiteoptimizer.com
+dacdn.vwo.com
+dakic-ia-300.com
+damageddistance.com
+damdoor.com
+dapper.net
+data.namesakeoscilloscopemarquis.com
+datapickles.com
+datenow.link
+daybreaklights.com
+dc-storm.com
+de17a.com
+dealdotcom.com
+decenterads.com
+decisivebase.com
+decisivedrawer.com
+decknetwork.net
+deepintent.com
+delicatecascade.com
+deloo.de
+demandbase.com
+demdex.net
+deployads.com
+desertgates.com
+desiredirt.com
+detailedgovernment.com
+detectdiscovery.com
+dev.visualwebsiteoptimizer.com
+dewdroplagoon.com
+dianomi.com
+dicecandies.com
+didtheyreadit.com
+digestiondrawer.com
+digital-ads.s3.amazonaws.com
+direct-events-collector.spot.im
+direct-promo.pro
+directaclick.com
+directorym.com
+discountclick.com
+discreetfield.com
+displayvertising.com
+disqusads.com
+dist.belnk.com
+distillery.wistia.com
+districtm.ca
+districtm.io
+dmp.mall.tv
+dmtracker.com
+dmtracking.alibaba.com
+dmtracking2.alibaba.com
+dnsdelegation.io
+do-global.com
+dockdigestion.com
+dogcollarfavourbluff.com
+domaining.in
+domdex.com
+dotmetrics.net
+dotomi.com
+doubleclick.com
+doubleclick.de
+doubleclick.net
+doublepimp.com
+doubleverify.com
+dpbolvw.net
+dpu.samsungelectronics.com
+dq95d35.com
+dragonbats.com
+drumcash.com
+dsp.colpirio.com
+dsp.io
+dstillery.com
+dustyhammer.com
+dyntrk.com
+e-eu.customeriomail.com
+e-m.fr
+e-planning.net
+e.customeriomail.com
+e.kde.cz
+e37364.dscd.akamaiedge.net
+eadexchange.com
+eas.almamedia.fi
+easyhits4u.com
+ebayadvertising.com
+ebuzzing.com
+echoacloud.com
+ecircle-ag.com
+ecleneue.com
+eclick.vn
+eclicks.deliveroo.com
+eclkspbn.com
+ecoupons.com
+edaa.eu
+edgexads.com
+eighthlayer.net
+eiv.baidu.com
+elasticchange.com
+elderlytown.com
+elitedollars.com
+em1.yoursantander.co.uk
+email-link.adtidy.info
+email-link.adtidy.net
+email-link.adtidy.org
+email-links.crowdfireapp.com
+email-open.adtidy.net
+email-open.adtidy.org
+email-trk.ihg-businessedge.com
+email.mg1.substack.com
+emailer.stockbit.com
+emaillinks.soundiiz.com
+emebo.io
+emerse.com
+emetriq.de
+emjcd.com
+eml.blackduck.com
+emltrk.com
+emodoinc.com
+emptyescort.com
+emxdigital.com
+energeticladybug.com
+engage.tines.com
+engage.windows.com
+engagebdr.com
+engageya.com
+engine.espace.netavenir.com
+engineertrick.com
+enginenetwork.com
+enormousearth.com
+enquisite.com
+ensighten.com
+entercasino.com
+entrecard.s3.amazonaws.com
+enviousthread.com
+epom.com
+epp.bih.net.ba
+eqads.com
+eqy.link
+erne.co
+ero-advertising.com
+essaygiants.com
+esty.com
+et.educationdynamics.com
+et.nytimes.com
+etahub.com
+etargetnet.com
+etracker.com
+etracker.de
+eu-adcenter.net
+eule1.pmu.fr
+eulerian.net
+eurekster.com
+euros4click.de
+eusta.de
+evadav.com
+evadavdsp.pro
+evencoating.com
+eventexistence.com
+events-eu.freshsuccess.com
+events-us.freshsuccess.com
+everestads.net
+everesttech.net
+evergage.com
+eversales.space
+evs.sgmt.loom.com
+evyy.net
+exampleshake.com
+exchange-it.com
+exchangead.com
+exchangeclicksonline.com
+exelate.com
+exelator.com
+exhibitsneeze.com
+exit76.com
+exitexchange.com
+exitfuel.com
+exoclick.com
+exosrv.com
+experianmarketingservices.digital
+explorads.com
+exponea.com
+exponential.com
+exportdialog.com
+express-submit.de
+extractobservation.com
+extreme-dm.com
+extremetracking.com
+eyeota.net
+eyeviewads.com
+eyewonder.com
+ezula.com
+f.pie.org
+f7ds.liberation.fr
+fabric.io
+fadedsnow.com
+fairfeeling.com
+fakedisguise.com
+fallaciousfifth.com
+fallingshoals.com
+fam-ad.com
+farethief.com
+farmergoldfish.com
+fast-redirecting.com
+fastclick.com
+fastclick.com.edgesuite.net
+fastclick.net
+fastly-insights.com
+faultycanvas.com
+fave.co
+fc.webmasterpro.de
+feedbackresearch.com
+feedjit.com
+feedmob.com
+femalecook.com
+figsprotein.com
+figurehunter.net
+fillthemap.com
+fimserve.com
+findcommerce.com
+findyourcasino.com
+fireads.online
+fireads.org
+fireworkadservices.com
+fireworkanalytics.com
+fireworks-advertising.com
+firstlightera.com
+fishingtoolsbox.com
+fixedfold.com
+fjordsand.com
+flairadscpc.com
+flakyfeast.com
+flashtalking.com
+flashtexting.com
+fleshlightcash.com
+flexbanner.com
+flimsycircle.com
+flimsythought.com
+floodprincipal.com
+flourishinginnovation.com
+floweryflavor.com
+flowgo.com
+flurry.com
+fontserif.com
+foo.cosmocode.de
+foresee.com
+forex-affiliate.net
+forkcdn.com
+fourlevelsgame.com
+fpctraffic.com
+fpjs.io
+fqtag.com
+fraysystems.com
+free-counter.co.uk
+freebanner.com
+freecounterstat.com
+freedomgrail.com
+freelogs.com
+freepay.com
+freestats.com
+freestats.tv
+freewebcounter.com
+freewheel.com
+freewheel.tv
+freezingbuilding.com
+frequentflesh.com
+freshrelevance.com
+fronttoad.com
+frtyj.com
+frtyk.com
+fudgegenie.com
+fullrestore.net
+fullstory.com
+functionalcrown.com
+functionalfeather.com
+funklicks.com
+funnelytics.io
+funtoyplanet.com
+furryfork.com
+fusionads.net
+fusionquest.com
+futuristicfifth.com
+futuristicframe.com
+fuzzybasketball.com
+fwcdn1.com
+fwcdn2.com
+fxstyle.net
+g2.gumgum.com
+ga.clearbit.com
+gadsbee.com
+galaxien.com
+game-advertising-online.com
+gamesites100.net
+gamesites200.com
+gammamaximum.com
+gaug.es
+gavvia.com
+gearwom.de
+geo.digitalpoint.com
+geobanner.adultfriendfinder.com
+georiot.com
+geovisite.com
+getclicky.com
+getintent.com
+getmyads.com
+getxmlisi.com
+giddycoat.com
+glasscoyote.com
+glisteningsign.com
+globalismedia.com
+gloriousbeef.com
+gmads.net
+gml.email
+go-clicks.de
+go-link.network
+go-mpulse.net
+go-rank.de
+go.clickwww.com
+go.dhs.gov
+go.eu.sparkpostmail1.com
+go.first.org
+go.icann.org
+go.scmagazine.com
+go.usa.gov
+go.xlirdr.com
+go2affise.com
+godseedband.com
+goingplatinum.com
+goldstats.com
+gondolagnome.com
+goodcontentservice.top
+google-analytics.com
+googleadservices.com
+googleanalytics.com
+googlesyndication.com
+googletagmanager.com
+googletagservices.com
+goqon.com
+gostats.com
+gothamads.com
+gotoyahoo.com
+gotraffic.net
+gp.dejanews.com
+grandfatherguitar.com
+granlite.com
+grapeshot.co.uk
+greystripe.com
+groovespacing.com
+grouchybrothers.com
+groundtruth.com
+growthrx.in
+gscontxt.net
+guardeddirection.com
+guardedschool.com
+gumyfui.com
+gunggo.com
+h-bid.com
+h-trck.com
+h0.t.hubspotemail.net
+haikusoap.com
+halcyoncanyon.com
+halocolor.com
+haltingbadge.com
+hammerhearing.com
+hamsterspot.com
+handsomehose.com
+handyfireman.com
+handyincrease.com
+haplesshydrant.com
+harrenmedia.com
+harrenmedianetwork.com
+hayweb.net
+hb.afl.rakuten.co.jp
+hb.vntsm.com
+hbb.afl.rakuten.co.jp
+hbopenbid.pubmatic.com
+heap.com
+heimi-lwx.com
+hellobar.com
+helpcollar.com
+hentaicounter.com
+herbalaffiliateprogram.com
+hexcan.com
+hexusads.fluent.ltd.uk
+heyos.com
+hf5rbejvpwds.com
+hfc195b.com
+hgads.com
+highnoongear.com
+hightrafficads.com
+hilariouszinc.com
+histats.com
+historytrade.com
+hit-parade.com
+hit.ua
+hit.webcentre.lycos.co.uk
+hitbox.com
+hitcounters.miarroba.com
+hitlist.ru
+hitlounge.com
+hitometer.com
+hits-i.iubenda.com
+hits.europuls.eu
+hits.informer.com
+hits.puls.lv
+hits.sh
+hits.theguardian.com
+hits4me.com
+hitslink.com
+hittail.com
+hlok.qertewrt.com
+hocgeese.com
+hollowafterthought.com
+homelycrown.com
+homepageking.de
+honorableland.com
+hostedads.realitykings.com
+hotjar.com
+hotlog.ru
+hotrank.com.tw
+hoverowl.com
+hs-analytics.net
+hs-banner.com
+hsadspixel.net
+hsleadflows.net
+hsn.uqhv.net
+htlbid.com
+httpool.com
+hubspotlinks.com
+hueads.com
+hueadsortb.com
+hueadsxml.com
+hurricanedigitalmedia.com
+hustlercoach.com
+hydraconcept.com
+hydramedia.com
+hyperbanner.net
+hypertracker.com
+hyprmx.com
+hystericalcloth.com
+i-i.lt
+i305175.net
+ia.iinfo.cz
+iad.anm.co.uk
+iadnet.com
+ibillboard.com
+icptrack.com
+icywinter.com
+id5-sync.com
+idealadvertising.net
+idevaffiliate.com
+idtargeting.com
+ientrymail.com
+iesnare.com
+ifa.tube8live.com
+ilbanner.com
+ilead.itrack.it
+illustriousoatmeal.com
+image2.pubmatic.com
+image3.pubmatic.com
+image4.pubmatic.com
+image6.pubmatic.com
+imagecash.net
+images-pw.secureserver.net
+img.prohardver.hu
+imgpromo.easyrencontre.com
+immensehoney.com
+imonomy.com
+imp.i312864.net
+impossibleexpansion.com
+imprese.cz
+impressionmedia.cz
+impressionmonster.com
+improvedigital.com
+imrworldwide.com
+inclk.com
+incognitosearches.com
+incoming-telemetry.thunderbird.net
+incoming.telemetry.mozilla.org
+indexexchange.com
+indexstats.com
+indexww.com
+indieclick.com
+industrybrains.com
+inetlog.ru
+infinite-ads.com
+infinityads.com
+infoevent.startappservice.com
+infolinks.com
+inmobi.com
+inner-active.com
+inner-active.mobi
+innovid.com
+inquisitiveinvention.com
+insgly.net
+insidepsych.net
+insightexpress.com
+insightexpressai.com
+inskinad.com
+inspectlet.com
+install.365-stream.com
+instantmadness.com
+insticator.com
+intelliads.com
+intelligenceadx.com
+interactive.forthnet.gr
+intercom-clicks.com
+intergi.com
+internalcondition.com
+internetfuel.com
+interreklame.de
+ioam.de
+ip.ro
+ip193.cn
+iperceptions.com
+ipredictive.com
+ipstack.com
+irchan.com
+ireklama.cz
+is-tracking-pixel-api-prod.appspot.com
+islandwebhelp.com
+itop.cz
+its-that-easy.com
+ivwbox.de
+ivykiosk.com
+iyfbodn.com
+iyfnzgb.com
+j93557g.com
+jads.co
+jamexport.com
+jcount.com
+jdoqocy.com
+jewelrysprings.com
+jinkads.de
+joetec.net
+joyoussurprise.com
+js-agent.newrelic.com
+js-api.otherlevels.com
+js-tags.otherlevels.com
+js.iterable.com
+js.users.51.la
+jsecoin.com
+jsrdn.com
+jubilantglimmer.com
+juiceblocks.com
+juicyads.com
+juicyads.me
+jumptap.com
+jungroup.com
+justicejudo.com
+justpremium.com
+justrelevant.com
+justwowjars.com
+k.iinfo.cz
+kameleoon.eu
+kanoodle.com
+kargo.com
+kernellife.com
+kickoffo.site
+kindads.com
+kindlereunion.com
+kissmetrics.com
+kittentacos.com
+kittycatking.com
+klclick.com
+klclick1.com
+kliks.nl
+knitstamp.com
+knorex.com
+knottyswing.com
+komoona.com
+kompasads.com
+kontera.com
+kost.tv
+kpu.samsungelectronics.com
+krxd.net
+ktu.sv2.biz
+kueezrtb.com
+kvsadman.com
+l1.britannica.com
+lakesecure.com
+lameletters.com
+landkarts.com
+larati.net
+largebrass.com
+laughcloth.com
+launchbit.com
+layer-ad.de
+layer-ads.de
+lazybumblebee.com
+lbn.ru
+lead02.com
+leadboltads.net
+leadclick.com
+leadinfo.net
+leadingedgecash.com
+leadplace.fr
+leadspace.com
+leadzupc.com
+leaplunchroom.com
+leftliquid.com
+lemmatechnologies.com
+lemnisk.co
+lever-analytics.com
+lfeeder.com
+lfstmedia.com
+lgsmartad.com
+li.alibris.com
+li.azstarnet.com
+li.dailycaller.com
+li.gatehousemedia.com
+li.gq.com
+li.hearstmags.com
+li.livingsocial.com
+li.mw.drhinternet.net
+li.onetravel.com
+li.patheos.com
+li.pmc.com
+li.realtor.com
+li.ziffimages.com
+liadm.com
+libraryfacts.com
+lifeimpressions.net
+liftdna.com
+ligatus.com
+ligatus.de
+lightspeedcash.com
+lightstep.medium.systems
+lijit.com
+limecodesign.com
+link-booster.de
+link.axios.com
+link.beelivery.com
+link.email.davidlloydclubs.co.uk
+link.email.usmagazine.com
+link.go.chase
+link.sbstck.com
+link.team.hyperoptic.com
+link.theatlantic.com
+link.uk.expediamail.com
+linkbuddies.com
+linkexchange.com
+linkprice.com
+linkrain.com
+linkreferral.com
+links-ranking.de
+links.email.crunchbase.com
+links.housekeep.com
+links.prosservice.fr
+links.zoopla.co.uk
+linksoutside.com
+linkstable.com
+linkstorms.com
+linkswaper.com
+linksynergy.com
+linktarget.com
+linkvertise.com
+liquidad.narrowcastmedia.com
+litix.io
+live.trmzum.com
+liveadexchanger.com
+liveintent.com
+livelylaugh.com
+liverail.com
+livingsleet.com
+lizardslaugh.com
+lkqd.com
+lnks.gd
+loading321.com
+loadsurprise.com
+locked4.com
+lockerdome.com
+locolava.com
+log.btopenworld.com
+log.logrocket.io
+log.pinterest.com
+log.videocampaign.co
+logger.snackly.co
+logs.roku.com
+logs.spilgames.com
+logsss.com
+logua.com
+look.djfiln.com
+look.ichlnk.com
+look.opskln.com
+look.ufinkln.com
+loopme.com
+loudlunch.com
+lowest-prices.eu
+lucidmedia.com
+luckyorange.com
+ludicrousarch.com
+lyricshook.com
+lytics.io
+lzjl.com
+m.trb.com
+m2.ai
+m32.media
+m4n.nl
+m6r.eu
+mackeeperapp.mackeeper.com
+madclient.uimserv.net
+madcpms.com
+madinad.com
+madisonavenue.com
+madvertise.de
+magicadz.co
+magicaljoin.com
+magsrv.com
+mail-ads.google.com
+maltiverse.lt.acemlnc.com
+manageadv.cblogs.eu
+mantisadnetwork.com
+mapcommand.com
+marinsm.com
+markedmeasure.com
+marketing.888.com
+marketing.desertcart.com
+marketing.net.brillen.de
+marketing.net.home24.de
+marketing.net.occhiali24.it
+marketing.nyi.net
+marketing.osijek031.com
+marketingcloudapis.com
+marketingsolutions.yahoo.com
+marketo.com
+marlowpillow.sjv.io
+marriedbelief.com
+mas.sector.sk
+matchcraft.com
+matheranalytics.com
+mathtag.com
+matomo.activate.cz
+matomo.crossiety.app
+mautic.com
+max.i12.de
+maximiser.net
+maxonclick.com
+mbs.megaroticlive.com
+mcdlks.com
+mcs-va.tiktok.com
+mcs-va.tiktokv.com
+meadowlullaby.com
+measlymiddle.com
+measure.office.com
+measuremap.com
+meatydime.com
+media-adrunner.mycomputer.com
+media.funpic.de
+media.net
+media01.eu
+media6degrees.com
+mediaarea.eu
+mediabridge.cc
+mediafuse.com
+mediageneral.com
+mediaiqdigital.com
+mediamath.com
+mediamgr.ugo.com
+mediaplazza.com
+mediaplex.com
+mediascale.de
+mediaserver.bwinpartypartners.it
+mediasmart.io
+mediasquare.fr
+mediatext.com
+mediavine.com
+mediavoice.com
+mediax.angloinfo.com
+mediaz.angloinfo.com
+medleyads.com
+medyanetads.com
+meetrics.net
+megacash.de
+megastats.com
+megawerbung.de
+meltmilk.com
+memorizeneck.com
+mercuryace.com
+merequartz.com
+messagelists.com
+metadsp.co.uk
+metaffiliation.com
+metajaws.com
+metanetwork.com
+methodcash.com
+metrics-logger.spot.im
+metrics.api.drift.com
+metrics.articulate.com
+metrics.cnn.com
+metrics.foxnews.com
+metrics.getrockerbox.com
+metrics.gfycat.com
+metrics.govexec.com
+metrics.icloud.com
+metrics.mzstatic.com
+metrilo.com
+mfadsrvr.com
+mg2connext.com
+mgid.com
+microstatic.pl
+microticker.com
+milotree.com
+mineinvoice.com
+minewhat.com
+minibilling.com
+mintegral.com
+mintfunnel.co
+mittencattle.com
+mix2ads.com
+mixedreading.com
+mixpanel.com
+mkto-ab410147.com
+mktoresp.com
+ml314.com
+mlm.de
+mlsend.com
+mltrk.io
+mmismm.com
+mmstat.com
+mmtro.com
+mntzrlt.net
+moartraffic.com
+moat.com
+moatads.com
+moatpixel.com
+mobclix.com
+mobfox.com
+mobileanalytics.us-east-1.amazonaws.com
+mobilefuse.com
+modernpricing.com
+mon-va.byteoversea.com
+mon.byteoversea.com
+monarchads.com
+monetate.net
+monetizer101.com
+monkeyapes.com
+monsterpops.com
+mookie1.com
+mopub.com
+morefolks.com
+motionlessmeeting.com
+motionspots.com
+mousestats.com
+movad.net
+movemeal.com
+mparticle.com
+mpstat.us
+mr-rank.de
+mrskincash.com
+mstrlytcs.com
+mtrcs.samba.tv
+mtree.com
+munchkin.marketo.net
+mundanenail.com
+mushroomgods.com
+musiccounter.ru
+muteknife.com
+muwmedia.com
+mxptint.net
+myads.company
+myads.net
+myads.telkomsel.com
+myaffiliateprogram.com
+mybbc-analytics.files.bbci.co.uk
+mybloglog.com
+mybuys.com
+mycounter.ua
+mydas.mobi
+mylead-tracking.tracknow.info
+mylead.global
+mylink-today.com
+mypagerank.net
+mypowermall.com
+mysketchpad.com
+mystat-in.net
+mystat.pl
+mytop-in.net
+n69.com
+naj.sk
+nakedly.ai
+nappyattack.com
+nappyneck.com
+nastydollars.com
+nativeroll.tv
+navegg.com
+navigator.io
+navrcholu.cz
+ncaudienceexchange.com
+ndparking.com
+nebulacrescent.com
+nedstatbasic.net
+needyneedle.com
+neighborlywatch.com
+nend.net
+neocounter.neoworx-blog-tools.net
+nervoussummer.com
+net-filter.com
+netaffiliation.com
+netagent.cz
+netclickstats.com
+netdirect.nl
+netech.postaffiliatepro.com
+netmera-web.com
+netmera.com
+netmng.com
+netpool.netbookia.net
+netshelter.net
+neudesicmediagroup.com
+newads.bangbros.com
+newnet.qsrch.com
+newnudecash.com
+news-cdn.site
+newsadsppush.com
+newsbotnet.com
+newt1.adultadworld.com
+newt1.adultworld.com
+nexac.com
+nexage.com
+ng3.ads.warnerbros.com
+nitroclicks.com
+nmtracking.netflix.com
+noiselessplough.com
+nondescriptcrowd.com
+nondescriptnote.com
+nondescriptstocking.com
+novem.pl
+nowaymail.com
+npttech.com
+nr-data.net
+nr.mmcdn.com
+nr.static.mmcdn.com
+ns1p.net
+ntv.io
+ntvk1.ru
+nullitics.com
+nuseek.com
+nzaza.com
+o2.mouseflow.com
+o333o.com
+oafishobservation.com
+oas.benchmark.fr
+oas.repubblica.it
+oas.roanoke.com
+oas.toronto.com
+oas.uniontrib.com
+oascentral.chicagobusiness.com
+oascentral.fortunecity.com
+oascentral.register.com
+objecthero.com
+obscenesidewalk.com
+oceancloudhosts.com
+oclasrv.com
+odbierz-bony.ovp.pl
+oewa.at
+offaces-butional.com
+offer.fyber.com
+offer.sponsorpay.com
+offerforge.com
+offermatica.com
+offshoregeology.com
+ogads-pa.googleapis.com
+oglasi.posjetnica.com
+ogury.com
+ojrq.net
+omg10.com
+omnijay.com
+omniture.com
+omtrdc.net
+onaudience.com
+onclickads.net
+onegg.site
+onestat.com
+onestatfree.com
+online-metrix.net
+online.miarroba.com
+onlinecash.com
+onlinecashmethod.com
+onlinerewardcenter.com
+onlinestarten.net
+onscroll.com
+onthe.io
+opads.us
+open.oneplus.net
+openad.tf1.fr
+openad.travelnow.com
+openads.friendfinder.com
+openads.org
+openadsnetwork.com
+openbid.pubmatic.com
+openx.angelsgroup.org.uk
+openx.cairo360.com
+openx.net
+openx.skinet.cz
+openx.smcaen.fr
+openx2.kytary.cz
+operationchicken.com
+opienetwork.com
+opmnstr.com
+oppuz.com
+optimallimit.com
+optimizely.com
+optimost.com
+optionsnomad.com
+optmd.com
+optmnstr.com
+optmstr.com
+optnmstr.com
+optnx.com
+orbsrv.com
+orientedargument.com
+orionember.com
+ota.cartrawler.com
+otto-images.developershed.com
+ourdreamstaticpages.pages.dev
+outbrain.com
+overconfidentfood.com
+overkick.com
+overture.com
+ow.pubmatic.com
+owebmoney.ru
+owlsr.us
+owneriq.net
+oxado.com
+oxcash.com
+oxen.hillcountrytexas.com
+p-n.io
+p7cloud.net
+paa-reporting-advertising.amazon
+page-checker.eu
+pagead.l.google.com
+pagefair.com
+pagerank-ranking.de
+pageranktop.com
+painstakingpickle.com
+paleleaf.com
+panickypancake.com
+panoramicplane.com
+parachutehome.sjv.io
+parchedsofa.com
+parentpicture.com
+parsely.com
+parsimoniouspolice.com
+partner-ads.com
+partner.pelikan.cz
+partnerad.l.google.com
+partnerads.ysm.yahoo.com
+partnercash.de
+partnerhut.com
+partnerlinks.io
+partners.priceline.com
+partplanes.com
+passeura.com
+paychat.fuse-cloud.com
+paycounter.com
+paypopup.com
+pbnet.ru
+pbterra.com
+pc-tc.s3-eu-west-1.amazonaws.com
+pcash.imlive.com
+peep-auktion.de
+peer39.com
+pennyweb.com
+pepperjamnetwork.com
+percentmobile.com
+perfectaudience.com
+perfiliate.com
+performancerevenue.com
+performancerevenues.com
+performancing.com
+permutive.com
+personagraph.com
+pgl.example.com
+pgl.example0101
+pgmediaserve.com
+pgpartner.com
+pheedo.com
+phoenix-adrunner.mycomputer.com
+piano.io
+pimproll.com
+ping.ublock.org
+pipedream.wistia.com
+pippio.com
+piquantpigs.com
+pix.spot.im
+pixel.condenastdigital.com
+pixel.keywee.co
+pixel.sojern.com
+pixel.watch
+pixel.yabidos.com
+placed.com
+placeframe.com
+placidactivity.com
+plausible.avris.it
+plausibleio.workers.dev
+play4traffic.com
+playhaven.com
+pleasantpump.com
+plista.com
+plotrabbit.com
+pltraffic8.com
+pluckypocket.com
+plugrush.com
+pocketfaucet.com
+poemprompt.com
+pointlessprofit.com
+pointroll.com
+pokkt.com
+polishedfolly.com
+polo.feathr.co
+popads.net
+popcash.net
+popmixradio.com
+popmyads.com
+popplantation.com
+popub.com
+popunder.ru
+popunhot1.blogspot.com
+popup.msn.com
+popupmoney.com
+popupnation.com
+popuptraffic.com
+porngraph.com
+porntrack.com
+possibleboats.com
+possiblepencil.com
+post.spmailtechno.com
+postback.iqm.com
+postrelease.com
+ppc.adhere.marchex.com
+pr-star.de
+praddpro.de
+prchecker.info
+prebid.org
+predictad.com
+premium-offers.com
+presetrabbits.com
+prettyeasycafe.com
+previousplayground.com
+prf.hn
+priceypies.com
+pricklydebt.com
+prideproms.com
+primetime.net
+privatecash.com
+prmtracking.com
+pro-market.net
+probablepartner.com
+processplantation.com
+proext.com
+profero.com
+profitrumour.com
+programattik.com
+projectwonderful.com
+promo.badoink.com
+promobenef.com
+promos.bwin.it
+promos.fling.com
+promote.pair.com
+pronetadvertising.com
+propellerads.com
+propellerclick.com
+proper.io
+props.id
+protectcrev.com
+protectpool.com
+protectsubrev.com
+protestcopy.com
+proton-tm.com
+protraffic.com
+provenpixel.com
+prpops.com
+prsitecheck.com
+prufenzo.xyz
+pstmrk.it
+pub.chez.com
+pub.club-internet.fr
+pub.hardware.fr
+pub.network
+pub.realmedia.fr
+pubdirecte.com
+publicidad.elmundo.es
+publicidees.com
+publicsofa.com
+pubmine.com
+pubnative.net
+puffyloss.com
+puffypaste.com
+puffypull.com
+puffypurpose.com
+pureclarity.net
+pushance.com
+pushengage.com
+pushno.com
+pushtrack.co
+px.dynamicyield.com
+px.gfycat.com
+pxf.io
+pxl-mailtracker.com
+pxl.iqm.com
+pymx5.com
+q.azcentral.com
+q1connect.com
+qa-analytics.com
+qctop.com
+ql.tc
+qnsr.com
+qrlsx.com
+quantcast.com
+quantcount.com
+quantserve.com
+quantummetric.com
+quarterserver.de
+quickkoala.io
+quietknowledge.com
+quiltruler.com
+quinst.com
+quirkysugar.com
+quisma.com
+quizzicalzephyr.com
+r.drinksdirect.net
+r.logrocket.io
+r.marketing.dubaisothebys.com
+r.msn.com
+r.scoota.co
+r.sibmail.havasit.com
+r1.arts-mail.com
+r1.visualwebsiteoptimizer.com
+r2.visualwebsiteoptimizer.com
+r3.visualwebsiteoptimizer.com
+rabbitrifle.com
+rackforstorage.com
+radar.cedexis.com
+radiate.com
+radiateprose.com
+rads.realadmin.pl
+railwayreason.com
+rambunctiousflock.com
+rampidads.com
+randkuj.xyz
+rankchamp.de
+ranking-charts.de
+ranking-hits.de
+ranking-links.de
+rankingscout.com
+rankyou.com
+rapidcounter.com
+raresummer.com
+rate.ru
+ratings.lycos.com
+rayjump.com
+rcadserver.com
+re-direct.pl
+reachjunction.com
+reactx.com
+readingguilt.com
+readymoon.com
+realcastmedia.com
+realclever.com
+realclix.com
+realmedia-a800.d4p.net
+realsrv.com
+realtechnetwork.com
+realtracker.com
+rebelhen.com
+rebelswing.com
+rec5.visualwebsiteoptimizer.com
+recapture.io
+receptivereaction.com
+recoco.it
+reconditerake.com
+record.bonniergaming.com
+record.mrwin.com
+redirectingat.com
+redirectvoluum.com
+redrection.pro
+redshell.io
+reduxmedia.com
+referralware.com
+referrer.disqus.com
+regularplants.com
+reklam.rfsl.se
+reklama.mironet.cz
+reklamcsere.hu
+reklamdsp.com
+relmaxtop.com
+rememberdiscussion.com
+remox.com
+report-1.appmetrica.webvisor.com
+report-2.appmetrica.webvisor.com
+report-partners.appmetrica.yandex.net
+report.ap.yandex-net.ru
+report.appmetrica.yandex.net
+republika.onet.pl
+resalag.com
+rescuerhino.com
+resonantbrush.com
+resonate.com
+responsiveads.com
+restrainstorm.com
+retargeter.com
+rev.iq
+revcatch.com
+revcontent.com
+reveal.clearbit.com
+revenuedirect.com
+revenuehits.com
+revive.haskovo.net
+revive.netriota.hu
+revive.plays.bg
+revprotect.com
+revstats.com
+rexadvert.xyz
+reyden-x.com
+rhombusads.com
+rhythmone.com
+richaudience.com
+richmails.com
+richstring.com
+rightstats.com
+ringplant.com
+ringsrecord.com
+ritzyrepresentative.com
+rlcdn.com
+rle.ru
+rmads.msn.com
+rmedia.boston.com
+roaddynamics.com
+roar.com
+robotreplay.com
+rockabox.co
+rockagainst.com
+rockstarwriter.com
+rok.com.com
+rollconnection.com
+rose.ixbt.com
+rotabanner.com
+roxr.net
+rpt-ads.vidaahub.com
+rqtrk.eu
+rs6.net
+rsc-ads.vidaahub.com
+rsc-mntz.vidaahub.com
+rta.dailymail.co.uk
+rtb.gumgum.com
+rtbadzesto.com
+rtbflairads.com
+rtbplatform.net
+rtbpop.com
+rtbpopd.com
+rtmark.net
+rtxplatform.com
+ru4.com
+rubiconproject.com
+rum-http-intake.logs.datadoghq.com
+rum-http-intake.logs.datadoghq.eu
+runads.com
+rundsp.com
+ruralrobin.com
+s.adroll.com
+s.dmmew.com
+s20dh7e9dh.com
+s2d6.com
+sabio.us
+sadloaf.com
+safeoffers.pro
+sail-horizon.com
+samplesamba.com
+samsungacr.com
+samsungads.com
+sanalytics.disneyplus.com
+sanity-dataplane.rudderstack.com
+savoryorange.com
+sbird.xyz
+sbx.pagesjaunes.fr
+sc-analytics.appspot.com
+scambiobanner.aruba.it
+scanscout.com
+scarcesign.com
+scaredsnakes.com
+scaredsong.com
+scarfsmash.com
+scatteredheat.com
+scintillatingscissors.com
+scintillatingsilver.com
+scissorsstatement.com
+scopelight.com
+scorecardresearch.com
+scratch2cash.com
+screechingfurniture.com
+screechingstocking.com
+screechingstove.com
+scrubswim.com
+seadform.net
+searchmarketing.com
+searchramp.com
+secre.jp
+secretspiders.com
+secure.webconnect.net
+securedopen-bp.com
+securemetrics.apple.com
+securemetrics.apple.com.cn
+sedoparking.com
+sedotracker.com
+segment-cdn.producthunt.com
+selectivesummer.com
+semasio.net
+sendmepixel.com
+seraphichorizon.com
+serendipityecho.com
+serv0.com
+servclick1move.com
+serve.tercept.com
+servedby-buysellads.com
+servedbyadbutler.com
+servedbyopenx.com
+servethis.com
+services.hearstmags.com
+sessioncam.com
+sexcounter.com
+sexlist.com
+sextracker.com
+shadowmade.com
+shakegoldfish.com
+shareasale.com
+sharethrough.com
+shd247.click
+sher.index.hu
+shesubscriptions.com
+shinystat.com
+shinystat.it
+shiveringspot.com
+shiverscissors.com
+shockinggrass.com
+shoppingads.com
+showads.pubmatic.com
+shredform.com
+shrillspoon.com
+shxtrk.com
+sicksmash.com
+sidebar.angelfire.com
+signalayer.com
+signalszone.com
+sillyscrew.com
+silvermob.com
+simpleanalytics.io
+simplesafari.com
+simpli.fi
+simulateswing.com
+sincerebuffalo.com
+sinoa.com
+sitedataprocessing.com
+siteimproveanalytics.com
+siteimproveanalytics.io
+siteintercept.qualtrics.com
+sitemeter.com
+sixscissors.com
+sixsigmatraffic.com
+sizmek.com
+skimresources.com
+skisofa.com
+skroutza.skroutz.gr
+skylink.vn
+slimesupplies.net
+slopeaota.com
+smaato.com
+smart-data-systems.com
+smart-traffik.com
+smart-traffik.io
+smart4ads.com
+smartadserver.com
+smartclip.net
+smartlook.com
+smartstream.tv
+smartyads.com
+smashquartz.com
+smashsurprise.com
+smetrics.10daily.com.au
+smetrics.bestbuy.com
+smetrics.ctv.ca
+smetrics.fedex.com
+smetrics.foxnews.com
+smetrics.walgreens.com
+smetrics.washingtonpost.com
+smilewanted.com
+smilingcattle.com
+smoggysnakes.com
+smrtb.com
+snapads.com
+snazzypoodle.com
+snoobi.com
+socialspark.com
+softclick.com.br
+soggysponge.com
+soicos.com
+sombersea.com
+sombersquirrel.com
+sombersurprise.com
+somniture.stuff.co.nz
+somoaudience.com
+sonobi.com
+sortable.com
+sourcepoint.vice.com
+sovrn.com
+sp-a-q-f.ib-game.jp
+spacash.com
+spaceleadster.com
+sparklingshelf.com
+sparkstudios.com
+speakol.com
+specificmedia.co.uk
+specificpop.com
+speedomizer.com
+speedshiftmedia.com
+spellingthoughts.com
+spezialreporte.de
+spiffymachine.com
+spinbox.techtracker.com
+spinbox.versiontracker.com
+spinnaker-js.com
+spirebaboon.com
+sponsorads.de
+sponsorpro.de
+spookysleet.com
+spotlessstamp.com
+spotscenered.info
+spotx.tv
+spotxchange.com
+springbot.com
+springserve.com
+sprysummit.com
+spulse.net
+spylog.com
+spywarelabs.com
+spywords.com
+srvmath.com
+srvtrck.com
+srwww1.com
+sshowads.pubmatic.com
+sskzlabs.com
+st.dynamicyield.com
+st.pubmatic.com
+stack-sonar.com
+stackadapt.com
+stakingsmile.com
+stalesummer.com
+starffa.com
+starkscale.com
+starrynets.com
+starsmarter.com
+startapp.com
+stat-track.com
+stat.cliche.se
+stat.dyna.ultraweb.hu
+stat.pl
+stat.webmedia.pl
+stat.xiaomi.com
+stat.zenon.net
+stat24.com
+stat24.meta.ua
+statcounter.com
+statdynamic.com
+static-tracking.klaviyo.com
+static.fmpub.net
+static.itrack.it
+static.kameleoon.com
+staticads.btopenworld.com
+statistik-gallup.net
+statm.the-adult-company.com
+stats.blogger.com
+stats.hyperinzerce.cz
+stats.merriam-webster.com
+stats.mirrorfootball.co.uk
+stats.nextgen-email.com
+stats.olark.com
+stats.pusher.com
+stats.rdphv.net
+stats.self.com
+stats.stb-ottow.de
+stats.townnews.com
+stats.wordpress.com
+stats.wp.com
+stats2.self.com
+stats4all.com
+statserv.net
+statsie.com
+statxpress.com
+steadfastsound.com
+steadfastsystem.com
+steelhouse.com
+steelhousemedia.com
+stickyadstv.com
+stiffgame.com
+stimulatingsneeze.com
+stomachscience.com
+stopstomach.com
+storetail.io
+storygize.net
+strack.pubmatic.com
+straightnest.com
+stretchsquirrel.com
+studycooking.com
+stupendoussleet.com
+stupendoussnow.com
+subscribe.hearstmags.com
+succeedscene.com
+successbuffet.com
+sugoicounter.com
+sulkycook.com
+summerobject.com
+sumo.com
+sumome.com
+sunsetcampfires.com
+superawesome.tv
+superchichair.com
+superclix.de
+superficialsquare.com
+supersonicads.com
+superstats.com
+supertop.ru
+supertop100.com
+supply.colossusssp.com
+supportwaves.com
+surfmusik-adserver.de
+surveygizmobeacon.s3.amazonaws.com
+sw88.espn.com
+swan-swan-goose.com
+swankysquare.com
+swingslip.com
+swordgoose.com
+synonymoussticks.com
+systemssummit.com
+t.appsflyer.com
+t.bawafx.com
+t.carta.com
+t.co
+t.eloqua.com
+t.email.superdrug.com
+t.en25.com
+t.firstpromoter.com
+t.insigit.com
+t.irtyd.com
+t.leady.com
+t.mmtrkr.com
+t.news.browns-restaurants.co.uk
+t.notif-colissimo-laposte.info
+t.pie.org
+t.podcast.co
+t.pubmatic.com
+t.salesmatemail.com
+t.vacations.disneydestinations.com
+t.visit.disneydestinations.com
+t.visitorqueue.com
+t.x.co
+t1.rorystravelclub.co.uk
+t1.rorytravelclub-news.co.uk
+taboola.com
+tag-demo.mention-me.com
+tag.mention-me.com
+tagcommander.com
+tagger.opecloud.com
+tags.tiqcdn.com
+tagtoo.com
+tailsweep.com
+tailsweep.se
+takethatad.com
+tamgrt.com
+tangibleteam.com
+tangyamount.com
+tapad.com
+tapfiliate.com
+tapinfluence.com
+tapjoy.com
+tappx.com
+targad.de
+target.microsoft.com
+targeting.api.drift.com
+targeting.nzme.arcpublishing.com
+targeting.voxus.tv
+targetingnow.com
+targetnet.com
+targetpoint.com
+tatsumi-sys.jp
+tawdryson.com
+tcads.net
+teads.tv
+tealeaf.com
+tealium.cbsnews.com
+tealium.com
+tealiumiq.com
+tedioustooth.com
+teenrevenue.com
+telaria.com
+telemetry.dropbox.com
+telemetry.goodlifefitness.com
+telemetry.malwarebytes.com
+telemetry.v.dropbox.com
+temelio.com
+tend.io
+tendertest.com
+ter-jrnl-oc.vidaahub.com
+terriblethumb.com
+text-link-ads.com
+textad.sexsearch.com
+textads.biz
+textlinks.com
+tfag.de
+the-ozone-project.com
+theadex.com
+theadhost.com
+theadsparks.com
+thebugs.ws
+thecrazychili.com
+themangotea.com
+themoneytizer.com
+therapistla.com
+thewavebeats.com
+thinkitten.com
+thirdparty.bnc.lt
+thirdrespect.com
+thomastorch.com
+throtle.io
+thruport.com
+thunderhead.com
+tia.timeinc.net
+ticketaunt.com
+ticklesign.com
+ticksel.com
+tics.techdirt.com
+tidaltv.com
+tidysprite.com
+tinybar.com
+tinybluewhale.com
+tinytendency.com
+tiresomethunder.com
+tkbo.com
+tls.telemetry.swe.quicinc.com
+tlvmedia.com
+tm.br.de
+tnkexchange.com
+tns-counter.ru
+toolforthought.com
+top-casting-termine.de
+top-site-list.com
+top.list.ru
+top.mail.ru
+top100-images.rambler.ru
+top100.mafia.ru
+top123.ro
+top20free.com
+toplist.cz
+toplist.pornhost.com
+toplista.mw.hu
+toplistcity.com
+topsir.com
+topsite.lv
+topsites.com.br
+topstats.com
+totemcash.com
+touchclarity.com
+tour.brazzers.com
+tr.api.fanbyte.com
+track-eu.customer.io
+track.adform.net
+track.anchorfree.com
+track.canva.com
+track.contently.com
+track.customer.io
+track.effiliation.com
+track.flexlinks.com
+track.flexlinkspro.com
+track.lettingaproperty.com
+track.mailalert.io
+track.mailerlite.com
+track.miro.com
+track.nationalgunrights.org
+track.privacyatclearbit.com
+track.pubmatic.com
+track.segmetrics.io
+track.smtpmessage.com
+track.software-codes.com
+track.spe.schoolmessenger.com
+track.ultravpn.com
+track.unear.net
+track.vcdc.com
+track.viewdeos.com
+track1.viewdeos.com
+trackalyzer.com
+trackedlink.net
+trackedweb.net
+tracker.bannerflow.com
+tracker.cdnbye.com
+tracker.icerocket.com
+tracker.metricswave.com
+tracker.mmdlv.it
+tracker.samplicio.us
+tracking.epicgames.com
+tracking.hyros.com
+tracking.ibxlink.com
+tracking.intentsify.io
+tracking.intl.miui.com
+tracking.jiffyworld.com
+tracking.markethero.io
+tracking.miui.com
+tracking.netalerts.io
+tracking.olx-st.com
+tracking.orixa-media.com
+tracking.shopstyle.com
+tracking.thinkabt.com
+tracking.wetter.at
+tracking01.walmart.com
+tracking101.com
+tracking22.com
+trackingsoft.com
+trackmysales.com
+tradeadexchange.com
+tradedoubler.com
+traffic-exchange.com
+traffic.hyteck.de
+trafficfactory.biz
+trafficforce.com
+trafficholder.com
+traffichunt.com
+trafficjunky.net
+trafficleader.com
+trafficrouter.io
+trafficshop.com
+trafficspaces.net
+trafficstrategies.com
+trafficswarm.com
+trafficz.com
+traffiq.com
+trafic.ro
+traktrafficflow.com
+tranquilplume.com
+travis.bosscasinos.com
+trck.a8.net
+trck.mtrgt.id
+trcklion.com
+treasuredata.com
+trekdata.com
+tremendoustime.com
+tremorhub.com
+trendcounter.com
+trendmd.com
+trialfire.com
+tribalfusion.com
+triplelift.com
+triptease.io
+trk.4ff.pro
+trk.bc.shutterfly.com
+trk.pinterest.com
+trk.sayerfinancial.com
+trk.techtarget.com
+trk1.avdlink.net
+trk42.net
+trkn.us
+trkoptimizer.com
+trkpnt.ongage.net
+trmit.com
+truckstomatoes.com
+truculentrate.com
+truehits.net
+truehits1.gits.net.th
+truehits2.gits.net.th
+trust.titanhq.com
+trustx.org
+tsyndicate.com
+tsyndicate.net
+tubemogul.com
+tumbleicicle.com
+turboadv.com
+turn.com
+twelvedawn.com
+twittad.com
+twyn.com
+tynt.com
+typicalteeth.com
+tyroo.com
+uarating.com
+ucfunnel.com
+udkcrj.com
+udncoeln.com
+uib.ff.avast.com
+ukoffzeh.com
+ultimateclixx.com
+ultramercial.com
+ultraoranges.com
+unaccountablepie.com
+unarmedindustry.com
+unbecominglamp.com
+understoodocean.com
+undertone.com
+unidentifiedanalytics.web.app
+unloadyourself.com
+unruly.co
+unrulymedia.com
+untd.com
+unusualtitle.com
+unwieldyhealth.com
+unwieldyimpulse.com
+upgradeyoga.com
+upu.samsungelectronics.com
+urbanlaurel.com
+url9467.comms-2.zoopla.co.uk
+urlcash.net
+us.a1.yimg.com
+userreplay.com
+userreplay.net
+users.maxcluster.net
+utils.mediageneral.net
+utl-1.com
+uu.domainforlite.com
+v1.cnzz.com
+v1adserver.com
+valerie.forbes.com
+validclick.com
+valuead.com
+valueclick.com
+valueclickmedia.com
+valuecommerce.com
+vanfireworks.com
+vcommission.com
+veille-referencement.com
+velismedia.com
+venetrigni.com
+vengefulgrass.com
+ventivmedia.com
+venturead.com
+vericlick.com
+vertamedia.com
+verticalmass.com
+vervewireless.com
+vgnp3trk.com
+vibrantsundown.com
+vid.pubmatic.com
+vidcpm.com
+video-stats.video.google.com
+videoadex.com
+videoadstech.org
+videoegg.com
+videostats.kakao.com
+vidora.com
+view4cash.de
+viglink.com
+vilenexus.com
+virtualvincent.com
+visiblemeasures.com
+visistat.com
+visitbox.de
+visual-pagerank.fr
+visualrevenue.com
+vivads.net
+vivtracking.com
+vmmpxl.com
+voicefive.com
+volatilevessel.com
+voluum.com
+voluumtrk2.com
+vpon.com
+vrs.cz
+vtracy.de
+vungle.com
+w55c.net
+wa.and.co.uk
+waardex.com
+warmafterthought.com
+washbanana.com
+wdads.sx.atl.publicus.com
+wdfl.co
+web-stat.com
+web.informer.com
+web2.deja.com
+webads.co.nz
+webads.nl
+webanalytics.zohodcm.com
+webcash.nl
+webcontentassessor.com
+webcounter.cz
+webcounter.goweb.de
+webgains.com
+weborama.com
+weborama.fr
+webpower.com
+webreseau.com
+webseoanalytics.com
+webstat.channel4.com
+webstat.com
+webstat.net
+webtrackerplus.com
+webtraffic.se
+webtraxx.de
+webxcdn.com
+welved.com
+werbung.meteoxpress.com
+wetrack.it
+whaleads.com
+wheredoyoucomefrom.ovh
+whirlwealth.com
+whiskyqueue.com
+whisperingcascade.com
+whisperingcrib.com
+whisperingsummit.com
+whoisonline.net
+wholepagecache.com
+wickedreports.com
+widget.educationdynamics.com
+widget.privy.com
+wikia-ads.wikia.com
+wikiquotations.com
+win.iqm.com
+window.nixnet.cz
+wintricksbanner.googlepages.com
+wirecomic.com
+wirypaste.com
+wisepops.com
+witch-counter.de
+wittypopcorn.com
+wizaly.com
+wl.spotify.com
+wlmarketing.com
+wondoads.de
+woopra.com
+worldrealize.com
+worldwide-cash.net
+worriednumber.com
+wowfunnow.com
+writerhubs.com
+wt-eu02.net
+wt.bankmillennium.pl
+www-banner.chat.ru
+www-google-analytics.l.google.com
+www.dnps.com
+www.kaplanindex.com
+www.photo-ads.co.uk
+www8.glam.com
+wwwpromoter.com
+x-traceur.com
+x6.yakiuchi.com
+xad.com
+xapads.com
+xchange.ro
+xertive.com
+xfreeservice.com
+xg4ken.com
+xiti.com
+xplusone.com
+xponsor.com
+xpu.samsungelectronics.com
+xq1.net
+xtendmedia.com
+xtracker.logimeter.com
+xxxcounter.com
+xxxmyself.com
+y.ibsys.com
+yab-adimages.s3.amazonaws.com
+yadro.ru
+yandexmetrica.com
+yepads.com
+yesads.com
+yesadvertising.com
+yieldads.com
+yieldlab.net
+yieldmanager.net
+yieldmo.com
+yieldoptimizer.com
+yieldtraffic.com
+yldbt.com
+ymetrica1.com
+yoads.net
+yoggrt.com
+youcandrawanything.com
+youradexchange.com
+ypu.samsungelectronics.com
+zangocash.com
+zanox-affiliate.de
+zanox.com
+zantracker.com
+zarget.com
+zdbb.net
+zedo.com
+zemanta.com
+zencudo.co.uk
+zenkreka.com
+zenzuu.com
+zephyrlabyrinth.com
+zeus.developershed.com
+zeusclicks.com
+zeydoo.com
+zion-telemetry.api.cnn.io
+zippingcare.com
+zlp6s.pw
+zm232.com
+zmedia.com
+zonewedgeshaft.com
+zpu.samsungelectronics.com
+zqtk.net
+zzhc.vnet.cn
+
diff --git a/browser/vendor/tld-0.13.2-psl.NOTICE b/browser/vendor/tld-0.13.2-psl.NOTICE
new file mode 100644
index 000000000..9a83edb1f
--- /dev/null
+++ b/browser/vendor/tld-0.13.2-psl.NOTICE
@@ -0,0 +1,15 @@
+The adaptive tracker reproduces the Public Suffix List snapshot bundled with
+tld 0.13.2. The complete base list is supplied by the pinned psl 2.1.180 Rust
+crate; src/scrapling/adaptive.rs carries the exact rule delta needed to restore
+the frozen snapshot.
+
+Frozen source metadata:
+
+ VERSION: 2026-03-06_02-20-37_UTC
+ COMMIT: a7621207f34b3a739a5cfb2c47a518b0b9054fe6
+ SHA-256: abf32ce9987d505b89765d76f35760543851235508f1f426b5b259a2062b5f68
+
+The Public Suffix List is licensed under the Mozilla Public License, v. 2.0:
+https://mozilla.org/MPL/2.0/
+
+Canonical source: https://publicsuffix.org/list/public_suffix_list.dat
diff --git a/browser/vendor/xmloxide/Cargo.toml b/browser/vendor/xmloxide/Cargo.toml
new file mode 100644
index 000000000..c7ec219a0
--- /dev/null
+++ b/browser/vendor/xmloxide/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "xmloxide"
+version = "0.5.0"
+edition = "2021"
+rust-version = "1.81"
+autobins = false
+autobenches = false
+license = "MIT"
+description = "Repository-owned Scrapling compatibility fork of xmloxide"
+
+[dependencies]
+encoding_rs = "0.8"
+
+[lib]
+path = "src/lib.rs"
diff --git a/browser/vendor/xmloxide/LICENSE b/browser/vendor/xmloxide/LICENSE
new file mode 100644
index 000000000..2d1bfd251
--- /dev/null
+++ b/browser/vendor/xmloxide/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jon Wiggins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/browser/vendor/xmloxide/README.md b/browser/vendor/xmloxide/README.md
new file mode 100644
index 000000000..545ed331b
--- /dev/null
+++ b/browser/vendor/xmloxide/README.md
@@ -0,0 +1,398 @@
+# xmloxide
+
+> **Scrapling-compatibility fork, trimmed.** This tree is the repository-owned
+> fork the browser worker parses with (lxml-parity patches on top of upstream)
+> and is cut down to the modules the worker consumes: `html`, `tree`, `serial`,
+> `xpath`, `parser`, `validation::dtd`, `encoding`, `error`. Upstream's WHATWG
+> html5 parser, CSS engine, SAX/reader APIs, RelaxNG/XSD/Schematron validators,
+> XInclude, catalogs, serde/async integration, FFI layer, and xmllint CLI are
+> removed — restore them from upstream if ever needed. The feature list below
+> is upstream's, kept for provenance.
+
+[](https://github.com/jonwiggins/xmloxide/actions/workflows/ci.yml)
+[](https://crates.io/crates/xmloxide)
+[](https://docs.rs/xmloxide)
+[](LICENSE)
+[](https://www.rust-lang.org)
+
+A pure Rust reimplementation of [libxml2](https://gitlab.gnome.org/GNOME/libxml2) — the de facto standard XML/HTML parsing library in the open-source world.
+
+libxml2 became officially unmaintained in December 2025 with known security issues. xmloxide aims to be a memory-safe, high-performance replacement that passes the same conformance test suites.
+
+## Features
+
+- **Memory-safe** — arena-based tree with zero `unsafe` in the public API
+- **Conformant** — 100% pass rate on the W3C XML Conformance Test Suite (1727/1727 applicable tests)
+- **Error recovery** — parse malformed XML and still produce a usable tree, just like libxml2
+- **Multiple parsing APIs** — DOM tree, SAX2 streaming, XmlReader pull, push/incremental
+- **HTML parser** — error-tolerant HTML 4.01 parsing with auto-closing and void elements
+- **WHATWG HTML5 parser** — full [HTML Living Standard](https://html.spec.whatwg.org/) tokenizer and tree builder (8810/8810 html5lib-tests passing)
+- **HTML5 streaming** — SAX-like callback API for HTML5 (`html5::sax`) that wraps the tokenizer without building a DOM tree
+- **CSS selectors** — query elements with familiar CSS syntax (`css::select`) including combinators, pseudo-classes, and fast `#id` lookup
+- **XPath 1.0+** — full expression parser and evaluator with all XPath 1.0 core functions plus key XPath 2.0 functions (`matches()`, `replace()`, `tokenize()`, `upper-case()`, `lower-case()`, `abs()`, `min()`, `max()`, and more)
+- **Validation** — DTD, RelaxNG, XML Schema (XSD), and ISO Schematron (ISO/IEC 19757-3) validation
+- **Serde integration** — optional `serde` feature for XML (de)serialization to/from Rust types
+- **Async parsing** — optional `async` feature for parsing from `tokio::io::AsyncRead` sources
+- **Canonical XML** — C14N 1.0 and Exclusive C14N serialization
+- **XInclude** — document inclusion processing
+- **XML Catalogs** — OASIS XML Catalogs for URI resolution
+- **`xmllint` CLI** — command-line tool for parsing, validating, and querying XML
+- **Zero-copy where possible** — string interning for fast comparisons
+- **No global state** — each `Document` is self-contained and `Send + Sync`
+- **C/C++ FFI** — full C API with header file (`include/xmloxide.h`) for embedding in C/C++ projects
+- **Minimal dependencies** — only `encoding_rs` (library has zero other deps; `clap` is CLI-only)
+
+## Quick Start
+
+```rust
+use xmloxide::Document;
+
+let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+let root = doc.root_element().unwrap();
+assert_eq!(doc.node_name(root), Some("root"));
+assert_eq!(doc.text_content(root), "Hello");
+```
+
+### Serialization
+
+```rust
+use xmloxide::Document;
+use xmloxide::serial::serialize;
+
+let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+let xml = serialize(&doc);
+assert_eq!(xml, "<root><child>Hello</child></root>");
+```
+
+### XPath Queries
+
+```rust
+use xmloxide::Document;
+use xmloxide::xpath::{evaluate, XPathValue};
+
+let doc = Document::parse_str("<library><book><title>Rust</title></book></library>").unwrap();
+let root = doc.root_element().unwrap();
+let result = evaluate(&doc, root, "count(book)").unwrap();
+assert_eq!(result.to_number(), 1.0);
+```
+
+### SAX2 Streaming
+
+```rust
+use xmloxide::sax::{parse_sax, SaxHandler, DefaultHandler};
+use xmloxide::parser::ParseOptions;
+
+struct MyHandler;
+impl SaxHandler for MyHandler {
+ fn start_element(&mut self, name: &str, _: Option<&str>, _: Option<&str>,
+ _: &[(String, String, Option<String>, Option<String>)]) {
+ println!("Element: {name}");
+ }
+}
+
+parse_sax("<root><child/></root>", &ParseOptions::default(), &mut MyHandler).unwrap();
+```
+
+### HTML Parsing
+
+```rust
+use xmloxide::html::parse_html;
+
+let doc = parse_html("<p>Hello <br> World").unwrap();
+let root = doc.root_element().unwrap();
+assert_eq!(doc.node_name(root), Some("html"));
+```
+
+### CSS Selectors
+
+```rust
+use xmloxide::css::select;
+use xmloxide::Document;
+
+let doc = Document::parse_str(r#"<div><p class="intro">Hello</p><p>World</p></div>"#).unwrap();
+let root = doc.root_element().unwrap();
+let intros = select(&doc, root, "p.intro").unwrap();
+assert_eq!(intros.len(), 1);
+assert_eq!(doc.text_content(intros[0]), "Hello");
+```
+
+### HTML5 Parsing (WHATWG)
+
+```rust
+use xmloxide::html5::parse_html5;
+
+let doc = parse_html5("<p>Hello <b>world</b>").unwrap();
+let root = doc.root_element().unwrap();
+assert_eq!(doc.node_name(root), Some("html"));
+```
+
+Fragment parsing (the algorithm behind `innerHTML`) is also supported:
+
+```rust
+use xmloxide::html5::{parse_html5_with_options, Html5ParseOptions};
+
+let opts = Html5ParseOptions {
+ scripting: false,
+ fragment_context: Some("body".to_string()),
+};
+let doc = parse_html5_with_options("<p>fragment</p>", &opts).unwrap();
+```
+
+### HTML5 Streaming (SAX-like)
+
+```rust
+use xmloxide::html5::sax::{Html5SaxHandler, parse_html5_sax};
+
+struct LinkExtractor { hrefs: Vec<String> }
+impl Html5SaxHandler for LinkExtractor {
+ fn start_element(&mut self, name: &str, attrs: &[(String, String)], _sc: bool) {
+ if name == "a" {
+ if let Some((_, href)) = attrs.iter().find(|(n, _)| n == "href") {
+ self.hrefs.push(href.clone());
+ }
+ }
+ }
+}
+
+let mut handler = LinkExtractor { hrefs: Vec::new() };
+parse_html5_sax(r#"<a href="/page">Link</a>"#, &mut handler);
+assert_eq!(handler.hrefs, vec!["/page"]);
+```
+
+### Error Recovery
+
+```rust
+use xmloxide::parser::{parse_str_with_options, ParseOptions};
+
+let opts = ParseOptions::default().recover(true);
+let doc = parse_str_with_options("<root><unclosed>", &opts).unwrap();
+for diag in &doc.diagnostics {
+ eprintln!("{}", diag);
+}
+```
+
+## CLI Tool
+
+```sh
+# Parse and pretty-print
+xmllint --format document.xml
+
+# Validate against a schema
+xmllint --schema schema.xsd document.xml
+xmllint --relaxng schema.rng document.xml
+xmllint --schematron schema.sch document.xml
+xmllint --dtdvalid schema.dtd document.xml
+
+# XPath query
+xmllint --xpath "//title" document.xml
+
+# Canonical XML
+xmllint --c14n document.xml
+
+# Parse HTML
+xmllint --html page.html
+```
+
+## Module Overview
+
+| Module | Description |
+|--------|-------------|
+| `tree` | Arena-based DOM tree (`Document`, `NodeId`, `NodeKind`) |
+| `parser` | XML 1.0 recursive descent parser with error recovery |
+| `parser::push` | Push/incremental parser for chunked input |
+| `html` | Error-tolerant HTML 4.01 parser |
+| `html5` | WHATWG HTML Living Standard parser (tokenizer + tree builder) |
+| `html5::sax` | Streaming SAX-like API for HTML5 (no DOM tree built) |
+| `css` | CSS selector engine for querying document trees |
+| `sax` | SAX2 streaming event-driven parser |
+| `reader` | XmlReader pull-based parsing API |
+| `serial` | XML, HTML, and HTML5 serializers, plus Canonical XML (C14N) |
+| `xpath` | XPath 1.0+ expression parser and evaluator |
+| `validation::dtd` | DTD parsing and validation |
+| `validation::relaxng` | RelaxNG schema validation |
+| `validation::xsd` | XML Schema (XSD) validation |
+| `validation::schematron` | ISO Schematron rule-based validation |
+| `serde_xml` | Serde XML (de)serialization (optional `serde` feature) |
+| `async_xml` | Async parsing via `tokio::io::AsyncRead` (optional `async` feature) |
+| `xinclude` | XInclude 1.0 document inclusion |
+| `catalog` | OASIS XML Catalogs for URI resolution |
+| `encoding` | Character encoding detection and transcoding |
+| `ffi` | C/C++ FFI bindings (`include/xmloxide.h`) |
+
+## Performance
+
+Parsing throughput is competitive with libxml2 — within 3-4% on most documents, and **12% faster** on SVG. Serialization is **1.5-2.4x faster** thanks to the arena-based tree design. XPath is **1.1-2.7x faster** across all benchmarks.
+
+**Parsing:**
+
+| Document | Size | xmloxide | libxml2 | Result |
+|----------|------|----------|---------|--------|
+| Atom feed | 4.9 KB | 26.7 µs (176 MiB/s) | 25.5 µs (184 MiB/s) | ~4% slower |
+| SVG drawing | 6.3 KB | 58.5 µs (103 MiB/s) | 65.6 µs (92 MiB/s) | **12% faster** |
+| Maven POM | 11.5 KB | 76.9 µs (142 MiB/s) | 74.2 µs (148 MiB/s) | ~4% slower |
+| XHTML page | 10.2 KB | 69.5 µs (139 MiB/s) | 61.5 µs (157 MiB/s) | ~13% slower |
+| Large (374 KB) | 374 KB | 2.15 ms (169 MiB/s) | 2.08 ms (175 MiB/s) | ~3% slower |
+
+**Serialization:**
+
+| Document | Size | xmloxide | libxml2 | Result |
+|----------|------|----------|---------|--------|
+| Atom feed | 4.9 KB | 11.3 µs | 17.5 µs | **1.5x faster** |
+| Maven POM | 11.5 KB | 20.1 µs | 47.5 µs | **2.4x faster** |
+| Large (374 KB) | 374 KB | 614 µs | 1397 µs | **2.3x faster** |
+
+**XPath:**
+
+| Expression | xmloxide | libxml2 | Result |
+|------------|----------|---------|--------|
+| Simple path (`//entry/title`) | 1.51 µs | 1.63 µs | **8% faster** |
+| Attribute predicate (`//book[@id]`) | 5.91 µs | 15.99 µs | **2.7x faster** |
+| `count()` function | 1.09 µs | 1.67 µs | **1.5x faster** |
+| `string()` function | 1.32 µs | 1.77 µs | **1.3x faster** |
+
+Key optimizations: arena-based tree for fast serialization, byte-level pre-checks for character validation, bulk text scanning, ASCII fast paths for name parsing, zero-copy element name splitting, inline entity resolution, XPath `//` step fusion with fused axis expansion, inlined tree accessors, and name-test fast paths for child/descendant axes.
+
+```sh
+# Run benchmarks (requires libxml2 system library)
+cargo bench --features bench-libxml2 --bench comparison_bench
+```
+
+## Testing
+
+- **1078 unit tests** across all modules
+- **138 FFI tests** covering the full C API surface (including SAX, Schematron, and CSS)
+- **libxml2 compatibility suite** — 119/119 tests passing (100%) covering XML parsing, namespaces, error detection, and HTML parsing
+- **W3C XML Conformance Test Suite** — 1727/1727 applicable tests passing (100%)
+- **html5lib-tests** — 7032/7032 tokenizer tests + 1778/1778 tree construction tests (100%)
+- **Integration tests** covering real-world XML/HTML documents, edge cases, and error recovery
+
+```sh
+cargo test --all-features
+```
+
+## C/C++ FFI
+
+xmloxide provides a C-compatible API for embedding in C/C++ projects (like Chromium, game engines, or any codebase that currently uses libxml2).
+
+```sh
+# Build shared + static libraries (uses the included Makefile)
+make
+
+# Or build individually:
+make shared # .so / .dylib / .dll
+make static # .a / .lib
+
+# Build and run the C example
+make example
+```
+
+```c
+#include "xmloxide.h"
+
+xmloxide_document *doc = xmloxide_parse_str("<root>Hello</root>");
+uint32_t root = xmloxide_doc_root_element(doc);
+char *name = xmloxide_node_name(doc, root); // "root"
+char *text = xmloxide_node_text_content(doc, root); // "Hello"
+
+xmloxide_free_string(name);
+xmloxide_free_string(text);
+xmloxide_free_doc(doc);
+```
+
+The full API — including tree navigation and mutation, XPath evaluation, serialization (plain and pretty-printed), HTML/HTML5 parsing, DTD/RelaxNG/XSD/Schematron validation, C14N, SAX streaming, XmlReader, push parser, and XML Catalogs — is declared in [`include/xmloxide.h`](include/xmloxide.h).
+
+## Migrating from libxml2
+
+| libxml2 | xmloxide (Rust) | xmloxide (C FFI) |
+|---------|----------------|------------------|
+| `xmlReadMemory` | `Document::parse_str` | `xmloxide_parse_str` |
+| `xmlReadFile` | `Document::parse_file` | `xmloxide_parse_file` |
+| `xmlParseDoc` | `Document::parse_bytes` | `xmloxide_parse_bytes` |
+| `htmlReadMemory` | `html::parse_html` | `xmloxide_parse_html` |
+| (HTML5 parsing) | `html5::parse_html5` | — |
+| (HTML5 fragment / innerHTML) | `html5::parse_html5_with_options` | — |
+| (HTML5 streaming) | `html5::sax::parse_html5_sax` | — |
+| (CSS selectors / `querySelector`) | `css::select` | — |
+| `xmlFreeDoc` | (drop `Document`) | `xmloxide_free_doc` |
+| `xmlDocGetRootElement` | `doc.root_element()` | `xmloxide_doc_root_element` |
+| `xmlNodeGetContent` | `doc.text_content(id)` | `xmloxide_node_text_content` |
+| `xmlNodeSetContent` | `doc.set_text_content(id, s)` | `xmloxide_set_text_content` |
+| `xmlGetProp` | `doc.attribute(id, name)` | `xmloxide_node_attribute` |
+| `xmlSetProp` | `doc.set_attribute(...)` | `xmloxide_set_attribute` |
+| `xmlNewNode` | `doc.create_node(...)` | `xmloxide_create_element` |
+| `xmlNewText` | `doc.create_node(Text{..})` | `xmloxide_create_text` |
+| `xmlAddChild` | `doc.append_child(p, c)` | `xmloxide_append_child` |
+| `xmlAddPrevSibling` | `doc.insert_before(ref, c)` | `xmloxide_insert_before` |
+| `xmlUnlinkNode` | `doc.remove_node(id)` | `xmloxide_remove_node` |
+| `xmlCopyNode` | `doc.clone_node(id, deep)` | `xmloxide_clone_node` |
+| `xmlGetID` | `doc.element_by_id(s)` | `xmloxide_element_by_id` |
+| `xmlDocDumpMemory` | `serial::serialize(&doc)` | `xmloxide_serialize` |
+| `xmlDocDumpFormatMemory` | `serial::serialize_with_options` | `xmloxide_serialize_pretty` |
+| `htmlDocDumpMemory` | `serial::html::serialize_html` | `xmloxide_serialize_html` |
+| `xmlC14NDocDumpMemory` | `serial::c14n::canonicalize` | `xmloxide_canonicalize` |
+| `xmlXPathEvalExpression` | `xpath::evaluate` | `xmloxide_xpath_eval` |
+| `xmlValidateDtd` | `validation::dtd::validate` | `xmloxide_validate_dtd` |
+| `xmlRelaxNGValidateDoc` | `validation::relaxng::validate` | `xmloxide_validate_relaxng` |
+| `xmlSchemaValidateDoc` | `validation::xsd::validate_xsd` | `xmloxide_validate_xsd` |
+| (Schematron validation) | `validation::schematron::validate_schematron` | `xmloxide_validate_schematron` |
+| `xmlXIncludeProcess` | `xinclude::process_xincludes` | `xmloxide_process_xincludes` |
+| `xmlLoadCatalog` | `Catalog::parse` | `xmloxide_parse_catalog` |
+| `xmlSAX2...` callbacks | `sax::SaxHandler` trait | `xmloxide_sax_parse` |
+| `xmlTextReaderRead` | `reader::XmlReader` | `xmloxide_reader_read` |
+| `xmlCreatePushParserCtxt` | `parser::PushParser` | `xmloxide_push_parser_new` |
+| `xmlParseChunk` | `PushParser::push` | `xmloxide_push_parser_push` |
+
+**Thread safety:** Unlike libxml2, xmloxide has no global state. Each `Document` is self-contained and `Send + Sync`. The FFI layer uses thread-local storage for the last error message — each thread has its own error state. No initialization or cleanup functions are needed.
+
+## Fuzzing
+
+xmloxide includes fuzz targets for security testing:
+
+```sh
+# Install cargo-fuzz (requires nightly)
+cargo install cargo-fuzz
+
+# Run a fuzz target
+cargo +nightly fuzz run fuzz_xml_parse
+cargo +nightly fuzz run fuzz_html_parse
+cargo +nightly fuzz run fuzz_html5_parse
+cargo +nightly fuzz run fuzz_html5_fragment
+cargo +nightly fuzz run fuzz_xpath
+cargo +nightly fuzz run fuzz_roundtrip
+cargo +nightly fuzz run fuzz_sax
+cargo +nightly fuzz run fuzz_reader
+cargo +nightly fuzz run fuzz_push
+cargo +nightly fuzz run fuzz_validation
+cargo +nightly fuzz run fuzz_schematron
+```
+
+## Building
+
+```sh
+cargo build
+cargo test
+cargo clippy --all-targets --all-features -- -D warnings
+cargo bench
+```
+
+Minimum supported Rust version: **1.81**
+
+## Limitations
+
+- **No XML 1.1** — xmloxide implements XML 1.0 (Fifth Edition) only. XML 1.1 is rarely used and not planned.
+- **No XSLT** — XSLT is a separate specification (libxslt) and is out of scope.
+- **HTML parsers** — both an HTML 4.01 parser (matching libxml2's behavior) and a full WHATWG HTML5 parser are provided. The HTML5 parser passes 100% of html5lib-tests.
+- **Push parser buffers internally** — the push/incremental parser API (`PushParser`) currently buffers all pushed data and performs the full parse on `finish()`, rather than truly streaming like libxml2's `xmlParseChunk`. SAX streaming (`parse_sax` for XML, `html5::sax::parse_html5_sax` for HTML5) is available as an alternative for memory-constrained large-document processing.
+- **XPath `namespace::` axis** — the `namespace::` axis returns the element node when in-scope namespaces match (rather than materializing separate namespace nodes), following the same pattern as the attribute axis.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and guidelines.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.
+
+## License
+
+MIT
diff --git a/browser/vendor/xmloxide/examples/basic_parse.rs b/browser/vendor/xmloxide/examples/basic_parse.rs
new file mode 100644
index 000000000..e9d2dc999
--- /dev/null
+++ b/browser/vendor/xmloxide/examples/basic_parse.rs
@@ -0,0 +1,54 @@
+//! Basic XML parsing and tree navigation.
+//!
+//! Run with: `cargo run --example basic_parse`
+#![allow(clippy::expect_used)]
+
+use xmloxide::tree::NodeKind;
+use xmloxide::Document;
+
+fn main() {
+ let xml = r#"<?xml version="1.0"?>
+<bookstore>
+ <book category="fiction">
+ <title lang="en">The Great Gatsby</title>
+ <author>F. Scott Fitzgerald</author>
+ <year>1925</year>
+ <price>10.99</price>
+ </book>
+ <book category="science">
+ <title lang="en">A Brief History of Time</title>
+ <author>Stephen Hawking</author>
+ <year>1988</year>
+ <price>14.99</price>
+ </book>
+</bookstore>"#;
+
+ let doc = Document::parse_str(xml).expect("failed to parse XML");
+ let root = doc.root_element().expect("no root element");
+
+ println!("Root element: {}", doc.node_name(root).unwrap_or("?"));
+
+ // Iterate over child elements
+ for child in doc.children(root) {
+ if let NodeKind::Element {
+ ref name,
+ ref attributes,
+ ..
+ } = doc.node(child).kind
+ {
+ let category = attributes
+ .iter()
+ .find(|a| a.name == "category")
+ .map_or("unknown", |a| a.value.as_str());
+ println!("\n<{name}> (category={category})");
+
+ // Print child elements
+ for grandchild in doc.children(child) {
+ if let NodeKind::Element { ref name, .. } = doc.node(grandchild).kind {
+ let text = doc.text_content(grandchild);
+ println!(" {name}: {text}");
+ }
+ }
+ }
+ }
+}
diff --git a/browser/vendor/xmloxide/examples/c14n.rs b/browser/vendor/xmloxide/examples/c14n.rs
new file mode 100644
index 000000000..c5e84fe75
--- /dev/null
+++ b/browser/vendor/xmloxide/examples/c14n.rs
@@ -0,0 +1,45 @@
+//! Canonical XML (C14N) serialization example.
+//!
+//! Canonical XML produces a deterministic byte-for-byte representation
+//! of an XML document, commonly used in digital signatures (XML-DSIG).
+//!
+//! Run with: `cargo run --example c14n`
+#![allow(clippy::expect_used)]
+
+use xmloxide::serial::c14n::{canonicalize, C14nOptions};
+use xmloxide::Document;
+
+fn main() {
+ // Input with varied formatting, attribute order, and extra whitespace
+ let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
+<!-- This comment will be stripped by default C14N -->
+<doc xmlns:b="http://example.com/b" xmlns:a="http://example.com/a">
+ <item z="3" a="1" m="2" >
+ <![CDATA[Some text]]]]><![CDATA[>
+ </item>
+ <empty/>
+ <b:element b:attr="val"/>
+</doc>"#;
+
+ let doc = Document::parse_str(xml).expect("parse failed");
+
+ // Standard C14N (default includes comments, sorts attributes and namespaces)
+ let c14n = canonicalize(&doc, &C14nOptions::default());
+ println!("=== C14N (with comments, default) ===\n{c14n}\n");
+
+ // C14N without comments
+ let opts_no_comments = C14nOptions {
+ with_comments: false,
+ ..C14nOptions::default()
+ };
+ let c14n_no_comments = canonicalize(&doc, &opts_no_comments);
+ println!("=== C14N (without comments) ===\n{c14n_no_comments}\n");
+
+ // Exclusive C14N (namespace-aware, used in XML signatures)
+ let opts_exclusive = C14nOptions {
+ exclusive: true,
+ ..C14nOptions::default()
+ };
+ let c14n_exc = canonicalize(&doc, &opts_exclusive);
+ println!("=== Exclusive C14N ===\n{c14n_exc}");
+}
diff --git a/browser/vendor/xmloxide/examples/error_recovery.rs b/browser/vendor/xmloxide/examples/error_recovery.rs
new file mode 100644
index 000000000..7543003f6
--- /dev/null
+++ b/browser/vendor/xmloxide/examples/error_recovery.rs
@@ -0,0 +1,48 @@
+//! Demonstrates error recovery on malformed XML.
+//!
+//! Run with: `cargo run --example error_recovery`
+#![allow(clippy::expect_used)]
+
+use xmloxide::parser::{parse_str_with_options, ParseOptions};
+use xmloxide::serial::serialize;
+
+fn main() {
+ let malformed_docs = vec![
+ ("Missing end tag", "<root><child>text</root>"),
+ ("Unclosed root", "<root><a>hello</a><b>world</b>"),
+ (
+ "Duplicate attributes",
+ "<root attr=\"1\" attr=\"2\">text</root>",
+ ),
+ ("Mismatched tags", "<a><b>text</a></b>"),
+ (
+ "Invalid characters",
+ "<root>valid text <!-- comment --> more</root>",
+ ),
+ ];
+
+ let opts = ParseOptions::default().recover(true);
+
+ for (label, xml) in malformed_docs {
+ println!("=== {label} ===");
+ println!("Input: {xml}");
+
+ match parse_str_with_options(xml, &opts) {
+ Ok(doc) => {
+ let output = serialize(&doc);
+ println!("Output: {output}");
+ if doc.diagnostics.is_empty() {
+ println!("(no diagnostics)");
+ } else {
+ for diag in &doc.diagnostics {
+ println!(" warning: {diag}");
+ }
+ }
+ }
+ Err(e) => {
+ println!("Fatal error: {e}");
+ }
+ }
+ println!();
+ }
+}
diff --git a/browser/vendor/xmloxide/examples/html_parse.rs b/browser/vendor/xmloxide/examples/html_parse.rs
new file mode 100644
index 000000000..ee7a3c79e
--- /dev/null
+++ b/browser/vendor/xmloxide/examples/html_parse.rs
@@ -0,0 +1,65 @@
+//! HTML parsing example demonstrating error-tolerant parsing.
+//!
+//! Run with: `cargo run --example html_parse`
+#![allow(clippy::expect_used)]
+
+use xmloxide::html::parse_html;
+use xmloxide::tree::NodeKind;
+use xmloxide::Document;
+
+fn print_tree(doc: &Document, node: xmloxide::NodeId, depth: usize) {
+ let indent = " ".repeat(depth);
+ let node_data = doc.node(node);
+ match &node_data.kind {
+ NodeKind::Element {
+ name, attributes, ..
+ } => {
+ if attributes.is_empty() {
+ println!("{indent}<{name}>");
+ } else {
+ let attrs: Vec<String> = attributes
+ .iter()
+ .map(|a| format!("{}=\"{}\"", a.name, a.value))
+ .collect();
+ println!("{indent}<{name} {}>", attrs.join(" "));
+ }
+ for child in doc.children(node) {
+ print_tree(doc, child, depth + 1);
+ }
+ }
+ NodeKind::Text { content } => {
+ let trimmed = content.trim();
+ if !trimmed.is_empty() {
+ println!("{indent}\"{trimmed}\"");
+ }
+ }
+ _ => {
+ for child in doc.children(node) {
+ print_tree(doc, child, depth + 1);
+ }
+ }
+ }
+}
+
+fn main() {
+ // HTML with missing tags, unclosed elements, void elements
+ let html = r#"
+<p>Hello <b>bold <i>and italic</b> text</i>
+<br>
+<img src="photo.jpg" alt="A photo">
+<ul>
+ <li>First item
+ <li>Second item
+ <li>Third item
+</ul>
+<div>Unclosed div
+"#;
+
+ println!("Input HTML:");
+ println!("{html}");
+ println!("Parsed tree:");
+
+ let doc = parse_html(html).expect("HTML parsing failed");
+ let root = doc.root_element().expect("no root");
+ print_tree(&doc, root, 0);
+}
diff --git a/browser/vendor/xmloxide/examples/push_parser.rs b/browser/vendor/xmloxide/examples/push_parser.rs
new file mode 100644
index 000000000..b8acadc95
--- /dev/null
+++ b/browser/vendor/xmloxide/examples/push_parser.rs
@@ -0,0 +1,65 @@
+//! Push/incremental parser example.
+//!
+//! The push parser accepts XML data in arbitrarily sized chunks, useful
+//! when data arrives incrementally (network sockets, streaming, etc.).
+//!
+//! Run with: `cargo run --example push_parser`
+#![allow(clippy::expect_used)]
+
+use xmloxide::parser::PushParser;
+use xmloxide::tree::NodeKind;
+
+fn main() {
+ // Simulate receiving XML in chunks (e.g., from a network stream)
+ let chunks = [
+ b"<?xml version=\"1.0\"?>" as &[u8],
+ b"<inventory>",
+ b" <item sku=\"A10",
+ b"1\"><name>Bolt</name>",
+ b"<qty>500</qty></item>",
+ b" <item sku=\"B202\">",
+ b"<name>Nut</name><qty>",
+ b"1000</qty></item>",
+ b"</inventory>",
+ ];
+
+ let mut parser = PushParser::new();
+
+ for (i, chunk) in chunks.iter().enumerate() {
+ parser.push(chunk);
+ println!(
+ "Pushed chunk {} ({} bytes, {} total buffered)",
+ i + 1,
+ chunk.len(),
+ parser.buffered_bytes()
+ );
+ }
+
+ let doc = parser.finish().expect("parsing failed");
+ let root = doc.root_element().expect("no root element");
+
+ println!("\nParsed document:");
+ println!("Root: {}", doc.node_name(root).unwrap_or("?"));
+
+ for child in doc.children(root) {
+ if let NodeKind::Element {
+ ref name,
+ ref attributes,
+ ..
+ } = doc.node(child).kind
+ {
+ let sku = attributes
+ .iter()
+ .find(|a| a.name == "sku")
+ .map_or("?", |a| a.value.as_str());
+ print!(" <{name} sku=\"{sku}\">");
+
+ for field in doc.children(child) {
+ if let NodeKind::Element { ref name, .. } = doc.node(field).kind {
+ print!(" {name}={}", doc.text_content(field));
+ }
+ }
+ println!();
+ }
+ }
+}
diff --git a/browser/vendor/xmloxide/examples/serialize.rs b/browser/vendor/xmloxide/examples/serialize.rs
new file mode 100644
index 000000000..9b50c0f6e
--- /dev/null
+++ b/browser/vendor/xmloxide/examples/serialize.rs
@@ -0,0 +1,39 @@
+//! XML serialization and roundtrip example.
+//!
+//! Run with: `cargo run --example serialize`
+#![allow(clippy::expect_used)]
+
+use xmloxide::serial::serialize;
+use xmloxide::Document;
+
+fn main() {
+ let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
+<root xmlns:app="http://example.com/app">
+ <app:config version="2.0">
+ <app:setting name="debug">true</app:setting>
+ <app:setting name="timeout">30</app:setting>
+ </app:config>
+ <data>
+ <item id="1">First & foremost</item>
+ <item id="2">Less <than> more</item>
+ <![CDATA[Some <raw> content & stuff]]]]><![CDATA[>
+ </data>
+</root>"#;
+
+ println!("=== Original XML ===");
+ println!("{xml}");
+
+ // Parse
+ let doc = Document::parse_str(xml).expect("failed to parse");
+
+ // Serialize
+ let output = serialize(&doc);
+ println!("\n=== Serialized ===");
+ println!("{output}");
+
+ // Roundtrip: parse the serialized output again
+ let doc2 = Document::parse_str(&output).expect("roundtrip parse failed");
+ let output2 = serialize(&doc2);
+
+ println!("\n=== Roundtrip stable: {} ===", output == output2);
+}
diff --git a/browser/vendor/xmloxide/examples/xpath_query.rs b/browser/vendor/xmloxide/examples/xpath_query.rs
new file mode 100644
index 000000000..8f44fb298
--- /dev/null
+++ b/browser/vendor/xmloxide/examples/xpath_query.rs
@@ -0,0 +1,61 @@
+//! `XPath` query examples.
+//!
+//! Run with: `cargo run --example xpath_query`
+#![allow(clippy::expect_used)]
+
+use xmloxide::xpath::{evaluate, XPathValue};
+use xmloxide::Document;
+
+fn main() {
+ let xml = r#"<?xml version="1.0"?>
+<library>
+ <book genre="fiction" id="1">
+ <title>The Great Gatsby</title>
+ <author>F. Scott Fitzgerald</author>
+ <price>10.99</price>
+ </book>
+ <book genre="science" id="2">
+ <title>A Brief History of Time</title>
+ <author>Stephen Hawking</author>
+ <price>14.99</price>
+ </book>
+ <book genre="fiction" id="3">
+ <title>1984</title>
+ <author>George Orwell</author>
+ <price>8.99</price>
+ </book>
+</library>"#;
+
+ let doc = Document::parse_str(xml).expect("failed to parse XML");
+ let root = doc.root_element().expect("no root element");
+
+ // Count all books
+ let result = evaluate(&doc, root, "count(book)").expect("XPath failed");
+ println!("Total books: {}", result.to_number());
+
+ // Find all fiction books
+ println!("\nFiction books:");
+ let result = evaluate(&doc, root, "book[@genre='fiction']/title").expect("XPath failed");
+ if let XPathValue::NodeSet(nodes) = &result {
+ for &node in nodes {
+ println!(" - {}", doc.text_content(node.anchor()));
+ }
+ }
+
+ // Find books over $10
+ println!("\nBooks over $10:");
+ let result = evaluate(&doc, root, "book[number(price) > 10]/title").expect("XPath failed");
+ if let XPathValue::NodeSet(nodes) = &result {
+ for &node in nodes {
+ println!(" - {}", doc.text_content(node.anchor()));
+ }
+ }
+
+ // Get a string value
+ let result = evaluate(&doc, root, "string(book[@id='2']/author)").expect("XPath failed");
+ println!("\nAuthor of book 2: {}", result.to_xpath_string());
+
+ // Sum prices
+ let result = evaluate(&doc, root, "sum(book/price)").expect("XPath failed");
+ println!("Total price: ${:.2}", result.to_number());
+}
diff --git a/browser/vendor/xmloxide/src/encoding/mod.rs b/browser/vendor/xmloxide/src/encoding/mod.rs
new file mode 100644
index 000000000..55bc88a79
--- /dev/null
+++ b/browser/vendor/xmloxide/src/encoding/mod.rs
@@ -0,0 +1,451 @@
+//! Encoding detection and transcoding.
+//!
+//! Implements BOM sniffing and XML declaration encoding detection per
+//! XML 1.0 Section 4.3.3 and Appendix F, bridging to `encoding_rs` for character
+//! encoding conversion.
+//!
+//! # Encoding Detection Strategy
+//!
+//! 1. Check for a Byte Order Mark (BOM) at the start of the input.
+//! 2. If a BOM is found, use the indicated encoding and skip the BOM bytes.
+//! 3. If no BOM is found, default to UTF-8 (per the XML specification).
+//! 4. After initial decoding, inspect the XML declaration's `encoding=` attribute
+//! to confirm or override the detected encoding.
+
+use std::fmt;
+
+/// An error that occurs during encoding detection or transcoding.
+#[derive(Debug, Clone)]
+pub struct EncodingError {
+ /// A human-readable description of the encoding error.
+ pub message: String,
+}
+
+impl EncodingError {
+ /// Creates a new `EncodingError` with the given message.
+ fn new(message: impl Into<String>) -> Self {
+ Self {
+ message: message.into(),
+ }
+ }
+}
+
+impl fmt::Display for EncodingError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "encoding error: {}", self.message)
+ }
+}
+
+impl std::error::Error for EncodingError {}
+
+/// Detects the encoding of an XML byte stream by inspecting the Byte Order Mark.
+///
+/// Returns a tuple of (encoding name, number of BOM bytes to skip). The encoding
+/// name is an IANA charset name suitable for passing to `encoding_rs`.
+///
+/// Per XML 1.0 Appendix F, the BOM detection order is:
+/// - `EF BB BF` -> UTF-8
+/// - `FE FF` -> UTF-16 BE
+/// - `FF FE` -> UTF-16 LE
+/// - No BOM -> UTF-8 (default per XML spec)
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::encoding::detect_encoding;
+///
+/// let (enc, skip) = detect_encoding(b"\xEF\xBB\xBFhello");
+/// assert_eq!(enc, "UTF-8");
+/// assert_eq!(skip, 3);
+///
+/// let (enc, skip) = detect_encoding(b"<root/>");
+/// assert_eq!(enc, "UTF-8");
+/// assert_eq!(skip, 0);
+/// ```
+#[must_use]
+pub fn detect_encoding(bytes: &[u8]) -> (&'static str, usize) {
+ if bytes.len() >= 3 && bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF {
+ ("UTF-8", 3)
+ } else if bytes.len() >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF {
+ ("UTF-16BE", 2)
+ } else if bytes.len() >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE {
+ ("UTF-16LE", 2)
+ } else {
+ ("UTF-8", 0)
+ }
+}
+
+/// Transcodes a byte slice from the named encoding into a UTF-8 `String`.
+///
+/// Uses `encoding_rs::Encoding::for_label` to look up the encoding by its IANA
+/// name (case-insensitive). Returns an error if the encoding is unknown or if
+/// the input contains malformed byte sequences.
+///
+/// # Errors
+///
+/// Returns `EncodingError` if the encoding name is not recognized or if
+/// transcoding fails due to malformed input bytes.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::encoding::transcode;
+///
+/// let result = transcode(b"hello", "UTF-8").unwrap();
+/// assert_eq!(result, "hello");
+/// ```
+pub fn transcode(bytes: &[u8], encoding_name: &str) -> Result<String, EncodingError> {
+ let encoding = encoding_rs::Encoding::for_label(encoding_name.as_bytes())
+ .ok_or_else(|| EncodingError::new(format!("unsupported encoding: {encoding_name}")))?;
+
+ let (result, _used_encoding, had_errors) = encoding.decode(bytes);
+ if had_errors {
+ return Err(EncodingError::new(format!(
+ "malformed byte sequence for encoding {encoding_name}"
+ )));
+ }
+ Ok(result.into_owned())
+}
+
+/// Extracts the `encoding` attribute value from an XML declaration in the given string.
+///
+/// This performs a lightweight scan of the first line to find a pattern like
+/// `encoding="..."` or `encoding='...'` without running the full XML parser.
+/// Returns `None` if no XML declaration or no encoding attribute is found.
+fn extract_xml_decl_encoding(text: &str) -> Option<String> {
+ // Only look at the beginning of the document, up to the end of the XML decl.
+ let decl_end = text.find("?>")?;
+ let decl = &text[..decl_end];
+
+ // Must start with <?xml to be a valid XML declaration
+ if !decl.starts_with("<?xml") {
+ return None;
+ }
+
+ let enc_pos = decl.find("encoding")?;
+ let after_enc = &decl[enc_pos + "encoding".len()..];
+
+ // Skip whitespace and '='
+ let after_enc = after_enc.trim_start();
+ let after_enc = after_enc.strip_prefix('=')?;
+ let after_enc = after_enc.trim_start();
+
+ // Extract the quoted value
+ let quote = after_enc.as_bytes().first().copied()?;
+ if quote != b'"' && quote != b'\'' {
+ return None;
+ }
+ let after_quote = &after_enc[1..];
+ let end = after_quote.find(quote as char)?;
+ Some(after_quote[..end].to_string())
+}
+
+/// Decodes raw XML bytes into a UTF-8 string, automatically detecting the encoding.
+///
+/// This implements the full encoding detection pipeline from XML 1.0 Section 4.3.3:
+///
+/// 1. Detect the BOM and determine the initial encoding.
+/// 2. If the encoding is UTF-8, validate and return the bytes as a string.
+/// 3. If non-UTF-8, transcode using `encoding_rs`.
+/// 4. After the initial decode, check the XML declaration's `encoding=` attribute.
+/// If it specifies a different encoding than what the BOM indicated, re-decode
+/// from the original bytes using the declared encoding.
+///
+/// # Errors
+///
+/// Returns `EncodingError` if the bytes contain invalid sequences for the
+/// detected encoding or if the declared encoding is unsupported.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::encoding::decode_to_utf8;
+///
+/// let xml = b"<?xml version=\"1.0\"?><root/>";
+/// let result = decode_to_utf8(xml).unwrap();
+/// assert!(result.contains("<root/>"));
+/// ```
+pub fn decode_to_utf8(bytes: &[u8]) -> Result<String, EncodingError> {
+ let (bom_encoding, bom_skip) = detect_encoding(bytes);
+ let content_bytes = &bytes[bom_skip..];
+
+ // Fast path: if the BOM says UTF-8 (or no BOM, which defaults to UTF-8),
+ // try to validate directly without transcoding.
+ if bom_encoding == "UTF-8" {
+ if let Ok(s) = std::str::from_utf8(content_bytes) {
+ // Valid UTF-8. Check for an encoding declaration that might
+ // indicate a different encoding (unusual but permitted).
+ if let Some(declared) = extract_xml_decl_encoding(s) {
+ let declared_upper = declared.to_ascii_uppercase();
+ if !is_utf8_label(&declared_upper) {
+ return transcode(content_bytes, &declared);
+ }
+ }
+ return Ok(s.to_string());
+ }
+ // Not valid UTF-8 and no BOM. The XML declaration is required
+ // to be in ASCII-compatible bytes, so try to extract the
+ // encoding= attribute from the raw bytes interpreted as ASCII.
+ // If found, transcode with the declared encoding; otherwise,
+ // the input is genuinely malformed UTF-8.
+ if let Some(declared) = extract_encoding_from_ascii_bytes(content_bytes) {
+ return transcode(content_bytes, &declared);
+ }
+ return Err(EncodingError::new("input is not valid UTF-8"));
+ }
+
+ // Non-UTF-8 BOM encoding: transcode first, then check for a declaration.
+ let initial_text = transcode(content_bytes, bom_encoding)?;
+
+ if let Some(declared_encoding) = extract_xml_decl_encoding(&initial_text) {
+ let declared_upper = declared_encoding.to_ascii_uppercase();
+ let bom_upper = bom_encoding.to_ascii_uppercase();
+
+ let effectively_same = declared_upper == bom_upper
+ || (is_utf8_label(&declared_upper) && is_utf8_label(&bom_upper))
+ // "UTF-16" is compatible with both "UTF-16BE" and "UTF-16LE" —
+ // the BOM determines the actual byte order.
+ || (declared_upper == "UTF-16"
+ && (bom_upper == "UTF-16BE" || bom_upper == "UTF-16LE"));
+
+ if !effectively_same {
+ return transcode(content_bytes, &declared_encoding);
+ }
+ }
+
+ Ok(initial_text)
+}
+
+/// Extracts the `encoding` attribute from raw bytes by treating them as ASCII.
+///
+/// This is used as a fallback when the input is not valid UTF-8 and has no BOM.
+/// Since the XML declaration must be in ASCII-compatible characters, we can scan
+/// the bytes directly. Returns `None` if no encoding declaration is found.
+fn extract_encoding_from_ascii_bytes(bytes: &[u8]) -> Option<String> {
+ // Only scan up to a reasonable limit for the XML declaration (first 200 bytes).
+ let limit = bytes.len().min(200);
+ let scan = &bytes[..limit];
+
+ // Look for "<?xml" at the start
+ if !scan.starts_with(b"<?xml") {
+ return None;
+ }
+
+ // Find "?>" to delimit the declaration
+ let decl_end = scan.windows(2).position(|w| w == b"?>")?;
+ let decl = &scan[..decl_end];
+
+ // Find "encoding" within the declaration
+ let enc_needle = b"encoding";
+ let enc_pos = decl
+ .windows(enc_needle.len())
+ .position(|w| w == enc_needle)?;
+ let after_enc = &decl[enc_pos + enc_needle.len()..];
+
+ // Skip whitespace and '='
+ let after_enc = skip_ascii_whitespace(after_enc);
+ if after_enc.first() != Some(&b'=') {
+ return None;
+ }
+ let after_eq = skip_ascii_whitespace(&after_enc[1..]);
+
+ // Extract quoted value
+ let quote = *after_eq.first()?;
+ if quote != b'"' && quote != b'\'' {
+ return None;
+ }
+ let after_quote = &after_eq[1..];
+ let end = after_quote.iter().position(|&b| b == quote)?;
+ let encoding_bytes = &after_quote[..end];
+
+ // The encoding name must be ASCII
+ if encoding_bytes.iter().all(u8::is_ascii) {
+ Some(String::from_utf8_lossy(encoding_bytes).into_owned())
+ } else {
+ None
+ }
+}
+
+/// Skips leading ASCII whitespace bytes (space, tab, CR, LF).
+fn skip_ascii_whitespace(bytes: &[u8]) -> &[u8] {
+ let skip = bytes
+ .iter()
+ .take_while(|&&b| b == b' ' || b == b'\t' || b == b'\r' || b == b'\n')
+ .count();
+ &bytes[skip..]
+}
+
+/// Returns `true` if the label is a recognized alias for UTF-8.
+fn is_utf8_label(label: &str) -> bool {
+ matches!(label, "UTF-8" | "UTF8")
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_detect_utf8_bom() {
+ let bytes = b"\xEF\xBB\xBF<?xml version=\"1.0\"?><root/>";
+ let (encoding, skip) = detect_encoding(bytes);
+ assert_eq!(encoding, "UTF-8");
+ assert_eq!(skip, 3);
+ }
+
+ #[test]
+ fn test_detect_utf16le_bom() {
+ let bytes = b"\xFF\xFE<\x00r\x00o\x00o\x00t\x00";
+ let (encoding, skip) = detect_encoding(bytes);
+ assert_eq!(encoding, "UTF-16LE");
+ assert_eq!(skip, 2);
+ }
+
+ #[test]
+ fn test_detect_utf16be_bom() {
+ let bytes = b"\xFE\xFF\x00<\x00r\x00o\x00o\x00t";
+ let (encoding, skip) = detect_encoding(bytes);
+ assert_eq!(encoding, "UTF-16BE");
+ assert_eq!(skip, 2);
+ }
+
+ #[test]
+ fn test_detect_no_bom() {
+ let bytes = b"<?xml version=\"1.0\"?><root/>";
+ let (encoding, skip) = detect_encoding(bytes);
+ assert_eq!(encoding, "UTF-8");
+ assert_eq!(skip, 0);
+ }
+
+ #[test]
+ fn test_detect_empty_input() {
+ let (encoding, skip) = detect_encoding(b"");
+ assert_eq!(encoding, "UTF-8");
+ assert_eq!(skip, 0);
+ }
+
+ #[test]
+ fn test_detect_single_byte() {
+ let (encoding, skip) = detect_encoding(b"\xEF");
+ assert_eq!(encoding, "UTF-8");
+ assert_eq!(skip, 0);
+ }
+
+ #[test]
+ fn test_decode_utf8() {
+ let bytes = b"<?xml version=\"1.0\"?><root>hello</root>";
+ let result = decode_to_utf8(bytes).unwrap();
+ assert_eq!(result, "<?xml version=\"1.0\"?><root>hello</root>");
+ }
+
+ #[test]
+ fn test_decode_utf8_with_bom() {
+ let bytes = b"\xEF\xBB\xBF<?xml version=\"1.0\"?><root/>";
+ let result = decode_to_utf8(bytes).unwrap();
+ assert_eq!(result, "<?xml version=\"1.0\"?><root/>");
+ }
+
+ #[test]
+ fn test_decode_latin1() {
+ // ISO-8859-1 encoded XML with encoding declaration.
+ // The byte 0xE9 is 'e' with acute accent in ISO-8859-1.
+ let mut bytes = Vec::new();
+ bytes.extend_from_slice(b"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>");
+ bytes.extend_from_slice(b"<root>caf\xE9</root>");
+
+ let result = decode_to_utf8(&bytes).unwrap();
+ assert!(result.contains("caf\u{00E9}"));
+ assert!(result.contains("<root>"));
+ }
+
+ #[test]
+ fn test_transcode_utf8() {
+ let result = transcode(b"hello world", "UTF-8").unwrap();
+ assert_eq!(result, "hello world");
+ }
+
+ #[test]
+ fn test_transcode_latin1() {
+ // 0xE9 = 'e with acute' in ISO-8859-1
+ let result = transcode(b"caf\xE9", "ISO-8859-1").unwrap();
+ assert_eq!(result, "caf\u{00E9}");
+ }
+
+ #[test]
+ fn test_transcode_unknown_encoding() {
+ let result = transcode(b"hello", "UNKNOWN-ENCODING-42");
+ assert!(result.is_err());
+ assert!(result.unwrap_err().message.contains("unsupported encoding"));
+ }
+
+ #[test]
+ fn test_extract_xml_decl_encoding_present() {
+ let text = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><root/>";
+ let enc = extract_xml_decl_encoding(text);
+ assert_eq!(enc, Some("ISO-8859-1".to_string()));
+ }
+
+ #[test]
+ fn test_extract_xml_decl_encoding_single_quotes() {
+ let text = "<?xml version='1.0' encoding='UTF-8'?><root/>";
+ let enc = extract_xml_decl_encoding(text);
+ assert_eq!(enc, Some("UTF-8".to_string()));
+ }
+
+ #[test]
+ fn test_extract_xml_decl_encoding_absent() {
+ let text = "<?xml version=\"1.0\"?><root/>";
+ let enc = extract_xml_decl_encoding(text);
+ assert_eq!(enc, None);
+ }
+
+ #[test]
+ fn test_extract_xml_decl_no_declaration() {
+ let text = "<root/>";
+ let enc = extract_xml_decl_encoding(text);
+ assert_eq!(enc, None);
+ }
+
+ #[test]
+ fn test_encoding_error_display() {
+ let err = EncodingError::new("test error");
+ assert_eq!(err.to_string(), "encoding error: test error");
+ }
+
+ #[test]
+ fn test_encoding_error_is_error_trait() {
+ let err = EncodingError::new("test");
+ let _: &dyn std::error::Error = &err;
+ }
+
+ #[test]
+ fn test_decode_invalid_utf8() {
+ // 0xFF 0xFE at the start is a UTF-16LE BOM, so use a different invalid sequence.
+ // Bytes that are invalid UTF-8 without matching any BOM pattern.
+ let bytes: &[u8] = &[0x80, 0x81, 0x82];
+ let result = decode_to_utf8(bytes);
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_parse_bytes_utf8() {
+ use crate::tree::Document;
+
+ let result = Document::parse_bytes(b"<root/>");
+ assert!(result.is_ok());
+ let doc = result.unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+
+ #[test]
+ fn test_parse_bytes_utf8_with_bom() {
+ use crate::tree::Document;
+
+ let mut bytes = vec![0xEF, 0xBB, 0xBF];
+ bytes.extend_from_slice(b"<root/>");
+ let doc = Document::parse_bytes(&bytes).unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+}
diff --git a/browser/vendor/xmloxide/src/error/mod.rs b/browser/vendor/xmloxide/src/error/mod.rs
new file mode 100644
index 000000000..7d28b25eb
--- /dev/null
+++ b/browser/vendor/xmloxide/src/error/mod.rs
@@ -0,0 +1,159 @@
+//! Error types and diagnostics for XML parsing.
+//!
+//! This module provides structured error reporting with source location tracking,
+//! matching libxml2's error reporting model. Errors carry line, column, and byte
+//! offset information for precise diagnostics.
+//!
+//! The parser supports **error recovery mode**: it collects errors into a
+//! `Vec<ParseDiagnostic>` while still producing a (possibly partial) tree.
+
+use std::fmt;
+
+/// Severity level for a parse diagnostic, matching libxml2's `xmlErrorLevel`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ErrorSeverity {
+ /// A non-fatal issue that doesn't prevent parsing.
+ Warning,
+ /// A recoverable error — the parser can continue but the document is malformed.
+ Error,
+ /// An unrecoverable error — parsing must stop.
+ Fatal,
+}
+
+impl fmt::Display for ErrorSeverity {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Warning => write!(f, "warning"),
+ Self::Error => write!(f, "error"),
+ Self::Fatal => write!(f, "fatal error"),
+ }
+ }
+}
+
+/// Source location within an XML document.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct SourceLocation {
+ /// 1-based line number.
+ pub line: u32,
+ /// 1-based column number (in characters, not bytes).
+ pub column: u32,
+ /// 0-based byte offset from the start of the input.
+ pub byte_offset: usize,
+}
+
+impl fmt::Display for SourceLocation {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "{}:{}", self.line, self.column)
+ }
+}
+
+/// A single diagnostic emitted during parsing.
+///
+/// Diagnostics are collected when the parser operates in recovery mode,
+/// allowing it to produce a partial tree even when the input is malformed.
+#[derive(Debug, Clone)]
+pub struct ParseDiagnostic {
+ /// The severity of this diagnostic.
+ pub severity: ErrorSeverity,
+ /// Human-readable error message.
+ pub message: String,
+ /// Where in the source this error occurred.
+ pub location: SourceLocation,
+}
+
+impl fmt::Display for ParseDiagnostic {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "{}: {} at {}",
+ self.severity, self.message, self.location
+ )
+ }
+}
+
+/// The error type returned when XML parsing fails.
+#[derive(Debug, Clone)]
+pub struct ParseError {
+ /// The primary error message.
+ pub message: String,
+ /// Where in the source the fatal error occurred.
+ pub location: SourceLocation,
+ /// All diagnostics collected before the fatal error (in recovery mode,
+ /// this includes warnings and recovered errors).
+ pub diagnostics: Vec<ParseDiagnostic>,
+}
+
+impl fmt::Display for ParseError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "parse error at {}: {}", self.location, self.message)
+ }
+}
+
+impl std::error::Error for ParseError {}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_source_location_display() {
+ let loc = SourceLocation {
+ line: 10,
+ column: 5,
+ byte_offset: 42,
+ };
+ assert_eq!(loc.to_string(), "10:5");
+ }
+
+ #[test]
+ fn test_parse_error_display() {
+ let err = ParseError {
+ message: "unexpected end of input".to_string(),
+ location: SourceLocation {
+ line: 1,
+ column: 15,
+ byte_offset: 14,
+ },
+ diagnostics: vec![],
+ };
+ assert_eq!(
+ err.to_string(),
+ "parse error at 1:15: unexpected end of input"
+ );
+ }
+
+ #[test]
+ fn test_parse_diagnostic_display() {
+ let diag = ParseDiagnostic {
+ severity: ErrorSeverity::Warning,
+ message: "attribute value not quoted".to_string(),
+ location: SourceLocation {
+ line: 3,
+ column: 10,
+ byte_offset: 50,
+ },
+ };
+ assert_eq!(
+ diag.to_string(),
+ "warning: attribute value not quoted at 3:10"
+ );
+ }
+
+ #[test]
+ fn test_error_severity_display() {
+ assert_eq!(ErrorSeverity::Warning.to_string(), "warning");
+ assert_eq!(ErrorSeverity::Error.to_string(), "error");
+ assert_eq!(ErrorSeverity::Fatal.to_string(), "fatal error");
+ }
+
+ #[test]
+ fn test_parse_error_is_error_trait() {
+ let err = ParseError {
+ message: "test".to_string(),
+ location: SourceLocation::default(),
+ diagnostics: vec![],
+ };
+ // Verify it implements std::error::Error
+ let _: &dyn std::error::Error = &err;
+ }
+}
diff --git a/browser/vendor/xmloxide/src/html/entities.rs b/browser/vendor/xmloxide/src/html/entities.rs
new file mode 100644
index 000000000..4997899ea
--- /dev/null
+++ b/browser/vendor/xmloxide/src/html/entities.rs
@@ -0,0 +1,388 @@
+//! HTML named character references.
+//!
+//! This module provides a lookup table for HTML 4.01 named character references
+//! (entities) such as ` `, `©`, `—`, etc. These extend beyond
+//! the five predefined XML entities (`amp`, `lt`, `gt`, `apos`, `quot`).
+//!
+//! The table covers the entities defined in the HTML 4.01 specification
+//! (section 24), which is what libxml2's HTML parser targets.
+//!
+//! See <https://www.w3.org/TR/html401/sgml/entities.html>
+
+/// Looks up an HTML named character reference and returns the corresponding
+/// Unicode character(s) as a string slice.
+///
+/// Returns `None` if the name is not a recognized HTML entity. The entity name
+/// should be provided without the leading `&` and trailing `;`.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::html::entities::lookup_entity;
+///
+/// assert_eq!(lookup_entity("nbsp"), Some("\u{00A0}"));
+/// assert_eq!(lookup_entity("copy"), Some("\u{00A9}"));
+/// assert_eq!(lookup_entity("nonexistent"), None);
+/// ```
+pub fn lookup_entity(name: &str) -> Option<&'static str> {
+ // Binary search on the sorted entity table.
+ ENTITIES
+ .binary_search_by_key(&name, |&(n, _)| n)
+ .ok()
+ .map(|i| ENTITIES[i].1)
+}
+
+/// Looks up the HTML named entity for a given character (reverse lookup).
+///
+/// Returns `None` if no named entity exists for the character, or if the
+/// character is one of the XML builtins (`&`, `<`, `>`, `'`, `"`) which
+/// are handled separately by the escaping logic.
+///
+/// Used by the HTML serializer to re-encode non-ASCII characters as their
+/// named entity form (e.g., `©` → `©`, `\u{00A0}` → ` `).
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::html::entities::reverse_lookup_entity;
+///
+/// assert_eq!(reverse_lookup_entity('\u{00A9}'), Some("copy"));
+/// assert_eq!(reverse_lookup_entity('\u{00A0}'), Some("nbsp"));
+/// assert_eq!(reverse_lookup_entity('A'), None);
+/// ```
+pub fn reverse_lookup_entity(ch: char) -> Option<&'static str> {
+ let mut buf = [0u8; 4];
+ let target = ch.encode_utf8(&mut buf);
+ for &(name, value) in ENTITIES {
+ if value == target {
+ return Some(name);
+ }
+ }
+ None
+}
+
+/// The HTML 4.01 named character reference table, sorted by name for binary
+/// search. Each entry is `(entity_name, replacement_str)`.
+///
+/// This covers ISO 8859-1 characters, mathematical/Greek/symbolic characters,
+/// and markup-significant characters defined in HTML 4.01.
+static ENTITIES: &[(&str, &str)] = &[
+ ("AElig", "\u{00C6}"),
+ ("Aacute", "\u{00C1}"),
+ ("Acirc", "\u{00C2}"),
+ ("Agrave", "\u{00C0}"),
+ ("Alpha", "\u{0391}"),
+ ("Aring", "\u{00C5}"),
+ ("Atilde", "\u{00C3}"),
+ ("Auml", "\u{00C4}"),
+ ("Beta", "\u{0392}"),
+ ("Ccedil", "\u{00C7}"),
+ ("Chi", "\u{03A7}"),
+ ("Dagger", "\u{2021}"),
+ ("Delta", "\u{0394}"),
+ ("ETH", "\u{00D0}"),
+ ("Eacute", "\u{00C9}"),
+ ("Ecirc", "\u{00CA}"),
+ ("Egrave", "\u{00C8}"),
+ ("Epsilon", "\u{0395}"),
+ ("Eta", "\u{0397}"),
+ ("Euml", "\u{00CB}"),
+ ("Gamma", "\u{0393}"),
+ ("Iacute", "\u{00CD}"),
+ ("Icirc", "\u{00CE}"),
+ ("Igrave", "\u{00CC}"),
+ ("Iota", "\u{0399}"),
+ ("Iuml", "\u{00CF}"),
+ ("Kappa", "\u{039A}"),
+ ("Lambda", "\u{039B}"),
+ ("Mu", "\u{039C}"),
+ ("Ntilde", "\u{00D1}"),
+ ("Nu", "\u{039D}"),
+ ("OElig", "\u{0152}"),
+ ("Oacute", "\u{00D3}"),
+ ("Ocirc", "\u{00D4}"),
+ ("Ograve", "\u{00D2}"),
+ ("Omega", "\u{03A9}"),
+ ("Omicron", "\u{039F}"),
+ ("Oslash", "\u{00D8}"),
+ ("Otilde", "\u{00D5}"),
+ ("Ouml", "\u{00D6}"),
+ ("Phi", "\u{03A6}"),
+ ("Pi", "\u{03A0}"),
+ ("Prime", "\u{2033}"),
+ ("Psi", "\u{03A8}"),
+ ("Rho", "\u{03A1}"),
+ ("Scaron", "\u{0160}"),
+ ("Sigma", "\u{03A3}"),
+ ("THORN", "\u{00DE}"),
+ ("Tau", "\u{03A4}"),
+ ("Theta", "\u{0398}"),
+ ("Uacute", "\u{00DA}"),
+ ("Ucirc", "\u{00DB}"),
+ ("Ugrave", "\u{00D9}"),
+ ("Upsilon", "\u{03A5}"),
+ ("Uuml", "\u{00DC}"),
+ ("Xi", "\u{039E}"),
+ ("Yacute", "\u{00DD}"),
+ ("Yuml", "\u{0178}"),
+ ("Zeta", "\u{0396}"),
+ ("aacute", "\u{00E1}"),
+ ("acirc", "\u{00E2}"),
+ ("acute", "\u{00B4}"),
+ ("aelig", "\u{00E6}"),
+ ("agrave", "\u{00E0}"),
+ ("alefsym", "\u{2135}"),
+ ("alpha", "\u{03B1}"),
+ ("amp", "&"),
+ ("and", "\u{2227}"),
+ ("ang", "\u{2220}"),
+ ("apos", "'"),
+ ("aring", "\u{00E5}"),
+ ("asymp", "\u{2248}"),
+ ("atilde", "\u{00E3}"),
+ ("auml", "\u{00E4}"),
+ ("bdquo", "\u{201E}"),
+ ("beta", "\u{03B2}"),
+ ("brvbar", "\u{00A6}"),
+ ("bull", "\u{2022}"),
+ ("cap", "\u{2229}"),
+ ("ccedil", "\u{00E7}"),
+ ("cedil", "\u{00B8}"),
+ ("cent", "\u{00A2}"),
+ ("chi", "\u{03C7}"),
+ ("circ", "\u{02C6}"),
+ ("clubs", "\u{2663}"),
+ ("cong", "\u{2245}"),
+ ("copy", "\u{00A9}"),
+ ("crarr", "\u{21B5}"),
+ ("cup", "\u{222A}"),
+ ("curren", "\u{00A4}"),
+ ("dArr", "\u{21D3}"),
+ ("dagger", "\u{2020}"),
+ ("darr", "\u{2193}"),
+ ("deg", "\u{00B0}"),
+ ("delta", "\u{03B4}"),
+ ("diams", "\u{2666}"),
+ ("divide", "\u{00F7}"),
+ ("eacute", "\u{00E9}"),
+ ("ecirc", "\u{00EA}"),
+ ("egrave", "\u{00E8}"),
+ ("empty", "\u{2205}"),
+ ("emsp", "\u{2003}"),
+ ("ensp", "\u{2002}"),
+ ("epsilon", "\u{03B5}"),
+ ("equiv", "\u{2261}"),
+ ("eta", "\u{03B7}"),
+ ("eth", "\u{00F0}"),
+ ("euml", "\u{00EB}"),
+ ("euro", "\u{20AC}"),
+ ("exist", "\u{2203}"),
+ ("fnof", "\u{0192}"),
+ ("forall", "\u{2200}"),
+ ("frac12", "\u{00BD}"),
+ ("frac14", "\u{00BC}"),
+ ("frac34", "\u{00BE}"),
+ ("frasl", "\u{2044}"),
+ ("gamma", "\u{03B3}"),
+ ("ge", "\u{2265}"),
+ ("gt", ">"),
+ ("hArr", "\u{21D4}"),
+ ("harr", "\u{2194}"),
+ ("hearts", "\u{2665}"),
+ ("hellip", "\u{2026}"),
+ ("iacute", "\u{00ED}"),
+ ("icirc", "\u{00EE}"),
+ ("iexcl", "\u{00A1}"),
+ ("igrave", "\u{00EC}"),
+ ("image", "\u{2111}"),
+ ("infin", "\u{221E}"),
+ ("int", "\u{222B}"),
+ ("iota", "\u{03B9}"),
+ ("iquest", "\u{00BF}"),
+ ("isin", "\u{2208}"),
+ ("iuml", "\u{00EF}"),
+ ("kappa", "\u{03BA}"),
+ ("lArr", "\u{21D0}"),
+ ("lambda", "\u{03BB}"),
+ ("lang", "\u{2329}"),
+ ("laquo", "\u{00AB}"),
+ ("larr", "\u{2190}"),
+ ("lceil", "\u{2308}"),
+ ("ldquo", "\u{201C}"),
+ ("le", "\u{2264}"),
+ ("lfloor", "\u{230A}"),
+ ("lowast", "\u{2217}"),
+ ("loz", "\u{25CA}"),
+ ("lrm", "\u{200E}"),
+ ("lsaquo", "\u{2039}"),
+ ("lsquo", "\u{2018}"),
+ ("lt", "<"),
+ ("macr", "\u{00AF}"),
+ ("mdash", "\u{2014}"),
+ ("micro", "\u{00B5}"),
+ ("middot", "\u{00B7}"),
+ ("minus", "\u{2212}"),
+ ("mu", "\u{03BC}"),
+ ("nabla", "\u{2207}"),
+ ("nbsp", "\u{00A0}"),
+ ("ndash", "\u{2013}"),
+ ("ne", "\u{2260}"),
+ ("ni", "\u{220B}"),
+ ("not", "\u{00AC}"),
+ ("notin", "\u{2209}"),
+ ("nsub", "\u{2284}"),
+ ("ntilde", "\u{00F1}"),
+ ("nu", "\u{03BD}"),
+ ("oacute", "\u{00F3}"),
+ ("ocirc", "\u{00F4}"),
+ ("oelig", "\u{0153}"),
+ ("ograve", "\u{00F2}"),
+ ("oline", "\u{203E}"),
+ ("omega", "\u{03C9}"),
+ ("omicron", "\u{03BF}"),
+ ("oplus", "\u{2295}"),
+ ("or", "\u{2228}"),
+ ("ordf", "\u{00AA}"),
+ ("ordm", "\u{00BA}"),
+ ("oslash", "\u{00F8}"),
+ ("otilde", "\u{00F5}"),
+ ("otimes", "\u{2297}"),
+ ("ouml", "\u{00F6}"),
+ ("para", "\u{00B6}"),
+ ("part", "\u{2202}"),
+ ("permil", "\u{2030}"),
+ ("perp", "\u{22A5}"),
+ ("phi", "\u{03C6}"),
+ ("pi", "\u{03C0}"),
+ ("piv", "\u{03D6}"),
+ ("plusmn", "\u{00B1}"),
+ ("pound", "\u{00A3}"),
+ ("prime", "\u{2032}"),
+ ("prod", "\u{220F}"),
+ ("prop", "\u{221D}"),
+ ("psi", "\u{03C8}"),
+ ("quot", "\""),
+ ("rArr", "\u{21D2}"),
+ ("radic", "\u{221A}"),
+ ("rang", "\u{232A}"),
+ ("raquo", "\u{00BB}"),
+ ("rarr", "\u{2192}"),
+ ("rceil", "\u{2309}"),
+ ("rdquo", "\u{201D}"),
+ ("real", "\u{211C}"),
+ ("reg", "\u{00AE}"),
+ ("rfloor", "\u{230B}"),
+ ("rho", "\u{03C1}"),
+ ("rlm", "\u{200F}"),
+ ("rsaquo", "\u{203A}"),
+ ("rsquo", "\u{2019}"),
+ ("sbquo", "\u{201A}"),
+ ("scaron", "\u{0161}"),
+ ("sdot", "\u{22C5}"),
+ ("sect", "\u{00A7}"),
+ ("shy", "\u{00AD}"),
+ ("sigma", "\u{03C3}"),
+ ("sigmaf", "\u{03C2}"),
+ ("sim", "\u{223C}"),
+ ("spades", "\u{2660}"),
+ ("sub", "\u{2282}"),
+ ("sube", "\u{2286}"),
+ ("sum", "\u{2211}"),
+ ("sup", "\u{2283}"),
+ ("sup1", "\u{00B9}"),
+ ("sup2", "\u{00B2}"),
+ ("sup3", "\u{00B3}"),
+ ("supe", "\u{2287}"),
+ ("szlig", "\u{00DF}"),
+ ("tau", "\u{03C4}"),
+ ("there4", "\u{2234}"),
+ ("theta", "\u{03B8}"),
+ ("thetasym", "\u{03D1}"),
+ ("thinsp", "\u{2009}"),
+ ("thorn", "\u{00FE}"),
+ ("tilde", "\u{02DC}"),
+ ("times", "\u{00D7}"),
+ ("trade", "\u{2122}"),
+ ("uArr", "\u{21D1}"),
+ ("uacute", "\u{00FA}"),
+ ("uarr", "\u{2191}"),
+ ("ucirc", "\u{00FB}"),
+ ("ugrave", "\u{00F9}"),
+ ("uml", "\u{00A8}"),
+ ("upsih", "\u{03D2}"),
+ ("upsilon", "\u{03C5}"),
+ ("uuml", "\u{00FC}"),
+ ("weierp", "\u{2118}"),
+ ("xi", "\u{03BE}"),
+ ("yacute", "\u{00FD}"),
+ ("yen", "\u{00A5}"),
+ ("yuml", "\u{00FF}"),
+ ("zeta", "\u{03B6}"),
+ ("zwj", "\u{200D}"),
+ ("zwnj", "\u{200C}"),
+];
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_lookup_basic_xml_entities() {
+ assert_eq!(lookup_entity("amp"), Some("&"));
+ assert_eq!(lookup_entity("lt"), Some("<"));
+ assert_eq!(lookup_entity("gt"), Some(">"));
+ assert_eq!(lookup_entity("apos"), Some("'"));
+ assert_eq!(lookup_entity("quot"), Some("\""));
+ }
+
+ #[test]
+ fn test_lookup_html_entities() {
+ assert_eq!(lookup_entity("nbsp"), Some("\u{00A0}"));
+ assert_eq!(lookup_entity("copy"), Some("\u{00A9}"));
+ assert_eq!(lookup_entity("reg"), Some("\u{00AE}"));
+ assert_eq!(lookup_entity("euro"), Some("\u{20AC}"));
+ assert_eq!(lookup_entity("mdash"), Some("\u{2014}"));
+ assert_eq!(lookup_entity("ndash"), Some("\u{2013}"));
+ assert_eq!(lookup_entity("hellip"), Some("\u{2026}"));
+ }
+
+ #[test]
+ fn test_lookup_greek_entities() {
+ assert_eq!(lookup_entity("Alpha"), Some("\u{0391}"));
+ assert_eq!(lookup_entity("alpha"), Some("\u{03B1}"));
+ assert_eq!(lookup_entity("Omega"), Some("\u{03A9}"));
+ assert_eq!(lookup_entity("omega"), Some("\u{03C9}"));
+ assert_eq!(lookup_entity("pi"), Some("\u{03C0}"));
+ }
+
+ #[test]
+ fn test_reverse_lookup() {
+ assert_eq!(reverse_lookup_entity('\u{00A9}'), Some("copy"));
+ assert_eq!(reverse_lookup_entity('\u{00A0}'), Some("nbsp"));
+ assert_eq!(reverse_lookup_entity('\u{0161}'), Some("scaron"));
+ assert_eq!(reverse_lookup_entity('\u{00E8}'), Some("egrave"));
+ assert_eq!(reverse_lookup_entity('\u{20AC}'), Some("euro"));
+ // ASCII characters should not have reverse lookups (handled separately)
+ assert_eq!(reverse_lookup_entity('A'), None);
+ assert_eq!(reverse_lookup_entity(' '), None);
+ }
+
+ #[test]
+ fn test_lookup_nonexistent() {
+ assert_eq!(lookup_entity("nonexistent"), None);
+ assert_eq!(lookup_entity(""), None);
+ assert_eq!(lookup_entity("NBSP"), None); // case-sensitive
+ }
+
+ #[test]
+ fn test_table_is_sorted() {
+ for window in ENTITIES.windows(2) {
+ assert!(
+ window[0].0 < window[1].0,
+ "entity table not sorted: {:?} should come before {:?}",
+ window[0].0,
+ window[1].0
+ );
+ }
+ }
+}
diff --git a/browser/vendor/xmloxide/src/html/mod.rs b/browser/vendor/xmloxide/src/html/mod.rs
new file mode 100644
index 000000000..ac1cc9c19
--- /dev/null
+++ b/browser/vendor/xmloxide/src/html/mod.rs
@@ -0,0 +1,1773 @@
+//! Error-tolerant HTML parser.
+//!
+//! This module implements an error-tolerant HTML 4.01 parser, similar to
+//! libxml2's `HTMLparser.c`. Unlike the strict XML parser, this parser handles
+//! common HTML patterns that are technically malformed:
+//!
+//! - Missing closing tags (auto-closed based on HTML content model rules)
+//! - Unquoted attribute values (`<div class=main>`)
+//! - Void elements that never need closing (`<br>`, `<img>`, `<hr>`, etc.)
+//! - Case-insensitive tag name matching
+//! - Bare `&` characters (not just `&`)
+//! - Missing doctype
+//! - Boolean attributes without values (`<input disabled>`)
+//!
+//! The parser produces the same `Document` tree structure as the XML parser.
+//!
+//! # Examples
+//!
+//! ```
+//! use xmloxide::html::parse_html;
+//!
+//! let doc = parse_html("<p>Hello <b>world</b>").unwrap();
+//! let root = doc.root_element().unwrap();
+//! assert_eq!(doc.node_name(root), Some("html"));
+//! ```
+
+pub mod entities;
+
+use crate::error::{ErrorSeverity, ParseDiagnostic, ParseError};
+use crate::parser::input::ParserInput;
+use crate::tree::{Attribute, Document, NodeId, NodeKind};
+
+/// Options controlling HTML parser behavior.
+///
+/// Use the builder pattern to configure options:
+///
+/// ```
+/// use xmloxide::html::HtmlParseOptions;
+///
+/// let opts = HtmlParseOptions::default()
+/// .recover(true)
+/// .no_blanks(true)
+/// .no_implied(true);
+/// ```
+#[derive(Debug, Clone)]
+#[allow(clippy::struct_excessive_bools)]
+pub struct HtmlParseOptions {
+ /// If true, attempt to recover from errors and produce a partial tree.
+ /// This is always effectively true for HTML parsing since HTML is
+ /// inherently error-tolerant, but setting this to false makes the parser
+ /// stricter about certain issues.
+ pub recover: bool,
+ /// If true, strip ignorable whitespace-only text nodes.
+ pub no_blanks: bool,
+ /// If true, do not add implied `html`, `head`, and `body` elements.
+ pub no_implied: bool,
+ /// If true, suppress warning diagnostics.
+ pub no_warnings: bool,
+}
+
+impl Default for HtmlParseOptions {
+ fn default() -> Self {
+ Self {
+ recover: true,
+ no_blanks: false,
+ no_implied: false,
+ no_warnings: false,
+ }
+ }
+}
+
+impl HtmlParseOptions {
+ /// Enables or disables error recovery mode.
+ ///
+ /// When enabled, the parser attempts to produce a partial tree even when
+ /// it encounters malformed markup, collecting errors as diagnostics on
+ /// the resulting [`Document`]. HTML parsing is inherently error-tolerant,
+ /// but disabling this makes the parser stricter about certain issues.
+ /// Enabled by default.
+ #[must_use]
+ pub fn recover(mut self, yes: bool) -> Self {
+ self.recover = yes;
+ self
+ }
+
+ /// Enables or disables stripping of blank (whitespace-only) text nodes.
+ ///
+ /// When enabled, text nodes that contain only whitespace (spaces, tabs,
+ /// newlines) are discarded during parsing. This is useful for reducing
+ /// tree size when whitespace between elements is not significant.
+ /// Disabled by default.
+ #[must_use]
+ pub fn no_blanks(mut self, yes: bool) -> Self {
+ self.no_blanks = yes;
+ self
+ }
+
+ /// Enables or disables generation of implied `<html>`, `<head>`, and
+ /// `<body>` elements.
+ ///
+ /// By default, the HTML parser automatically wraps content in these
+ /// structural elements when they are missing (matching browser behavior).
+ /// When enabled, the parser omits these implied wrappers, producing a
+ /// tree that more closely reflects the literal input.
+ /// Disabled by default.
+ #[must_use]
+ pub fn no_implied(mut self, yes: bool) -> Self {
+ self.no_implied = yes;
+ self
+ }
+
+ /// Enables or disables suppression of warning-level diagnostics.
+ ///
+ /// When enabled, only errors and fatal issues are recorded in
+ /// [`Document::diagnostics`]; warnings about non-critical issues (e.g.,
+ /// missing optional closing tags) are silently discarded.
+ /// Disabled by default.
+ #[must_use]
+ pub fn no_warnings(mut self, yes: bool) -> Self {
+ self.no_warnings = yes;
+ self
+ }
+}
+
+/// Parses an HTML string into a `Document` with default options.
+///
+/// The parser is error-tolerant and will produce a tree even for malformed
+/// HTML. Diagnostics about any issues found during parsing are stored in
+/// `Document::diagnostics`.
+///
+/// # Errors
+///
+/// Returns `ParseError` only for truly unrecoverable errors (e.g., empty input
+/// when recovery is disabled).
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::html::parse_html;
+///
+/// let doc = parse_html("<p>Hello <b>world</b>").unwrap();
+/// let root = doc.root_element().unwrap();
+/// assert_eq!(doc.node_name(root), Some("html"));
+/// ```
+pub fn parse_html(input: &str) -> Result<Document, ParseError> {
+ parse_html_with_options(input, &HtmlParseOptions::default())
+}
+
+/// Parses an HTML string into a `Document` with the given options.
+///
+/// # Errors
+///
+/// Returns `ParseError` if the input cannot be parsed and recovery mode is
+/// disabled.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::html::{parse_html_with_options, HtmlParseOptions};
+///
+/// let opts = HtmlParseOptions::default().no_blanks(true);
+/// let doc = parse_html_with_options("<html><body><p>Hi</p></body></html>", &opts).unwrap();
+/// ```
+pub fn parse_html_with_options(
+ input: &str,
+ options: &HtmlParseOptions,
+) -> Result<Document, ParseError> {
+ let mut parser = HtmlParser::new(input, options);
+ parser.parse()
+}
+
+// --- Void elements (elements that must not have content) ---
+// See HTML 4.01 and common usage. These elements are self-closing.
+
+/// Returns true if the given tag name (lowercase) is a void element that
+/// must not have content.
+pub(crate) fn is_void_element(tag: &str) -> bool {
+ matches!(
+ tag,
+ "area"
+ | "base"
+ | "br"
+ | "col"
+ | "embed"
+ | "hr"
+ | "img"
+ | "input"
+ | "link"
+ | "meta"
+ | "param"
+ | "source"
+ | "track"
+ | "wbr"
+ | "basefont"
+ | "frame"
+ | "isindex"
+ )
+}
+
+/// HTML4 attributes libxml serializes in minimized form regardless of value.
+pub(crate) fn is_boolean_attribute(name: &str) -> bool {
+ matches!(
+ name,
+ "checked"
+ | "compact"
+ | "declare"
+ | "defer"
+ | "disabled"
+ | "ismap"
+ | "multiple"
+ | "nohref"
+ | "noresize"
+ | "noshade"
+ | "nowrap"
+ | "readonly"
+ | "selected"
+ )
+}
+
+fn html_char_reference(value: u32) -> char {
+ match value {
+ 0 | 0xD800..=0xDFFF | 0x11_0000.. => '\u{FFFD}',
+ 0x80 => '\u{20AC}',
+ 0x82 => '\u{201A}',
+ 0x83 => '\u{0192}',
+ 0x84 => '\u{201E}',
+ 0x85 => '\u{2026}',
+ 0x86 => '\u{2020}',
+ 0x87 => '\u{2021}',
+ 0x88 => '\u{02C6}',
+ 0x89 => '\u{2030}',
+ 0x8A => '\u{0160}',
+ 0x8B => '\u{2039}',
+ 0x8C => '\u{0152}',
+ 0x8E => '\u{017D}',
+ 0x91 => '\u{2018}',
+ 0x92 => '\u{2019}',
+ 0x93 => '\u{201C}',
+ 0x94 => '\u{201D}',
+ 0x95 => '\u{2022}',
+ 0x96 => '\u{2013}',
+ 0x97 => '\u{2014}',
+ 0x98 => '\u{02DC}',
+ 0x99 => '\u{2122}',
+ 0x9A => '\u{0161}',
+ 0x9B => '\u{203A}',
+ 0x9C => '\u{0153}',
+ 0x9E => '\u{017E}',
+ 0x9F => '\u{0178}',
+ _ => char::from_u32(value).unwrap_or('\u{FFFD}'),
+ }
+}
+
+/// Returns true if `tag` is an element whose opening auto-closes `open_tag`.
+///
+/// For example, a `<p>` auto-closes a previous `<p>`, and a `<li>` auto-closes
+/// a previous `<li>`.
+///
+/// See HTML 4.01 DTD for the optional end tag rules.
+fn auto_closes(open_tag: &str, tag: &str) -> bool {
+ match open_tag {
+ "a" => matches!(tag, "fieldset" | "table" | "td" | "th" | "a"),
+ "b" | "i" | "u" => matches!(tag, "p" | "td" | "th"),
+ "s" | "small" | "big" => tag == "p",
+ "span" | "font" => matches!(tag, "td" | "th"),
+ "p" => matches!(
+ tag,
+ "p" | "div"
+ | "ul"
+ | "ol"
+ | "dl"
+ | "pre"
+ | "table"
+ | "blockquote"
+ | "address"
+ | "h1"
+ | "h2"
+ | "h3"
+ | "h4"
+ | "h5"
+ | "h6"
+ | "hr"
+ | "form"
+ | "fieldset"
+ | "section"
+ | "article"
+ | "aside"
+ | "header"
+ | "footer"
+ | "nav"
+ | "figure"
+ | "figcaption"
+ | "main"
+ | "details"
+ | "summary"
+ | "tr"
+ | "td"
+ | "th"
+ ),
+ "li" => tag == "li",
+ "dt" => matches!(tag, "dt" | "dd"),
+ "dd" => tag == "dt",
+ "tr" => tag == "tr",
+ "td" => matches!(tag, "td" | "th" | "tr"),
+ "th" => matches!(tag, "td" | "th" | "tr"),
+ "thead" => matches!(tag, "tbody" | "tfoot"),
+ "tbody" => matches!(tag, "tbody" | "tfoot"),
+ "tfoot" => tag == "tbody",
+ "option" => matches!(tag, "option" | "optgroup"),
+ "optgroup" => tag == "optgroup",
+ "colgroup" => {
+ // colgroup is auto-closed by most things that are not col
+ tag != "col" && matches!(tag, "thead" | "tbody" | "tfoot" | "tr" | "colgroup")
+ }
+ "head" => matches!(tag, "body" | "frameset"),
+ _ => false,
+ }
+}
+
+/// Returns true if `tag` is a raw text element whose content is not parsed
+/// as HTML (script, style).
+pub(crate) fn is_raw_text_element(tag: &str) -> bool {
+ matches!(tag, "script" | "style")
+}
+
+/// Returns true if `tag` is an element that belongs in `<head>`.
+fn is_head_content_element(tag: &str) -> bool {
+ matches!(
+ tag,
+ "title" | "meta" | "link" | "base" | "style" | "script" | "noscript"
+ )
+}
+
+// --- The HTML Parser ---
+
+/// The core HTML parser state machine.
+///
+/// Implements a hand-rolled, error-tolerant parser for HTML 4.01 that produces
+/// a `Document` tree. Unlike the XML parser, this parser:
+/// - Normalizes tag names to lowercase
+/// - Handles void elements (self-closing elements like `<br>`)
+/// - Auto-closes elements based on HTML content model rules
+/// - Accepts unquoted and boolean attributes
+/// - Resolves HTML named character references
+/// - Adds implied elements (html, head, body) when missing
+struct HtmlParser<'a> {
+ /// Shared low-level input state (position, peek, advance, etc.).
+ input: ParserInput<'a>,
+ /// The document being built.
+ doc: Document,
+ /// Parser options.
+ options: HtmlParseOptions,
+ /// Stack of open element node IDs and their lowercase tag names.
+ open_elements: Vec<(NodeId, String)>,
+ /// Set when a fatal error (e.g. depth limit) occurs; stops parsing.
+ fatal_error: Option<ParseError>,
+}
+
+impl<'a> HtmlParser<'a> {
+ fn new(input: &'a str, options: &HtmlParseOptions) -> Self {
+ let mut pi = ParserInput::new(input);
+ pi.set_recover(options.recover);
+
+ Self {
+ input: pi,
+ doc: Document::new(),
+ options: options.clone(),
+ open_elements: Vec::new(),
+ fatal_error: None,
+ }
+ }
+
+ /// Main parse entry point. Parses the entire HTML document.
+ fn parse(&mut self) -> Result<Document, ParseError> {
+ self.input.skip_whitespace();
+
+ // Track whether a DOCTYPE was found in the input
+ let mut has_doctype = false;
+
+ // Parse optional DOCTYPE
+ if self.input.looking_at_ci(b"<!doctype") {
+ self.parse_doctype();
+ self.input.skip_whitespace();
+ has_doctype = true;
+ }
+
+ // Parse the body content
+ self.parse_content();
+
+ // If a fatal error was recorded (e.g. depth limit), return it.
+ if let Some(err) = self.fatal_error.take() {
+ return Err(err);
+ }
+
+ // Close any remaining open elements
+ while let Some((_, tag)) = self.open_elements.pop() {
+ self.push_warning(format!("unclosed element <{tag}> at end of document"));
+ }
+
+ // Add default DOCTYPE if none was in the input and not disabled
+ if !has_doctype && !self.options.no_implied {
+ let doctype_id = self.doc.create_node(NodeKind::DocumentType {
+ name: "html".to_string(),
+ public_id: Some("-//W3C//DTD HTML 4.0 Transitional//EN".to_string()),
+ system_id: Some("http://www.w3.org/TR/REC-html40/loose.dtd".to_string()),
+ internal_subset: None,
+ });
+ // Prepend DOCTYPE before the first child of the document root
+ let root = self.doc.root();
+ self.doc.prepend_child(root, doctype_id);
+ }
+
+ Ok(std::mem::take(&mut self.doc))
+ }
+
+ /// Ensures an implied `<html>` element exists at the document root.
+ /// Returns its `NodeId`.
+ fn ensure_html(&mut self) -> NodeId {
+ let root = self.doc.root();
+ // Look for existing html element
+ for id in self.doc.children(root) {
+ if matches!(&self.doc.node(id).kind, NodeKind::Element { name, .. } if name == "html") {
+ return id;
+ }
+ }
+ // Create implied html
+ let html_id = self.doc.create_node(NodeKind::Element {
+ name: "html".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ self.doc.append_child(root, html_id);
+ self.open_elements.push((html_id, "html".to_string()));
+ html_id
+ }
+
+ /// Ensures an implied `<body>` element exists under `<html>`.
+ /// Returns its `NodeId`.
+ fn ensure_body(&mut self) -> NodeId {
+ let html_id = self.ensure_html();
+ // Look for existing body element
+ for id in self.doc.children(html_id) {
+ if matches!(&self.doc.node(id).kind, NodeKind::Element { name, .. } if name == "body") {
+ return id;
+ }
+ }
+ // Create implied body
+ let body_id = self.doc.create_node(NodeKind::Element {
+ name: "body".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ self.doc.append_child(html_id, body_id);
+ self.open_elements.push((body_id, "body".to_string()));
+ body_id
+ }
+
+ /// Ensures an implied `<head>` element exists under `<html>`.
+ /// Returns its `NodeId`.
+ fn ensure_head(&mut self) -> NodeId {
+ let html_id = self.ensure_html();
+ // Look for existing head element
+ for id in self.doc.children(html_id) {
+ if matches!(&self.doc.node(id).kind, NodeKind::Element { name, .. } if name == "head") {
+ return id;
+ }
+ }
+ // Create implied head. Insert before body if body exists,
+ // otherwise append to html.
+ let head_id = self.doc.create_node(NodeKind::Element {
+ name: "head".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ // Find body — if it exists, insert head before it
+ let body_id = self.doc.children(html_id).find(|&id| {
+ matches!(&self.doc.node(id).kind, NodeKind::Element { name, .. } if name == "body")
+ });
+ if let Some(body) = body_id {
+ self.doc.insert_before(body, head_id);
+ } else {
+ self.doc.append_child(html_id, head_id);
+ }
+ head_id
+ }
+
+ /// Returns the current insertion point (the innermost open element, or
+ /// the document root).
+ fn current_parent(&self) -> NodeId {
+ self.open_elements
+ .last()
+ .map_or_else(|| self.doc.root(), |&(id, _)| id)
+ }
+
+ /// Parses the HTML content: elements, text, comments, etc.
+ fn parse_content(&mut self) {
+ while !self.input.at_end() && self.fatal_error.is_none() {
+ if self.input.looking_at(b"<!--") {
+ self.parse_comment();
+ } else if self.input.looking_at_ci(b"<!doctype") {
+ // Ignore extra doctypes
+ self.skip_to_gt();
+ } else if self.input.looking_at(b"</") {
+ self.parse_end_tag();
+ } else if self.input.peek() == Some(b'<')
+ && self
+ .input
+ .peek_at(1)
+ .is_some_and(|b| b.is_ascii_alphabetic())
+ {
+ self.parse_start_tag();
+ } else if self.input.peek() == Some(b'<') && self.input.peek_at(1) == Some(b'!') {
+ // Could be <![if ...]> (IE conditional comment) or other malformed markup
+ if self.input.peek_at(2) == Some(b'[') {
+ self.skip_conditional_comment();
+ } else {
+ self.push_warning("malformed markup".to_string());
+ self.input.advance(1);
+ }
+ } else if self.input.peek() == Some(b'<') && self.input.peek_at(1) == Some(b'?') {
+ self.parse_processing_instruction();
+ } else if self.input.peek() == Some(b'<') {
+ // Bare '<' not followed by alpha, '/', '!', or '?' — treat as text.
+ // We must consume it here to avoid an infinite loop, since
+ // parse_text() breaks on '<' without advancing.
+ self.input.advance(1);
+ if !self.options.no_implied && self.open_elements.is_empty() {
+ self.ensure_body();
+ }
+ let parent = self.current_parent();
+ // Merge with previous text node if possible
+ if let Some(last_child) = self.doc.last_child(parent) {
+ if let NodeKind::Text { content } = &mut self.doc.node_mut(last_child).kind {
+ content.push('<');
+ continue;
+ }
+ }
+ let text_id = self.doc.create_node(NodeKind::Text {
+ content: "<".to_string(),
+ });
+ self.doc.append_child(parent, text_id);
+ } else {
+ self.parse_text();
+ }
+ }
+ }
+
+ // --- DOCTYPE ---
+
+ fn parse_doctype(&mut self) {
+ // Skip <!DOCTYPE (case-insensitive)
+ self.input.advance(9); // "<!DOCTYPE" or "<!doctype"
+ self.input.skip_whitespace();
+
+ // Read the root element name
+ let name = self.parse_tag_name();
+
+ self.input.skip_whitespace();
+
+ let mut system_id = None;
+ let mut public_id = None;
+
+ if self.input.looking_at_ci(b"system") {
+ self.input.advance(6);
+ self.input.skip_whitespace();
+ system_id = self.try_parse_quoted_value();
+ self.input.skip_whitespace();
+ } else if self.input.looking_at_ci(b"public") {
+ self.input.advance(6);
+ self.input.skip_whitespace();
+ public_id = self.try_parse_quoted_value();
+ self.input.skip_whitespace();
+ system_id = self.try_parse_quoted_value();
+ self.input.skip_whitespace();
+ }
+
+ // Skip to end of DOCTYPE
+ while !self.input.at_end() && self.input.peek() != Some(b'>') {
+ self.input.advance(1);
+ }
+ if !self.input.at_end() {
+ self.input.advance(1); // consume '>'
+ }
+
+ let doctype_id = self.doc.create_node(NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ internal_subset: None,
+ });
+ self.doc.append_child(self.doc.root(), doctype_id);
+ }
+
+ // --- Start Tag ---
+
+ #[allow(clippy::too_many_lines)]
+ fn parse_start_tag(&mut self) {
+ let tag_start = self.input.save_position();
+ self.input.advance(1); // consume '<'
+ if let Err(e) = self.input.increment_depth() {
+ self.fatal_error = Some(e);
+ return;
+ }
+ let tag = self.parse_tag_name();
+
+ if tag.is_empty() {
+ self.push_warning("empty tag name".to_string());
+ self.input.decrement_depth();
+ self.skip_to_gt();
+ return;
+ }
+
+ let lower_tag = tag.to_ascii_lowercase();
+
+ // Parse attributes
+ let attributes = self.parse_attributes();
+
+ self.input.skip_whitespace();
+
+ // libxml discards an unterminated start tag and everything consumed
+ // since '<' instead of synthesizing an element at EOF.
+ if self.input.at_end() {
+ self.input.restore_position(tag_start);
+ self.input.advance(self.input.remaining().len());
+ self.input.decrement_depth();
+ return;
+ }
+
+ // Handle self-closing slash
+ let explicit_self_close = self.input.peek() == Some(b'/');
+ if explicit_self_close {
+ self.input.advance(1);
+ }
+
+ // Consume '>'
+ if self.input.peek() == Some(b'>') {
+ self.input.advance(1);
+ } else if !self.input.at_end() {
+ self.push_warning(format!("expected '>' after tag <{lower_tag}>"));
+ self.skip_to_gt();
+ }
+
+ // Handle structural elements by merging with existing implied elements
+ if !self.options.no_implied {
+ if lower_tag == "html" {
+ let html_id = self.ensure_html();
+ self.merge_attributes(html_id, attributes);
+ // Ensure html is on the open_elements stack
+ if !self.open_elements.iter().any(|(_, t)| t == "html") {
+ self.open_elements.push((html_id, "html".to_string()));
+ }
+ self.input.decrement_depth();
+ return;
+ }
+ if lower_tag == "head" {
+ let head_id = self.ensure_head();
+ self.merge_attributes(head_id, attributes);
+ // Push head to open_elements so child elements go inside it
+ if !self.open_elements.iter().any(|(_, t)| t == "head") {
+ self.open_elements.push((head_id, "head".to_string()));
+ }
+ self.input.decrement_depth();
+ return;
+ }
+ if lower_tag == "body" && !self.is_in_frameset() {
+ // Close head if open
+ self.close_head_if_open();
+ let body_id = self.ensure_body();
+ self.merge_attributes(body_id, attributes);
+ if !self.open_elements.iter().any(|(_, t)| t == "body") {
+ self.open_elements.push((body_id, "body".to_string()));
+ }
+ self.input.decrement_depth();
+ return;
+ }
+ }
+
+ // Handle auto-closing: if the new element auto-closes an open one,
+ // pop the stack accordingly.
+ self.handle_auto_close(&lower_tag);
+
+ // For non-structural elements, ensure proper containment
+ if !self.options.no_implied {
+ if lower_tag == "frameset" {
+ // <frameset> replaces <body> in HTML 4.01 — place it
+ // directly under <html>, not inside <body>
+ self.close_head_if_open();
+ self.ensure_html();
+ } else if is_head_content_element(&lower_tag) && !self.is_in_body() {
+ // Head-content elements go under <head>
+ let head_id = self.ensure_head();
+ if !self.open_elements.iter().any(|(_, t)| t == "head") {
+ self.open_elements.push((head_id, "head".to_string()));
+ }
+ } else if self.is_in_frameset() {
+ // Inside a frameset context, don't auto-create body.
+ // Elements like <frame>, <noframes> stay inside frameset.
+ } else {
+ // Body-content elements: close head, ensure body exists
+ self.close_head_if_open();
+ self.ensure_body();
+ }
+ }
+
+ let parent = self.current_parent();
+
+ let id_value = attributes.iter().find_map(|a| {
+ if a.name == "id" {
+ Some(a.value.clone())
+ } else {
+ None
+ }
+ });
+
+ let elem_id = self.doc.create_node(NodeKind::Element {
+ name: lower_tag.clone(),
+ prefix: None,
+ namespace: None,
+ attributes,
+ });
+ self.doc.append_child(parent, elem_id);
+
+ if let Some(id_val) = id_value {
+ self.doc.set_id(&id_val, elem_id);
+ }
+
+ // Void elements and explicit self-close don't get pushed
+ if is_void_element(&lower_tag) || explicit_self_close {
+ self.input.decrement_depth();
+ return;
+ }
+
+ // Raw text elements (script, style) need special handling
+ if is_raw_text_element(&lower_tag) {
+ self.open_elements.push((elem_id, lower_tag.clone()));
+ self.parse_raw_text(&lower_tag);
+ // pop the element after raw text
+ self.open_elements.pop();
+ self.input.decrement_depth();
+ return;
+ }
+
+ // HTML4/libxml treats `<plaintext>` as an irreversible switch: every
+ // remaining byte, including apparent end tags and entity references,
+ // belongs to one text node. The serializer escapes that text and adds
+ // the element's synthetic closing tag.
+ if lower_tag == "plaintext" {
+ self.open_elements.push((elem_id, lower_tag));
+ let remaining = self.input.remaining();
+ if !remaining.is_empty() {
+ let content = String::from_utf8_lossy(remaining).into_owned();
+ let text_id = self.doc.create_node(NodeKind::Text { content });
+ self.doc.append_child(elem_id, text_id);
+ self.input.advance(remaining.len());
+ }
+ self.input.decrement_depth();
+ return;
+ }
+
+ self.open_elements.push((elem_id, lower_tag));
+ }
+
+ /// Merges attributes from a parsed tag into an existing element node.
+ fn merge_attributes(&mut self, elem_id: NodeId, attrs: Vec<Attribute>) {
+ if attrs.is_empty() {
+ return;
+ }
+ if let NodeKind::Element { attributes, .. } = &mut self.doc.node_mut(elem_id).kind {
+ for attr in attrs {
+ if !attributes.iter().any(|a| a.name == attr.name) {
+ attributes.push(attr);
+ }
+ }
+ }
+ }
+
+ /// Closes `<head>` if it's currently open on the element stack.
+ fn close_head_if_open(&mut self) {
+ if self.open_elements.last().is_some_and(|(_, t)| t == "head") {
+ self.open_elements.pop();
+ }
+ }
+
+ /// Returns true if the parser is currently inside `<body>`.
+ fn is_in_body(&self) -> bool {
+ self.open_elements.iter().any(|(_, t)| t == "body")
+ }
+
+ /// Returns true if the parser is currently inside a `<frameset>`.
+ fn is_in_frameset(&self) -> bool {
+ self.open_elements.iter().any(|(_, t)| t == "frameset")
+ }
+
+ /// Handles auto-closing of open elements when a new element is encountered.
+ fn handle_auto_close(&mut self, new_tag: &str) {
+ // Walk the open elements stack from top to find elements that should
+ // be auto-closed by the new tag.
+ loop {
+ let should_close = self
+ .open_elements
+ .last()
+ .is_some_and(|(_, open_tag)| auto_closes(open_tag, new_tag));
+ if should_close {
+ self.open_elements.pop();
+ self.input.decrement_depth();
+ } else {
+ break;
+ }
+ }
+ }
+
+ // --- End Tag ---
+
+ fn parse_end_tag(&mut self) {
+ self.input.advance(2); // consume '</'
+ let tag = self.parse_tag_name();
+ let lower_tag = tag.to_ascii_lowercase();
+
+ // Skip to '>'
+ self.input.skip_whitespace();
+ if self.input.peek() == Some(b'>') {
+ self.input.advance(1);
+ } else if !self.input.at_end() {
+ self.push_warning(format!("expected '>' after end tag </{lower_tag}>"));
+ self.skip_to_gt();
+ }
+
+ // Void elements should not have end tags; ignore them.
+ if is_void_element(&lower_tag) {
+ self.push_warning(format!("end tag for void element </{lower_tag}> ignored"));
+ return;
+ }
+
+ // Find the matching open element in the stack
+ let found = self
+ .open_elements
+ .iter()
+ .rposition(|(_, name)| *name == lower_tag);
+
+ if let Some(idx) = found {
+ // libxml's HTML4 recovery refuses an ancestor end tag when a
+ // still-open structural element above it cannot be implicitly
+ // closed. The unmatched ancestor then remains open to EOF.
+ let incompatible = |tag: &str| match lower_tag.as_str() {
+ "table" => false,
+ "thead" => matches!(tag, "table" | "tbody" | "tfoot"),
+ "tbody" => matches!(tag, "table" | "tfoot"),
+ "tfoot" => matches!(tag, "table" | "tbody"),
+ "tr" => matches!(tag, "table" | "thead" | "tbody" | "tfoot"),
+ "td" | "th" => matches!(
+ tag,
+ "table" | "thead" | "tbody" | "tfoot" | "tr" | "td" | "th"
+ ),
+ _ => matches!(
+ tag,
+ "div" | "table" | "thead" | "tbody" | "tfoot" | "tr" | "td" | "th"
+ ),
+ };
+ if self.open_elements[idx + 1..]
+ .iter()
+ .any(|(_, tag)| incompatible(tag))
+ {
+ self.push_warning(format!("stray end tag </{lower_tag}>"));
+ return;
+ }
+ // Pop everything above and including the matched element
+ // (auto-closing any intervening elements)
+ let count = self.open_elements.len() - idx;
+ for i in (0..count).rev() {
+ let stack_idx = idx + i;
+ if stack_idx < self.open_elements.len() {
+ let (_, ref closed_tag) = self.open_elements[stack_idx];
+ if *closed_tag != lower_tag {
+ self.push_warning(format!(
+ "implicitly closing <{closed_tag}> before </{lower_tag}>"
+ ));
+ }
+ }
+ }
+ // Decrement depth for each element being closed
+ for _ in 0..count {
+ self.input.decrement_depth();
+ }
+ self.open_elements.truncate(idx);
+ } else {
+ // No matching open element — stray end tag
+ self.push_warning(format!("stray end tag </{lower_tag}>"));
+ }
+ }
+
+ // --- Attributes ---
+
+ fn parse_attributes(&mut self) -> Vec<Attribute> {
+ let mut attributes = Vec::new();
+
+ loop {
+ self.input.skip_whitespace();
+
+ // Check for end of tag
+ if self.input.at_end()
+ || self.input.peek() == Some(b'>')
+ || self.input.peek() == Some(b'/')
+ || self.input.looking_at(b"/>")
+ {
+ break;
+ }
+
+ // Parse attribute name
+ let name = self.parse_attr_name();
+ if name.is_empty() {
+ // Skip the bad character and continue
+ self.input.advance(1);
+ continue;
+ }
+
+ let lower_name = name.to_ascii_lowercase();
+
+ self.input.skip_whitespace();
+
+ // Check for = (attribute with value)
+ let (value, minimized) = if self.input.peek() == Some(b'=') {
+ self.input.advance(1); // consume '='
+ self.input.skip_whitespace();
+ (self.parse_attr_value(), false)
+ } else {
+ // libxml exposes HTML4 boolean attributes as their own name;
+ // other minimized attributes have an empty DOM value.
+ (
+ if is_boolean_attribute(&lower_name) {
+ lower_name.clone()
+ } else {
+ String::new()
+ },
+ true,
+ )
+ };
+
+ // libxml keeps the first duplicate attribute and discards later
+ // occurrences without disturbing source order.
+ if !attributes
+ .iter()
+ .any(|attr: &Attribute| attr.name == lower_name)
+ {
+ attributes.push(Attribute {
+ name: lower_name,
+ value,
+ prefix: None,
+ namespace: None,
+ // An empty raw value cannot be produced by entity
+ // expansion, so it safely remembers source minimization
+ // for the libxml-compatible HTML serializer.
+ raw_value: minimized.then(String::new),
+ });
+ }
+ }
+
+ attributes
+ }
+
+ /// Parses an attribute name (sequence of non-whitespace, non-special chars).
+ fn parse_attr_name(&mut self) -> String {
+ let start = self.input.pos();
+ while let Some(b) = self.input.peek() {
+ if b == b' '
+ || b == b'\t'
+ || b == b'\r'
+ || b == b'\n'
+ || b == b'='
+ || b == b'>'
+ || b == b'/'
+ || b == b'<'
+ || b == b'"'
+ || b == b'\''
+ {
+ break;
+ }
+ self.input.advance(1);
+ }
+ String::from_utf8_lossy(self.input.slice(start, self.input.pos())).to_string()
+ }
+
+ /// Parses an attribute value. Handles quoted and unquoted values.
+ fn parse_attr_value(&mut self) -> String {
+ if self.input.at_end() {
+ return String::new();
+ }
+
+ let b = self.input.peek();
+ if b == Some(b'"') || b == Some(b'\'') {
+ // Quoted attribute value — we know `b` is Some from the check above
+ let quote = b.unwrap_or(b'"');
+ self.input.advance(1); // consume opening quote
+ let mut value = String::new();
+ while !self.input.at_end() {
+ let ch = self.input.peek();
+ if ch == Some(quote) {
+ self.input.advance(1);
+ break;
+ }
+ if ch == Some(b'&') {
+ let resolved = self.parse_html_reference();
+ value.push_str(&resolved);
+ } else {
+ let c = self.next_char_html();
+ value.push(c);
+ }
+ }
+ value
+ } else {
+ // Unquoted attribute value
+ let mut value = String::new();
+ while let Some(b) = self.input.peek() {
+ if b == b' '
+ || b == b'\t'
+ || b == b'\r'
+ || b == b'\n'
+ || b == b'>'
+ || b == b'<'
+ || b == b'`'
+ {
+ break;
+ }
+ // Backslash escaping: \c includes both chars literally
+ // (libxml2 treats \" as literal backslash+quote)
+ if b == b'\\' {
+ let c1 = self.next_char_html();
+ value.push(c1);
+ if !self.input.at_end() {
+ let c2 = self.next_char_html();
+ value.push(c2);
+ }
+ continue;
+ }
+ if b == b'"' || b == b'\'' {
+ break;
+ }
+ if b == b'&' {
+ let resolved = self.parse_html_reference();
+ value.push_str(&resolved);
+ } else {
+ let c = self.next_char_html();
+ value.push(c);
+ }
+ }
+ value
+ }
+ }
+
+ // --- Text Content ---
+
+ fn parse_text(&mut self) {
+ let mut text = String::new();
+
+ while !self.input.at_end() {
+ if self.input.peek() == Some(b'<') {
+ break;
+ }
+
+ if self.input.peek() == Some(b'&') {
+ let resolved = self.parse_html_reference();
+ text.push_str(&resolved);
+ } else {
+ let ch = self.next_char_html();
+ text.push(ch);
+ }
+ }
+
+ if !text.is_empty() {
+ // Strip blank text nodes if configured
+ if self.options.no_blanks && text.chars().all(char::is_whitespace) {
+ return;
+ }
+ // Ensure body exists for text content (unless whitespace between
+ // structural elements or we're already inside an element)
+ if !self.options.no_implied && self.open_elements.is_empty() {
+ // Whitespace-only text before any elements is ignored
+ if text.chars().all(char::is_whitespace) {
+ return;
+ }
+ self.ensure_body();
+ }
+ let parent = self.current_parent();
+ let text_id = self.doc.create_node(NodeKind::Text { content: text });
+ self.doc.append_child(parent, text_id);
+ }
+ }
+
+ // --- Raw text (script/style) ---
+
+ fn parse_raw_text(&mut self, tag: &str) {
+ let mut content = String::new();
+ let end_tag_bytes: Vec<u8> = format!("</{tag}").bytes().collect();
+
+ while !self.input.at_end() {
+ if self.input.looking_at_ci(&end_tag_bytes) {
+ break;
+ }
+ let ch = self.next_char_html();
+ content.push(ch);
+ }
+
+ if !content.is_empty() {
+ let parent = self.current_parent();
+ let text_id = self.doc.create_node(NodeKind::Text { content });
+ self.doc.append_child(parent, text_id);
+ }
+
+ // Consume the end tag
+ if !self.input.at_end() {
+ self.input.advance(end_tag_bytes.len());
+ self.input.skip_whitespace();
+ if self.input.peek() == Some(b'>') {
+ self.input.advance(1);
+ }
+ }
+ }
+
+ // --- Comments ---
+
+ fn parse_comment(&mut self) {
+ self.input.advance(4); // consume '<!--'
+
+ // Handle abrupt closing: <!--> and <!--->
+ if self.input.peek() == Some(b'>') {
+ self.input.advance(1);
+ let parent = self.current_parent();
+ let comment_id = self.doc.create_node(NodeKind::Comment {
+ content: String::new(),
+ });
+ self.doc.append_child(parent, comment_id);
+ return;
+ }
+ if self.input.looking_at(b"->") {
+ self.input.advance(2);
+ let parent = self.current_parent();
+ let comment_id = self.doc.create_node(NodeKind::Comment {
+ content: String::new(),
+ });
+ self.doc.append_child(parent, comment_id);
+ return;
+ }
+
+ let mut content = String::new();
+ let mut terminated = false;
+
+ loop {
+ if self.input.at_end() {
+ self.push_warning("unterminated comment".to_string());
+ break;
+ }
+ // Standard comment end: -->
+ if self.input.looking_at(b"-->") {
+ self.input.advance(3);
+ terminated = true;
+ break;
+ }
+ // Quirky comment end: --!> (libxml2 treats this as -->)
+ if self.input.looking_at(b"--!>") {
+ self.input.advance(4);
+ terminated = true;
+ break;
+ }
+ let ch = self.next_char_html();
+ content.push(ch);
+ }
+
+ // libxml2 drops unterminated comments (those that reach EOF)
+ if !terminated {
+ return;
+ }
+
+ let parent = self.current_parent();
+ let comment_id = self.doc.create_node(NodeKind::Comment { content });
+ self.doc.append_child(parent, comment_id);
+ }
+
+ // --- Processing Instructions ---
+
+ fn parse_processing_instruction(&mut self) {
+ self.input.advance(2); // consume '<?'
+ let target = self.parse_tag_name();
+ self.input.skip_whitespace();
+
+ let mut data = String::new();
+ // In HTML mode, libxml2 reads PI content up to '>' only.
+ // The '?' before '>' (if present) is included in the content,
+ // so <?pi data?> stores data as "data?" and serializes as "<?pi data?>".
+ loop {
+ if self.input.at_end() {
+ self.push_warning("unterminated processing instruction".to_string());
+ break;
+ }
+ if self.input.peek() == Some(b'>') {
+ self.input.advance(1);
+ break;
+ }
+ let ch = self.next_char_html();
+ data.push(ch);
+ }
+
+ let pi_data = if data.is_empty() { None } else { Some(data) };
+
+ let parent = self.current_parent();
+ let pi_id = self.doc.create_node(NodeKind::ProcessingInstruction {
+ target,
+ data: pi_data,
+ });
+ self.doc.append_child(parent, pi_id);
+ }
+
+ // --- HTML Entity/Character References ---
+
+ /// Parses an HTML character or entity reference, or returns a bare `&`
+ /// if it doesn't look like a valid reference (error-tolerant).
+ fn parse_html_reference(&mut self) -> String {
+ // Save position for backtracking
+ let saved = self.input.save_position();
+
+ self.input.advance(1); // consume '&'
+
+ if self.input.peek() == Some(b'#') {
+ // Character reference
+ self.input.advance(1);
+ if self.input.peek() == Some(b'x') || self.input.peek() == Some(b'X') {
+ // Hex
+ self.input.advance(1);
+ let hex = self.take_while_ascii(|b| b.is_ascii_hexdigit());
+ if !hex.is_empty() {
+ if self.input.peek() == Some(b';') {
+ self.input.advance(1);
+ }
+ if let Ok(value) = u32::from_str_radix(&hex, 16) {
+ return html_char_reference(value).to_string();
+ }
+ }
+ // Invalid — backtrack
+ self.input.restore_position(saved);
+ self.input.advance(1);
+ return "&".to_string();
+ }
+ // Decimal
+ let dec = self.take_while_ascii(|b| b.is_ascii_digit());
+ if !dec.is_empty() {
+ if self.input.peek() == Some(b';') {
+ self.input.advance(1);
+ }
+ if let Ok(value) = dec.parse::<u32>() {
+ return html_char_reference(value).to_string();
+ }
+ }
+ // Invalid — backtrack
+ self.input.restore_position(saved);
+ self.input.advance(1);
+ return "&".to_string();
+ }
+
+ // Named entity reference
+ let name = self.take_while_ascii(|b| b.is_ascii_alphanumeric());
+ if !name.is_empty() {
+ // Try with semicolon
+ if self.input.peek() == Some(b';') {
+ self.input.advance(1);
+ if let Some(value) = entities::lookup_entity(&name) {
+ return value.to_string();
+ }
+ // libxml's HTML parser accepts the longest known entity
+ // prefix even when the complete name is unknown.
+ for split in (1..name.len()).rev() {
+ if !name.is_char_boundary(split) {
+ continue;
+ }
+ if let Some(value) = entities::lookup_entity(&name[..split]) {
+ return format!("{value}{};", &name[split..]);
+ }
+ }
+ // Unknown entity — return it as-is with the & and ;
+ self.push_warning(format!("unknown entity reference: &{name};"));
+ return format!("&{name};");
+ }
+ // Try without semicolon (error-tolerant: some HTML uses & without ;)
+ if let Some(value) = entities::lookup_entity(&name) {
+ self.push_warning(format!("entity reference &{name} missing semicolon"));
+ return value.to_string();
+ }
+ }
+
+ // Not a valid reference — backtrack and return bare &
+ self.input.restore_position(saved);
+ self.input.advance(1);
+ "&".to_string()
+ }
+
+ // --- Tag Name Parsing ---
+
+ /// Parses an HTML tag name. Tag names can contain letters, digits, hyphens,
+ /// and a few other characters. Returns the name as-is (caller normalizes case).
+ fn parse_tag_name(&mut self) -> String {
+ let start = self.input.pos();
+ while let Some(b) = self.input.peek() {
+ if b.is_ascii_alphanumeric() || b == b'-' || b == b'_' || b == b':' || b == b'.' {
+ self.input.advance(1);
+ } else {
+ break;
+ }
+ }
+ String::from_utf8_lossy(self.input.slice(start, self.input.pos())).to_string()
+ }
+
+ /// Tries to parse a quoted value for DOCTYPE SYSTEM/PUBLIC identifiers.
+ fn try_parse_quoted_value(&mut self) -> Option<String> {
+ let quote = self.input.peek()?;
+ if quote != b'"' && quote != b'\'' {
+ return None;
+ }
+ self.input.advance(1);
+ let start = self.input.pos();
+ while !self.input.at_end() && self.input.peek() != Some(quote) {
+ self.input.advance(1);
+ }
+ let value = String::from_utf8_lossy(self.input.slice(start, self.input.pos())).to_string();
+ if !self.input.at_end() {
+ self.input.advance(1); // closing quote
+ }
+ Some(value)
+ }
+
+ // --- HTML-specific low-level helpers ---
+ // These methods are NOT shared with the XML parser because HTML has
+ // different rules (error tolerance, different character handling, etc.).
+
+ /// Reads the next character, handling CR/LF normalization.
+ /// Returns `'\0'` at end of input (error-tolerant, unlike the XML parser
+ /// which returns an error).
+ fn next_char_html(&mut self) -> char {
+ if self.input.at_end() {
+ return '\0';
+ }
+ if let Some(ch) = self.input.peek_char() {
+ self.input.advance_char(ch);
+ // Handle \r\n normalization
+ if ch == '\r' {
+ if self.input.peek() == Some(b'\n') {
+ self.input.advance(1);
+ }
+ return '\n';
+ }
+ ch
+ } else {
+ // Invalid UTF-8 — skip the byte and return replacement character
+ self.input.advance(1);
+ '\u{FFFD}'
+ }
+ }
+
+ /// Skips an IE conditional comment marker (`<![if ...]>` or `<![endif]>`).
+ ///
+ /// These are Microsoft extensions to HTML. Each `<![...>` marker is
+ /// individually consumed, but the content between them flows as normal
+ /// text, matching libxml2 behavior.
+ fn skip_conditional_comment(&mut self) {
+ self.push_warning("incorrectly opened comment".to_string());
+ self.skip_to_gt();
+ }
+
+ /// Skips forward to and past the next `>` character.
+ fn skip_to_gt(&mut self) {
+ while !self.input.at_end() {
+ if self.input.peek() == Some(b'>') {
+ self.input.advance(1);
+ return;
+ }
+ self.input.advance(1);
+ }
+ }
+
+ /// Takes characters while they match the predicate (ASCII only).
+ fn take_while_ascii(&mut self, pred: impl Fn(u8) -> bool) -> String {
+ let start = self.input.pos();
+ while let Some(b) = self.input.peek() {
+ if pred(b) {
+ self.input.advance(1);
+ } else {
+ break;
+ }
+ }
+ String::from_utf8_lossy(self.input.slice(start, self.input.pos())).to_string()
+ }
+
+ /// Pushes a warning diagnostic to the document. Respects the
+ /// `no_warnings` option.
+ fn push_warning(&mut self, message: String) {
+ if self.options.no_warnings {
+ return;
+ }
+ self.doc.diagnostics.push(ParseDiagnostic {
+ severity: ErrorSeverity::Warning,
+ message,
+ location: self.input.location(),
+ });
+ }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ fn parse(input: &str) -> Document {
+ parse_html(input).unwrap_or_else(|e| panic!("parse failed: {e}"))
+ }
+
+ fn parse_no_implied(input: &str) -> Document {
+ let opts = HtmlParseOptions::default().no_implied(true);
+ parse_html_with_options(input, &opts).unwrap_or_else(|e| panic!("parse failed: {e}"))
+ }
+
+ // --- Basic parsing ---
+
+ #[test]
+ fn test_parse_simple_html() {
+ let doc = parse("<html><body><p>Hello</p></body></html>");
+ let html = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(html), Some("html"));
+ }
+
+ #[test]
+ fn test_parse_implied_structure() {
+ // Even without explicit html/body, the parser adds them
+ let doc = parse("<p>Hello</p>");
+ let html = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(html), Some("html"));
+
+ // Should have body child (empty head is removed)
+ let children: Vec<_> = doc.children(html).collect();
+ assert!(!children.is_empty());
+ // Body should contain the <p>
+ let body = children.last().unwrap();
+ assert_eq!(doc.node_name(*body), Some("body"));
+ }
+
+ #[test]
+ fn test_parse_no_implied_option() {
+ let doc = parse_no_implied("<p>Hello</p>");
+ let root = doc.root();
+ let first = doc.first_child(root).unwrap();
+ // Without implied structure, p should be directly under root
+ assert_eq!(doc.node_name(first), Some("p"));
+ assert_eq!(doc.text_content(first), "Hello");
+ }
+
+ // --- Void elements ---
+
+ #[test]
+ fn test_void_elements() {
+ let doc = parse_no_implied("<p>line1<br>line2</p>");
+ let root = doc.root();
+ let p = doc.first_child(root).unwrap();
+ let children: Vec<_> = doc.children(p).collect();
+ assert_eq!(children.len(), 3); // "line1", <br>, "line2"
+ assert_eq!(doc.node_name(children[1]), Some("br"));
+ assert!(doc.first_child(children[1]).is_none()); // br has no children
+ }
+
+ #[test]
+ fn test_void_element_with_end_tag() {
+ let doc = parse_no_implied("<p>text<br></br>more</p>");
+ let root = doc.root();
+ let p = doc.first_child(root).unwrap();
+ // The </br> should be ignored
+ let children: Vec<_> = doc.children(p).collect();
+ assert_eq!(children.len(), 3); // "text", <br>, "more"
+ }
+
+ #[test]
+ fn test_img_void_element() {
+ let doc = parse_no_implied("<img src=\"test.jpg\" alt=\"test\">");
+ let root = doc.root();
+ let img = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(img), Some("img"));
+ assert_eq!(doc.attribute(img, "src"), Some("test.jpg"));
+ assert_eq!(doc.attribute(img, "alt"), Some("test"));
+ }
+
+ // --- Case-insensitive tags ---
+
+ #[test]
+ fn test_case_insensitive_tags() {
+ let doc = parse_no_implied("<DIV><P>Hello</P></DIV>");
+ let root = doc.root();
+ let div = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(div), Some("div"));
+ let p = doc.first_child(div).unwrap();
+ assert_eq!(doc.node_name(p), Some("p"));
+ assert_eq!(doc.text_content(p), "Hello");
+ }
+
+ #[test]
+ fn test_mixed_case_tags() {
+ let doc = parse_no_implied("<Div><SPAN>Hi</span></div>");
+ let root = doc.root();
+ let div = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(div), Some("div"));
+ }
+
+ // --- Unquoted attributes ---
+
+ #[test]
+ fn test_unquoted_attributes() {
+ let doc = parse_no_implied("<div class=main id=content>text</div>");
+ let root = doc.root();
+ let div = doc.first_child(root).unwrap();
+ assert_eq!(doc.attribute(div, "class"), Some("main"));
+ assert_eq!(doc.attribute(div, "id"), Some("content"));
+ }
+
+ #[test]
+ fn test_boolean_attributes() {
+ let doc = parse_no_implied("<input disabled readonly>");
+ let root = doc.root();
+ let input = doc.first_child(root).unwrap();
+ assert_eq!(doc.attribute(input, "disabled"), Some("disabled"));
+ assert_eq!(doc.attribute(input, "readonly"), Some("readonly"));
+ }
+
+ // --- Auto-closing ---
+
+ #[test]
+ fn test_p_auto_closes_p() {
+ let doc = parse_no_implied("<p>First<p>Second");
+ let root = doc.root();
+ let children: Vec<_> = doc.children(root).collect();
+ // Should have two p elements as siblings, not nested
+ assert_eq!(children.len(), 2);
+ assert_eq!(doc.node_name(children[0]), Some("p"));
+ assert_eq!(doc.text_content(children[0]), "First");
+ assert_eq!(doc.node_name(children[1]), Some("p"));
+ assert_eq!(doc.text_content(children[1]), "Second");
+ }
+
+ #[test]
+ fn test_li_auto_closes_li() {
+ let doc = parse_no_implied("<ul><li>A<li>B<li>C</ul>");
+ let root = doc.root();
+ let ul = doc.first_child(root).unwrap();
+ let items: Vec<_> = doc.children(ul).collect();
+ assert_eq!(items.len(), 3);
+ assert_eq!(doc.text_content(items[0]), "A");
+ assert_eq!(doc.text_content(items[1]), "B");
+ assert_eq!(doc.text_content(items[2]), "C");
+ }
+
+ #[test]
+ fn test_dd_dt_auto_close() {
+ let doc = parse_no_implied("<dl><dt>Term<dd>Def<dt>Term2<dd>Def2</dl>");
+ let root = doc.root();
+ let dl = doc.first_child(root).unwrap();
+ let items: Vec<_> = doc.children(dl).collect();
+ assert_eq!(items.len(), 4);
+ assert_eq!(doc.node_name(items[0]), Some("dt"));
+ assert_eq!(doc.node_name(items[1]), Some("dd"));
+ assert_eq!(doc.node_name(items[2]), Some("dt"));
+ assert_eq!(doc.node_name(items[3]), Some("dd"));
+ }
+
+ // --- Entity references ---
+
+ #[test]
+ fn test_html_entities() {
+ let doc = parse_no_implied("<p>© 2024 — All rights reserved</p>");
+ let root = doc.root();
+ let p = doc.first_child(root).unwrap();
+ let text = doc.text_content(p);
+ assert!(text.contains('\u{00A9}')); // copyright sign
+ assert!(text.contains('\u{2014}')); // em dash
+ }
+
+ #[test]
+ fn test_bare_ampersand() {
+ let doc = parse_no_implied("<p>A & B</p>");
+ let root = doc.root();
+ let p = doc.first_child(root).unwrap();
+ assert_eq!(doc.text_content(p), "A & B");
+ }
+
+ #[test]
+ fn test_numeric_character_reference() {
+ let doc = parse_no_implied("<p>A B</p>");
+ let root = doc.root();
+ let p = doc.first_child(root).unwrap();
+ assert_eq!(doc.text_content(p), "A B");
+ }
+
+ #[test]
+ fn test_libxml_numeric_reference_recovery() {
+ let doc = parse_no_implied("<p>€ € � �</p>");
+ let p = doc.first_child(doc.root()).unwrap();
+ assert_eq!(doc.text_content(p), "€ € � �");
+ }
+
+ #[test]
+ fn test_minimized_attribute_values() {
+ let doc = parse_no_implied("<div foo checked hidden=hidden></div>");
+ let div = doc.first_child(doc.root()).unwrap();
+ assert_eq!(doc.attribute(div, "foo"), Some(""));
+ assert_eq!(doc.attribute(div, "checked"), Some("checked"));
+ assert_eq!(doc.attribute(div, "hidden"), Some("hidden"));
+ }
+
+ // --- Missing closing tags ---
+
+ #[test]
+ fn test_missing_closing_tags() {
+ let doc = parse_no_implied("<div><p>Hello");
+ let root = doc.root();
+ let div = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(div), Some("div"));
+ let p = doc.first_child(div).unwrap();
+ assert_eq!(doc.node_name(p), Some("p"));
+ assert_eq!(doc.text_content(p), "Hello");
+ }
+
+ // --- Comments ---
+
+ #[test]
+ fn test_html_comment() {
+ let doc = parse_no_implied("<!-- hello --><p>text</p>");
+ let root = doc.root();
+ let first = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_text(first), Some(" hello "));
+ }
+
+ // --- Script/style raw text ---
+
+ #[test]
+ fn test_script_raw_text() {
+ let doc = parse_no_implied("<script>var x = 1 < 2 && true;</script>");
+ let root = doc.root();
+ let script = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(script), Some("script"));
+ assert_eq!(doc.text_content(script), "var x = 1 < 2 && true;");
+ }
+
+ #[test]
+ fn test_style_raw_text() {
+ let doc = parse_no_implied("<style>p > span { color: red; }</style>");
+ let root = doc.root();
+ let style = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(style), Some("style"));
+ assert_eq!(doc.text_content(style), "p > span { color: red; }");
+ }
+
+ // --- DOCTYPE ---
+
+ #[test]
+ fn test_html_doctype() {
+ let doc = parse_no_implied("<!DOCTYPE html><p>text</p>");
+ let root = doc.root();
+ let children: Vec<_> = doc.children(root).collect();
+ assert!(children.len() >= 2);
+ match &doc.node(children[0]).kind {
+ NodeKind::DocumentType { name, .. } => {
+ assert_eq!(name, "html");
+ }
+ other => panic!("expected DocumentType, got {other:?}"),
+ }
+ }
+
+ // --- Single-quoted and double-quoted attributes ---
+
+ #[test]
+ fn test_single_quoted_attributes() {
+ let doc = parse_no_implied("<div class='main'>text</div>");
+ let root = doc.root();
+ let div = doc.first_child(root).unwrap();
+ assert_eq!(doc.attribute(div, "class"), Some("main"));
+ }
+
+ // --- Processing instructions ---
+
+ #[test]
+ fn test_html_processing_instruction() {
+ let doc = parse_no_implied("<?xml-stylesheet type=\"text/css\"?><p>text</p>");
+ let root = doc.root();
+ let first = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(first), Some("xml-stylesheet"));
+ }
+
+ // --- Attribute case normalization ---
+
+ #[test]
+ fn test_attribute_case_normalized() {
+ let doc = parse_no_implied("<div CLASS=\"main\" ID=\"1\">text</div>");
+ let root = doc.root();
+ let div = doc.first_child(root).unwrap();
+ assert_eq!(doc.attribute(div, "class"), Some("main"));
+ assert_eq!(doc.attribute(div, "id"), Some("1"));
+ }
+
+ // --- Whitespace stripping ---
+
+ #[test]
+ fn test_no_blanks_option() {
+ let opts = HtmlParseOptions::default().no_blanks(true).no_implied(true);
+ let doc = parse_html_with_options("<div> \n <p>text</p> \n </div>", &opts).unwrap();
+ let root = doc.root();
+ let div = doc.first_child(root).unwrap();
+ // With no_blanks, whitespace-only text nodes are stripped
+ let children: Vec<_> = doc.children(div).collect();
+ assert_eq!(children.len(), 1);
+ assert_eq!(doc.node_name(children[0]), Some("p"));
+ }
+
+ // --- Stray end tags ---
+
+ #[test]
+ fn test_stray_end_tag() {
+ let doc = parse_no_implied("</div><p>text</p>");
+ let root = doc.root();
+ let p = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(p), Some("p"));
+ assert_eq!(doc.text_content(p), "text");
+ // Should have a diagnostic about the stray end tag
+ assert!(!doc.diagnostics.is_empty());
+ }
+
+ // --- Complex document ---
+
+ #[test]
+ fn test_complex_html_document() {
+ let doc = parse(
+ r#"<!DOCTYPE html>
+<html>
+<head><title>Test</title></head>
+<body>
+<h1>Hello</h1>
+<p>A paragraph with <b>bold</b> and <em>emphasis</em>.</p>
+<ul>
+<li>Item 1
+<li>Item 2
+<li>Item 3
+</ul>
+<img src="test.jpg">
+</body>
+</html>"#,
+ );
+ let html = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(html), Some("html"));
+ }
+
+ // --- Self-closing syntax ---
+
+ #[test]
+ fn test_self_closing_syntax() {
+ let doc = parse_no_implied("<br/>");
+ let root = doc.root();
+ let br = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(br), Some("br"));
+ assert!(doc.first_child(br).is_none());
+ }
+
+ // --- Entity in attribute ---
+
+ #[test]
+ fn test_entity_in_attribute() {
+ let doc = parse_no_implied("<a href=\"page?a=1&b=2\">link</a>");
+ let root = doc.root();
+ let a = doc.first_child(root).unwrap();
+ assert_eq!(doc.attribute(a, "href"), Some("page?a=1&b=2"));
+ }
+}
diff --git a/browser/vendor/xmloxide/src/lib.rs b/browser/vendor/xmloxide/src/lib.rs
new file mode 100644
index 000000000..9a0bb5fcd
--- /dev/null
+++ b/browser/vendor/xmloxide/src/lib.rs
@@ -0,0 +1,46 @@
+//! # xmloxide
+//!
+//! A pure Rust reimplementation of libxml2 — the de facto standard XML/HTML
+//! parsing library. Memory-safe, high-performance, and conformant with the
+//! W3C XML 1.0 (Fifth Edition) specification.
+//!
+//! ## Modules
+//!
+//! This Scrapling-compatibility fork is trimmed to the slice the browser
+//! worker consumes. Upstream's WHATWG html5 parser, CSS engine, SAX/reader
+//! streaming APIs, RelaxNG/XSD/Schematron validators, XInclude, catalogs,
+//! serde integration, async parsing, FFI layer, and xmllint CLI are removed;
+//! restore them from upstream xmloxide if ever needed.
+//!
+//! - [`tree`] — DOM tree representation with arena-allocated nodes ([`Document`], [`NodeId`])
+//! - [`parser`] — XML 1.0 parser with error recovery and push/incremental parsing
+//! - [`html`] — Error-tolerant HTML 4.01 parser
+//! - [`xpath`] — `XPath` 1.0+ expression evaluation (includes key `XPath` 2.0 functions)
+//! - [`validation`] — DTD processing (`validation::dtd`; the parser depends on it)
+//! - [`serial`] — XML/HTML serialization and Canonical XML (C14N)
+//! - [`encoding`] — Character encoding detection and conversion
+//! - [`error`] — Error types and diagnostics
+//!
+//! ## Quick Start
+//!
+//! ```
+//! use xmloxide::Document;
+//!
+//! let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+//! let root = doc.root_element().unwrap();
+//! assert_eq!(doc.node_name(root), Some("root"));
+//! ```
+
+pub mod encoding;
+pub mod error;
+pub mod html;
+pub mod parser;
+pub mod serial;
+pub mod tree;
+#[allow(dead_code)]
+pub(crate) mod util;
+pub mod validation;
+pub mod xpath;
+
+// Re-export primary types at the crate root for convenience.
+pub use tree::{Attribute, Document, NodeId};
diff --git a/browser/vendor/xmloxide/src/parser/input.rs b/browser/vendor/xmloxide/src/parser/input.rs
new file mode 100644
index 000000000..28e31bb8e
--- /dev/null
+++ b/browser/vendor/xmloxide/src/parser/input.rs
@@ -0,0 +1,3497 @@
+//! Shared low-level input handling for XML and HTML parsers.
+//!
+//! [`ParserInput`] encapsulates the raw byte stream, position tracking
+//! (line, column, byte offset), and common parsing primitives such as
+//! peeking, advancing, name parsing, and entity reference resolution.
+//!
+//! # Security
+//!
+//! `ParserInput` tracks nesting depth and entity expansion count to guard
+//! against denial-of-service attacks:
+//!
+//! - **Depth limit**: prevents stack overflow from deeply nested elements.
+//! - **Entity expansion limit**: defense-in-depth counter for entity
+//! references. Currently only the five built-in XML entities are
+//! supported (amp, lt, gt, apos, quot), so recursive expansion is
+//! impossible, but the limit protects against future DTD entity support
+//! and documents with an unreasonable number of references.
+//! - **Name length limit**: prevents memory exhaustion from huge names.
+//!
+//! No external entity loading is performed (immune to XXE).
+
+use std::collections::HashMap;
+
+use crate::error::{ErrorSeverity, ParseDiagnostic, ParseError, SourceLocation};
+use crate::parser::{EntityResolver, ExternalEntityRequest};
+
+// -------------------------------------------------------------------------
+// Security defaults
+// -------------------------------------------------------------------------
+
+/// Default maximum element nesting depth.
+pub(crate) const DEFAULT_MAX_DEPTH: u32 = 256;
+
+/// Default maximum number of attributes on a single element.
+pub(crate) const DEFAULT_MAX_ATTRIBUTES: u32 = 256;
+
+/// Default maximum length (in bytes) of an attribute value.
+pub(crate) const DEFAULT_MAX_ATTRIBUTE_LENGTH: usize = 10 * 1024 * 1024; // 10 MB
+
+/// Default maximum length (in bytes) of a text node.
+pub(crate) const DEFAULT_MAX_TEXT_LENGTH: usize = 10 * 1024 * 1024; // 10 MB
+
+/// Default maximum length (in bytes) of an element or attribute name.
+pub(crate) const DEFAULT_MAX_NAME_LENGTH: usize = 50_000;
+
+/// Default maximum number of entity expansions per document.
+pub(crate) const DEFAULT_MAX_ENTITY_EXPANSIONS: u32 = 10_000;
+
+// -------------------------------------------------------------------------
+// XML Name character classes (XML 1.0 §2.3)
+// -------------------------------------------------------------------------
+
+/// Returns `true` if `c` is a valid `Char` per XML 1.0 §2.2 `[2]`.
+///
+/// The XML 1.0 (Fifth Edition) `Char` production allows:
+/// `#x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]`
+pub(crate) fn is_xml_char(c: char) -> bool {
+ matches!(c as u32,
+ 0x09 | 0x0A | 0x0D | 0x20..=0xD7FF | 0xE000..=0xFFFD | 0x0001_0000..=0x0010_FFFF
+ )
+}
+
+/// Returns `true` if `c` is a valid `NameStartChar` per XML 1.0 §2.3 `[4]`.
+pub(crate) fn is_name_start_char(c: char) -> bool {
+ matches!(c,
+ ':' | 'A'..='Z' | '_' | 'a'..='z' |
+ '\u{C0}'..='\u{D6}' | '\u{D8}'..='\u{F6}' | '\u{F8}'..='\u{2FF}' |
+ '\u{370}'..='\u{37D}' | '\u{37F}'..='\u{1FFF}' |
+ '\u{200C}'..='\u{200D}' | '\u{2070}'..='\u{218F}' |
+ '\u{2C00}'..='\u{2FEF}' | '\u{3001}'..='\u{D7FF}' |
+ '\u{F900}'..='\u{FDCF}' | '\u{FDF0}'..='\u{FFFD}' |
+ '\u{10000}'..='\u{EFFFF}'
+ )
+}
+
+/// Returns `true` if `c` is a valid `NameChar` per XML 1.0 §2.3 [4a].
+pub(crate) fn is_name_char(c: char) -> bool {
+ is_name_start_char(c)
+ || matches!(c,
+ '-' | '.' | '0'..='9' | '\u{B7}' |
+ '\u{300}'..='\u{36F}' | '\u{203F}'..='\u{2040}'
+ )
+}
+
+/// Returns `true` if `b` is a valid ASCII `NameStartChar`.
+///
+/// Covers the ASCII subset of XML 1.0 §2.3 `[4]`: `[A-Za-z_:]`.
+fn is_ascii_name_start(b: u8) -> bool {
+ b.is_ascii_alphabetic() || b == b'_' || b == b':'
+}
+
+/// Returns `true` if `b` is a valid ASCII `NameChar`.
+///
+/// Covers the ASCII subset of XML 1.0 §2.3 `[4a]`: `[A-Za-z0-9_:.-]`.
+fn is_ascii_name_char(b: u8) -> bool {
+ b.is_ascii_alphanumeric() || b == b'_' || b == b':' || b == b'-' || b == b'.'
+}
+
+/// Matches one of the five XML builtin entity references at the byte level.
+///
+/// Given bytes starting after `&`, returns `(replacement_char, bytes_to_skip)`
+/// if the bytes match a builtin entity (`amp;`, `lt;`, `gt;`, `apos;`, `quot;`).
+/// The `bytes_to_skip` includes the semicolon.
+fn match_builtin_entity(bytes: &[u8]) -> Option<(&'static str, usize)> {
+ // Use first byte to narrow the match
+ match bytes.first() {
+ Some(b'a') => {
+ if bytes.starts_with(b"amp;") {
+ return Some(("&", 4));
+ }
+ if bytes.starts_with(b"apos;") {
+ return Some(("'", 5));
+ }
+ None
+ }
+ Some(b'l') => {
+ if bytes.starts_with(b"lt;") {
+ return Some(("<", 3));
+ }
+ None
+ }
+ Some(b'g') => {
+ if bytes.starts_with(b"gt;") {
+ return Some((">", 3));
+ }
+ None
+ }
+ Some(b'q') => {
+ if bytes.starts_with(b"quot;") {
+ return Some(("\"", 5));
+ }
+ None
+ }
+ _ => None,
+ }
+}
+
+/// Checks whether a chunk of text contains any characters that are not valid
+/// XML `Char`s per XML 1.0 §2.2. Returns the first invalid character found
+/// (if any), or `None` if the chunk is clean.
+pub(crate) fn find_invalid_xml_char(s: &str) -> Option<char> {
+ s.chars().find(|&ch| !is_xml_char(ch))
+}
+
+/// Returns `true` if a byte slice might contain invalid XML characters.
+/// This is a fast pre-check: if all bytes are >= 0x20 (and no DEL 0x7F),
+/// the content is guaranteed valid for the ASCII range. Also detects
+/// the UTF-8 encodings of U+FFFE and U+FFFF (0xEF 0xBF 0xBE/0xBF).
+pub(crate) fn may_contain_invalid_xml_chars(bytes: &[u8]) -> bool {
+ let len = bytes.len();
+ let mut i = 0;
+ while i < len {
+ let b = bytes[i];
+ if (b < 0x20 && b != b'\t' && b != b'\n' && b != b'\r') || b == 0x7F {
+ return true;
+ }
+ if b == 0xEF
+ && i + 2 < len
+ && bytes[i + 1] == 0xBF
+ && (bytes[i + 2] == 0xBE || bytes[i + 2] == 0xBF)
+ {
+ return true;
+ }
+ i += 1;
+ }
+ false
+}
+
+/// Splits a qualified name into optional prefix and local part.
+///
+/// `"foo:bar"` → `(Some("foo"), "bar")`
+/// `"bar"` → `(None, "bar")`
+pub(crate) fn split_name(name: &str) -> (Option<&str>, &str) {
+ match name.find(':') {
+ Some(pos) => (Some(&name[..pos]), &name[pos + 1..]),
+ None => (None, name),
+ }
+}
+
+/// Splits an owned `QName` into `(Option<prefix>, local_name)`, reusing the
+/// original `String` buffer for the prefix portion when possible.
+///
+/// `"foo:bar".to_string()` → `(Some("foo"), "bar")` — prefix reuses the
+/// original allocation (truncated), local is a new `String`.
+///
+/// `"bar".to_string()` → `(None, "bar")` — no allocation, returns the
+/// original `String` as the local name.
+pub(crate) fn split_owned_name(name: String) -> (Option<String>, String) {
+ match name.find(':') {
+ Some(pos) => {
+ let local = name[pos + 1..].to_string();
+ let mut prefix = name;
+ prefix.truncate(pos);
+ (Some(prefix), local)
+ }
+ None => (None, name),
+ }
+}
+
+/// Validates that a name is a legal `QName` per Namespaces in XML 1.0 §4.
+///
+/// A `QName` has at most one colon, and neither prefix nor local part may be
+/// empty. Returns an error message if invalid, or `None` if valid.
+#[allow(dead_code)]
+pub(crate) fn validate_qname(name: &str) -> Option<&'static str> {
+ let colon_count = name.chars().filter(|&c| c == ':').count();
+ if colon_count > 1 {
+ return Some("QName contains multiple colons");
+ }
+ if colon_count == 1 && (name.starts_with(':') || name.ends_with(':')) {
+ return Some("QName has empty prefix or local part");
+ }
+ None
+}
+
+/// The well-known xmlns namespace URI.
+pub(crate) const XMLNS_NAMESPACE: &str = "http://www.w3.org/2000/xmlns/";
+
+/// Returns `true` if `c` is a valid `PubidChar` per XML 1.0 §2.3 `[13]`.
+///
+/// `PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]`
+pub(crate) fn is_pubid_char(c: char) -> bool {
+ matches!(c,
+ ' ' | '\r' | '\n' |
+ 'a'..='z' | 'A'..='Z' | '0'..='9' |
+ '-' | '\'' | '(' | ')' | '+' | ',' | '.' | '/' | ':' |
+ '=' | '?' | ';' | '!' | '*' | '#' | '@' | '$' | '_' | '%'
+ )
+}
+
+/// Validates that a string contains only valid `PubidChar`s.
+///
+/// Returns `None` if valid, or a descriptive error message if not.
+pub(crate) fn validate_pubid(s: &str) -> Option<String> {
+ for c in s.chars() {
+ if !is_pubid_char(c) {
+ return Some(format!(
+ "invalid character '{}' (U+{:04X}) in public ID",
+ c.escape_default(),
+ c as u32
+ ));
+ }
+ }
+ None
+}
+
+// -------------------------------------------------------------------------
+// Position checkpointing (for backtracking)
+// -------------------------------------------------------------------------
+
+/// A snapshot of the input position (byte offset, line, column).
+///
+/// Obtained via [`ParserInput::save_position`] and restored via
+/// [`ParserInput::restore_position`]. Used by error-tolerant parsers
+/// (e.g., the HTML parser) that need to backtrack when a speculative
+/// parse fails.
+#[derive(Debug, Clone, Copy)]
+#[allow(dead_code)]
+pub(crate) struct SavedPosition {
+ pos: usize,
+ line: u32,
+ column: u32,
+}
+
+// -------------------------------------------------------------------------
+// ParserInput
+// -------------------------------------------------------------------------
+
+/// Information about an externally-declared entity (SYSTEM/PUBLIC).
+#[derive(Debug, Clone)]
+pub(crate) struct ExternalEntityInfo {
+ /// The SYSTEM identifier (URI) from the entity declaration.
+ pub system_id: String,
+ /// The PUBLIC identifier, if any.
+ pub public_id: Option<String>,
+}
+
+/// Shared low-level input state for all parsers.
+///
+/// Tracks the byte stream, position (line/column/offset), nesting depth,
+/// entity expansion count, and accumulated diagnostics. All parsers
+/// (tree-building, SAX, reader, HTML) compose this struct rather than
+/// reimplementing input handling.
+pub(crate) struct ParserInput<'a> {
+ /// The input bytes (must be valid UTF-8).
+ input: &'a [u8],
+
+ /// Current byte offset in `input`.
+ pos: usize,
+
+ /// Current line number (1-based).
+ line: u32,
+
+ /// Current column number (1-based).
+ column: u32,
+
+ /// Current element nesting depth.
+ depth: u32,
+
+ /// Maximum allowed nesting depth.
+ max_depth: u32,
+
+ /// Maximum allowed name length in bytes.
+ max_name_length: usize,
+
+ /// Number of entity references expanded so far.
+ pub(crate) entity_expansions: u32,
+
+ /// Maximum allowed entity expansions.
+ max_entity_expansions: u32,
+
+ /// Whether the parser is in error-recovery mode.
+ recover: bool,
+
+ /// Accumulated diagnostics (warnings and recoverable errors).
+ pub(crate) diagnostics: Vec<ParseDiagnostic>,
+
+ /// Entity replacement values from the DTD internal subset.
+ /// Populated after parsing `<!DOCTYPE root [ ... ]>`.
+ pub(crate) entity_map: HashMap<String, String>,
+
+ /// External entity declarations keyed by entity name, storing the
+ /// SYSTEM and PUBLIC identifiers. Used for the entity resolver and
+ /// to enforce WFC: No External Entity References in attribute values.
+ pub(crate) entity_external: HashMap<String, ExternalEntityInfo>,
+
+ /// Whether the DTD internal subset contained parameter entity references.
+ /// Per XML 1.0 §4.1 WFC: Entity Declared, undeclared entity references
+ /// are only well-formedness errors if the document has no parameter entity
+ /// references in the internal subset.
+ pub(crate) has_pe_references: bool,
+
+ /// Whether the document has an external DTD subset (SYSTEM or PUBLIC).
+ /// Per XML 1.0 §4.1 WFC: Entity Declared, undeclared entity references
+ /// are not well-formedness errors when the document references an
+ /// external DTD subset that was not read.
+ pub(crate) has_external_dtd: bool,
+
+ /// Entities whose content production has already been validated.
+ /// Prevents redundant re-validation on repeated references.
+ validated_entities: std::collections::HashSet<String>,
+
+ /// Optional callback for resolving external entities.
+ entity_resolver: Option<EntityResolver>,
+}
+
+impl<'a> ParserInput<'a> {
+ /// Creates a new `ParserInput` from a UTF-8 string with default limits.
+ pub fn new(input: &'a str) -> Self {
+ Self {
+ input: input.as_bytes(),
+ pos: 0,
+ line: 1,
+ column: 1,
+ depth: 0,
+ max_depth: DEFAULT_MAX_DEPTH,
+ max_name_length: DEFAULT_MAX_NAME_LENGTH,
+ entity_expansions: 0,
+ max_entity_expansions: DEFAULT_MAX_ENTITY_EXPANSIONS,
+ recover: false,
+ diagnostics: Vec::new(),
+ entity_map: HashMap::new(),
+ entity_external: HashMap::new(),
+ has_pe_references: false,
+ has_external_dtd: false,
+ validated_entities: std::collections::HashSet::new(),
+ entity_resolver: None,
+ }
+ }
+
+ /// Sets the external entity resolver.
+ pub fn set_entity_resolver(&mut self, resolver: Option<EntityResolver>) {
+ self.entity_resolver = resolver;
+ }
+
+ /// Sets the maximum nesting depth.
+ pub fn set_max_depth(&mut self, max: u32) {
+ self.max_depth = max;
+ }
+
+ /// Sets the maximum name length.
+ pub fn set_max_name_length(&mut self, max: usize) {
+ self.max_name_length = max;
+ }
+
+ /// Sets the maximum entity expansion count.
+ pub fn set_max_entity_expansions(&mut self, max: u32) {
+ self.max_entity_expansions = max;
+ }
+
+ /// Enables or disables error-recovery mode.
+ pub fn set_recover(&mut self, recover: bool) {
+ self.recover = recover;
+ }
+
+ /// Returns whether recovery mode is enabled.
+ pub fn recover(&self) -> bool {
+ self.recover
+ }
+
+ // -- Depth tracking --
+
+ /// Increments the nesting depth. Returns an error if the limit is exceeded.
+ pub fn increment_depth(&mut self) -> Result<(), ParseError> {
+ self.depth += 1;
+ if self.depth > self.max_depth {
+ return Err(self.fatal(format!(
+ "maximum nesting depth exceeded ({})",
+ self.max_depth
+ )));
+ }
+ Ok(())
+ }
+
+ /// Decrements the nesting depth (saturating at 0).
+ pub fn decrement_depth(&mut self) {
+ self.depth = self.depth.saturating_sub(1);
+ }
+
+ /// Returns the current nesting depth.
+ pub fn depth(&self) -> u32 {
+ self.depth
+ }
+
+ /// Sets the current nesting depth.
+ ///
+ /// Used when a nested sub-parser (entity replacement text) must inherit
+ /// the outer parser's depth so the total element nesting across entity
+ /// expansions stays bounded by `max_depth`.
+ pub fn set_depth(&mut self, depth: u32) {
+ self.depth = depth;
+ }
+
+ // -- Position queries --
+
+ /// Returns the current source location.
+ pub fn location(&self) -> SourceLocation {
+ SourceLocation {
+ line: self.line,
+ column: self.column,
+ byte_offset: self.pos,
+ }
+ }
+
+ /// Returns `true` if all input has been consumed.
+ #[inline]
+ pub fn at_end(&self) -> bool {
+ self.pos >= self.input.len()
+ }
+
+ /// Returns the current byte offset.
+ #[allow(dead_code)]
+ #[inline]
+ pub fn pos(&self) -> usize {
+ self.pos
+ }
+
+ /// Returns a slice of the raw input bytes from `start` to `end`.
+ #[allow(dead_code)]
+ #[inline]
+ pub fn slice(&self, start: usize, end: usize) -> &[u8] {
+ &self.input[start..end]
+ }
+
+ /// Returns the remaining input bytes from the current position.
+ #[allow(dead_code)]
+ #[inline]
+ pub fn remaining(&self) -> &[u8] {
+ &self.input[self.pos..]
+ }
+
+ /// Saves the current position (byte offset, line, column) so it can be
+ /// restored later with [`restore_position`]. This is useful for
+ /// backtracking in error-tolerant parsers (e.g., the HTML parser).
+ #[allow(dead_code)]
+ pub fn save_position(&self) -> SavedPosition {
+ SavedPosition {
+ pos: self.pos,
+ line: self.line,
+ column: self.column,
+ }
+ }
+
+ /// Restores a previously saved position. All progress since the
+ /// [`save_position`] call is discarded.
+ #[allow(dead_code)]
+ pub fn restore_position(&mut self, saved: SavedPosition) {
+ self.pos = saved.pos;
+ self.line = saved.line;
+ self.column = saved.column;
+ }
+
+ // -- Peek operations --
+
+ /// Returns the byte at the current position without consuming it.
+ #[inline]
+ pub fn peek(&self) -> Option<u8> {
+ self.input.get(self.pos).copied()
+ }
+
+ /// Returns the byte at `current_position + offset` without consuming.
+ pub fn peek_at(&self, offset: usize) -> Option<u8> {
+ self.input.get(self.pos + offset).copied()
+ }
+
+ /// Returns the character at the current position without consuming it.
+ ///
+ /// Uses an ASCII fast path (single byte check) for the common case,
+ /// and decodes only the minimal 1–4 bytes needed for multi-byte UTF-8.
+ #[inline]
+ pub fn peek_char(&self) -> Option<char> {
+ if self.pos >= self.input.len() {
+ return None;
+ }
+ let first = self.input[self.pos];
+ // Fast path: ASCII (covers 95%+ of XML content)
+ if first < 0x80 {
+ return Some(first as char);
+ }
+ // Slow path: multi-byte UTF-8 — decode only the needed bytes
+ let len = match first {
+ 0xC0..=0xDF => 2,
+ 0xE0..=0xEF => 3,
+ 0xF0..=0xF7 => 4,
+ _ => return None, // invalid UTF-8 lead byte
+ };
+ let remaining = &self.input[self.pos..];
+ if remaining.len() < len {
+ return None;
+ }
+ std::str::from_utf8(&remaining[..len])
+ .ok()
+ .and_then(|s| s.chars().next())
+ }
+
+ // -- Advance operations --
+
+ /// Advances the position by `count` bytes, updating line/column.
+ #[inline]
+ pub fn advance(&mut self, count: usize) {
+ // Fast path for count == 1 (the most common case from expect_byte, etc.)
+ if count == 1 {
+ if self.pos < self.input.len() {
+ if self.input[self.pos] == b'\n' {
+ self.line += 1;
+ self.column = 1;
+ } else {
+ self.column += 1;
+ }
+ self.pos += 1;
+ }
+ return;
+ }
+ self.advance_counting_lines(count.min(self.input.len() - self.pos));
+ }
+
+ /// Advances by one UTF-8 character, updating line/column.
+ #[inline]
+ pub fn advance_char(&mut self, ch: char) {
+ let len = ch.len_utf8();
+ if ch == '\n' {
+ self.line += 1;
+ self.column = 1;
+ } else {
+ self.column += 1;
+ }
+ self.pos += len;
+ }
+
+ /// Consumes and returns the next byte, or returns an error at EOF.
+ #[inline]
+ pub fn next_byte(&mut self) -> Result<u8, ParseError> {
+ if self.at_end() {
+ return Err(self.fatal("unexpected end of input"));
+ }
+ let b = self.input[self.pos];
+ self.advance(1);
+ Ok(b)
+ }
+
+ /// Consumes and returns the next character with `\r\n` normalization
+ /// (XML 1.0 §2.11) and character validation (XML 1.0 §2.2).
+ #[inline]
+ pub fn next_char(&mut self) -> Result<char, ParseError> {
+ if self.pos >= self.input.len() {
+ return Err(self.fatal("unexpected end of input"));
+ }
+ let first = self.input[self.pos];
+ // Fast path: ASCII (covers 95%+ of XML content)
+ if first < 0x80 {
+ self.pos += 1;
+ if first == b'\n' {
+ self.line += 1;
+ self.column = 1;
+ } else if first == b'\r' {
+ // \r\n → \n normalization (XML 1.0 §2.11)
+ self.line += 1;
+ self.column = 1;
+ if self.pos < self.input.len() && self.input[self.pos] == b'\n' {
+ self.pos += 1;
+ }
+ return Ok('\n');
+ } else {
+ self.column += 1;
+ // Validate ASCII control chars (XML 1.0 §2.2: only #x9, #xA, #xD, #x20+ allowed)
+ if first < 0x20 && first != b'\t' {
+ let ch = first as char;
+ if self.recover {
+ self.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("invalid XML character: U+{:04X}", ch as u32),
+ );
+ } else {
+ return Err(
+ self.fatal(format!("invalid XML character: U+{:04X}", ch as u32))
+ );
+ }
+ }
+ }
+ return Ok(first as char);
+ }
+ // Slow path: multi-byte UTF-8
+ let ch = self
+ .peek_char()
+ .ok_or_else(|| self.fatal("unexpected end of input"))?;
+ self.advance_char(ch);
+ // Validate against XML 1.0 §2.2 Char production
+ if !is_xml_char(ch) {
+ if self.recover {
+ self.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("invalid XML character: U+{:04X}", ch as u32),
+ );
+ } else {
+ return Err(self.fatal(format!("invalid XML character: U+{:04X}", ch as u32)));
+ }
+ }
+ Ok(ch)
+ }
+
+ // -- Bulk scanning --
+
+ /// Scans forward from the current position to find the next character data
+ /// boundary (`<`, `&`, or `]]]]><![CDATA[>`). Returns the number of safe bytes that
+ /// can be consumed as plain text content.
+ #[inline]
+ pub fn scan_char_data(&self) -> usize {
+ let bytes = &self.input[self.pos..];
+ let mut i = 0;
+ while i < bytes.len() {
+ let b = bytes[i];
+ match b {
+ b'<' | b'&' => return i,
+ b']' if i + 2 < bytes.len() && bytes[i + 1] == b']' && bytes[i + 2] == b'>' => {
+ return i;
+ }
+ _ => {
+ // Stop at invalid XML control characters (0x00-0x08, 0x0B, 0x0C, 0x0E-0x1F)
+ // so they fall through to next_char() which validates and reports errors.
+ if b < 0x20 && b != b'\t' && b != b'\n' && b != b'\r' {
+ return i;
+ }
+ i += 1;
+ }
+ }
+ }
+ bytes.len()
+ }
+
+ /// Scans forward to find the next attribute value delimiter: the given
+ /// `quote` byte, `&`, `<`, or any invalid XML control character.
+ /// Returns the number of safe bytes before the delimiter.
+ /// Avoids the 256-byte lookup table of `scan_until_any`.
+ #[inline]
+ pub fn scan_attr_value(&self, quote: u8) -> usize {
+ let bytes = &self.input[self.pos..];
+ let mut i = 0;
+ while i < bytes.len() {
+ let b = bytes[i];
+ if b == quote || b == b'&' || b == b'<' {
+ return i;
+ }
+ // Stop at invalid XML control characters (0x00-0x08, 0x0B, 0x0C, 0x0E-0x1F)
+ // so they fall through to next_char() which validates and reports errors.
+ if b < 0x20 && b != b'\t' && b != b'\n' && b != b'\r' {
+ return i;
+ }
+ i += 1;
+ }
+ bytes.len()
+ }
+
+ /// Scans forward to find the next occurrence of any of the given marker
+ /// bytes. Returns the number of bytes before the marker.
+ ///
+ /// Uses a 256-byte lookup table for O(1) per-byte matching instead of
+ /// linear `contains()` on the marker slice.
+ #[allow(dead_code)]
+ pub fn scan_until_any(&self, markers: &[u8]) -> usize {
+ let mut marker_set = [false; 256];
+ for &m in markers {
+ marker_set[m as usize] = true;
+ }
+ let bytes = &self.input[self.pos..];
+ for (i, &b) in bytes.iter().enumerate() {
+ if marker_set[b as usize] {
+ return i;
+ }
+ }
+ bytes.len()
+ }
+
+ /// Scans forward to find a 2-byte terminator sequence (e.g., `?>`, `--`).
+ /// Returns the number of bytes before the first byte of the terminator,
+ /// or `None` if not found.
+ pub fn scan_for_2byte_terminator(&self, t0: u8, t1: u8) -> Option<usize> {
+ let bytes = &self.input[self.pos..];
+ if bytes.len() < 2 {
+ return None;
+ }
+ let mut i = 0;
+ let end = bytes.len() - 1;
+ while i < end {
+ if bytes[i] == t0 && bytes[i + 1] == t1 {
+ return Some(i);
+ }
+ i += 1;
+ }
+ None
+ }
+
+ /// Scans forward to find a 3-byte terminator sequence (e.g., `-->`, `]]]]><![CDATA[>`).
+ /// Returns the number of bytes before the first byte of the terminator,
+ /// or `None` if not found.
+ pub fn scan_for_3byte_terminator(&self, t0: u8, t1: u8, t2: u8) -> Option<usize> {
+ let bytes = &self.input[self.pos..];
+ if bytes.len() < 3 {
+ return None;
+ }
+ let mut i = 0;
+ let end = bytes.len() - 2;
+ while i < end {
+ if bytes[i] == t0 && bytes[i + 1] == t1 && bytes[i + 2] == t2 {
+ return Some(i);
+ }
+ i += 1;
+ }
+ None
+ }
+
+ /// Advances the position by `count` bytes, tracking line/column numbers
+ /// in a single pass. More efficient than calling `advance(1)` in a loop
+ /// for bulk text consumption.
+ #[inline]
+ pub fn advance_counting_lines(&mut self, count: usize) {
+ let end = self.pos + count;
+ let slice = &self.input[self.pos..end];
+ // Fast path: if no newlines in the slice, just bump column
+ if slice.contains(&b'\n') {
+ for &b in slice {
+ if b == b'\n' {
+ self.line += 1;
+ self.column = 1;
+ } else {
+ self.column += 1;
+ }
+ }
+ } else {
+ #[allow(clippy::cast_possible_truncation)]
+ {
+ self.column += count as u32;
+ }
+ }
+ self.pos = end;
+ }
+
+ // -- Expect operations --
+
+ /// Consumes the next byte and asserts it matches `expected`.
+ #[inline]
+ pub fn expect_byte(&mut self, expected: u8) -> Result<(), ParseError> {
+ let b = self.next_byte()?;
+ if b != expected {
+ return Err(self.fatal(format!(
+ "expected '{}', found '{}'",
+ expected as char, b as char
+ )));
+ }
+ Ok(())
+ }
+
+ /// Consumes bytes and asserts they match the `expected` sequence.
+ #[inline]
+ pub fn expect_str(&mut self, expected: &[u8]) -> Result<(), ParseError> {
+ if self.pos + expected.len() > self.input.len() {
+ return Err(self.fatal("unexpected end of input"));
+ }
+ if &self.input[self.pos..self.pos + expected.len()] == expected {
+ self.advance_counting_lines(expected.len());
+ } else {
+ // Fall back to per-byte for precise error reporting
+ for &b in expected {
+ self.expect_byte(b)?;
+ }
+ }
+ Ok(())
+ }
+
+ // -- Lookahead --
+
+ /// Returns `true` if the remaining input starts with `s`.
+ #[inline]
+ pub fn looking_at(&self, s: &[u8]) -> bool {
+ self.input[self.pos..].starts_with(s)
+ }
+
+ /// Case-insensitive lookahead check. Returns `true` if the remaining
+ /// input starts with `expected` when compared case-insensitively (ASCII).
+ #[allow(dead_code)]
+ pub fn looking_at_ci(&self, expected: &[u8]) -> bool {
+ if self.pos + expected.len() > self.input.len() {
+ return false;
+ }
+ self.input[self.pos..self.pos + expected.len()].eq_ignore_ascii_case(expected)
+ }
+
+ // -- Whitespace --
+
+ /// Skips whitespace characters. Returns `true` if any were consumed.
+ #[inline]
+ pub fn skip_whitespace(&mut self) -> bool {
+ let start = self.pos;
+ while self.pos < self.input.len() {
+ match self.input[self.pos] {
+ b'\n' => {
+ self.line += 1;
+ self.column = 1;
+ self.pos += 1;
+ }
+ b' ' | b'\t' | b'\r' => {
+ self.column += 1;
+ self.pos += 1;
+ }
+ _ => break,
+ }
+ }
+ self.pos > start
+ }
+
+ /// Consumes and returns any whitespace characters at the current position.
+ ///
+ /// Returns the consumed whitespace as a `&str` (empty if no whitespace).
+ pub fn consume_whitespace(&mut self) -> &str {
+ let start = self.pos;
+ while self.pos < self.input.len() {
+ match self.input[self.pos] {
+ b'\n' => {
+ self.line += 1;
+ self.column = 1;
+ self.pos += 1;
+ }
+ b' ' | b'\t' | b'\r' => {
+ self.column += 1;
+ self.pos += 1;
+ }
+ _ => break,
+ }
+ }
+ // Whitespace bytes are valid ASCII/UTF-8, so this conversion is safe.
+ std::str::from_utf8(&self.input[start..self.pos]).unwrap_or_default()
+ }
+
+ /// Skips whitespace, returning an error if none is found.
+ pub fn skip_whitespace_required(&mut self) -> Result<(), ParseError> {
+ if !self.skip_whitespace() {
+ return Err(self.fatal("whitespace required"));
+ }
+ Ok(())
+ }
+
+ // -- Take while --
+
+ /// Consumes bytes while `pred` returns `true` and returns the string.
+ pub fn take_while(&mut self, pred: impl Fn(u8) -> bool) -> String {
+ let start = self.pos;
+ while self.pos < self.input.len() && pred(self.input[self.pos]) {
+ if self.input[self.pos] == b'\n' {
+ self.line += 1;
+ self.column = 1;
+ } else {
+ self.column += 1;
+ }
+ self.pos += 1;
+ }
+ // The predicates used (ascii_digit, ascii_hexdigit) only match ASCII,
+ // so the consumed range is always valid UTF-8.
+ std::str::from_utf8(&self.input[start..self.pos])
+ .unwrap_or("")
+ .to_string()
+ }
+
+ // -- Name parsing (XML 1.0 §2.3) --
+
+ /// Parses an XML `Name` per XML 1.0 §2.3 production `[5]`.
+ ///
+ /// A `Name` starts with a `NameStartChar` followed by zero or more
+ /// `NameChar`s. Returns an error if the name is empty or starts with
+ /// an invalid character.
+ ///
+ /// Uses an ASCII fast path that scans name characters as bytes,
+ /// avoiding per-character UTF-8 decoding for the common case.
+ #[inline]
+ pub fn parse_name(&mut self) -> Result<String, ParseError> {
+ let start = self.pos;
+ if self.pos >= self.input.len() {
+ return Err(self.fatal("expected name, found end of input"));
+ }
+
+ let first = self.input[self.pos];
+
+ // ASCII fast path: most XML names are pure ASCII
+ if is_ascii_name_start(first) {
+ self.pos += 1;
+ self.column += 1;
+ while self.pos < self.input.len() && is_ascii_name_char(self.input[self.pos]) {
+ self.pos += 1;
+ self.column += 1;
+ }
+ // Check if we stopped at a non-ASCII byte (need slow path)
+ if self.pos >= self.input.len() || self.input[self.pos] < 0x80 {
+ let len = self.pos - start;
+ if len > self.max_name_length {
+ return Err(self.fatal(format!(
+ "name length ({len}) exceeds maximum ({})",
+ self.max_name_length
+ )));
+ }
+ // Input is guaranteed valid UTF-8 and we only consumed ASCII bytes
+ let name = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ return Ok(name.to_string());
+ }
+ // Fall through: hit a non-ASCII continuation byte, continue
+ // with the char-by-char path below.
+ } else {
+ // Non-ASCII first byte or invalid ASCII start char —
+ // use the standard char-by-char path.
+ let ch = self
+ .peek_char()
+ .ok_or_else(|| self.fatal("expected name"))?;
+ if !is_name_start_char(ch) {
+ return Err(self.fatal(format!("invalid name start character: '{ch}'")));
+ }
+ self.advance_char(ch);
+ }
+
+ // Slow path: handles non-ASCII name characters
+ while let Some(ch) = self.peek_char() {
+ if is_name_char(ch) {
+ self.advance_char(ch);
+ } else {
+ break;
+ }
+ }
+
+ let len = self.pos - start;
+ if len > self.max_name_length {
+ return Err(self.fatal(format!(
+ "name length ({len}) exceeds maximum ({})",
+ self.max_name_length
+ )));
+ }
+
+ let name = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ Ok(name.to_string())
+ }
+
+ /// Parses a name from the input and checks whether it matches `expected`.
+ ///
+ /// Advances past the parsed name in all cases. Returns `Ok(None)` if the
+ /// name matches, or `Ok(Some(parsed_name))` if it doesn't (the caller
+ /// gets the actual name for error messages). This avoids allocating a
+ /// `String` in the happy path (matching names).
+ #[allow(dead_code)]
+ pub fn parse_name_eq(&mut self, expected: &str) -> Result<Option<String>, ParseError> {
+ let start = self.pos;
+ if self.pos >= self.input.len() {
+ return Err(self.fatal("expected name, found end of input"));
+ }
+
+ let first = self.input[self.pos];
+
+ // ASCII fast path
+ if is_ascii_name_start(first) {
+ self.pos += 1;
+ self.column += 1;
+ while self.pos < self.input.len() && is_ascii_name_char(self.input[self.pos]) {
+ self.pos += 1;
+ self.column += 1;
+ }
+ if self.pos >= self.input.len() || self.input[self.pos] < 0x80 {
+ let len = self.pos - start;
+ if len > self.max_name_length {
+ return Err(self.fatal(format!(
+ "name length ({len}) exceeds maximum ({})",
+ self.max_name_length
+ )));
+ }
+ // Compare directly against input bytes — no allocation needed
+ if len == expected.len() && &self.input[start..self.pos] == expected.as_bytes() {
+ return Ok(None); // match — no allocation
+ }
+ let name = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ return Ok(Some(name.to_string()));
+ }
+ // Fall through to slow path for non-ASCII
+ } else {
+ let ch = self
+ .peek_char()
+ .ok_or_else(|| self.fatal("expected name"))?;
+ if !is_name_start_char(ch) {
+ return Err(self.fatal(format!("invalid name start character: '{ch}'")));
+ }
+ self.advance_char(ch);
+ }
+
+ // Slow path for non-ASCII names
+ while let Some(ch) = self.peek_char() {
+ if is_name_char(ch) {
+ self.advance_char(ch);
+ } else {
+ break;
+ }
+ }
+
+ let len = self.pos - start;
+ if len > self.max_name_length {
+ return Err(self.fatal(format!(
+ "name length ({len}) exceeds maximum ({})",
+ self.max_name_length
+ )));
+ }
+
+ if len == expected.len() && &self.input[start..self.pos] == expected.as_bytes() {
+ return Ok(None);
+ }
+ let name = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ Ok(Some(name.to_string()))
+ }
+
+ /// Parses a name and checks whether it matches the given prefix + local
+ /// name parts. This avoids needing the full `"prefix:local"` `String` for
+ /// end tag matching — the caller can pass already-split owned parts.
+ ///
+ /// Returns `Ok(None)` on match, or `Ok(Some(parsed_name))` on mismatch.
+ pub fn parse_name_eq_parts(
+ &mut self,
+ prefix: Option<&str>,
+ local: &str,
+ ) -> Result<Option<String>, ParseError> {
+ let start = self.pos;
+ if self.pos >= self.input.len() {
+ return Err(self.fatal("expected name, found end of input"));
+ }
+
+ let first = self.input[self.pos];
+
+ // ASCII fast path
+ if is_ascii_name_start(first) {
+ self.pos += 1;
+ self.column += 1;
+ while self.pos < self.input.len() && is_ascii_name_char(self.input[self.pos]) {
+ self.pos += 1;
+ self.column += 1;
+ }
+ if self.pos >= self.input.len() || self.input[self.pos] < 0x80 {
+ let len = self.pos - start;
+ if len > self.max_name_length {
+ return Err(self.fatal(format!(
+ "name length ({len}) exceeds maximum ({})",
+ self.max_name_length
+ )));
+ }
+ let parsed = &self.input[start..self.pos];
+ // Compare against prefix:local parts
+ let matches = match prefix {
+ Some(pfx) => {
+ let expected_len = pfx.len() + 1 + local.len();
+ len == expected_len
+ && parsed[..pfx.len()] == *pfx.as_bytes()
+ && parsed[pfx.len()] == b':'
+ && parsed[pfx.len() + 1..] == *local.as_bytes()
+ }
+ None => len == local.len() && parsed == local.as_bytes(),
+ };
+ if matches {
+ return Ok(None);
+ }
+ let name =
+ std::str::from_utf8(parsed).map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ return Ok(Some(name.to_string()));
+ }
+ // Fall through to slow path for non-ASCII
+ } else {
+ let ch = self
+ .peek_char()
+ .ok_or_else(|| self.fatal("expected name"))?;
+ if !is_name_start_char(ch) {
+ return Err(self.fatal(format!("invalid name start character: '{ch}'")));
+ }
+ self.advance_char(ch);
+ }
+
+ // Slow path for non-ASCII names
+ while let Some(ch) = self.peek_char() {
+ if is_name_char(ch) {
+ self.advance_char(ch);
+ } else {
+ break;
+ }
+ }
+
+ let len = self.pos - start;
+ if len > self.max_name_length {
+ return Err(self.fatal(format!(
+ "name length ({len}) exceeds maximum ({})",
+ self.max_name_length
+ )));
+ }
+
+ let parsed = &self.input[start..self.pos];
+ let matches = match prefix {
+ Some(pfx) => {
+ let expected_len = pfx.len() + 1 + local.len();
+ len == expected_len
+ && parsed[..pfx.len()] == *pfx.as_bytes()
+ && parsed[pfx.len()] == b':'
+ && parsed[pfx.len() + 1..] == *local.as_bytes()
+ }
+ None => len == local.len() && parsed == local.as_bytes(),
+ };
+ if matches {
+ return Ok(None);
+ }
+ let name = std::str::from_utf8(parsed).map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ Ok(Some(name.to_string()))
+ }
+
+ // -- Reference parsing (XML 1.0 §4.1) --
+
+ /// Counts one entity expansion against the security limit.
+ ///
+ /// Returns an error if the configured maximum is exceeded.
+ pub fn count_entity_expansion(&mut self) -> Result<(), ParseError> {
+ self.entity_expansions += 1;
+ if self.entity_expansions > self.max_entity_expansions {
+ return Err(self.fatal(format!(
+ "entity expansion limit exceeded ({})",
+ self.max_entity_expansions
+ )));
+ }
+ Ok(())
+ }
+
+ /// Parses an entity or character reference (`&...;`).
+ ///
+ /// Handles the five built-in XML entities (`amp`, `lt`, `gt`, `apos`,
+ /// `quot`) and decimal/hexadecimal character references.
+ ///
+ /// # Security
+ ///
+ /// Increments the entity expansion counter and returns an error if the
+ /// limit is exceeded.
+ #[cfg(test)]
+ pub fn parse_reference(&mut self) -> Result<String, ParseError> {
+ let mut buf = String::new();
+ self.parse_reference_into(&mut buf)?;
+ Ok(buf)
+ }
+
+ /// Parses an entity or character reference and appends the result
+ /// directly into `buf`, avoiding an intermediate `String` allocation.
+ ///
+ /// For builtin entities (`&`, `<`, etc.) and character references
+ /// (`A`, `A`), pushes the resolved character directly. For
+ /// general entities, appends the expanded replacement text.
+ ///
+ /// Returns the resolved text as a `&str` slice of `buf` (the portion
+ /// that was appended), which callers can use for validation.
+ pub fn parse_reference_into<'b>(&mut self, buf: &'b mut String) -> Result<&'b str, ParseError> {
+ self.count_entity_expansion()?;
+
+ self.expect_byte(b'&')?;
+
+ // Fast path: recognize builtin entities at byte level
+ let remaining = &self.input[self.pos..];
+ if let Some(result) = match_builtin_entity(remaining) {
+ let advance_len = result.1;
+ self.advance_counting_lines(advance_len);
+ let start = buf.len();
+ buf.push_str(result.0);
+ return Ok(&buf[start..]);
+ }
+
+ if self.peek() == Some(b'#') {
+ // Character reference
+ self.advance(1);
+ let value = if self.peek() == Some(b'x') {
+ self.advance(1);
+ let hex = self.take_while(|b| b.is_ascii_hexdigit());
+ if hex.is_empty() {
+ return Err(self.fatal("empty hex character reference"));
+ }
+ u32::from_str_radix(&hex, 16)
+ .map_err(|_| self.fatal("invalid hex character reference"))?
+ } else {
+ let dec = self.take_while(|b| b.is_ascii_digit());
+ if dec.is_empty() {
+ return Err(self.fatal("empty decimal character reference"));
+ }
+ dec.parse::<u32>()
+ .map_err(|_| self.fatal("invalid decimal character reference"))?
+ };
+ self.expect_byte(b';')?;
+
+ let ch = char::from_u32(value)
+ .ok_or_else(|| self.fatal(format!("invalid character reference: U+{value:04X}")))?;
+
+ if !is_xml_char(ch) {
+ return Err(self.fatal(format!(
+ "character reference &#x{value:X}; does not refer to a valid XML character"
+ )));
+ }
+
+ let start = buf.len();
+ buf.push(ch);
+ Ok(&buf[start..])
+ } else {
+ // General entity reference — delegate to parse_reference logic
+ // (rare path, allocation is acceptable)
+ let name = self.parse_name()?;
+ self.expect_byte(b';')?;
+
+ let expanded = match name.as_str() {
+ "amp" | "lt" | "gt" | "apos" | "quot" => {
+ unreachable!("builtin entity should be caught by fast path")
+ }
+ _ => {
+ if let Some(info) = self.entity_external.get(&name).cloned() {
+ if let Some(ref resolver) = self.entity_resolver.clone() {
+ let request = ExternalEntityRequest {
+ name: &name,
+ system_id: &info.system_id,
+ public_id: info.public_id.as_deref(),
+ };
+ if let Some(resolved) = resolver(request) {
+ self.expand_entity_text(&resolved)?
+ } else {
+ return Err(self.fatal(format!(
+ "reference to external entity '{name}' is not supported"
+ )));
+ }
+ } else {
+ return Err(self.fatal(format!(
+ "reference to external entity '{name}' is not supported"
+ )));
+ }
+ } else if let Some(value) = self.entity_map.get(&name).cloned() {
+ if !self.validated_entities.contains(&name) {
+ self.validated_entities.insert(name.clone());
+ self.validate_entity_content(&name, &value)?;
+ }
+ self.expand_entity_text(&value)?
+ } else if self.recover || self.has_pe_references || self.has_external_dtd {
+ self.push_diagnostic(
+ ErrorSeverity::Warning,
+ format!("unknown entity reference: &{name};"),
+ );
+ String::new()
+ } else {
+ return Err(self.fatal(format!("unknown entity reference: &{name};")));
+ }
+ }
+ };
+ let start = buf.len();
+ buf.push_str(&expanded);
+ Ok(&buf[start..])
+ }
+ }
+
+ /// Expands entity and character references in entity replacement text.
+ ///
+ /// Per XML 1.0 §4.4, when an entity's replacement text is included,
+ /// character references and entity references within it are resolved.
+ /// This method performs that resolution recursively, using the entity
+ /// map populated from the DTD.
+ #[allow(clippy::too_many_lines)]
+ fn expand_entity_text(&mut self, text: &str) -> Result<String, ParseError> {
+ // Fast path — no references to expand
+ if !text.contains('&') {
+ return Ok(text.to_string());
+ }
+
+ let bytes = text.as_bytes();
+ let mut result = String::with_capacity(text.len());
+ let mut i = 0;
+ let mut in_cdata = false;
+
+ while i < bytes.len() {
+ // Track CDATA sections — entity references inside CDATA are
+ // literal text and should not be expanded.
+ if !in_cdata && i + 8 < bytes.len() && &bytes[i..i + 9] == b"<![CDATA[" {
+ in_cdata = true;
+ result.push_str("<![CDATA[");
+ i += 9;
+ continue;
+ }
+ if in_cdata {
+ if i + 2 < bytes.len() && &bytes[i..i + 3] == b"]]]]><![CDATA[>" {
+ in_cdata = false;
+ result.push_str("]]]]><![CDATA[>");
+ i += 3;
+ } else {
+ result.push(bytes[i] as char);
+ i += 1;
+ }
+ continue;
+ }
+ if bytes[i] == b'&' {
+ i += 1;
+ if i < bytes.len() && bytes[i] == b'#' {
+ // Character reference
+ i += 1;
+ let char_val = if i < bytes.len() && bytes[i] == b'x' {
+ i += 1;
+ let start = i;
+ while i < bytes.len() && bytes[i].is_ascii_hexdigit() {
+ i += 1;
+ }
+ let hex = std::str::from_utf8(&bytes[start..i])
+ .map_err(|_| self.fatal("invalid UTF-8 in entity value"))?;
+ u32::from_str_radix(hex, 16)
+ .map_err(|_| self.fatal("invalid hex character reference"))?
+ } else {
+ let start = i;
+ while i < bytes.len() && bytes[i].is_ascii_digit() {
+ i += 1;
+ }
+ let dec = std::str::from_utf8(&bytes[start..i])
+ .map_err(|_| self.fatal("invalid UTF-8 in entity value"))?;
+ dec.parse::<u32>()
+ .map_err(|_| self.fatal("invalid decimal character reference"))?
+ };
+ if i >= bytes.len() || bytes[i] != b';' {
+ return Err(self.fatal("incomplete character reference in entity value"));
+ }
+ i += 1;
+ let ch = char::from_u32(char_val).ok_or_else(|| {
+ self.fatal(format!("invalid character reference: U+{char_val:04X}"))
+ })?;
+ result.push(ch);
+ } else {
+ // Entity reference
+ let start = i;
+ while i < bytes.len() && bytes[i] != b';' {
+ i += 1;
+ }
+ if i >= bytes.len() {
+ return Err(self.fatal("incomplete entity reference in entity value"));
+ }
+ let name = std::str::from_utf8(&bytes[start..i])
+ .map_err(|_| self.fatal("invalid UTF-8 in entity name"))?;
+ i += 1; // skip ';'
+
+ self.entity_expansions += 1;
+ if self.entity_expansions > self.max_entity_expansions {
+ return Err(self.fatal(format!(
+ "entity expansion limit exceeded ({})",
+ self.max_entity_expansions
+ )));
+ }
+
+ // Fast path: builtin entities push directly, no allocation
+ match name {
+ "amp" => {
+ result.push('&');
+ continue;
+ }
+ "lt" => {
+ result.push('<');
+ continue;
+ }
+ "gt" => {
+ result.push('>');
+ continue;
+ }
+ "apos" => {
+ result.push('\'');
+ continue;
+ }
+ "quot" => {
+ result.push('"');
+ continue;
+ }
+ _ => {}
+ }
+
+ let expanded = if let Some(info) = self.entity_external.get(name).cloned() {
+ if let Some(ref resolver) = self.entity_resolver.clone() {
+ let request = ExternalEntityRequest {
+ name,
+ system_id: &info.system_id,
+ public_id: info.public_id.as_deref(),
+ };
+ if let Some(resolved) = resolver(request) {
+ self.expand_entity_text(&resolved)?
+ } else {
+ return Err(self.fatal(format!(
+ "reference to external entity '{name}' is not supported"
+ )));
+ }
+ } else {
+ return Err(self.fatal(format!(
+ "reference to external entity '{name}' is not supported"
+ )));
+ }
+ } else if let Some(value) = self.entity_map.get(name).cloned() {
+ self.expand_entity_text(&value)?
+ } else if self.recover || self.has_pe_references || self.has_external_dtd {
+ self.push_diagnostic(
+ ErrorSeverity::Warning,
+ format!("unknown entity reference: &{name};"),
+ );
+ String::new()
+ } else {
+ return Err(self.fatal(format!("unknown entity reference: &{name};")));
+ };
+ result.push_str(&expanded);
+ }
+ } else {
+ // Regular character — copy as-is, handling multi-byte UTF-8
+ let start = i;
+ i += 1;
+ // Skip continuation bytes
+ while i < bytes.len() && bytes[i] & 0xC0 == 0x80 {
+ i += 1;
+ }
+ if let Ok(s) = std::str::from_utf8(&bytes[start..i]) {
+ result.push_str(s);
+ }
+ }
+ }
+
+ Ok(result)
+ }
+
+ /// Validates that an entity's replacement text matches the XML content
+ /// production (XML 1.0 §4.3.2 WFC: Parsed Entity).
+ ///
+ /// Expands character references in the raw entity value, replaces entity
+ /// references with placeholders, then wraps in a synthetic root element
+ /// and parses. If parsing fails, the entity is not well-formed.
+ fn validate_entity_content(&self, name: &str, raw_value: &str) -> Result<(), ParseError> {
+ let replacement = crate::validation::dtd::expand_char_refs_only(raw_value);
+
+ // If no '<', the text is just character data — always valid content.
+ if !replacement.contains('<') {
+ return Ok(());
+ }
+
+ let sanitized = crate::validation::dtd::replace_entity_refs(&replacement);
+ let wrapped = format!("<_r>{sanitized}</_r>");
+
+ let options = super::ParseOptions::default();
+ if super::parse_str_with_options(&wrapped, &options).is_err() {
+ return Err(self.fatal(format!(
+ "entity '{name}' replacement text is not \
+ well-formed XML content"
+ )));
+ }
+
+ Ok(())
+ }
+
+ // -- Attribute value parsing (XML 1.0 §3.3.3) --
+
+ /// Parses a quoted attribute value with entity resolution and
+ /// whitespace normalization.
+ ///
+ /// Uses bulk scanning to find the next `&`, `<`, or quote character,
+ /// then extracts safe chunks with a single `push_str()` instead of
+ /// processing character by character.
+ pub fn parse_attribute_value(&mut self) -> Result<String, ParseError> {
+ let quote = self.next_byte()?;
+ if quote != b'"' && quote != b'\'' {
+ return Err(self.fatal("attribute value must be quoted"));
+ }
+
+ let mut value = String::new();
+ loop {
+ // Bulk scan for the next interesting byte
+ let safe_len = self.scan_attr_value(quote);
+ if safe_len > 0 {
+ let start = self.pos;
+ let chunk = std::str::from_utf8(&self.input[start..start + safe_len])
+ .map_err(|_| self.fatal("invalid UTF-8 in attribute value"))?;
+ // Fast byte-level pre-check: only validate when bytes suggest
+ // possible invalid chars (0x7F or U+FFFE/U+FFFF sequences).
+ if let Some(bad) = may_contain_invalid_xml_chars(chunk.as_bytes())
+ .then(|| find_invalid_xml_char(chunk))
+ .flatten()
+ {
+ if self.recover {
+ self.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("invalid XML character: U+{:04X}", bad as u32),
+ );
+ } else {
+ return Err(
+ self.fatal(format!("invalid XML character: U+{:04X}", bad as u32))
+ );
+ }
+ }
+ // Normalize whitespace in chunk (XML 1.0 §3.3.3)
+ if chunk
+ .as_bytes()
+ .iter()
+ .any(|&b| b == b'\t' || b == b'\n' || b == b'\r')
+ {
+ for ch in chunk.chars() {
+ match ch {
+ '\t' | '\n' | '\r' => value.push(' '),
+ _ => value.push(ch),
+ }
+ }
+ } else {
+ value.push_str(chunk);
+ }
+ self.advance_counting_lines(safe_len);
+ }
+
+ if self.at_end() {
+ return Err(self.fatal("unexpected end of input in attribute value"));
+ }
+
+ let b = self.input[self.pos];
+ if b == quote {
+ self.advance(1);
+ break;
+ }
+ if b == b'&' {
+ // Check if this is a DTD entity reference (not a built-in
+ // or character reference) by peeking ahead.
+ let is_custom_entity = self.input.get(self.pos + 1) != Some(&b'#')
+ && !self.input[self.pos + 1..].starts_with(b"lt;")
+ && !self.input[self.pos + 1..].starts_with(b"gt;")
+ && !self.input[self.pos + 1..].starts_with(b"amp;")
+ && !self.input[self.pos + 1..].starts_with(b"apos;")
+ && !self.input[self.pos + 1..].starts_with(b"quot;");
+ let resolved = self.parse_reference_into(&mut value)?;
+ // WFC: No < in Attribute Values — entity replacement text
+ // must not contain '<' (XML 1.0 §3.1). Built-in entity
+ // < is explicitly excluded from this constraint.
+ if is_custom_entity && resolved.contains('<') {
+ return Err(
+ self.fatal("'<' not allowed in attribute values (from entity expansion)")
+ );
+ }
+ } else if b == b'<' {
+ return Err(self.fatal("'<' not allowed in attribute values"));
+ } else {
+ let ch = self.next_char()?;
+ // Normalize whitespace in attribute values (XML 1.0 §3.3.3)
+ if ch == '\r' || ch == '\n' || ch == '\t' {
+ value.push(' ');
+ } else {
+ value.push(ch);
+ }
+ }
+ }
+
+ Ok(value)
+ }
+
+ /// Parses a simple quoted value (single or double quotes, no entity
+ /// resolution).
+ pub fn parse_quoted_value(&mut self) -> Result<String, ParseError> {
+ let quote = self.next_byte()?;
+ if quote != b'"' && quote != b'\'' {
+ return Err(self.fatal("expected quoted value"));
+ }
+ let start = self.pos;
+ while !self.at_end() && self.peek() != Some(quote) {
+ self.advance(1);
+ }
+ let value = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in quoted value"))?
+ .to_string();
+ self.expect_byte(quote)?;
+ Ok(value)
+ }
+
+ // -- Error helpers --
+
+ /// Creates a fatal `ParseError` at the current location.
+ pub fn fatal(&self, message: impl Into<String>) -> ParseError {
+ ParseError {
+ message: message.into(),
+ location: self.location(),
+ diagnostics: self.diagnostics.clone(),
+ }
+ }
+
+ /// Appends a diagnostic (warning or recoverable error) to the list.
+ pub fn push_diagnostic(&mut self, severity: ErrorSeverity, message: String) {
+ self.diagnostics.push(ParseDiagnostic {
+ severity,
+ message,
+ location: self.location(),
+ });
+ }
+}
+
+// -------------------------------------------------------------------------
+// Namespace resolver
+// -------------------------------------------------------------------------
+
+/// Manages namespace scope for XML parsers.
+///
+/// Maintains a stack of namespace binding frames that mirrors the element
+/// nesting. Each frame contains the `xmlns` declarations introduced on
+/// that element. A `HashMap` cache provides O(1) namespace resolution
+/// instead of walking the stack.
+pub(crate) struct NamespaceResolver {
+ /// Stack of namespace binding frames. Each frame is a `Vec` of
+ /// `(prefix, uri)` pairs where a `None` prefix represents the
+ /// default namespace.
+ stack: Vec<Vec<(Option<String>, String)>>,
+ /// O(1) lookup cache for the default namespace (prefix = None).
+ default_ns: Option<String>,
+ /// O(1) lookup cache for prefixed namespaces. Uses `String` keys so
+ /// lookups with `&str` work via the `Borrow` trait without allocation.
+ prefixed_ns: HashMap<String, String>,
+}
+
+/// The well-known XML namespace URI, pre-bound to the `xml` prefix.
+pub(crate) const XML_NAMESPACE: &str = "http://www.w3.org/XML/1998/namespace";
+
+impl NamespaceResolver {
+ /// Creates a new resolver with the `xml` prefix pre-bound.
+ pub fn new() -> Self {
+ let initial = vec![(Some("xml".to_string()), XML_NAMESPACE.to_string())];
+ let mut prefixed_ns = HashMap::new();
+ prefixed_ns.insert("xml".to_string(), XML_NAMESPACE.to_string());
+ Self {
+ stack: vec![initial],
+ default_ns: None,
+ prefixed_ns,
+ }
+ }
+
+ /// Pushes a new (empty) namespace scope for an element.
+ pub fn push_scope(&mut self) {
+ self.stack.push(Vec::new());
+ }
+
+ /// Pops the current namespace scope, restoring previous bindings.
+ pub fn pop_scope(&mut self) {
+ if let Some(bindings) = self.stack.pop() {
+ for (prefix, _uri) in bindings.iter().rev() {
+ // Find previous binding in remaining stack
+ let prev = self
+ .stack
+ .iter()
+ .rev()
+ .flat_map(|frame| frame.iter().rev())
+ .find(|(p, _)| p == prefix)
+ .map(|(_, u)| u.clone());
+ match prefix {
+ None => {
+ self.default_ns = prev;
+ }
+ Some(pfx) => {
+ if let Some(prev_uri) = prev {
+ self.prefixed_ns.insert(pfx.clone(), prev_uri);
+ } else {
+ self.prefixed_ns.remove(pfx);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /// Binds a namespace prefix to a URI in the current scope.
+ ///
+ /// Use `prefix = None` for the default namespace (`xmlns="..."`).
+ pub fn bind(&mut self, prefix: Option<String>, uri: String) {
+ if let Some(frame) = self.stack.last_mut() {
+ frame.push((prefix.clone(), uri.clone()));
+ }
+ match prefix {
+ None => {
+ self.default_ns = Some(uri);
+ }
+ Some(pfx) => {
+ self.prefixed_ns.insert(pfx, uri);
+ }
+ }
+ }
+
+ /// Resolves a namespace prefix to its URI in O(1) time.
+ ///
+ /// Use `prefix = None` to resolve the default namespace.
+ pub fn resolve(&self, prefix: Option<&str>) -> Option<&str> {
+ match prefix {
+ None => self.default_ns.as_deref().filter(|s| !s.is_empty()),
+ Some(pfx) => self
+ .prefixed_ns
+ .get(pfx)
+ .map(String::as_str)
+ .filter(|s| !s.is_empty()),
+ }
+ }
+}
+
+// -------------------------------------------------------------------------
+// Common XML parsing helpers
+// -------------------------------------------------------------------------
+
+/// Parses an XML comment (`<!-- ... -->`), returning the content text.
+///
+/// The opening `<!--` must not have been consumed yet.
+///
+/// See XML 1.0 §2.5 production `[15]`.
+pub(crate) fn parse_comment_content(input: &mut ParserInput<'_>) -> Result<String, ParseError> {
+ input.expect_str(b"<!--")?;
+
+ // Bulk scan for `--` (which is either `-->` end or illegal `--`)
+ let mut content = String::new();
+ loop {
+ match input.scan_for_2byte_terminator(b'-', b'-') {
+ Some(safe_len) => {
+ // Copy everything before the `--`
+ if safe_len > 0 {
+ let start = input.pos();
+ // Validate XML chars using byte-level pre-check
+ let has_bad =
+ may_contain_invalid_xml_chars(input.slice(start, start + safe_len));
+ let chunk = std::str::from_utf8(input.slice(start, start + safe_len))
+ .map_err(|_| input.fatal("invalid UTF-8 in comment"))?
+ .to_string();
+ if has_bad {
+ if let Some(bad) = find_invalid_xml_char(&chunk) {
+ if input.recover() {
+ input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("invalid XML character: U+{:04X}", bad as u32),
+ );
+ } else {
+ return Err(input.fatal(format!(
+ "invalid XML character: U+{:04X}",
+ bad as u32
+ )));
+ }
+ }
+ }
+ content.push_str(&chunk);
+ input.advance_counting_lines(safe_len);
+ }
+ // Check if it's `-->` (end of comment) or just `--`
+ if input.looking_at(b"-->") {
+ input.advance_counting_lines(3);
+ break;
+ }
+ // Bare `--` inside comment
+ if input.recover() {
+ input.push_diagnostic(
+ ErrorSeverity::Error,
+ "'--' not allowed inside comments".to_string(),
+ );
+ content.push_str("--");
+ input.advance_counting_lines(2);
+ } else {
+ return Err(input.fatal("'--' not allowed inside comments"));
+ }
+ }
+ None => {
+ return Err(input.fatal("unexpected end of input in comment"));
+ }
+ }
+ }
+
+ Ok(content)
+}
+
+/// Parses a CDATA section (`<![CDATA[ ... ]]]]><![CDATA[>`), returning the content text.
+///
+/// The opening `<![CDATA[` must not have been consumed yet.
+///
+/// See XML 1.0 §2.7 production `[18]`.
+pub(crate) fn parse_cdata_content(input: &mut ParserInput<'_>) -> Result<String, ParseError> {
+ input.expect_str(b"<![CDATA[")?;
+
+ // Bulk scan for `]]]]><![CDATA[>` terminator
+ match input.scan_for_3byte_terminator(b']', b']', b'>') {
+ Some(safe_len) => {
+ let start = input.pos();
+ let has_bad = may_contain_invalid_xml_chars(input.slice(start, start + safe_len));
+ let content = std::str::from_utf8(input.slice(start, start + safe_len))
+ .map_err(|_| input.fatal("invalid UTF-8 in CDATA section"))?
+ .to_string();
+ if has_bad {
+ if let Some(bad) = find_invalid_xml_char(&content) {
+ if input.recover() {
+ input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("invalid XML character: U+{:04X}", bad as u32),
+ );
+ } else {
+ return Err(
+ input.fatal(format!("invalid XML character: U+{:04X}", bad as u32))
+ );
+ }
+ }
+ }
+ input.advance_counting_lines(safe_len + 3); // skip content + ]]]]><![CDATA[>
+ Ok(content)
+ }
+ None => Err(input.fatal("unexpected end of input in CDATA section")),
+ }
+}
+
+/// Parses a processing instruction (`<?target data?>`), returning
+/// `(target, optional_data)`.
+///
+/// The opening `<?` must not have been consumed yet.
+///
+/// See XML 1.0 §2.6 production `[16]`.
+pub(crate) fn parse_pi_content(
+ input: &mut ParserInput<'_>,
+) -> Result<(String, Option<String>), ParseError> {
+ input.expect_str(b"<?")?;
+ let target = input.parse_name()?;
+
+ // "xml" (case-insensitive) is reserved for the XML declaration
+ if target.eq_ignore_ascii_case("xml") {
+ return Err(input.fatal("PI target 'xml' is reserved"));
+ }
+
+ // Namespaces in XML 1.0 §3: PI targets must be NCNames (no colons).
+ if target.contains(':') {
+ return Err(input.fatal("PI target must not contain a colon"));
+ }
+
+ let data = if input.skip_whitespace() {
+ // Bulk scan for `?>` terminator
+ match input.scan_for_2byte_terminator(b'?', b'>') {
+ Some(data_len) => {
+ let start = input.pos();
+ let has_bad = may_contain_invalid_xml_chars(input.slice(start, start + data_len));
+ let data = std::str::from_utf8(input.slice(start, start + data_len))
+ .map_err(|_| input.fatal("invalid UTF-8 in processing instruction"))?
+ .to_string();
+ if has_bad {
+ if let Some(bad) = find_invalid_xml_char(&data) {
+ if input.recover() {
+ input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("invalid XML character: U+{:04X}", bad as u32),
+ );
+ } else {
+ return Err(
+ input.fatal(format!("invalid XML character: U+{:04X}", bad as u32))
+ );
+ }
+ }
+ }
+ input.advance_counting_lines(data_len + 2); // skip data + ?>
+ if data.is_empty() {
+ None
+ } else {
+ Some(data)
+ }
+ }
+ None => {
+ return Err(input.fatal("unexpected end of input in processing instruction"));
+ }
+ }
+ } else {
+ input.expect_str(b"?>")?;
+ None
+ };
+
+ Ok((target, data))
+}
+
+/// Parsed XML declaration data.
+#[derive(Debug, Clone)]
+pub(crate) struct XmlDeclaration {
+ /// XML version (e.g. `"1.0"`).
+ pub version: String,
+ /// Optional encoding declaration.
+ pub encoding: Option<String>,
+ /// Optional standalone declaration.
+ pub standalone: Option<bool>,
+}
+
+/// Parses an XML declaration (`<?xml version="1.0" ...?>`), returning the
+/// parsed version, encoding, and standalone values.
+///
+/// The opening `<?xml ` must not have been consumed yet (but should be
+/// verified by the caller via `looking_at`).
+///
+/// See XML 1.0 §2.8 production `[23]`.
+pub(crate) fn parse_xml_decl(input: &mut ParserInput<'_>) -> Result<XmlDeclaration, ParseError> {
+ input.expect_str(b"<?xml")?;
+ input.skip_whitespace_required()?;
+
+ // version is required
+ input.expect_str(b"version")?;
+ input.skip_whitespace();
+ input.expect_byte(b'=')?;
+ input.skip_whitespace();
+ let version = input.parse_quoted_value()?;
+
+ // XML 1.0 §2.8: VersionNum ::= '1.' [0-9]+
+ if !is_valid_version_num(&version) {
+ return Err(input.fatal(format!("invalid version number: '{version}'")));
+ }
+
+ // encoding is optional
+ let had_ws = input.skip_whitespace();
+ let encoding = if input.looking_at(b"encoding") {
+ if !had_ws {
+ return Err(input.fatal("whitespace required before encoding"));
+ }
+ input.expect_str(b"encoding")?;
+ input.skip_whitespace();
+ input.expect_byte(b'=')?;
+ input.skip_whitespace();
+ let enc = input.parse_quoted_value()?;
+
+ // XML 1.0 §4.3.3: EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
+ if !is_valid_encoding_name(&enc) {
+ return Err(input.fatal(format!("invalid encoding name: '{enc}'")));
+ }
+
+ Some(enc)
+ } else {
+ None
+ };
+
+ // standalone is optional
+ // If encoding was present, we need fresh whitespace before standalone.
+ // If encoding was absent, the whitespace consumed when looking for
+ // encoding already separates version from standalone.
+ let had_ws2 = input.skip_whitespace() || (encoding.is_none() && had_ws);
+ let standalone = if input.looking_at(b"standalone") {
+ if !had_ws2 {
+ return Err(input.fatal("whitespace required before standalone"));
+ }
+ input.expect_str(b"standalone")?;
+ input.skip_whitespace();
+ input.expect_byte(b'=')?;
+ input.skip_whitespace();
+ let val = input.parse_quoted_value()?;
+ match val.as_str() {
+ "yes" => Some(true),
+ "no" => Some(false),
+ _ => return Err(input.fatal("standalone must be 'yes' or 'no'")),
+ }
+ } else {
+ None
+ };
+
+ input.skip_whitespace();
+ input.expect_str(b"?>")?;
+
+ Ok(XmlDeclaration {
+ version,
+ encoding,
+ standalone,
+ })
+}
+
+/// Validates an XML version number per XML 1.0 §2.8.
+///
+/// `VersionNum ::= '1.' [0-9]+`
+fn is_valid_version_num(s: &str) -> bool {
+ if let Some(rest) = s.strip_prefix("1.") {
+ !rest.is_empty() && rest.bytes().all(|b| b.is_ascii_digit())
+ } else {
+ false
+ }
+}
+
+/// Validates an encoding name per XML 1.0 §4.3.3.
+///
+/// `EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*`
+fn is_valid_encoding_name(s: &str) -> bool {
+ let bytes = s.as_bytes();
+ if bytes.is_empty() {
+ return false;
+ }
+ if !bytes[0].is_ascii_alphabetic() {
+ return false;
+ }
+ bytes[1..]
+ .iter()
+ .all(|&b| b.is_ascii_alphanumeric() || b == b'.' || b == b'_' || b == b'-')
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_peek_and_advance() {
+ let mut input = ParserInput::new("abc");
+ assert_eq!(input.peek(), Some(b'a'));
+ assert_eq!(input.peek_at(1), Some(b'b'));
+ input.advance(1);
+ assert_eq!(input.peek(), Some(b'b'));
+ input.advance(2);
+ assert!(input.at_end());
+ }
+
+ #[test]
+ fn test_line_column_tracking() {
+ let mut input = ParserInput::new("ab\ncd");
+ assert_eq!(input.location().line, 1);
+ assert_eq!(input.location().column, 1);
+ input.advance(2); // past "ab"
+ assert_eq!(input.location().column, 3);
+ input.advance(1); // past "\n"
+ assert_eq!(input.location().line, 2);
+ assert_eq!(input.location().column, 1);
+ }
+
+ #[test]
+ fn test_next_char_cr_normalization() {
+ let mut input = ParserInput::new("a\r\nb");
+ assert_eq!(input.next_char().unwrap(), 'a');
+ assert_eq!(input.next_char().unwrap(), '\n'); // \r\n → \n
+ assert_eq!(input.next_char().unwrap(), 'b');
+ }
+
+ #[test]
+ fn test_parse_name() {
+ let mut input = ParserInput::new("foo:bar ");
+ let name = input.parse_name().unwrap();
+ assert_eq!(name, "foo:bar");
+ }
+
+ #[test]
+ fn test_parse_name_length_limit() {
+ let long_name = "a".repeat(100);
+ let mut input = ParserInput::new(&long_name);
+ input.set_max_name_length(50);
+ let result = input.parse_name();
+ assert!(result.is_err());
+ assert!(result.unwrap_err().message.contains("name length"));
+ }
+
+ #[test]
+ fn test_parse_reference_builtin() {
+ let mut input = ParserInput::new("&");
+ assert_eq!(input.parse_reference().unwrap(), "&");
+
+ let mut input = ParserInput::new("<");
+ assert_eq!(input.parse_reference().unwrap(), "<");
+
+ let mut input = ParserInput::new(">");
+ assert_eq!(input.parse_reference().unwrap(), ">");
+
+ let mut input = ParserInput::new("'");
+ assert_eq!(input.parse_reference().unwrap(), "'");
+
+ let mut input = ParserInput::new(""");
+ assert_eq!(input.parse_reference().unwrap(), "\"");
+ }
+
+ #[test]
+ fn test_parse_reference_char_decimal() {
+ let mut input = ParserInput::new("A");
+ assert_eq!(input.parse_reference().unwrap(), "A");
+ }
+
+ #[test]
+ fn test_parse_reference_char_hex() {
+ let mut input = ParserInput::new("A");
+ assert_eq!(input.parse_reference().unwrap(), "A");
+ }
+
+ #[test]
+ fn test_parse_reference_unknown_error() {
+ let mut input = ParserInput::new("&bogus;");
+ assert!(input.parse_reference().is_err());
+ }
+
+ #[test]
+ fn test_parse_reference_unknown_recovery() {
+ let mut input = ParserInput::new("&bogus;");
+ input.set_recover(true);
+ let result = input.parse_reference().unwrap();
+ assert_eq!(result, "");
+ assert_eq!(input.diagnostics.len(), 1);
+ }
+
+ #[test]
+ fn test_entity_expansion_limit() {
+ let mut input = ParserInput::new("&&&");
+ input.set_max_entity_expansions(2);
+ assert!(input.parse_reference().is_ok());
+ assert!(input.parse_reference().is_ok());
+ assert!(input.parse_reference().is_err());
+ }
+
+ #[test]
+ fn test_depth_limit() {
+ let mut input = ParserInput::new("");
+ input.set_max_depth(2);
+ assert!(input.increment_depth().is_ok()); // depth = 1
+ assert!(input.increment_depth().is_ok()); // depth = 2
+ assert!(input.increment_depth().is_err()); // depth = 3 > 2
+ }
+
+ #[test]
+ fn test_parse_attribute_value() {
+ let mut input = ParserInput::new("\"hello & world\"");
+ let value = input.parse_attribute_value().unwrap();
+ assert_eq!(value, "hello & world");
+ }
+
+ #[test]
+ fn test_parse_attribute_value_whitespace_normalization() {
+ let mut input = ParserInput::new("\"a\tb\nc\"");
+ let value = input.parse_attribute_value().unwrap();
+ assert_eq!(value, "a b c");
+ }
+
+ #[test]
+ fn test_parse_quoted_value() {
+ let mut input = ParserInput::new("'hello'");
+ let value = input.parse_quoted_value().unwrap();
+ assert_eq!(value, "hello");
+ }
+
+ #[test]
+ fn test_skip_whitespace() {
+ let mut input = ParserInput::new(" \t\n abc");
+ assert!(input.skip_whitespace());
+ assert_eq!(input.peek(), Some(b'a'));
+ }
+
+ #[test]
+ fn test_looking_at() {
+ let input = ParserInput::new("<!--comment-->");
+ assert!(input.looking_at(b"<!--"));
+ assert!(!input.looking_at(b"<![CDATA["));
+ }
+
+ #[test]
+ fn test_take_while() {
+ let mut input = ParserInput::new("12345abc");
+ let digits = input.take_while(|b| b.is_ascii_digit());
+ assert_eq!(digits, "12345");
+ assert_eq!(input.peek(), Some(b'a'));
+ }
+
+ #[test]
+ fn test_split_name() {
+ assert_eq!(split_name("foo:bar"), (Some("foo"), "bar"));
+ assert_eq!(split_name("bar"), (None, "bar"));
+ assert_eq!(split_name(":bar"), (Some(""), "bar"));
+ }
+
+ #[test]
+ fn test_namespace_resolver() {
+ let mut ns = NamespaceResolver::new();
+
+ // xml prefix is pre-bound
+ assert_eq!(ns.resolve(Some("xml")), Some(XML_NAMESPACE));
+ assert_eq!(ns.resolve(None), None); // no default namespace
+
+ ns.push_scope();
+ ns.bind(None, "http://default".to_string());
+ ns.bind(Some("foo".to_string()), "http://foo".to_string());
+
+ assert_eq!(ns.resolve(None), Some("http://default"));
+ assert_eq!(ns.resolve(Some("foo")), Some("http://foo"));
+
+ ns.pop_scope();
+ assert_eq!(ns.resolve(None), None);
+ assert_eq!(ns.resolve(Some("foo")), None);
+ }
+
+ #[test]
+ fn test_namespace_undeclare_default() {
+ let mut ns = NamespaceResolver::new();
+ ns.push_scope();
+ ns.bind(None, "http://default".to_string());
+ assert_eq!(ns.resolve(None), Some("http://default"));
+
+ ns.push_scope();
+ ns.bind(None, String::new()); // xmlns=""
+ assert_eq!(ns.resolve(None), None);
+
+ ns.pop_scope();
+ assert_eq!(ns.resolve(None), Some("http://default"));
+ }
+
+ #[test]
+ fn test_parse_comment_content() {
+ let mut input = ParserInput::new("<!-- hello -->");
+ let content = parse_comment_content(&mut input).unwrap();
+ assert_eq!(content, " hello ");
+ }
+
+ #[test]
+ fn test_parse_cdata_content() {
+ let mut input = ParserInput::new("<![CDATA[some <data>]]]]><![CDATA[>");
+ let content = parse_cdata_content(&mut input).unwrap();
+ assert_eq!(content, "some <data>");
+ }
+
+ #[test]
+ fn test_parse_pi_content() {
+ let mut input = ParserInput::new("<?target data?>");
+ let (target, data) = parse_pi_content(&mut input).unwrap();
+ assert_eq!(target, "target");
+ assert_eq!(data.as_deref(), Some("data"));
+ }
+
+ #[test]
+ fn test_parse_pi_no_data() {
+ let mut input = ParserInput::new("<?target?>");
+ let (target, data) = parse_pi_content(&mut input).unwrap();
+ assert_eq!(target, "target");
+ assert_eq!(data, None);
+ }
+
+ #[test]
+ fn test_parse_xml_decl() {
+ let mut input = ParserInput::new("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+ let decl = parse_xml_decl(&mut input).unwrap();
+ assert_eq!(decl.version, "1.0");
+ assert_eq!(decl.encoding.as_deref(), Some("UTF-8"));
+ assert_eq!(decl.standalone, None);
+ }
+
+ #[test]
+ fn test_parse_xml_decl_standalone() {
+ let mut input =
+ ParserInput::new("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
+ let decl = parse_xml_decl(&mut input).unwrap();
+ assert_eq!(decl.standalone, Some(true));
+ }
+
+ #[test]
+ fn test_is_name_chars() {
+ assert!(is_name_start_char('a'));
+ assert!(is_name_start_char('Z'));
+ assert!(is_name_start_char('_'));
+ assert!(is_name_start_char(':'));
+ assert!(!is_name_start_char('0'));
+ assert!(!is_name_start_char('-'));
+
+ assert!(is_name_char('a'));
+ assert!(is_name_char('0'));
+ assert!(is_name_char('-'));
+ assert!(is_name_char('.'));
+ assert!(!is_name_char(' '));
+ }
+
+ // =====================================================================
+ // Security-critical boundary tests
+ // =====================================================================
+
+ // -- Depth limit boundary checks --
+
+ #[test]
+ fn test_increment_depth_exact_boundary() {
+ let mut input = ParserInput::new("");
+ input.set_max_depth(3);
+ assert!(input.increment_depth().is_ok()); // depth = 1
+ assert!(input.increment_depth().is_ok()); // depth = 2
+ assert!(input.increment_depth().is_ok()); // depth = 3 (== max)
+ assert!(input.increment_depth().is_err()); // depth = 4 > 3
+ }
+
+ #[test]
+ fn test_increment_depth_max_depth_one() {
+ // Edge case: max_depth = 1 means only one level allowed
+ let mut input = ParserInput::new("");
+ input.set_max_depth(1);
+ assert!(input.increment_depth().is_ok()); // depth = 1
+ let err = input.increment_depth().unwrap_err();
+ assert!(err.message.contains("maximum nesting depth exceeded"));
+ }
+
+ #[test]
+ fn test_increment_depth_max_depth_zero() {
+ // max_depth = 0 means no nesting allowed at all
+ let mut input = ParserInput::new("");
+ input.set_max_depth(0);
+ let err = input.increment_depth().unwrap_err();
+ assert!(err.message.contains("maximum nesting depth exceeded"));
+ }
+
+ #[test]
+ fn test_decrement_depth_saturates_at_zero() {
+ let mut input = ParserInput::new("");
+ // Decrementing from 0 should not underflow
+ input.decrement_depth();
+ assert_eq!(input.depth(), 0);
+ // Increment then decrement twice — should saturate
+ input.increment_depth().unwrap();
+ assert_eq!(input.depth(), 1);
+ input.decrement_depth();
+ assert_eq!(input.depth(), 0);
+ input.decrement_depth();
+ assert_eq!(input.depth(), 0);
+ }
+
+ #[test]
+ fn test_depth_resets_after_decrement_allows_reentry() {
+ // Verify that after popping back under the limit, new pushes succeed
+ let mut input = ParserInput::new("");
+ input.set_max_depth(2);
+ assert!(input.increment_depth().is_ok()); // depth = 1
+ assert!(input.increment_depth().is_ok()); // depth = 2
+ input.decrement_depth(); // depth = 1
+ assert!(input.increment_depth().is_ok()); // depth = 2 again
+ assert!(input.increment_depth().is_err()); // depth = 3 > 2
+ }
+
+ // -- Entity expansion limit boundary checks --
+
+ #[test]
+ fn test_entity_expansion_limit_exact_boundary() {
+ // max_entity_expansions = 3 means exactly 3 are allowed
+ let mut input = ParserInput::new("&&&&");
+ input.set_max_entity_expansions(3);
+ assert!(input.parse_reference().is_ok()); // expansion 1
+ assert!(input.parse_reference().is_ok()); // expansion 2
+ assert!(input.parse_reference().is_ok()); // expansion 3
+ let err = input.parse_reference().unwrap_err();
+ assert!(err.message.contains("entity expansion limit exceeded"));
+ }
+
+ #[test]
+ fn test_entity_expansion_limit_zero() {
+ // max_entity_expansions = 0 means no expansions allowed
+ let mut input = ParserInput::new("&");
+ input.set_max_entity_expansions(0);
+ let err = input.parse_reference().unwrap_err();
+ assert!(err.message.contains("entity expansion limit exceeded"));
+ }
+
+ #[test]
+ fn test_entity_expansion_limit_one() {
+ let mut input = ParserInput::new("&<");
+ input.set_max_entity_expansions(1);
+ assert!(input.parse_reference().is_ok());
+ let err = input.parse_reference().unwrap_err();
+ assert!(err.message.contains("entity expansion limit exceeded"));
+ }
+
+ #[test]
+ fn test_entity_expansion_counter_includes_char_refs() {
+ // Character references also increment the entity expansion counter
+ let mut input = ParserInput::new("ABC");
+ input.set_max_entity_expansions(2);
+ assert!(input.parse_reference().is_ok()); // A → A
+ assert!(input.parse_reference().is_ok()); // B → B
+ let err = input.parse_reference().unwrap_err();
+ assert!(err.message.contains("entity expansion limit exceeded"));
+ }
+
+ #[test]
+ fn test_entity_expansion_limit_via_parse_str() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // Test through the high-level API: document with many char refs
+ let refs: String = (0..50).map(|_| "A").collect();
+ let xml = format!("<r>{refs}</r>");
+ let opts = ParseOptions::default().max_entity_expansions(10);
+ let result = parse_str_with_options(&xml, &opts);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("entity expansion limit"));
+ }
+
+ // -- Entity expansion: DTD internal entity recursion --
+
+ #[test]
+ fn test_entity_expansion_dtd_internal_entity() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY greet "Hello">
+]>
+<r>&greet;</r>"#;
+ let doc = parse_str_with_options(xml, &ParseOptions::default()).unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "Hello");
+ }
+
+ #[test]
+ fn test_entity_expansion_nested_dtd_entities() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // Entity "b" references entity "a". The nested reference is parsed
+ // as content (XML 1.0 §4.4), so the entity expansion is visible
+ // through text_content.
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY a "world">
+<!ENTITY b "hello &a;">
+]>
+<r>&b;</r>"#;
+ let doc = parse_str_with_options(xml, &ParseOptions::default()).unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "hello world");
+ }
+
+ #[test]
+ fn test_entity_expansion_limit_nested_dtd_entities_in_attributes() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // In attribute values, entity references ARE fully expanded through
+ // parse_reference_into + expand_entity_text. Each expansion counts
+ // against the limit. Chain: c -> 3*b -> 9*a = 13 total expansions.
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY a "x">
+<!ENTITY b "&a;&a;&a;">
+<!ENTITY c "&b;&b;&b;">
+]>
+<r v="&c;"/>"#;
+ let opts = ParseOptions::default().max_entity_expansions(5);
+ let result = parse_str_with_options(xml, &opts);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("entity expansion limit"));
+ }
+
+ // -- Billion laughs style attack (exponential entity expansion) --
+
+ #[test]
+ fn test_billion_laughs_entity_bomb_in_attribute() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // Classic billion laughs pattern in an attribute value where
+ // entities ARE fully expanded. Each entity references the
+ // previous one multiple times, causing exponential expansion.
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY lol "lol">
+<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
+<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
+<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
+]>
+<r v="&lol4;"/>"#;
+ // lol4 -> 10 * lol3 -> 100 * lol2 -> 1000 * lol = 1111 expansions
+ let opts = ParseOptions::default().max_entity_expansions(100);
+ let result = parse_str_with_options(xml, &opts);
+ assert!(result.is_err());
+ let err = result.unwrap_err();
+ assert!(
+ err.message.contains("entity expansion limit"),
+ "billion laughs should be caught by expansion limit, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_billion_laughs_in_text_content_with_markup() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // When entity replacement text contains '<', the parser must expand
+ // it (to validate the markup), which triggers entity expansion
+ // counting. This tests the billion laughs pattern for text content
+ // entities that contain markup.
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY lol "lol">
+<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
+<!ENTITY lol3 "<i>&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;</i>">
+]>
+<r>&lol3;</r>"#;
+ let opts = ParseOptions::default().max_entity_expansions(50);
+ let result = parse_str_with_options(xml, &opts);
+ assert!(result.is_err());
+ let err = result.unwrap_err();
+ assert!(
+ err.message.contains("entity expansion limit"),
+ "billion laughs with markup should be caught, got: {}",
+ err.message
+ );
+ }
+
+ // -- XXE prevention: external entity references without resolver --
+
+ #[test]
+ fn test_xxe_external_entity_rejected_by_default() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY xxe SYSTEM "file:///etc/passwd">
+]>
+<r>&xxe;</r>"#;
+ let result = parse_str_with_options(xml, &ParseOptions::default());
+ assert!(result.is_err());
+ let err = result.unwrap_err();
+ assert!(
+ err.message.contains("external entity"),
+ "XXE should be rejected by default, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_xxe_external_entity_with_public_id_rejected() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY xxe PUBLIC "-//Evil//EN" "http://evil.com/payload">
+]>
+<r>&xxe;</r>"#;
+ let result = parse_str_with_options(xml, &ParseOptions::default());
+ assert!(result.is_err());
+ let err = result.unwrap_err();
+ assert!(
+ err.message.contains("external entity"),
+ "XXE with PUBLIC id should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_xxe_external_entity_in_attribute_rejected() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY xxe SYSTEM "file:///etc/shadow">
+]>
+<r a="&xxe;"/>"#;
+ let result = parse_str_with_options(xml, &ParseOptions::default());
+ assert!(result.is_err(), "XXE in attribute should be rejected");
+ }
+
+ #[test]
+ fn test_xxe_multiple_external_entities_all_rejected() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // Even if one entity is internal, the external one should fail
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY safe "ok">
+<!ENTITY evil SYSTEM "file:///etc/passwd">
+]>
+<r>&safe;&evil;</r>"#;
+ let result = parse_str_with_options(xml, &ParseOptions::default());
+ assert!(result.is_err());
+ }
+
+ // -- Character reference edge cases --
+
+ #[test]
+ fn test_char_ref_null_character_rejected() {
+ // � is not a valid XML character (XML 1.0 §2.2)
+ let mut input = ParserInput::new("�");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("valid XML character"),
+ "null char ref should be rejected as invalid XML char, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_null_hex_rejected() {
+ let mut input = ParserInput::new("�");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("valid XML character"),
+ "� should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_control_chars_rejected() {
+ // Control characters 0x01-0x08, 0x0B, 0x0C, 0x0E-0x1F are invalid
+ for codepoint in [1u32, 2, 7, 8, 0x0B, 0x0C, 0x0E, 0x1F] {
+ let ref_str = format!("&#x{codepoint:X};");
+ let mut input = ParserInput::new(&ref_str);
+ let result = input.parse_reference();
+ assert!(
+ result.is_err(),
+ "&#x{codepoint:X}; should be rejected as invalid XML character"
+ );
+ }
+ }
+
+ #[test]
+ fn test_char_ref_allowed_control_chars() {
+ // Tab (0x09), LF (0x0A), CR (0x0D) ARE valid XML characters
+ let mut input = ParserInput::new("	");
+ assert_eq!(input.parse_reference().unwrap(), "\t");
+
+ let mut input = ParserInput::new("
");
+ assert_eq!(input.parse_reference().unwrap(), "\n");
+
+ let mut input = ParserInput::new("
");
+ assert_eq!(input.parse_reference().unwrap(), "\r");
+ }
+
+ #[test]
+ fn test_char_ref_surrogate_codepoints_rejected() {
+ // U+D800 through U+DFFF are surrogates, not valid Unicode scalar values.
+ // char::from_u32 returns None for these.
+ let mut input = ParserInput::new("�");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("invalid character reference"),
+ "surrogate � should be rejected, got: {}",
+ err.message
+ );
+
+ let mut input = ParserInput::new("�");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("invalid character reference"),
+ "surrogate � should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_fffe_and_ffff_rejected() {
+ // U+FFFE and U+FFFF are not valid XML characters per §2.2
+ let mut input = ParserInput::new("");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("valid XML character"),
+ " should be rejected, got: {}",
+ err.message
+ );
+
+ let mut input = ParserInput::new("");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("valid XML character"),
+ " should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_max_valid_codepoint() {
+ // U+10FFFF is the highest valid Unicode scalar value and a valid
+ // XML character per §2.2
+ let mut input = ParserInput::new("");
+ let result = input.parse_reference().unwrap();
+ assert_eq!(result, "\u{10FFFF}");
+ }
+
+ #[test]
+ fn test_char_ref_beyond_unicode_range() {
+ // U+110000 is beyond the Unicode range — char::from_u32 returns None
+ let mut input = ParserInput::new("�");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("invalid character reference"),
+ "codepoint beyond Unicode range should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_very_large_decimal_rejected() {
+ // A huge decimal value that overflows u32
+ let mut input = ParserInput::new("�");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("invalid decimal character reference"),
+ "overflowing decimal char ref should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_very_large_hex_rejected() {
+ // A huge hex value that overflows u32
+ let mut input = ParserInput::new("�");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("invalid hex character reference"),
+ "overflowing hex char ref should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_empty_decimal_rejected() {
+ let mut input = ParserInput::new("&#;");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("empty decimal character reference"),
+ "empty decimal ref should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_empty_hex_rejected() {
+ let mut input = ParserInput::new("&#x;");
+ let err = input.parse_reference().unwrap_err();
+ assert!(
+ err.message.contains("empty hex character reference"),
+ "empty hex ref should be rejected, got: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_char_ref_valid_bmp_characters() {
+ // Space (0x20), Latin A (0x41), CJK character
+ let mut input = ParserInput::new(" ");
+ assert_eq!(input.parse_reference().unwrap(), " ");
+
+ let mut input = ParserInput::new("A");
+ assert_eq!(input.parse_reference().unwrap(), "A");
+
+ let mut input = ParserInput::new("中"); // CJK '中'
+ assert_eq!(input.parse_reference().unwrap(), "\u{4E2D}");
+ }
+
+ #[test]
+ fn test_char_ref_supplementary_plane() {
+ // Musical symbol G clef: U+1D11E
+ let mut input = ParserInput::new("𝄞");
+ assert_eq!(input.parse_reference().unwrap(), "\u{1D11E}");
+ }
+
+ // -- Name length limit edge cases --
+
+ #[test]
+ fn test_parse_name_at_exact_length_limit() {
+ let name = "a".repeat(50);
+ let input_str = format!("{name} ");
+ let mut input = ParserInput::new(&input_str);
+ input.set_max_name_length(50);
+ let result = input.parse_name().unwrap();
+ assert_eq!(result.len(), 50);
+ }
+
+ #[test]
+ fn test_parse_name_one_over_length_limit() {
+ let name = "a".repeat(51);
+ let input_str = format!("{name} ");
+ let mut input = ParserInput::new(&input_str);
+ input.set_max_name_length(50);
+ let result = input.parse_name();
+ assert!(result.is_err());
+ assert!(result.unwrap_err().message.contains("name length"));
+ }
+
+ #[test]
+ fn test_parse_name_length_limit_one() {
+ // Single-character names should work with limit = 1
+ let mut input = ParserInput::new("a ");
+ input.set_max_name_length(1);
+ assert_eq!(input.parse_name().unwrap(), "a");
+
+ // Two-character name should fail with limit = 1
+ let mut input = ParserInput::new("ab ");
+ input.set_max_name_length(1);
+ assert!(input.parse_name().is_err());
+ }
+
+ #[test]
+ fn test_parse_name_unicode_length_counted_in_bytes() {
+ // Unicode names — the limit is in bytes, not characters.
+ // \u{C0} is 'À' which is 2 bytes in UTF-8.
+ let name = "\u{C0}\u{C0}\u{C0}"; // 6 bytes
+ let input_str = format!("{name} ");
+ let mut input = ParserInput::new(&input_str);
+ input.set_max_name_length(5);
+ let result = input.parse_name();
+ assert!(
+ result.is_err(),
+ "6-byte unicode name should exceed 5-byte limit"
+ );
+
+ let mut input = ParserInput::new(&input_str);
+ input.set_max_name_length(6);
+ assert!(
+ input.parse_name().is_ok(),
+ "6-byte unicode name should fit 6-byte limit"
+ );
+ }
+
+ #[test]
+ fn test_parse_name_eq_length_limit() {
+ let name = "a".repeat(51);
+ let input_str = format!("{name} ");
+ let mut input = ParserInput::new(&input_str);
+ input.set_max_name_length(50);
+ let result = input.parse_name_eq("something");
+ assert!(result.is_err());
+ assert!(result.unwrap_err().message.contains("name length"));
+ }
+
+ #[test]
+ fn test_parse_name_eq_parts_length_limit() {
+ let name = "a".repeat(51);
+ let input_str = format!("{name} ");
+ let mut input = ParserInput::new(&input_str);
+ input.set_max_name_length(50);
+ let result = input.parse_name_eq_parts(None, "something");
+ assert!(result.is_err());
+ assert!(result.unwrap_err().message.contains("name length"));
+ }
+
+ // -- Comment boundary edge cases --
+
+ #[test]
+ fn test_comment_double_dash_rejected() {
+ // `--` inside a comment is not allowed per XML 1.0 §2.5
+ let mut input = ParserInput::new("<!-- bad -- comment -->");
+ let result = parse_comment_content(&mut input);
+ assert!(result.is_err());
+ assert!(
+ result.unwrap_err().message.contains("'--' not allowed"),
+ "double dash inside comment should be rejected"
+ );
+ }
+
+ #[test]
+ fn test_comment_double_dash_recovery() {
+ let mut input = ParserInput::new("<!-- bad -- comment -->");
+ input.set_recover(true);
+ let content = parse_comment_content(&mut input).unwrap();
+ assert!(content.contains("--"));
+ assert!(!input.diagnostics.is_empty());
+ }
+
+ #[test]
+ fn test_comment_unterminated() {
+ let mut input = ParserInput::new("<!-- no end");
+ let result = parse_comment_content(&mut input);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("unexpected end of input in comment"));
+ }
+
+ #[test]
+ fn test_comment_empty() {
+ let mut input = ParserInput::new("<!---->");
+ let content = parse_comment_content(&mut input).unwrap();
+ assert_eq!(content, "");
+ }
+
+ #[test]
+ fn test_comment_single_dash_allowed() {
+ // A single dash followed by a non-dash is allowed in comments
+ let mut input = ParserInput::new("<!-- a - b -->");
+ let content = parse_comment_content(&mut input).unwrap();
+ assert_eq!(content, " a - b ");
+ }
+
+ #[test]
+ fn test_comment_ending_with_triple_dash_rejected() {
+ // `<!--- --->` contains `--` followed by `->`, which means
+ // the `--` appears inside the comment (the comment ends at `-->`)
+ let mut input = ParserInput::new("<!----->");
+ let result = parse_comment_content(&mut input);
+ // The scanner finds `--` at position 0 inside the comment content,
+ // but then sees `-->` — this is actually `--` + `>` which is "--->"
+ // meaning the content is "-" and there is a bare "--" before the `>`.
+ assert!(
+ result.is_err() || {
+ // In recovery mode it might succeed with a diagnostic
+ false
+ }
+ );
+ }
+
+ // -- CDATA boundary edge cases --
+
+ #[test]
+ fn test_cdata_unterminated() {
+ let mut input = ParserInput::new("<![CDATA[no end");
+ let result = parse_cdata_content(&mut input);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("unexpected end of input in CDATA"));
+ }
+
+ #[test]
+ fn test_cdata_empty() {
+ let mut input = ParserInput::new("<![CDATA[]]]]><![CDATA[>");
+ let content = parse_cdata_content(&mut input).unwrap();
+ assert_eq!(content, "");
+ }
+
+ #[test]
+ fn test_cdata_with_angle_brackets() {
+ // CDATA sections can contain < and > freely
+ let mut input = ParserInput::new("<![CDATA[<div>hello</div>]]]]><![CDATA[>");
+ let content = parse_cdata_content(&mut input).unwrap();
+ assert_eq!(content, "<div>hello</div>");
+ }
+
+ #[test]
+ fn test_cdata_with_double_bracket_not_terminator() {
+ // `]]` without `>` should not end the CDATA section
+ let mut input = ParserInput::new("<![CDATA[a]]b]]]]><![CDATA[>");
+ let content = parse_cdata_content(&mut input).unwrap();
+ assert_eq!(content, "a]]b");
+ }
+
+ #[test]
+ fn test_cdata_with_ampersand() {
+ // Entity references are NOT expanded in CDATA sections
+ let mut input = ParserInput::new("<![CDATA[& <]]]]><![CDATA[>");
+ let content = parse_cdata_content(&mut input).unwrap();
+ assert_eq!(content, "& <");
+ }
+
+ // -- Processing instruction boundary edge cases --
+
+ #[test]
+ fn test_pi_target_xml_reserved() {
+ let mut input = ParserInput::new("<?xml data?>");
+ let result = parse_pi_content(&mut input);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("PI target 'xml' is reserved"));
+ }
+
+ #[test]
+ fn test_pi_target_xml_case_insensitive() {
+ // "XML", "Xml", etc. should all be reserved
+ for target in ["XML", "Xml", "xMl", "xmL"] {
+ let pi = format!("<?{target} data?>");
+ let mut input = ParserInput::new(&pi);
+ let result = parse_pi_content(&mut input);
+ assert!(result.is_err(), "PI target '{target}' should be reserved");
+ }
+ }
+
+ #[test]
+ fn test_pi_target_with_colon_rejected() {
+ let mut input = ParserInput::new("<?ns:target data?>");
+ let result = parse_pi_content(&mut input);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("must not contain a colon"));
+ }
+
+ #[test]
+ fn test_pi_unterminated() {
+ let mut input = ParserInput::new("<?target no end");
+ let result = parse_pi_content(&mut input);
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_pi_empty_data_after_whitespace() {
+ let mut input = ParserInput::new("<?target ?>");
+ let (target, data) = parse_pi_content(&mut input).unwrap();
+ assert_eq!(target, "target");
+ assert_eq!(data, None); // whitespace only, no real data
+ }
+
+ // -- Attribute value security edge cases --
+
+ #[test]
+ fn test_attribute_value_less_than_rejected() {
+ // `<` is not allowed in attribute values per XML 1.0 §3.1
+ let mut input = ParserInput::new("\"abc<def\"");
+ let result = input.parse_attribute_value();
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("'<' not allowed in attribute values"));
+ }
+
+ #[test]
+ fn test_attribute_value_unterminated() {
+ let mut input = ParserInput::new("\"no closing quote");
+ let result = input.parse_attribute_value();
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("unexpected end of input"));
+ }
+
+ #[test]
+ fn test_attribute_value_not_quoted() {
+ let mut input = ParserInput::new("unquoted");
+ let result = input.parse_attribute_value();
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("attribute value must be quoted"));
+ }
+
+ #[test]
+ fn test_attribute_value_single_quotes() {
+ let mut input = ParserInput::new("'hello'");
+ let value = input.parse_attribute_value().unwrap();
+ assert_eq!(value, "hello");
+ }
+
+ #[test]
+ fn test_attribute_value_entity_with_less_than_rejected() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // Entity whose replacement text contains '<' is rejected
+ // per WFC: No < in Attribute Values
+ let xml = r#"<!DOCTYPE r [
+<!ENTITY bad "a<b">
+]>
+<r a="&bad;"/>"#;
+ // Note: < in the entity value is expanded to <, which is then
+ // found in the attribute value. Whether this triggers the WFC check
+ // depends on the implementation's handling of nested expansion.
+ // This test verifies the parser has SOME handling for this case.
+ let result = parse_str_with_options(xml, &ParseOptions::default());
+ // The entity "bad" contains "<" which expands to "<".
+ // This "<" in attribute value should be caught.
+ assert!(result.is_err());
+ }
+
+ // -- Invalid XML character detection --
+
+ #[test]
+ fn test_is_xml_char_boundary_values() {
+ // Valid boundary values
+ assert!(is_xml_char('\t')); // U+0009
+ assert!(is_xml_char('\n')); // U+000A
+ assert!(is_xml_char('\r')); // U+000D
+ assert!(is_xml_char(' ')); // U+0020
+ assert!(is_xml_char('\u{D7FF}'));
+ assert!(is_xml_char('\u{E000}'));
+ assert!(is_xml_char('\u{FFFD}'));
+ assert!(is_xml_char('\u{10000}'));
+ assert!(is_xml_char('\u{10FFFF}'));
+
+ // Invalid boundary values
+ assert!(!is_xml_char('\0')); // U+0000
+ assert!(!is_xml_char('\u{0001}')); // U+0001
+ assert!(!is_xml_char('\u{0008}')); // U+0008
+ assert!(!is_xml_char('\u{000B}')); // U+000B
+ assert!(!is_xml_char('\u{000C}')); // U+000C
+ assert!(!is_xml_char('\u{000E}')); // U+000E
+ assert!(!is_xml_char('\u{001F}')); // U+001F
+ assert!(!is_xml_char('\u{FFFE}')); // U+FFFE
+ assert!(!is_xml_char('\u{FFFF}')); // U+FFFF
+ }
+
+ #[test]
+ fn test_next_char_rejects_control_characters() {
+ // U+0001 (SOH) is an invalid XML character
+ let input_bytes = "\x01";
+ let mut input = ParserInput::new(input_bytes);
+ let result = input.next_char();
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("invalid XML character"));
+ }
+
+ #[test]
+ fn test_next_char_control_char_recovery() {
+ let input_bytes = "\x01X";
+ let mut input = ParserInput::new(input_bytes);
+ input.set_recover(true);
+ // In recovery mode, control chars produce diagnostics but parsing continues
+ let ch = input.next_char().unwrap();
+ assert_eq!(ch, '\x01');
+ assert!(!input.diagnostics.is_empty());
+ // Next character should work fine
+ assert_eq!(input.next_char().unwrap(), 'X');
+ }
+
+ // -- Scan boundary edge cases --
+
+ #[test]
+ fn test_scan_char_data_cdata_end_marker() {
+ // `]]]]><![CDATA[>` in character data is not allowed — the scanner should stop before it
+ let input = ParserInput::new("text]]]]><![CDATA[>more");
+ let len = input.scan_char_data();
+ assert_eq!(len, 4); // stops before `]]]]><![CDATA[>`
+ }
+
+ #[test]
+ fn test_scan_char_data_empty() {
+ let input = ParserInput::new("<");
+ assert_eq!(input.scan_char_data(), 0);
+ }
+
+ #[test]
+ fn test_scan_char_data_stops_at_ampersand() {
+ let input = ParserInput::new("text&ref;");
+ assert_eq!(input.scan_char_data(), 4);
+ }
+
+ #[test]
+ fn test_scan_char_data_stops_at_less_than() {
+ let input = ParserInput::new("text<elem");
+ assert_eq!(input.scan_char_data(), 4);
+ }
+
+ #[test]
+ fn test_scan_for_2byte_terminator_at_end() {
+ // Input too short for any 2-byte terminator
+ let input = ParserInput::new("x");
+ assert_eq!(input.scan_for_2byte_terminator(b'-', b'-'), None);
+ }
+
+ #[test]
+ fn test_scan_for_2byte_terminator_exact_2_bytes() {
+ let input = ParserInput::new("--");
+ assert_eq!(input.scan_for_2byte_terminator(b'-', b'-'), Some(0));
+ }
+
+ #[test]
+ fn test_scan_for_3byte_terminator_at_end() {
+ let input = ParserInput::new("]]");
+ assert_eq!(input.scan_for_3byte_terminator(b']', b']', b'>'), None);
+ }
+
+ #[test]
+ fn test_scan_for_3byte_terminator_exact_3_bytes() {
+ let input = ParserInput::new("]]]]><![CDATA[>");
+ assert_eq!(input.scan_for_3byte_terminator(b']', b']', b'>'), Some(0));
+ }
+
+ // -- Namespace resolution edge cases --
+
+ #[test]
+ fn test_namespace_resolver_nested_override() {
+ let mut ns = NamespaceResolver::new();
+ ns.push_scope();
+ ns.bind(Some("p".to_string()), "http://outer".to_string());
+ assert_eq!(ns.resolve(Some("p")), Some("http://outer"));
+
+ // Inner scope overrides the same prefix
+ ns.push_scope();
+ ns.bind(Some("p".to_string()), "http://inner".to_string());
+ assert_eq!(ns.resolve(Some("p")), Some("http://inner"));
+
+ // After popping, outer binding is restored
+ ns.pop_scope();
+ assert_eq!(ns.resolve(Some("p")), Some("http://outer"));
+
+ ns.pop_scope();
+ assert_eq!(ns.resolve(Some("p")), None);
+ }
+
+ #[test]
+ fn test_namespace_resolver_default_ns_override_and_restore() {
+ let mut ns = NamespaceResolver::new();
+ ns.push_scope();
+ ns.bind(None, "http://a".to_string());
+ ns.push_scope();
+ ns.bind(None, "http://b".to_string());
+ assert_eq!(ns.resolve(None), Some("http://b"));
+ ns.pop_scope();
+ assert_eq!(ns.resolve(None), Some("http://a"));
+ ns.pop_scope();
+ assert_eq!(ns.resolve(None), None);
+ }
+
+ #[test]
+ fn test_namespace_resolver_undeclare_default_then_redeclare() {
+ let mut ns = NamespaceResolver::new();
+ ns.push_scope();
+ ns.bind(None, "http://ns".to_string());
+ ns.push_scope();
+ ns.bind(None, String::new()); // undeclare
+ assert_eq!(ns.resolve(None), None);
+ ns.push_scope();
+ ns.bind(None, "http://new".to_string()); // re-declare
+ assert_eq!(ns.resolve(None), Some("http://new"));
+ ns.pop_scope();
+ assert_eq!(ns.resolve(None), None); // back to undeclared
+ ns.pop_scope();
+ assert_eq!(ns.resolve(None), Some("http://ns")); // original
+ ns.pop_scope();
+ assert_eq!(ns.resolve(None), None);
+ }
+
+ #[test]
+ fn test_namespace_resolver_xml_prefix_always_bound() {
+ let ns = NamespaceResolver::new();
+ assert_eq!(ns.resolve(Some("xml")), Some(XML_NAMESPACE));
+ }
+
+ #[test]
+ fn test_namespace_resolver_unbound_prefix() {
+ let ns = NamespaceResolver::new();
+ assert_eq!(ns.resolve(Some("foo")), None);
+ assert_eq!(ns.resolve(Some("xmlns")), None);
+ }
+
+ #[test]
+ fn test_namespace_resolver_many_scopes() {
+ // Stress test: push and pop many scopes with bindings
+ let mut ns = NamespaceResolver::new();
+ for i in 0..100 {
+ ns.push_scope();
+ ns.bind(Some("p".to_string()), format!("http://ns/{i}"));
+ }
+ assert_eq!(ns.resolve(Some("p")), Some("http://ns/99"));
+ for i in (0..100).rev() {
+ ns.pop_scope();
+ if i > 0 {
+ let expected = format!("http://ns/{}", i - 1);
+ assert_eq!(ns.resolve(Some("p")), Some(expected.as_str()));
+ }
+ }
+ assert_eq!(ns.resolve(Some("p")), None);
+ }
+
+ // -- QName validation edge cases --
+
+ #[test]
+ fn test_validate_qname_valid() {
+ assert_eq!(validate_qname("foo"), None);
+ assert_eq!(validate_qname("ns:local"), None);
+ assert_eq!(validate_qname("a"), None);
+ }
+
+ #[test]
+ fn test_validate_qname_multiple_colons() {
+ let result = validate_qname("a:b:c");
+ assert!(result.is_some());
+ assert!(result.unwrap().contains("multiple colons"));
+ }
+
+ #[test]
+ fn test_validate_qname_empty_prefix() {
+ let result = validate_qname(":local");
+ assert!(result.is_some());
+ assert!(result.unwrap().contains("empty prefix or local part"));
+ }
+
+ #[test]
+ fn test_validate_qname_empty_local() {
+ let result = validate_qname("prefix:");
+ assert!(result.is_some());
+ assert!(result.unwrap().contains("empty prefix or local part"));
+ }
+
+ // -- split_owned_name edge cases --
+
+ #[test]
+ fn test_split_owned_name_with_prefix() {
+ let (prefix, local) = split_owned_name("ns:elem".to_string());
+ assert_eq!(prefix.as_deref(), Some("ns"));
+ assert_eq!(local, "elem");
+ }
+
+ #[test]
+ fn test_split_owned_name_no_prefix() {
+ let (prefix, local) = split_owned_name("elem".to_string());
+ assert_eq!(prefix, None);
+ assert_eq!(local, "elem");
+ }
+
+ // -- pubid validation edge cases --
+
+ #[test]
+ fn test_validate_pubid_valid() {
+ assert_eq!(validate_pubid("-//W3C//DTD XML 1.0//EN"), None);
+ }
+
+ #[test]
+ fn test_validate_pubid_invalid_char() {
+ let result = validate_pubid("bad\x01char");
+ assert!(result.is_some());
+ assert!(result.unwrap().contains("invalid character"));
+ }
+
+ // -- XML declaration edge cases --
+
+ #[test]
+ fn test_xml_decl_invalid_version() {
+ let mut input = ParserInput::new("<?xml version=\"2.0\"?>");
+ let result = parse_xml_decl(&mut input);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("invalid version number"));
+ }
+
+ #[test]
+ fn test_xml_decl_invalid_encoding() {
+ let mut input = ParserInput::new("<?xml version=\"1.0\" encoding=\"123bad\"?>");
+ let result = parse_xml_decl(&mut input);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("invalid encoding name"));
+ }
+
+ #[test]
+ fn test_xml_decl_standalone_invalid() {
+ let mut input = ParserInput::new("<?xml version=\"1.0\" standalone=\"maybe\"?>");
+ let result = parse_xml_decl(&mut input);
+ assert!(result.is_err());
+ assert!(result
+ .unwrap_err()
+ .message
+ .contains("standalone must be 'yes' or 'no'"));
+ }
+
+ #[test]
+ fn test_xml_decl_standalone_no() {
+ let mut input = ParserInput::new("<?xml version=\"1.0\" standalone=\"no\"?>");
+ let decl = parse_xml_decl(&mut input).unwrap();
+ assert_eq!(decl.standalone, Some(false));
+ }
+
+ // -- Position save/restore edge cases --
+
+ #[test]
+ fn test_save_restore_position() {
+ let mut input = ParserInput::new("abcdef");
+ input.advance(3);
+ assert_eq!(input.peek(), Some(b'd'));
+ let saved = input.save_position();
+ input.advance(2);
+ assert_eq!(input.peek(), Some(b'f'));
+ input.restore_position(saved);
+ assert_eq!(input.peek(), Some(b'd'));
+ assert_eq!(input.location().column, 4); // restored column
+ }
+
+ // -- Depth limit via full parser (integration-level, but testing
+ // the boundary precisely through the public API) --
+
+ #[test]
+ fn test_depth_limit_via_parse_str_with_options() {
+ use crate::parser::{parse_str_with_options, ParseOptions};
+ // 3 levels with limit 3 should succeed
+ let xml = "<a><b><c/></b></a>";
+ let opts = ParseOptions::default().max_depth(3);
+ assert!(parse_str_with_options(xml, &opts).is_ok());
+
+ // 4 levels with limit 3 should fail
+ let xml = "<a><b><c><d/></c></b></a>";
+ let result = parse_str_with_options(xml, &opts);
+ assert!(result.is_err());
+ assert!(result.unwrap_err().message.contains("depth"));
+ }
+
+ // -- Builtin entity matching edge cases --
+
+ #[test]
+ fn test_match_builtin_entity_all() {
+ assert_eq!(match_builtin_entity(b"amp;"), Some(("&", 4)));
+ assert_eq!(match_builtin_entity(b"lt;"), Some(("<", 3)));
+ assert_eq!(match_builtin_entity(b"gt;"), Some((">", 3)));
+ assert_eq!(match_builtin_entity(b"apos;"), Some(("'", 5)));
+ assert_eq!(match_builtin_entity(b"quot;"), Some(("\"", 5)));
+ }
+
+ #[test]
+ fn test_match_builtin_entity_partial_no_match() {
+ // Partial matches should return None
+ assert_eq!(match_builtin_entity(b"am"), None);
+ assert_eq!(match_builtin_entity(b"l"), None);
+ assert_eq!(match_builtin_entity(b"apo"), None);
+ assert_eq!(match_builtin_entity(b"quo"), None);
+ }
+
+ #[test]
+ fn test_match_builtin_entity_unknown() {
+ assert_eq!(match_builtin_entity(b"foo;"), None);
+ assert_eq!(match_builtin_entity(b""), None);
+ assert_eq!(match_builtin_entity(b"x"), None);
+ }
+
+ // -- expand_entity_text security: nested entity expansion limit --
+
+ #[test]
+ fn test_expand_entity_text_counts_against_limit() {
+ // Set up a ParserInput with entity_map containing nested references
+ let mut input = ParserInput::new("");
+ input
+ .entity_map
+ .insert("a".to_string(), "hello".to_string());
+ input
+ .entity_map
+ .insert("b".to_string(), "&a; &a;".to_string());
+ input.set_max_entity_expansions(2);
+
+ // Expanding "b" should expand &a; twice, hitting the limit
+ let result = input.expand_entity_text("&b;");
+ // "b" expands to "&a; &a;", then each &a; expansion counts.
+ // Entity count: 1 (for b) + 1 (first a) + 1 (second a) = 3 > 2
+ // But note: expand_entity_text doesn't count the outer reference
+ // itself, only the inner ones. Let's verify the behavior:
+ // The first &a; increments to 1, second &a; to 2, and on the
+ // next call (which would be the &b; reference) it would hit the limit.
+ // Actually, expand_entity_text handles the inner references only.
+ // The outer reference (&b;) was already counted by the caller.
+ // With limit=2, the inner &a; references (2 of them) exactly hit the limit.
+ assert!(
+ result.is_ok() || result.is_err(),
+ "expansion should either succeed at limit or fail over limit"
+ );
+ }
+
+ #[test]
+ fn test_expand_entity_text_no_references() {
+ let mut input = ParserInput::new("");
+ let result = input.expand_entity_text("plain text").unwrap();
+ assert_eq!(result, "plain text");
+ }
+
+ #[test]
+ fn test_expand_entity_text_builtin_entities() {
+ let mut input = ParserInput::new("");
+ let result = input.expand_entity_text("a & b < c").unwrap();
+ assert_eq!(result, "a & b < c");
+ }
+
+ #[test]
+ fn test_expand_entity_text_char_refs() {
+ let mut input = ParserInput::new("");
+ let result = input.expand_entity_text("A B").unwrap();
+ assert_eq!(result, "A B");
+ }
+
+ #[test]
+ fn test_expand_entity_text_unknown_entity_strict() {
+ let mut input = ParserInput::new("");
+ let result = input.expand_entity_text("&unknown;");
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_expand_entity_text_cdata_not_expanded() {
+ let mut input = ParserInput::new("");
+ let result = input
+ .expand_entity_text("<![CDATA[& not expanded]]]]><![CDATA[>")
+ .unwrap();
+ assert_eq!(result, "<![CDATA[& not expanded]]]]><![CDATA[>");
+ }
+
+ // -- find_invalid_xml_char and may_contain_invalid_xml_chars --
+
+ #[test]
+ fn test_find_invalid_xml_char_clean() {
+ assert_eq!(find_invalid_xml_char("hello world"), None);
+ assert_eq!(find_invalid_xml_char("tab\there"), None);
+ assert_eq!(find_invalid_xml_char("newline\nhere"), None);
+ }
+
+ #[test]
+ fn test_find_invalid_xml_char_with_null() {
+ assert_eq!(find_invalid_xml_char("bad\x00char"), Some('\x00'));
+ }
+
+ #[test]
+ fn test_find_invalid_xml_char_with_control() {
+ assert_eq!(find_invalid_xml_char("bad\x01char"), Some('\x01'));
+ assert_eq!(find_invalid_xml_char("bad\x08char"), Some('\x08'));
+ }
+
+ #[test]
+ fn test_may_contain_invalid_xml_chars_fast_check() {
+ assert!(!may_contain_invalid_xml_chars(b"hello world"));
+ assert!(!may_contain_invalid_xml_chars(b"tab\there"));
+ assert!(!may_contain_invalid_xml_chars(b"newline\nhere"));
+ assert!(may_contain_invalid_xml_chars(b"bad\x00char"));
+ assert!(may_contain_invalid_xml_chars(b"bad\x01char"));
+ assert!(may_contain_invalid_xml_chars(b"\x7F")); // DEL
+ }
+}
diff --git a/browser/vendor/xmloxide/src/parser/mod.rs b/browser/vendor/xmloxide/src/parser/mod.rs
new file mode 100644
index 000000000..b0ce7f67f
--- /dev/null
+++ b/browser/vendor/xmloxide/src/parser/mod.rs
@@ -0,0 +1,243 @@
+//! XML 1.0 parser.
+//!
+//! A hand-rolled recursive descent parser conforming to the W3C XML 1.0
+//! (Fifth Edition) specification. The parser builds a `Document` tree and
+//! supports error recovery mode for processing malformed input.
+//!
+//! The parser is hand-rolled (not combinator-based) because:
+//! 1. libxml2's parser is recursive descent and we need identical behavior
+//! 2. Error recovery requires fine-grained control over parse state
+//! 3. Push/incremental parsing requires suspendable state
+//! 4. Performance — no abstraction overhead
+
+pub(crate) mod input;
+pub mod push;
+mod xml;
+
+pub use push::PushParser;
+
+use std::sync::Arc;
+
+use crate::error::ParseError;
+use crate::tree::Document;
+
+use input::{
+ DEFAULT_MAX_ATTRIBUTES, DEFAULT_MAX_ATTRIBUTE_LENGTH, DEFAULT_MAX_DEPTH,
+ DEFAULT_MAX_ENTITY_EXPANSIONS, DEFAULT_MAX_NAME_LENGTH, DEFAULT_MAX_TEXT_LENGTH,
+};
+
+/// A request to resolve an external entity.
+///
+/// Passed to the [`EntityResolver`] callback when the parser encounters
+/// a reference to an externally-declared entity (SYSTEM or PUBLIC).
+#[derive(Debug)]
+pub struct ExternalEntityRequest<'a> {
+ /// The entity name as declared in the DTD.
+ pub name: &'a str,
+ /// The SYSTEM identifier (URI) from the entity declaration.
+ pub system_id: &'a str,
+ /// The PUBLIC identifier from the entity declaration, if any.
+ pub public_id: Option<&'a str>,
+}
+
+/// A callback for resolving external entities.
+///
+/// Returns `Some(replacement_text)` to expand the entity, or `None` to
+/// reject the reference (which will produce a parse error or, in recovery
+/// mode, an empty expansion).
+///
+/// # Security
+///
+/// **Warning:** Enabling external entity resolution opens the door to
+/// XML External Entity (XXE) attacks. Only use this with trusted input,
+/// and consider restricting which URIs the resolver is willing to fetch.
+pub type EntityResolver = Arc<dyn Fn(ExternalEntityRequest<'_>) -> Option<String> + Send + Sync>;
+
+/// Parse options controlling parser behavior and security limits.
+///
+/// Use the builder pattern to configure options:
+///
+/// ```
+/// use xmloxide::parser::ParseOptions;
+///
+/// let opts = ParseOptions::default()
+/// .recover(true)
+/// .no_blanks(true)
+/// .max_depth(128);
+/// ```
+pub struct ParseOptions {
+ /// If true, attempt to recover from errors and produce a partial tree.
+ pub recover: bool,
+ /// If true, strip ignorable whitespace-only text nodes.
+ pub no_blanks: bool,
+
+ // -- Security limits --
+ /// Maximum element nesting depth (default: 256).
+ pub max_depth: u32,
+ /// Maximum number of attributes on a single element (default: 256).
+ pub max_attributes: u32,
+ /// Maximum length in bytes of a single attribute value (default: 10 MB).
+ pub max_attribute_length: usize,
+ /// Maximum length in bytes of a single text node (default: 10 MB).
+ pub max_text_length: usize,
+ /// Maximum length in bytes of an element or attribute name (default: 50,000).
+ pub max_name_length: usize,
+ /// Maximum number of entity reference expansions per document (default: 10,000).
+ pub max_entity_expansions: u32,
+ /// Optional callback for resolving external entities.
+ ///
+ /// When set, references to externally-declared entities (SYSTEM/PUBLIC)
+ /// are passed to this resolver instead of producing an error. See
+ /// [`EntityResolver`] for security considerations.
+ pub entity_resolver: Option<EntityResolver>,
+}
+
+impl Clone for ParseOptions {
+ fn clone(&self) -> Self {
+ Self {
+ recover: self.recover,
+ no_blanks: self.no_blanks,
+ max_depth: self.max_depth,
+ max_attributes: self.max_attributes,
+ max_attribute_length: self.max_attribute_length,
+ max_text_length: self.max_text_length,
+ max_name_length: self.max_name_length,
+ max_entity_expansions: self.max_entity_expansions,
+ entity_resolver: self.entity_resolver.clone(),
+ }
+ }
+}
+
+impl std::fmt::Debug for ParseOptions {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("ParseOptions")
+ .field("recover", &self.recover)
+ .field("no_blanks", &self.no_blanks)
+ .field("max_depth", &self.max_depth)
+ .field("max_attributes", &self.max_attributes)
+ .field("max_attribute_length", &self.max_attribute_length)
+ .field("max_text_length", &self.max_text_length)
+ .field("max_name_length", &self.max_name_length)
+ .field("max_entity_expansions", &self.max_entity_expansions)
+ .field(
+ "entity_resolver",
+ &self.entity_resolver.as_ref().map(|_| "..."),
+ )
+ .finish()
+ }
+}
+
+impl Default for ParseOptions {
+ fn default() -> Self {
+ Self {
+ recover: false,
+ no_blanks: false,
+ max_depth: DEFAULT_MAX_DEPTH,
+ max_attributes: DEFAULT_MAX_ATTRIBUTES,
+ max_attribute_length: DEFAULT_MAX_ATTRIBUTE_LENGTH,
+ max_text_length: DEFAULT_MAX_TEXT_LENGTH,
+ max_name_length: DEFAULT_MAX_NAME_LENGTH,
+ max_entity_expansions: DEFAULT_MAX_ENTITY_EXPANSIONS,
+ entity_resolver: None,
+ }
+ }
+}
+
+impl ParseOptions {
+ /// Enables or disables error recovery mode.
+ #[must_use]
+ pub fn recover(mut self, yes: bool) -> Self {
+ self.recover = yes;
+ self
+ }
+
+ /// Enables or disables stripping of blank text nodes.
+ #[must_use]
+ pub fn no_blanks(mut self, yes: bool) -> Self {
+ self.no_blanks = yes;
+ self
+ }
+
+ /// Sets the maximum element nesting depth.
+ #[must_use]
+ pub fn max_depth(mut self, max: u32) -> Self {
+ self.max_depth = max;
+ self
+ }
+
+ /// Sets the maximum number of attributes per element.
+ #[must_use]
+ pub fn max_attributes(mut self, max: u32) -> Self {
+ self.max_attributes = max;
+ self
+ }
+
+ /// Sets the maximum attribute value length in bytes.
+ #[must_use]
+ pub fn max_attribute_length(mut self, max: usize) -> Self {
+ self.max_attribute_length = max;
+ self
+ }
+
+ /// Sets the maximum text node length in bytes.
+ #[must_use]
+ pub fn max_text_length(mut self, max: usize) -> Self {
+ self.max_text_length = max;
+ self
+ }
+
+ /// Sets the maximum element/attribute name length in bytes.
+ #[must_use]
+ pub fn max_name_length(mut self, max: usize) -> Self {
+ self.max_name_length = max;
+ self
+ }
+
+ /// Sets the maximum number of entity reference expansions.
+ #[must_use]
+ pub fn max_entity_expansions(mut self, max: u32) -> Self {
+ self.max_entity_expansions = max;
+ self
+ }
+
+ /// Sets the external entity resolver callback.
+ ///
+ /// When set, references to externally-declared entities (SYSTEM/PUBLIC)
+ /// are passed to this callback for resolution. The callback receives an
+ /// [`ExternalEntityRequest`] and should return `Some(replacement_text)`
+ /// to expand the entity, or `None` to reject the reference.
+ ///
+ /// # Security
+ ///
+ /// **Warning:** Enabling external entity resolution opens the door to
+ /// XML External Entity (XXE) attacks. Only use this with trusted input,
+ /// and consider restricting which URIs the resolver is willing to fetch.
+ #[must_use]
+ pub fn entity_resolver(
+ mut self,
+ resolver: impl Fn(ExternalEntityRequest<'_>) -> Option<String> + Send + Sync + 'static,
+ ) -> Self {
+ self.entity_resolver = Some(Arc::new(resolver));
+ self
+ }
+}
+
+/// Parses an XML string with default options.
+///
+/// # Errors
+///
+/// Returns `ParseError` if the input is not well-formed XML.
+pub fn parse_str(input: &str) -> Result<Document, ParseError> {
+ parse_str_with_options(input, &ParseOptions::default())
+}
+
+/// Parses an XML string with the given options.
+///
+/// # Errors
+///
+/// Returns `ParseError` if the input is not well-formed XML and recovery
+/// mode is not enabled.
+pub fn parse_str_with_options(input: &str, options: &ParseOptions) -> Result<Document, ParseError> {
+ let mut parser = xml::XmlParser::new(input, options);
+ parser.parse()
+}
diff --git a/browser/vendor/xmloxide/src/parser/push.rs b/browser/vendor/xmloxide/src/parser/push.rs
new file mode 100644
index 000000000..a3f147d5b
--- /dev/null
+++ b/browser/vendor/xmloxide/src/parser/push.rs
@@ -0,0 +1,509 @@
+//! Push/incremental XML parser.
+//!
+//! Provides a chunk-oriented parsing interface inspired by libxml2's push parser
+//! (`xmlCreatePushParserCtxt` / `xmlParseChunk`). Data can be fed to the parser
+//! in arbitrarily sized chunks via [`PushParser::push`], and the final document
+//! is obtained by calling [`PushParser::finish`].
+//!
+//! This is useful for scenarios where XML data arrives incrementally, such as
+//! reading from a network socket or streaming from another process.
+//!
+//! # Design
+//!
+//! The current implementation buffers all pushed data internally and performs
+//! the full parse on [`PushParser::finish`]. This provides correct chunk-boundary
+//! handling with minimal complexity. A future optimization may parse eagerly
+//! after each [`PushParser::push`] call.
+//!
+//! # Examples
+//!
+//! ```
+//! use xmloxide::parser::PushParser;
+//!
+//! let mut parser = PushParser::new();
+//! parser.push(b"<root>");
+//! parser.push(b"<child>Hello</child>");
+//! parser.push(b"</root>");
+//!
+//! let doc = parser.finish().unwrap();
+//! let root = doc.root_element().unwrap();
+//! assert_eq!(doc.node_name(root), Some("root"));
+//! ```
+
+use crate::encoding::decode_to_utf8;
+use crate::error::{ParseError, SourceLocation};
+use crate::parser::ParseOptions;
+use crate::tree::Document;
+
+/// A push-based (incremental) XML parser.
+///
+/// Accepts XML data in arbitrarily sized chunks and builds a [`Document`] tree
+/// when parsing is finalized. This mirrors libxml2's push parser interface
+/// (`xmlCreatePushParserCtxt` / `xmlParseChunk`).
+///
+/// # Construction
+///
+/// Use [`PushParser::new`] for default options, or [`PushParser::with_options`]
+/// to configure parser behavior.
+///
+/// # Examples
+///
+/// Basic usage with multiple chunks:
+///
+/// ```
+/// use xmloxide::parser::PushParser;
+///
+/// let mut parser = PushParser::new();
+/// parser.push(b"<?xml version=\"1.0\"?>");
+/// parser.push(b"<root attr=\"value\">");
+/// parser.push(b"Hello, world!");
+/// parser.push(b"</root>");
+///
+/// let doc = parser.finish().unwrap();
+/// let root = doc.root_element().unwrap();
+/// assert_eq!(doc.node_name(root), Some("root"));
+/// assert_eq!(doc.text_content(root), "Hello, world!");
+/// ```
+///
+/// With parse options:
+///
+/// ```
+/// use xmloxide::parser::{ParseOptions, PushParser};
+///
+/// let opts = ParseOptions::default().recover(true);
+/// let mut parser = PushParser::with_options(opts);
+/// parser.push(b"<root>");
+/// parser.push(b"</root>");
+///
+/// let doc = parser.finish().unwrap();
+/// assert!(doc.root_element().is_some());
+/// ```
+pub struct PushParser {
+ /// Accumulated raw bytes from all `push()` calls.
+ buffer: Vec<u8>,
+ /// Parser options.
+ options: ParseOptions,
+ /// Whether `finish()` has already been called.
+ finished: bool,
+}
+
+impl PushParser {
+ /// Creates a new push parser with default options.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::parser::PushParser;
+ ///
+ /// let mut parser = PushParser::new();
+ /// parser.push(b"<root/>");
+ /// let doc = parser.finish().unwrap();
+ /// ```
+ #[must_use]
+ pub fn new() -> Self {
+ Self {
+ buffer: Vec::new(),
+ options: ParseOptions::default(),
+ finished: false,
+ }
+ }
+
+ /// Creates a new push parser with the specified options.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::parser::{ParseOptions, PushParser};
+ ///
+ /// let parser = PushParser::with_options(
+ /// ParseOptions::default().recover(true).no_blanks(true),
+ /// );
+ /// ```
+ #[must_use]
+ pub fn with_options(options: ParseOptions) -> Self {
+ Self {
+ buffer: Vec::new(),
+ options,
+ finished: false,
+ }
+ }
+
+ /// Feeds a chunk of raw XML bytes into the parser.
+ ///
+ /// Data is accumulated in an internal buffer. The chunk can be any size
+ /// and may split tokens, elements, or even multi-byte characters at
+ /// arbitrary boundaries.
+ ///
+ /// # Panics
+ ///
+ /// Panics if called after [`finish`](PushParser::finish) has been invoked.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::parser::PushParser;
+ ///
+ /// let mut parser = PushParser::new();
+ /// parser.push(b"<ro");
+ /// parser.push(b"ot/>");
+ /// let doc = parser.finish().unwrap();
+ /// ```
+ pub fn push(&mut self, data: &[u8]) {
+ assert!(
+ !self.finished,
+ "push() called after finish() — parser has already been consumed"
+ );
+ self.buffer.extend_from_slice(data);
+ }
+
+ /// Finalizes parsing and returns the constructed [`Document`].
+ ///
+ /// This consumes the parser. All buffered data is decoded (with automatic
+ /// encoding detection) and parsed as a complete XML document.
+ ///
+ /// # Errors
+ ///
+ /// Returns [`ParseError`] if the accumulated data is not well-formed XML
+ /// (unless recovery mode is enabled via [`ParseOptions::recover`]).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::parser::PushParser;
+ ///
+ /// let mut parser = PushParser::new();
+ /// parser.push(b"<root><child/></root>");
+ /// let doc = parser.finish().unwrap();
+ /// ```
+ pub fn finish(mut self) -> Result<Document, ParseError> {
+ self.finished = true;
+
+ let utf8 = decode_to_utf8(&self.buffer).map_err(|e| ParseError {
+ message: e.message,
+ location: SourceLocation::default(),
+ diagnostics: Vec::new(),
+ })?;
+
+ crate::parser::parse_str_with_options(&utf8, &self.options)
+ }
+
+ /// Returns the number of bytes currently buffered.
+ ///
+ /// This is the total number of bytes received via [`push`](PushParser::push)
+ /// that have not yet been parsed (parsing occurs on [`finish`](PushParser::finish)).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::parser::PushParser;
+ ///
+ /// let mut parser = PushParser::new();
+ /// assert_eq!(parser.buffered_bytes(), 0);
+ /// parser.push(b"<root/>");
+ /// assert_eq!(parser.buffered_bytes(), 7);
+ /// ```
+ #[must_use]
+ pub fn buffered_bytes(&self) -> usize {
+ self.buffer.len()
+ }
+
+ /// Returns `true` if no data has been pushed yet.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::parser::PushParser;
+ ///
+ /// let mut parser = PushParser::new();
+ /// assert!(parser.is_empty());
+ /// parser.push(b"<root/>");
+ /// assert!(!parser.is_empty());
+ /// ```
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.buffer.is_empty()
+ }
+
+ /// Resets the parser, discarding all buffered data.
+ ///
+ /// After calling this method, the parser is in the same state as a
+ /// newly created one (with the same options). This allows reusing
+ /// the parser for a new document without allocating a new instance.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::parser::PushParser;
+ ///
+ /// let mut parser = PushParser::new();
+ /// parser.push(b"<root/>");
+ /// parser.reset();
+ /// assert!(parser.is_empty());
+ /// parser.push(b"<other/>");
+ /// let doc = parser.finish().unwrap();
+ /// ```
+ pub fn reset(&mut self) {
+ self.buffer.clear();
+ self.finished = false;
+ }
+}
+
+impl Default for PushParser {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl std::fmt::Debug for PushParser {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct("PushParser")
+ .field("buffered_bytes", &self.buffer.len())
+ .field("options", &self.options)
+ .field("finished", &self.finished)
+ .finish()
+ }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_push_parser_single_chunk() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root/>");
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+
+ #[test]
+ fn test_push_parser_multiple_chunks() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root>");
+ parser.push(b"<child>text</child>");
+ parser.push(b"</root>");
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(child), Some("child"));
+ assert_eq!(doc.text_content(child), "text");
+ }
+
+ #[test]
+ fn test_push_parser_split_token() {
+ // Split an element tag across chunk boundaries.
+ let mut parser = PushParser::new();
+ parser.push(b"<ro");
+ parser.push(b"ot att");
+ parser.push(b"r=\"val");
+ parser.push(b"ue\"/>");
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ assert_eq!(doc.attribute(root, "attr"), Some("value"));
+ }
+
+ #[test]
+ fn test_push_parser_byte_at_a_time() {
+ let xml = b"<root><child/></root>";
+ let mut parser = PushParser::new();
+ for &byte in xml {
+ parser.push(&[byte]);
+ }
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(child), Some("child"));
+ }
+
+ #[test]
+ fn test_push_parser_xml_declaration_split() {
+ let mut parser = PushParser::new();
+ parser.push(b"<?xml ver");
+ parser.push(b"sion=\"1.0\" encoding=\"UTF-8\"?>");
+ parser.push(b"<root/>");
+ let doc = parser.finish().unwrap();
+ assert_eq!(doc.version.as_deref(), Some("1.0"));
+ assert_eq!(doc.encoding.as_deref(), Some("UTF-8"));
+ }
+
+ #[test]
+ fn test_push_parser_empty_input() {
+ let parser = PushParser::new();
+ let result = parser.finish();
+ // XML 1.0 §2.1 requires a root element
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_push_parser_with_options_recover() {
+ let opts = ParseOptions::default().recover(true);
+ let mut parser = PushParser::with_options(opts);
+ // Mismatched tags — should succeed in recovery mode.
+ parser.push(b"<a></b>");
+ let result = parser.finish();
+ assert!(result.is_ok());
+ }
+
+ #[test]
+ fn test_push_parser_with_options_no_blanks() {
+ let opts = ParseOptions::default().no_blanks(true);
+ let mut parser = PushParser::with_options(opts);
+ parser.push(b"<root> <child/> </root>");
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ // The blank text nodes (" ") should have been stripped.
+ let children: Vec<_> = doc.children(root).collect();
+ assert_eq!(children.len(), 1);
+ assert_eq!(doc.node_name(children[0]), Some("child"));
+ }
+
+ #[test]
+ fn test_push_parser_error_malformed() {
+ let mut parser = PushParser::new();
+ parser.push(b"<a></b>");
+ let result = parser.finish();
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_push_parser_buffered_bytes() {
+ let mut parser = PushParser::new();
+ assert_eq!(parser.buffered_bytes(), 0);
+ parser.push(b"<root>");
+ assert_eq!(parser.buffered_bytes(), 6);
+ parser.push(b"</root>");
+ assert_eq!(parser.buffered_bytes(), 13);
+ }
+
+ #[test]
+ fn test_push_parser_is_empty() {
+ let mut parser = PushParser::new();
+ assert!(parser.is_empty());
+ parser.push(b"<root/>");
+ assert!(!parser.is_empty());
+ }
+
+ #[test]
+ fn test_push_parser_reset() {
+ let mut parser = PushParser::new();
+ parser.push(b"<invalid");
+ parser.reset();
+ assert!(parser.is_empty());
+ assert_eq!(parser.buffered_bytes(), 0);
+ parser.push(b"<root/>");
+ let doc = parser.finish().unwrap();
+ assert!(doc.root_element().is_some());
+ }
+
+ #[test]
+ fn test_push_parser_default_trait() {
+ let parser = PushParser::default();
+ assert!(parser.is_empty());
+ }
+
+ #[test]
+ fn test_push_parser_debug_trait() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root/>");
+ let debug_str = format!("{parser:?}");
+ assert!(debug_str.contains("PushParser"));
+ assert!(debug_str.contains("buffered_bytes: 7"));
+ }
+
+ #[test]
+ fn test_push_parser_utf8_bom() {
+ let mut parser = PushParser::new();
+ // Push UTF-8 BOM followed by XML.
+ parser.push(b"\xEF\xBB\xBF");
+ parser.push(b"<root/>");
+ let doc = parser.finish().unwrap();
+ assert!(doc.root_element().is_some());
+ }
+
+ #[test]
+ fn test_push_parser_comment_split() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root><!-");
+ parser.push(b"- comment -");
+ parser.push(b"-></root>");
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_text(child), Some(" comment "));
+ }
+
+ #[test]
+ fn test_push_parser_cdata_split() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root><![CDA");
+ parser.push(b"TA[some data]]");
+ parser.push(b"></root>");
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_text(child), Some("some data"));
+ }
+
+ #[test]
+ fn test_push_parser_entity_references() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root>&am");
+ parser.push(b"p; < ></root>");
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "& < >");
+ }
+
+ #[test]
+ fn test_push_parser_roundtrip() {
+ let input = b"<root><child attr=\"val\">text</child></root>";
+ let mut parser = PushParser::new();
+ parser.push(&input[..10]);
+ parser.push(&input[10..25]);
+ parser.push(&input[25..]);
+ let doc = parser.finish().unwrap();
+ let output = crate::serial::serialize(&doc);
+ let expected = format!(
+ "<?xml version=\"1.0\"?>\n{}\n",
+ std::str::from_utf8(input).unwrap()
+ );
+ assert_eq!(output, expected);
+ }
+
+ #[test]
+ #[should_panic(expected = "push() called after finish()")]
+ fn test_push_parser_push_after_finish_panics() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root/>");
+ // Simulate calling push after finish by using an unsafe trick.
+ // Actually we need to keep a reference — but finish() consumes self.
+ // The assertion in push() uses self.finished, so we test indirectly.
+ //
+ // We cannot directly test this because `finish()` takes self by value.
+ // Instead, test the assert fires when finished is set.
+ parser.finished = true;
+ parser.push(b"more data");
+ }
+
+ #[test]
+ fn test_push_parser_large_document() {
+ let mut parser = PushParser::new();
+ parser.push(b"<root>");
+ for i in 0..100 {
+ let chunk = format!("<item id=\"{i}\">value {i}</item>");
+ parser.push(chunk.as_bytes());
+ }
+ parser.push(b"</root>");
+
+ let doc = parser.finish().unwrap();
+ let root = doc.root_element().unwrap();
+ let children: Vec<_> = doc.children(root).collect();
+ assert_eq!(children.len(), 100);
+ }
+}
diff --git a/browser/vendor/xmloxide/src/parser/xml.rs b/browser/vendor/xmloxide/src/parser/xml.rs
new file mode 100644
index 000000000..494d8464c
--- /dev/null
+++ b/browser/vendor/xmloxide/src/parser/xml.rs
@@ -0,0 +1,2176 @@
+//! Core XML 1.0 parser state machine.
+//!
+//! Implements a hand-rolled recursive descent parser for XML 1.0 (Fifth Edition).
+//! See <https://www.w3.org/TR/xml/> for the specification.
+
+use std::collections::HashMap;
+
+use crate::error::{ErrorSeverity, ParseError};
+use crate::tree::{Attribute, Document, NodeId, NodeKind};
+use crate::validation::dtd::{parse_dtd, serialize_dtd, AttributeDecl, AttributeType, EntityKind};
+
+use super::input::{
+ find_invalid_xml_char, may_contain_invalid_xml_chars, parse_cdata_content,
+ parse_comment_content, parse_pi_content, parse_xml_decl, split_name, split_owned_name,
+ validate_pubid, ExternalEntityInfo, NamespaceResolver, ParserInput, XMLNS_NAMESPACE,
+ XML_NAMESPACE,
+};
+use super::ParseOptions;
+
+/// Default maximum amplification factor for entity/attribute expansion.
+///
+/// libxml2 uses a factor of 5 — if the expanded output exceeds 5x the input
+/// size due to default attribute application or entity expansion, the document
+/// is rejected as a potential denial-of-service attack.
+const DEFAULT_MAX_AMPLIFICATION: usize = 5;
+
+/// Maximum nesting depth of general entity expansion in content.
+///
+/// Bounds the recursion when an entity's replacement text references other
+/// entities (XML 1.0 §4.4 "Included"). Recursion is already rejected by the
+/// DTD parser (WFC: No Recursion), so this is defense-in-depth for
+/// resolver-provided external entities and stack safety.
+const MAX_ENTITY_DEPTH: u32 = 32;
+
+/// The core XML parser.
+pub(crate) struct XmlParser<'a> {
+ /// Shared low-level input state (position, peek, advance, name parsing, etc.).
+ input: ParserInput<'a>,
+ /// The document being built.
+ doc: Document,
+ /// Parser options.
+ options: ParseOptions,
+ /// Namespace resolver managing the scope stack.
+ ns: NamespaceResolver,
+ /// DTD attribute type declarations, keyed by `(element_name, attr_name)`.
+ /// Used for attribute value normalization of namespace URIs.
+ attr_types: HashMap<(String, String), AttributeType>,
+ /// DTD attribute default value declarations, keyed by element name.
+ /// Used for applying default/fixed attributes from ATTLIST.
+ attr_defaults: HashMap<String, Vec<AttributeDecl>>,
+ /// Total input size in bytes, used for amplification factor checking.
+ input_size: usize,
+ /// Running total of bytes added through default attribute expansion.
+ expansion_size: usize,
+ /// Current nesting depth of general entity expansion (0 = document level).
+ entity_depth: u32,
+}
+
+impl<'a> XmlParser<'a> {
+ pub fn new(input: &'a str, options: &ParseOptions) -> Self {
+ let mut pi = ParserInput::new(input);
+ pi.set_recover(options.recover);
+ pi.set_max_depth(options.max_depth);
+ pi.set_max_name_length(options.max_name_length);
+ pi.set_max_entity_expansions(options.max_entity_expansions);
+ pi.set_entity_resolver(options.entity_resolver.clone());
+
+ // Pre-size the node arena — roughly 1 node per 30 bytes of input.
+ let estimated_nodes = (input.len() / 30).max(64);
+ Self {
+ input: pi,
+ doc: Document::with_capacity(estimated_nodes),
+ options: options.clone(),
+ ns: NamespaceResolver::new(),
+ attr_types: HashMap::new(),
+ attr_defaults: HashMap::new(),
+ input_size: input.len(),
+ expansion_size: 0,
+ entity_depth: 0,
+ }
+ }
+
+ /// Main parse entry point. Parses the entire document.
+ pub fn parse(&mut self) -> Result<Document, ParseError> {
+ // Parse optional XML declaration — must be at the very start of the
+ // document with no leading whitespace (XML 1.0 §2.8).
+ if self.input.looking_at(b"<?xml ")
+ || self.input.looking_at(b"<?xml\t")
+ || self.input.looking_at(b"<?xml\r")
+ {
+ self.parse_xml_declaration()?;
+ // Skip whitespace immediately after the XML declaration — the
+ // serializer always emits its own newline after the declaration.
+ self.input.skip_whitespace();
+ } else if !self.input.at_end() {
+ // If there's no XML declaration, skip any leading whitespace.
+ // Leading whitespace before a non-declaration is tolerated
+ // (it will be handled as misc content).
+ let had_leading_ws = self.input.skip_whitespace();
+ // But if the whitespace was hiding an XML declaration, that's an error
+ if had_leading_ws
+ && (self.input.looking_at(b"<?xml ")
+ || self.input.looking_at(b"<?xml\t")
+ || self.input.looking_at(b"<?xml\r"))
+ {
+ return Err(self
+ .input
+ .fatal("XML declaration must be at the start of the document"));
+ }
+ }
+
+ // Parse prolog content (comments, PIs, whitespace before root element)
+ self.parse_misc(self.doc.root())?;
+
+ // Parse optional DOCTYPE declaration
+ if self.input.looking_at(b"<!DOCTYPE") || self.input.looking_at(b"<!doctype") {
+ self.parse_doctype(self.doc.root())?;
+ self.parse_misc(self.doc.root())?; // more misc after doctype
+ }
+
+ // Parse root element (required by XML 1.0 §2.1)
+ if self.input.peek() == Some(b'<')
+ && self
+ .input
+ .peek_at(1)
+ .is_some_and(|b| b != b'!' && b != b'?')
+ {
+ self.parse_element(self.doc.root())?;
+ } else if self.options.recover {
+ self.input
+ .push_diagnostic(ErrorSeverity::Error, "missing root element".to_string());
+ } else {
+ return Err(self.input.fatal("missing root element"));
+ }
+
+ // Parse trailing content (comments, PIs after root element)
+ self.parse_misc(self.doc.root())?;
+
+ self.input.skip_whitespace();
+ if !self.input.at_end() && !self.options.recover {
+ return Err(self.input.fatal("content after document element"));
+ }
+
+ // Sync diagnostics from input to document before returning.
+ self.doc.diagnostics = std::mem::take(&mut self.input.diagnostics);
+
+ Ok(std::mem::take(&mut self.doc))
+ }
+
+ // --- XML Declaration ---
+ // See XML 1.0 §2.8: [23] XMLDecl
+
+ fn parse_xml_declaration(&mut self) -> Result<(), ParseError> {
+ let decl = parse_xml_decl(&mut self.input)?;
+ self.doc.version = Some(decl.version);
+ self.doc.encoding = decl.encoding;
+ self.doc.standalone = decl.standalone;
+ Ok(())
+ }
+
+ // --- Misc (comments, PIs, whitespace) ---
+
+ fn parse_misc(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ loop {
+ // Preserve document-level whitespace as text nodes (matches libxml2).
+ // libxml2 normalizes prolog/epilog whitespace to a single `\n`
+ // regardless of how many blank lines appear in the source.
+ let ws = self.input.consume_whitespace();
+ if !ws.is_empty() {
+ let ws_node = self.doc.create_node(NodeKind::Text {
+ content: "\n".to_string(),
+ });
+ self.doc.append_child(parent, ws_node);
+ }
+ if self.input.at_end() {
+ break;
+ }
+ if self.input.looking_at(b"<!--") {
+ self.parse_comment(parent)?;
+ } else if self.input.looking_at(b"<?") {
+ self.parse_processing_instruction(parent)?;
+ } else {
+ break;
+ }
+ }
+ Ok(())
+ }
+
+ // --- DOCTYPE Declaration ---
+ // See XML 1.0 §2.8: [28] doctypedecl
+
+ #[allow(clippy::too_many_lines)]
+ fn parse_doctype(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ // Consume <!DOCTYPE (case-insensitive match already checked by caller)
+ self.input.expect_str(b"<!DOCTYPE")?;
+ self.input.skip_whitespace_required()?;
+
+ // Read the root element name
+ let name = self.input.parse_name()?;
+
+ self.input.skip_whitespace();
+
+ // Check for external ID: SYSTEM or PUBLIC
+ let mut system_id = None;
+ let mut public_id = None;
+
+ if self.input.looking_at(b"SYSTEM") {
+ self.input.expect_str(b"SYSTEM")?;
+ self.input.skip_whitespace_required()?;
+ system_id = Some(self.input.parse_quoted_value()?);
+ self.input.skip_whitespace();
+ } else if self.input.looking_at(b"PUBLIC") {
+ self.input.expect_str(b"PUBLIC")?;
+ self.input.skip_whitespace_required()?;
+ let pid = self.input.parse_quoted_value()?;
+ // Validate public ID characters per XML 1.0 §2.3 [13].
+ if let Some(msg) = validate_pubid(&pid) {
+ if self.options.recover {
+ self.input.push_diagnostic(ErrorSeverity::Warning, msg);
+ } else {
+ return Err(self.input.fatal(msg));
+ }
+ }
+ public_id = Some(pid);
+ self.input.skip_whitespace_required()?;
+ system_id = Some(self.input.parse_quoted_value()?);
+ self.input.skip_whitespace();
+ }
+
+ // Flag whether there's an external DTD subset. Per XML 1.0 §4.1 WFC:
+ // Entity Declared, undeclared entities are not WF errors when the
+ // document references an unread external DTD subset.
+ if system_id.is_some() || public_id.is_some() {
+ self.input.has_external_dtd = true;
+ }
+
+ // Parse optional internal subset: [ ... ]
+ let mut internal_subset = None;
+ if self.input.peek() == Some(b'[') {
+ self.input.advance(1);
+ let start = self.input.pos();
+
+ // Scan to matching ']', tracking depth for bracket chars inside
+ // entity values. Quoted strings and comments are skipped to avoid
+ // misinterpreting brackets or apostrophes in comments.
+ let mut depth: u32 = 1;
+ while !self.input.at_end() && depth > 0 {
+ if self.input.looking_at(b"<!--") {
+ // Skip XML comments (may contain apostrophes/quotes)
+ self.input.advance(4);
+ while !self.input.at_end() && !self.input.looking_at(b"-->") {
+ self.input.advance(1);
+ }
+ if !self.input.at_end() {
+ self.input.advance(3); // consume -->
+ }
+ } else if let Some(b'"' | b'\'') = self.input.peek() {
+ let quote = self.input.peek().unwrap_or(b'"');
+ self.input.advance(1);
+ while !self.input.at_end() && self.input.peek() != Some(quote) {
+ self.input.advance(1);
+ }
+ if !self.input.at_end() {
+ self.input.advance(1); // closing quote
+ }
+ } else if self.input.peek() == Some(b'[') {
+ depth += 1;
+ self.input.advance(1);
+ } else if self.input.peek() == Some(b']') {
+ depth -= 1;
+ self.input.advance(1);
+ } else {
+ self.input.advance(1);
+ }
+ }
+ if depth > 0 {
+ return Err(self
+ .input
+ .fatal("unexpected end of input in internal subset"));
+ }
+
+ // Extract the internal subset text (between '[' and ']').
+ let end = self.input.pos() - 1; // exclude the closing ']'
+ let subset_text = std::str::from_utf8(self.input.slice(start, end))
+ .ok()
+ .map(str::to_string);
+
+ if let Some(subset_text) = subset_text {
+ // Detect parameter entity references in the internal subset.
+ // Per XML 1.0 §4.1 WFC: Entity Declared, their presence
+ // means undeclared general entities are not WF errors.
+ if subset_text.contains('%') {
+ self.input.has_pe_references = true;
+ }
+
+ match parse_dtd(&subset_text) {
+ Ok(dtd) => {
+ // Wire entity declarations into the parser input
+ // for entity reference resolution.
+ for (ent_name, ent_decl) in &dtd.entities {
+ match &ent_decl.kind {
+ EntityKind::Internal(value) => {
+ self.input
+ .entity_map
+ .insert(ent_name.clone(), value.clone());
+ }
+ EntityKind::External {
+ system_id,
+ public_id,
+ } => {
+ self.input.entity_external.insert(
+ ent_name.clone(),
+ ExternalEntityInfo {
+ system_id: system_id.clone(),
+ public_id: public_id.clone(),
+ },
+ );
+ }
+ }
+ }
+
+ // Wire attribute type declarations for namespace
+ // URI normalization (XML 1.0 §3.3.3).
+ for (element_name, attrs) in &dtd.attributes {
+ for attr_decl in attrs {
+ self.attr_types.insert(
+ (element_name.clone(), attr_decl.attribute_name.clone()),
+ attr_decl.attribute_type.clone(),
+ );
+ }
+ }
+
+ // Store attribute default values for later application.
+ for (element_name, attrs) in &dtd.attributes {
+ for attr_decl in attrs {
+ self.attr_defaults
+ .entry(element_name.clone())
+ .or_default()
+ .push(attr_decl.clone());
+ }
+ }
+
+ // Re-serialize the DTD from parsed structures for
+ // consistent formatting (matches libxml2 behavior).
+ let serialized = serialize_dtd(&dtd);
+ if !serialized.is_empty() {
+ internal_subset = Some(serialized);
+ }
+ }
+ Err(e) => {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Warning,
+ format!("error parsing DTD internal subset: {}", e.message),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal(format!("error in DTD internal subset: {}", e.message)));
+ }
+ }
+ }
+ }
+
+ self.input.skip_whitespace();
+ }
+
+ self.input.expect_byte(b'>')?;
+
+ let doctype_id = self.doc.create_node(NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ internal_subset,
+ });
+ self.doc.append_child(parent, doctype_id);
+ Ok(())
+ }
+
+ // --- Elements ---
+ // See XML 1.0 §3.1: [40] STag, [42] ETag, [44] EmptyElemTag
+
+ #[allow(clippy::too_many_lines)]
+ fn parse_element(&mut self, parent: NodeId) -> Result<NodeId, ParseError> {
+ self.input.increment_depth()?;
+ self.input.expect_byte(b'<')?;
+ let name = self.input.parse_name()?;
+ let mut attributes = Vec::new();
+
+ // Parse attributes
+ loop {
+ let had_ws = self.input.skip_whitespace();
+ if self.input.peek() == Some(b'>') || self.input.looking_at(b"/>") {
+ break;
+ }
+ if !had_ws {
+ return Err(self.input.fatal("whitespace required between attributes"));
+ }
+ let attr = self.parse_attribute()?;
+ attributes.push(attr);
+ }
+
+ // Check for duplicate attributes (XML 1.0 §3.1 WFC: Unique Att Spec)
+ // Skip for 0 or 1 attributes (no duplicates possible).
+ if attributes.len() >= 2 {
+ // O(n²) comparison avoids HashSet allocation for small attribute lists.
+ let mut found_dup = false;
+ 'outer: for i in 1..attributes.len() {
+ for j in 0..i {
+ if attributes[i].name == attributes[j].name
+ && attributes[i].prefix == attributes[j].prefix
+ {
+ let full_name = if let Some(ref pfx) = attributes[i].prefix {
+ format!("{pfx}:{}", attributes[i].name)
+ } else {
+ attributes[i].name.clone()
+ };
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("duplicate attribute: '{full_name}'"),
+ );
+ found_dup = true;
+ } else {
+ return Err(self
+ .input
+ .fatal(format!("duplicate attribute: '{full_name}'")));
+ }
+ break 'outer;
+ }
+ }
+ }
+ let _ = found_dup; // suppress unused warning
+ }
+
+ // --- Apply DTD ATTLIST default attributes (#FIXED and #DEFAULT) ---
+ // Per XML 1.0 §3.3.2, when an attribute declared in an ATTLIST is not
+ // present on the element, the parser must add it with the declared
+ // default value. This applies to both `#FIXED "v"` and bare `"v"`
+ // (so-called #DEFAULT) declarations. libxml2 applies both during
+ // normal parsing — verifiable via `xmllint --c14n` on a document
+ // with an ATTLIST default, which emits the default attribute in the
+ // canonical form.
+ // Namespace declarations (xmlns, xmlns:prefix) are inserted before
+ // other attributes to match libxml2's attribute ordering.
+ if let Some(defaults) = if self.attr_defaults.is_empty() {
+ None
+ } else {
+ self.attr_defaults.get(&name).cloned()
+ } {
+ let mut insert_pos = 0; // insertion point for namespace declarations
+ for attr_decl in &defaults {
+ let (default_value, is_fixed) = match &attr_decl.default {
+ crate::validation::dtd::AttributeDefault::Fixed(v) => (Some(v.clone()), true),
+ crate::validation::dtd::AttributeDefault::Default(v) => {
+ (Some(v.clone()), false)
+ }
+ _ => (None, false),
+ };
+ if let Some(value) = default_value {
+ // Check if the attribute is already present by comparing
+ // prefix:local components directly, avoiding format!/clone.
+ let attr_name = &attr_decl.attribute_name;
+ let (decl_pfx, decl_local) = split_name(attr_name);
+ let already_present = attributes
+ .iter()
+ .any(|a| a.name == decl_local && a.prefix.as_deref() == decl_pfx);
+ if !already_present {
+ // Track expansion for amplification factor check
+ // (both #FIXED and #DEFAULT contribute to expansion).
+ self.expansion_size += attr_name.len() + value.len();
+
+ // Insert both #FIXED and #DEFAULT defaults into the
+ // tree. The `is_fixed` flag is no longer used to gate
+ // insertion; it would only matter if we additionally
+ // validated source attributes against #FIXED values,
+ // which is a separate validation step.
+ let _ = is_fixed;
+ let (decl_prefix, decl_local) = split_name(attr_name);
+ let attr = Attribute {
+ name: decl_local.to_string(),
+ value,
+ prefix: decl_prefix.map(String::from),
+ namespace: None,
+ raw_value: None,
+ };
+ let is_ns_decl = attr_name == "xmlns" || attr_name.starts_with("xmlns:");
+ if is_ns_decl {
+ attributes.insert(insert_pos, attr);
+ insert_pos += 1;
+ } else {
+ attributes.push(attr);
+ }
+ }
+ }
+ }
+
+ // Check amplification factor: reject if default attribute
+ // expansion would exceed the input size by more than the
+ // maximum factor (matching libxml2's xmlCtxtSetMaxAmplification).
+ if self.expansion_size > self.input_size.saturating_mul(DEFAULT_MAX_AMPLIFICATION) {
+ return Err(self
+ .input
+ .fatal("maximum entity amplification factor exceeded"));
+ }
+ }
+
+ // --- Namespace processing (Namespaces in XML 1.0 section 3) ---
+
+ // Check for namespace declarations to skip namespace scope push/pop
+ // when not needed. Skip the scan entirely when there are no attributes.
+ let has_ns_decls = !attributes.is_empty()
+ && attributes.iter().any(|a| {
+ a.prefix.as_deref() == Some("xmlns") || (a.prefix.is_none() && a.name == "xmlns")
+ });
+ if has_ns_decls {
+ self.ns.push_scope();
+ }
+
+ // Split into prefix and local name for namespace processing.
+ let (prefix, local_name) = split_name(&name);
+
+ // Validate QName syntax: check for multiple colons (the local part
+ // should not contain a colon after split_name).
+ if prefix.is_some() && local_name.contains(':') {
+ let msg = "QName contains multiple colons";
+ if self.options.recover {
+ self.input
+ .push_diagnostic(ErrorSeverity::Error, msg.to_string());
+ } else {
+ return Err(self.input.fatal(msg));
+ }
+ }
+
+ // Reject element names with "xmlns" prefix (Namespaces in XML 1.0 §3).
+ if prefix == Some("xmlns") {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "elements must not have the prefix 'xmlns'".to_string(),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal("elements must not have the prefix 'xmlns'"));
+ }
+ }
+
+ // Scan attributes for namespace declarations and bind them,
+ // with validation of namespace constraints.
+ // In recovery mode, some invalid attributes may be stripped.
+ let mut strip_attr_indices: Vec<usize> = Vec::new();
+ if has_ns_decls {
+ for (attr_idx, attr) in attributes.iter().enumerate() {
+ if attr.prefix.as_deref() == Some("xmlns") {
+ // Prefixed namespace declaration: xmlns:prefix="uri"
+ let declared_prefix = &attr.name;
+
+ // Validate QName: the local part (declared_prefix) must be
+ // a non-empty NCName (no colon, not empty). An empty local
+ // part means the attribute was `xmlns:` with nothing after
+ // the colon, which is not a valid QName.
+ if declared_prefix.is_empty() {
+ let msg = "namespace prefix must not be empty (invalid QName 'xmlns:')";
+ if self.options.recover {
+ self.input
+ .push_diagnostic(ErrorSeverity::Error, msg.to_string());
+ continue;
+ }
+ return Err(self.input.fatal(msg));
+ }
+ if declared_prefix.contains(':') {
+ let msg = "QName contains multiple colons";
+ if self.options.recover {
+ self.input
+ .push_diagnostic(ErrorSeverity::Error, msg.to_string());
+ } else {
+ return Err(self.input.fatal(msg));
+ }
+ }
+
+ // Normalize namespace URI based on DTD-declared attribute
+ // type. For non-CDATA types (e.g., NMTOKEN), whitespace is
+ // collapsed per XML 1.0 §3.3.3. Construct the full attribute
+ // name only when attr_types is non-empty (DTD present).
+ let ns_value = if self.attr_types.is_empty() {
+ attr.value.clone()
+ } else {
+ let attr_qname = format!("xmlns:{declared_prefix}");
+ self.normalize_attr_value_by_type(&name, &attr_qname, &attr.value)
+ };
+
+ // XML 1.0 Namespaces: cannot unbind a prefix (xmlns:prefix="").
+ if ns_value.is_empty() {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("namespace prefix '{declared_prefix}' cannot be undeclared in XML 1.0"),
+ );
+ } else {
+ return Err(self.input.fatal(format!(
+ "namespace prefix '{declared_prefix}' cannot be undeclared in XML 1.0"
+ )));
+ }
+ }
+
+ // Cannot declare the 'xmlns' prefix itself.
+ if declared_prefix == "xmlns" {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "the 'xmlns' prefix must not be declared".to_string(),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal("the 'xmlns' prefix must not be declared"));
+ }
+ }
+
+ // 'xml' prefix must map to the XML namespace URI and vice versa.
+ if declared_prefix == "xml" && ns_value != XML_NAMESPACE {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "the 'xml' prefix must be bound to the XML namespace".to_string(),
+ );
+ // In recovery mode, strip the invalid rebinding
+ // (matches libxml2: output is <tst/> not <tst xmlns:xml="..."/>).
+ strip_attr_indices.push(attr_idx);
+ continue;
+ }
+ return Err(self
+ .input
+ .fatal("the 'xml' prefix must be bound to the XML namespace"));
+ }
+
+ // No other prefix may be bound to the XML namespace URI.
+ if declared_prefix != "xml" && ns_value == XML_NAMESPACE {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "only the 'xml' prefix may be bound to the XML namespace"
+ .to_string(),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal("only the 'xml' prefix may be bound to the XML namespace"));
+ }
+ }
+
+ // No prefix may be bound to the xmlns namespace URI.
+ if ns_value == XMLNS_NAMESPACE {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "the xmlns namespace must not be bound to any prefix".to_string(),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal("the xmlns namespace must not be bound to any prefix"));
+ }
+ }
+
+ self.ns.bind(Some(attr.name.clone()), ns_value);
+ } else if attr.prefix.is_none() && attr.name == "xmlns" {
+ // Default namespace declaration: xmlns="uri"
+
+ // Normalize namespace URI based on DTD-declared attribute type.
+ let ns_value = if self.attr_types.is_empty() {
+ attr.value.clone()
+ } else {
+ self.normalize_attr_value_by_type(&name, "xmlns", &attr.value)
+ };
+
+ // Cannot bind default namespace to the XML or xmlns namespace URIs.
+ if ns_value == XML_NAMESPACE {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "the xml namespace must not be declared as the default namespace"
+ .to_string(),
+ );
+ } else {
+ return Err(self.input.fatal(
+ "the xml namespace must not be declared as the default namespace",
+ ));
+ }
+ }
+ if ns_value == XMLNS_NAMESPACE {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "the xmlns namespace must not be declared as the default namespace"
+ .to_string(),
+ );
+ } else {
+ return Err(self.input.fatal(
+ "the xmlns namespace must not be declared as the default namespace",
+ ));
+ }
+ }
+ self.ns.bind(None, ns_value);
+ } else if attr.prefix.is_some() && attr.name.contains(':') {
+ // Validate QName syntax for prefixed non-namespace attributes.
+ let msg = "QName contains multiple colons";
+ if self.options.recover {
+ self.input
+ .push_diagnostic(ErrorSeverity::Error, msg.to_string());
+ } else {
+ return Err(self.input.fatal(msg));
+ }
+ }
+ }
+ } else {
+ // No namespace declarations — only validate QName syntax for
+ // prefixed attributes (checking for multiple colons).
+ for attr in &attributes {
+ if attr.prefix.is_some() && attr.name.contains(':') {
+ let msg = "QName contains multiple colons";
+ if self.options.recover {
+ self.input
+ .push_diagnostic(ErrorSeverity::Error, msg.to_string());
+ } else {
+ return Err(self.input.fatal(msg));
+ }
+ }
+ }
+ }
+
+ // Resolve the element's namespace URI from its prefix.
+ let elem_ns = self.ns.resolve(prefix).map(String::from);
+
+ // Check for unbound element prefix.
+ if let Some(pfx) = prefix {
+ if pfx != "xml" && elem_ns.is_none() {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("unbound namespace prefix '{pfx}'"),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal(format!("unbound namespace prefix '{pfx}'")));
+ }
+ }
+ }
+
+ // Resolve namespace URIs for non-xmlns prefixed attributes.
+ // Unprefixed attributes do NOT inherit the default namespace (per spec).
+ // Skip entirely when there are no prefixed non-xmlns attributes.
+ let has_prefixed_attrs = !attributes.is_empty()
+ && attributes
+ .iter()
+ .any(|a| a.prefix.is_some() && a.prefix.as_deref() != Some("xmlns"));
+ if has_prefixed_attrs {
+ for attr in &mut attributes {
+ if let Some(pfx) = &attr.prefix {
+ if pfx == "xmlns" {
+ continue; // namespace declaration, not a real attribute prefix
+ }
+ let resolved = self.ns.resolve(Some(pfx.as_str())).map(String::from);
+ if pfx != "xml" && resolved.is_none() {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("unbound namespace prefix '{pfx}' on attribute"),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal(format!("unbound namespace prefix '{pfx}' on attribute")));
+ }
+ }
+ attr.namespace = resolved;
+ }
+ }
+ }
+
+ // Namespace-aware attribute uniqueness: two attributes with the same
+ // namespace URI and local name are duplicates, even if they use different
+ // prefixes (Namespaces in XML 1.0 §6.3).
+ // Only meaningful when there are 2+ namespaced (non-xmlns) attributes.
+ // Skip entirely when no prefixed attributes exist (no namespaces were
+ // resolved, so ns_attr_count is guaranteed to be 0).
+ if has_prefixed_attrs {
+ let ns_attr_count = attributes.iter().filter(|a| a.namespace.is_some()).count();
+ if ns_attr_count >= 2 {
+ // O(n²) comparison avoids HashSet allocation
+ 'ns_outer: for i in 1..attributes.len() {
+ if attributes[i].namespace.is_none() {
+ continue;
+ }
+ for j in 0..i {
+ if attributes[j].namespace.is_none() {
+ continue;
+ }
+ if attributes[i].namespace == attributes[j].namespace
+ && attributes[i].name == attributes[j].name
+ {
+ let display = if let Some(ns) = &attributes[i].namespace {
+ format!("{{{}}}:{}", ns, attributes[i].name)
+ } else {
+ attributes[i].name.clone()
+ };
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("namespace-aware duplicate attribute: '{display}'"),
+ );
+ } else {
+ return Err(self.input.fatal(format!(
+ "namespace-aware duplicate attribute: '{display}'"
+ )));
+ }
+ break 'ns_outer;
+ }
+ }
+ }
+ }
+ }
+
+ // Remove stripped attributes (e.g., invalid xmlns:xml rebindings).
+ if !strip_attr_indices.is_empty() {
+ // Remove in reverse order to preserve indices.
+ for &idx in strip_attr_indices.iter().rev() {
+ attributes.remove(idx);
+ }
+ }
+
+ // Consume the original name String via split_owned_name, avoiding a
+ // re-allocation for unprefixed names (the common case). For unprefixed
+ // names, split_owned_name returns (None, name) — just a move, zero copy.
+ let (elem_prefix_owned, elem_local_owned) = split_owned_name(name);
+ // Auto-populate id_map for "id" attributes (enables element_by_id
+ // and fast CSS #id selectors without requiring DTD validation).
+ let id_value = attributes.iter().find_map(|a| {
+ if a.prefix.is_none() && a.name == "id" {
+ Some(a.value.clone())
+ } else {
+ None
+ }
+ });
+
+ let elem_id = self.doc.create_node(NodeKind::Element {
+ name: elem_local_owned,
+ prefix: elem_prefix_owned,
+ namespace: elem_ns,
+ attributes,
+ });
+ self.doc.append_child(parent, elem_id);
+
+ if let Some(id_val) = id_value {
+ self.doc.set_id(&id_val, elem_id);
+ }
+
+ // Empty element tag <foo/>
+ if self.input.looking_at(b"/>") {
+ self.input.advance(2);
+ if has_ns_decls {
+ self.ns.pop_scope();
+ }
+ self.input.decrement_depth();
+ return Ok(elem_id);
+ }
+
+ // Start tag close >
+ self.input.expect_byte(b'>')?;
+
+ // Parse element content
+ self.parse_content(elem_id)?;
+
+ // Parse end tag — read back the stored name from the tree node
+ // for matching, since the original name was consumed by split_owned_name.
+ self.input.expect_str(b"</")?;
+ let (match_prefix, match_local) = {
+ let node = self.doc.node(elem_id);
+ match &node.kind {
+ NodeKind::Element { name, prefix, .. } => (prefix.as_deref(), name.as_str()),
+ _ => unreachable!(),
+ }
+ };
+ if let Some(end_name) = self.input.parse_name_eq_parts(match_prefix, match_local)? {
+ let expected = match match_prefix {
+ Some(pfx) => format!("{pfx}:{match_local}"),
+ None => match_local.to_string(),
+ };
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("mismatched end tag: expected </{expected}>, found </{end_name}>"),
+ );
+ } else {
+ return Err(self.input.fatal(format!(
+ "mismatched end tag: expected </{expected}>, found </{end_name}>"
+ )));
+ }
+ }
+ self.input.skip_whitespace();
+ self.input.expect_byte(b'>')?;
+
+ // Pop the namespace scope when leaving this element (only if we pushed).
+ if has_ns_decls {
+ self.ns.pop_scope();
+ }
+ self.input.decrement_depth();
+
+ Ok(elem_id)
+ }
+
+ /// Normalizes an attribute value based on its DTD-declared type.
+ ///
+ /// For non-CDATA types (e.g., NMTOKEN, ID, IDREF), collapses whitespace:
+ /// trim leading/trailing whitespace, reduce internal whitespace sequences
+ /// to single spaces (XML 1.0 §3.3.3).
+ fn normalize_attr_value_by_type(
+ &self,
+ element_name: &str,
+ attr_name: &str,
+ value: &str,
+ ) -> String {
+ // Fast path: skip lookup when no DTD attribute types are declared
+ // (the common case for documents without a DTD).
+ if !self.attr_types.is_empty() {
+ let key = (element_name.to_string(), attr_name.to_string());
+ if let Some(attr_type) = self.attr_types.get(&key) {
+ if !matches!(attr_type, AttributeType::CData) {
+ return value.split_whitespace().collect::<Vec<_>>().join(" ");
+ }
+ }
+ }
+ value.to_string()
+ }
+
+ // --- Content ---
+ // See XML 1.0 §3.1: [43] content
+
+ fn parse_content(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ loop {
+ if self.input.at_end() {
+ if self.options.recover {
+ break;
+ }
+ return Err(self
+ .input
+ .fatal("unexpected end of input in element content"));
+ }
+
+ // End tag starts
+ if self.input.looking_at(b"</") {
+ break;
+ }
+
+ if self.input.looking_at(b"<![CDATA[") {
+ self.parse_cdata(parent)?;
+ } else if self.input.looking_at(b"<!--") {
+ self.parse_comment(parent)?;
+ } else if self.input.looking_at(b"<?") {
+ self.parse_processing_instruction(parent)?;
+ } else if self.input.peek() == Some(b'<') {
+ self.parse_element(parent)?;
+ } else {
+ self.parse_char_data(parent)?;
+ }
+ }
+ Ok(())
+ }
+
+ // --- Character Data ---
+ // See XML 1.0 §2.4: [14] CharData
+
+ #[allow(clippy::too_many_lines)]
+ fn parse_char_data(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ let mut text = String::new();
+
+ while !self.input.at_end() {
+ // Bulk scan: find the next `<`, `&`, or `]]]]><![CDATA[>` boundary and
+ // consume all safe bytes in one go.
+ let safe_len = self.input.scan_char_data();
+ if safe_len > 0 {
+ let start = self.input.pos();
+ let chunk = std::str::from_utf8(self.input.slice(start, start + safe_len))
+ .map_err(|_| self.input.fatal("invalid UTF-8 in character data"))?;
+ // Fast byte-level pre-check for invalid XML chars (0x7F,
+ // U+FFFE, U+FFFF). Skips the expensive char-by-char
+ // validation for the 99.9% of chunks that are clean.
+ let bad_char = if may_contain_invalid_xml_chars(chunk.as_bytes()) {
+ find_invalid_xml_char(chunk)
+ } else {
+ None
+ };
+ // Append text with CR normalization if needed (XML 1.0 §2.11)
+ if chunk.as_bytes().contains(&b'\r') {
+ let mut chars = chunk.chars().peekable();
+ while let Some(ch) = chars.next() {
+ if ch == '\r' {
+ if chars.peek() == Some(&'\n') {
+ chars.next();
+ }
+ text.push('\n');
+ } else {
+ text.push(ch);
+ }
+ }
+ } else {
+ text.push_str(chunk);
+ }
+ // chunk borrow released — safe to mutably borrow self.input
+ self.input.advance_counting_lines(safe_len);
+ if let Some(bad) = bad_char {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ format!("invalid XML character: U+{:04X}", bad as u32),
+ );
+ } else {
+ return Err(self
+ .input
+ .fatal(format!("invalid XML character: U+{:04X}", bad as u32)));
+ }
+ }
+ continue;
+ }
+
+ if self.input.peek() == Some(b'<') {
+ break;
+ }
+
+ // XML 1.0 §2.4: "]]]]><![CDATA[>" is forbidden in character data
+ if self.input.looking_at(b"]]]]><![CDATA[>") {
+ if self.options.recover {
+ self.input.push_diagnostic(
+ ErrorSeverity::Error,
+ "']]]]><![CDATA[>' not allowed in character data".to_string(),
+ );
+ text.push_str("]]]]><![CDATA[>");
+ self.input.advance(3);
+ continue;
+ }
+ return Err(self.input.fatal("']]]]><, end of input is the
+ /// normal termination and an end tag (`</`) is an error (it would close
+ /// an element opened outside the entity — WFC violation).
+ fn parse_content_fragment(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ while !self.input.at_end() {
+ if self.input.looking_at(b"</") {
+ return Err(self.input.fatal("unbalanced end tag"));
+ }
+ if self.input.looking_at(b"<![CDATA[") {
+ self.parse_cdata(parent)?;
+ } else if self.input.looking_at(b"<!--") {
+ self.parse_comment(parent)?;
+ } else if self.input.looking_at(b"<?") {
+ self.parse_processing_instruction(parent)?;
+ } else if self.input.peek() == Some(b'<') {
+ self.parse_element(parent)?;
+ } else {
+ self.parse_char_data(parent)?;
+ }
+ }
+ Ok(())
+ }
+
+ /// Recursively deep-copies a subtree from `src` into `dst`, appending
+ /// the copy under `dst_parent`.
+ fn import_subtree(dst: &mut Document, src: &Document, src_id: NodeId, dst_parent: NodeId) {
+ let kind = src.node(src_id).kind.clone();
+ let new_id = dst.create_node(kind);
+ dst.append_child(dst_parent, new_id);
+ for child in src.children(src_id) {
+ Self::import_subtree(dst, src, child, new_id);
+ }
+ }
+
+ /// Checks if the input is positioned at a builtin entity reference
+ /// (`&`, `<`, `>`, `'`, `"`) using byte-level
+ /// checks. This avoids the `String` allocation of `peek_entity_ref_name`.
+ #[inline]
+ fn is_looking_at_builtin_entity_ref(&self) -> bool {
+ let remaining = self.input.remaining();
+ if remaining.len() < 4 || remaining[0] != b'&' {
+ return false;
+ }
+ let after_amp = &remaining[1..];
+ after_amp.starts_with(b"lt;")
+ || after_amp.starts_with(b"gt;")
+ || after_amp.starts_with(b"amp;")
+ || after_amp.starts_with(b"apos;")
+ || after_amp.starts_with(b"quot;")
+ }
+
+ /// Peeks ahead to extract the entity name from `&name;` without consuming
+ /// any input. Returns `None` if the next bytes don't form a valid entity
+ /// reference pattern.
+ fn peek_entity_ref_name(&self) -> Option<String> {
+ // We're at `&` — look ahead past it to find the name and `;`
+ let remaining = self.input.remaining();
+ if remaining.len() < 2 || remaining[0] != b'&' {
+ return None;
+ }
+ let mut i = 1;
+ // Collect name bytes
+ let name_start = i;
+ while i < remaining.len()
+ && (remaining[i].is_ascii_alphanumeric()
+ || remaining[i] == b'_'
+ || remaining[i] == b':'
+ || remaining[i] == b'-'
+ || remaining[i] == b'.')
+ {
+ i += 1;
+ }
+ if i == name_start || i >= remaining.len() || remaining[i] != b';' {
+ return None;
+ }
+ std::str::from_utf8(&remaining[name_start..i])
+ .ok()
+ .map(String::from)
+ }
+
+ /// Checks if all entity references (`&name;`) in a raw attribute value
+ /// text are declared in the entity map. Returns false if any undeclared
+ /// entity ref is found (these should not be preserved via `raw_value`).
+ fn all_entity_refs_declared(&self, raw: &str) -> bool {
+ let bytes = raw.as_bytes();
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'&' && i + 1 < bytes.len() && bytes[i + 1] != b'#' {
+ // Named entity reference — extract the name
+ let mut j = i + 1;
+ while j < bytes.len()
+ && (bytes[j].is_ascii_alphanumeric()
+ || bytes[j] == b'_'
+ || bytes[j] == b':'
+ || bytes[j] == b'-'
+ || bytes[j] == b'.')
+ {
+ j += 1;
+ }
+ if j < bytes.len() && bytes[j] == b';' {
+ let name = std::str::from_utf8(&bytes[i + 1..j]).unwrap_or("");
+ if !is_builtin_entity(name) && !self.input.entity_map.contains_key(name) {
+ return false;
+ }
+ i = j + 1;
+ } else {
+ i += 1;
+ }
+ } else {
+ i += 1;
+ }
+ }
+ true
+ }
+
+ // --- Attributes ---
+ // See XML 1.0 §3.1: [41] Attribute
+
+ fn parse_attribute(&mut self) -> Result<Attribute, ParseError> {
+ let name = self.input.parse_name()?;
+ self.input.skip_whitespace();
+ self.input.expect_byte(b'=')?;
+ self.input.skip_whitespace();
+
+ // Capture raw attribute value text (before entity expansion) so we
+ // can preserve entity references during serialization.
+ let raw_start = self.input.pos();
+ let value = self.input.parse_attribute_value()?;
+ let raw_end = self.input.pos();
+
+ // Extract raw value (between quotes) — the raw slice includes the
+ // outer quote chars, so trim them. Skip entirely when the raw bytes
+ // contain no '&' (most attributes have no entity references).
+ let raw_value = if raw_end > raw_start + 2 {
+ let raw_bytes = self.input.slice(raw_start + 1, raw_end - 1);
+ if raw_bytes.contains(&b'&') {
+ let raw_str = std::str::from_utf8(raw_bytes).ok().map(str::to_string);
+ // Only store raw_value if it differs from the expanded value
+ // (i.e., it contained entity references that got expanded) AND
+ // all entity references in the raw value are declared (not
+ // undeclared entities that expanded to empty string).
+ raw_str.filter(|raw| *raw != value && self.all_entity_refs_declared(raw))
+ } else {
+ None
+ }
+ } else {
+ None
+ };
+
+ let (prefix, local_name) = split_owned_name(name);
+
+ Ok(Attribute {
+ name: local_name,
+ value,
+ prefix,
+ namespace: None,
+ raw_value,
+ })
+ }
+
+ // --- Comments ---
+ // See XML 1.0 §2.5: [15] Comment
+
+ fn parse_comment(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ let content = parse_comment_content(&mut self.input)?;
+ let comment_id = self.doc.create_node(NodeKind::Comment { content });
+ self.doc.append_child(parent, comment_id);
+ Ok(())
+ }
+
+ // --- CDATA Sections ---
+ // See XML 1.0 §2.7: [18] CDSect
+
+ fn parse_cdata(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ let content = parse_cdata_content(&mut self.input)?;
+ let cdata_id = self.doc.create_node(NodeKind::CData { content });
+ self.doc.append_child(parent, cdata_id);
+ Ok(())
+ }
+
+ // --- Processing Instructions ---
+ // See XML 1.0 §2.6: [16] PI
+
+ fn parse_processing_instruction(&mut self, parent: NodeId) -> Result<(), ParseError> {
+ let (target, data) = parse_pi_content(&mut self.input)?;
+ let pi_id = self
+ .doc
+ .create_node(NodeKind::ProcessingInstruction { target, data });
+ self.doc.append_child(parent, pi_id);
+ Ok(())
+ }
+}
+
+/// Normalizes line ends per XML 1.0 §2.11: `\r\n` and lone `\r` become `\n`.
+fn normalize_line_ends(s: &str) -> String {
+ let mut out = String::with_capacity(s.len());
+ let mut chars = s.chars().peekable();
+ while let Some(ch) = chars.next() {
+ if ch == '\r' {
+ if chars.peek() == Some(&'\n') {
+ chars.next();
+ }
+ out.push('\n');
+ } else {
+ out.push(ch);
+ }
+ }
+ out
+}
+
+/// Strips an optional leading text declaration (`<?xml ...?>`) from external
+/// parsed entity text (XML 1.0 §4.3.1: `TextDecl`).
+fn strip_text_declaration(s: &str) -> &str {
+ let rest = s.strip_prefix("<?xml").filter(|r| {
+ r.starts_with(' ') || r.starts_with('\t') || r.starts_with('\r') || r.starts_with('\n')
+ });
+ if let Some(rest) = rest {
+ if let Some(end) = rest.find("?>") {
+ return &rest[end + 2..];
+ }
+ }
+ s
+}
+
+/// Returns true if the entity name is one of the five XML builtin entities.
+fn is_builtin_entity(name: &str) -> bool {
+ matches!(name, "amp" | "lt" | "gt" | "apos" | "quot")
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+ use crate::tree::Document;
+
+ fn parse(input: &str) -> Document {
+ Document::parse_str(input).unwrap_or_else(|e| panic!("parse failed: {e}"))
+ }
+
+ #[test]
+ fn test_parse_empty_element() {
+ let doc = parse("<root/>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ assert_eq!(doc.first_child(root), None);
+ }
+
+ #[test]
+ fn test_parse_element_with_text() {
+ let doc = parse("<greeting>Hello, world!</greeting>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("greeting"));
+ assert_eq!(doc.text_content(root), "Hello, world!");
+ }
+
+ #[test]
+ fn test_parse_nested_elements() {
+ let doc = parse("<a><b><c/></b></a>");
+ let a = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(a), Some("a"));
+
+ let b = doc.first_child(a).unwrap();
+ assert_eq!(doc.node_name(b), Some("b"));
+
+ let c = doc.first_child(b).unwrap();
+ assert_eq!(doc.node_name(c), Some("c"));
+ }
+
+ #[test]
+ fn test_parse_attributes() {
+ let doc = parse("<div id=\"main\" class=\"big\"/>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.attribute(root, "id"), Some("main"));
+ assert_eq!(doc.attribute(root, "class"), Some("big"));
+ }
+
+ #[test]
+ fn test_parse_single_quoted_attributes() {
+ let doc = parse("<div id='main'/>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.attribute(root, "id"), Some("main"));
+ }
+
+ #[test]
+ fn test_parse_xml_declaration() {
+ let doc = parse("<?xml version=\"1.0\" encoding=\"UTF-8\"?><root/>");
+ assert_eq!(doc.version.as_deref(), Some("1.0"));
+ assert_eq!(doc.encoding.as_deref(), Some("UTF-8"));
+ }
+
+ #[test]
+ fn test_parse_xml_declaration_standalone() {
+ let doc = parse("<?xml version=\"1.0\" standalone=\"yes\"?><root/>");
+ assert_eq!(doc.standalone, Some(true));
+ }
+
+ #[test]
+ fn test_parse_comment() {
+ let doc = parse("<root><!-- hello --></root>");
+ let root = doc.root_element().unwrap();
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_text(child), Some(" hello "));
+ }
+
+ #[test]
+ fn test_parse_cdata() {
+ let doc = parse("<root><![CDATA[x < 1 && y > 2]]]]><![CDATA[></root>");
+ let root = doc.root_element().unwrap();
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_text(child), Some("x < 1 && y > 2"));
+ }
+
+ #[test]
+ fn test_parse_processing_instruction() {
+ let doc = parse("<?my-pi some data?><root/>");
+ let pi = doc.first_child(doc.root()).unwrap();
+ assert_eq!(doc.node_name(pi), Some("my-pi"));
+ assert_eq!(doc.node_text(pi), Some("some data"));
+ }
+
+ #[test]
+ fn test_parse_entity_references() {
+ let doc = parse("<root>& < > ' "</root>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "& < > ' \"");
+ }
+
+ #[test]
+ fn test_parse_char_reference_decimal() {
+ let doc = parse("<root>A</root>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "A");
+ }
+
+ #[test]
+ fn test_parse_char_reference_hex() {
+ let doc = parse("<root>A</root>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "A");
+ }
+
+ #[test]
+ fn test_parse_mixed_content() {
+ let doc = parse("<p>Hello <b>world</b>!</p>");
+ let p = doc.root_element().unwrap();
+ let children: Vec<_> = doc.children(p).collect();
+ assert_eq!(children.len(), 3); // "Hello ", <b>, "!"
+
+ assert_eq!(doc.node_text(children[0]), Some("Hello "));
+ assert_eq!(doc.node_name(children[1]), Some("b"));
+ assert_eq!(doc.text_content(children[1]), "world");
+ assert_eq!(doc.node_text(children[2]), Some("!"));
+ }
+
+ #[test]
+ fn test_parse_prefixed_element() {
+ let doc = parse("<svg:rect xmlns:svg=\"http://www.w3.org/2000/svg\"/>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("rect"));
+ match &doc.node(root).kind {
+ NodeKind::Element { prefix, .. } => {
+ assert_eq!(prefix.as_deref(), Some("svg"));
+ }
+ _ => panic!("expected element"),
+ }
+ }
+
+ #[test]
+ fn test_parse_prefixed_attribute() {
+ let doc = parse("<root xml:lang=\"en\"/>");
+ let root = doc.root_element().unwrap();
+ let attrs = doc.attributes(root);
+ assert_eq!(attrs.len(), 1);
+ assert_eq!(attrs[0].name, "lang");
+ assert_eq!(attrs[0].prefix.as_deref(), Some("xml"));
+ assert_eq!(attrs[0].value, "en");
+ }
+
+ #[test]
+ fn test_parse_error_mismatched_tags() {
+ let result = Document::parse_str("<a></b>");
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_parse_error_unexpected_eof() {
+ let result = Document::parse_str("<a>");
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_parse_error_no_root() {
+ let result = Document::parse_str("");
+ // XML 1.0 §2.1 requires a root element
+ assert!(result.is_err());
+ }
+
+ /// The XML declaration prefix that `serialize()` always emits.
+ const DECL: &str = "<?xml version=\"1.0\"?>\n";
+
+ #[test]
+ fn test_roundtrip_simple() {
+ let input = "<root><child>text</child></root>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(output, format!("{DECL}{input}\n"));
+ }
+
+ #[test]
+ fn test_roundtrip_attributes() {
+ let input = "<root attr=\"value\"><child id=\"1\"/></root>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(output, format!("{DECL}{input}\n"));
+ }
+
+ #[test]
+ fn test_roundtrip_entities() {
+ let input = "<root>& < ></root>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ // After parsing, entities are resolved to characters.
+ // Serialization re-escapes them.
+ assert_eq!(output, format!("{DECL}<root>& < ></root>\n"));
+ }
+
+ #[test]
+ fn test_roundtrip_comment() {
+ let input = "<root><!-- comment --></root>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(output, format!("{DECL}{input}\n"));
+ }
+
+ #[test]
+ fn test_roundtrip_cdata() {
+ let input = "<root><![CDATA[data & stuff]]]]><![CDATA[></root>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(output, format!("{DECL}{input}\n"));
+ }
+
+ #[test]
+ fn test_roundtrip_pi() {
+ let input = "<?target data?><root/>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(output, format!("{DECL}{input}\n"));
+ }
+
+ #[test]
+ fn test_roundtrip_xml_declaration() {
+ let input = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><root/>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(
+ output,
+ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root/>\n"
+ );
+ }
+
+ #[test]
+ fn test_whitespace_in_attribute_value() {
+ let doc = parse("<root attr=\"a\tb\nc\"/>");
+ let root = doc.root_element().unwrap();
+ // Tabs and newlines in attribute values are normalized to spaces
+ assert_eq!(doc.attribute(root, "attr"), Some("a b c"));
+ }
+
+ #[test]
+ fn test_name_chars() {
+ use super::super::input::{is_name_char, is_name_start_char};
+
+ assert!(is_name_start_char('A'));
+ assert!(is_name_start_char('z'));
+ assert!(is_name_start_char('_'));
+ assert!(is_name_start_char(':'));
+ assert!(!is_name_start_char('0'));
+ assert!(!is_name_start_char('-'));
+
+ assert!(is_name_char('A'));
+ assert!(is_name_char('0'));
+ assert!(is_name_char('-'));
+ assert!(is_name_char('.'));
+ assert!(!is_name_char(' '));
+ }
+
+ #[test]
+ fn test_parse_doctype_simple() {
+ let doc = parse("<!DOCTYPE html><html/>");
+ let root = doc.root();
+ let children: Vec<_> = doc.children(root).collect();
+ assert_eq!(children.len(), 2);
+
+ match &doc.node(children[0]).kind {
+ NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ ..
+ } => {
+ assert_eq!(name, "html");
+ assert_eq!(*system_id, None);
+ assert_eq!(*public_id, None);
+ }
+ other => panic!("expected DocumentType, got {other:?}"),
+ }
+
+ assert_eq!(doc.node_name(children[1]), Some("html"));
+ }
+
+ #[test]
+ fn test_parse_doctype_system() {
+ let doc = parse("<!DOCTYPE root SYSTEM \"root.dtd\"><root/>");
+ let root = doc.root();
+ let children: Vec<_> = doc.children(root).collect();
+ assert_eq!(children.len(), 2);
+
+ match &doc.node(children[0]).kind {
+ NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ ..
+ } => {
+ assert_eq!(name, "root");
+ assert_eq!(system_id.as_deref(), Some("root.dtd"));
+ assert_eq!(*public_id, None);
+ }
+ other => panic!("expected DocumentType, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_doctype_public() {
+ let doc = parse(
+ "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0//EN\" \
+ \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"><html/>",
+ );
+ let root = doc.root();
+ let children: Vec<_> = doc.children(root).collect();
+ assert_eq!(children.len(), 2);
+
+ match &doc.node(children[0]).kind {
+ NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ ..
+ } => {
+ assert_eq!(name, "html");
+ assert_eq!(public_id.as_deref(), Some("-//W3C//DTD XHTML 1.0//EN"));
+ assert_eq!(
+ system_id.as_deref(),
+ Some("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd")
+ );
+ }
+ other => panic!("expected DocumentType, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_doctype_internal_subset() {
+ let doc = parse("<!DOCTYPE root [<!ELEMENT root (#PCDATA)>]><root/>");
+ let root = doc.root();
+ let children: Vec<_> = doc.children(root).collect();
+ assert_eq!(children.len(), 2);
+
+ match &doc.node(children[0]).kind {
+ NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ ..
+ } => {
+ assert_eq!(name, "root");
+ assert_eq!(*system_id, None);
+ assert_eq!(*public_id, None);
+ }
+ other => panic!("expected DocumentType, got {other:?}"),
+ }
+
+ assert_eq!(doc.node_name(children[1]), Some("root"));
+ }
+
+ #[test]
+ fn test_parse_doctype_multiline_internal_subset() {
+ let input =
+ "<!DOCTYPE root [\n<!ELEMENT y (#PCDATA|x|x)*>\n<!ELEMENT root ANY>\n]>\n\n<root/>";
+ let doc = parse(input);
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+
+ #[test]
+ fn test_parse_doctype_with_entity() {
+ let input = "<!DOCTYPE doc [\n<!ELEMENT doc (#PCDATA)>\n<!ENTITY rsqb \"]\">\n]>\n<doc>]</doc>";
+ let doc = parse(input);
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "]");
+ }
+
+ #[test]
+ fn test_parse_doctype_content_model() {
+ let input = "<!DOCTYPE violation [\n<!ELEMENT violation (a,a,a,b)>\n<!ELEMENT a EMPTY>\n<!ELEMENT b EMPTY>\n]>\n<violation>\n <a/>\n <a/>\n <b/>\n</violation>";
+ let doc = parse(input);
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("violation"));
+ }
+
+ #[test]
+ fn test_parse_doctype_with_crlf() {
+ // Test with CRLF line endings (like the OASIS conformance tests)
+ let input =
+ "<!DOCTYPE doc\r\n[\r\n<!ELEMENT doc ANY>\r\n<!ELEMENT a (doc?)>\r\n]>\r\n<doc/>";
+ let doc = parse(input);
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("doc"));
+ }
+
+ #[test]
+ fn test_parse_doctype_attlist() {
+ let input = "<!DOCTYPE root [\n<!ELEMENT root EMPTY>\n<!ATTLIST root\n token\tNMTOKEN\t\t#REQUIRED\n >\n\n <!-- comment -->\n]>\n<root token=\"dev@null\"/>";
+ let doc = parse(input);
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+
+ #[test]
+ fn test_parse_doctype_comment_with_apostrophe() {
+ // Apostrophes in DTD comments must not confuse the bracket scanner
+ let input = "<!DOCTYPE root [\n<!ELEMENT root ANY>\n<!-- can't break -->\n]>\n<root/>";
+ let doc = parse(input);
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+
+ #[test]
+ fn test_roundtrip_doctype() {
+ // Simple DOCTYPE (no whitespace between DOCTYPE and root in input)
+ let input = "<!DOCTYPE html><html/>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(output, format!("{DECL}<!DOCTYPE html><html/>\n"));
+
+ // DOCTYPE with SYSTEM
+ let input = "<!DOCTYPE root SYSTEM \"root.dtd\"><root/>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(
+ output,
+ format!("{DECL}<!DOCTYPE root SYSTEM \"root.dtd\"><root/>\n")
+ );
+
+ // DOCTYPE with PUBLIC
+ let input = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0//EN\" \
+ \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"><html/>";
+ let doc = parse(input);
+ let output = crate::serial::serialize(&doc);
+ assert_eq!(
+ output,
+ format!(
+ "{DECL}<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0//EN\" \
+ \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"><html/>\n"
+ )
+ );
+ }
+
+ // --- Namespace resolution tests ---
+
+ #[test]
+ fn test_parse_default_namespace() {
+ let doc = parse("<root xmlns=\"http://example.com\"/>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_namespace(root), Some("http://example.com"));
+ }
+
+ #[test]
+ fn test_parse_prefixed_namespace() {
+ let doc = parse("<ns:root xmlns:ns=\"http://example.com\"/>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ assert_eq!(doc.node_namespace(root), Some("http://example.com"));
+ match &doc.node(root).kind {
+ NodeKind::Element { prefix, .. } => {
+ assert_eq!(prefix.as_deref(), Some("ns"));
+ }
+ _ => panic!("expected element"),
+ }
+ }
+
+ #[test]
+ fn test_parse_nested_namespace() {
+ // Child elements inherit the default namespace from the parent.
+ let doc = parse("<root xmlns=\"http://example.com\"><child/></root>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_namespace(root), Some("http://example.com"));
+
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_name(child), Some("child"));
+ assert_eq!(doc.node_namespace(child), Some("http://example.com"));
+ }
+
+ #[test]
+ fn test_parse_namespace_override() {
+ // A child element can override the parent's default namespace.
+ let doc = parse(
+ "<root xmlns=\"http://example.com\">\
+ <child xmlns=\"http://other.com\"/>\
+ </root>",
+ );
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_namespace(root), Some("http://example.com"));
+
+ let child = doc.first_child(root).unwrap();
+ assert_eq!(doc.node_namespace(child), Some("http://other.com"));
+ }
+
+ #[test]
+ fn test_parse_xml_namespace() {
+ // The xml: prefix is always bound to the XML namespace URI.
+ let doc = parse("<root xml:lang=\"en\"/>");
+ let root = doc.root_element().unwrap();
+ let attrs = doc.attributes(root);
+ assert_eq!(attrs.len(), 1);
+ assert_eq!(attrs[0].name, "lang");
+ assert_eq!(attrs[0].prefix.as_deref(), Some("xml"));
+ assert_eq!(
+ attrs[0].namespace.as_deref(),
+ Some("http://www.w3.org/XML/1998/namespace")
+ );
+ }
+
+ #[test]
+ fn test_parse_attribute_namespace() {
+ // Prefixed attributes get their namespace resolved.
+ let doc = parse("<root xmlns:app=\"http://example.com/app\" app:version=\"2.0\"/>");
+ let root = doc.root_element().unwrap();
+ let attrs = doc.attributes(root);
+
+ // Find the app:version attribute
+ let version_attr = attrs.iter().find(|a| a.name == "version").unwrap();
+ assert_eq!(version_attr.prefix.as_deref(), Some("app"));
+ assert_eq!(
+ version_attr.namespace.as_deref(),
+ Some("http://example.com/app")
+ );
+
+ // The xmlns:app attribute should not have a resolved namespace itself.
+ let xmlns_attr = attrs.iter().find(|a| a.name == "app").unwrap();
+ assert_eq!(xmlns_attr.prefix.as_deref(), Some("xmlns"));
+ assert_eq!(xmlns_attr.namespace, None);
+ }
+
+ // -- General entity inclusion in content (issue #43) --------------------
+ //
+ // XML 1.0 §4.4 "Included": a general entity referenced in content has
+ // its replacement text parsed as content. §4.5: character references in
+ // the declaration are expanded when the replacement text is built.
+
+ #[test]
+ fn test_parse_entity_charref_replacement() {
+ let doc = parse("<!DOCTYPE d [<!ENTITY e \"café\">]><d>&e;</d>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "caf\u{e9}");
+ }
+
+ #[test]
+ fn test_parse_entity_nested_reference() {
+ let doc = parse("<!DOCTYPE d [<!ENTITY a \"XYZ\"><!ENTITY b \"&a;\">]><d>&b;</d>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "XYZ");
+ // Tree shape: EntityRef(b) -> EntityRef(a) -> Text("XYZ").
+ let outer = doc.first_child(root).unwrap();
+ let NodeKind::EntityRef { ref name, .. } = doc.node(outer).kind else {
+ panic!("expected EntityRef, got {:?}", doc.node(outer).kind);
+ };
+ assert_eq!(name, "b");
+ let inner = doc.first_child(outer).unwrap();
+ let NodeKind::EntityRef { ref name, .. } = doc.node(inner).kind else {
+ panic!("expected EntityRef, got {:?}", doc.node(inner).kind);
+ };
+ assert_eq!(name, "a");
+ }
+
+ #[test]
+ fn test_parse_entity_amp_double_reference() {
+ // "&amp;" builds replacement text "&", which is then parsed
+ // as content, yielding "&".
+ let doc = parse("<!DOCTYPE d [<!ENTITY e \"&amp;\">]><d>&e;</d>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "&");
+ }
+
+ #[test]
+ fn test_parse_entity_markup_content() {
+ // Markup in the replacement text becomes real element children of
+ // the EntityRef node — not escaped text.
+ let doc = parse("<!DOCTYPE d [<!ENTITY e \"<b>hi</b>\">]><d>&e;</d>");
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.text_content(root), "hi");
+ let entity_ref = doc.first_child(root).unwrap();
+ let element = doc.first_child(entity_ref).unwrap();
+ assert_eq!(doc.node_name(element), Some("b"));
+ // Serialization re-emits the entity reference, preserving roundtrip.
+ let out = crate::serial::serialize(&doc);
+ assert!(
+ out.contains("<d>&e;</d>"),
+ "unexpected serialization: {out}"
+ );
+ }
+
+ #[test]
+ fn test_parse_entity_charref_markup() {
+ // "<b>hi</b>" expands to "<b>hi</b>" at declaration time
+ // (§4.5) and must be parsed as markup at reference time.
+ let doc = parse("<!DOCTYPE d [<!ENTITY e \"<b>hi</b>\">]><d>&e;</d>");
+ let root = doc.root_element().unwrap();
+ let entity_ref = doc.first_child(root).unwrap();
+ let element = doc.first_child(entity_ref).unwrap();
+ assert_eq!(doc.node_name(element), Some("b"));
+ assert_eq!(doc.text_content(root), "hi");
+ }
+
+ #[test]
+ fn test_parse_entity_markup_roundtrip() {
+ // parse -> serialize -> parse must preserve the element structure
+ // inside the entity expansion.
+ let input = "<!DOCTYPE d [<!ENTITY e \"<b>hi</b>\">]><d>&e;</d>";
+ let doc = parse(input);
+ let out = crate::serial::serialize(&doc);
+ let doc2 = parse(&out);
+ let root2 = doc2.root_element().unwrap();
+ assert_eq!(doc2.text_content(root2), "hi");
+ let entity_ref = doc2.first_child(root2).unwrap();
+ let element = doc2.first_child(entity_ref).unwrap();
+ assert_eq!(doc2.node_name(element), Some("b"));
+ }
+
+ #[test]
+ fn test_parse_entity_unbalanced_markup_rejected() {
+ // §4.3.2: replacement text must match the content production; an
+ // unbalanced start tag is not well-formed.
+ let result = Document::parse_str("<!DOCTYPE d [<!ENTITY e \"<b>hi\">]><d>&e;</d>");
+ assert!(
+ result.is_err(),
+ "unbalanced entity content must be rejected"
+ );
+ }
+
+ #[test]
+ fn test_parse_entity_split_tags_rejected() {
+ // A start tag in one entity and its end tag in another violates
+ // WFC: Element Type Match within the replacement text.
+ let result = Document::parse_str(
+ "<!DOCTYPE d [<!ENTITY open \"<b>\"><!ENTITY close \"</b>\">]><d>&open;hi&close;</d>",
+ );
+ assert!(result.is_err(), "split tag pair must be rejected");
+ }
+
+ #[test]
+ fn test_parse_entity_namespace_inherited() {
+ // Elements produced by entity expansion resolve namespaces in scope
+ // at the point of reference.
+ let doc = parse("<!DOCTYPE d [<!ENTITY e \"<b/>\">]><d xmlns=\"urn:x\">&e;</d>");
+ let root = doc.root_element().unwrap();
+ let entity_ref = doc.first_child(root).unwrap();
+ let element = doc.first_child(entity_ref).unwrap();
+ let NodeKind::Element { ref namespace, .. } = doc.node(element).kind else {
+ panic!("expected Element, got {:?}", doc.node(element).kind);
+ };
+ assert_eq!(namespace.as_deref(), Some("urn:x"));
+ }
+
+ #[test]
+ fn test_parse_entity_nesting_depth_limit() {
+ // A 40-deep reference chain exceeds MAX_ENTITY_DEPTH when expanded.
+ use std::fmt::Write as _;
+ let mut dtd = String::from("<!ENTITY e0 \"<b/>\">");
+ for i in 1..40u32 {
+ let _ = write!(dtd, "<!ENTITY e{i} \"<b>&e{};</b>\">", i - 1);
+ }
+ let xml = format!("<!DOCTYPE d [{dtd}]><d>&e39;</d>");
+ let result = Document::parse_str(&xml);
+ let Err(err) = result else {
+ panic!("expected depth-limited parse to fail");
+ };
+ assert!(
+ err.message.contains("depth"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_parse_entity_amplification_rejected() {
+ // Many references to a large entity trip the amplification guard
+ // (or the expansion counter) — billion-laughs protection.
+ let mut xml = String::from(
+ "<!DOCTYPE d [<!ENTITY a \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\">\
+ <!ENTITY b \"&a;&a;&a;&a;&a;&a;&a;&a;&a;&a;\">\
+ <!ENTITY c \"&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;\">\
+ <!ENTITY e \"&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;\">]><d>",
+ );
+ for _ in 0..20 {
+ xml.push_str("&e;");
+ }
+ xml.push_str("</d>");
+ let result = Document::parse_str(&xml);
+ let Err(err) = result else {
+ panic!("expected amplification attack to be rejected");
+ };
+ assert!(
+ err.message.contains("amplification") || err.message.contains("expansion limit"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+}
diff --git a/browser/vendor/xmloxide/src/serial/c14n.rs b/browser/vendor/xmloxide/src/serial/c14n.rs
new file mode 100644
index 000000000..ddaa02d16
--- /dev/null
+++ b/browser/vendor/xmloxide/src/serial/c14n.rs
@@ -0,0 +1,1184 @@
+//! Canonical XML (C14N) serialization.
+//!
+//! Implements Canonical XML 1.0 per the W3C specification:
+//! <https://www.w3.org/TR/xml-c14n/>
+//!
+//! Canonical XML produces a unique, deterministic byte sequence for logically
+//! equivalent XML documents. This is critical for XML digital signatures, where
+//! the canonical form must be identical regardless of insignificant variations
+//! in the original serialization.
+//!
+//! # Key C14N rules
+//!
+//! - No XML declaration in output
+//! - Attributes sorted by namespace URI then local name
+//! - Namespace declarations sorted by prefix
+//! - Empty elements always use start-end tag pairs (`<a></a>`, not `<a/>`)
+//! - CDATA sections replaced with escaped text content
+//! - Entity references expanded
+//! - DOCTYPE declarations removed
+//! - Specific character escaping rules for text content and attribute values
+//!
+//! # Examples
+//!
+//! ```
+//! use xmloxide::Document;
+//! use xmloxide::serial::c14n::{canonicalize, C14nOptions};
+//!
+//! let doc = Document::parse_str("<root><child/></root>").unwrap();
+//! let c14n = canonicalize(&doc, &C14nOptions::default());
+//! assert_eq!(c14n, "<root><child></child></root>");
+//! ```
+
+use std::collections::BTreeMap;
+
+use crate::tree::{Document, NodeId, NodeKind};
+
+/// Options for canonical XML serialization.
+///
+/// Controls the mode of canonicalization: inclusive or exclusive,
+/// with or without comments.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::serial::c14n::C14nOptions;
+///
+/// // Default: inclusive C14N with comments
+/// let opts = C14nOptions::default();
+/// assert!(opts.with_comments);
+/// assert!(!opts.exclusive);
+/// ```
+#[derive(Debug, Clone)]
+pub struct C14nOptions {
+ /// If true, include comments in output (C14N with comments).
+ /// If false, strip comments (plain C14N).
+ pub with_comments: bool,
+ /// If true, use exclusive C14N (Exclusive XML Canonicalization 1.0).
+ /// If false, use inclusive C14N.
+ pub exclusive: bool,
+ /// For exclusive C14N, the list of additional namespace prefixes to
+ /// treat as visibly utilized (the `InclusiveNamespaces PrefixList`).
+ pub inclusive_prefixes: Vec<String>,
+}
+
+impl Default for C14nOptions {
+ fn default() -> Self {
+ Self {
+ with_comments: true,
+ exclusive: false,
+ inclusive_prefixes: Vec::new(),
+ }
+ }
+}
+
+/// Serializes a document to Canonical XML (C14N 1.0).
+///
+/// Processes the entire document according to the Canonical XML specification.
+/// The output never includes an XML declaration, DOCTYPE declarations are
+/// removed, and all other canonicalization rules are applied.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+/// use xmloxide::serial::c14n::{canonicalize, C14nOptions};
+///
+/// let doc = Document::parse_str("<root attr2=\"b\" attr1=\"a\"/>").unwrap();
+/// let c14n = canonicalize(&doc, &C14nOptions::default());
+/// // Attributes are sorted, empty element uses start-end tags
+/// assert_eq!(c14n, "<root attr1=\"a\" attr2=\"b\"></root>");
+/// ```
+#[must_use]
+pub fn canonicalize(doc: &Document, options: &C14nOptions) -> String {
+ let mut ctx = C14nContext::new(doc, options);
+ ctx.process_document();
+ ctx.output
+}
+
+/// Serializes a subtree (specific node and its descendants) to Canonical XML.
+///
+/// This is useful when canonicalizing a portion of a document, for example
+/// when computing a digest for a specific element in an XML signature.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+/// use xmloxide::serial::c14n::{canonicalize_subtree, C14nOptions};
+///
+/// let doc = Document::parse_str("<root><child>text</child></root>").unwrap();
+/// let root = doc.root_element().unwrap();
+/// let c14n = canonicalize_subtree(&doc, root, &C14nOptions::default());
+/// assert_eq!(c14n, "<root><child>text</child></root>");
+/// ```
+#[must_use]
+pub fn canonicalize_subtree(doc: &Document, node: NodeId, options: &C14nOptions) -> String {
+ let mut ctx = C14nContext::new(doc, options);
+ ctx.process_node(node);
+ ctx.output
+}
+
+/// A namespace binding: prefix (empty string for default namespace) to URI.
+type NsBinding = BTreeMap<String, String>;
+
+/// Internal context for C14N serialization.
+struct C14nContext<'a> {
+ doc: &'a Document,
+ options: &'a C14nOptions,
+ output: String,
+ /// Stack of namespace bindings currently in scope.
+ /// Each entry maps prefix -> URI. The stack tracks what has been
+ /// rendered so far, to avoid redundant re-declarations.
+ rendered_ns_stack: Vec<NsBinding>,
+}
+
+impl<'a> C14nContext<'a> {
+ fn new(doc: &'a Document, options: &'a C14nOptions) -> Self {
+ // Seed the rendered namespace stack with the implicit `xml` prefix
+ // binding. The XML Namespaces spec reserves `xml` as always bound to
+ // `http://www.w3.org/XML/1998/namespace`. Canonical XML 1.0 §2.3
+ // ("Processing Model") requires that this binding is never emitted:
+ // "omit namespace node with local name xml, which defines the
+ // xml prefix, if its string value is
+ // http://www.w3.org/XML/1998/namespace"
+ // Exclusive C14N §3 defines itself as a variant of Canonical XML and
+ // does not restate this rule — it inherits it. Pre-populating the
+ // binding here makes the dedup check in `compute_ns_declarations`
+ // filter it out automatically when an element uses `xml:lang`,
+ // `xml:space`, or `xml:base`.
+ let mut initial_bindings = NsBinding::new();
+ initial_bindings.insert(
+ "xml".to_string(),
+ "http://www.w3.org/XML/1998/namespace".to_string(),
+ );
+ Self {
+ doc,
+ options,
+ output: String::new(),
+ rendered_ns_stack: vec![initial_bindings],
+ }
+ }
+
+ /// Processes the entire document node.
+ fn process_document(&mut self) {
+ let root = self.doc.root();
+ let children: Vec<NodeId> = self.doc.children(root).collect();
+ let root_elem_index = children
+ .iter()
+ .position(|&id| matches!(self.doc.node(id).kind, NodeKind::Element { .. }));
+
+ for (i, &child) in children.iter().enumerate() {
+ match &self.doc.node(child).kind {
+ NodeKind::Comment { .. } if !self.options.with_comments => {}
+ NodeKind::Comment { content } => {
+ if let Some(root_idx) = root_elem_index {
+ if i < root_idx {
+ write_c14n_comment(&mut self.output, content);
+ self.output.push('\n');
+ } else if i > root_idx {
+ self.output.push('\n');
+ write_c14n_comment(&mut self.output, content);
+ }
+ } else {
+ write_c14n_comment(&mut self.output, content);
+ }
+ }
+ NodeKind::ProcessingInstruction { target, data } => {
+ if let Some(root_idx) = root_elem_index {
+ if i < root_idx {
+ write_c14n_pi(&mut self.output, target, data.as_deref());
+ self.output.push('\n');
+ } else if i > root_idx {
+ self.output.push('\n');
+ write_c14n_pi(&mut self.output, target, data.as_deref());
+ }
+ } else {
+ write_c14n_pi(&mut self.output, target, data.as_deref());
+ }
+ }
+ NodeKind::Element { .. } => {
+ self.process_element(child);
+ }
+ // DOCTYPE, Document, Text, CData, EntityRef nodes at the
+ // document level are not output in C14N.
+ _ => {}
+ }
+ }
+ }
+
+ /// Processes a single node, dispatching by kind.
+ fn process_node(&mut self, id: NodeId) {
+ match &self.doc.node(id).kind {
+ NodeKind::Element { .. } => {
+ self.process_element(id);
+ }
+ NodeKind::Text { content } => {
+ write_c14n_text(&mut self.output, content);
+ }
+ NodeKind::CData { content } => {
+ // CDATA sections are replaced with their escaped text content
+ write_c14n_text(&mut self.output, content);
+ }
+ NodeKind::Comment { content } => {
+ if self.options.with_comments {
+ write_c14n_comment(&mut self.output, content);
+ }
+ }
+ NodeKind::ProcessingInstruction { target, data } => {
+ write_c14n_pi(&mut self.output, target, data.as_deref());
+ }
+ NodeKind::EntityRef { name, .. } => {
+ // Entity references are expanded. We output the entity
+ // reference's children (the expansion). If there are no
+ // children (unexpanded), output the reference as text.
+ let has_children = self.doc.first_child(id).is_some();
+ if has_children {
+ for child in self.doc.children(id) {
+ self.process_node(child);
+ }
+ } else {
+ // Fallback: output the predefined entity expansion
+ let expanded = expand_predefined_entity(name);
+ write_c14n_text(&mut self.output, expanded);
+ }
+ }
+ NodeKind::DocumentType { .. } | NodeKind::Document => {
+ // DOCTYPE and Document nodes are not output
+ }
+ }
+ }
+
+ /// Processes an element node according to C14N rules.
+ ///
+ /// This is the core of the canonicalization algorithm. It:
+ /// 1. Collects namespace declarations that need to be output
+ /// 2. Sorts and outputs namespace declarations
+ /// 3. Sorts and outputs attributes
+ /// 4. Recursively processes children
+ /// 5. Always uses start-end tag pairs (never self-closing)
+ fn process_element(&mut self, id: NodeId) {
+ let (name, prefix, namespace, attributes) = match &self.doc.node(id).kind {
+ NodeKind::Element {
+ name,
+ prefix,
+ namespace,
+ attributes,
+ } => (
+ name.clone(),
+ prefix.clone(),
+ namespace.clone(),
+ attributes.clone(),
+ ),
+ _ => return,
+ };
+
+ let qname = match &prefix {
+ Some(pfx) => format!("{pfx}:{name}"),
+ None => name.clone(),
+ };
+
+ let ns_to_output = self.compute_ns_declarations(
+ id,
+ &name,
+ prefix.as_deref(),
+ namespace.as_deref(),
+ &attributes,
+ );
+
+ self.output.push('<');
+ self.output.push_str(&qname);
+ self.write_ns_declarations(&ns_to_output);
+ self.write_sorted_attributes(&attributes);
+ self.output.push('>');
+
+ for child in self.doc.children(id) {
+ self.process_node(child);
+ }
+
+ self.output.push_str("</");
+ self.output.push_str(&qname);
+ self.output.push('>');
+
+ self.rendered_ns_stack.pop();
+ }
+
+ /// Computes which namespace declarations need to be output for an element,
+ /// pushes a new rendered namespace scope, and returns the sorted list of
+ /// (prefix, URI) pairs to emit.
+ fn compute_ns_declarations(
+ &mut self,
+ id: NodeId,
+ name: &str,
+ prefix: Option<&str>,
+ namespace: Option<&str>,
+ attributes: &[crate::tree::Attribute],
+ ) -> Vec<(String, String)> {
+ let ns_decls = if self.options.exclusive {
+ collect_exclusive_ns_decls(
+ &self.options.inclusive_prefixes,
+ prefix,
+ namespace,
+ attributes,
+ )
+ } else {
+ collect_inclusive_ns_decls(attributes)
+ };
+
+ let mut current_rendered = self.rendered_ns_stack.last().cloned().unwrap_or_default();
+ let mut ns_to_output: Vec<(String, String)> = Vec::new();
+
+ for (ns_prefix, ns_uri) in &ns_decls {
+ if current_rendered.get(ns_prefix) == Some(ns_uri) {
+ continue;
+ }
+
+ // Special case for `xmlns=""`: per Canonical XML 1.0 §3.7 and
+ // c14n11 §3.1, the empty default-namespace declaration is only
+ // emitted to undeclare a *non-empty* inherited default. If no
+ // non-empty default is currently in scope (parent has no default,
+ // or the inherited default is itself empty), the `xmlns=""` from
+ // the source must not appear in the canonical form.
+ if ns_prefix.is_empty() && ns_uri.is_empty() {
+ let has_nonempty_inherited_default =
+ current_rendered.get("").is_some_and(|s| !s.is_empty());
+ if !has_nonempty_inherited_default {
+ continue;
+ }
+ }
+
+ ns_to_output.push((ns_prefix.clone(), ns_uri.clone()));
+ current_rendered.insert(ns_prefix.clone(), ns_uri.clone());
+ }
+
+ // The default-namespace undeclaration rule applies in both modes. If
+ // the parent's default namespace is non-empty and visibly rendered in
+ // scope, and the current element is in no namespace (the source has
+ // an explicit `xmlns=""`), the canonical output must emit `xmlns=""`
+ // to undeclare it. Canonical XML 1.0 §2.3 covers the inclusive case;
+ // Exclusive C14N §3 inherits the rule (the default prefix is part of
+ // the visibly-utilized set when an explicit undeclaration is present
+ // in the source and the inherited default would otherwise propagate).
+ self.check_default_ns_undeclaration(
+ &ns_decls,
+ attributes,
+ &mut ns_to_output,
+ &mut current_rendered,
+ );
+
+ // Suppress unused variable warnings for future use
+ let _ = (id, name);
+
+ ns_to_output.sort_by(|a, b| a.0.cmp(&b.0));
+ self.rendered_ns_stack.push(current_rendered);
+ ns_to_output
+ }
+
+ /// Checks whether a default namespace undeclaration (`xmlns=""`) is needed
+ /// and adds it to the output list if so.
+ fn check_default_ns_undeclaration(
+ &self,
+ ns_decls: &[(String, String)],
+ attributes: &[crate::tree::Attribute],
+ ns_to_output: &mut Vec<(String, String)>,
+ current_rendered: &mut NsBinding,
+ ) {
+ let parent_default = self
+ .rendered_ns_stack
+ .last()
+ .and_then(|m| m.get(""))
+ .cloned();
+
+ let has_current_default = ns_decls.iter().any(|(p, _)| p.is_empty());
+
+ if !has_current_default && parent_default.is_some() && parent_default.as_deref() != Some("")
+ {
+ let has_explicit_undecl = attributes
+ .iter()
+ .any(|a| a.prefix.is_none() && a.name == "xmlns" && a.value.is_empty());
+ if has_explicit_undecl {
+ ns_to_output.push((String::new(), String::new()));
+ current_rendered.insert(String::new(), String::new());
+ }
+ }
+ }
+
+ /// Writes sorted namespace declarations to the output.
+ fn write_ns_declarations(&mut self, ns_to_output: &[(String, String)]) {
+ for (ns_prefix, ns_uri) in ns_to_output {
+ if ns_prefix.is_empty() {
+ self.output.push_str(" xmlns=\"");
+ } else {
+ self.output.push_str(" xmlns:");
+ self.output.push_str(ns_prefix);
+ self.output.push_str("=\"");
+ }
+ write_c14n_attr_value(&mut self.output, ns_uri);
+ self.output.push('"');
+ }
+ }
+
+ /// Writes sorted non-namespace attributes to the output.
+ fn write_sorted_attributes(&mut self, attributes: &[crate::tree::Attribute]) {
+ let mut regular_attrs: Vec<_> = attributes
+ .iter()
+ .filter(|a| !is_ns_declaration(a))
+ .collect();
+
+ regular_attrs.sort_by(|a, b| {
+ let a_ns = a.namespace.as_deref().unwrap_or("");
+ let b_ns = b.namespace.as_deref().unwrap_or("");
+ match a_ns.cmp(b_ns) {
+ std::cmp::Ordering::Equal => a.name.cmp(&b.name),
+ other => other,
+ }
+ });
+
+ for attr in ®ular_attrs {
+ self.output.push(' ');
+ if let Some(pfx) = &attr.prefix {
+ self.output.push_str(pfx);
+ self.output.push(':');
+ }
+ self.output.push_str(&attr.name);
+ self.output.push_str("=\"");
+ write_c14n_attr_value(&mut self.output, &attr.value);
+ self.output.push('"');
+ }
+ }
+}
+
+/// Returns true if the attribute is a namespace declaration (`xmlns` or `xmlns:*`).
+fn is_ns_declaration(attr: &crate::tree::Attribute) -> bool {
+ attr.prefix.as_deref() == Some("xmlns") || (attr.prefix.is_none() && attr.name == "xmlns")
+}
+
+/// Collects namespace declarations for inclusive C14N.
+///
+/// In inclusive mode, all namespace declarations present on the element's
+/// attributes are collected. The rendering stack handles deduplication.
+fn collect_inclusive_ns_decls(attributes: &[crate::tree::Attribute]) -> Vec<(String, String)> {
+ let mut decls = Vec::new();
+ for attr in attributes {
+ if attr.prefix.as_deref() == Some("xmlns") {
+ decls.push((attr.name.clone(), attr.value.clone()));
+ } else if attr.prefix.is_none() && attr.name == "xmlns" {
+ decls.push((String::new(), attr.value.clone()));
+ }
+ }
+ decls
+}
+
+/// Collects namespace declarations for exclusive C14N.
+///
+/// In exclusive mode, only "visibly utilized" namespace prefixes are output.
+/// A namespace prefix is visibly utilized if it appears as the element's own
+/// prefix, an attribute's prefix, or is listed in the `inclusive_prefixes`
+/// option.
+fn collect_exclusive_ns_decls(
+ inclusive_prefixes: &[String],
+ elem_prefix: Option<&str>,
+ elem_ns: Option<&str>,
+ attributes: &[crate::tree::Attribute],
+) -> Vec<(String, String)> {
+ let mut all_decls: BTreeMap<String, String> = BTreeMap::new();
+ for attr in attributes {
+ if attr.prefix.as_deref() == Some("xmlns") {
+ all_decls.insert(attr.name.clone(), attr.value.clone());
+ } else if attr.prefix.is_none() && attr.name == "xmlns" {
+ all_decls.insert(String::new(), attr.value.clone());
+ }
+ }
+
+ let mut utilized: Vec<String> = Vec::new();
+
+ if let Some(pfx) = elem_prefix {
+ utilized.push(pfx.to_string());
+ } else if elem_ns.is_some() {
+ utilized.push(String::new());
+ }
+
+ for attr in attributes {
+ if is_ns_declaration(attr) {
+ continue;
+ }
+ if let Some(pfx) = &attr.prefix {
+ if !utilized.contains(pfx) {
+ utilized.push(pfx.clone());
+ }
+ }
+ }
+
+ for pfx in inclusive_prefixes {
+ let key = if pfx == "#default" {
+ String::new()
+ } else {
+ pfx.clone()
+ };
+ if !utilized.contains(&key) {
+ utilized.push(key);
+ }
+ }
+
+ // Build a map of prefix -> URI from both explicit xmlns declarations
+ // and the resolved namespace information on the element and attributes.
+ // This handles the case where a subtree is canonicalized and the xmlns
+ // declaration lives on an ancestor element.
+ let mut available_bindings = all_decls;
+
+ // Add the element's own namespace binding
+ if let (Some(pfx), Some(uri)) = (elem_prefix, elem_ns) {
+ available_bindings
+ .entry(pfx.to_string())
+ .or_insert_with(|| uri.to_string());
+ } else if let (None, Some(uri)) = (elem_prefix, elem_ns) {
+ available_bindings
+ .entry(String::new())
+ .or_insert_with(|| uri.to_string());
+ }
+
+ // Add attribute namespace bindings
+ for attr in attributes {
+ if is_ns_declaration(attr) {
+ continue;
+ }
+ if let (Some(pfx), Some(uri)) = (&attr.prefix, &attr.namespace) {
+ available_bindings
+ .entry(pfx.clone())
+ .or_insert_with(|| uri.clone());
+ }
+ }
+
+ let mut result = Vec::new();
+ for pfx in &utilized {
+ if let Some(uri) = available_bindings.get(pfx) {
+ result.push((pfx.clone(), uri.clone()));
+ }
+ }
+ result
+}
+
+/// Writes a processing instruction in C14N form.
+fn write_c14n_pi(out: &mut String, target: &str, data: Option<&str>) {
+ out.push_str("<?");
+ out.push_str(target);
+ if let Some(d) = data {
+ out.push(' ');
+ out.push_str(d);
+ }
+ out.push_str("?>");
+}
+
+/// Writes a comment in C14N form.
+fn write_c14n_comment(out: &mut String, content: &str) {
+ out.push_str("<!--");
+ out.push_str(content);
+ out.push_str("-->");
+}
+
+/// Escapes text content per C14N rules.
+///
+/// C14N text escaping: `&` -> `&`, `<` -> `<`, `>` -> `>`,
+/// `\r` -> `
`
+fn write_c14n_text(out: &mut String, text: &str) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ '\r' => out.push_str("
"),
+ _ => out.push(ch),
+ }
+ }
+}
+
+/// Escapes an attribute value per C14N rules.
+///
+/// C14N attribute value escaping: `&` -> `&`, `<` -> `<`,
+/// `"` -> `"`, `\t` -> `	`, `\n` -> `
`, `\r` -> `
`
+fn write_c14n_attr_value(out: &mut String, text: &str) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '"' => out.push_str("""),
+ '\t' => out.push_str("	"),
+ '\n' => out.push_str("
"),
+ '\r' => out.push_str("
"),
+ _ => out.push(ch),
+ }
+ }
+}
+
+/// Expands a predefined XML entity name to its character value.
+fn expand_predefined_entity(name: &str) -> &str {
+ match name {
+ "amp" => "&",
+ "lt" => "<",
+ "gt" => ">",
+ "apos" => "'",
+ "quot" => "\"",
+ _ => "",
+ }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+ use crate::tree::Attribute;
+
+ /// Helper: create a document from XML and return its C14N output.
+ fn c14n(xml: &str) -> String {
+ let doc = Document::parse_str(xml).unwrap();
+ canonicalize(&doc, &C14nOptions::default())
+ }
+
+ /// Helper: create a C14N without comments.
+ fn c14n_no_comments(xml: &str) -> String {
+ let doc = Document::parse_str(xml).unwrap();
+ canonicalize(
+ &doc,
+ &C14nOptions {
+ with_comments: false,
+ ..C14nOptions::default()
+ },
+ )
+ }
+
+ #[test]
+ fn test_c14n_empty_element_uses_start_end_tags() {
+ // C14N rule: empty elements always use start-end tag pairs, never
+ // self-closing.
+ let result = c14n("<root/>");
+ assert_eq!(result, "<root></root>");
+
+ let result = c14n("<root><child/></root>");
+ assert_eq!(result, "<root><child></child></root>");
+ }
+
+ #[test]
+ fn test_c14n_attribute_sorting() {
+ // C14N rule: attributes sorted by namespace URI then local name.
+ // Non-namespaced attributes (empty NS URI) come first.
+ let result = c14n("<root z=\"1\" a=\"2\" m=\"3\"/>");
+ assert_eq!(result, "<root a=\"2\" m=\"3\" z=\"1\"></root>");
+ }
+
+ #[test]
+ fn test_c14n_namespace_declaration_ordering() {
+ // C14N rule: namespace declarations sorted by prefix.
+ let result = c14n("<root xmlns:z=\"http://z.example\" xmlns:a=\"http://a.example\"/>");
+ assert_eq!(
+ result,
+ "<root xmlns:a=\"http://a.example\" xmlns:z=\"http://z.example\"></root>"
+ );
+ }
+
+ #[test]
+ fn test_c14n_text_content_escaping() {
+ // C14N text escaping: & < > and \r
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "root".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let text = doc.create_node(NodeKind::Text {
+ content: "a & b < c > d\re".to_string(),
+ });
+ doc.append_child(root, elem);
+ doc.append_child(elem, text);
+ let result = canonicalize(&doc, &C14nOptions::default());
+ assert_eq!(result, "<root>a & b < c > d
e</root>");
+ }
+
+ #[test]
+ fn test_c14n_attribute_value_escaping() {
+ // C14N attribute value escaping: & < " \t \n \r
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "root".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![Attribute {
+ name: "val".to_string(),
+ value: "a&b<c\"d\te\nf\rg".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ }],
+ });
+ doc.append_child(root, elem);
+ let result = canonicalize(&doc, &C14nOptions::default());
+ assert_eq!(
+ result,
+ "<root val=\"a&b<c"d	e
f
g\"></root>"
+ );
+ }
+
+ #[test]
+ fn test_c14n_no_xml_declaration() {
+ // C14N rule: output never includes XML declaration.
+ let result = c14n("<?xml version=\"1.0\" encoding=\"UTF-8\"?><root/>");
+ assert_eq!(result, "<root></root>");
+ assert!(!result.contains("<?xml"));
+ }
+
+ #[test]
+ fn test_c14n_cdata_replaced_with_escaped_text() {
+ // C14N rule: CDATA sections replaced with escaped text content.
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "root".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let cdata = doc.create_node(NodeKind::CData {
+ content: "x < 1 && y > 2".to_string(),
+ });
+ doc.append_child(root, elem);
+ doc.append_child(elem, cdata);
+ let result = canonicalize(&doc, &C14nOptions::default());
+ assert_eq!(result, "<root>x < 1 && y > 2</root>");
+ }
+
+ #[test]
+ fn test_c14n_comments_included_by_default() {
+ // C14N with comments: comments are included.
+ let result = c14n("<root><!-- hello --></root>");
+ assert_eq!(result, "<root><!-- hello --></root>");
+ }
+
+ #[test]
+ fn test_c14n_comments_excluded_when_option_set() {
+ // C14N without comments: comments are stripped.
+ let result = c14n_no_comments("<root><!-- hello --></root>");
+ assert_eq!(result, "<root></root>");
+ }
+
+ #[test]
+ fn test_c14n_doctype_removed() {
+ // C14N rule: DOCTYPE declarations removed from output.
+ let mut doc = Document::new();
+ let root = doc.root();
+ let doctype = doc.create_node(NodeKind::DocumentType {
+ name: "html".to_string(),
+ system_id: None,
+ public_id: None,
+ internal_subset: None,
+ });
+ let elem = doc.create_node(NodeKind::Element {
+ name: "html".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, doctype);
+ doc.append_child(root, elem);
+ let result = canonicalize(&doc, &C14nOptions::default());
+ assert_eq!(result, "<html></html>");
+ assert!(!result.contains("DOCTYPE"));
+ }
+
+ #[test]
+ fn test_c14n_processing_instructions_preserved() {
+ // C14N rule: processing instructions are preserved.
+ let result = c14n("<root><?target data?></root>");
+ assert_eq!(result, "<root><?target data?></root>");
+ }
+
+ #[test]
+ fn test_c14n_simple_document_roundtrip() {
+ // A simple well-formed document should canonicalize predictably.
+ let result = c14n("<root><a>hello</a><b>world</b></root>");
+ assert_eq!(result, "<root><a>hello</a><b>world</b></root>");
+ }
+
+ #[test]
+ fn test_c14n_namespace_handling_default() {
+ // Default namespace declaration should be output.
+ let result = c14n("<root xmlns=\"http://example.com\"/>");
+ assert_eq!(result, "<root xmlns=\"http://example.com\"></root>");
+ }
+
+ #[test]
+ fn test_c14n_namespace_handling_prefixed() {
+ // Prefixed namespace declaration should be output.
+ let result = c14n("<ns:root xmlns:ns=\"http://example.com\"/>");
+ assert_eq!(
+ result,
+ "<ns:root xmlns:ns=\"http://example.com\"></ns:root>"
+ );
+ }
+
+ #[test]
+ fn test_c14n_whitespace_only_text_preserved() {
+ // Whitespace-only text nodes within elements are preserved.
+ let result = c14n("<root> </root>");
+ assert_eq!(result, "<root> </root>");
+
+ let result = c14n("<root> \n </root>");
+ assert_eq!(result, "<root> \n </root>");
+ }
+
+ #[test]
+ fn test_c14n_exclusive_namespace_scoping() {
+ // In exclusive C14N, only visibly utilized namespaces are output.
+ let doc = Document::parse_str(
+ "<root xmlns:a=\"http://a.example\" xmlns:b=\"http://b.example\">\
+ <a:child/></root>",
+ )
+ .unwrap();
+
+ let root_elem = doc.root_element().unwrap();
+ let child = doc.first_child(root_elem).unwrap();
+
+ let result = canonicalize_subtree(
+ &doc,
+ child,
+ &C14nOptions {
+ with_comments: true,
+ exclusive: true,
+ inclusive_prefixes: vec![],
+ },
+ );
+
+ // In exclusive mode on the subtree, only the "a" namespace that is
+ // visibly utilized should appear. The "b" namespace should not.
+ assert!(result.contains("xmlns:a="));
+ assert!(!result.contains("xmlns:b="));
+ }
+
+ #[test]
+ fn test_c14n_complex_document_all_node_types() {
+ // A document exercising many node types together.
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ // Comment before root element
+ let comment_before = doc.create_node(NodeKind::Comment {
+ content: " prologue comment ".to_string(),
+ });
+ doc.append_child(root, comment_before);
+
+ // PI before root element
+ let pi_before = doc.create_node(NodeKind::ProcessingInstruction {
+ target: "app".to_string(),
+ data: Some("start".to_string()),
+ });
+ doc.append_child(root, pi_before);
+
+ // Root element with attributes
+ let elem = doc.create_node(NodeKind::Element {
+ name: "root".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![
+ Attribute {
+ name: "z".to_string(),
+ value: "1".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ },
+ Attribute {
+ name: "a".to_string(),
+ value: "2".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ },
+ ],
+ });
+ doc.append_child(root, elem);
+
+ // Text child
+ let text = doc.create_node(NodeKind::Text {
+ content: "hello".to_string(),
+ });
+ doc.append_child(elem, text);
+
+ // CDATA child
+ let cdata = doc.create_node(NodeKind::CData {
+ content: "a<b".to_string(),
+ });
+ doc.append_child(elem, cdata);
+
+ // Comment child
+ let inner_comment = doc.create_node(NodeKind::Comment {
+ content: " inner ".to_string(),
+ });
+ doc.append_child(elem, inner_comment);
+
+ // PI child
+ let inner_pi = doc.create_node(NodeKind::ProcessingInstruction {
+ target: "proc".to_string(),
+ data: None,
+ });
+ doc.append_child(elem, inner_pi);
+
+ // Comment after root element
+ let comment_after = doc.create_node(NodeKind::Comment {
+ content: " epilogue ".to_string(),
+ });
+ doc.append_child(root, comment_after);
+
+ let result = canonicalize(&doc, &C14nOptions::default());
+
+ // Expected: comment + newline, PI + newline, root element
+ // (sorted attrs), content, newline + trailing comment
+ assert_eq!(
+ result,
+ "<!-- prologue comment -->\n\
+ <?app start?>\n\
+ <root a=\"2\" z=\"1\">helloa<b<!-- inner --><?proc?></root>\n\
+ <!-- epilogue -->"
+ );
+ }
+
+ #[test]
+ fn test_c14n_subtree_serialization() {
+ // Canonicalize only a subtree of a larger document.
+ let doc = Document::parse_str("<root><child attr=\"value\">text</child></root>").unwrap();
+ let root_elem = doc.root_element().unwrap();
+ let child = doc.first_child(root_elem).unwrap();
+
+ let result = canonicalize_subtree(&doc, child, &C14nOptions::default());
+ assert_eq!(result, "<child attr=\"value\">text</child>");
+ }
+
+ #[test]
+ fn test_c14n_redundant_namespace_not_redeclared() {
+ // When a child element inherits a namespace from a parent,
+ // C14N should not re-declare it.
+ let result = c14n(
+ "<root xmlns=\"http://example.com\">\
+ <child xmlns=\"http://example.com\"/></root>",
+ );
+ // The child should not have xmlns re-declared
+ assert_eq!(
+ result,
+ "<root xmlns=\"http://example.com\"><child></child></root>"
+ );
+ }
+
+ #[test]
+ fn test_c14n_mixed_namespace_and_regular_attrs() {
+ // Namespace declarations come before regular attributes,
+ // sorted by prefix. Regular attributes sorted by ns URI then
+ // local name.
+ let result =
+ c14n("<root xmlns:b=\"http://b\" xmlns:a=\"http://a\" b:y=\"1\" a:x=\"2\" c=\"3\"/>");
+ // Namespace decls: xmlns:a, xmlns:b (sorted by prefix)
+ // Regular attrs: c (no ns, empty URI), a:x (http://a), b:y (http://b)
+ assert_eq!(
+ result,
+ "<root xmlns:a=\"http://a\" xmlns:b=\"http://b\" c=\"3\" a:x=\"2\" b:y=\"1\"></root>"
+ );
+ }
+
+ #[test]
+ fn test_c14n_pi_without_data() {
+ // Processing instruction with no data.
+ let result = c14n("<root><?target?></root>");
+ assert_eq!(result, "<root><?target?></root>");
+ }
+
+ #[test]
+ fn test_c14n_nested_elements() {
+ // Deeply nested elements all use start-end tags.
+ let result = c14n("<a><b><c/></b></a>");
+ assert_eq!(result, "<a><b><c></c></b></a>");
+ }
+
+ #[test]
+ fn test_c14n_exclusive_with_inclusive_prefixes() {
+ // Exclusive C14N with additional inclusive prefixes.
+ let doc = Document::parse_str(
+ "<root xmlns:a=\"http://a\" xmlns:b=\"http://b\">\
+ <child/></root>",
+ )
+ .unwrap();
+ let root_elem = doc.root_element().unwrap();
+ let child = doc.first_child(root_elem).unwrap();
+
+ let result = canonicalize_subtree(
+ &doc,
+ child,
+ &C14nOptions {
+ with_comments: true,
+ exclusive: true,
+ inclusive_prefixes: vec!["b".to_string()],
+ },
+ );
+
+ // The "b" prefix is forced via inclusive_prefixes even though
+ // it's not visibly utilized on the child element.
+ // However, the child element doesn't have the xmlns:b declaration
+ // as an attribute, so it won't appear (it's on the parent).
+ // This tests the boundary condition.
+ assert_eq!(result, "<child></child>");
+ }
+
+ #[test]
+ fn test_c14n_document_comments_and_pis_spacing() {
+ // Comments and PIs before the root element get a trailing newline.
+ // Comments and PIs after the root element get a leading newline.
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let pi = doc.create_node(NodeKind::ProcessingInstruction {
+ target: "before".to_string(),
+ data: None,
+ });
+ doc.append_child(root, pi);
+
+ let elem = doc.create_node(NodeKind::Element {
+ name: "root".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, elem);
+
+ let pi_after = doc.create_node(NodeKind::ProcessingInstruction {
+ target: "after".to_string(),
+ data: None,
+ });
+ doc.append_child(root, pi_after);
+
+ let result = canonicalize(&doc, &C14nOptions::default());
+ assert_eq!(result, "<?before?>\n<root></root>\n<?after?>");
+ }
+
+ #[test]
+ fn test_c14n_inclusive_xml_prefix_not_emitted() {
+ // XML Namespaces reserves the `xml` prefix as implicitly bound to
+ // `http://www.w3.org/XML/1998/namespace`. Canonical XML §2.3 requires
+ // that this binding is never emitted as an `xmlns:xml` declaration.
+ let result = c14n("<root xml:lang=\"en\">hello</root>");
+ assert_eq!(result, "<root xml:lang=\"en\">hello</root>");
+ assert!(
+ !result.contains("xmlns:xml"),
+ "implicit xml namespace should not be emitted, got: {result}"
+ );
+ }
+
+ #[test]
+ fn test_c14n_exclusive_xml_prefix_not_emitted_on_root() {
+ // Exclusive C14N §3 is defined as a variant of Canonical XML and
+ // inherits the §2.3 rule that suppresses the implicit `xml` prefix
+ // binding from canonical output.
+ let doc = Document::parse_str("<root xml:lang=\"en\">hello</root>").unwrap();
+ let result = canonicalize(
+ &doc,
+ &C14nOptions {
+ with_comments: false,
+ exclusive: true,
+ inclusive_prefixes: vec![],
+ },
+ );
+ assert_eq!(result, "<root xml:lang=\"en\">hello</root>");
+ assert!(!result.contains("xmlns:xml"));
+ }
+
+ #[test]
+ fn test_c14n_exclusive_xml_prefix_not_emitted_on_subtree() {
+ // When canonicalizing a subtree whose ancestor carries `xml:lang`,
+ // the subtree must not spuriously declare `xmlns:xml` just because
+ // an `xml:` attribute appears in scope.
+ let doc = Document::parse_str(
+ "<root xmlns=\"http://example.com\" xml:lang=\"en\">\
+ <child xml:space=\"preserve\">hi</child></root>",
+ )
+ .unwrap();
+ let root = doc.root_element().unwrap();
+ let child = doc
+ .children(root)
+ .find(|&n| doc.node_name(n) == Some("child"))
+ .unwrap();
+
+ let result = canonicalize_subtree(
+ &doc,
+ child,
+ &C14nOptions {
+ with_comments: false,
+ exclusive: true,
+ inclusive_prefixes: vec![],
+ },
+ );
+
+ assert!(
+ !result.contains("xmlns:xml"),
+ "implicit xml namespace should not be emitted in exclusive C14N, got: {result}"
+ );
+ // The default namespace from the root IS visibly utilized by the
+ // child element's unprefixed name, so it should appear.
+ assert!(result.contains("xmlns=\"http://example.com\""));
+ assert!(result.contains("xml:space=\"preserve\""));
+ }
+
+ /// W3C Canonical XML §2.3 — when a child element is in no namespace under
+ /// a parent that has a non-empty default namespace, the canonical output
+ /// must emit `xmlns=""` to undeclare the inherited default. This is the
+ /// inclusive-mode baseline; libxml2's `xmllint --c14n` exhibits the same.
+ #[test]
+ fn test_c14n_inclusive_emits_default_ns_undeclaration() {
+ let xml =
+ r#"<Envelope xmlns="http://example.org/usps"><NonNs xmlns="">child</NonNs></Envelope>"#;
+ let result = c14n(xml);
+ assert!(
+ result.contains("<NonNs xmlns=\"\">"),
+ "default namespace undeclaration missing, got: {result}"
+ );
+ }
+
+ /// W3C Exclusive C14N §3 inherits Canonical XML's default-namespace
+ /// undeclaration rule. Without it, the canonical form leaks the parent's
+ /// default namespace into a child that explicitly has none, producing a
+ /// digest that diverges from libxml2 / xmlsec.
+ #[test]
+ fn test_c14n_exclusive_emits_default_ns_undeclaration() {
+ let xml =
+ r#"<Envelope xmlns="http://example.org/usps"><NonNs xmlns="">child</NonNs></Envelope>"#;
+ let doc = Document::parse_str(xml).unwrap();
+ let result = canonicalize(
+ &doc,
+ &C14nOptions {
+ with_comments: false,
+ exclusive: true,
+ inclusive_prefixes: vec![],
+ },
+ );
+ assert!(
+ result.contains("<NonNs xmlns=\"\">"),
+ "exclusive C14N must emit xmlns=\"\" to undeclare inherited default ns, got: {result}"
+ );
+ }
+
+ /// Negative companion: when no inherited default exists, the output must
+ /// NOT emit a spurious `xmlns=""`.
+ #[test]
+ fn test_c14n_exclusive_no_undeclaration_when_no_inherited_default() {
+ let xml = r"<root><child>x</child></root>";
+ let doc = Document::parse_str(xml).unwrap();
+ let result = canonicalize(
+ &doc,
+ &C14nOptions {
+ with_comments: false,
+ exclusive: true,
+ inclusive_prefixes: vec![],
+ },
+ );
+ assert!(
+ !result.contains("xmlns=\"\""),
+ "exclusive C14N must not emit xmlns=\"\" when no inherited default to undeclare, got: {result}"
+ );
+ }
+}
diff --git a/browser/vendor/xmloxide/src/serial/html.rs b/browser/vendor/xmloxide/src/serial/html.rs
new file mode 100644
index 000000000..4b90b6e36
--- /dev/null
+++ b/browser/vendor/xmloxide/src/serial/html.rs
@@ -0,0 +1,970 @@
+//! HTML serializer.
+//!
+//! Serializes a `Document` tree into an HTML string, following libxml2's
+//! `htmlSaveFile` behavior. Key differences from XML serialization:
+//!
+//! - No XML declaration (`<?xml ...?>`)
+//! - Void elements use `<br>` syntax (no `/>`)
+//! - Non-void empty elements use `<p></p>` (no `<p/>`)
+//! - Raw text elements (script, style) are not escaped
+//! - Non-ASCII characters are re-encoded as HTML named entities where possible
+//! - Formatting newlines around block-level elements
+
+use crate::html::entities::reverse_lookup_entity;
+use crate::html::{is_boolean_attribute, is_raw_text_element, is_void_element};
+use crate::tree::{Document, NodeId, NodeKind};
+
+/// Serializes a document to an HTML string.
+///
+/// Produces output compatible with libxml2's HTML serialization:
+/// - DOCTYPE declaration (if present, or default HTML 4.0 Transitional)
+/// - HTML void elements serialized without self-closing slash
+/// - Script/style content preserved without escaping
+/// - Non-ASCII characters re-encoded as named HTML entities
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::html::parse_html;
+/// use xmloxide::serial::html::serialize_html;
+///
+/// let doc = parse_html("<p>Hello</p>").unwrap();
+/// let html = serialize_html(&doc);
+/// assert!(html.contains("<p>"));
+/// ```
+#[must_use]
+pub fn serialize_html(doc: &Document) -> String {
+ let mut output = String::new();
+
+ // Detect whether the document declares UTF-8 charset.
+ // If so, non-ASCII characters are preserved as raw UTF-8.
+ // Otherwise (default ISO-8859-1), they are re-encoded as named entities.
+ let reencode = !detect_utf8_charset(doc);
+
+ // Serialize children of the document root (DOCTYPE, elements, etc.)
+ for child in doc.children(doc.root()) {
+ serialize_html_node(doc, child, &mut output, reencode);
+ }
+
+ // Trailing newline (matches libxml2 output convention)
+ if !output.ends_with('\n') {
+ output.push('\n');
+ }
+
+ output
+}
+
+/// Serializes one node without the document serializer's formatting newlines
+/// or legacy non-ASCII re-encoding. This matches `lxml.html.tostring(...,
+/// encoding="unicode")`, which Scrapling exposes as `html_content`.
+#[must_use]
+pub fn serialize_html_subtree(doc: &Document, node: NodeId) -> String {
+ let mut output = String::new();
+ serialize_html_subtree_node(doc, node, &mut output);
+ output
+}
+
+fn serialize_html_subtree_node(doc: &Document, id: NodeId, out: &mut String) {
+ match &doc.node(id).kind {
+ NodeKind::Element {
+ name,
+ prefix,
+ attributes,
+ ..
+ } => {
+ out.push('<');
+ if let Some(prefix) = prefix {
+ out.push_str(prefix);
+ out.push(':');
+ }
+ out.push_str(name);
+ for attr in attributes {
+ out.push(' ');
+ if let Some(prefix) = &attr.prefix {
+ out.push_str(prefix);
+ out.push(':');
+ }
+ out.push_str(&attr.name);
+ if !is_boolean_attribute(&attr.name) && attr.raw_value.as_deref() != Some("") {
+ out.push_str("=\"");
+ write_unicode_attribute(out, &attr.value);
+ out.push('"');
+ }
+ }
+ out.push('>');
+ if is_void_element(&name.to_ascii_lowercase()) {
+ return;
+ }
+ let lower_name = name.to_ascii_lowercase();
+ if is_raw_text_element(&lower_name) {
+ for child in doc.children(id) {
+ if let Some(text) = doc.node_text(child) {
+ out.push_str(text);
+ } else {
+ serialize_html_subtree_node(doc, child, out);
+ }
+ }
+ } else if lower_name == "plaintext" {
+ for child in doc.children(id) {
+ if let Some(text) = doc.node_text(child) {
+ write_plaintext(out, text);
+ } else {
+ serialize_html_subtree_node(doc, child, out);
+ }
+ }
+ } else {
+ for child in doc.children(id) {
+ serialize_html_subtree_node(doc, child, out);
+ }
+ }
+ out.push_str("</");
+ if let Some(prefix) = prefix {
+ out.push_str(prefix);
+ out.push(':');
+ }
+ out.push_str(name);
+ out.push('>');
+ }
+ NodeKind::Text { content } | NodeKind::CData { content } => {
+ write_unicode_text(out, content);
+ }
+ NodeKind::Comment { content } => {
+ out.push_str("<!--");
+ out.push_str(content);
+ out.push_str("-->");
+ }
+ NodeKind::EntityRef { value, name } => {
+ if let Some(value) = value {
+ write_unicode_text(out, value);
+ } else {
+ out.push('&');
+ out.push_str(name);
+ out.push(';');
+ }
+ }
+ NodeKind::ProcessingInstruction { target, data } => {
+ out.push_str("<?");
+ out.push_str(target);
+ if let Some(data) = data {
+ out.push(' ');
+ out.push_str(data);
+ }
+ out.push('>');
+ }
+ NodeKind::Document | NodeKind::DocumentType { .. } => {
+ for child in doc.children(id) {
+ serialize_html_subtree_node(doc, child, out);
+ }
+ }
+ }
+}
+
+fn write_unicode_text(out: &mut String, value: &str) {
+ for ch in value.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ _ => out.push(ch),
+ }
+ }
+}
+
+fn write_plaintext(out: &mut String, value: &str) {
+ for ch in value.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ _ => out.push(ch),
+ }
+ }
+}
+
+fn write_unicode_attribute(out: &mut String, value: &str) {
+ for ch in value.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '"' => out.push_str("""),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ _ => out.push(ch),
+ }
+ }
+}
+
+/// Detects whether the document declares a UTF-8 charset via `<meta>` tags.
+///
+/// Checks for:
+/// - `<meta charset="utf-8">`
+/// - `<meta http-equiv="Content-Type" content="...charset=utf-8...">`
+///
+/// When the charset is UTF-8, non-ASCII characters are preserved as raw
+/// UTF-8 in the output. Otherwise (default ISO-8859-1 for HTML), they
+/// are re-encoded as named HTML entities.
+fn detect_utf8_charset(doc: &Document) -> bool {
+ let root = doc.root();
+ for id in doc.children(root) {
+ if check_meta_charset(doc, id) {
+ return true;
+ }
+ }
+ false
+}
+
+/// Recursively checks an element subtree for meta charset declarations.
+fn check_meta_charset(doc: &Document, id: NodeId) -> bool {
+ if let NodeKind::Element {
+ name, attributes, ..
+ } = &doc.node(id).kind
+ {
+ if name == "meta" {
+ // Check <meta charset="utf-8">
+ for attr in attributes {
+ if attr.name == "charset" && attr.value.eq_ignore_ascii_case("utf-8") {
+ return true;
+ }
+ }
+ // Check <meta http-equiv="Content-Type" content="...charset=utf-8...">
+ let is_content_type = attributes
+ .iter()
+ .any(|a| a.name == "http-equiv" && a.value.eq_ignore_ascii_case("content-type"));
+ if is_content_type {
+ for attr in attributes {
+ if attr.name == "content" {
+ let lower = attr.value.to_ascii_lowercase();
+ if lower.contains("charset=utf-8") {
+ return true;
+ }
+ }
+ }
+ }
+ }
+ // Recurse into children
+ for child in doc.children(id) {
+ if check_meta_charset(doc, child) {
+ return true;
+ }
+ }
+ }
+ false
+}
+
+/// Returns true if the element is an HTML inline element.
+///
+/// libxml2 categorizes elements as inline or block-level. Block-level
+/// elements get formatting newlines around them in the serialized output.
+fn is_inline_element(tag: &str) -> bool {
+ matches!(
+ tag,
+ "a" | "abbr"
+ | "acronym"
+ | "b"
+ | "bdo"
+ | "big"
+ | "br"
+ | "cite"
+ | "code"
+ | "dfn"
+ | "em"
+ | "font"
+ | "i"
+ | "img"
+ | "input"
+ | "kbd"
+ | "label"
+ | "q"
+ | "s"
+ | "samp"
+ | "select"
+ | "small"
+ | "span"
+ | "strike"
+ | "strong"
+ | "sub"
+ | "sup"
+ | "textarea"
+ | "tt"
+ | "u"
+ | "var"
+ )
+}
+
+/// Returns true if the node kind is text-like (`Text`, `CData`, or `EntityRef`).
+///
+/// libxml2 suppresses formatting newlines when adjacent to text-like nodes.
+fn is_text_like(kind: &NodeKind) -> bool {
+ matches!(
+ kind,
+ NodeKind::Text { .. } | NodeKind::CData { .. } | NodeKind::EntityRef { .. }
+ )
+}
+
+/// Checks whether a formatting newline should be added after a block-level
+/// element's opening tag (libxml2 behavior).
+///
+/// Adds `\n` when:
+/// - Element is not inline
+/// - Element name does not start with 'p' (p, pre, param)
+/// - First child is not a text-like node
+/// - Element has more than one child
+fn maybe_newline_after_open(doc: &Document, id: NodeId, tag: &str, out: &mut String) {
+ if is_inline_element(tag) || tag.starts_with('p') {
+ return;
+ }
+ let Some(first) = doc.first_child(id) else {
+ return;
+ };
+ if is_text_like(&doc.node(first).kind) {
+ return;
+ }
+ // Check that the element has more than one child
+ if doc.next_sibling(first).is_none() {
+ return;
+ }
+ out.push('\n');
+}
+
+/// Checks whether a formatting newline should be added before a block-level
+/// element's closing tag (libxml2 behavior).
+///
+/// Adds `\n` when:
+/// - Element is not inline
+/// - Element name does not start with 'p' (p, pre, param)
+/// - Last child is not a text-like node
+/// - Element has more than one child
+fn maybe_newline_before_close(doc: &Document, id: NodeId, tag: &str, out: &mut String) {
+ if is_inline_element(tag) || tag.starts_with('p') {
+ return;
+ }
+ let Some(first) = doc.first_child(id) else {
+ return;
+ };
+ let Some(last) = doc.last_child(id) else {
+ return;
+ };
+ if is_text_like(&doc.node(last).kind) {
+ return;
+ }
+ // More than one child
+ if doc.next_sibling(first).is_none() {
+ return;
+ }
+ out.push('\n');
+}
+
+/// Checks whether a formatting newline should be added after a block-level
+/// element's closing tag (libxml2 behavior).
+///
+/// Adds `\n` when:
+/// - Element is not inline
+/// - Next sibling exists and is not a text-like node
+/// - Parent element name does not start with 'p'
+fn maybe_newline_after_close(doc: &Document, id: NodeId, tag: &str, out: &mut String) {
+ if is_inline_element(tag) {
+ return;
+ }
+ let Some(next) = doc.next_sibling(id) else {
+ return;
+ };
+ if is_text_like(&doc.node(next).kind) {
+ return;
+ }
+ if let Some(parent) = doc.parent(id) {
+ let parent_name = doc.node_name(parent).unwrap_or("");
+ if parent_name.starts_with('p') {
+ return;
+ }
+ }
+ out.push('\n');
+}
+
+#[allow(clippy::too_many_lines)]
+fn serialize_html_node(doc: &Document, id: NodeId, out: &mut String, reencode: bool) {
+ match &doc.node(id).kind {
+ NodeKind::Element {
+ name,
+ prefix,
+ attributes,
+ ..
+ } => {
+ out.push('<');
+ if let Some(pfx) = prefix {
+ out.push_str(pfx);
+ out.push(':');
+ }
+ out.push_str(name);
+
+ for attr in attributes {
+ out.push(' ');
+ if let Some(pfx) = &attr.prefix {
+ out.push_str(pfx);
+ out.push(':');
+ }
+ out.push_str(&attr.name);
+ if !is_boolean_attribute(&attr.name) && attr.raw_value.as_deref() != Some("") {
+ // Use single quotes when value contains double quotes
+ if attr.value.contains('"') && !attr.value.contains('\'') {
+ out.push_str("='");
+ write_html_escaped_attr_sq(out, &attr.value, reencode);
+ out.push('\'');
+ } else {
+ out.push_str("=\"");
+ if is_uri_attribute(&attr.name) {
+ write_html_uri_attr(out, &attr.value, reencode);
+ } else {
+ write_html_escaped_attr(out, &attr.value, reencode);
+ }
+ out.push('"');
+ }
+ }
+ }
+ out.push('>');
+
+ let lower = name.to_ascii_lowercase();
+
+ // Void elements: no closing tag
+ if is_void_element(&lower) {
+ maybe_newline_after_close(doc, id, &lower, out);
+ return;
+ }
+
+ // Formatting newline after opening tag for block elements
+ maybe_newline_after_open(doc, id, &lower, out);
+
+ // Raw text elements: output content without escaping
+ if is_raw_text_element(&lower) {
+ for child in doc.children(id) {
+ if let NodeKind::Text { content } = &doc.node(child).kind {
+ out.push_str(content);
+ } else {
+ serialize_html_node(doc, child, out, reencode);
+ }
+ }
+ } else {
+ for child in doc.children(id) {
+ serialize_html_node(doc, child, out, reencode);
+ }
+ }
+
+ // Formatting newline before closing tag for block elements
+ maybe_newline_before_close(doc, id, &lower, out);
+
+ // Closing tag
+ out.push_str("</");
+ if let Some(pfx) = prefix {
+ out.push_str(pfx);
+ out.push(':');
+ }
+ out.push_str(name);
+ out.push('>');
+
+ // Formatting newline after closing tag for block elements
+ maybe_newline_after_close(doc, id, &lower, out);
+ }
+ NodeKind::Text { content } => {
+ write_html_escaped_text(out, content, reencode);
+ }
+ NodeKind::CData { content } => {
+ // In HTML, CDATA is not standard — output as text
+ write_html_escaped_text(out, content, reencode);
+ }
+ NodeKind::Comment { content } => {
+ out.push_str("<!--");
+ out.push_str(content);
+ out.push_str("-->");
+ }
+ NodeKind::ProcessingInstruction { target, data } => {
+ // HTML PIs use '>' as terminator, not '?>' (XML style)
+ out.push_str("<?");
+ out.push_str(target);
+ if let Some(d) = data {
+ out.push(' ');
+ out.push_str(d);
+ }
+ out.push('>');
+ }
+ NodeKind::EntityRef { name, .. } => {
+ out.push('&');
+ out.push_str(name);
+ out.push(';');
+ }
+ NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ ..
+ } => {
+ out.push_str("<!DOCTYPE ");
+ out.push_str(name);
+ match (public_id, system_id) {
+ (Some(pub_id), Some(sys_id)) => {
+ out.push_str(" PUBLIC \"");
+ out.push_str(pub_id);
+ out.push('"');
+ if !sys_id.is_empty() {
+ out.push_str(" \"");
+ out.push_str(sys_id);
+ out.push('"');
+ }
+ }
+ (Some(pub_id), None) => {
+ out.push_str(" PUBLIC \"");
+ out.push_str(pub_id);
+ out.push('"');
+ }
+ (None, Some(sys_id)) => {
+ out.push_str(" SYSTEM \"");
+ out.push_str(sys_id);
+ out.push('"');
+ }
+ _ => {}
+ }
+ out.push_str(">\n");
+ }
+ NodeKind::Document => {
+ // Should not appear as a child node
+ }
+ }
+}
+
+/// Escapes text content for HTML output.
+///
+/// - `&` → `&`
+/// - `<` → `<`
+/// - `>` → `>`
+/// - Non-ASCII characters with known HTML entities → `&name;` (when `reencode` is true)
+fn write_html_escaped_text(out: &mut String, text: &str, reencode: bool) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ c if reencode && (c as u32) >= 0x80 => {
+ if let Some(name) = reverse_lookup_entity(c) {
+ out.push('&');
+ out.push_str(name);
+ out.push(';');
+ } else {
+ out.push(c);
+ }
+ }
+ _ => out.push(ch),
+ }
+ }
+}
+
+/// Returns true if the attribute name is a URI-type attribute that should
+/// have its value URL-encoded (spaces → `%20`, etc.).
+fn is_uri_attribute(name: &str) -> bool {
+ matches!(
+ name,
+ "href"
+ | "src"
+ | "action"
+ | "background"
+ | "cite"
+ | "classid"
+ | "codebase"
+ | "data"
+ | "longdesc"
+ | "profile"
+ | "usemap"
+ )
+}
+
+/// Writes a URI attribute value with URL encoding for non-URI characters.
+///
+/// Spaces are encoded as `%20`. HTML-special characters (`&`, `<`, `>`)
+/// are entity-escaped. Non-ASCII characters are handled based on the
+/// `reencode` flag.
+fn write_html_uri_attr(out: &mut String, text: &str, reencode: bool) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '"' => out.push_str("""),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ ' ' => out.push_str("%20"),
+ c if reencode && (c as u32) >= 0x80 => {
+ if let Some(name) = reverse_lookup_entity(c) {
+ out.push('&');
+ out.push_str(name);
+ out.push(';');
+ } else {
+ out.push(c);
+ }
+ }
+ _ => out.push(ch),
+ }
+ }
+}
+
+/// Escapes an attribute value for HTML output (single-quote delimited).
+///
+/// Used when the value contains `"` characters and is delimited by `'`.
+/// - `&` → `&`
+/// - `'` → `'`
+/// - `<` → `<`
+/// - `>` → `>`
+/// - Non-ASCII characters with known HTML entities → `&name;` (when `reencode` is true)
+fn write_html_escaped_attr_sq(out: &mut String, text: &str, reencode: bool) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '\'' => out.push_str("'"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ c if reencode && (c as u32) >= 0x80 => {
+ if let Some(name) = reverse_lookup_entity(c) {
+ out.push('&');
+ out.push_str(name);
+ out.push(';');
+ } else {
+ out.push(c);
+ }
+ }
+ _ => out.push(ch),
+ }
+ }
+}
+
+/// Escapes an attribute value for HTML output.
+///
+/// - `&` → `&`
+/// - `"` → `"`
+/// - `<` → `<`
+/// - `>` → `>`
+/// - Non-ASCII characters with known HTML entities → `&name;` (when `reencode` is true)
+fn write_html_escaped_attr(out: &mut String, text: &str, reencode: bool) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '"' => out.push_str("""),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ c if reencode && (c as u32) >= 0x80 => {
+ if let Some(name) = reverse_lookup_entity(c) {
+ out.push('&');
+ out.push_str(name);
+ out.push(';');
+ } else {
+ out.push(c);
+ }
+ }
+ _ => out.push(ch),
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// HTML5 serialization
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+ use crate::html::parse_html;
+
+ // -- Void elements -------------------------------------------------------
+
+ #[test]
+ fn test_void_element_br() {
+ let doc = parse_html("<html><body><br></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ assert!(html.contains("<br>"), "expected <br>, got: {html}");
+ assert!(!html.contains("<br/>"), "should not have <br/>");
+ assert!(!html.contains("</br>"), "should not have </br>");
+ }
+
+ #[test]
+ fn test_void_element_img_with_attr() {
+ let doc = parse_html(r#"<html><body><img src="x.png"></body></html>"#).unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains(r#"<img src="x.png">"#),
+ "expected img with src, got: {html}"
+ );
+ assert!(!html.contains("</img>"), "void element should not close");
+ }
+
+ // -- Non-void elements ---------------------------------------------------
+
+ #[test]
+ fn test_non_void_empty_element() {
+ let doc = parse_html("<html><body><p></p></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains("<p></p>"),
+ "expected <p></p>, not self-closing, got: {html}"
+ );
+ }
+
+ // -- Raw text elements ---------------------------------------------------
+
+ #[test]
+ fn test_script_not_escaped() {
+ let doc = parse_html("<html><body><script>if (a < b) {}</script></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains("if (a < b) {}"),
+ "script content should not be escaped, got: {html}"
+ );
+ assert!(
+ !html.contains("<"),
+ "script content should not contain <"
+ );
+ }
+
+ #[test]
+ fn test_style_not_escaped() {
+ let doc = parse_html("<html><body><style>.a > .b {}</style></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains(".a > .b {}"),
+ "style content should not be escaped, got: {html}"
+ );
+ assert!(
+ !html.contains(">"),
+ "style content should not contain > inside style tag"
+ );
+ }
+
+ // -- Attributes ----------------------------------------------------------
+
+ #[test]
+ fn test_boolean_attribute() {
+ let doc = parse_html(r#"<html><body><input disabled="disabled"></body></html>"#).unwrap();
+ let html = serialize_html(&doc);
+ // Boolean attribute: when value == name, output without value
+ assert!(
+ html.contains("<input disabled>") || html.contains("<input disabled "),
+ "expected boolean attr, got: {html}"
+ );
+ }
+
+ #[test]
+ fn test_regular_attribute_preserved() {
+ let doc = parse_html(r#"<html><body><input type="text"></body></html>"#).unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains(r#"type="text""#),
+ "expected type=\"text\", got: {html}"
+ );
+ }
+
+ #[test]
+ fn test_multiple_attributes() {
+ let doc = parse_html(
+ r#"<html><body><input type="text" name="field" value="hello"></body></html>"#,
+ )
+ .unwrap();
+ let html = serialize_html(&doc);
+ assert!(html.contains(r#"type="text""#), "missing type attr");
+ assert!(html.contains(r#"name="field""#), "missing name attr");
+ assert!(html.contains(r#"value="hello""#), "missing value attr");
+ }
+
+ // -- Text escaping -------------------------------------------------------
+
+ #[test]
+ fn test_text_escaping() {
+ let doc = parse_html("<html><body><p>a & b < c > d</p></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ // The serializer should re-escape special characters in text
+ assert!(
+ html.contains("&") && html.contains("<") && html.contains(">"),
+ "expected escaped entities in text, got: {html}"
+ );
+ }
+
+ // -- Comments ------------------------------------------------------------
+
+ #[test]
+ fn test_comment_preserved() {
+ let doc = parse_html("<html><body><!-- comment --></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains("<!-- comment -->"),
+ "comment should be preserved, got: {html}"
+ );
+ }
+
+ // -- DOCTYPE -------------------------------------------------------------
+
+ #[test]
+ fn test_doctype_serialization() {
+ let doc = parse_html(
+ r#"<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"><html><body></body></html>"#,
+ )
+ .unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains("<!DOCTYPE html"),
+ "expected DOCTYPE, got: {html}"
+ );
+ assert!(
+ html.contains("PUBLIC"),
+ "expected PUBLIC in DOCTYPE, got: {html}"
+ );
+ }
+
+ // -- Charset / encoding --------------------------------------------------
+
+ #[test]
+ fn test_meta_charset_utf8() {
+ let doc =
+ parse_html(r#"<html><head><meta charset="utf-8"></head><body>café</body></html>"#)
+ .unwrap();
+ let html = serialize_html(&doc);
+ // With UTF-8 charset declared, non-ASCII should be preserved as UTF-8
+ assert!(
+ html.contains("café") || html.contains("caf"),
+ "UTF-8 content should be preserved, got: {html}"
+ );
+ }
+
+ // -- Block/inline formatting ---------------------------------------------
+
+ #[test]
+ fn test_inline_element_no_newlines() {
+ let doc = parse_html("<html><body><p>Hello <span>world</span></p></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ // Inline elements like span should not have extra formatting newlines
+ assert!(
+ html.contains("<span>world</span>"),
+ "inline element should not have extra newlines, got: {html}"
+ );
+ }
+
+ // -- Trailing newline ----------------------------------------------------
+
+ #[test]
+ fn test_trailing_newline() {
+ let doc = parse_html("<html><body></body></html>").unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.ends_with('\n'),
+ "output should end with newline, got: {html:?}"
+ );
+ }
+
+ // -- Nested elements -----------------------------------------------------
+
+ #[test]
+ fn test_nested_elements() {
+ let doc =
+ parse_html("<html><body><div><ul><li>one</li><li>two</li></ul></div></body></html>")
+ .unwrap();
+ let html = serialize_html(&doc);
+ assert!(html.contains("<ul>"), "missing <ul>");
+ assert!(html.contains("<li>one</li>"), "missing first li");
+ assert!(html.contains("<li>two</li>"), "missing second li");
+ assert!(html.contains("</ul>"), "missing </ul>");
+ }
+
+ // -- Entity references ---------------------------------------------------
+
+ #[test]
+ fn test_entity_ref_serialization() {
+ // Build a document manually with an entity reference node
+ let mut doc = Document::new();
+ let root = doc.root();
+ let html_id = doc.create_node(NodeKind::Element {
+ name: "html".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, html_id);
+ let body_id = doc.create_node(NodeKind::Element {
+ name: "body".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(html_id, body_id);
+ let entity_id = doc.create_node(NodeKind::EntityRef {
+ name: "nbsp".to_string(),
+ value: None,
+ });
+ doc.append_child(body_id, entity_id);
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains(" "),
+ "entity reference should be preserved, got: {html}"
+ );
+ }
+
+ // -- Full document roundtrip ---------------------------------------------
+
+ #[test]
+ fn test_full_html_document() {
+ let input =
+ "<html><head><title>Test</title></head><body><h1>Hello</h1><p>World</p></body></html>";
+ let doc = parse_html(input).unwrap();
+ let html = serialize_html(&doc);
+ assert!(html.contains("<html>"), "missing <html>");
+ assert!(html.contains("<head>"), "missing <head>");
+ assert!(html.contains("<title>Test</title>"), "missing title");
+ assert!(html.contains("<body>"), "missing <body>");
+ assert!(html.contains("Hello"), "missing h1 content");
+ assert!(html.contains("World"), "missing p content");
+ assert!(html.contains("</html>"), "missing </html>");
+ }
+
+ // -- URI attribute encoding ----------------------------------------------
+
+ #[test]
+ fn test_uri_attribute_space() {
+ let doc = parse_html(r#"<html><body><a href="a b">link</a></body></html>"#).unwrap();
+ let html = serialize_html(&doc);
+ assert!(
+ html.contains("a%20b"),
+ "spaces in href should be encoded as %20, got: {html}"
+ );
+ }
+
+ // -- Attribute with quotes -----------------------------------------------
+
+ #[test]
+ fn test_attr_with_quotes() {
+ // Build manually to control the attribute value precisely
+ let mut doc = Document::new();
+ let root = doc.root();
+ let html_id = doc.create_node(NodeKind::Element {
+ name: "html".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, html_id);
+ let body_id = doc.create_node(NodeKind::Element {
+ name: "body".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(html_id, body_id);
+ let div_id = doc.create_node(NodeKind::Element {
+ name: "div".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![crate::tree::Attribute {
+ name: "title".to_string(),
+ value: "say \"hello\"".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ }],
+ });
+ doc.append_child(body_id, div_id);
+ let html = serialize_html(&doc);
+ // When value contains " and not ', should use single-quote delimiters
+ assert!(
+ html.contains("title='say \"hello\"'"),
+ "expected single-quoted attr, got: {html}"
+ );
+ }
+}
diff --git a/browser/vendor/xmloxide/src/serial/mod.rs b/browser/vendor/xmloxide/src/serial/mod.rs
new file mode 100644
index 000000000..e54216a97
--- /dev/null
+++ b/browser/vendor/xmloxide/src/serial/mod.rs
@@ -0,0 +1,12 @@
+//! XML and HTML serialization.
+//!
+//! This module serializes a `Document` tree back to XML (or HTML) text.
+//! The serializer handles proper escaping, XML declarations, and
+//! formatting options. Includes Canonical XML (C14N) serialization for
+//! producing deterministic byte sequences required by XML digital signatures.
+
+pub mod c14n;
+pub mod html;
+pub mod xml;
+
+pub use xml::{serialize, serialize_with_options, SerializeOptions};
diff --git a/browser/vendor/xmloxide/src/serial/xml.rs b/browser/vendor/xmloxide/src/serial/xml.rs
new file mode 100644
index 000000000..f73832c71
--- /dev/null
+++ b/browser/vendor/xmloxide/src/serial/xml.rs
@@ -0,0 +1,768 @@
+//! XML serializer.
+//!
+//! Serializes a `Document` tree into a well-formed XML string.
+
+use crate::tree::{Document, NodeId, NodeKind};
+
+/// Options controlling XML serialization output.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+/// use xmloxide::serial::{serialize_with_options, SerializeOptions};
+///
+/// let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+/// let xml = serialize_with_options(&doc, &SerializeOptions::default().indent(true));
+/// assert!(xml.contains(" <child>"));
+/// ```
+#[derive(Debug, Clone)]
+pub struct SerializeOptions {
+ /// Whether to produce indented (pretty-printed) output.
+ /// Defaults to `false`.
+ pub indent: bool,
+ /// The indentation string used for each level when `indent` is `true`.
+ /// Defaults to two spaces.
+ pub indent_str: String,
+}
+
+impl Default for SerializeOptions {
+ fn default() -> Self {
+ Self {
+ indent: false,
+ indent_str: " ".to_string(),
+ }
+ }
+}
+
+impl SerializeOptions {
+ /// Enables or disables indented (pretty-printed) output.
+ ///
+ /// When enabled, child elements are placed on their own lines with
+ /// indentation (two spaces per level by default). Mixed-content elements
+ /// (those containing both text and element children) are not indented.
+ /// Use [`indent_str`](Self::indent_str) to customize the indentation
+ /// string. Disabled by default.
+ #[must_use]
+ pub fn indent(mut self, indent: bool) -> Self {
+ self.indent = indent;
+ self
+ }
+
+ /// Sets the indentation string used for each nesting level.
+ ///
+ /// The default is two spaces (`" "`). Common alternatives include a tab
+ /// (`"\t"`) or four spaces (`" "`). This only takes effect when
+ /// [`indent`](Self::indent) is enabled.
+ #[must_use]
+ pub fn indent_str(mut self, s: &str) -> Self {
+ self.indent_str = s.to_string();
+ self
+ }
+}
+
+/// Serializes a document to an XML string.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+/// use xmloxide::serial::serialize;
+///
+/// let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+/// let xml = serialize(&doc);
+/// assert!(xml.contains("<root>"));
+/// ```
+#[must_use]
+pub fn serialize(doc: &Document) -> String {
+ serialize_with_options(doc, &SerializeOptions::default())
+}
+
+/// Serializes a document to an XML string with the given options.
+///
+/// When `options.indent` is `true`, produces pretty-printed output with
+/// newlines and indentation between elements.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+/// use xmloxide::serial::{serialize_with_options, SerializeOptions};
+///
+/// let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+/// let xml = serialize_with_options(&doc, &SerializeOptions::default().indent(true));
+/// assert!(xml.contains(" <child>"));
+/// ```
+#[must_use]
+pub fn serialize_with_options(doc: &Document, options: &SerializeOptions) -> String {
+ let mut output = String::new();
+
+ // XML declaration — always emit, defaulting to version 1.0 (matches libxml2)
+ let version = doc.version.as_deref().unwrap_or("1.0");
+ output.push_str("<?xml version=\"");
+ output.push_str(version);
+ output.push('"');
+ if let Some(ref encoding) = doc.encoding {
+ output.push_str(" encoding=\"");
+ output.push_str(encoding);
+ output.push('"');
+ }
+ if let Some(standalone) = doc.standalone {
+ output.push_str(" standalone=\"");
+ output.push_str(if standalone { "yes" } else { "no" });
+ output.push('"');
+ }
+ output.push_str("?>\n");
+
+ // When no encoding is declared, non-ASCII chars in attributes are
+ // re-encoded as hex character references (matches libxml2 behavior).
+ let reencode_non_ascii = doc.encoding.is_none();
+
+ // Serialize children of the document root
+ for child in doc.children(doc.root()) {
+ serialize_node(
+ doc,
+ child,
+ &mut output,
+ reencode_non_ascii,
+ options,
+ 0,
+ false,
+ );
+ }
+
+ // Trailing newline (matches libxml2 output convention)
+ output.push('\n');
+
+ output
+}
+
+/// Returns `true` if the element contains only other elements (and optional
+/// whitespace text), meaning it's safe to add indentation.
+fn is_element_only(doc: &Document, id: NodeId) -> bool {
+ let mut has_element_child = false;
+ for child in doc.children(id) {
+ match &doc.node(child).kind {
+ NodeKind::Element { .. } => has_element_child = true,
+ NodeKind::Text { content } if !content.trim().is_empty() => {
+ return false;
+ }
+ NodeKind::CData { .. } | NodeKind::EntityRef { .. } => return false,
+ _ => {}
+ }
+ }
+ has_element_child
+}
+
+#[allow(clippy::too_many_lines)]
+fn serialize_node(
+ doc: &Document,
+ id: NodeId,
+ out: &mut String,
+ reencode_non_ascii: bool,
+ options: &SerializeOptions,
+ depth: usize,
+ parent_is_element_only: bool,
+) {
+ let indent = options.indent;
+ match &doc.node(id).kind {
+ NodeKind::Element {
+ name,
+ prefix,
+ attributes,
+ ..
+ } => {
+ if indent && parent_is_element_only {
+ for _ in 0..depth {
+ out.push_str(&options.indent_str);
+ }
+ }
+ out.push('<');
+ if let Some(pfx) = prefix {
+ out.push_str(pfx);
+ out.push(':');
+ }
+ out.push_str(name);
+
+ for attr in attributes {
+ out.push(' ');
+ if let Some(pfx) = &attr.prefix {
+ out.push_str(pfx);
+ out.push(':');
+ }
+ out.push_str(&attr.name);
+ out.push_str("=\"");
+ let is_ns_decl = attr.name == "xmlns" || attr.prefix.as_deref() == Some("xmlns");
+ if let Some(raw) = attr.raw_value.as_ref().filter(|_| !is_ns_decl) {
+ write_escaped_attr_preserve_refs(out, raw, reencode_non_ascii);
+ } else {
+ write_escaped_attr(out, &attr.value, reencode_non_ascii);
+ }
+ out.push('"');
+ }
+
+ if doc.first_child(id).is_none() {
+ out.push_str("/>");
+ if indent && parent_is_element_only {
+ out.push('\n');
+ }
+ } else {
+ out.push('>');
+ let element_only = indent && is_element_only(doc, id);
+ if element_only {
+ out.push('\n');
+ }
+ for child in doc.children(id) {
+ if element_only {
+ if let NodeKind::Text { content } = &doc.node(child).kind {
+ if content.trim().is_empty() {
+ continue;
+ }
+ }
+ }
+ serialize_node(
+ doc,
+ child,
+ out,
+ reencode_non_ascii,
+ options,
+ depth + 1,
+ element_only,
+ );
+ }
+ if element_only {
+ for _ in 0..depth {
+ out.push_str(&options.indent_str);
+ }
+ }
+ out.push_str("</");
+ if let Some(pfx) = prefix {
+ out.push_str(pfx);
+ out.push(':');
+ }
+ out.push_str(name);
+ out.push('>');
+ if indent && parent_is_element_only {
+ out.push('\n');
+ }
+ }
+ }
+ NodeKind::Text { content } => {
+ write_escaped_text(out, content, reencode_non_ascii);
+ }
+ NodeKind::CData { content } => {
+ out.push_str("<![CDATA[");
+ out.push_str(content);
+ out.push_str("]]]]><![CDATA[>");
+ }
+ NodeKind::Comment { content } => {
+ if indent && parent_is_element_only {
+ for _ in 0..depth {
+ out.push_str(&options.indent_str);
+ }
+ }
+ out.push_str("<!--");
+ out.push_str(content);
+ out.push_str("-->");
+ if indent && parent_is_element_only {
+ out.push('\n');
+ }
+ }
+ NodeKind::ProcessingInstruction { target, data } => {
+ if indent && parent_is_element_only {
+ for _ in 0..depth {
+ out.push_str(&options.indent_str);
+ }
+ }
+ out.push_str("<?");
+ out.push_str(target);
+ if let Some(d) = data {
+ out.push(' ');
+ out.push_str(d);
+ }
+ out.push_str("?>");
+ if indent && parent_is_element_only {
+ out.push('\n');
+ }
+ }
+ NodeKind::EntityRef { name, .. } => {
+ out.push('&');
+ out.push_str(name);
+ out.push(';');
+ }
+ NodeKind::DocumentType {
+ name,
+ system_id,
+ public_id,
+ internal_subset,
+ } => {
+ out.push_str("<!DOCTYPE ");
+ out.push_str(name);
+ match (public_id, system_id) {
+ (Some(pub_id), Some(sys_id)) => {
+ out.push_str(" PUBLIC \"");
+ out.push_str(pub_id);
+ out.push_str("\" \"");
+ out.push_str(sys_id);
+ out.push('"');
+ }
+ (None, Some(sys_id)) => {
+ out.push_str(" SYSTEM \"");
+ out.push_str(sys_id);
+ out.push('"');
+ }
+ _ => {}
+ }
+ if let Some(ref subset) = internal_subset {
+ out.push_str(" [");
+ out.push_str(subset);
+ out.push_str("]>");
+ } else {
+ out.push('>');
+ }
+ }
+ NodeKind::Document => {
+ // Should not appear as a child node
+ }
+ }
+}
+
+/// Writes a hexadecimal character reference (`&#xHH;`) for a Unicode code point.
+fn write_hex_char_ref(out: &mut String, ch: char) {
+ use std::fmt::Write;
+ let _ = write!(out, "&#x{:X};", ch as u32);
+}
+
+/// Escapes text content for XML output.
+///
+/// Follows libxml2's `xmlEscapeEntities` behavior:
+/// - `<`, `>`, `&` are escaped with named entity references
+/// - `\r` is encoded as ` `
+/// - `\t` and `\n` are passed through
+/// - Control characters below 0x20 (other than `\t`, `\n`, `\r`) are hex-encoded
+/// - Non-ASCII characters are passed through as raw UTF-8
+fn write_escaped_text(out: &mut String, text: &str, reencode_non_ascii: bool) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ '\r' => out.push_str(" "),
+ '\t' | '\n' => out.push(ch),
+ c if (c as u32) < 0x20 => write_hex_char_ref(out, c),
+ c if reencode_non_ascii && (c as u32) >= 0x80 => write_hex_char_ref(out, c),
+ _ => out.push(ch),
+ }
+ }
+}
+
+/// Escapes an attribute value that contains preserved entity references.
+///
+/// Custom entity references (`&name;` where name is not a builtin) are
+/// preserved as-is. Character references (`&#...;`) and builtin entity refs
+/// (`&`, `<`, `>`, `'`, `"`) are decoded to their
+/// actual characters and then re-escaped normally through the attribute
+/// escaping logic. This matches libxml2's serialization behavior.
+fn write_escaped_attr_preserve_refs(out: &mut String, text: &str, reencode_non_ascii: bool) {
+ let bytes = text.as_bytes();
+ let len = bytes.len();
+ let mut i = 0;
+
+ while i < len {
+ let b = bytes[i];
+ if b == b'&' {
+ // Check if this starts a valid reference
+ if let Some(ref_end) = find_attr_reference_end(bytes, i) {
+ let ref_str = &text[i..=ref_end];
+ if ref_str.starts_with("&#") {
+ // Character reference — decode to char, then escape normally
+ if let Some(ch) = decode_char_ref(ref_str) {
+ write_escaped_attr_char(out, ch, reencode_non_ascii);
+ } else {
+ out.push_str(ref_str);
+ }
+ } else if let Some(ch) = decode_builtin_entity_ref(ref_str) {
+ // Builtin entity ref — decode and re-escape normally
+ write_escaped_attr_char(out, ch, reencode_non_ascii);
+ } else {
+ // Custom entity reference — preserve as-is
+ out.push_str(ref_str);
+ }
+ i = ref_end + 1;
+ continue;
+ }
+ out.push_str("&");
+ i += 1;
+ } else if b == b'<' {
+ out.push_str("<");
+ i += 1;
+ } else if b == b'>' {
+ out.push_str(">");
+ i += 1;
+ } else if b == b'"' {
+ out.push_str(""");
+ i += 1;
+ } else if b == b'\t' {
+ out.push_str("	");
+ i += 1;
+ } else if b == b'\n' {
+ out.push_str(" ");
+ i += 1;
+ } else if b == b'\r' {
+ out.push_str(" ");
+ i += 1;
+ } else {
+ let ch = &text[i..];
+ if let Some(c) = ch.chars().next() {
+ if (c as u32) < 0x20 || (reencode_non_ascii && (c as u32) >= 0x80) {
+ write_hex_char_ref(out, c);
+ } else {
+ out.push(c);
+ }
+ i += c.len_utf8();
+ } else {
+ i += 1;
+ }
+ }
+ }
+}
+
+/// Decodes a character reference (`&#NNN;` or `&#xHHH;`) to a `char`.
+fn decode_char_ref(s: &str) -> Option<char> {
+ let inner = s.strip_prefix("&#")?.strip_suffix(';')?;
+ let code_point = if let Some(hex) = inner.strip_prefix('x') {
+ u32::from_str_radix(hex, 16).ok()?
+ } else {
+ inner.parse::<u32>().ok()?
+ };
+ char::from_u32(code_point)
+}
+
+/// Decodes a builtin entity reference to a `char`, if it is one.
+/// Returns `None` for custom (non-builtin) entity references.
+fn decode_builtin_entity_ref(s: &str) -> Option<char> {
+ match s {
+ "&" => Some('&'),
+ "<" => Some('<'),
+ ">" => Some('>'),
+ "'" => Some('\''),
+ """ => Some('"'),
+ _ => None,
+ }
+}
+
+/// Writes a single character with attribute escaping rules.
+fn write_escaped_attr_char(out: &mut String, ch: char, reencode_non_ascii: bool) {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ '"' => out.push_str("""),
+ '\t' => out.push_str("	"),
+ '\n' => out.push_str(" "),
+ '\r' => out.push_str(" "),
+ c if (c as u32) < 0x20 => write_hex_char_ref(out, c),
+ c if reencode_non_ascii && (c as u32) >= 0x80 => write_hex_char_ref(out, c),
+ _ => out.push(ch),
+ }
+}
+
+/// Finds the end of an entity/character reference in attribute raw value.
+fn find_attr_reference_end(bytes: &[u8], start: usize) -> Option<usize> {
+ if start >= bytes.len() || bytes[start] != b'&' {
+ return None;
+ }
+ let mut i = start + 1;
+ if i >= bytes.len() {
+ return None;
+ }
+ if bytes[i] == b'#' {
+ i += 1;
+ if i >= bytes.len() {
+ return None;
+ }
+ if bytes[i] == b'x' {
+ i += 1;
+ let d = i;
+ while i < bytes.len() && bytes[i].is_ascii_hexdigit() {
+ i += 1;
+ }
+ if i == d || i >= bytes.len() || bytes[i] != b';' {
+ return None;
+ }
+ } else {
+ let d = i;
+ while i < bytes.len() && bytes[i].is_ascii_digit() {
+ i += 1;
+ }
+ if i == d || i >= bytes.len() || bytes[i] != b';' {
+ return None;
+ }
+ }
+ Some(i)
+ } else {
+ if !bytes[i].is_ascii_alphabetic() && bytes[i] != b'_' && bytes[i] != b':' {
+ return None;
+ }
+ i += 1;
+ while i < bytes.len()
+ && (bytes[i].is_ascii_alphanumeric()
+ || bytes[i] == b'_'
+ || bytes[i] == b':'
+ || bytes[i] == b'-'
+ || bytes[i] == b'.')
+ {
+ i += 1;
+ }
+ if i >= bytes.len() || bytes[i] != b';' {
+ return None;
+ }
+ Some(i)
+ }
+}
+
+/// Escapes attribute values for XML output.
+///
+/// Follows libxml2's `xmlAttrSerializeTxtContent` behavior:
+/// - `<`, `>`, `&`, `"` are escaped with named entity references
+/// - `\t` → `	`, `\n` → ` `, `\r` → ` `
+/// - When `reencode_non_ascii` is true (doc has no declared encoding), non-ASCII
+/// characters (>= U+0080) are encoded as hex character references
+fn write_escaped_attr(out: &mut String, text: &str, reencode_non_ascii: bool) {
+ for ch in text.chars() {
+ match ch {
+ '&' => out.push_str("&"),
+ '<' => out.push_str("<"),
+ '>' => out.push_str(">"),
+ '"' => out.push_str("""),
+ '\t' => out.push_str("	"),
+ '\n' => out.push_str(" "),
+ '\r' => out.push_str(" "),
+ c if (c as u32) < 0x20 => write_hex_char_ref(out, c),
+ c if reencode_non_ascii && (c as u32) >= 0x80 => write_hex_char_ref(out, c),
+ _ => out.push(ch),
+ }
+ }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+ use crate::tree::Attribute;
+
+ #[test]
+ fn test_serialize_empty_element() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "br".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, elem);
+ assert_eq!(serialize(&doc), "<?xml version=\"1.0\"?>\n<br/>\n");
+ }
+
+ #[test]
+ fn test_serialize_element_with_text() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "p".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let text = doc.create_node(NodeKind::Text {
+ content: "Hello".to_string(),
+ });
+ doc.append_child(root, elem);
+ doc.append_child(elem, text);
+ assert_eq!(serialize(&doc), "<?xml version=\"1.0\"?>\n<p>Hello</p>\n");
+ }
+
+ #[test]
+ fn test_serialize_element_with_attributes() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "div".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![
+ Attribute {
+ name: "id".to_string(),
+ value: "main".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ },
+ Attribute {
+ name: "class".to_string(),
+ value: "big".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ },
+ ],
+ });
+ doc.append_child(root, elem);
+ assert_eq!(
+ serialize(&doc),
+ "<?xml version=\"1.0\"?>\n<div id=\"main\" class=\"big\"/>\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_escaping() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "p".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let text = doc.create_node(NodeKind::Text {
+ content: "a < b & c > d".to_string(),
+ });
+ doc.append_child(root, elem);
+ doc.append_child(elem, text);
+ assert_eq!(
+ serialize(&doc),
+ "<?xml version=\"1.0\"?>\n<p>a < b & c > d</p>\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_comment() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let comment = doc.create_node(NodeKind::Comment {
+ content: " a comment ".to_string(),
+ });
+ doc.append_child(root, comment);
+ assert_eq!(
+ serialize(&doc),
+ "<?xml version=\"1.0\"?>\n<!-- a comment -->\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_cdata() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "script".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let cdata = doc.create_node(NodeKind::CData {
+ content: "x < 1 && y > 2".to_string(),
+ });
+ doc.append_child(root, elem);
+ doc.append_child(elem, cdata);
+ assert_eq!(
+ serialize(&doc),
+ "<?xml version=\"1.0\"?>\n<script><![CDATA[x < 1 && y > 2]]]]><![CDATA[></script>\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_processing_instruction() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let pi = doc.create_node(NodeKind::ProcessingInstruction {
+ target: "xml-stylesheet".to_string(),
+ data: Some("type=\"text/css\" href=\"style.css\"".to_string()),
+ });
+ doc.append_child(root, pi);
+ assert_eq!(
+ serialize(&doc),
+ "<?xml version=\"1.0\"?>\n<?xml-stylesheet type=\"text/css\" href=\"style.css\"?>\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_xml_declaration() {
+ let mut doc = Document::new();
+ doc.version = Some("1.0".to_string());
+ doc.encoding = Some("UTF-8".to_string());
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "root".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, elem);
+ assert_eq!(
+ serialize(&doc),
+ "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root/>\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_attr_escaping() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "a".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![Attribute {
+ name: "title".to_string(),
+ value: "He said \"hello\" & <bye>".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ }],
+ });
+ doc.append_child(root, elem);
+ assert_eq!(
+ serialize(&doc),
+ "<?xml version=\"1.0\"?>\n<a title=\"He said "hello" & <bye>\"/>\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_pretty_print() {
+ let doc = Document::parse_str("<root><child><inner>text</inner></child></root>").unwrap();
+ let opts = SerializeOptions::default().indent(true);
+ let xml = serialize_with_options(&doc, &opts);
+ assert_eq!(
+ xml,
+ "<?xml version=\"1.0\"?>\n<root>\n <child>\n <inner>text</inner>\n </child>\n</root>\n"
+ );
+ }
+
+ #[test]
+ fn test_serialize_pretty_print_mixed_content() {
+ // Mixed content (element + non-whitespace text) should not be indented
+ let doc = Document::parse_str("<root><p>Hello <b>world</b></p></root>").unwrap();
+ let opts = SerializeOptions::default().indent(true);
+ let xml = serialize_with_options(&doc, &opts);
+ // Mixed content children are not indented
+ assert!(xml.contains(" <p>Hello <b>world</b></p>"));
+ }
+
+ #[test]
+ fn test_serialize_pretty_print_custom_indent() {
+ let doc = Document::parse_str("<root><child/></root>").unwrap();
+ let opts = SerializeOptions::default().indent(true).indent_str("\t");
+ let xml = serialize_with_options(&doc, &opts);
+ assert!(xml.contains("\t<child/>"));
+ }
+
+ #[test]
+ fn test_serialize_no_indent_unchanged() {
+ // Default (no indent) should produce same output as serialize()
+ let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+ let xml1 = serialize(&doc);
+ let xml2 = serialize_with_options(&doc, &SerializeOptions::default());
+ assert_eq!(xml1, xml2);
+ }
+}
diff --git a/browser/vendor/xmloxide/src/tree/mod.rs b/browser/vendor/xmloxide/src/tree/mod.rs
new file mode 100644
index 000000000..cdfbec501
--- /dev/null
+++ b/browser/vendor/xmloxide/src/tree/mod.rs
@@ -0,0 +1,2197 @@
+//! Arena-based XML document tree.
+//!
+//! This module implements the core tree representation using arena allocation
+//! with typed indices. All nodes live in a contiguous `Vec<NodeData>` owned by
+//! the `Document`, and are referenced by `NodeId` — a newtype over `NonZeroU32`.
+//!
+//! This design provides O(1) node access, cache-friendly layout, no reference
+//! counting overhead, and safe bulk deallocation (drop the `Document` and
+//! everything is freed).
+//!
+//! # Architecture
+//!
+//! Unlike libxml2's web of raw C pointers, we use arena indices for all
+//! navigation links (parent, first\_child, last\_child, next\_sibling,
+//! prev\_sibling). This avoids borrow checker issues, reference cycles,
+//! and per-node heap allocation.
+
+mod node;
+
+pub use node::NodeKind;
+
+use crate::error::{ParseDiagnostic, ParseError};
+use std::collections::HashMap;
+use std::num::NonZeroU32;
+
+/// A typed index into the document's node arena.
+///
+/// `NodeId` is a newtype over `NonZeroU32`, meaning it can never be zero
+/// and `Option<NodeId>` has the same size as `NodeId` (niche optimization).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[repr(transparent)]
+pub struct NodeId(NonZeroU32);
+
+impl NodeId {
+ /// Creates a `NodeId` from a raw index.
+ ///
+ /// # Panics
+ ///
+ /// Panics if `index` is 0.
+ #[allow(clippy::expect_used, clippy::cast_possible_truncation)]
+ #[inline]
+ fn from_index(index: usize) -> Self {
+ Self(NonZeroU32::new(index as u32).expect("NodeId index must be non-zero"))
+ }
+
+ /// Returns the raw index as a `usize` for indexing into the arena.
+ #[inline]
+ fn as_index(self) -> usize {
+ self.0.get() as usize
+ }
+
+ /// Converts this `NodeId` to a raw `u32` for FFI interop.
+ ///
+ /// The returned value is always non-zero (valid `NodeId`s start at 1).
+ /// Use 0 to represent "no node" in FFI code.
+ #[must_use]
+ pub fn into_raw(self) -> u32 {
+ self.0.get()
+ }
+
+ /// Creates a `NodeId` from a raw `u32`, if non-zero.
+ ///
+ /// Returns `None` if `raw` is 0 (which represents "no node" in FFI code).
+ #[must_use]
+ pub fn from_raw(raw: u32) -> Option<Self> {
+ NonZeroU32::new(raw).map(Self)
+ }
+}
+
+/// Storage for a single node in the document arena.
+///
+/// Each node stores its kind (element, text, comment, etc.) and links to
+/// parent, children, and siblings for tree navigation. Access individual
+/// nodes via [`Document::node`].
+#[derive(Debug, Clone)]
+pub struct NodeData {
+ /// What kind of node this is (element, text, comment, etc.) and its payload.
+ pub kind: NodeKind,
+ /// Parent node, if any. The document root node has no parent.
+ pub parent: Option<NodeId>,
+ /// First child node.
+ pub first_child: Option<NodeId>,
+ /// Last child node (for O(1) append).
+ pub last_child: Option<NodeId>,
+ /// Next sibling.
+ pub next_sibling: Option<NodeId>,
+ /// Previous sibling.
+ pub prev_sibling: Option<NodeId>,
+}
+
+impl NodeData {
+ fn new(kind: NodeKind) -> Self {
+ Self {
+ kind,
+ parent: None,
+ first_child: None,
+ last_child: None,
+ next_sibling: None,
+ prev_sibling: None,
+ }
+ }
+}
+
+/// An XML attribute on an element.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Attribute {
+ /// The attribute name (the local part, e.g., `"lang"` for `xml:lang`).
+ pub name: String,
+ /// The attribute value (fully expanded — entity references resolved).
+ pub value: String,
+ /// Namespace prefix, if any (e.g., `"xml"` for `xml:lang`).
+ pub prefix: Option<String>,
+ /// Namespace URI after resolution, if any.
+ pub namespace: Option<String>,
+ /// The original attribute value text before entity expansion, if it
+ /// contained entity references. Used for serialization to preserve
+ /// entity references in the output (matching libxml2 behavior).
+ pub raw_value: Option<String>,
+}
+
+/// An XML document.
+///
+/// The `Document` owns all nodes in an arena and provides methods for
+/// tree navigation and mutation. All tree operations go through
+/// `&Document` (navigation) or `&mut Document` (mutation).
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+///
+/// let doc = Document::parse_str("<root/>").unwrap();
+/// let root = doc.root_element().unwrap();
+/// assert_eq!(doc.node_name(root), Some("root"));
+/// ```
+#[derive(Debug, Clone)]
+pub struct Document {
+ /// The node arena. Index 0 is unused (placeholder for `NonZeroU32`).
+ nodes: Vec<NodeData>,
+ /// The document root node id (the Document node, not the root element).
+ root: NodeId,
+ /// XML version from the XML declaration (e.g., "1.0").
+ pub version: Option<String>,
+ /// Encoding from the XML declaration (e.g., "UTF-8").
+ pub encoding: Option<String>,
+ /// Standalone flag from the XML declaration.
+ pub standalone: Option<bool>,
+ /// Diagnostics collected during parsing (warnings and recovered errors).
+ pub diagnostics: Vec<ParseDiagnostic>,
+ /// Mapping from ID attribute values to element nodes.
+ ///
+ /// Populated during DTD validation when attributes of type ID are
+ /// validated. Used by [`element_by_id`](Document::element_by_id) and
+ /// the `XPath` `id()` function.
+ id_map: HashMap<String, NodeId>,
+}
+
+impl Document {
+ /// Creates a new empty document.
+ ///
+ /// The document contains a single root Document node.
+ #[must_use]
+ pub fn new() -> Self {
+ Self::with_capacity(64)
+ }
+
+ /// Creates a new empty document with pre-allocated capacity for `n` nodes.
+ #[must_use]
+ pub fn with_capacity(n: usize) -> Self {
+ let mut nodes = Vec::with_capacity(n);
+ // Index 0: placeholder (NodeId uses NonZeroU32)
+ nodes.push(NodeData::new(NodeKind::Document));
+ // Index 1: the document root node
+ nodes.push(NodeData::new(NodeKind::Document));
+ let root = NodeId::from_index(1);
+ Self {
+ nodes,
+ root,
+ version: None,
+ encoding: None,
+ standalone: None,
+ diagnostics: Vec::new(),
+ id_map: HashMap::new(),
+ }
+ }
+
+ /// Parses an XML string into a `Document`.
+ ///
+ /// # Errors
+ ///
+ /// Returns `ParseError` if the input is not well-formed XML.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::Document;
+ ///
+ /// let doc = Document::parse_str("<root><child/></root>").unwrap();
+ /// ```
+ pub fn parse_str(input: &str) -> Result<Self, ParseError> {
+ // Strip leading UTF-8 BOM (U+FEFF) if present — per XML 1.0 §4.3.3,
+ // the BOM is used for encoding detection and should be ignored.
+ let had_bom = input.starts_with('\u{FEFF}');
+ let input = input.strip_prefix('\u{FEFF}').unwrap_or(input);
+
+ // Check encoding declaration compatibility.
+ if let Some(enc) = Self::extract_encoding_from_decl(input) {
+ let enc_lower = enc.to_ascii_lowercase();
+ if had_bom && enc_lower != "utf-8" {
+ // UTF-8 BOM present but encoding is not UTF-8.
+ return Err(crate::error::ParseError {
+ message: format!("UTF-8 BOM present but encoding declared as '{enc}'"),
+ location: crate::error::SourceLocation::default(),
+ diagnostics: Vec::new(),
+ });
+ }
+ // Reject clearly incompatible encodings (multi-byte or
+ // non-ASCII-compatible). UTF-8, US-ASCII, and single-byte
+ // ISO-8859 variants are compatible with UTF-8 text.
+ let incompatible = enc_lower.starts_with("utf-16")
+ || enc_lower.starts_with("utf-32")
+ || enc_lower.starts_with("ucs")
+ || enc_lower == "ebcdic";
+ if incompatible {
+ return Err(crate::error::ParseError {
+ message: format!(
+ "encoding declaration '{enc}' is incompatible with actual encoding"
+ ),
+ location: crate::error::SourceLocation::default(),
+ diagnostics: Vec::new(),
+ });
+ }
+ // Reject encoding names that are not recognized by encoding_rs
+ // (excluding UTF-8 and ASCII which are always valid for Rust strings).
+ if enc_lower != "utf-8"
+ && enc_lower != "us-ascii"
+ && enc_lower != "ascii"
+ && encoding_rs::Encoding::for_label(enc.as_bytes()).is_none()
+ {
+ return Err(crate::error::ParseError {
+ message: format!("unsupported encoding '{enc}'"),
+ location: crate::error::SourceLocation::default(),
+ diagnostics: Vec::new(),
+ });
+ }
+ }
+
+ crate::parser::parse_str(input)
+ }
+
+ /// Extracts the encoding value from an XML declaration, if present.
+ fn extract_encoding_from_decl(input: &str) -> Option<String> {
+ let trimmed = input.trim_start();
+ if !trimmed.starts_with("<?xml") {
+ return None;
+ }
+ // Find the end of the XML declaration
+ let decl_end = trimmed.find("?>")?;
+ let decl = &trimmed[..decl_end];
+
+ // Look for encoding="..." or encoding='...'
+ let enc_pos = decl.find("encoding")?;
+ let after_enc = &decl[enc_pos + 8..].trim_start();
+ let after_eq = after_enc.strip_prefix('=')?.trim_start();
+ let quote = after_eq.chars().next()?;
+ if quote != '"' && quote != '\'' {
+ return None;
+ }
+ let value_start = 1;
+ let value_end = after_eq[value_start..].find(quote)?;
+ Some(after_eq[value_start..value_start + value_end].to_string())
+ }
+
+ /// Parses XML from raw bytes, detecting encoding automatically.
+ ///
+ /// Uses BOM sniffing and XML declaration inspection to determine the
+ /// encoding, then transcodes to UTF-8 before parsing. See
+ /// [`crate::encoding::decode_to_utf8`] for the full detection pipeline.
+ ///
+ /// # Errors
+ ///
+ /// Returns `ParseError` if the encoding cannot be determined, the bytes
+ /// cannot be transcoded, or the resulting XML is not well-formed.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::Document;
+ ///
+ /// let doc = Document::parse_bytes(b"<root/>").unwrap();
+ /// let root = doc.root_element().unwrap();
+ /// assert_eq!(doc.node_name(root), Some("root"));
+ /// ```
+ pub fn parse_bytes(input: &[u8]) -> Result<Self, ParseError> {
+ use crate::encoding::decode_to_utf8;
+ use crate::error::SourceLocation;
+
+ let utf8 = decode_to_utf8(input).map_err(|e| ParseError {
+ message: e.message,
+ location: SourceLocation::default(),
+ diagnostics: Vec::new(),
+ })?;
+
+ // Skip BOM and encoding checks — decode_to_utf8 already handled
+ // encoding detection and transcoding. Go directly to the parser.
+ let text = utf8.strip_prefix('\u{FEFF}').unwrap_or(&utf8);
+ crate::parser::parse_str(text)
+ }
+
+ /// Parses an XML file from the filesystem.
+ ///
+ /// Reads the file as raw bytes and uses automatic encoding detection
+ /// (BOM sniffing and XML declaration inspection) before parsing.
+ ///
+ /// # Errors
+ ///
+ /// Returns `ParseError` if the file cannot be read, the encoding
+ /// cannot be determined, or the XML is not well-formed.
+ ///
+ /// # Examples
+ ///
+ /// ```no_run
+ /// use xmloxide::Document;
+ ///
+ /// let doc = Document::parse_file("document.xml").unwrap();
+ /// ```
+ pub fn parse_file<P: AsRef<std::path::Path>>(path: P) -> Result<Self, ParseError> {
+ use crate::error::SourceLocation;
+
+ let bytes = std::fs::read(path.as_ref()).map_err(|e| ParseError {
+ message: format!("failed to read file: {e}"),
+ location: SourceLocation::default(),
+ diagnostics: Vec::new(),
+ })?;
+ Self::parse_bytes(&bytes)
+ }
+
+ /// Returns the document root `NodeId`.
+ ///
+ /// This is the synthetic `Document` node that sits above the root element,
+ /// processing instructions, comments, and DOCTYPE in the prolog. To get the
+ /// root *element*, use [`root_element`](Self::root_element).
+ #[must_use]
+ pub fn root(&self) -> NodeId {
+ self.root
+ }
+
+ /// Returns the root element of the document (the single top-level element).
+ ///
+ /// Returns `None` if the document has no element children.
+ #[must_use]
+ pub fn root_element(&self) -> Option<NodeId> {
+ self.children(self.root)
+ .find(|&id| matches!(self.node(id).kind, NodeKind::Element { .. }))
+ }
+
+ /// Returns a reference to the [`NodeData`] for the given node.
+ ///
+ /// Use this to inspect a node's [`kind`](NodeData::kind) and navigation
+ /// links. For common queries, prefer the typed accessors like
+ /// [`node_name`](Self::node_name) and [`node_text`](Self::node_text).
+ ///
+ /// # Panics
+ ///
+ /// Panics if `id` does not refer to a valid node in this document.
+ #[must_use]
+ #[inline]
+ pub fn node(&self, id: NodeId) -> &NodeData {
+ &self.nodes[id.as_index()]
+ }
+
+ /// Returns a mutable reference to the `NodeData` for the given node.
+ #[inline]
+ pub(crate) fn node_mut(&mut self, id: NodeId) -> &mut NodeData {
+ &mut self.nodes[id.as_index()]
+ }
+
+ /// Returns `true` if the node is an element.
+ #[must_use]
+ #[inline]
+ pub fn is_element(&self, id: NodeId) -> bool {
+ matches!(self.node(id).kind, NodeKind::Element { .. })
+ }
+
+ /// Returns the local name of a node, if applicable.
+ ///
+ /// For elements, this is the tag name (e.g., `"div"`). For processing
+ /// instructions, this is the target (e.g., `"xml-stylesheet"`). Text,
+ /// comment, CDATA, and document nodes return `None`.
+ #[must_use]
+ #[inline]
+ pub fn node_name(&self, id: NodeId) -> Option<&str> {
+ match &self.node(id).kind {
+ NodeKind::Element { name, .. }
+ | NodeKind::ProcessingInstruction { target: name, .. } => Some(name),
+ _ => None,
+ }
+ }
+
+ /// Returns the namespace URI of an element node, if any.
+ ///
+ /// Non-element nodes always return `None`. Elements that have no namespace
+ /// declaration in scope also return `None`.
+ #[must_use]
+ pub fn node_namespace(&self, id: NodeId) -> Option<&str> {
+ match &self.node(id).kind {
+ NodeKind::Element { namespace, .. } => namespace.as_deref(),
+ _ => None,
+ }
+ }
+
+ /// Returns the namespace prefix of an element node, if any.
+ ///
+ /// For example, returns `Some("svg")` for `<svg:rect>`.
+ /// Non-element nodes always return `None`.
+ #[must_use]
+ pub fn node_prefix(&self, id: NodeId) -> Option<&str> {
+ match &self.node(id).kind {
+ NodeKind::Element { prefix, .. } => prefix.as_deref(),
+ _ => None,
+ }
+ }
+
+ /// Returns the direct text content of a text, comment, CDATA, or PI node.
+ ///
+ /// For text, comment, and CDATA nodes, returns their string content. For
+ /// processing instructions, returns the data portion (after the target).
+ /// For element nodes, returns `None` — use
+ /// [`text_content`](Self::text_content) to get the concatenated text of
+ /// all descendant text nodes.
+ #[must_use]
+ pub fn node_text(&self, id: NodeId) -> Option<&str> {
+ match &self.node(id).kind {
+ NodeKind::Text { content }
+ | NodeKind::Comment { content }
+ | NodeKind::CData { content } => Some(content),
+ NodeKind::ProcessingInstruction { data, .. } => data.as_deref(),
+ _ => None,
+ }
+ }
+
+ /// Returns the concatenated text content of a node and all its descendants.
+ ///
+ /// Recursively collects text from all descendant text and CDATA nodes.
+ /// For a leaf text node, this is equivalent to [`node_text`](Self::node_text).
+ /// For an element, this concatenates all nested text content (matching
+ /// the DOM `textContent` property).
+ #[must_use]
+ pub fn text_content(&self, id: NodeId) -> String {
+ let mut result = String::new();
+ self.collect_text(id, &mut result);
+ result
+ }
+
+ fn collect_text(&self, id: NodeId, buf: &mut String) {
+ match &self.node(id).kind {
+ NodeKind::Text { content } | NodeKind::CData { content } => {
+ buf.push_str(content);
+ }
+ NodeKind::EntityRef { value, .. } => {
+ // When the entity's replacement text was parsed as content
+ // (XML 1.0 §4.4), the expansion lives in the children.
+ // Fall back to the stored replacement value otherwise.
+ if self.node(id).first_child.is_some() {
+ for child in self.children(id) {
+ self.collect_text(child, buf);
+ }
+ } else if let Some(val) = value {
+ buf.push_str(val);
+ }
+ }
+ _ => {
+ for child in self.children(id) {
+ self.collect_text(child, buf);
+ }
+ }
+ }
+ }
+
+ /// Returns the attributes of an element node as a slice.
+ ///
+ /// Each [`Attribute`] contains the name, value, optional namespace prefix,
+ /// and namespace URI. Returns an empty slice for non-element nodes.
+ #[must_use]
+ #[inline]
+ pub fn attributes(&self, id: NodeId) -> &[Attribute] {
+ match &self.node(id).kind {
+ NodeKind::Element { attributes, .. } => attributes,
+ _ => &[],
+ }
+ }
+
+ /// Returns the value of an attribute by local name on an element node.
+ ///
+ /// Performs a linear scan of the element's attributes. Returns `None` if
+ /// the attribute is not present or the node is not an element.
+ #[must_use]
+ #[inline]
+ pub fn attribute(&self, id: NodeId, name: &str) -> Option<&str> {
+ self.attributes(id)
+ .iter()
+ .find(|a| a.name == name)
+ .map(|a| a.value.as_str())
+ }
+
+ // --- ID lookup ---
+
+ /// Associates an ID value with an element node.
+ ///
+ /// Called during DTD validation when an attribute of type ID is found.
+ /// Subsequent calls to [`element_by_id`](Document::element_by_id) will
+ /// return the associated node.
+ pub fn set_id(&mut self, id: &str, node: NodeId) {
+ self.id_map.insert(id.to_string(), node);
+ }
+
+ /// Looks up an element by its ID attribute value.
+ ///
+ /// Returns the `NodeId` of the element that was registered with
+ /// [`set_id`](Document::set_id) for the given ID string, or `None`
+ /// if no such ID exists.
+ #[must_use]
+ pub fn element_by_id(&self, id: &str) -> Option<NodeId> {
+ self.id_map.get(id).copied()
+ }
+
+ // --- Navigation ---
+
+ /// Returns the parent of a node, or `None` for the document root.
+ #[must_use]
+ #[inline]
+ pub fn parent(&self, id: NodeId) -> Option<NodeId> {
+ self.node(id).parent
+ }
+
+ /// Returns the first child of a node, or `None` if it has no children.
+ #[inline]
+ #[must_use]
+ pub fn first_child(&self, id: NodeId) -> Option<NodeId> {
+ self.node(id).first_child
+ }
+
+ /// Returns the last child of a node, or `None` if it has no children.
+ #[inline]
+ #[must_use]
+ pub fn last_child(&self, id: NodeId) -> Option<NodeId> {
+ self.node(id).last_child
+ }
+
+ /// Returns the next sibling of a node, or `None` if it is the last child.
+ #[inline]
+ #[must_use]
+ pub fn next_sibling(&self, id: NodeId) -> Option<NodeId> {
+ self.node(id).next_sibling
+ }
+
+ /// Returns the previous sibling of a node, or `None` if it is the first child.
+ #[inline]
+ #[must_use]
+ pub fn prev_sibling(&self, id: NodeId) -> Option<NodeId> {
+ self.node(id).prev_sibling
+ }
+
+ /// Returns an iterator over the direct children of a node.
+ ///
+ /// Yields each child `NodeId` in document order (first child to last).
+ /// For a depth-first traversal that includes nested descendants, use
+ /// [`descendants`](Self::descendants).
+ pub fn children(&self, id: NodeId) -> Children<'_> {
+ Children {
+ doc: self,
+ next: self.node(id).first_child,
+ }
+ }
+
+ /// Returns an iterator over a node and its ancestors, walking up to the
+ /// document root.
+ ///
+ /// The first item yielded is `id` itself, followed by its parent, then
+ /// grandparent, and so on up to the document root node.
+ pub fn ancestors(&self, id: NodeId) -> Ancestors<'_> {
+ Ancestors {
+ doc: self,
+ next: Some(id),
+ }
+ }
+
+ /// Returns an iterator over all descendants of a node in depth-first
+ /// (pre-order) traversal.
+ ///
+ /// Does *not* yield `id` itself — only its children, grandchildren, etc.
+ /// For iterating only the direct children, use
+ /// [`children`](Self::children).
+ pub fn descendants(&self, id: NodeId) -> Descendants<'_> {
+ Descendants {
+ doc: self,
+ root: id,
+ next: self.first_child(id),
+ }
+ }
+
+ // --- Mutation ---
+
+ /// Allocates a new node in the arena and returns its `NodeId`.
+ ///
+ /// The new node is detached (has no parent). Use
+ /// [`append_child`](Self::append_child),
+ /// [`prepend_child`](Self::prepend_child), or
+ /// [`insert_before`](Self::insert_before) to attach it to the tree.
+ pub fn create_node(&mut self, kind: NodeKind) -> NodeId {
+ let index = self.nodes.len();
+ self.nodes.push(NodeData::new(kind));
+ NodeId::from_index(index)
+ }
+
+ /// Appends a child node to the end of a parent's child list.
+ ///
+ /// The child becomes the new [`last_child`](Self::last_child) of `parent`.
+ /// If the parent had no children, the child also becomes the
+ /// [`first_child`](Self::first_child).
+ ///
+ /// # Panics
+ ///
+ /// Panics (debug-only) if `child` already has a parent. Call
+ /// [`detach`](Self::detach) first to re-parent an existing node.
+ pub fn append_child(&mut self, parent: NodeId, child: NodeId) {
+ debug_assert!(
+ self.node(child).parent.is_none(),
+ "child already has a parent; detach it first"
+ );
+
+ self.node_mut(child).parent = Some(parent);
+
+ if let Some(last) = self.node(parent).last_child {
+ self.node_mut(last).next_sibling = Some(child);
+ self.node_mut(child).prev_sibling = Some(last);
+ self.node_mut(parent).last_child = Some(child);
+ } else {
+ self.node_mut(parent).first_child = Some(child);
+ self.node_mut(parent).last_child = Some(child);
+ }
+ }
+
+ /// Inserts `new_child` immediately before `reference` in the sibling list.
+ ///
+ /// The new child is given the same parent as `reference` and is linked as
+ /// its previous sibling.
+ ///
+ /// # Panics
+ ///
+ /// Panics if `reference` has no parent or if `new_child` already has a
+ /// parent (detach it first).
+ #[allow(clippy::expect_used)]
+ pub fn insert_before(&mut self, reference: NodeId, new_child: NodeId) {
+ debug_assert!(
+ self.node(new_child).parent.is_none(),
+ "new_child already has a parent; detach it first"
+ );
+
+ let parent = self
+ .node(reference)
+ .parent
+ .expect("reference has no parent");
+ self.node_mut(new_child).parent = Some(parent);
+
+ if let Some(prev) = self.node(reference).prev_sibling {
+ self.node_mut(prev).next_sibling = Some(new_child);
+ self.node_mut(new_child).prev_sibling = Some(prev);
+ } else {
+ self.node_mut(parent).first_child = Some(new_child);
+ }
+
+ self.node_mut(new_child).next_sibling = Some(reference);
+ self.node_mut(reference).prev_sibling = Some(new_child);
+ }
+
+ /// Prepends a child node as the first child of a parent.
+ ///
+ /// If the parent already has children, the new child is inserted before
+ /// the current first child. Otherwise, it becomes the only child.
+ pub fn prepend_child(&mut self, parent: NodeId, child: NodeId) {
+ if let Some(first) = self.first_child(parent) {
+ self.insert_before(first, child);
+ } else {
+ self.append_child(parent, child);
+ }
+ }
+
+ /// Removes a node from the tree by detaching it from its parent.
+ ///
+ /// The node and its subtree remain allocated in the arena but become
+ /// unreachable through tree navigation. This is an alias for
+ /// [`detach`](Self::detach).
+ pub fn remove_node(&mut self, id: NodeId) {
+ self.detach(id);
+ }
+
+ /// Detaches a node from its parent without freeing it from the arena.
+ ///
+ /// Updates sibling and parent links so the node is no longer reachable
+ /// through tree traversal. The node's own children are left intact, so the
+ /// detached subtree remains internally connected. If the node has no
+ /// parent, this is a no-op.
+ pub fn detach(&mut self, id: NodeId) {
+ let Some(parent) = self.node(id).parent else {
+ return;
+ };
+
+ let prev = self.node(id).prev_sibling;
+ let next = self.node(id).next_sibling;
+
+ match prev {
+ Some(p) => self.node_mut(p).next_sibling = next,
+ None => self.node_mut(parent).first_child = next,
+ }
+
+ match next {
+ Some(n) => self.node_mut(n).prev_sibling = prev,
+ None => self.node_mut(parent).last_child = prev,
+ }
+
+ self.node_mut(id).parent = None;
+ self.node_mut(id).prev_sibling = None;
+ self.node_mut(id).next_sibling = None;
+ }
+
+ /// Deep-copies a node and all its descendants within this document.
+ ///
+ /// The cloned subtree is detached (has no parent). If `deep` is `false`,
+ /// only the node itself is cloned without its children.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::Document;
+ ///
+ /// let mut doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+ /// let root = doc.root_element().unwrap();
+ /// let child = doc.first_child(root).unwrap();
+ /// let cloned = doc.clone_node(child, true);
+ /// doc.append_child(root, cloned);
+ /// ```
+ pub fn clone_node(&mut self, id: NodeId, deep: bool) -> NodeId {
+ let kind = self.node(id).kind.clone();
+ let new_id = self.create_node(kind);
+ if deep {
+ // Clone children recursively
+ let children: Vec<NodeId> = self.children(id).collect();
+ for child_id in children {
+ let cloned_child = self.clone_node(child_id, true);
+ self.append_child(new_id, cloned_child);
+ }
+ }
+ new_id
+ }
+
+ /// Sets the text content of a text, CDATA, or comment node.
+ ///
+ /// For element nodes, this removes all children and replaces them with
+ /// a single text node containing the given content.
+ ///
+ /// Returns `true` if the content was set, `false` if the node type does
+ /// not support text content (e.g., the document root).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use xmloxide::Document;
+ ///
+ /// let mut doc = Document::parse_str("<root>old</root>").unwrap();
+ /// let root = doc.root_element().unwrap();
+ /// let text_node = doc.first_child(root).unwrap();
+ /// assert!(doc.set_text_content(text_node, "new"));
+ /// assert_eq!(doc.text_content(root), "new");
+ /// ```
+ pub fn set_text_content(&mut self, id: NodeId, content: &str) -> bool {
+ match &self.node(id).kind {
+ NodeKind::Text { .. } | NodeKind::CData { .. } | NodeKind::Comment { .. } => {
+ match &mut self.node_mut(id).kind {
+ NodeKind::Text {
+ content: ref mut c, ..
+ }
+ | NodeKind::CData {
+ content: ref mut c, ..
+ }
+ | NodeKind::Comment {
+ content: ref mut c, ..
+ } => {
+ *c = content.to_string();
+ }
+ _ => unreachable!(),
+ }
+ true
+ }
+ NodeKind::Element { .. } => {
+ // Remove all children
+ let children: Vec<NodeId> = self.children(id).collect();
+ for child in children {
+ self.remove_node(child);
+ }
+ // Add a single text node
+ let text = self.create_node(NodeKind::Text {
+ content: content.to_string(),
+ });
+ self.append_child(id, text);
+ true
+ }
+ NodeKind::ProcessingInstruction { .. } => {
+ if let NodeKind::ProcessingInstruction { data, .. } = &mut self.node_mut(id).kind {
+ *data = Some(content.to_string());
+ }
+ true
+ }
+ NodeKind::Document | NodeKind::DocumentType { .. } | NodeKind::EntityRef { .. } => {
+ false
+ }
+ }
+ }
+
+ /// Creates a new element node (detached) and returns its `NodeId`.
+ ///
+ /// Use [`append_child`](Self::append_child), [`prepend_child`](Self::prepend_child),
+ /// or [`insert_before`](Self::insert_before) to attach it.
+ pub fn create_element(&mut self, name: &str) -> NodeId {
+ self.create_node(NodeKind::Element {
+ name: name.to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ })
+ }
+
+ /// Creates a new text node (detached) and returns its `NodeId`.
+ pub fn create_text(&mut self, content: &str) -> NodeId {
+ self.create_node(NodeKind::Text {
+ content: content.to_string(),
+ })
+ }
+
+ /// Creates a new comment node (detached) and returns its `NodeId`.
+ pub fn create_comment(&mut self, content: &str) -> NodeId {
+ self.create_node(NodeKind::Comment {
+ content: content.to_string(),
+ })
+ }
+
+ /// Creates a new processing instruction node (detached) and returns its `NodeId`.
+ pub fn create_processing_instruction(&mut self, target: &str, data: Option<&str>) -> NodeId {
+ self.create_node(NodeKind::ProcessingInstruction {
+ target: target.to_string(),
+ data: data.map(ToString::to_string),
+ })
+ }
+
+ /// Inserts `new_child` immediately after `reference` in the sibling list.
+ ///
+ /// If `reference` is the last child, this is equivalent to appending to the parent.
+ ///
+ /// # Panics
+ ///
+ /// Panics if `reference` has no parent or if `new_child` already has a parent.
+ #[allow(clippy::expect_used)]
+ pub fn insert_after(&mut self, reference: NodeId, new_child: NodeId) {
+ debug_assert!(
+ self.node(new_child).parent.is_none(),
+ "new_child already has a parent; detach it first"
+ );
+
+ let parent = self
+ .node(reference)
+ .parent
+ .expect("reference has no parent");
+ self.node_mut(new_child).parent = Some(parent);
+
+ if let Some(next) = self.node(reference).next_sibling {
+ self.node_mut(next).prev_sibling = Some(new_child);
+ self.node_mut(new_child).next_sibling = Some(next);
+ } else {
+ self.node_mut(parent).last_child = Some(new_child);
+ }
+
+ self.node_mut(new_child).prev_sibling = Some(reference);
+ self.node_mut(reference).next_sibling = Some(new_child);
+ }
+
+ /// Replaces `old_node` with `new_node` in the tree.
+ ///
+ /// The old node is detached and the new node takes its place in the
+ /// sibling list. Returns the id of the old (now detached) node.
+ ///
+ /// # Panics
+ ///
+ /// Panics if `old_node` has no parent or if `new_node` already has a parent.
+ pub fn replace_node(&mut self, old_node: NodeId, new_node: NodeId) -> NodeId {
+ self.insert_before(old_node, new_node);
+ self.detach(old_node);
+ old_node
+ }
+
+ /// Sets an attribute on an element node. If the attribute already exists,
+ /// its value is updated. Returns `true` on success, `false` if the node
+ /// is not an element.
+ pub fn set_attribute(&mut self, id: NodeId, name: &str, value: &str) -> bool {
+ if let NodeKind::Element { attributes, .. } = &mut self.node_mut(id).kind {
+ if let Some(attr) = attributes.iter_mut().find(|a| a.name == name) {
+ attr.value = value.to_string();
+ attr.raw_value = None;
+ } else {
+ attributes.push(Attribute {
+ name: name.to_string(),
+ value: value.to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ });
+ }
+ true
+ } else {
+ false
+ }
+ }
+
+ /// Removes an attribute by name from an element node.
+ ///
+ /// Returns `true` if the attribute was found and removed, `false` if the
+ /// attribute was not present or the node is not an element.
+ pub fn remove_attribute(&mut self, id: NodeId, name: &str) -> bool {
+ if let NodeKind::Element { attributes, .. } = &mut self.node_mut(id).kind {
+ let len = attributes.len();
+ attributes.retain(|a| a.name != name);
+ attributes.len() < len
+ } else {
+ false
+ }
+ }
+
+ /// Renames an element node. Returns `true` on success, `false` if the
+ /// node is not an element.
+ pub fn rename_element(&mut self, id: NodeId, new_name: &str) -> bool {
+ if let NodeKind::Element { name, .. } = &mut self.node_mut(id).kind {
+ *name = new_name.to_string();
+ true
+ } else {
+ false
+ }
+ }
+
+ /// Returns the total number of nodes in the document.
+ ///
+ /// This includes all node types (elements, text, comments, etc.) but
+ /// excludes the internal arena placeholder. Detached nodes that have not
+ /// been garbage-collected are still counted.
+ #[must_use]
+ pub fn node_count(&self) -> usize {
+ self.nodes.len() - 1 // subtract placeholder at index 0
+ }
+}
+
+impl Default for Document {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+// --- Iterators ---
+
+/// Iterator over the direct children of a node.
+///
+/// Created by [`Document::children`]. Yields each child's `NodeId` in
+/// document order by following `next_sibling` links.
+pub struct Children<'a> {
+ doc: &'a Document,
+ next: Option<NodeId>,
+}
+
+impl Iterator for Children<'_> {
+ type Item = NodeId;
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ let current = self.next?;
+ self.next = self.doc.nodes[current.as_index()].next_sibling;
+ Some(current)
+ }
+}
+
+/// Iterator over a node and its ancestors, walking up toward the document root.
+///
+/// Created by [`Document::ancestors`]. The first item yielded is the starting
+/// node itself, followed by its parent, grandparent, etc.
+pub struct Ancestors<'a> {
+ doc: &'a Document,
+ next: Option<NodeId>,
+}
+
+impl Iterator for Ancestors<'_> {
+ type Item = NodeId;
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ let current = self.next?;
+ self.next = self.doc.node(current).parent;
+ Some(current)
+ }
+}
+
+/// Depth-first (pre-order) iterator over all descendants of a node.
+///
+/// Created by [`Document::descendants`]. Yields every node in the subtree
+/// below the starting node, but does *not* yield the starting node itself.
+pub struct Descendants<'a> {
+ doc: &'a Document,
+ root: NodeId,
+ next: Option<NodeId>,
+}
+
+impl Iterator for Descendants<'_> {
+ type Item = NodeId;
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ let current = self.next?;
+ let nodes = &self.doc.nodes;
+
+ // Try to go deeper first
+ let node = &nodes[current.as_index()];
+ if let Some(child) = node.first_child {
+ self.next = Some(child);
+ return Some(current);
+ }
+
+ // Try next sibling
+ if let Some(sibling) = node.next_sibling {
+ self.next = Some(sibling);
+ return Some(current);
+ }
+
+ // Walk up to find an ancestor with a next sibling
+ let mut ancestor = node.parent;
+ while let Some(anc) = ancestor {
+ if anc == self.root {
+ self.next = None;
+ return Some(current);
+ }
+ let anc_node = &nodes[anc.as_index()];
+ if let Some(sibling) = anc_node.next_sibling {
+ self.next = Some(sibling);
+ return Some(current);
+ }
+ ancestor = anc_node.parent;
+ }
+
+ self.next = None;
+ Some(current)
+ }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_new_document_has_root() {
+ let doc = Document::new();
+ assert!(matches!(doc.node(doc.root()).kind, NodeKind::Document));
+ assert_eq!(doc.node_count(), 1); // just the root
+ }
+
+ #[test]
+ fn test_create_and_append_element() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "div".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, elem);
+
+ assert_eq!(doc.first_child(root), Some(elem));
+ assert_eq!(doc.last_child(root), Some(elem));
+ assert_eq!(doc.parent(elem), Some(root));
+ assert_eq!(doc.node_name(elem), Some("div"));
+ }
+
+ #[test]
+ fn test_append_multiple_children() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+ doc.append_child(root, c);
+
+ assert_eq!(doc.first_child(root), Some(a));
+ assert_eq!(doc.last_child(root), Some(c));
+ assert_eq!(doc.next_sibling(a), Some(b));
+ assert_eq!(doc.next_sibling(b), Some(c));
+ assert_eq!(doc.next_sibling(c), None);
+ assert_eq!(doc.prev_sibling(c), Some(b));
+ assert_eq!(doc.prev_sibling(b), Some(a));
+ assert_eq!(doc.prev_sibling(a), None);
+ }
+
+ #[test]
+ fn test_children_iterator() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+ doc.append_child(root, c);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, b, c]);
+ }
+
+ #[test]
+ fn test_children_iterator_empty() {
+ let doc = Document::new();
+ let children: Vec<NodeId> = doc.children(doc.root()).collect();
+ assert!(children.is_empty());
+ }
+
+ #[test]
+ fn test_insert_before() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+ doc.append_child(root, a);
+ doc.append_child(root, c);
+
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ doc.insert_before(c, b);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, b, c]);
+ assert_eq!(doc.parent(b), Some(root));
+ }
+
+ #[test]
+ fn test_insert_before_first_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ doc.append_child(root, b);
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ doc.insert_before(b, a);
+
+ assert_eq!(doc.first_child(root), Some(a));
+ assert_eq!(doc.next_sibling(a), Some(b));
+ }
+
+ #[test]
+ fn test_detach() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+ doc.append_child(root, c);
+
+ doc.detach(b);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, c]);
+ assert_eq!(doc.parent(b), None);
+ assert_eq!(doc.next_sibling(a), Some(c));
+ assert_eq!(doc.prev_sibling(c), Some(a));
+ }
+
+ #[test]
+ fn test_detach_first_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+
+ doc.detach(a);
+ assert_eq!(doc.first_child(root), Some(b));
+ assert_eq!(doc.prev_sibling(b), None);
+ }
+
+ #[test]
+ fn test_detach_last_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+
+ doc.detach(b);
+ assert_eq!(doc.last_child(root), Some(a));
+ assert_eq!(doc.next_sibling(a), None);
+ }
+
+ #[test]
+ fn test_detach_only_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ doc.append_child(root, a);
+ doc.detach(a);
+
+ assert_eq!(doc.first_child(root), None);
+ assert_eq!(doc.last_child(root), None);
+ }
+
+ #[test]
+ fn test_ancestors_iterator() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let parent = doc.create_node(NodeKind::Element {
+ name: "parent".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let child = doc.create_node(NodeKind::Element {
+ name: "child".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+
+ doc.append_child(root, parent);
+ doc.append_child(parent, child);
+
+ let ancestors: Vec<NodeId> = doc.ancestors(child).collect();
+ assert_eq!(ancestors, vec![child, parent, root]);
+ }
+
+ #[test]
+ fn test_descendants_iterator() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let p = doc.create_node(NodeKind::Element {
+ name: "p".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let a = doc.create_node(NodeKind::Text {
+ content: "hello ".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Element {
+ name: "b".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let b_text = doc.create_node(NodeKind::Text {
+ content: "world".to_string(),
+ });
+
+ doc.append_child(root, p);
+ doc.append_child(p, a);
+ doc.append_child(p, b);
+ doc.append_child(b, b_text);
+
+ let desc: Vec<NodeId> = doc.descendants(root).collect();
+ assert_eq!(desc, vec![p, a, b, b_text]);
+ }
+
+ #[test]
+ fn test_text_content() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let p = doc.create_node(NodeKind::Element {
+ name: "p".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let text1 = doc.create_node(NodeKind::Text {
+ content: "hello ".to_string(),
+ });
+ let bold = doc.create_node(NodeKind::Element {
+ name: "b".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ let text2 = doc.create_node(NodeKind::Text {
+ content: "world".to_string(),
+ });
+
+ doc.append_child(root, p);
+ doc.append_child(p, text1);
+ doc.append_child(p, bold);
+ doc.append_child(bold, text2);
+
+ assert_eq!(doc.text_content(p), "hello world");
+ }
+
+ #[test]
+ fn test_text_content_entity_ref_children_take_priority() {
+ // When an EntityRef node carries parsed replacement children
+ // (XML 1.0 §4.4), text_content reads them, not the stored value.
+ let mut doc = Document::new();
+ let root = doc.root();
+ let entity = doc.create_node(NodeKind::EntityRef {
+ name: "e".to_string(),
+ value: Some("raw value".to_string()),
+ });
+ let text = doc.create_node(NodeKind::Text {
+ content: "expanded".to_string(),
+ });
+ doc.append_child(root, entity);
+ doc.append_child(entity, text);
+ assert_eq!(doc.text_content(root), "expanded");
+ }
+
+ #[test]
+ fn test_text_content_entity_ref_value_fallback() {
+ // A childless EntityRef (e.g. built programmatically) falls back to
+ // its stored replacement value.
+ let mut doc = Document::new();
+ let root = doc.root();
+ let entity = doc.create_node(NodeKind::EntityRef {
+ name: "e".to_string(),
+ value: Some("fallback".to_string()),
+ });
+ doc.append_child(root, entity);
+ assert_eq!(doc.text_content(root), "fallback");
+ }
+
+ #[test]
+ fn test_attributes() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let elem = doc.create_node(NodeKind::Element {
+ name: "div".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![
+ Attribute {
+ name: "id".to_string(),
+ value: "main".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ },
+ Attribute {
+ name: "class".to_string(),
+ value: "container".to_string(),
+ prefix: None,
+ namespace: None,
+ raw_value: None,
+ },
+ ],
+ });
+ doc.append_child(root, elem);
+
+ assert_eq!(doc.attribute(elem, "id"), Some("main"));
+ assert_eq!(doc.attribute(elem, "class"), Some("container"));
+ assert_eq!(doc.attribute(elem, "style"), None);
+ assert_eq!(doc.attributes(elem).len(), 2);
+ }
+
+ #[test]
+ fn test_root_element() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ // No element children yet
+ assert_eq!(doc.root_element(), None);
+
+ let elem = doc.create_node(NodeKind::Element {
+ name: "root".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, elem);
+
+ assert_eq!(doc.root_element(), Some(elem));
+ }
+
+ #[test]
+ fn test_node_text() {
+ let mut doc = Document::new();
+
+ let text = doc.create_node(NodeKind::Text {
+ content: "hello".to_string(),
+ });
+ assert_eq!(doc.node_text(text), Some("hello"));
+
+ let comment = doc.create_node(NodeKind::Comment {
+ content: "a comment".to_string(),
+ });
+ assert_eq!(doc.node_text(comment), Some("a comment"));
+
+ let cdata = doc.create_node(NodeKind::CData {
+ content: "cdata content".to_string(),
+ });
+ assert_eq!(doc.node_text(cdata), Some("cdata content"));
+
+ let elem = doc.create_node(NodeKind::Element {
+ name: "div".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ assert_eq!(doc.node_text(elem), None);
+ }
+
+ #[test]
+ fn test_element_by_id_none() {
+ let doc = Document::new();
+ assert_eq!(doc.element_by_id("nonexistent"), None);
+ }
+
+ #[test]
+ fn test_set_id_and_lookup() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "item".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, elem);
+ doc.set_id("a", elem);
+ assert_eq!(doc.element_by_id("a"), Some(elem));
+ assert_eq!(doc.element_by_id("b"), None);
+ }
+
+ #[test]
+ fn test_remove_node_middle_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+ doc.append_child(root, c);
+
+ doc.remove_node(b);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, c]);
+ assert_eq!(doc.parent(b), None);
+ assert_eq!(doc.next_sibling(b), None);
+ assert_eq!(doc.prev_sibling(b), None);
+ assert_eq!(doc.next_sibling(a), Some(c));
+ assert_eq!(doc.prev_sibling(c), Some(a));
+ }
+
+ #[test]
+ fn test_remove_node_only_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Element {
+ name: "only".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, a);
+
+ doc.remove_node(a);
+
+ assert_eq!(doc.first_child(root), None);
+ assert_eq!(doc.last_child(root), None);
+ assert_eq!(doc.parent(a), None);
+ }
+
+ #[test]
+ fn test_remove_node_first_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+
+ doc.remove_node(a);
+
+ assert_eq!(doc.first_child(root), Some(b));
+ assert_eq!(doc.prev_sibling(b), None);
+ assert_eq!(doc.parent(a), None);
+ }
+
+ #[test]
+ fn test_remove_node_last_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+
+ doc.remove_node(b);
+
+ assert_eq!(doc.last_child(root), Some(a));
+ assert_eq!(doc.next_sibling(a), None);
+ assert_eq!(doc.parent(b), None);
+ }
+
+ #[test]
+ fn test_remove_node_no_parent_is_noop() {
+ let mut doc = Document::new();
+ let orphan = doc.create_node(NodeKind::Text {
+ content: "orphan".to_string(),
+ });
+
+ // Removing a node with no parent should not panic
+ doc.remove_node(orphan);
+
+ assert_eq!(doc.parent(orphan), None);
+ }
+
+ #[test]
+ fn test_prepend_child_to_empty_parent() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Element {
+ name: "first".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+
+ doc.prepend_child(root, a);
+
+ assert_eq!(doc.first_child(root), Some(a));
+ assert_eq!(doc.last_child(root), Some(a));
+ assert_eq!(doc.parent(a), Some(root));
+ }
+
+ #[test]
+ fn test_prepend_child_before_existing() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+ doc.append_child(root, b);
+ doc.append_child(root, c);
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ doc.prepend_child(root, a);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, b, c]);
+ assert_eq!(doc.first_child(root), Some(a));
+ assert_eq!(doc.last_child(root), Some(c));
+ assert_eq!(doc.parent(a), Some(root));
+ assert_eq!(doc.next_sibling(a), Some(b));
+ assert_eq!(doc.prev_sibling(b), Some(a));
+ }
+
+ #[test]
+ fn test_prepend_child_multiple_times() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+
+ doc.prepend_child(root, c);
+ doc.prepend_child(root, b);
+ doc.prepend_child(root, a);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, b, c]);
+ }
+
+ #[test]
+ fn test_node_namespace_with_namespace() {
+ let mut doc = Document::new();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "rect".to_string(),
+ prefix: Some("svg".to_string()),
+ namespace: Some("http://www.w3.org/2000/svg".to_string()),
+ attributes: vec![],
+ });
+
+ assert_eq!(doc.node_namespace(elem), Some("http://www.w3.org/2000/svg"));
+ }
+
+ #[test]
+ fn test_node_namespace_without_namespace() {
+ let mut doc = Document::new();
+ let elem = doc.create_node(NodeKind::Element {
+ name: "div".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+
+ assert_eq!(doc.node_namespace(elem), None);
+ }
+
+ #[test]
+ fn test_node_namespace_non_element() {
+ let mut doc = Document::new();
+ let text = doc.create_node(NodeKind::Text {
+ content: "hello".to_string(),
+ });
+ let comment = doc.create_node(NodeKind::Comment {
+ content: "a comment".to_string(),
+ });
+
+ assert_eq!(doc.node_namespace(text), None);
+ assert_eq!(doc.node_namespace(comment), None);
+ }
+
+ #[test]
+ fn test_first_child_of_leaf_node() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let leaf = doc.create_node(NodeKind::Text {
+ content: "leaf".to_string(),
+ });
+ doc.append_child(root, leaf);
+
+ assert_eq!(doc.first_child(leaf), None);
+ }
+
+ #[test]
+ fn test_last_child_of_leaf_node() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let leaf = doc.create_node(NodeKind::Text {
+ content: "leaf".to_string(),
+ });
+ doc.append_child(root, leaf);
+
+ assert_eq!(doc.last_child(leaf), None);
+ }
+
+ #[test]
+ fn test_first_child_last_child_single_child() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let only = doc.create_node(NodeKind::Element {
+ name: "only".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ doc.append_child(root, only);
+
+ assert_eq!(doc.first_child(root), Some(only));
+ assert_eq!(doc.last_child(root), Some(only));
+ }
+
+ #[test]
+ fn test_first_child_last_child_multiple_children() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let first = doc.create_node(NodeKind::Text {
+ content: "first".to_string(),
+ });
+ let middle = doc.create_node(NodeKind::Text {
+ content: "middle".to_string(),
+ });
+ let last = doc.create_node(NodeKind::Text {
+ content: "last".to_string(),
+ });
+
+ doc.append_child(root, first);
+ doc.append_child(root, middle);
+ doc.append_child(root, last);
+
+ assert_eq!(doc.first_child(root), Some(first));
+ assert_eq!(doc.last_child(root), Some(last));
+ assert_ne!(doc.first_child(root), doc.last_child(root));
+ }
+
+ #[test]
+ fn test_next_sibling_last_has_none() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+
+ assert_eq!(doc.next_sibling(a), Some(b));
+ assert_eq!(doc.next_sibling(b), None);
+ }
+
+ #[test]
+ fn test_prev_sibling_first_has_none() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+
+ assert_eq!(doc.prev_sibling(a), None);
+ assert_eq!(doc.prev_sibling(b), Some(a));
+ }
+
+ #[test]
+ fn test_next_prev_sibling_chain() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ let b = doc.create_node(NodeKind::Text {
+ content: "B".to_string(),
+ });
+ let c = doc.create_node(NodeKind::Text {
+ content: "C".to_string(),
+ });
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+ doc.append_child(root, c);
+
+ // Forward traversal
+ assert_eq!(doc.next_sibling(a), Some(b));
+ assert_eq!(doc.next_sibling(b), Some(c));
+ assert_eq!(doc.next_sibling(c), None);
+
+ // Backward traversal
+ assert_eq!(doc.prev_sibling(c), Some(b));
+ assert_eq!(doc.prev_sibling(b), Some(a));
+ assert_eq!(doc.prev_sibling(a), None);
+ }
+
+ #[test]
+ fn test_parse_str_simple_element() {
+ let Ok(doc) = Document::parse_str("<root/>") else {
+ panic!("failed to parse simple element");
+ };
+ let Some(root) = doc.root_element() else {
+ panic!("parsed document has no root element");
+ };
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+
+ #[test]
+ fn test_parse_str_nested_elements() {
+ let Ok(doc) = Document::parse_str("<parent><child/></parent>") else {
+ panic!("failed to parse nested elements");
+ };
+ let Some(root) = doc.root_element() else {
+ panic!("parsed document has no root element");
+ };
+ assert_eq!(doc.node_name(root), Some("parent"));
+
+ let Some(child) = doc.first_child(root) else {
+ panic!("root element has no children");
+ };
+ assert_eq!(doc.node_name(child), Some("child"));
+ }
+
+ #[test]
+ fn test_parse_str_with_text_content() {
+ let Ok(doc) = Document::parse_str("<msg>hello</msg>") else {
+ panic!("failed to parse element with text");
+ };
+ let Some(root) = doc.root_element() else {
+ panic!("parsed document has no root element");
+ };
+ assert_eq!(doc.text_content(root), "hello");
+ }
+
+ #[test]
+ fn test_parse_str_with_attributes() {
+ let Ok(doc) = Document::parse_str(r#"<div id="main" class="x"/>"#) else {
+ panic!("failed to parse element with attributes");
+ };
+ let Some(root) = doc.root_element() else {
+ panic!("parsed document has no root element");
+ };
+ assert_eq!(doc.attribute(root, "id"), Some("main"));
+ assert_eq!(doc.attribute(root, "class"), Some("x"));
+ }
+
+ #[test]
+ fn test_parse_bytes_utf8() {
+ let input = b"<root>hello</root>";
+ let Ok(doc) = Document::parse_bytes(input) else {
+ panic!("failed to parse bytes");
+ };
+ let Some(root) = doc.root_element() else {
+ panic!("parsed document has no root element");
+ };
+ assert_eq!(doc.node_name(root), Some("root"));
+ assert_eq!(doc.text_content(root), "hello");
+ }
+
+ #[test]
+ fn test_parse_bytes_with_xml_declaration() {
+ let input = b"<?xml version=\"1.0\" encoding=\"UTF-8\"?><data/>";
+ let Ok(doc) = Document::parse_bytes(input) else {
+ panic!("failed to parse bytes with XML declaration");
+ };
+ let Some(root) = doc.root_element() else {
+ panic!("parsed document has no root element");
+ };
+ assert_eq!(doc.node_name(root), Some("data"));
+ }
+
+ #[test]
+ fn test_parse_bytes_with_bom() {
+ // UTF-8 BOM followed by XML
+ let mut input = vec![0xEF, 0xBB, 0xBF];
+ input.extend_from_slice(b"<root/>");
+ let Ok(doc) = Document::parse_bytes(&input) else {
+ panic!("failed to parse bytes with BOM");
+ };
+ let Some(root) = doc.root_element() else {
+ panic!("parsed document has no root element");
+ };
+ assert_eq!(doc.node_name(root), Some("root"));
+ }
+
+ #[test]
+ fn test_node_count_empty_document() {
+ let doc = Document::new();
+ // A new document has exactly 1 node: the document root node
+ assert_eq!(doc.node_count(), 1);
+ }
+
+ #[test]
+ fn test_node_count_after_creating_nodes() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Element {
+ name: "a".to_string(),
+ prefix: None,
+ namespace: None,
+ attributes: vec![],
+ });
+ assert_eq!(doc.node_count(), 2);
+
+ let b = doc.create_node(NodeKind::Text {
+ content: "text".to_string(),
+ });
+ assert_eq!(doc.node_count(), 3);
+
+ doc.append_child(root, a);
+ doc.append_child(a, b);
+
+ // Appending does not change the count — nodes already exist in arena
+ assert_eq!(doc.node_count(), 3);
+ }
+
+ #[test]
+ fn test_node_count_after_remove() {
+ let mut doc = Document::new();
+ let root = doc.root();
+
+ let a = doc.create_node(NodeKind::Text {
+ content: "A".to_string(),
+ });
+ doc.append_child(root, a);
+ assert_eq!(doc.node_count(), 2);
+
+ // Removing a node does not free it from the arena
+ doc.remove_node(a);
+ assert_eq!(doc.node_count(), 2);
+ }
+
+ #[test]
+ fn test_clone_node_shallow() {
+ let mut doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+ let root = doc.root_element().unwrap();
+ let child = doc.first_child(root).unwrap();
+
+ let cloned = doc.clone_node(child, false);
+ assert_eq!(doc.node_name(cloned), Some("child"));
+ // Shallow clone has no children
+ assert!(doc.first_child(cloned).is_none());
+ // Clone is detached
+ assert!(doc.parent(cloned).is_none());
+ }
+
+ #[test]
+ fn test_clone_node_deep() {
+ let mut doc =
+ Document::parse_str("<root><parent><child>Hello</child></parent></root>").unwrap();
+ let root = doc.root_element().unwrap();
+ let parent_elem = doc.first_child(root).unwrap();
+
+ let cloned = doc.clone_node(parent_elem, true);
+ assert_eq!(doc.node_name(cloned), Some("parent"));
+ // Deep clone has children
+ let cloned_child = doc.first_child(cloned).unwrap();
+ assert_eq!(doc.node_name(cloned_child), Some("child"));
+ let cloned_text = doc.first_child(cloned_child).unwrap();
+ assert_eq!(doc.node_text(cloned_text), Some("Hello"));
+ // Clone is detached
+ assert!(doc.parent(cloned).is_none());
+ // Original is unchanged
+ assert!(doc.first_child(parent_elem).is_some());
+ }
+
+ #[test]
+ fn test_clone_node_and_append() {
+ let mut doc = Document::parse_str("<root><item>A</item></root>").unwrap();
+ let root = doc.root_element().unwrap();
+ let item = doc.first_child(root).unwrap();
+
+ let cloned = doc.clone_node(item, true);
+ doc.append_child(root, cloned);
+
+ let children: Vec<_> = doc.children(root).collect();
+ assert_eq!(children.len(), 2);
+ assert_eq!(doc.text_content(children[0]), "A");
+ assert_eq!(doc.text_content(children[1]), "A");
+ }
+
+ #[test]
+ fn test_parse_file_nonexistent() {
+ let result = Document::parse_file("/nonexistent/path.xml");
+ assert!(result.is_err());
+ assert!(result.unwrap_err().message.contains("failed to read file"));
+ }
+
+ #[test]
+ fn test_parse_file_valid() {
+ use std::io::Write;
+ let dir = std::env::temp_dir().join("xmloxide_test_parse_file");
+ std::fs::create_dir_all(&dir).unwrap();
+ let path = dir.join("test.xml");
+ let mut f = std::fs::File::create(&path).unwrap();
+ f.write_all(b"<root>Hello</root>").unwrap();
+ drop(f);
+
+ let doc = Document::parse_file(&path).unwrap();
+ let root = doc.root_element().unwrap();
+ assert_eq!(doc.node_name(root), Some("root"));
+ assert_eq!(doc.text_content(root), "Hello");
+
+ std::fs::remove_dir_all(&dir).unwrap();
+ }
+
+ #[test]
+ fn test_create_element_convenience() {
+ let mut doc = Document::new();
+ let elem = doc.create_element("div");
+ assert_eq!(doc.node_name(elem), Some("div"));
+ assert!(matches!(doc.node(elem).kind, NodeKind::Element { .. }));
+ }
+
+ #[test]
+ fn test_create_text_convenience() {
+ let mut doc = Document::new();
+ let t = doc.create_text("hello");
+ assert_eq!(doc.node_text(t), Some("hello"));
+ }
+
+ #[test]
+ fn test_create_comment_convenience() {
+ let mut doc = Document::new();
+ let c = doc.create_comment("a comment");
+ assert_eq!(doc.node_text(c), Some("a comment"));
+ assert!(matches!(doc.node(c).kind, NodeKind::Comment { .. }));
+ }
+
+ #[test]
+ fn test_create_processing_instruction() {
+ let mut doc = Document::new();
+ let pi = doc.create_processing_instruction("target", Some("data"));
+ assert_eq!(doc.node_name(pi), Some("target"));
+ assert_eq!(doc.node_text(pi), Some("data"));
+ }
+
+ #[test]
+ fn test_insert_after() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let a = doc.create_text("A");
+ let b = doc.create_text("B");
+ let c = doc.create_text("C");
+
+ doc.append_child(root, a);
+ doc.append_child(root, c);
+ doc.insert_after(a, b);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, b, c]);
+ assert_eq!(doc.next_sibling(a), Some(b));
+ assert_eq!(doc.next_sibling(b), Some(c));
+ assert_eq!(doc.prev_sibling(c), Some(b));
+ }
+
+ #[test]
+ fn test_insert_after_last() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let a = doc.create_text("A");
+ let b = doc.create_text("B");
+
+ doc.append_child(root, a);
+ doc.insert_after(a, b);
+
+ assert_eq!(doc.last_child(root), Some(b));
+ assert_eq!(doc.next_sibling(a), Some(b));
+ assert_eq!(doc.prev_sibling(b), Some(a));
+ }
+
+ #[test]
+ fn test_replace_node() {
+ let mut doc = Document::new();
+ let root = doc.root();
+ let a = doc.create_text("A");
+ let b = doc.create_text("B");
+ let c = doc.create_text("C");
+ let new_b = doc.create_text("NEW_B");
+
+ doc.append_child(root, a);
+ doc.append_child(root, b);
+ doc.append_child(root, c);
+
+ doc.replace_node(b, new_b);
+
+ let children: Vec<NodeId> = doc.children(root).collect();
+ assert_eq!(children, vec![a, new_b, c]);
+ assert!(doc.parent(b).is_none()); // old node detached
+ }
+
+ #[test]
+ fn test_set_attribute() {
+ let mut doc = Document::new();
+ let elem = doc.create_element("div");
+ assert!(doc.set_attribute(elem, "class", "foo"));
+ assert_eq!(doc.attribute(elem, "class"), Some("foo"));
+
+ // Update existing
+ assert!(doc.set_attribute(elem, "class", "bar"));
+ assert_eq!(doc.attribute(elem, "class"), Some("bar"));
+ }
+
+ #[test]
+ fn test_set_attribute_on_non_element() {
+ let mut doc = Document::new();
+ let text = doc.create_text("hello");
+ assert!(!doc.set_attribute(text, "class", "foo"));
+ }
+
+ #[test]
+ fn test_remove_attribute() {
+ let mut doc = Document::new();
+ let elem = doc.create_element("div");
+ doc.set_attribute(elem, "class", "foo");
+ doc.set_attribute(elem, "id", "bar");
+
+ assert!(doc.remove_attribute(elem, "class"));
+ assert_eq!(doc.attribute(elem, "class"), None);
+ assert_eq!(doc.attribute(elem, "id"), Some("bar"));
+
+ // Removing non-existent returns false
+ assert!(!doc.remove_attribute(elem, "class"));
+ }
+
+ #[test]
+ fn test_remove_attribute_on_non_element() {
+ let mut doc = Document::new();
+ let text = doc.create_text("hello");
+ assert!(!doc.remove_attribute(text, "class"));
+ }
+
+ #[test]
+ fn test_rename_element() {
+ let mut doc = Document::new();
+ let elem = doc.create_element("div");
+ assert!(doc.rename_element(elem, "span"));
+ assert_eq!(doc.node_name(elem), Some("span"));
+ }
+
+ #[test]
+ fn test_rename_non_element() {
+ let mut doc = Document::new();
+ let text = doc.create_text("hello");
+ assert!(!doc.rename_element(text, "span"));
+ }
+}
diff --git a/browser/vendor/xmloxide/src/tree/node.rs b/browser/vendor/xmloxide/src/tree/node.rs
new file mode 100644
index 000000000..e6199d813
--- /dev/null
+++ b/browser/vendor/xmloxide/src/tree/node.rs
@@ -0,0 +1,77 @@
+//! Node type definitions.
+//!
+//! The `NodeKind` enum represents all node types in an XML document tree,
+//! corresponding to libxml2's `xmlElementType`. Each variant carries the
+//! node-type-specific payload (e.g., element name and attributes, text content).
+
+use super::Attribute;
+
+/// The kind of an XML node and its associated data.
+///
+/// This enum carries the payload for each node type. Navigation links
+/// (parent, children, siblings) are stored in `NodeData`, not here.
+#[derive(Debug, Clone)]
+pub enum NodeKind {
+ /// The document node — there is exactly one per `Document`.
+ Document,
+
+ /// An element node, e.g., `<div class="x">`.
+ Element {
+ /// The element's local name (or full `QName` before namespace resolution).
+ name: String,
+ /// Namespace prefix (e.g., `"svg"` in `svg:rect`), if any.
+ prefix: Option<String>,
+ /// Namespace URI after resolution, if any.
+ namespace: Option<String>,
+ /// Attributes on this element.
+ attributes: Vec<Attribute>,
+ },
+
+ /// A text node containing character data.
+ Text {
+ /// The text content (already decoded — character references resolved).
+ content: String,
+ },
+
+ /// A CDATA section, e.g., `<![CDATA[...]]]]><![CDATA[>`.
+ CData {
+ /// The CDATA content (no escaping applied).
+ content: String,
+ },
+
+ /// A comment node, e.g., `<!-- ... -->`.
+ Comment {
+ /// The comment text (without the `<!--` and `-->` delimiters).
+ content: String,
+ },
+
+ /// A processing instruction, e.g., `<?target data?>`.
+ ProcessingInstruction {
+ /// The PI target (e.g., `"xml-stylesheet"`).
+ target: String,
+ /// The PI data, if any.
+ data: Option<String>,
+ },
+
+ /// An entity reference node (e.g., `&` when not expanded).
+ EntityRef {
+ /// The entity name (without `&` and `;`).
+ name: String,
+ /// The expanded value of the entity (used for `text_content()`).
+ value: Option<String>,
+ },
+
+ /// A document type declaration node, e.g., `<!DOCTYPE html>`.
+ ///
+ /// See XML 1.0 §2.8: `[28]` doctypedecl
+ DocumentType {
+ /// The root element name declared in the DOCTYPE.
+ name: String,
+ /// The SYSTEM identifier (URI), if any.
+ system_id: Option<String>,
+ /// The PUBLIC identifier, if any.
+ public_id: Option<String>,
+ /// The serialized internal subset content (between `[` and `]`), if any.
+ internal_subset: Option<String>,
+ },
+}
diff --git a/browser/vendor/xmloxide/src/util/dict.rs b/browser/vendor/xmloxide/src/util/dict.rs
new file mode 100644
index 000000000..eb1ca9c74
--- /dev/null
+++ b/browser/vendor/xmloxide/src/util/dict.rs
@@ -0,0 +1,175 @@
+//! String interning dictionary.
+//!
+//! The `Dict` provides string interning so that element names, attribute names,
+//! namespace URIs, and other frequently repeated strings are stored once and
+//! compared by index rather than by value. This is critical for parser
+//! performance — hot-path string comparisons use `SymbolId` equality (a single
+//! `u32` compare) instead of full string comparison.
+//!
+//! See libxml2's `dict.c` for the reference implementation.
+
+use std::collections::HashMap;
+use std::num::NonZeroU32;
+
+/// An interned string identifier.
+///
+/// Two `SymbolId` values are equal if and only if they refer to the same
+/// interned string within the same `Dict`. Comparing `SymbolId` is O(1).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct SymbolId(NonZeroU32);
+
+impl SymbolId {
+ /// Returns the raw index value.
+ #[must_use]
+ pub fn as_u32(self) -> u32 {
+ self.0.get()
+ }
+}
+
+/// A string interning dictionary.
+///
+/// Stores unique strings and returns `SymbolId` handles for O(1) equality
+/// comparisons. The dictionary owns all interned strings.
+///
+/// # Examples
+///
+/// ```ignore
+/// use xmloxide::util::dict::Dict;
+///
+/// let mut dict = Dict::new();
+/// let a = dict.intern("hello");
+/// let b = dict.intern("hello");
+/// let c = dict.intern("world");
+///
+/// assert_eq!(a, b);
+/// assert_ne!(a, c);
+/// assert_eq!(dict.resolve(a), "hello");
+/// ```
+#[derive(Debug)]
+pub struct Dict {
+ /// Map from string to its symbol id for O(1) lookup-or-insert.
+ map: HashMap<String, SymbolId>,
+ /// Indexed storage: symbol id → string. Index 0 is unused (`NonZeroU32`).
+ strings: Vec<String>,
+}
+
+impl Dict {
+ /// Creates a new empty dictionary.
+ #[must_use]
+ pub fn new() -> Self {
+ Self {
+ map: HashMap::new(),
+ // Index 0 is a placeholder since SymbolId uses NonZeroU32.
+ strings: vec![String::new()],
+ }
+ }
+
+ /// Interns a string and returns its `SymbolId`.
+ ///
+ /// If the string has been interned before, the existing `SymbolId` is
+ /// returned. Otherwise, the string is stored and a new `SymbolId` is
+ /// created.
+ #[allow(clippy::cast_possible_truncation, clippy::expect_used)]
+ pub fn intern(&mut self, s: &str) -> SymbolId {
+ if let Some(&id) = self.map.get(s) {
+ return id;
+ }
+ // strings.len() starts at 1 and only grows, so index >= 1 and
+ // NonZeroU32::new will never return None. Truncation is acceptable
+ // because we will never intern more than u32::MAX strings.
+ let index = self.strings.len() as u32;
+ let id = SymbolId(NonZeroU32::new(index).expect("symbol index overflow"));
+ self.strings.push(s.to_owned());
+ self.map.insert(s.to_owned(), id);
+ id
+ }
+
+ /// Resolves a `SymbolId` back to its string.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the `SymbolId` was not created by this dictionary.
+ #[must_use]
+ pub fn resolve(&self, id: SymbolId) -> &str {
+ &self.strings[id.0.get() as usize]
+ }
+
+ /// Returns the number of interned strings.
+ #[must_use]
+ pub fn len(&self) -> usize {
+ self.strings.len() - 1 // subtract the placeholder
+ }
+
+ /// Returns `true` if the dictionary contains no interned strings.
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+}
+
+impl Default for Dict {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_intern_returns_same_id_for_same_string() {
+ let mut dict = Dict::new();
+ let a = dict.intern("hello");
+ let b = dict.intern("hello");
+ assert_eq!(a, b);
+ }
+
+ #[test]
+ fn test_intern_returns_different_ids_for_different_strings() {
+ let mut dict = Dict::new();
+ let a = dict.intern("hello");
+ let b = dict.intern("world");
+ assert_ne!(a, b);
+ }
+
+ #[test]
+ fn test_resolve_returns_original_string() {
+ let mut dict = Dict::new();
+ let id = dict.intern("test string");
+ assert_eq!(dict.resolve(id), "test string");
+ }
+
+ #[test]
+ fn test_len_and_is_empty() {
+ let mut dict = Dict::new();
+ assert!(dict.is_empty());
+ assert_eq!(dict.len(), 0);
+
+ dict.intern("a");
+ assert!(!dict.is_empty());
+ assert_eq!(dict.len(), 1);
+
+ dict.intern("b");
+ assert_eq!(dict.len(), 2);
+
+ // Interning duplicate doesn't increase length
+ dict.intern("a");
+ assert_eq!(dict.len(), 2);
+ }
+
+ #[test]
+ fn test_empty_string_interning() {
+ let mut dict = Dict::new();
+ let id = dict.intern("");
+ assert_eq!(dict.resolve(id), "");
+ }
+
+ #[test]
+ fn test_symbol_id_as_u32() {
+ let mut dict = Dict::new();
+ let id = dict.intern("first");
+ assert_eq!(id.as_u32(), 1); // First real entry is index 1
+ }
+}
diff --git a/browser/vendor/xmloxide/src/util/mod.rs b/browser/vendor/xmloxide/src/util/mod.rs
new file mode 100644
index 000000000..902e76ccd
--- /dev/null
+++ b/browser/vendor/xmloxide/src/util/mod.rs
@@ -0,0 +1,7 @@
+//! Utility modules for xmloxide.
+//!
+//! Contains the string interning dictionary, `QName` handling, URI parsing,
+//! and growable byte buffer.
+
+pub mod dict;
+pub mod qname;
diff --git a/browser/vendor/xmloxide/src/util/qname.rs b/browser/vendor/xmloxide/src/util/qname.rs
new file mode 100644
index 000000000..fd65a7a59
--- /dev/null
+++ b/browser/vendor/xmloxide/src/util/qname.rs
@@ -0,0 +1,64 @@
+//! `QName` (qualified name) handling.
+//!
+//! A `QName` is a name of the form `prefix:localname` or just `localname` (with
+//! no prefix). This module provides utilities for splitting and working with
+//! qualified names as defined by the Namespaces in XML 1.0 specification.
+//!
+//! See <https://www.w3.org/TR/xml-names/#NT-QName>
+
+/// Splits a `QName` into its prefix and local name parts.
+///
+/// Returns `(Some(prefix), localname)` if the name contains a colon,
+/// or `(None, localname)` if it does not.
+///
+/// # Examples
+///
+/// ```ignore
+/// use xmloxide::util::qname::split_qname;
+///
+/// assert_eq!(split_qname("svg:rect"), (Some("svg"), "rect"));
+/// assert_eq!(split_qname("div"), (None, "div"));
+/// ```
+#[must_use]
+pub fn split_qname(qname: &str) -> (Option<&str>, &str) {
+ match qname.find(':') {
+ Some(pos) => (Some(&qname[..pos]), &qname[pos + 1..]),
+ None => (None, qname),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_split_qname_with_prefix() {
+ assert_eq!(split_qname("xml:lang"), (Some("xml"), "lang"));
+ }
+
+ #[test]
+ fn test_split_qname_without_prefix() {
+ assert_eq!(split_qname("div"), (None, "div"));
+ }
+
+ #[test]
+ fn test_split_qname_empty() {
+ assert_eq!(split_qname(""), (None, ""));
+ }
+
+ #[test]
+ fn test_split_qname_colon_at_start() {
+ assert_eq!(split_qname(":local"), (Some(""), "local"));
+ }
+
+ #[test]
+ fn test_split_qname_colon_at_end() {
+ assert_eq!(split_qname("prefix:"), (Some("prefix"), ""));
+ }
+
+ #[test]
+ fn test_split_qname_multiple_colons() {
+ // Only splits on first colon
+ assert_eq!(split_qname("a:b:c"), (Some("a"), "b:c"));
+ }
+}
diff --git a/browser/vendor/xmloxide/src/validation/dtd.rs b/browser/vendor/xmloxide/src/validation/dtd.rs
new file mode 100644
index 000000000..da5d17d34
--- /dev/null
+++ b/browser/vendor/xmloxide/src/validation/dtd.rs
@@ -0,0 +1,3891 @@
+//! DTD (Document Type Definition) data model, parser, and validator.
+//!
+//! This module implements DTD processing as defined in XML 1.0 (Fifth Edition)
+//! sections 2.8, 3.2, 3.3, 3.4, and 4.2. It provides:
+//!
+//! - A data model for DTD declarations (elements, attributes, entities, notations)
+//! - A parser that processes DTD internal subset content
+//! - A validator that checks document conformance against a parsed DTD
+//!
+//! # Content Model Matching
+//!
+//! The validator implements deterministic content model matching for:
+//! - `EMPTY`: element must have no element or text children
+//! - `ANY`: any content is allowed
+//! - Mixed content `(#PCDATA|a|b)*`: text and listed elements in any order
+//! - Element content with sequences `(a,b,c)`, choices `(a|b|c)`, and
+//! occurrence indicators `?`, `*`, `+`
+//!
+//! See XML 1.0 section 3.2 for the full content model specification.
+
+use std::collections::{HashMap, HashSet};
+use std::fmt;
+
+use crate::error::{ParseError, SourceLocation};
+use crate::tree::{Document, NodeId, NodeKind};
+
+use super::{ValidationError, ValidationResult};
+
+// ---------------------------------------------------------------------------
+// DTD Data Model
+// ---------------------------------------------------------------------------
+
+/// A parsed DTD containing all declarations from the internal subset.
+///
+/// This is the result of [`parse_dtd`] and serves as input to [`validate`].
+#[derive(Debug, Clone, Default)]
+pub struct Dtd {
+ /// Element declarations, keyed by element name.
+ pub elements: HashMap<String, ElementDecl>,
+ /// Attribute declarations, keyed by `(element_name, attribute_name)`.
+ pub attributes: HashMap<String, Vec<AttributeDecl>>,
+ /// General entity declarations, keyed by entity name.
+ pub entities: HashMap<String, EntityDecl>,
+ /// Parameter entity declarations, keyed by entity name.
+ pub param_entities: HashMap<String, EntityDecl>,
+ /// Notation declarations, keyed by notation name.
+ pub notations: HashMap<String, NotationDecl>,
+ /// Ordered list of all declarations (preserving source order and comments).
+ pub declarations: Vec<DtdDeclaration>,
+}
+
+/// A single DTD declaration, preserving source order for re-serialization.
+#[derive(Debug, Clone)]
+pub enum DtdDeclaration {
+ /// An element declaration.
+ Element(ElementDecl),
+ /// A single attribute declaration (one per attribute, even if the source
+ /// used a multi-attribute ATTLIST).
+ Attlist(AttributeDecl),
+ /// A general entity declaration.
+ Entity(EntityDecl),
+ /// A notation declaration.
+ Notation(NotationDecl),
+ /// A comment.
+ Comment(String),
+ /// A processing instruction.
+ Pi(String, Option<String>),
+}
+
+/// An element declaration from `<!ELEMENT name content-model>`.
+///
+/// See XML 1.0 section 3.2.
+#[derive(Debug, Clone)]
+pub struct ElementDecl {
+ /// The element name.
+ pub name: String,
+ /// The declared content model.
+ pub content_model: ContentModel,
+}
+
+/// The content model for an element declaration.
+///
+/// See XML 1.0 section 3.2 for the grammar:
+/// - `contentspec ::= 'EMPTY' | 'ANY' | Mixed | children`
+#[derive(Debug, Clone, PartialEq)]
+pub enum ContentModel {
+ /// The element must have no children (no elements, no text).
+ /// Declared as `<!ELEMENT name EMPTY>`.
+ Empty,
+ /// Any content is allowed.
+ /// Declared as `<!ELEMENT name ANY>`.
+ Any,
+ /// Mixed content: text and optionally listed elements in any order.
+ /// Declared as `<!ELEMENT name (#PCDATA)>` or `<!ELEMENT name (#PCDATA|a|b)*>`.
+ ///
+ /// The `Vec<String>` contains the allowed element names (empty for `#PCDATA` only).
+ Mixed(Vec<String>),
+ /// Element-only content following a content spec pattern.
+ /// Declared as `<!ELEMENT name (a,b,c)>` etc.
+ Children(ContentSpec),
+}
+
+/// A content specification for element-only content models.
+///
+/// Represents the recursive structure of `(a,b)`, `(a|b)`, etc.
+/// with occurrence indicators.
+///
+/// See XML 1.0 section 3.2.1 and 3.2.2.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ContentSpec {
+ /// The content particle kind.
+ pub kind: ContentSpecKind,
+ /// How many times this particle may occur.
+ pub occurrence: Occurrence,
+}
+
+/// The kind of a content specification particle.
+#[derive(Debug, Clone, PartialEq)]
+pub enum ContentSpecKind {
+ /// A single named element, e.g., `a`.
+ Name(String),
+ /// A sequence of particles, e.g., `(a, b, c)`.
+ Seq(Vec<ContentSpec>),
+ /// A choice among particles, e.g., `(a | b | c)`.
+ Choice(Vec<ContentSpec>),
+}
+
+/// Occurrence indicator for a content particle.
+///
+/// See XML 1.0 section 3.2.1: `'?' | '*' | '+'`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Occurrence {
+ /// Exactly once (no indicator).
+ Once,
+ /// Zero or one time (`?`).
+ Optional,
+ /// Zero or more times (`*`).
+ ZeroOrMore,
+ /// One or more times (`+`).
+ OneOrMore,
+}
+
+/// An attribute declaration from `<!ATTLIST element-name attr-name type default>`.
+///
+/// See XML 1.0 section 3.3.
+#[derive(Debug, Clone)]
+pub struct AttributeDecl {
+ /// The element this attribute belongs to.
+ pub element_name: String,
+ /// The attribute name.
+ pub attribute_name: String,
+ /// The attribute type.
+ pub attribute_type: AttributeType,
+ /// The default value specification.
+ pub default: AttributeDefault,
+}
+
+/// The type of an attribute as declared in `<!ATTLIST>`.
+///
+/// See XML 1.0 section 3.3.1.
+#[derive(Debug, Clone, PartialEq)]
+pub enum AttributeType {
+ /// Character data (`CDATA`).
+ CData,
+ /// A unique identifier (`ID`).
+ Id,
+ /// A reference to an ID (`IDREF`).
+ IdRef,
+ /// Space-separated list of ID references (`IDREFS`).
+ IdRefs,
+ /// An entity name (`ENTITY`).
+ Entity,
+ /// Space-separated list of entity names (`ENTITIES`).
+ Entities,
+ /// A name token (`NMTOKEN`).
+ NmToken,
+ /// Space-separated list of name tokens (`NMTOKENS`).
+ NmTokens,
+ /// A notation type with allowed notation names (`NOTATION (a|b|c)`).
+ Notation(Vec<String>),
+ /// An enumeration of allowed values (`(a|b|c)`).
+ Enumeration(Vec<String>),
+}
+
+/// The default value specification for an attribute.
+///
+/// See XML 1.0 section 3.3.2.
+#[derive(Debug, Clone, PartialEq)]
+pub enum AttributeDefault {
+ /// The attribute is required (`#REQUIRED`).
+ Required,
+ /// The attribute is optional with no default (`#IMPLIED`).
+ Implied,
+ /// The attribute has a fixed value (`#FIXED "value"`).
+ Fixed(String),
+ /// The attribute has a default value (`"value"`).
+ Default(String),
+}
+
+/// A general entity declaration.
+///
+/// See XML 1.0 section 4.2.
+#[derive(Debug, Clone)]
+pub struct EntityDecl {
+ /// The entity name.
+ pub name: String,
+ /// The entity's value, either internal or external.
+ pub kind: EntityKind,
+}
+
+/// Whether an entity is internal (has a literal value) or external
+/// (references an external resource).
+#[derive(Debug, Clone)]
+pub enum EntityKind {
+ /// Internal entity with a literal replacement text.
+ Internal(String),
+ /// External entity identified by a system URI and optional public ID.
+ External {
+ /// The SYSTEM identifier (URI).
+ system_id: String,
+ /// The PUBLIC identifier, if any.
+ public_id: Option<String>,
+ },
+}
+
+/// A notation declaration from `<!NOTATION name ...>`.
+///
+/// See XML 1.0 section 4.7.
+#[derive(Debug, Clone)]
+pub struct NotationDecl {
+ /// The notation name.
+ pub name: String,
+ /// The SYSTEM identifier, if any.
+ pub system_id: Option<String>,
+ /// The PUBLIC identifier, if any.
+ pub public_id: Option<String>,
+}
+
+impl fmt::Display for ContentModel {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Empty => write!(f, "EMPTY"),
+ Self::Any => write!(f, "ANY"),
+ Self::Mixed(names) => {
+ if names.is_empty() {
+ write!(f, "(#PCDATA)")
+ } else {
+ write!(f, "(#PCDATA|{})*", names.join("|"))
+ }
+ }
+ Self::Children(spec) => write!(f, "{spec}"),
+ }
+ }
+}
+
+impl fmt::Display for ContentSpec {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match &self.kind {
+ ContentSpecKind::Name(name) => write!(f, "{name}")?,
+ ContentSpecKind::Seq(items) => {
+ write!(f, "(")?;
+ for (i, item) in items.iter().enumerate() {
+ if i > 0 {
+ write!(f, " , ")?;
+ }
+ write!(f, "{item}")?;
+ }
+ write!(f, ")")?;
+ }
+ ContentSpecKind::Choice(items) => {
+ write!(f, "(")?;
+ for (i, item) in items.iter().enumerate() {
+ if i > 0 {
+ write!(f, " | ")?;
+ }
+ write!(f, "{item}")?;
+ }
+ write!(f, ")")?;
+ }
+ }
+ match self.occurrence {
+ Occurrence::Once => {}
+ Occurrence::Optional => write!(f, "?")?,
+ Occurrence::ZeroOrMore => write!(f, "*")?,
+ Occurrence::OneOrMore => write!(f, "+")?,
+ }
+ Ok(())
+ }
+}
+
+// ---------------------------------------------------------------------------
+// DTD Serializer
+// ---------------------------------------------------------------------------
+
+/// Serializes a parsed DTD's declarations into the internal subset format
+/// used by libxml2.
+///
+/// Each declaration appears on its own line. The output does NOT include
+/// the surrounding `[` and `]>` — the caller adds those.
+#[must_use]
+#[allow(clippy::too_many_lines)]
+pub fn serialize_dtd(dtd: &Dtd) -> String {
+ let mut out = String::new();
+ let mut last_was_comment = false;
+
+ for decl in &dtd.declarations {
+ // Don't add a newline before declarations that immediately follow
+ // a comment — the comment text already contains any needed whitespace.
+ // libxml2 concatenates the comment closing `-->` and the next
+ // declaration on the same line.
+ if !last_was_comment {
+ out.push('\n');
+ }
+ match decl {
+ DtdDeclaration::Element(e) => {
+ out.push_str("<!ELEMENT ");
+ out.push_str(&e.name);
+ out.push(' ');
+ write_content_model(&mut out, &e.content_model);
+ out.push('>');
+ last_was_comment = false;
+ }
+ DtdDeclaration::Attlist(a) => {
+ out.push_str("<!ATTLIST ");
+ out.push_str(&a.element_name);
+ out.push(' ');
+ out.push_str(&a.attribute_name);
+ out.push(' ');
+ write_attribute_type(&mut out, &a.attribute_type);
+ out.push(' ');
+ write_attribute_default(&mut out, &a.default);
+ out.push('>');
+ last_was_comment = false;
+ }
+ DtdDeclaration::Entity(e) => {
+ out.push_str("<!ENTITY ");
+ out.push_str(&e.name);
+ match &e.kind {
+ EntityKind::Internal(value) => {
+ out.push(' ');
+ write_entity_value(&mut out, value);
+ }
+ EntityKind::External {
+ system_id,
+ public_id,
+ } => {
+ if let Some(pub_id) = public_id {
+ out.push_str(" PUBLIC \"");
+ out.push_str(pub_id);
+ out.push_str("\" \"");
+ out.push_str(system_id);
+ out.push('"');
+ } else {
+ out.push_str(" SYSTEM \"");
+ out.push_str(system_id);
+ out.push('"');
+ }
+ }
+ }
+ out.push('>');
+ last_was_comment = false;
+ }
+ DtdDeclaration::Notation(n) => {
+ out.push_str("<!NOTATION ");
+ out.push_str(&n.name);
+ match (&n.public_id, &n.system_id) {
+ (Some(pub_id), Some(sys_id)) => {
+ out.push_str(" PUBLIC \"");
+ out.push_str(pub_id);
+ out.push_str("\" \"");
+ out.push_str(sys_id);
+ out.push('"');
+ }
+ (Some(pub_id), None) => {
+ out.push_str(" PUBLIC \"");
+ out.push_str(pub_id);
+ out.push('"');
+ }
+ (None, Some(sys_id)) => {
+ out.push_str(" SYSTEM \"");
+ out.push_str(sys_id);
+ out.push('"');
+ }
+ (None, None) => {}
+ }
+ out.push('>');
+ last_was_comment = false;
+ }
+ DtdDeclaration::Comment(text) => {
+ out.push_str("<!--");
+ out.push_str(text);
+ out.push_str("-->");
+ last_was_comment = true;
+ }
+ DtdDeclaration::Pi(target, data) => {
+ out.push_str("<?");
+ out.push_str(target);
+ if let Some(d) = data {
+ out.push(' ');
+ out.push_str(d);
+ }
+ out.push_str("?>");
+ last_was_comment = false;
+ }
+ }
+ }
+
+ // libxml2 adds a newline before ]> unless the last item was a comment.
+ if !last_was_comment && !dtd.declarations.is_empty() {
+ out.push('\n');
+ }
+
+ out
+}
+
+/// Writes a content model in libxml2's format.
+fn write_content_model(out: &mut String, model: &ContentModel) {
+ match model {
+ ContentModel::Empty => out.push_str("EMPTY"),
+ ContentModel::Any => out.push_str("ANY"),
+ ContentModel::Mixed(names) => {
+ if names.is_empty() {
+ out.push_str("(#PCDATA)");
+ } else {
+ out.push_str("(#PCDATA");
+ for name in names {
+ out.push_str(" | ");
+ out.push_str(name);
+ }
+ out.push_str(")*");
+ }
+ }
+ ContentModel::Children(spec) => {
+ use std::fmt::Write;
+ let _ = write!(out, "{spec}");
+ }
+ }
+}
+
+/// Writes an attribute type in libxml2's format.
+fn write_attribute_type(out: &mut String, attr_type: &AttributeType) {
+ match attr_type {
+ AttributeType::CData => out.push_str("CDATA"),
+ AttributeType::Id => out.push_str("ID"),
+ AttributeType::IdRef => out.push_str("IDREF"),
+ AttributeType::IdRefs => out.push_str("IDREFS"),
+ AttributeType::Entity => out.push_str("ENTITY"),
+ AttributeType::Entities => out.push_str("ENTITIES"),
+ AttributeType::NmToken => out.push_str("NMTOKEN"),
+ AttributeType::NmTokens => out.push_str("NMTOKENS"),
+ AttributeType::Notation(values) | AttributeType::Enumeration(values) => {
+ if matches!(attr_type, AttributeType::Notation(_)) {
+ out.push_str("NOTATION ");
+ }
+ out.push('(');
+ for (i, v) in values.iter().enumerate() {
+ if i > 0 {
+ out.push_str(" | ");
+ }
+ out.push_str(v);
+ }
+ out.push(')');
+ }
+ }
+}
+
+/// Writes an attribute default in libxml2's format.
+fn write_attribute_default(out: &mut String, default: &AttributeDefault) {
+ match default {
+ AttributeDefault::Required => out.push_str("#REQUIRED"),
+ AttributeDefault::Implied => out.push_str("#IMPLIED"),
+ AttributeDefault::Fixed(value) => {
+ out.push_str("#FIXED \"");
+ out.push_str(value);
+ out.push('"');
+ }
+ AttributeDefault::Default(value) => {
+ out.push('"');
+ out.push_str(value);
+ out.push('"');
+ }
+ }
+}
+
+/// Escapes an entity value for DTD serialization.
+///
+/// Entity references (`&name;`) and character references (`&#...;`) within
+/// the value are preserved as-is (matching libxml2 behavior). Only standalone
+/// `&` characters are escaped. The quote character is chosen to minimize
+/// escaping: single quotes when the value contains double quotes.
+fn write_entity_value(out: &mut String, value: &str) {
+ // Choose quote character: use single quotes if value contains double quotes
+ // but not single quotes (avoids escaping). Otherwise use double quotes.
+ let quote = if value.contains('"') && !value.contains('\'') {
+ '\''
+ } else {
+ '"'
+ };
+ out.push(quote);
+
+ let bytes = value.as_bytes();
+ let len = bytes.len();
+ let mut i = 0;
+
+ while i < len {
+ if bytes[i] == b'&' {
+ // Check if this is a valid entity or character reference — if so, pass through.
+ if let Some(ref_end) = find_reference_end(bytes, i) {
+ // Copy the reference as-is
+ let ref_str = std::str::from_utf8(&bytes[i..=ref_end]).unwrap_or("&");
+ out.push_str(ref_str);
+ i = ref_end + 1;
+ } else {
+ out.push_str("&");
+ i += 1;
+ }
+ } else if bytes[i] == b'%' {
+ out.push_str("%");
+ i += 1;
+ } else if bytes[i] == quote as u8 {
+ if quote == '"' {
+ out.push_str(""");
+ } else {
+ out.push_str("'");
+ }
+ i += 1;
+ } else {
+ // Push the char (may be multi-byte UTF-8)
+ let ch = &value[i..];
+ if let Some(c) = ch.chars().next() {
+ out.push(c);
+ i += c.len_utf8();
+ } else {
+ i += 1;
+ }
+ }
+ }
+
+ out.push(quote);
+}
+
+/// Finds the end position (inclusive, the `;`) of an entity or character
+/// reference starting at `start` in `bytes`. Returns `None` if the `&` at
+/// `start` is not the beginning of a valid reference.
+fn find_reference_end(bytes: &[u8], start: usize) -> Option<usize> {
+ if start >= bytes.len() || bytes[start] != b'&' {
+ return None;
+ }
+ let mut i = start + 1;
+ if i >= bytes.len() {
+ return None;
+ }
+
+ if bytes[i] == b'#' {
+ // Character reference: &#digits; or &#xhexdigits;
+ i += 1;
+ if i >= bytes.len() {
+ return None;
+ }
+ if bytes[i] == b'x' {
+ i += 1;
+ let digit_start = i;
+ while i < bytes.len() && bytes[i].is_ascii_hexdigit() {
+ i += 1;
+ }
+ if i == digit_start || i >= bytes.len() || bytes[i] != b';' {
+ return None;
+ }
+ } else {
+ let digit_start = i;
+ while i < bytes.len() && bytes[i].is_ascii_digit() {
+ i += 1;
+ }
+ if i == digit_start || i >= bytes.len() || bytes[i] != b';' {
+ return None;
+ }
+ }
+ Some(i)
+ } else {
+ // Named entity reference: &name;
+ // Name must start with a name start char (letter or _)
+ if !is_name_start_byte(bytes[i]) {
+ return None;
+ }
+ i += 1;
+ while i < bytes.len() && is_name_byte(bytes[i]) {
+ i += 1;
+ }
+ if i >= bytes.len() || bytes[i] != b';' {
+ return None;
+ }
+ Some(i)
+ }
+}
+
+/// Checks if a byte is valid as the start of an XML name.
+fn is_name_start_byte(b: u8) -> bool {
+ b.is_ascii_alphabetic() || b == b'_' || b == b':'
+}
+
+/// Checks if a byte is valid within an XML name.
+fn is_name_byte(b: u8) -> bool {
+ b.is_ascii_alphanumeric() || b == b'_' || b == b':' || b == b'-' || b == b'.'
+}
+
+// ---------------------------------------------------------------------------
+// DTD Parser
+// ---------------------------------------------------------------------------
+
+/// Parses a DTD internal subset string into a [`Dtd`] data structure.
+///
+/// The input should be the content from inside `<!DOCTYPE root [ ... ]>`,
+/// i.e., just the internal subset without the surrounding brackets.
+///
+/// # Errors
+///
+/// Returns a `ParseError` if the DTD content is malformed.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::validation::dtd::parse_dtd;
+///
+/// let dtd = parse_dtd("<!ELEMENT root (#PCDATA)>").unwrap();
+/// assert!(dtd.elements.contains_key("root"));
+/// ```
+pub fn parse_dtd(input: &str) -> Result<Dtd, ParseError> {
+ let mut parser = DtdParser::new(input);
+ parser.parse()
+}
+
+/// Maximum nesting depth for `<!ELEMENT>` content-model groups.
+///
+/// Bounds the mutual recursion between [`DtdParser::parse_content_spec_group`]
+/// and [`DtdParser::parse_content_particle`] so that a deeply-nested
+/// parenthesised content model cannot exhaust the stack (CWE-674). Matches
+/// the spirit of the parser's `DEFAULT_MAX_DEPTH`, which bounds element
+/// nesting but does not reach the DTD content-model grammar.
+const MAX_CONTENT_MODEL_DEPTH: u32 = 256;
+
+/// Internal DTD parser state.
+struct DtdParser<'a> {
+ input: &'a [u8],
+ pos: usize,
+ line: u32,
+ column: u32,
+ dtd: Dtd,
+}
+
+impl<'a> DtdParser<'a> {
+ fn new(input: &'a str) -> Self {
+ Self {
+ input: input.as_bytes(),
+ pos: 0,
+ line: 1,
+ column: 1,
+ dtd: Dtd::default(),
+ }
+ }
+
+ fn parse(&mut self) -> Result<Dtd, ParseError> {
+ loop {
+ self.skip_whitespace();
+ if self.at_end() {
+ break;
+ }
+
+ if self.looking_at(b"<!--") {
+ self.parse_comment_decl()?;
+ } else if self.looking_at(b"<!ELEMENT") {
+ self.parse_element_decl()?;
+ } else if self.looking_at(b"<!ATTLIST") {
+ self.parse_attlist_decl()?;
+ } else if self.looking_at(b"<!ENTITY") {
+ self.parse_entity_decl()?;
+ } else if self.looking_at(b"<!NOTATION") {
+ self.parse_notation_decl()?;
+ } else if self.looking_at(b"<?") {
+ self.parse_pi_decl()?;
+ } else if self.peek() == Some(b'%') {
+ // Parameter entity reference — skip it since we don't expand
+ self.skip_pe_reference()?;
+ } else {
+ return Err(self.fatal(format!(
+ "unexpected character '{}' in DTD",
+ self.peek().map_or('?', |b| b as char)
+ )));
+ }
+ }
+
+ self.post_validate()?;
+
+ Ok(std::mem::take(&mut self.dtd))
+ }
+
+ /// Post-parse validation checks that require the complete entity map.
+ ///
+ /// Detects entity recursion (WFC: No Recursion), validates that entity
+ /// references in attribute defaults refer to internal parsed entities,
+ /// and checks for `<` in entity replacement text used in attributes.
+ fn post_validate(&self) -> Result<(), ParseError> {
+ // Check for entity recursion (WFC: No Recursion, XML 1.0 §4.1).
+ // `safe` memoizes entities already proven acyclic so the walk is
+ // linear in the total size of the entity declarations rather than
+ // exponential in chain depth.
+ let mut safe = std::collections::HashSet::new();
+ for (name, decl) in &self.dtd.entities {
+ if let EntityKind::Internal(ref value) = decl.kind {
+ if safe.contains(name.as_str()) {
+ continue;
+ }
+ let mut visited = std::collections::HashSet::new();
+ visited.insert(name.clone());
+ self.check_entity_recursion(value, &mut visited, &mut safe)?;
+ safe.insert(name.clone());
+ }
+ }
+
+ // Check for parameter entity recursion (WFC: No Recursion, XML 1.0 §4.1).
+ // PE values may contain encoded PE references via % (which is '%').
+ // After char ref expansion, if %name; appears in its own value, that's
+ // direct or indirect recursion.
+ let mut safe = std::collections::HashSet::new();
+ for (name, decl) in &self.dtd.param_entities {
+ if let EntityKind::Internal(ref value) = decl.kind {
+ if safe.contains(name.as_str()) {
+ continue;
+ }
+ let expanded = expand_char_refs_only(value);
+ let mut visited = std::collections::HashSet::new();
+ visited.insert(name.clone());
+ self.check_pe_recursion(&expanded, &mut visited, &mut safe)?;
+ safe.insert(name.clone());
+ }
+ }
+
+ // Validate entity replacement text after character reference
+ // expansion (XML 1.0 §4.5). Character references in entity
+ // values are expanded at declaration time. The resulting
+ // replacement text must be well-formed when re-parsed.
+ for (name, decl) in &self.dtd.entities {
+ if let EntityKind::Internal(ref value) = decl.kind {
+ self.validate_replacement_text(name, value)?;
+ }
+ }
+
+ // Validate predefined entity redeclarations (XML 1.0 §4.6).
+ // If lt, gt, amp, apos, or quot are declared, their replacement
+ // text must be a character reference to the respective character.
+ self.validate_predefined_entities()?;
+
+ // Note: content production validation (XML 1.0 §4.3.2) is
+ // performed at entity expansion time in the XML parser, not
+ // here, because it only applies to entities that are actually
+ // referenced in the document.
+
+ // Validate entity references in ATTLIST defaults. `checked`
+ // memoizes entities already validated so shared references are
+ // walked once (the reference graph is acyclic at this point).
+ let mut checked = std::collections::HashSet::new();
+ for attrs in self.dtd.attributes.values() {
+ for attr in attrs {
+ let (AttributeDefault::Default(default_value)
+ | AttributeDefault::Fixed(default_value)) = &attr.default
+ else {
+ continue;
+ };
+ self.validate_attr_default_entities(default_value, &mut checked)?;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Validates that predefined entity redeclarations (lt, gt, amp, apos,
+ /// quot) use the correct character reference as replacement text.
+ ///
+ /// Per XML 1.0 §4.6: "If the entities lt or amp are declared, they MUST
+ /// be declared as internal entities whose replacement text is a character
+ /// reference to the respective character."
+ fn validate_predefined_entities(&self) -> Result<(), ParseError> {
+ // Per XML 1.0 §4.6: lt and amp MUST use character references.
+ // gt, apos, and quot may use either the literal character or a
+ // character reference.
+ let expected: &[(&str, &str, &[&str])] = &[
+ ("lt", "<", &["<", "<", "<"]),
+ ("gt", ">", &[">", ">", ">", ">"]),
+ ("amp", "&", &["&", "&"]),
+ ("apos", "'", &["'", "'", "'"]),
+ ("quot", "\"", &["\"", """, """]),
+ ];
+ for &(name, _char_val, valid_refs) in expected {
+ if let Some(decl) = self.dtd.entities.get(name) {
+ match &decl.kind {
+ EntityKind::Internal(value) => {
+ // Check if the value is a valid character reference
+ // for this predefined entity.
+ if !valid_refs.iter().any(|r| r == value) {
+ return Err(self.fatal(format!(
+ "predefined entity '{name}' must be declared as \
+ a character reference (e.g., '{}')",
+ valid_refs[0]
+ )));
+ }
+ }
+ EntityKind::External { .. } => {
+ return Err(self.fatal(format!(
+ "predefined entity '{name}' must be an internal entity"
+ )));
+ }
+ }
+ }
+ }
+ Ok(())
+ }
+
+ /// Validates entity replacement text after character reference
+ /// expansion per XML 1.0 §4.5.
+ ///
+ /// Expands only character references in the entity value (not entity
+ /// references), then checks the resulting replacement text for basic
+ /// well-formedness: bare `&` characters from `&` expansion that
+ /// don't form valid references are rejected.
+ fn validate_replacement_text(&self, entity_name: &str, value: &str) -> Result<(), ParseError> {
+ // Only check values that contain character references
+ if !value.contains("&#") {
+ return Ok(());
+ }
+
+ // Build replacement text by expanding only character references
+ let replacement = Self::expand_char_refs_only(value);
+
+ // Check for bare '&' in the replacement text that don't form
+ // valid entity or character references
+ let bytes = replacement.as_bytes();
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'&' {
+ i += 1;
+ if i >= bytes.len() {
+ return Err(self.fatal(format!(
+ "entity '{entity_name}' replacement text contains \
+ bare '&' at end of text"
+ )));
+ }
+ if bytes[i] == b'#' {
+ // Character reference — check it's complete
+ i += 1;
+ let has_digits = if i < bytes.len() && bytes[i] == b'x' {
+ i += 1;
+ let start = i;
+ while i < bytes.len() && bytes[i].is_ascii_hexdigit() {
+ i += 1;
+ }
+ i > start
+ } else {
+ let start = i;
+ while i < bytes.len() && bytes[i].is_ascii_digit() {
+ i += 1;
+ }
+ i > start
+ };
+ if !has_digits || i >= bytes.len() || bytes[i] != b';' {
+ return Err(self.fatal(format!(
+ "entity '{entity_name}' replacement text contains \
+ incomplete character reference"
+ )));
+ }
+ i += 1;
+ } else if bytes[i].is_ascii_alphabetic() || bytes[i] == b'_' || bytes[i] == b':' {
+ // Entity reference — skip name
+ while i < bytes.len() && bytes[i] != b';' {
+ i += 1;
+ }
+ if i >= bytes.len() {
+ return Err(self.fatal(format!(
+ "entity '{entity_name}' replacement text contains \
+ incomplete entity reference"
+ )));
+ }
+ i += 1;
+ } else {
+ return Err(self.fatal(format!(
+ "entity '{entity_name}' replacement text contains \
+ bare '&' not followed by a valid reference"
+ )));
+ }
+ } else {
+ i += 1;
+ }
+ }
+ Ok(())
+ }
+
+ /// Expands only character references in a string, leaving entity
+ /// references as-is. Returns the expanded text.
+ fn expand_char_refs_only(value: &str) -> String {
+ expand_char_refs_only(value)
+ }
+
+ /// Recursively checks for entity reference cycles.
+ fn check_entity_recursion(
+ &self,
+ value: &str,
+ visited: &mut std::collections::HashSet<String>,
+ safe: &mut std::collections::HashSet<String>,
+ ) -> Result<(), ParseError> {
+ for ref_name in Self::extract_entity_refs(value) {
+ if safe.contains(ref_name) {
+ continue;
+ }
+ if visited.contains(ref_name) {
+ return Err(self.fatal(format!("recursive entity reference: '{ref_name}'")));
+ }
+ if let Some(decl) = self.dtd.entities.get(ref_name) {
+ if let EntityKind::Internal(ref inner_value) = decl.kind {
+ visited.insert(ref_name.to_string());
+ self.check_entity_recursion(inner_value, visited, safe)?;
+ visited.remove(ref_name);
+ safe.insert(ref_name.to_string());
+ }
+ }
+ }
+ Ok(())
+ }
+
+ /// Recursively checks for parameter entity reference cycles.
+ ///
+ /// Examines the char-ref-expanded replacement text for `%name;` patterns.
+ fn check_pe_recursion(
+ &self,
+ value: &str,
+ visited: &mut std::collections::HashSet<String>,
+ safe: &mut std::collections::HashSet<String>,
+ ) -> Result<(), ParseError> {
+ for ref_name in Self::extract_pe_refs(value) {
+ if safe.contains(&ref_name) {
+ continue;
+ }
+ if visited.contains(&ref_name) {
+ return Err(self.fatal(format!(
+ "recursive parameter entity reference: '%{ref_name}'"
+ )));
+ }
+ if let Some(decl) = self.dtd.param_entities.get(&ref_name) {
+ if let EntityKind::Internal(ref inner_value) = decl.kind {
+ let expanded = expand_char_refs_only(inner_value);
+ visited.insert(ref_name.clone());
+ self.check_pe_recursion(&expanded, visited, safe)?;
+ visited.remove(&ref_name);
+ safe.insert(ref_name.clone());
+ }
+ }
+ }
+ Ok(())
+ }
+
+ /// Extracts parameter entity reference names (`%name;`) from a string.
+ fn extract_pe_refs(value: &str) -> Vec<String> {
+ let mut refs = Vec::new();
+ let bytes = value.as_bytes();
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'%' {
+ i += 1;
+ if i < bytes.len() && (bytes[i].is_ascii_alphabetic() || bytes[i] == b'_') {
+ let start = i;
+ while i < bytes.len() && bytes[i] != b';' && !bytes[i].is_ascii_whitespace() {
+ i += 1;
+ }
+ if i < bytes.len() && bytes[i] == b';' && i > start {
+ if let Ok(name) = std::str::from_utf8(&bytes[start..i]) {
+ refs.push(name.to_string());
+ }
+ i += 1;
+ }
+ }
+ } else {
+ i += 1;
+ }
+ }
+ refs
+ }
+
+ /// Validates entity references in attribute default values.
+ ///
+ /// Checks WFC: No External Entity References (§3.1) and
+ /// WFC: No `<` in Attribute Values for entity replacement text.
+ fn validate_attr_default_entities(
+ &self,
+ value: &str,
+ checked: &mut std::collections::HashSet<String>,
+ ) -> Result<(), ParseError> {
+ for ref_name in Self::extract_entity_refs(value) {
+ // Built-in entities are always fine
+ if matches!(ref_name, "amp" | "lt" | "gt" | "apos" | "quot") {
+ continue;
+ }
+ if checked.contains(ref_name) {
+ continue;
+ }
+ match self.dtd.entities.get(ref_name) {
+ None => {
+ return Err(self.fatal(format!(
+ "undeclared entity '{ref_name}' referenced in \
+ attribute default value"
+ )));
+ }
+ Some(decl) => match &decl.kind {
+ EntityKind::External { .. } => {
+ return Err(self.fatal(format!(
+ "attribute default value must not reference \
+ external entity '{ref_name}'"
+ )));
+ }
+ EntityKind::Internal(ref text) => {
+ // Check for '<' in replacement text (WFC: No < in
+ // Attribute Values, XML 1.0 §3.1)
+ if text.contains('<') {
+ return Err(self.fatal(format!(
+ "entity '{ref_name}' contains '<' and cannot \
+ be used in attribute values"
+ )));
+ }
+ // Recursively check referenced entities
+ checked.insert(ref_name.to_string());
+ self.validate_attr_default_entities(text, checked)?;
+ }
+ },
+ }
+ }
+ Ok(())
+ }
+
+ /// Extracts entity reference names from a string value.
+ ///
+ /// Returns an iterator over entity names found in `&name;` patterns,
+ /// excluding character references (`&#...;`).
+ fn extract_entity_refs(value: &str) -> Vec<&str> {
+ let mut refs = Vec::new();
+ let bytes = value.as_bytes();
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'&' {
+ i += 1;
+ if i < bytes.len() && bytes[i] == b'#' {
+ // Character reference — skip
+ while i < bytes.len() && bytes[i] != b';' {
+ i += 1;
+ }
+ if i < bytes.len() {
+ i += 1;
+ }
+ } else {
+ // Entity reference
+ let start = i;
+ while i < bytes.len() && bytes[i] != b';' && bytes[i] != b'&' {
+ i += 1;
+ }
+ if i < bytes.len() && bytes[i] == b';' && i > start {
+ if let Ok(name) = std::str::from_utf8(&bytes[start..i]) {
+ refs.push(name);
+ }
+ i += 1;
+ }
+ }
+ } else {
+ i += 1;
+ }
+ }
+ refs
+ }
+
+ // --- ELEMENT declaration ---
+ // See XML 1.0 §3.2: [45] elementdecl
+
+ fn parse_element_decl(&mut self) -> Result<(), ParseError> {
+ self.expect_str(b"<!ELEMENT")?;
+ self.skip_whitespace_required()?;
+ let name = self.parse_name()?;
+ self.skip_whitespace_required()?;
+ let content_model = self.parse_content_model()?;
+ self.skip_whitespace();
+ self.expect_byte(b'>')?;
+
+ let decl = ElementDecl {
+ name: name.clone(),
+ content_model,
+ };
+ self.dtd
+ .declarations
+ .push(DtdDeclaration::Element(decl.clone()));
+ self.dtd.elements.insert(name, decl);
+ Ok(())
+ }
+
+ fn parse_content_model(&mut self) -> Result<ContentModel, ParseError> {
+ if self.looking_at(b"EMPTY") {
+ self.expect_str(b"EMPTY")?;
+ return Ok(ContentModel::Empty);
+ }
+ if self.looking_at(b"ANY") {
+ self.expect_str(b"ANY")?;
+ return Ok(ContentModel::Any);
+ }
+
+ // Must be Mixed or Children, both start with '('
+ self.expect_byte(b'(')?;
+ self.skip_whitespace();
+
+ // Check for mixed content: (#PCDATA ...)
+ if self.looking_at(b"#PCDATA") {
+ self.expect_str(b"#PCDATA")?;
+ self.skip_whitespace();
+
+ let mut names = Vec::new();
+
+ if self.peek() == Some(b')') {
+ // (#PCDATA) — text only
+ self.advance(1);
+ // Optional '*' after (#PCDATA) — some DTDs write (#PCDATA)*
+ if self.peek() == Some(b'*') {
+ self.advance(1);
+ }
+ return Ok(ContentModel::Mixed(names));
+ }
+
+ // (#PCDATA|a|b)*
+ while self.peek() == Some(b'|') {
+ self.advance(1);
+ self.skip_whitespace();
+ let elem_name = self.parse_name()?;
+ names.push(elem_name);
+ self.skip_whitespace();
+ }
+
+ self.expect_byte(b')')?;
+ self.expect_byte(b'*')?;
+
+ return Ok(ContentModel::Mixed(names));
+ }
+
+ // Element-only content: parse as a content spec group. The opening
+ // '(' has already been consumed, so we are one level deep.
+ let spec = self.parse_content_spec_group(1)?;
+ Ok(ContentModel::Children(spec))
+ }
+
+ /// Parses a content spec starting after the opening '(' has been consumed
+ /// and the first item is NOT `#PCDATA`.
+ ///
+ /// `depth` is the current parenthesis-nesting level (1 for the outermost
+ /// group). It bounds the mutual recursion with `parse_content_particle` so
+ /// that untrusted input cannot exhaust the stack; see
+ /// [`MAX_CONTENT_MODEL_DEPTH`].
+ fn parse_content_spec_group(&mut self, depth: u32) -> Result<ContentSpec, ParseError> {
+ if depth > MAX_CONTENT_MODEL_DEPTH {
+ return Err(self.fatal(format!(
+ "content model nesting exceeds maximum depth of {MAX_CONTENT_MODEL_DEPTH}"
+ )));
+ }
+ let mut first = self.parse_content_particle(depth)?;
+ self.skip_whitespace();
+
+ // Determine if this is a sequence (,) or choice (|)
+ if self.peek() == Some(b',') {
+ // Sequence
+ let mut items = vec![first];
+ while self.peek() == Some(b',') {
+ self.advance(1);
+ self.skip_whitespace();
+ let item = self.parse_content_particle(depth)?;
+ items.push(item);
+ self.skip_whitespace();
+ }
+ self.expect_byte(b')')?;
+ let occurrence = self.parse_occurrence();
+ Ok(ContentSpec {
+ kind: ContentSpecKind::Seq(items),
+ occurrence,
+ })
+ } else if self.peek() == Some(b'|') {
+ // Choice
+ let mut items = vec![first];
+ while self.peek() == Some(b'|') {
+ self.advance(1);
+ self.skip_whitespace();
+ let item = self.parse_content_particle(depth)?;
+ items.push(item);
+ self.skip_whitespace();
+ }
+ self.expect_byte(b')')?;
+ let occurrence = self.parse_occurrence();
+ Ok(ContentSpec {
+ kind: ContentSpecKind::Choice(items),
+ occurrence,
+ })
+ } else {
+ // Single item group: (item)?/*
+ self.expect_byte(b')')?;
+ let group_occurrence = self.parse_occurrence();
+
+ if group_occurrence != Occurrence::Once {
+ // Group has occurrence: (X)+ → wrap in Seq
+ Ok(ContentSpec {
+ kind: ContentSpecKind::Seq(vec![first]),
+ occurrence: group_occurrence,
+ })
+ } else if first.occurrence != Occurrence::Once {
+ // Inner particle has occurrence but group doesn't.
+ // libxml2 normalizes (X+) → (X)+ by moving occurrence
+ // to the outer group.
+ let inner_occ = first.occurrence;
+ first.occurrence = Occurrence::Once;
+ Ok(ContentSpec {
+ kind: ContentSpecKind::Seq(vec![first]),
+ occurrence: inner_occ,
+ })
+ } else {
+ // No occurrence on either — unwrap the group
+ Ok(first)
+ }
+ }
+ }
+
+ /// Parses a single content particle: a name with an optional occurrence
+ /// indicator, or a nested parenthesised group.
+ ///
+ /// `depth` is the enclosing parenthesis-nesting level; a nested group
+ /// recurses at `depth + 1`. See [`MAX_CONTENT_MODEL_DEPTH`].
+ fn parse_content_particle(&mut self, depth: u32) -> Result<ContentSpec, ParseError> {
+ if self.peek() == Some(b'(') {
+ self.advance(1);
+ self.skip_whitespace();
+ self.parse_content_spec_group(depth + 1)
+ } else {
+ let name = self.parse_name()?;
+ let occurrence = self.parse_occurrence();
+ Ok(ContentSpec {
+ kind: ContentSpecKind::Name(name),
+ occurrence,
+ })
+ }
+ }
+
+ fn parse_occurrence(&mut self) -> Occurrence {
+ match self.peek() {
+ Some(b'?') => {
+ self.advance(1);
+ Occurrence::Optional
+ }
+ Some(b'*') => {
+ self.advance(1);
+ Occurrence::ZeroOrMore
+ }
+ Some(b'+') => {
+ self.advance(1);
+ Occurrence::OneOrMore
+ }
+ _ => Occurrence::Once,
+ }
+ }
+
+ // --- ATTLIST declaration ---
+ // See XML 1.0 §3.3: [52] AttlistDecl
+
+ fn parse_attlist_decl(&mut self) -> Result<(), ParseError> {
+ self.expect_str(b"<!ATTLIST")?;
+ self.skip_whitespace_required()?;
+ let element_name = self.parse_name()?;
+
+ loop {
+ self.skip_whitespace();
+ if self.peek() == Some(b'>') {
+ self.advance(1);
+ break;
+ }
+
+ let attribute_name = self.parse_name()?;
+ self.skip_whitespace_required()?;
+ let attribute_type = self.parse_attribute_type()?;
+ self.skip_whitespace_required()?;
+ let default = self.parse_attribute_default()?;
+
+ let decl = AttributeDecl {
+ element_name: element_name.clone(),
+ attribute_name,
+ attribute_type,
+ default,
+ };
+
+ // Per XML 1.0 §3.3, the first attribute declaration is binding;
+ // subsequent declarations for the same attribute are ignored.
+ let attrs = self.dtd.attributes.entry(element_name.clone()).or_default();
+ if !attrs
+ .iter()
+ .any(|a| a.attribute_name == decl.attribute_name)
+ {
+ self.dtd
+ .declarations
+ .push(DtdDeclaration::Attlist(decl.clone()));
+ attrs.push(decl);
+ }
+ }
+
+ Ok(())
+ }
+
+ fn parse_attribute_type(&mut self) -> Result<AttributeType, ParseError> {
+ if self.looking_at(b"CDATA") {
+ self.expect_str(b"CDATA")?;
+ Ok(AttributeType::CData)
+ } else if self.looking_at(b"IDREFS") {
+ self.expect_str(b"IDREFS")?;
+ Ok(AttributeType::IdRefs)
+ } else if self.looking_at(b"IDREF") {
+ self.expect_str(b"IDREF")?;
+ Ok(AttributeType::IdRef)
+ } else if self.looking_at(b"ID") {
+ self.expect_str(b"ID")?;
+ Ok(AttributeType::Id)
+ } else if self.looking_at(b"ENTITIES") {
+ self.expect_str(b"ENTITIES")?;
+ Ok(AttributeType::Entities)
+ } else if self.looking_at(b"ENTITY") {
+ self.expect_str(b"ENTITY")?;
+ Ok(AttributeType::Entity)
+ } else if self.looking_at(b"NMTOKENS") {
+ self.expect_str(b"NMTOKENS")?;
+ Ok(AttributeType::NmTokens)
+ } else if self.looking_at(b"NMTOKEN") {
+ self.expect_str(b"NMTOKEN")?;
+ Ok(AttributeType::NmToken)
+ } else if self.looking_at(b"NOTATION") {
+ self.expect_str(b"NOTATION")?;
+ self.skip_whitespace_required()?;
+ let values = self.parse_enumerated_values()?;
+ Ok(AttributeType::Notation(values))
+ } else if self.peek() == Some(b'(') {
+ let values = self.parse_enumerated_values()?;
+ Ok(AttributeType::Enumeration(values))
+ } else {
+ Err(self.fatal("expected attribute type"))
+ }
+ }
+
+ fn parse_enumerated_values(&mut self) -> Result<Vec<String>, ParseError> {
+ self.expect_byte(b'(')?;
+ self.skip_whitespace();
+ let mut values = Vec::new();
+
+ let first = self.parse_nmtoken()?;
+ values.push(first);
+
+ loop {
+ self.skip_whitespace();
+ if self.peek() == Some(b')') {
+ self.advance(1);
+ break;
+ }
+ self.expect_byte(b'|')?;
+ self.skip_whitespace();
+ let val = self.parse_nmtoken()?;
+ values.push(val);
+ }
+
+ Ok(values)
+ }
+
+ fn parse_attribute_default(&mut self) -> Result<AttributeDefault, ParseError> {
+ if self.looking_at(b"#REQUIRED") {
+ self.expect_str(b"#REQUIRED")?;
+ Ok(AttributeDefault::Required)
+ } else if self.looking_at(b"#IMPLIED") {
+ self.expect_str(b"#IMPLIED")?;
+ Ok(AttributeDefault::Implied)
+ } else if self.looking_at(b"#FIXED") {
+ self.expect_str(b"#FIXED")?;
+ self.skip_whitespace_required()?;
+ let value = self.parse_quoted_value()?;
+ self.validate_default_value(&value)?;
+ Ok(AttributeDefault::Fixed(value))
+ } else {
+ let value = self.parse_quoted_value()?;
+ self.validate_default_value(&value)?;
+ Ok(AttributeDefault::Default(value))
+ }
+ }
+
+ // --- ENTITY declaration ---
+ // See XML 1.0 §4.2: [70] EntityDecl
+
+ #[allow(clippy::too_many_lines)]
+ fn parse_entity_decl(&mut self) -> Result<(), ParseError> {
+ self.expect_str(b"<!ENTITY")?;
+ self.skip_whitespace_required()?;
+
+ // Parameter entities (% name)
+ if self.peek() == Some(b'%') {
+ self.advance(1);
+ self.skip_whitespace_required()?;
+ let pe_name = self.parse_name()?;
+ // Namespaces in XML 1.0: entity names must be NCNames (no colons).
+ if pe_name.contains(':') {
+ return Err(self.fatal(format!("entity name '{pe_name}' must not contain a colon")));
+ }
+ self.skip_whitespace_required()?;
+
+ let pe_kind = if self.peek() == Some(b'"') || self.peek() == Some(b'\'') {
+ // Internal PE — parse and validate the value
+ let value = self.parse_quoted_value()?;
+ self.validate_entity_value(&value, true)?;
+ Some(EntityKind::Internal(value))
+ } else if self.looking_at(b"SYSTEM") {
+ // External PE — parse external ID
+ self.expect_str(b"SYSTEM")?;
+ self.skip_whitespace_required()?;
+ let system_id = self.parse_quoted_value()?;
+ Some(EntityKind::External {
+ system_id,
+ public_id: None,
+ })
+ } else if self.looking_at(b"PUBLIC") {
+ self.expect_str(b"PUBLIC")?;
+ self.skip_whitespace_required()?;
+ let public_id = self.parse_quoted_value()?;
+ self.validate_public_id(&public_id)?;
+ self.skip_whitespace_required()?;
+ let system_id = self.parse_quoted_value()?;
+ Some(EntityKind::External {
+ system_id,
+ public_id: Some(public_id),
+ })
+ } else {
+ return Err(self.fatal("expected entity value or external ID"));
+ };
+
+ self.skip_whitespace();
+ // Reject NDATA on parameter entities (XML 1.0 §4.2.2)
+ if self.looking_at(b"NDATA") {
+ return Err(self.fatal("NDATA annotation is not allowed on parameter entities"));
+ }
+ self.expect_byte(b'>')?;
+
+ // Store PE declaration (first declaration wins per XML 1.0 §4.2)
+ if let Some(kind) = pe_kind {
+ self.dtd
+ .param_entities
+ .entry(pe_name)
+ .or_insert(EntityDecl {
+ name: String::new(),
+ kind,
+ });
+ }
+ return Ok(());
+ }
+
+ let name = self.parse_name()?;
+ // Namespaces in XML 1.0: entity names must be NCNames (no colons).
+ if name.contains(':') {
+ return Err(self.fatal(format!("entity name '{name}' must not contain a colon")));
+ }
+ self.skip_whitespace_required()?;
+
+ let is_parameter_entity = false;
+ let kind = if self.peek() == Some(b'"') || self.peek() == Some(b'\'') {
+ // Internal entity
+ let value = self.parse_quoted_value()?;
+ self.validate_entity_value(&value, is_parameter_entity)?;
+ EntityKind::Internal(value)
+ } else if self.looking_at(b"SYSTEM") {
+ self.expect_str(b"SYSTEM")?;
+ self.skip_whitespace_required()?;
+ let system_id = self.parse_quoted_value()?;
+ EntityKind::External {
+ system_id,
+ public_id: None,
+ }
+ } else if self.looking_at(b"PUBLIC") {
+ self.expect_str(b"PUBLIC")?;
+ self.skip_whitespace_required()?;
+ let public_id = self.parse_quoted_value()?;
+ self.validate_public_id(&public_id)?;
+ self.skip_whitespace_required()?;
+ let system_id = self.parse_quoted_value()?;
+ EntityKind::External {
+ system_id,
+ public_id: Some(public_id),
+ }
+ } else {
+ return Err(self.fatal("expected entity value or external ID"));
+ };
+
+ let had_ws = self.skip_whitespace();
+
+ // Handle optional NDATA for unparsed external entities (XML 1.0 §4.2.2)
+ if self.looking_at(b"NDATA") {
+ // NDATA is only allowed on external entities
+ if matches!(kind, EntityKind::Internal(_)) {
+ return Err(self.fatal("NDATA annotation is not allowed on internal entities"));
+ }
+ // Whitespace is required before NDATA (XML 1.0 §4.2.2)
+ if !had_ws {
+ return Err(self.fatal("whitespace required before NDATA"));
+ }
+ self.expect_str(b"NDATA")?;
+ self.skip_whitespace_required()?;
+ let _notation_name = self.parse_name()?;
+ self.skip_whitespace();
+ }
+
+ self.expect_byte(b'>')?;
+
+ // Per XML 1.0 §4.2, the first entity declaration is binding;
+ // subsequent declarations of the same entity are ignored.
+ let decl = EntityDecl {
+ name: name.clone(),
+ kind,
+ };
+ self.dtd
+ .declarations
+ .push(DtdDeclaration::Entity(decl.clone()));
+ self.dtd.entities.entry(name).or_insert(decl);
+ Ok(())
+ }
+
+ // --- NOTATION declaration ---
+ // See XML 1.0 §4.7: [82] NotationDecl
+
+ fn parse_notation_decl(&mut self) -> Result<(), ParseError> {
+ self.expect_str(b"<!NOTATION")?;
+ self.skip_whitespace_required()?;
+ let name = self.parse_name()?;
+ // Namespaces in XML 1.0: notation names must be NCNames (no colons).
+ if name.contains(':') {
+ return Err(self.fatal(format!("notation name '{name}' must not contain a colon")));
+ }
+ self.skip_whitespace_required()?;
+
+ let (system_id, public_id) = if self.looking_at(b"SYSTEM") {
+ self.expect_str(b"SYSTEM")?;
+ self.skip_whitespace_required()?;
+ let sid = self.parse_quoted_value()?;
+ (Some(sid), None)
+ } else if self.looking_at(b"PUBLIC") {
+ self.expect_str(b"PUBLIC")?;
+ self.skip_whitespace_required()?;
+ let pid = self.parse_quoted_value()?;
+ self.validate_public_id(&pid)?;
+ // System ID is optional for notations with PUBLIC
+ self.skip_whitespace();
+ let sid = if self.peek() == Some(b'"') || self.peek() == Some(b'\'') {
+ Some(self.parse_quoted_value()?)
+ } else {
+ None
+ };
+ (sid, Some(pid))
+ } else {
+ return Err(self.fatal("expected SYSTEM or PUBLIC in NOTATION declaration"));
+ };
+
+ self.skip_whitespace();
+ self.expect_byte(b'>')?;
+
+ let decl = NotationDecl {
+ name: name.clone(),
+ system_id,
+ public_id,
+ };
+ self.dtd
+ .declarations
+ .push(DtdDeclaration::Notation(decl.clone()));
+ self.dtd.notations.insert(name, decl);
+ Ok(())
+ }
+
+ // --- Skip helpers ---
+
+ /// Parses a comment and stores it as a `DtdDeclaration::Comment`.
+ fn parse_comment_decl(&mut self) -> Result<(), ParseError> {
+ self.expect_str(b"<!--")?;
+ let start = self.pos;
+ loop {
+ if self.at_end() {
+ return Err(self.fatal("unexpected end of input in comment"));
+ }
+ if self.looking_at(b"-->") {
+ let text = std::str::from_utf8(&self.input[start..self.pos])
+ .unwrap_or("")
+ .to_string();
+ self.advance(3);
+ self.dtd.declarations.push(DtdDeclaration::Comment(text));
+ return Ok(());
+ }
+ self.advance(1);
+ }
+ }
+
+ /// Parses a processing instruction and stores it as a `DtdDeclaration::Pi`.
+ fn parse_pi_decl(&mut self) -> Result<(), ParseError> {
+ self.expect_str(b"<?")?;
+
+ // Parse and validate the PI target name (XML 1.0 §2.6)
+ let target = self.parse_name()?;
+
+ // Reject <?xml ...?> inside DTD (XML 1.0 §2.8)
+ if target.eq_ignore_ascii_case("xml") {
+ return Err(self.fatal("XML declaration is not allowed inside DTD"));
+ }
+
+ // If we're immediately at ?>, no data — that's fine
+ if self.looking_at(b"?>") {
+ self.advance(2);
+ self.dtd.declarations.push(DtdDeclaration::Pi(target, None));
+ return Ok(());
+ }
+
+ // If there's data, whitespace is required between target and data
+ let is_ws = self
+ .peek()
+ .is_some_and(|b| b == b' ' || b == b'\t' || b == b'\r' || b == b'\n');
+ if !is_ws {
+ return Err(self.fatal("space required between PI target and data"));
+ }
+
+ let start = self.pos;
+ loop {
+ if self.at_end() {
+ return Err(self.fatal("unexpected end of input in processing instruction"));
+ }
+ if self.looking_at(b"?>") {
+ let data = std::str::from_utf8(&self.input[start..self.pos])
+ .unwrap_or("")
+ .trim()
+ .to_string();
+ self.advance(2);
+ let data = if data.is_empty() { None } else { Some(data) };
+ self.dtd.declarations.push(DtdDeclaration::Pi(target, data));
+ return Ok(());
+ }
+ self.advance(1);
+ }
+ }
+
+ fn skip_pe_reference(&mut self) -> Result<(), ParseError> {
+ self.expect_byte(b'%')?;
+ // Read the name
+ let _name = self.parse_name()?;
+ self.expect_byte(b';')?;
+ Ok(())
+ }
+
+ // --- Name / token parsing ---
+
+ fn parse_name(&mut self) -> Result<String, ParseError> {
+ if self.pos >= self.input.len() {
+ return Err(self.fatal("expected name, found end of input"));
+ }
+
+ let start = self.pos;
+ let first = self.input[self.pos];
+
+ // ASCII fast path
+ if is_ascii_name_start(first) {
+ self.pos += 1;
+ self.column += 1;
+ while self.pos < self.input.len() && is_ascii_name_char(self.input[self.pos]) {
+ self.pos += 1;
+ self.column += 1;
+ }
+ if self.pos >= self.input.len() || self.input[self.pos] < 0x80 {
+ let name = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ return Ok(name.to_string());
+ }
+ // Fall through to slow path for non-ASCII continuation
+ } else {
+ let ch = self
+ .peek_char()
+ .ok_or_else(|| self.fatal("expected name"))?;
+ if !is_name_start_char(ch) {
+ return Err(self.fatal(format!("invalid name start character: '{ch}'")));
+ }
+ self.advance_char(ch);
+ }
+
+ while let Some(ch) = self.peek_char() {
+ if is_name_char(ch) {
+ self.advance_char(ch);
+ } else {
+ break;
+ }
+ }
+
+ let name = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in name"))?;
+ Ok(name.to_string())
+ }
+
+ fn parse_nmtoken(&mut self) -> Result<String, ParseError> {
+ if self.pos >= self.input.len() {
+ return Err(self.fatal("expected NMTOKEN, found end of input"));
+ }
+
+ let start = self.pos;
+ let first = self.input[self.pos];
+
+ // ASCII fast path
+ if is_ascii_name_char(first) {
+ self.pos += 1;
+ self.column += 1;
+ while self.pos < self.input.len() && is_ascii_name_char(self.input[self.pos]) {
+ self.pos += 1;
+ self.column += 1;
+ }
+ if self.pos >= self.input.len() || self.input[self.pos] < 0x80 {
+ let token = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in NMTOKEN"))?;
+ return Ok(token.to_string());
+ }
+ // Fall through to slow path
+ } else {
+ let ch = self
+ .peek_char()
+ .ok_or_else(|| self.fatal("expected NMTOKEN"))?;
+ if !is_name_char(ch) {
+ return Err(self.fatal(format!("invalid NMTOKEN character: '{ch}'")));
+ }
+ self.advance_char(ch);
+ }
+
+ while let Some(ch) = self.peek_char() {
+ if is_name_char(ch) {
+ self.advance_char(ch);
+ } else {
+ break;
+ }
+ }
+
+ let token = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in NMTOKEN"))?;
+ Ok(token.to_string())
+ }
+
+ /// Validates an entity value per XML 1.0 §4.3.2 `EntityValue` production.
+ ///
+ /// Checks that `&` is only used in valid entity/character references,
+ /// and that `%` is not present in general entity values.
+ #[allow(clippy::too_many_lines)]
+ fn validate_entity_value(
+ &self,
+ value: &str,
+ is_parameter_entity: bool,
+ ) -> Result<(), ParseError> {
+ // First validate all characters are valid XML chars.
+ for c in value.chars() {
+ if !crate::parser::input::is_xml_char(c) {
+ return Err(self.fatal(format!(
+ "invalid XML character U+{:04X} in entity value",
+ c as u32
+ )));
+ }
+ }
+
+ // Text declarations (<?xml ...?>) are forbidden in internal
+ // entities (XML 1.0 §4.3.1). They may only appear at the start
+ // of external parsed entities.
+ if value.starts_with("<?xml") {
+ let after = value.as_bytes().get(5).copied();
+ if after.map_or(true, |b| b == b' ' || b == b'\t' || b == b'?') {
+ return Err(self.fatal("text declaration is not allowed in internal entity value"));
+ }
+ }
+
+ let bytes = value.as_bytes();
+ let mut i = 0;
+ while i < bytes.len() {
+ match bytes[i] {
+ b'&' => {
+ // Must be a valid reference: &name; or &#N; or &#xH;
+ i += 1;
+ if i >= bytes.len() {
+ return Err(self.fatal("incomplete reference in entity value: '&' at end"));
+ }
+ if bytes[i] == b'#' {
+ // Character reference — parse and validate
+ i += 1;
+ let char_val = if i < bytes.len() && bytes[i] == b'x' {
+ i += 1;
+ let hex_start = i;
+ if i >= bytes.len() || !bytes[i].is_ascii_hexdigit() {
+ return Err(
+ self.fatal("malformed character reference in entity value")
+ );
+ }
+ while i < bytes.len() && bytes[i].is_ascii_hexdigit() {
+ i += 1;
+ }
+ let hex_str = std::str::from_utf8(&bytes[hex_start..i]).unwrap_or("");
+ u32::from_str_radix(hex_str, 16).unwrap_or(0)
+ } else {
+ let dec_start = i;
+ if i >= bytes.len() || !bytes[i].is_ascii_digit() {
+ return Err(
+ self.fatal("malformed character reference in entity value")
+ );
+ }
+ while i < bytes.len() && bytes[i].is_ascii_digit() {
+ i += 1;
+ }
+ let dec_str = std::str::from_utf8(&bytes[dec_start..i]).unwrap_or("");
+ dec_str.parse::<u32>().unwrap_or(0)
+ };
+ if i >= bytes.len() || bytes[i] != b';' {
+ return Err(
+ self.fatal("incomplete character reference in entity value")
+ );
+ }
+ i += 1;
+ // Validate the referenced character is a valid XML char
+ if let Some(c) = char::from_u32(char_val) {
+ if !crate::parser::input::is_xml_char(c) {
+ return Err(self.fatal(format!(
+ "character reference &#x{char_val:X}; refers to invalid XML character"
+ )));
+ }
+ } else {
+ return Err(self.fatal(format!(
+ "character reference value {char_val} is not a valid Unicode code point"
+ )));
+ }
+ } else {
+ // Entity reference — must be Name followed by ';'
+ let start = i;
+ while i < bytes.len()
+ && bytes[i] != b';'
+ && bytes[i] != b'&'
+ && !bytes[i].is_ascii_whitespace()
+ {
+ i += 1;
+ }
+ if i == start || i >= bytes.len() || bytes[i] != b';' {
+ return Err(self.fatal("malformed entity reference in entity value"));
+ }
+ // Validate the entity name starts with a NameStartChar
+ let name_str = std::str::from_utf8(&bytes[start..i]).unwrap_or("");
+ if let Some(first_char) = name_str.chars().next() {
+ if !is_name_start_char(first_char) {
+ return Err(self.fatal(format!(
+ "entity reference name must start with a letter or underscore, found '{first_char}'"
+ )));
+ }
+ }
+ i += 1;
+ }
+ }
+ b'%' if !is_parameter_entity => {
+ // '%' is not allowed in general entity values (XML 1.0 §4.3.2)
+ return Err(self.fatal("'%' not allowed in general entity value"));
+ }
+ b'%' if is_parameter_entity => {
+ // WFC: PEs in Internal Subset — PE references MUST NOT
+ // occur within markup declarations in the internal subset
+ // (XML 1.0 §2.8).
+ i += 1;
+ if i < bytes.len() {
+ let first = bytes[i];
+ if first.is_ascii_alphabetic() || first == b'_' || first == b':' {
+ return Err(self.fatal(
+ "parameter entity reference not allowed within \
+ markup declaration in internal subset",
+ ));
+ }
+ }
+ }
+ _ => {
+ i += 1;
+ }
+ }
+ }
+ Ok(())
+ }
+
+ /// Validates an attribute default value per XML 1.0 §3.3.2.
+ ///
+ /// Checks that entity references within the default value refer to
+ /// entities that have already been declared (WFC: Entity Declared).
+ /// Also rejects `<` in default values (WFC: No `<` in Attribute Values).
+ fn validate_default_value(&self, value: &str) -> Result<(), ParseError> {
+ let bytes = value.as_bytes();
+ let mut i = 0;
+ while i < bytes.len() {
+ match bytes[i] {
+ b'<' => {
+ return Err(self.fatal("'<' not allowed in attribute default value"));
+ }
+ b'&' => {
+ i += 1;
+ if i < bytes.len() && bytes[i] == b'#' {
+ // Character reference — skip over it
+ i += 1;
+ while i < bytes.len() && bytes[i] != b';' {
+ i += 1;
+ }
+ if i < bytes.len() {
+ i += 1;
+ }
+ } else {
+ // Entity reference — extract name and check declaration
+ let start = i;
+ while i < bytes.len() && bytes[i] != b';' {
+ i += 1;
+ }
+ if i > start && i < bytes.len() {
+ let name = std::str::from_utf8(&bytes[start..i]).unwrap_or("");
+ // Built-in entities are always available
+ let is_builtin = matches!(name, "amp" | "lt" | "gt" | "apos" | "quot");
+ if !is_builtin && !self.dtd.entities.contains_key(name) {
+ return Err(self.fatal(format!(
+ "undeclared entity '{name}' in attribute default value"
+ )));
+ }
+ }
+ if i < bytes.len() {
+ i += 1;
+ }
+ }
+ }
+ _ => {
+ i += 1;
+ }
+ }
+ }
+ Ok(())
+ }
+
+ /// Validates that a public ID string contains only valid `PubidChar`s
+ /// per XML 1.0 §2.3 `[13]`.
+ fn validate_public_id(&self, pid: &str) -> Result<(), ParseError> {
+ for c in pid.chars() {
+ let valid = matches!(c,
+ ' ' | '\r' | '\n' |
+ 'a'..='z' | 'A'..='Z' | '0'..='9' |
+ '-' | '\'' | '(' | ')' | '+' | ',' | '.' | '/' | ':' |
+ '=' | '?' | ';' | '!' | '*' | '#' | '@' | '$' | '_' | '%'
+ );
+ if !valid {
+ return Err(self.fatal(format!(
+ "invalid character in public ID: U+{:04X}",
+ c as u32
+ )));
+ }
+ }
+ Ok(())
+ }
+
+ fn parse_quoted_value(&mut self) -> Result<String, ParseError> {
+ let quote = self.next_byte()?;
+ if quote != b'"' && quote != b'\'' {
+ return Err(self.fatal("expected quoted value"));
+ }
+ let start = self.pos;
+ while !self.at_end() && self.peek() != Some(quote) {
+ self.advance(1);
+ }
+ let value = std::str::from_utf8(&self.input[start..self.pos])
+ .map_err(|_| self.fatal("invalid UTF-8 in quoted value"))?
+ .to_string();
+ if self.at_end() {
+ return Err(self.fatal("unexpected end of input in quoted value"));
+ }
+ self.advance(1); // consume closing quote
+ Ok(value)
+ }
+
+ // --- Low-level input helpers ---
+
+ fn location(&self) -> SourceLocation {
+ SourceLocation {
+ line: self.line,
+ column: self.column,
+ byte_offset: self.pos,
+ }
+ }
+
+ fn at_end(&self) -> bool {
+ self.pos >= self.input.len()
+ }
+
+ fn peek(&self) -> Option<u8> {
+ self.input.get(self.pos).copied()
+ }
+
+ fn peek_char(&self) -> Option<char> {
+ if self.pos >= self.input.len() {
+ return None;
+ }
+ let first = self.input[self.pos];
+ // Fast path: ASCII
+ if first < 0x80 {
+ return Some(first as char);
+ }
+ // Slow path: multi-byte UTF-8 — decode only the needed bytes
+ let len = match first {
+ 0xC0..=0xDF => 2,
+ 0xE0..=0xEF => 3,
+ 0xF0..=0xF7 => 4,
+ _ => return None,
+ };
+ let remaining = &self.input[self.pos..];
+ if remaining.len() < len {
+ return None;
+ }
+ std::str::from_utf8(&remaining[..len])
+ .ok()
+ .and_then(|s| s.chars().next())
+ }
+
+ fn advance(&mut self, count: usize) {
+ for _ in 0..count {
+ if self.pos < self.input.len() {
+ if self.input[self.pos] == b'\n' {
+ self.line += 1;
+ self.column = 1;
+ } else {
+ self.column += 1;
+ }
+ self.pos += 1;
+ }
+ }
+ }
+
+ fn advance_char(&mut self, ch: char) {
+ let len = ch.len_utf8();
+ if ch == '\n' {
+ self.line += 1;
+ self.column = 1;
+ } else {
+ self.column += 1;
+ }
+ self.pos += len;
+ }
+
+ fn next_byte(&mut self) -> Result<u8, ParseError> {
+ if self.at_end() {
+ return Err(self.fatal("unexpected end of input"));
+ }
+ let b = self.input[self.pos];
+ self.advance(1);
+ Ok(b)
+ }
+
+ fn expect_byte(&mut self, expected: u8) -> Result<(), ParseError> {
+ let b = self.next_byte()?;
+ if b == expected {
+ Ok(())
+ } else {
+ Err(self.fatal(format!(
+ "expected '{}', found '{}'",
+ expected as char, b as char
+ )))
+ }
+ }
+
+ fn expect_str(&mut self, expected: &[u8]) -> Result<(), ParseError> {
+ for &b in expected {
+ self.expect_byte(b)?;
+ }
+ Ok(())
+ }
+
+ fn looking_at(&self, s: &[u8]) -> bool {
+ self.pos + s.len() <= self.input.len() && self.input[self.pos..].starts_with(s)
+ }
+
+ fn skip_whitespace(&mut self) -> bool {
+ let start = self.pos;
+ while let Some(b) = self.peek() {
+ if b == b' ' || b == b'\t' || b == b'\r' || b == b'\n' {
+ self.advance(1);
+ } else {
+ break;
+ }
+ }
+ self.pos > start
+ }
+
+ fn skip_whitespace_required(&mut self) -> Result<(), ParseError> {
+ if !self.skip_whitespace() {
+ return Err(self.fatal("whitespace required"));
+ }
+ Ok(())
+ }
+
+ fn fatal(&self, message: impl Into<String>) -> ParseError {
+ ParseError {
+ message: message.into(),
+ location: self.location(),
+ diagnostics: Vec::new(),
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Entity value helper functions (used by DTD parser and XML parser)
+// ---------------------------------------------------------------------------
+
+/// Expands only character references in a string, leaving entity references
+/// as-is. Returns the expanded text.
+///
+/// Used to compute the replacement text of an internal entity per XML 1.0
+/// §4.5: character references are expanded at declaration time, while
+/// entity references are left for expansion at reference time.
+pub(crate) fn expand_char_refs_only(value: &str) -> String {
+ let bytes = value.as_bytes();
+ let mut result = String::with_capacity(value.len());
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'&' && i + 1 < bytes.len() && bytes[i + 1] == b'#' {
+ i += 2;
+ let char_val = if i < bytes.len() && bytes[i] == b'x' {
+ i += 1;
+ let start = i;
+ while i < bytes.len() && bytes[i].is_ascii_hexdigit() {
+ i += 1;
+ }
+ let hex = std::str::from_utf8(&bytes[start..i]).unwrap_or("0");
+ u32::from_str_radix(hex, 16).unwrap_or(0)
+ } else {
+ let start = i;
+ while i < bytes.len() && bytes[i].is_ascii_digit() {
+ i += 1;
+ }
+ let dec = std::str::from_utf8(&bytes[start..i]).unwrap_or("0");
+ dec.parse::<u32>().unwrap_or(0)
+ };
+ if i < bytes.len() && bytes[i] == b';' {
+ i += 1;
+ }
+ if let Some(ch) = char::from_u32(char_val) {
+ result.push(ch);
+ }
+ } else {
+ // Copy one complete UTF-8 character
+ let ch = value[i..].chars().next().unwrap_or('\u{FFFD}');
+ result.push(ch);
+ i += ch.len_utf8();
+ }
+ }
+ result
+}
+
+/// Replaces entity references (`&name;`) with spaces, leaving character
+/// references (`&#...;`) and other text unchanged. Correctly handles
+/// multi-byte UTF-8 characters.
+///
+/// Used to sanitize entity replacement text before fragment parsing so
+/// that entity references (which are valid `Reference` productions in
+/// content) don't cause undeclared-entity errors.
+pub(crate) fn replace_entity_refs(text: &str) -> String {
+ let bytes = text.as_bytes();
+ let mut result = String::with_capacity(text.len());
+ let mut i = 0;
+ while i < bytes.len() {
+ if bytes[i] == b'&' && i + 1 < bytes.len() && bytes[i + 1] != b'#' {
+ // Possible entity reference: &name;
+ let start = i;
+ i += 1;
+ if i < bytes.len()
+ && (bytes[i].is_ascii_alphabetic() || bytes[i] == b'_' || bytes[i] == b':')
+ {
+ // Scan to semicolon
+ while i < bytes.len() && bytes[i] != b';' {
+ i += 1;
+ }
+ if i < bytes.len() && bytes[i] == b';' {
+ // Complete entity reference — replace with space
+ result.push(' ');
+ i += 1;
+ } else {
+ // Incomplete — keep original text
+ result.push_str(&text[start..i]);
+ }
+ } else {
+ // Not a valid entity ref start — keep the '&'
+ result.push('&');
+ }
+ } else {
+ // Copy one complete UTF-8 character
+ let ch = text[i..].chars().next().unwrap_or('\u{FFFD}');
+ result.push(ch);
+ i += ch.len_utf8();
+ }
+ }
+ result
+}
+
+// ---------------------------------------------------------------------------
+// XML Name character classes (shared with parser/xml.rs)
+// ---------------------------------------------------------------------------
+
+fn is_ascii_name_start(b: u8) -> bool {
+ b.is_ascii_alphabetic() || b == b'_' || b == b':'
+}
+
+fn is_ascii_name_char(b: u8) -> bool {
+ b.is_ascii_alphanumeric() || b == b'_' || b == b':' || b == b'-' || b == b'.'
+}
+
+fn is_name_start_char(c: char) -> bool {
+ matches!(c,
+ ':' | 'A'..='Z' | '_' | 'a'..='z' |
+ '\u{C0}'..='\u{D6}' | '\u{D8}'..='\u{F6}' | '\u{F8}'..='\u{2FF}' |
+ '\u{370}'..='\u{37D}' | '\u{37F}'..='\u{1FFF}' |
+ '\u{200C}'..='\u{200D}' | '\u{2070}'..='\u{218F}' |
+ '\u{2C00}'..='\u{2FEF}' | '\u{3001}'..='\u{D7FF}' |
+ '\u{F900}'..='\u{FDCF}' | '\u{FDF0}'..='\u{FFFD}' |
+ '\u{10000}'..='\u{EFFFF}'
+ )
+}
+
+fn is_name_char(c: char) -> bool {
+ is_name_start_char(c)
+ || matches!(c,
+ '-' | '.' | '0'..='9' | '\u{B7}' |
+ '\u{300}'..='\u{36F}' | '\u{203F}'..='\u{2040}'
+ )
+}
+
+// ---------------------------------------------------------------------------
+// DTD Validator
+// ---------------------------------------------------------------------------
+
+/// Validates a document against a DTD.
+///
+/// Checks that the document conforms to the element declarations, attribute
+/// declarations, and other constraints in the DTD. Returns a
+/// [`ValidationResult`] with any errors and warnings.
+///
+/// # Checks Performed
+///
+/// - Root element name matches DOCTYPE declaration
+/// - Element content matches declared content models
+/// - Required attributes are present
+/// - Attribute values match their declared types (ID uniqueness, IDREF targets,
+/// enumeration values)
+/// - No undeclared elements (when the DTD declares elements)
+/// - No undeclared attributes (when the DTD declares attributes for that element)
+/// - `#FIXED` attribute values match the declared value
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+/// use xmloxide::validation::dtd::{parse_dtd, validate};
+///
+/// let dtd = parse_dtd("<!ELEMENT root (#PCDATA)>").unwrap();
+/// let mut doc = Document::parse_str("<!DOCTYPE root><root>hello</root>").unwrap();
+/// let result = validate(&mut doc, &dtd);
+/// assert!(result.is_valid);
+/// ```
+pub fn validate(doc: &mut Document, dtd: &Dtd) -> ValidationResult {
+ let mut errors = Vec::new();
+ let mut warnings = Vec::new();
+ let mut id_values: HashSet<String> = HashSet::new();
+ let mut idref_values: Vec<String> = Vec::new();
+
+ // Check root element name against DOCTYPE
+ check_root_element(doc, dtd, &mut errors);
+
+ // Walk all element nodes and validate
+ if let Some(root_elem) = doc.root_element() {
+ validate_element_recursive(
+ doc,
+ dtd,
+ root_elem,
+ &mut errors,
+ &mut warnings,
+ &mut id_values,
+ &mut idref_values,
+ );
+ }
+
+ // Check that all IDREF values point to existing IDs
+ for idref in &idref_values {
+ if !id_values.contains(idref) {
+ errors.push(ValidationError {
+ message: format!("IDREF '{idref}' does not match any ID in the document"),
+ line: None,
+ column: None,
+ });
+ }
+ }
+
+ let is_valid = errors.is_empty();
+ ValidationResult {
+ is_valid,
+ errors,
+ warnings,
+ }
+}
+
+/// Checks that the root element name matches the DOCTYPE name.
+fn check_root_element(doc: &Document, _dtd: &Dtd, errors: &mut Vec<ValidationError>) {
+ // Find the DOCTYPE node to get the declared root name
+ let doctype_name = doc.children(doc.root()).find_map(|id| {
+ if let NodeKind::DocumentType { ref name, .. } = doc.node(id).kind {
+ Some(name.clone())
+ } else {
+ None
+ }
+ });
+
+ if let Some(ref expected_name) = doctype_name {
+ if let Some(root_elem) = doc.root_element() {
+ if let Some(actual_name) = doc.node_name(root_elem) {
+ if actual_name != expected_name {
+ errors.push(ValidationError {
+ message: format!(
+ "root element '{actual_name}' does not match \
+ DOCTYPE name '{expected_name}'"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+ }
+ }
+}
+
+/// Recursively validates an element and its descendants.
+#[allow(clippy::too_many_arguments)]
+fn validate_element_recursive(
+ doc: &mut Document,
+ dtd: &Dtd,
+ node_id: NodeId,
+ errors: &mut Vec<ValidationError>,
+ warnings: &mut Vec<ValidationError>,
+ id_values: &mut HashSet<String>,
+ idref_values: &mut Vec<String>,
+) {
+ let elem_name = match doc.node_name(node_id) {
+ Some(name) => name.to_string(),
+ None => return,
+ };
+
+ // Check if element is declared
+ let has_element_decls = !dtd.elements.is_empty();
+ if has_element_decls && !dtd.elements.contains_key(&elem_name) {
+ errors.push(ValidationError {
+ message: format!("element '{elem_name}' is not declared in the DTD"),
+ line: None,
+ column: None,
+ });
+ }
+
+ // Check content model
+ if let Some(elem_decl) = dtd.elements.get(&elem_name) {
+ validate_content_model(doc, node_id, &elem_name, &elem_decl.content_model, errors);
+ }
+
+ // Check attributes
+ validate_attributes(
+ doc,
+ dtd,
+ node_id,
+ &elem_name,
+ errors,
+ warnings,
+ id_values,
+ idref_values,
+ );
+
+ // Collect child element IDs first to avoid borrow conflicts. Entity
+ // references are looked through so that entity-supplied elements are
+ // validated too (XML 1.0 §4.4.3: included replacement text participates
+ // in validation).
+ let child_ids: Vec<NodeId> = effective_content_children(doc, node_id)
+ .into_iter()
+ .filter(|&child_id| matches!(doc.node(child_id).kind, NodeKind::Element { .. }))
+ .collect();
+
+ // Recurse into child elements
+ for child_id in child_ids {
+ validate_element_recursive(
+ doc,
+ dtd,
+ child_id,
+ errors,
+ warnings,
+ id_values,
+ idref_values,
+ );
+ }
+}
+
+/// Collects an element's content children in document order, transparently
+/// expanding entity-reference nodes into their parsed replacement children.
+///
+/// Per XML 1.0 §4.4.3, replacement text included for an entity reference is
+/// part of the document's content and participates in validation, so the
+/// content-model checks must see through `EntityRef` nodes. An entity
+/// reference without parsed children (e.g. an undeclared entity preserved in
+/// tolerant mode) contributes nothing.
+fn effective_content_children(doc: &Document, node_id: NodeId) -> Vec<NodeId> {
+ fn collect(doc: &Document, node_id: NodeId, out: &mut Vec<NodeId>) {
+ for child in doc.children(node_id) {
+ if matches!(doc.node(child).kind, NodeKind::EntityRef { .. }) {
+ collect(doc, child, out);
+ } else {
+ out.push(child);
+ }
+ }
+ }
+ let mut out = Vec::new();
+ collect(doc, node_id, &mut out);
+ out
+}
+
+/// Validates that an element's children match its declared content model.
+fn validate_content_model(
+ doc: &Document,
+ node_id: NodeId,
+ elem_name: &str,
+ model: &ContentModel,
+ errors: &mut Vec<ValidationError>,
+) {
+ // Entity references are looked through: their parsed replacement
+ // children are part of the content being validated (XML 1.0 §4.4.3).
+ let content_children = effective_content_children(doc, node_id);
+ match model {
+ ContentModel::Empty => {
+ // No children at all
+ let has_content = content_children.iter().any(|&child| {
+ matches!(
+ doc.node(child).kind,
+ NodeKind::Element { .. } | NodeKind::Text { .. } | NodeKind::CData { .. }
+ )
+ });
+ if has_content {
+ errors.push(ValidationError {
+ message: format!(
+ "element '{elem_name}' is declared EMPTY \
+ but has content"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+ ContentModel::Any => {
+ // Anything is valid
+ }
+ ContentModel::Mixed(allowed_names) => {
+ // Text is always allowed. Check that element children are in the allowed list.
+ for &child_id in &content_children {
+ if let NodeKind::Element { ref name, .. } = doc.node(child_id).kind {
+ if !allowed_names.contains(name) {
+ errors.push(ValidationError {
+ message: format!(
+ "element '{name}' is not allowed in mixed content \
+ of '{elem_name}' (allowed: #PCDATA{})",
+ if allowed_names.is_empty() {
+ String::new()
+ } else {
+ format!("|{}", allowed_names.join("|"))
+ }
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+ }
+ }
+ ContentModel::Children(spec) => {
+ // Collect element child names (ignore text, comments, PIs)
+ let child_names: Vec<String> = content_children
+ .iter()
+ .filter_map(|&child_id| {
+ if let NodeKind::Element { ref name, .. } = doc.node(child_id).kind {
+ Some(name.clone())
+ } else {
+ None
+ }
+ })
+ .collect();
+
+ // Check for text content in element-only content model
+ let has_text = content_children.iter().any(|&child_id| {
+ if let NodeKind::Text { ref content } = doc.node(child_id).kind {
+ !content.trim().is_empty()
+ } else {
+ matches!(doc.node(child_id).kind, NodeKind::CData { .. })
+ }
+ });
+
+ if has_text {
+ errors.push(ValidationError {
+ message: format!(
+ "element '{elem_name}' has element-only content model \
+ but contains text"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+
+ // Match the sequence of child element names against the content spec
+ let consumed = match_content_spec(spec, &child_names, 0);
+ match consumed {
+ Some(n) if n == child_names.len() => {
+ // Perfect match
+ }
+ _ => {
+ errors.push(ValidationError {
+ message: format!(
+ "element '{elem_name}' content does not match \
+ declared content model {model}; \
+ found children: [{}]",
+ child_names.join(", ")
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+ }
+ }
+}
+
+/// Matches a content spec against a slice of element names starting at `pos`.
+///
+/// Returns `Some(count)` if the spec matches, consuming `count` names from
+/// position `pos`. Returns `None` if no match is possible.
+fn match_content_spec(spec: &ContentSpec, names: &[String], pos: usize) -> Option<usize> {
+ match &spec.kind {
+ ContentSpecKind::Name(expected) => match_with_occurrence(
+ |all_names, p| {
+ if p < all_names.len() && all_names[p] == *expected {
+ Some(1)
+ } else {
+ None
+ }
+ },
+ names,
+ pos,
+ spec.occurrence,
+ ),
+ ContentSpecKind::Seq(items) => match_with_occurrence(
+ |all_names, p| {
+ let mut current = p;
+ for item in items {
+ match match_content_spec(item, all_names, current) {
+ Some(consumed) => current += consumed,
+ None => return None,
+ }
+ }
+ Some(current - p)
+ },
+ names,
+ pos,
+ spec.occurrence,
+ ),
+ ContentSpecKind::Choice(items) => match_with_occurrence(
+ |all_names, p| {
+ for item in items {
+ if let Some(consumed) = match_content_spec(item, all_names, p) {
+ return Some(consumed);
+ }
+ }
+ None
+ },
+ names,
+ pos,
+ spec.occurrence,
+ ),
+ }
+}
+
+/// Applies occurrence matching around a base matcher function.
+///
+/// The `base_match` function attempts a single match at a given position,
+/// returning `Some(consumed)` on success.
+fn match_with_occurrence(
+ base_match: impl Fn(&[String], usize) -> Option<usize>,
+ names: &[String],
+ pos: usize,
+ occurrence: Occurrence,
+) -> Option<usize> {
+ match occurrence {
+ Occurrence::Once => base_match(names, pos),
+ Occurrence::Optional => {
+ // Try matching once; if it fails, succeed consuming 0
+ Some(base_match(names, pos).unwrap_or(0))
+ }
+ Occurrence::ZeroOrMore | Occurrence::OneOrMore => {
+ let mut total = 0;
+ loop {
+ match base_match(names, pos + total) {
+ Some(0) | None => break, // zero-width or no match
+ Some(n) => total += n,
+ }
+ }
+ // OneOrMore requires at least one match
+ if occurrence == Occurrence::OneOrMore && total == 0 {
+ None
+ } else {
+ Some(total)
+ }
+ }
+ }
+}
+
+/// Validates attributes for an element against DTD attribute declarations.
+#[allow(clippy::too_many_arguments)]
+fn validate_attributes(
+ doc: &mut Document,
+ dtd: &Dtd,
+ node_id: NodeId,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+ _warnings: &mut Vec<ValidationError>,
+ id_values: &mut HashSet<String>,
+ idref_values: &mut Vec<String>,
+) {
+ let attr_decls = dtd.attributes.get(elem_name);
+ let actual_attrs = doc.attributes(node_id).to_vec();
+
+ if let Some(decls) = attr_decls {
+ // Check each declared attribute
+ for decl in decls {
+ let actual = actual_attrs.iter().find(|a| a.name == decl.attribute_name);
+
+ match (&decl.default, actual) {
+ (AttributeDefault::Required, None) => {
+ errors.push(ValidationError {
+ message: format!(
+ "required attribute '{}' missing on element '{elem_name}'",
+ decl.attribute_name
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ (AttributeDefault::Fixed(fixed_val), Some(attr)) if attr.value != *fixed_val => {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{}' on element '{elem_name}' must have \
+ fixed value '{fixed_val}', found '{}'",
+ decl.attribute_name, attr.value
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ _ => {}
+ }
+
+ // Type checking for present attributes
+ if let Some(attr) = actual {
+ validate_attribute_type(
+ doc,
+ node_id,
+ &attr.value,
+ &decl.attribute_type,
+ &decl.attribute_name,
+ elem_name,
+ errors,
+ id_values,
+ idref_values,
+ );
+ }
+ }
+
+ // Check for undeclared attributes (skip xmlns-related attributes)
+ for attr in &actual_attrs {
+ if attr.name == "xmlns" || attr.prefix.as_deref() == Some("xmlns") {
+ continue;
+ }
+ let is_declared = decls.iter().any(|d| d.attribute_name == attr.name);
+ if !is_declared {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{}' on element '{elem_name}' is not declared in the DTD",
+ attr.name
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+ }
+}
+
+/// Validates an attribute value against its declared type.
+#[allow(clippy::too_many_arguments)]
+fn validate_attribute_type(
+ doc: &mut Document,
+ node_id: NodeId,
+ value: &str,
+ attr_type: &AttributeType,
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+ id_values: &mut HashSet<String>,
+ idref_values: &mut Vec<String>,
+) {
+ match attr_type {
+ AttributeType::CData => {
+ // Any string is valid CDATA
+ }
+ AttributeType::Id => {
+ validate_id_value(doc, node_id, value, attr_name, elem_name, errors, id_values);
+ }
+ AttributeType::IdRef => {
+ validate_idref_value(value, attr_name, elem_name, errors, idref_values);
+ }
+ AttributeType::IdRefs => {
+ validate_idrefs_value(value, attr_name, elem_name, errors, idref_values);
+ }
+ AttributeType::NmToken => {
+ validate_nmtoken_value(value, attr_name, elem_name, errors);
+ }
+ AttributeType::NmTokens => {
+ validate_nmtokens_value(value, attr_name, elem_name, errors);
+ }
+ AttributeType::Enumeration(values) | AttributeType::Notation(values) => {
+ validate_enumeration_value(value, values, attr_name, elem_name, errors);
+ }
+ AttributeType::Entity | AttributeType::Entities => {
+ validate_entity_value(value, attr_type, attr_name, elem_name, errors);
+ }
+ }
+}
+
+/// Validates an ID attribute value: must be a valid XML Name and unique.
+///
+/// On success, registers the ID in the document's `id_map` so it can be
+/// looked up via [`Document::element_by_id`] and the `XPath` `id()` function.
+fn validate_id_value(
+ doc: &mut Document,
+ node_id: NodeId,
+ value: &str,
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+ id_values: &mut HashSet<String>,
+) {
+ if !is_valid_name(value) {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{attr_name}' on element '{elem_name}' \
+ has invalid ID value '{value}' (not a valid XML Name)"
+ ),
+ line: None,
+ column: None,
+ });
+ } else if !id_values.insert(value.to_string()) {
+ errors.push(ValidationError {
+ message: format!(
+ "duplicate ID value '{value}' on attribute '{attr_name}' \
+ of element '{elem_name}'"
+ ),
+ line: None,
+ column: None,
+ });
+ } else {
+ doc.set_id(value, node_id);
+ }
+}
+
+/// Validates an IDREF attribute value.
+fn validate_idref_value(
+ value: &str,
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+ idref_values: &mut Vec<String>,
+) {
+ if is_valid_name(value) {
+ idref_values.push(value.to_string());
+ } else {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{attr_name}' on element '{elem_name}' \
+ has invalid IDREF value '{value}'"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+}
+
+/// Validates an IDREFS attribute value (space-separated list).
+fn validate_idrefs_value(
+ value: &str,
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+ idref_values: &mut Vec<String>,
+) {
+ for token in value.split_whitespace() {
+ if is_valid_name(token) {
+ idref_values.push(token.to_string());
+ } else {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{attr_name}' on element '{elem_name}' \
+ has invalid IDREFS token '{token}'"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+}
+
+/// Validates a NMTOKEN attribute value.
+fn validate_nmtoken_value(
+ value: &str,
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+) {
+ if !is_valid_nmtoken(value) {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{attr_name}' on element '{elem_name}' \
+ has invalid NMTOKEN value '{value}'"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+}
+
+/// Validates a NMTOKENS attribute value (space-separated list).
+fn validate_nmtokens_value(
+ value: &str,
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+) {
+ for token in value.split_whitespace() {
+ if !is_valid_nmtoken(token) {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{attr_name}' on element '{elem_name}' \
+ has invalid NMTOKENS token '{token}'"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+}
+
+/// Validates an enumeration or notation attribute value.
+fn validate_enumeration_value(
+ value: &str,
+ allowed: &[String],
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+) {
+ if !allowed.contains(&value.to_string()) {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{attr_name}' on element '{elem_name}' \
+ has value '{value}' which is not in the allowed \
+ values ({})",
+ allowed.join("|")
+ ),
+ line: None,
+ column: None,
+ });
+ }
+}
+
+/// Validates an ENTITY or ENTITIES attribute value.
+fn validate_entity_value(
+ value: &str,
+ attr_type: &AttributeType,
+ attr_name: &str,
+ elem_name: &str,
+ errors: &mut Vec<ValidationError>,
+) {
+ // Entity/Entities validation would require checking against
+ // declared unparsed entities. For now we just check Name validity.
+ let tokens: Vec<&str> = if matches!(attr_type, AttributeType::Entities) {
+ value.split_whitespace().collect()
+ } else {
+ vec![value]
+ };
+ for token in tokens {
+ if !is_valid_name(token) {
+ errors.push(ValidationError {
+ message: format!(
+ "attribute '{attr_name}' on element '{elem_name}' \
+ has invalid ENTITY/ENTITIES value '{token}'"
+ ),
+ line: None,
+ column: None,
+ });
+ }
+ }
+}
+
+/// Checks if a string is a valid XML Name.
+fn is_valid_name(s: &str) -> bool {
+ let mut chars = s.chars();
+ match chars.next() {
+ Some(first) if is_name_start_char(first) => chars.all(is_name_char),
+ _ => false,
+ }
+}
+
+/// Checks if a string is a valid NMTOKEN.
+fn is_valid_nmtoken(s: &str) -> bool {
+ !s.is_empty() && s.chars().all(is_name_char)
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ // --- DTD Parsing Tests ---
+
+ #[test]
+ fn test_parse_element_empty() {
+ let dtd = parse_dtd("<!ELEMENT br EMPTY>").unwrap();
+ let decl = dtd.elements.get("br").unwrap();
+ assert_eq!(decl.content_model, ContentModel::Empty);
+ }
+
+ #[test]
+ fn test_parse_element_any() {
+ let dtd = parse_dtd("<!ELEMENT container ANY>").unwrap();
+ let decl = dtd.elements.get("container").unwrap();
+ assert_eq!(decl.content_model, ContentModel::Any);
+ }
+
+ #[test]
+ fn test_parse_element_pcdata() {
+ let dtd = parse_dtd("<!ELEMENT title (#PCDATA)>").unwrap();
+ let decl = dtd.elements.get("title").unwrap();
+ assert_eq!(decl.content_model, ContentModel::Mixed(vec![]));
+ }
+
+ #[test]
+ fn test_parse_element_mixed_content() {
+ let dtd = parse_dtd("<!ELEMENT p (#PCDATA|em|strong)*>").unwrap();
+ let decl = dtd.elements.get("p").unwrap();
+ assert_eq!(
+ decl.content_model,
+ ContentModel::Mixed(vec!["em".to_string(), "strong".to_string()])
+ );
+ }
+
+ #[test]
+ fn test_parse_element_sequence() {
+ let dtd = parse_dtd("<!ELEMENT book (title,author,year)>").unwrap();
+ let decl = dtd.elements.get("book").unwrap();
+ match &decl.content_model {
+ ContentModel::Children(spec) => {
+ assert_eq!(spec.occurrence, Occurrence::Once);
+ match &spec.kind {
+ ContentSpecKind::Seq(items) => {
+ assert_eq!(items.len(), 3);
+ assert_eq!(items[0].kind, ContentSpecKind::Name("title".to_string()));
+ assert_eq!(items[1].kind, ContentSpecKind::Name("author".to_string()));
+ assert_eq!(items[2].kind, ContentSpecKind::Name("year".to_string()));
+ }
+ other => panic!("expected Seq, got {other:?}"),
+ }
+ }
+ other => panic!("expected Children, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_element_choice() {
+ let dtd = parse_dtd("<!ELEMENT item (a|b|c)>").unwrap();
+ let decl = dtd.elements.get("item").unwrap();
+ match &decl.content_model {
+ ContentModel::Children(spec) => match &spec.kind {
+ ContentSpecKind::Choice(items) => {
+ assert_eq!(items.len(), 3);
+ }
+ other => panic!("expected Choice, got {other:?}"),
+ },
+ other => panic!("expected Children, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_element_occurrence_indicators() {
+ let dtd = parse_dtd("<!ELEMENT doc (head, body?, appendix*)>").unwrap();
+ let decl = dtd.elements.get("doc").unwrap();
+ match &decl.content_model {
+ ContentModel::Children(spec) => match &spec.kind {
+ ContentSpecKind::Seq(items) => {
+ assert_eq!(items[0].occurrence, Occurrence::Once);
+ assert_eq!(items[1].occurrence, Occurrence::Optional);
+ assert_eq!(items[2].occurrence, Occurrence::ZeroOrMore);
+ }
+ other => panic!("expected Seq, got {other:?}"),
+ },
+ other => panic!("expected Children, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_element_nested_groups() {
+ let dtd = parse_dtd("<!ELEMENT article ((title, author), body)>").unwrap();
+ let decl = dtd.elements.get("article").unwrap();
+ match &decl.content_model {
+ ContentModel::Children(spec) => match &spec.kind {
+ ContentSpecKind::Seq(items) => {
+ assert_eq!(items.len(), 2);
+ // First item is a nested sequence (title, author)
+ match &items[0].kind {
+ ContentSpecKind::Seq(inner) => {
+ assert_eq!(inner.len(), 2);
+ }
+ other => panic!("expected nested Seq, got {other:?}"),
+ }
+ }
+ other => panic!("expected Seq, got {other:?}"),
+ },
+ other => panic!("expected Children, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_attlist_cdata() {
+ let dtd = parse_dtd("<!ATTLIST img src CDATA #REQUIRED>").unwrap();
+ let decls = dtd.attributes.get("img").unwrap();
+ assert_eq!(decls.len(), 1);
+ assert_eq!(decls[0].attribute_name, "src");
+ assert_eq!(decls[0].attribute_type, AttributeType::CData);
+ assert_eq!(decls[0].default, AttributeDefault::Required);
+ }
+
+ #[test]
+ fn test_parse_attlist_id() {
+ let dtd = parse_dtd("<!ATTLIST div id ID #IMPLIED>").unwrap();
+ let decls = dtd.attributes.get("div").unwrap();
+ assert_eq!(decls[0].attribute_type, AttributeType::Id);
+ assert_eq!(decls[0].default, AttributeDefault::Implied);
+ }
+
+ #[test]
+ fn test_parse_attlist_enumeration() {
+ let dtd = parse_dtd("<!ATTLIST input type (text|password|submit) \"text\">").unwrap();
+ let decls = dtd.attributes.get("input").unwrap();
+ assert_eq!(
+ decls[0].attribute_type,
+ AttributeType::Enumeration(vec![
+ "text".to_string(),
+ "password".to_string(),
+ "submit".to_string()
+ ])
+ );
+ assert_eq!(
+ decls[0].default,
+ AttributeDefault::Default("text".to_string())
+ );
+ }
+
+ #[test]
+ fn test_parse_attlist_fixed() {
+ let dtd = parse_dtd("<!ATTLIST doc version CDATA #FIXED \"1.0\">").unwrap();
+ let decls = dtd.attributes.get("doc").unwrap();
+ assert_eq!(decls[0].default, AttributeDefault::Fixed("1.0".to_string()));
+ }
+
+ #[test]
+ fn test_parse_attlist_multiple_attrs() {
+ let dtd =
+ parse_dtd("<!ATTLIST person\n name CDATA #REQUIRED\n age NMTOKEN #IMPLIED>").unwrap();
+ let decls = dtd.attributes.get("person").unwrap();
+ assert_eq!(decls.len(), 2);
+ assert_eq!(decls[0].attribute_name, "name");
+ assert_eq!(decls[1].attribute_name, "age");
+ assert_eq!(decls[1].attribute_type, AttributeType::NmToken);
+ }
+
+ #[test]
+ fn test_parse_entity_internal() {
+ let dtd = parse_dtd("<!ENTITY copy \"©\">").unwrap();
+ let ent = dtd.entities.get("copy").unwrap();
+ match &ent.kind {
+ EntityKind::Internal(value) => assert_eq!(value, "©"),
+ EntityKind::External { .. } => panic!("expected Internal, got External"),
+ }
+ }
+
+ #[test]
+ fn test_parse_entity_external() {
+ let dtd = parse_dtd("<!ENTITY chapter SYSTEM \"chapter.xml\">").unwrap();
+ let ent = dtd.entities.get("chapter").unwrap();
+ match &ent.kind {
+ EntityKind::External {
+ system_id,
+ public_id,
+ } => {
+ assert_eq!(system_id, "chapter.xml");
+ assert_eq!(*public_id, None);
+ }
+ EntityKind::Internal(val) => panic!("expected External, got Internal({val})"),
+ }
+ }
+
+ #[test]
+ fn test_parse_notation() {
+ let dtd = parse_dtd("<!NOTATION png SYSTEM \"image/png\">").unwrap();
+ let notation = dtd.notations.get("png").unwrap();
+ assert_eq!(notation.system_id.as_deref(), Some("image/png"));
+ }
+
+ #[test]
+ fn test_parse_dtd_with_comments() {
+ let dtd = parse_dtd(
+ "<!-- element declarations -->\n\
+ <!ELEMENT root (#PCDATA)>\n\
+ <!-- end -->",
+ )
+ .unwrap();
+ assert!(dtd.elements.contains_key("root"));
+ }
+
+ #[test]
+ fn test_parse_dtd_complex() {
+ let input = "\
+ <!ELEMENT doc (head, body)>\n\
+ <!ELEMENT head (title)>\n\
+ <!ELEMENT title (#PCDATA)>\n\
+ <!ELEMENT body (p+)>\n\
+ <!ELEMENT p (#PCDATA|em)*>\n\
+ <!ELEMENT em (#PCDATA)>\n\
+ <!ATTLIST doc version CDATA #FIXED \"1.0\">\n\
+ <!ATTLIST p id ID #IMPLIED>\n\
+ <!ENTITY copyright \"Copyright 2024\">\n";
+ let dtd = parse_dtd(input).unwrap();
+ assert_eq!(dtd.elements.len(), 6);
+ assert!(dtd.attributes.contains_key("doc"));
+ assert!(dtd.attributes.contains_key("p"));
+ assert!(dtd.entities.contains_key("copyright"));
+ }
+
+ // --- Validation Tests ---
+
+ fn make_doc(xml: &str) -> Document {
+ Document::parse_str(xml).unwrap()
+ }
+
+ #[test]
+ fn test_validate_valid_document() {
+ let dtd = parse_dtd("<!ELEMENT root (#PCDATA)>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE root><root>hello</root>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_root_name_mismatch() {
+ let dtd = parse_dtd("<!ELEMENT root (#PCDATA)>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE root><other>text</other>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("root element 'other'")
+ && e.message.contains("does not match DOCTYPE name 'root'")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_empty_element() {
+ let dtd = parse_dtd("<!ELEMENT br EMPTY>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE br><br/>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_empty_element_has_content() {
+ let dtd = parse_dtd("<!ELEMENT br EMPTY>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE br><br>text</br>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("EMPTY") && e.message.contains("has content")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_any_content() {
+ let dtd = parse_dtd(
+ "<!ELEMENT container ANY>\n\
+ <!ELEMENT child (#PCDATA)>",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE container><container><child>text</child></container>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_sequence_correct() {
+ let dtd = parse_dtd(
+ "<!ELEMENT book (title,author)>\n\
+ <!ELEMENT title (#PCDATA)>\n\
+ <!ELEMENT author (#PCDATA)>",
+ )
+ .unwrap();
+ let mut doc = make_doc(
+ "<!DOCTYPE book>\
+ <book><title>XML</title><author>Jon</author></book>",
+ );
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_sequence_wrong_order() {
+ let dtd = parse_dtd(
+ "<!ELEMENT book (title,author)>\n\
+ <!ELEMENT title (#PCDATA)>\n\
+ <!ELEMENT author (#PCDATA)>",
+ )
+ .unwrap();
+ let mut doc = make_doc(
+ "<!DOCTYPE book>\
+ <book><author>Jon</author><title>XML</title></book>",
+ );
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("content does not match")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_required_attribute_missing() {
+ let dtd = parse_dtd(
+ "<!ELEMENT img EMPTY>\n\
+ <!ATTLIST img src CDATA #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE img><img/>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("required attribute 'src'")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_required_attribute_present() {
+ let dtd = parse_dtd(
+ "<!ELEMENT img EMPTY>\n\
+ <!ATTLIST img src CDATA #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE img><img src=\"photo.jpg\"/>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_fixed_attribute_correct() {
+ let dtd = parse_dtd(
+ "<!ELEMENT doc (#PCDATA)>\n\
+ <!ATTLIST doc version CDATA #FIXED \"1.0\">",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE doc><doc version=\"1.0\">text</doc>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_fixed_attribute_wrong_value() {
+ let dtd = parse_dtd(
+ "<!ELEMENT doc (#PCDATA)>\n\
+ <!ATTLIST doc version CDATA #FIXED \"1.0\">",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE doc><doc version=\"2.0\">text</doc>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("fixed value '1.0'")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_enumeration_valid() {
+ let dtd = parse_dtd(
+ "<!ELEMENT input EMPTY>\n\
+ <!ATTLIST input type (text|password) #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE input><input type=\"text\"/>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_enumeration_invalid() {
+ let dtd = parse_dtd(
+ "<!ELEMENT input EMPTY>\n\
+ <!ATTLIST input type (text|password) #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE input><input type=\"checkbox\"/>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("not in the allowed values")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_duplicate_id() {
+ let dtd = parse_dtd(
+ "<!ELEMENT root (item, item)>\n\
+ <!ELEMENT item (#PCDATA)>\n\
+ <!ATTLIST item id ID #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc = make_doc(
+ "<!DOCTYPE root>\
+ <root>\
+ <item id=\"a\">first</item>\
+ <item id=\"a\">second</item>\
+ </root>",
+ );
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("duplicate ID value 'a'")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_idref_valid() {
+ let dtd = parse_dtd(
+ "<!ELEMENT root (item, ref)>\n\
+ <!ELEMENT item (#PCDATA)>\n\
+ <!ELEMENT ref (#PCDATA)>\n\
+ <!ATTLIST item id ID #REQUIRED>\n\
+ <!ATTLIST ref target IDREF #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc = make_doc(
+ "<!DOCTYPE root>\
+ <root>\
+ <item id=\"x\">item</item>\
+ <ref target=\"x\">ref</ref>\
+ </root>",
+ );
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_idref_dangling() {
+ let dtd = parse_dtd(
+ "<!ELEMENT root (ref)>\n\
+ <!ELEMENT ref (#PCDATA)>\n\
+ <!ATTLIST ref target IDREF #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc = make_doc(
+ "<!DOCTYPE root>\
+ <root><ref target=\"nonexistent\">ref</ref></root>",
+ );
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result.errors.iter().any(|e| e
+ .message
+ .contains("IDREF 'nonexistent' does not match any ID")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_undeclared_element() {
+ let dtd = parse_dtd("<!ELEMENT root (child)>\n<!ELEMENT child (#PCDATA)>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE root><root><unknown/></root>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("element 'unknown' is not declared")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_undeclared_attribute() {
+ let dtd = parse_dtd(
+ "<!ELEMENT root (#PCDATA)>\n\
+ <!ATTLIST root id ID #IMPLIED>",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE root><root id=\"x\" bogus=\"y\">text</root>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("attribute 'bogus'")
+ && e.message.contains("not declared")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_mixed_content_valid() {
+ let dtd = parse_dtd(
+ "<!ELEMENT p (#PCDATA|em|strong)*>\n\
+ <!ELEMENT em (#PCDATA)>\n\
+ <!ELEMENT strong (#PCDATA)>",
+ )
+ .unwrap();
+ let mut doc = make_doc(
+ "<!DOCTYPE p>\
+ <p>Hello <em>world</em> and <strong>friends</strong></p>",
+ );
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_mixed_content_invalid_child() {
+ let dtd = parse_dtd(
+ "<!ELEMENT p (#PCDATA|em)*>\n\
+ <!ELEMENT em (#PCDATA)>\n\
+ <!ELEMENT b (#PCDATA)>",
+ )
+ .unwrap();
+ let mut doc = make_doc(
+ "<!DOCTYPE p>\
+ <p>Hello <b>world</b></p>",
+ );
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("'b' is not allowed in mixed content")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_choice_correct() {
+ let dtd = parse_dtd(
+ "<!ELEMENT item (a|b)>\n\
+ <!ELEMENT a (#PCDATA)>\n\
+ <!ELEMENT b (#PCDATA)>",
+ )
+ .unwrap();
+ let mut doc = make_doc("<!DOCTYPE item><item><b>hello</b></item>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_one_or_more() {
+ let dtd = parse_dtd("<!ELEMENT list (item+)>\n<!ELEMENT item (#PCDATA)>").unwrap();
+
+ // Valid: one item
+ let mut doc = make_doc("<!DOCTYPE list><list><item>a</item></list>");
+ assert!(validate(&mut doc, &dtd).is_valid);
+
+ // Valid: multiple items
+ let mut doc = make_doc("<!DOCTYPE list><list><item>a</item><item>b</item></list>");
+ assert!(validate(&mut doc, &dtd).is_valid);
+
+ // Invalid: zero items
+ let mut doc = make_doc("<!DOCTYPE list><list></list>");
+ assert!(!validate(&mut doc, &dtd).is_valid);
+ }
+
+ #[test]
+ fn test_validate_zero_or_more() {
+ let dtd = parse_dtd("<!ELEMENT list (item*)>\n<!ELEMENT item (#PCDATA)>").unwrap();
+
+ // Valid: zero items
+ let mut doc = make_doc("<!DOCTYPE list><list></list>");
+ assert!(validate(&mut doc, &dtd).is_valid);
+
+ // Valid: multiple items
+ let mut doc = make_doc("<!DOCTYPE list><list><item>a</item><item>b</item></list>");
+ assert!(validate(&mut doc, &dtd).is_valid);
+ }
+
+ #[test]
+ fn test_validate_optional_element() {
+ let dtd = parse_dtd(
+ "<!ELEMENT doc (title, subtitle?)>\n\
+ <!ELEMENT title (#PCDATA)>\n\
+ <!ELEMENT subtitle (#PCDATA)>",
+ )
+ .unwrap();
+
+ // Valid: with optional
+ let mut doc = make_doc(
+ "<!DOCTYPE doc>\
+ <doc><title>T</title><subtitle>S</subtitle></doc>",
+ );
+ assert!(validate(&mut doc, &dtd).is_valid);
+
+ // Valid: without optional
+ let mut doc = make_doc("<!DOCTYPE doc><doc><title>T</title></doc>");
+ assert!(validate(&mut doc, &dtd).is_valid);
+ }
+
+ #[test]
+ fn test_content_model_display() {
+ assert_eq!(ContentModel::Empty.to_string(), "EMPTY");
+ assert_eq!(ContentModel::Any.to_string(), "ANY");
+ assert_eq!(ContentModel::Mixed(vec![]).to_string(), "(#PCDATA)");
+ assert_eq!(
+ ContentModel::Mixed(vec!["a".to_string(), "b".to_string()]).to_string(),
+ "(#PCDATA|a|b)*"
+ );
+
+ let spec = ContentSpec {
+ kind: ContentSpecKind::Seq(vec![
+ ContentSpec {
+ kind: ContentSpecKind::Name("a".to_string()),
+ occurrence: Occurrence::Once,
+ },
+ ContentSpec {
+ kind: ContentSpecKind::Name("b".to_string()),
+ occurrence: Occurrence::ZeroOrMore,
+ },
+ ]),
+ occurrence: Occurrence::Once,
+ };
+ assert_eq!(ContentModel::Children(spec).to_string(), "(a , b*)");
+ }
+
+ #[test]
+ fn test_parse_attlist_idref_idrefs() {
+ let dtd = parse_dtd(
+ "<!ATTLIST link target IDREF #REQUIRED>\n\
+ <!ATTLIST group members IDREFS #REQUIRED>",
+ )
+ .unwrap();
+ let link_decls = dtd.attributes.get("link").unwrap();
+ assert_eq!(link_decls[0].attribute_type, AttributeType::IdRef);
+ let group_decls = dtd.attributes.get("group").unwrap();
+ assert_eq!(group_decls[0].attribute_type, AttributeType::IdRefs);
+ }
+
+ #[test]
+ fn test_validate_element_content_with_text() {
+ let dtd = parse_dtd("<!ELEMENT book (title)>\n<!ELEMENT title (#PCDATA)>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE book><book>stray text<title>T</title></book>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("element-only content model")
+ && e.message.contains("contains text")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_parse_entity_public() {
+ let dtd = parse_dtd("<!ENTITY logo PUBLIC \"-//LOGO//\" \"logo.png\">").unwrap();
+ let ent = dtd.entities.get("logo").unwrap();
+ match &ent.kind {
+ EntityKind::External {
+ system_id,
+ public_id,
+ } => {
+ assert_eq!(system_id, "logo.png");
+ assert_eq!(public_id.as_deref(), Some("-//LOGO//"));
+ }
+ EntityKind::Internal(val) => panic!("expected External, got Internal({val})"),
+ }
+ }
+
+ #[test]
+ fn test_parse_notation_public() {
+ let dtd = parse_dtd("<!NOTATION gif PUBLIC \"-//GIF//\">").unwrap();
+ let notation = dtd.notations.get("gif").unwrap();
+ assert_eq!(notation.public_id.as_deref(), Some("-//GIF//"));
+ assert_eq!(notation.system_id, None);
+ }
+
+ #[test]
+ fn test_parse_parameter_entity_skipped() {
+ // Parameter entities should be skipped without error
+ let dtd = parse_dtd(
+ "<!ENTITY % common \"(#PCDATA)\">\n\
+ <!ELEMENT root (#PCDATA)>",
+ )
+ .unwrap();
+ assert!(dtd.elements.contains_key("root"));
+ }
+
+ #[test]
+ fn test_validate_nmtoken_attribute() {
+ let dtd = parse_dtd(
+ "<!ELEMENT root (#PCDATA)>\n\
+ <!ATTLIST root token NMTOKEN #REQUIRED>",
+ )
+ .unwrap();
+
+ // Valid NMTOKEN
+ let mut doc = make_doc("<!DOCTYPE root><root token=\"abc-123\">text</root>");
+ assert!(validate(&mut doc, &dtd).is_valid);
+
+ // Invalid NMTOKEN (spaces not allowed)
+ let mut doc = make_doc("<!DOCTYPE root><root token=\"abc 123\">text</root>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid);
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("invalid NMTOKEN")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_populates_id_map() {
+ let dtd = parse_dtd(
+ "<!ELEMENT root (item*)>\n\
+ <!ELEMENT item (#PCDATA)>\n\
+ <!ATTLIST item id ID #REQUIRED>",
+ )
+ .unwrap();
+ let mut doc =
+ make_doc(r#"<!DOCTYPE root><root><item id="a">A</item><item id="b">B</item></root>"#);
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+
+ // The id_map should have been populated
+ let item_a = doc.element_by_id("a");
+ assert!(item_a.is_some(), "expected to find element with id='a'");
+ let item_b = doc.element_by_id("b");
+ assert!(item_b.is_some(), "expected to find element with id='b'");
+ assert_eq!(doc.element_by_id("c"), None);
+
+ // Verify the nodes are the correct elements
+ assert_eq!(doc.node_name(item_a.unwrap()), Some("item"));
+ assert_eq!(doc.node_name(item_b.unwrap()), Some("item"));
+ }
+
+ #[test]
+ fn test_content_model_deep_nesting_is_bounded() {
+ // Regression test for CVE-2026-61727 (GHSA-7jmw-29gc-ffx4): a content
+ // model with deeply nested '(' must return a normal error instead of
+ // recursing until the stack overflows.
+ let depth = (MAX_CONTENT_MODEL_DEPTH as usize) + 50;
+ let mut src = String::from("<!ELEMENT r ");
+ src.push_str(&"(".repeat(depth));
+ src.push('a');
+ src.push_str(&")".repeat(depth));
+ src.push('>');
+
+ let result = parse_dtd(&src);
+ let Err(err) = result else {
+ panic!("expected deep content model to be rejected, got Ok");
+ };
+ assert!(
+ err.message.contains("maximum depth"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_content_model_shallow_nesting_still_parses() {
+ // The depth bound must not affect ordinary, shallowly-nested models.
+ let dtd = parse_dtd("<!ELEMENT a (b,(c|d),e)>").unwrap();
+ assert!(dtd.elements.contains_key("a"));
+ }
+
+ // --- Entity recursion checks (WFC: No Recursion, XML 1.0 §4.1) ---
+
+ #[test]
+ fn test_entity_recursion_direct_cycle_rejected() {
+ let err = parse_dtd("<!ENTITY x \"&x;\">").unwrap_err();
+ assert!(
+ err.message.contains("recursive entity reference"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_entity_recursion_indirect_cycle_rejected() {
+ let err =
+ parse_dtd("<!ENTITY a \"&b;\"><!ENTITY b \"&c;\"><!ENTITY c \"&a;\">").unwrap_err();
+ assert!(
+ err.message.contains("recursive entity reference"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_entity_recursion_cycle_behind_safe_entity_rejected() {
+ // Regression test for the memoized walk (issue #42): `ok` is acyclic
+ // and shared by both cycle members. Marking `ok` as proven-safe must
+ // not mask the a<->b cycle behind it.
+ let err = parse_dtd(
+ "<!ENTITY ok \"text\">\
+ <!ENTITY a \"&ok;&b;\">\
+ <!ENTITY b \"&ok;&a;\">",
+ )
+ .unwrap_err();
+ assert!(
+ err.message.contains("recursive entity reference"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_entity_recursion_acyclic_diamond_accepted() {
+ // d is reachable through two paths (a->b->d and a->c->d) but there
+ // is no cycle; the memoized walk must accept this.
+ let dtd = parse_dtd(
+ "<!ENTITY d \"leaf\">\
+ <!ENTITY b \"&d;&d;\">\
+ <!ENTITY c \"&d;&d;\">\
+ <!ENTITY a \"&b;&c;\">",
+ )
+ .unwrap();
+ assert_eq!(dtd.entities.len(), 4);
+ }
+
+ #[test]
+ fn test_entity_recursion_deep_chain_is_linear() {
+ // Regression test for issue #42: each level references the previous
+ // entity 10 times. Without memoization the recursion check walks
+ // 10^30 paths and never finishes; with it, this parses instantly.
+ use std::fmt::Write as _;
+ let mut src = String::from("<!ENTITY a \"AAAA\">");
+ for i in 1..=30u32 {
+ let prev = if i == 1 {
+ "a".to_string()
+ } else {
+ format!("e{}", i - 1)
+ };
+ let refs = format!("&{prev};").repeat(10);
+ let _ = write!(src, "<!ENTITY e{i} \"{refs}\">");
+ }
+ let dtd = parse_dtd(&src).unwrap();
+ assert_eq!(dtd.entities.len(), 31);
+ }
+
+ #[test]
+ fn test_pe_recursion_direct_cycle_rejected() {
+ // %p; encoded as %p; inside the value (XML 1.0 §4.1).
+ let err = parse_dtd("<!ENTITY % p \"%p;\">").unwrap_err();
+ assert!(
+ err.message.contains("recursive parameter entity reference"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+
+ #[test]
+ fn test_pe_recursion_indirect_cycle_rejected() {
+ let err = parse_dtd("<!ENTITY % p \"%q;\"><!ENTITY % q \"%p;\">").unwrap_err();
+ assert!(
+ err.message.contains("recursive parameter entity reference"),
+ "unexpected error message: {}",
+ err.message
+ );
+ }
+
+ // --- Content-model validation through entity references (§4.4.3) ---
+
+ #[test]
+ fn test_validate_entity_supplied_child_matches_model() {
+ // The required <x> child arrives via an entity reference; the
+ // content model must see through the EntityRef node.
+ let dtd = parse_dtd("<!ELEMENT d (x)><!ELEMENT x (#PCDATA)>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE d [<!ENTITY e \"<x>hi</x>\">]><d>&e;</d>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+
+ #[test]
+ fn test_validate_entity_supplied_child_violates_model() {
+ // An entity-supplied element that violates the content model must
+ // still be reported.
+ let dtd =
+ parse_dtd("<!ELEMENT d (x)><!ELEMENT x (#PCDATA)><!ELEMENT y (#PCDATA)>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE d [<!ENTITY e \"<y>hi</y>\">]><d>&e;</d>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid, "expected content-model violation");
+ }
+
+ #[test]
+ fn test_validate_entity_supplied_element_content_checked() {
+ // Elements inside entity expansions are themselves validated: <x>
+ // is declared EMPTY but the entity gives it text content.
+ let dtd = parse_dtd("<!ELEMENT d (x)><!ELEMENT x EMPTY>").unwrap();
+ let mut doc = make_doc("<!DOCTYPE d [<!ENTITY e \"<x>hi</x>\">]><d>&e;</d>");
+ let result = validate(&mut doc, &dtd);
+ assert!(!result.is_valid, "expected EMPTY-content violation");
+ assert!(
+ result
+ .errors
+ .iter()
+ .any(|e| e.message.contains("EMPTY") && e.message.contains("has content")),
+ "errors: {:?}",
+ result.errors
+ );
+ }
+
+ #[test]
+ fn test_validate_mixed_content_through_entity() {
+ let dtd = parse_dtd("<!ELEMENT p (#PCDATA|em)*><!ELEMENT em (#PCDATA)>").unwrap();
+ let mut doc =
+ make_doc("<!DOCTYPE p [<!ENTITY e \"text <em>emph</em>\">]><p>before &e; after</p>");
+ let result = validate(&mut doc, &dtd);
+ assert!(result.is_valid, "errors: {:?}", result.errors);
+ }
+}
diff --git a/browser/vendor/xmloxide/src/validation/mod.rs b/browser/vendor/xmloxide/src/validation/mod.rs
new file mode 100644
index 000000000..49e4d29b6
--- /dev/null
+++ b/browser/vendor/xmloxide/src/validation/mod.rs
@@ -0,0 +1,143 @@
+//! Document validation framework.
+//!
+//! This module provides schema validation for XML documents. Each validator
+//! parses its schema format and checks document conformance, returning a
+//! `ValidationResult` with errors and warnings.
+//!
+//! # Architecture
+//!
+//! The validation module is organized into:
+//! - Common types (`ValidationResult`, `ValidationError`) used across all validators
+//! - DTD validation (`dtd` submodule) for XML 1.0 DTD processing
+//!
+//! This fork keeps only the DTD submodule (the XML parser depends on it);
+//! upstream's `RelaxNG`, XSD, and Schematron validators are trimmed away.
+
+pub mod dtd;
+
+use std::fmt;
+
+/// Result of validating a document against a schema (DTD, `RelaxNG`, XSD, etc.).
+///
+/// Contains the overall validity status plus any errors and warnings
+/// encountered during validation.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::validation::ValidationResult;
+///
+/// let result = ValidationResult {
+/// is_valid: true,
+/// errors: vec![],
+/// warnings: vec![],
+/// };
+/// assert!(result.is_valid);
+/// ```
+#[derive(Debug, Clone)]
+pub struct ValidationResult {
+ /// Whether the document is valid according to the schema.
+ pub is_valid: bool,
+ /// Validation errors (each one makes the document invalid).
+ pub errors: Vec<ValidationError>,
+ /// Validation warnings (informational, do not affect validity).
+ pub warnings: Vec<ValidationError>,
+}
+
+/// A validation error or warning with optional source location.
+///
+/// Carries a human-readable message and optional line/column information
+/// for pinpointing the issue in the source document.
+#[derive(Debug, Clone)]
+pub struct ValidationError {
+ /// Human-readable description of the validation issue.
+ pub message: String,
+ /// The 1-based line number where the issue was detected, if known.
+ pub line: Option<usize>,
+ /// The 1-based column number where the issue was detected, if known.
+ pub column: Option<usize>,
+}
+
+impl fmt::Display for ValidationError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match (self.line, self.column) {
+ (Some(line), Some(col)) => write!(f, "{}:{}: {}", line, col, self.message),
+ (Some(line), None) => write!(f, "line {}: {}", line, self.message),
+ _ => write!(f, "{}", self.message),
+ }
+ }
+}
+
+impl fmt::Display for ValidationResult {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if self.is_valid {
+ write!(f, "valid")?;
+ } else {
+ write!(f, "invalid ({} error(s))", self.errors.len())?;
+ }
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_validation_error_display_with_location() {
+ let err = ValidationError {
+ message: "missing required attribute".to_string(),
+ line: Some(5),
+ column: Some(10),
+ };
+ assert_eq!(err.to_string(), "5:10: missing required attribute");
+ }
+
+ #[test]
+ fn test_validation_error_display_line_only() {
+ let err = ValidationError {
+ message: "unexpected element".to_string(),
+ line: Some(3),
+ column: None,
+ };
+ assert_eq!(err.to_string(), "line 3: unexpected element");
+ }
+
+ #[test]
+ fn test_validation_error_display_no_location() {
+ let err = ValidationError {
+ message: "duplicate ID".to_string(),
+ line: None,
+ column: None,
+ };
+ assert_eq!(err.to_string(), "duplicate ID");
+ }
+
+ #[test]
+ fn test_validation_result_display() {
+ let valid = ValidationResult {
+ is_valid: true,
+ errors: vec![],
+ warnings: vec![],
+ };
+ assert_eq!(valid.to_string(), "valid");
+
+ let invalid = ValidationResult {
+ is_valid: false,
+ errors: vec![
+ ValidationError {
+ message: "error 1".to_string(),
+ line: None,
+ column: None,
+ },
+ ValidationError {
+ message: "error 2".to_string(),
+ line: None,
+ column: None,
+ },
+ ],
+ warnings: vec![],
+ };
+ assert_eq!(invalid.to_string(), "invalid (2 error(s))");
+ }
+}
diff --git a/browser/vendor/xmloxide/src/xpath/ast.rs b/browser/vendor/xmloxide/src/xpath/ast.rs
new file mode 100644
index 000000000..0c73233b0
--- /dev/null
+++ b/browser/vendor/xmloxide/src/xpath/ast.rs
@@ -0,0 +1,427 @@
+//! Abstract syntax tree types for `XPath` 1.0 expressions.
+//!
+//! This module defines the AST that results from parsing an `XPath` expression
+//! string. The AST closely follows the `XPath` 1.0 grammar from
+//! <https://www.w3.org/TR/xpath-10/#section-Basics>.
+//!
+//! The primary type is [`Expr`], which represents any `XPath` expression.
+//! Location paths are composed of [`Step`]s, each having an [`Axis`],
+//! a [`NodeTest`], and zero or more predicate expressions.
+
+/// An `XPath` 1.0 expression.
+///
+/// This enum represents the full range of `XPath` 1.0 expressions, including
+/// literals, operators, function calls, and location paths.
+///
+/// See `XPath` 1.0 section 3.
+#[derive(Debug, Clone)]
+pub enum Expr {
+ /// A numeric literal (e.g., `42`, `3.14`).
+ ///
+ /// See `XPath` 1.0 section 3.5.
+ Number(f64),
+
+ /// A string literal (e.g., `"hello"` or `'world'`).
+ ///
+ /// See `XPath` 1.0 section 3.5.
+ String(String),
+
+ /// A variable reference (e.g., `$foo`).
+ ///
+ /// The string contains the variable name without the leading `$`.
+ ///
+ /// See `XPath` 1.0 section 3.1.
+ Variable(String),
+
+ /// A binary operation (e.g., `a + b`, `x = y`, `p and q`).
+ ///
+ /// See `XPath` 1.0 sections 3.3, 3.4, 3.5.
+ BinaryOp {
+ /// The operator.
+ op: BinaryOp,
+ /// The left-hand operand.
+ left: Box<Expr>,
+ /// The right-hand operand.
+ right: Box<Expr>,
+ },
+
+ /// Unary negation (e.g., `-x`).
+ ///
+ /// See `XPath` 1.0 section 3.5.
+ UnaryNeg(Box<Expr>),
+
+ /// A function call (e.g., `contains(name, 'foo')`).
+ ///
+ /// See `XPath` 1.0 section 3.2.
+ FunctionCall {
+ /// The function name.
+ name: String,
+ /// The argument expressions.
+ args: Vec<Expr>,
+ },
+
+ /// A relative location path (e.g., `child::p/child::a`).
+ ///
+ /// See `XPath` 1.0 section 2.
+ Path {
+ /// The steps in the path, evaluated left to right.
+ steps: Vec<Step>,
+ },
+
+ /// An absolute location path (e.g., `/html/body`).
+ ///
+ /// An empty `steps` vector represents the bare `/` (root node).
+ ///
+ /// See `XPath` 1.0 section 2.
+ RootPath {
+ /// The steps following the initial `/`.
+ steps: Vec<Step>,
+ },
+
+ /// A filter expression with predicates (e.g., `$nodes[1]`).
+ ///
+ /// See `XPath` 1.0 section 3.3.
+ Filter {
+ /// The primary expression being filtered.
+ expr: Box<Expr>,
+ /// The predicate expressions.
+ predicates: Vec<Expr>,
+ },
+
+ /// A filter expression followed by a relative location path
+ /// (e.g., `(//a)[1]/@href` or `$nodes//b`).
+ ///
+ /// See `XPath` 1.0 section 3.3 (`PathExpr`).
+ FilterPath {
+ /// The filter expression producing the initial node-set.
+ expr: Box<Expr>,
+ /// The location path steps applied to that node-set.
+ steps: Vec<Step>,
+ },
+
+ /// A union of two node-sets (e.g., `a | b`).
+ ///
+ /// See `XPath` 1.0 section 3.3.
+ Union(Box<Expr>, Box<Expr>),
+}
+
+/// A binary operator in an `XPath` expression.
+///
+/// Covers arithmetic, comparison, and logical operators.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum BinaryOp {
+ /// Addition (`+`).
+ Add,
+ /// Subtraction (`-`).
+ Sub,
+ /// Multiplication (`*`).
+ Mul,
+ /// Division (`div`).
+ Div,
+ /// Modulo (`mod`).
+ Mod,
+ /// Equality (`=`).
+ Eq,
+ /// Inequality (`!=`).
+ Neq,
+ /// Less than (`<`).
+ Lt,
+ /// Less than or equal (`<=`).
+ Lte,
+ /// Greater than (`>`).
+ Gt,
+ /// Greater than or equal (`>=`).
+ Gte,
+ /// Logical and (`and`).
+ And,
+ /// Logical or (`or`).
+ Or,
+}
+
+/// A single step in a location path.
+///
+/// A step consists of an axis, a node test, and zero or more predicates.
+/// For example, in `child::p[@class='intro']`, the axis is `Child`,
+/// the node test is `Name("p")`, and there is one predicate.
+///
+/// See `XPath` 1.0 section 2.1.
+#[derive(Debug, Clone)]
+pub struct Step {
+ /// The axis along which to select nodes.
+ pub axis: Axis,
+ /// The test applied to each candidate node.
+ pub node_test: NodeTest,
+ /// Predicate expressions that further filter the selected nodes.
+ pub predicates: Vec<Expr>,
+}
+
+/// An `XPath` axis, specifying the direction of node selection.
+///
+/// `XPath` 1.0 defines 13 axes. See `XPath` 1.0 section 2.2.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Axis {
+ /// The `child` axis: direct children.
+ Child,
+ /// The `descendant` axis: all descendants (children, grandchildren, etc.).
+ Descendant,
+ /// The `parent` axis: the immediate parent.
+ Parent,
+ /// The `ancestor` axis: all ancestors up to and including the root.
+ Ancestor,
+ /// The `following-sibling` axis: siblings that come after this node.
+ FollowingSibling,
+ /// The `preceding-sibling` axis: siblings that come before this node.
+ PrecedingSibling,
+ /// The `following` axis: all nodes after this node in document order.
+ Following,
+ /// The `preceding` axis: all nodes before this node in document order.
+ Preceding,
+ /// The `attribute` axis: attributes of the context node.
+ Attribute,
+ /// The `namespace` axis: namespace nodes of the context node.
+ Namespace,
+ /// The `self` axis: just the context node itself.
+ Self_,
+ /// The `descendant-or-self` axis: the context node and its descendants.
+ DescendantOrSelf,
+ /// The `ancestor-or-self` axis: the context node and its ancestors.
+ AncestorOrSelf,
+}
+
+impl Axis {
+ /// Returns the axis name as it appears in `XPath` syntax.
+ ///
+ /// # Examples
+ ///
+ /// ```ignore
+ /// assert_eq!(Axis::Child.as_str(), "child");
+ /// assert_eq!(Axis::DescendantOrSelf.as_str(), "descendant-or-self");
+ /// ```
+ #[must_use]
+ pub fn as_str(self) -> &'static str {
+ match self {
+ Self::Child => "child",
+ Self::Descendant => "descendant",
+ Self::Parent => "parent",
+ Self::Ancestor => "ancestor",
+ Self::FollowingSibling => "following-sibling",
+ Self::PrecedingSibling => "preceding-sibling",
+ Self::Following => "following",
+ Self::Preceding => "preceding",
+ Self::Attribute => "attribute",
+ Self::Namespace => "namespace",
+ Self::Self_ => "self",
+ Self::DescendantOrSelf => "descendant-or-self",
+ Self::AncestorOrSelf => "ancestor-or-self",
+ }
+ }
+
+ /// Parses an axis name string into an `Axis` variant.
+ ///
+ /// Returns `None` if the string is not a recognized axis name.
+ #[must_use]
+ pub fn parse(s: &str) -> Option<Self> {
+ match s {
+ "child" => Some(Self::Child),
+ "descendant" => Some(Self::Descendant),
+ "parent" => Some(Self::Parent),
+ "ancestor" => Some(Self::Ancestor),
+ "following-sibling" => Some(Self::FollowingSibling),
+ "preceding-sibling" => Some(Self::PrecedingSibling),
+ "following" => Some(Self::Following),
+ "preceding" => Some(Self::Preceding),
+ "attribute" => Some(Self::Attribute),
+ "namespace" => Some(Self::Namespace),
+ "self" => Some(Self::Self_),
+ "descendant-or-self" => Some(Self::DescendantOrSelf),
+ "ancestor-or-self" => Some(Self::AncestorOrSelf),
+ _ => None,
+ }
+ }
+}
+
+impl std::fmt::Display for Axis {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str(self.as_str())
+ }
+}
+
+/// A node test in a location path step.
+///
+/// Node tests filter candidate nodes by name or kind.
+///
+/// See `XPath` 1.0 section 2.3.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NodeTest {
+ /// A name test matching a specific element or attribute name.
+ ///
+ /// The string may be an `NCName` or a `QName` (with prefix).
+ Name(String),
+
+ /// The `*` wildcard, matching any name.
+ Wildcard,
+
+ /// A prefixed wildcard like `prefix:*`, matching any local name in
+ /// the namespace bound to the given prefix.
+ PrefixWildcard(String),
+
+ /// The `node()` node type test, matching any node.
+ Node,
+
+ /// The `text()` node type test, matching text nodes.
+ Text,
+
+ /// The `comment()` node type test, matching comment nodes.
+ Comment,
+
+ /// The `processing-instruction()` node type test.
+ ///
+ /// When the optional string is `Some`, it matches only PIs with that target
+ /// name (e.g., `processing-instruction('xml-stylesheet')`).
+ ProcessingInstruction(Option<String>),
+}
+
+impl std::fmt::Display for NodeTest {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Name(name) => write!(f, "{name}"),
+ Self::Wildcard => f.write_str("*"),
+ Self::PrefixWildcard(prefix) => write!(f, "{prefix}:*"),
+ Self::Node => f.write_str("node()"),
+ Self::Text => f.write_str("text()"),
+ Self::Comment => f.write_str("comment()"),
+ Self::ProcessingInstruction(None) => f.write_str("processing-instruction()"),
+ Self::ProcessingInstruction(Some(name)) => {
+ write!(f, "processing-instruction('{name}')")
+ }
+ }
+ }
+}
+
+impl std::fmt::Display for BinaryOp {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::Add => f.write_str("+"),
+ Self::Sub => f.write_str("-"),
+ Self::Mul => f.write_str("*"),
+ Self::Div => f.write_str("div"),
+ Self::Mod => f.write_str("mod"),
+ Self::Eq => f.write_str("="),
+ Self::Neq => f.write_str("!="),
+ Self::Lt => f.write_str("<"),
+ Self::Lte => f.write_str("<="),
+ Self::Gt => f.write_str(">"),
+ Self::Gte => f.write_str(">="),
+ Self::And => f.write_str("and"),
+ Self::Or => f.write_str("or"),
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_axis_roundtrip() {
+ let axes = [
+ Axis::Child,
+ Axis::Descendant,
+ Axis::Parent,
+ Axis::Ancestor,
+ Axis::FollowingSibling,
+ Axis::PrecedingSibling,
+ Axis::Following,
+ Axis::Preceding,
+ Axis::Attribute,
+ Axis::Namespace,
+ Axis::Self_,
+ Axis::DescendantOrSelf,
+ Axis::AncestorOrSelf,
+ ];
+ for axis in axes {
+ let name = axis.as_str();
+ let parsed = Axis::parse(name);
+ assert_eq!(parsed, Some(axis), "roundtrip failed for {name}");
+ }
+ }
+
+ #[test]
+ fn test_axis_from_str_invalid() {
+ assert_eq!(Axis::parse("invalid"), None);
+ assert_eq!(Axis::parse(""), None);
+ assert_eq!(Axis::parse("children"), None);
+ }
+
+ #[test]
+ fn test_axis_display() {
+ assert_eq!(Axis::Child.to_string(), "child");
+ assert_eq!(Axis::DescendantOrSelf.to_string(), "descendant-or-self");
+ assert_eq!(Axis::AncestorOrSelf.to_string(), "ancestor-or-self");
+ assert_eq!(Axis::FollowingSibling.to_string(), "following-sibling");
+ }
+
+ #[test]
+ fn test_node_test_display() {
+ assert_eq!(NodeTest::Name("foo".to_string()).to_string(), "foo");
+ assert_eq!(NodeTest::Wildcard.to_string(), "*");
+ assert_eq!(
+ NodeTest::PrefixWildcard("svg".to_string()).to_string(),
+ "svg:*"
+ );
+ assert_eq!(NodeTest::Node.to_string(), "node()");
+ assert_eq!(NodeTest::Text.to_string(), "text()");
+ assert_eq!(NodeTest::Comment.to_string(), "comment()");
+ assert_eq!(
+ NodeTest::ProcessingInstruction(None).to_string(),
+ "processing-instruction()"
+ );
+ assert_eq!(
+ NodeTest::ProcessingInstruction(Some("xml-stylesheet".to_string())).to_string(),
+ "processing-instruction('xml-stylesheet')"
+ );
+ }
+
+ #[test]
+ fn test_binary_op_display() {
+ assert_eq!(BinaryOp::Add.to_string(), "+");
+ assert_eq!(BinaryOp::Sub.to_string(), "-");
+ assert_eq!(BinaryOp::Mul.to_string(), "*");
+ assert_eq!(BinaryOp::Div.to_string(), "div");
+ assert_eq!(BinaryOp::Mod.to_string(), "mod");
+ assert_eq!(BinaryOp::Eq.to_string(), "=");
+ assert_eq!(BinaryOp::Neq.to_string(), "!=");
+ assert_eq!(BinaryOp::Lt.to_string(), "<");
+ assert_eq!(BinaryOp::Lte.to_string(), "<=");
+ assert_eq!(BinaryOp::Gt.to_string(), ">");
+ assert_eq!(BinaryOp::Gte.to_string(), ">=");
+ assert_eq!(BinaryOp::And.to_string(), "and");
+ assert_eq!(BinaryOp::Or.to_string(), "or");
+ }
+
+ #[test]
+ fn test_expr_clone() {
+ let expr = Expr::BinaryOp {
+ op: BinaryOp::Add,
+ left: Box::new(Expr::Number(1.0)),
+ right: Box::new(Expr::Number(2.0)),
+ };
+ let cloned = expr.clone();
+ match cloned {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::Add),
+ _ => panic!("unexpected variant after clone"),
+ }
+ }
+
+ #[test]
+ fn test_step_construction() {
+ let step = Step {
+ axis: Axis::Child,
+ node_test: NodeTest::Name("p".to_string()),
+ predicates: vec![Expr::Number(1.0)],
+ };
+ assert_eq!(step.axis, Axis::Child);
+ assert_eq!(step.node_test, NodeTest::Name("p".to_string()));
+ assert_eq!(step.predicates.len(), 1);
+ }
+}
diff --git a/browser/vendor/xmloxide/src/xpath/eval.rs b/browser/vendor/xmloxide/src/xpath/eval.rs
new file mode 100644
index 000000000..1bec3236a
--- /dev/null
+++ b/browser/vendor/xmloxide/src/xpath/eval.rs
@@ -0,0 +1,3149 @@
+//! `XPath` 1.0 expression evaluator.
+//!
+//! This module implements the core evaluation engine for `XPath` 1.0 expressions
+//! as specified in <https://www.w3.org/TR/xpath-10/>. It walks an [`Expr`] AST
+//! (produced by [`super::parser::parse`]) and evaluates it against a
+//! [`Document`] tree, producing an [`XPathValue`].
+//!
+//! # Evaluation Context
+//!
+//! Per `XPath` 1.0 section 1, every expression is evaluated with respect to a
+//! **context** consisting of a context node, context position, context size,
+//! variable bindings, and a function library. The [`XPathContext`] struct holds
+//! all of these.
+//!
+//! # Location Paths
+//!
+//! The evaluator supports all 13 `XPath` axes, node test filtering, and
+//! predicate evaluation. Results are maintained in document order.
+//!
+//! # Functions
+//!
+//! All 27 core `XPath` 1.0 functions are implemented (node-set, string,
+//! boolean, and number function groups).
+
+use std::collections::{HashMap, HashSet};
+
+use super::ast::{Axis, BinaryOp, Expr, NodeTest, Step};
+use super::types::{XPathError, XPathNode};
+use crate::tree::{Attribute, Document, NodeId, NodeKind};
+
+/// Evaluation context for an `XPath` 1.0 expression.
+///
+/// Holds the document reference, the context node, context position and size,
+/// and variable bindings. Created via [`XPathContext::new`] and then used to
+/// evaluate parsed `XPath` expressions via [`XPathContext::evaluate`].
+///
+/// # Examples
+///
+/// ```ignore
+/// use xmloxide::xpath::eval::XPathContext;
+/// use xmloxide::xpath::parser::parse;
+/// use xmloxide::Document;
+///
+/// let doc = Document::parse_str("<root><a/><b/></root>").unwrap();
+/// let root = doc.root_element().unwrap();
+/// let expr = parse("count(*)").unwrap();
+/// let ctx = XPathContext::new(&doc, root);
+/// let result = ctx.evaluate(&expr).unwrap();
+/// ```
+pub struct XPathContext<'a> {
+ /// The document being queried.
+ doc: &'a Document,
+ /// The context node for expression evaluation (may be an attribute node
+ /// when evaluating predicates over attribute-axis results).
+ context_node: XPathNode,
+ /// 1-based position of the context node within its context node-set.
+ context_position: usize,
+ /// The size of the context node-set.
+ context_size: usize,
+ /// Variable bindings available during evaluation.
+ variables: HashMap<String, XPathValue>,
+ /// Namespace prefix → URI bindings for resolving prefixed name tests.
+ ///
+ /// When set (e.g., via Schematron `<sch:ns>` bindings), prefixed names
+ /// like `inv:invoice` in `XPath` expressions are matched by resolving
+ /// the prefix to a URI and comparing against the element's namespace URI
+ /// and local name.
+ namespaces: HashMap<String, String>,
+}
+
+/// An `XPath` 1.0 value.
+///
+/// Re-exported locally to keep the evaluator self-contained. This mirrors
+/// [`super::types::XPathValue`] but uses `String` payloads computed within
+/// the evaluator for node-set string-value access.
+pub use super::types::XPathValue;
+
+impl<'a> XPathContext<'a> {
+ /// Creates a new evaluation context rooted at `context_node`.
+ ///
+ /// The context position and size are both set to 1 (as if the context
+ /// node is the only member of a singleton node-set).
+ #[must_use]
+ pub fn new(doc: &'a Document, context_node: NodeId) -> Self {
+ Self::new_at(doc, XPathNode::Node(context_node))
+ }
+
+ /// Creates a new evaluation context at an arbitrary `XPath` node,
+ /// including an attribute node.
+ ///
+ /// Used when the context node comes from a previous `XPath` evaluation
+ /// (e.g., a Schematron rule whose context expression selects
+ /// attributes).
+ #[must_use]
+ pub fn new_at(doc: &'a Document, context_node: XPathNode) -> Self {
+ Self {
+ doc,
+ context_node,
+ context_position: 1,
+ context_size: 1,
+ variables: HashMap::new(),
+ namespaces: HashMap::new(),
+ }
+ }
+
+ /// Looks up an attribute node's underlying [`Attribute`] data.
+ fn attr(&self, owner: NodeId, index: u32) -> Option<&Attribute> {
+ self.doc.attributes(owner).get(index as usize)
+ }
+
+ /// Registers a namespace prefix → URI binding for name resolution.
+ ///
+ /// When evaluating `XPath` expressions containing prefixed name tests
+ /// (e.g., `//inv:invoice`), the prefix is resolved to a URI using these
+ /// bindings, and the element's namespace URI and local name are compared
+ /// instead of the raw `QName` string.
+ ///
+ /// This is used by Schematron validation to pass `<sch:ns>` bindings
+ /// to the `XPath` evaluator.
+ pub fn set_namespace(&mut self, prefix: &str, uri: &str) {
+ self.namespaces.insert(prefix.to_owned(), uri.to_owned());
+ }
+
+ /// Binds a variable name to a value in this context.
+ ///
+ /// Variable references in expressions (e.g., `$x`) will resolve to the
+ /// value set here.
+ pub fn set_variable(&mut self, name: &str, value: XPathValue) {
+ self.variables.insert(name.to_owned(), value);
+ }
+
+ /// Evaluates an `XPath` expression AST against this context.
+ ///
+ /// # Errors
+ ///
+ /// Returns [`XPathError`] if evaluation fails (e.g., undefined variable,
+ /// unknown function, type mismatch).
+ pub fn evaluate(&self, expr: &Expr) -> Result<XPathValue, XPathError> {
+ self.eval_expr(expr)
+ }
+
+ // -----------------------------------------------------------------------
+ // Internal expression dispatch
+ // -----------------------------------------------------------------------
+
+ fn eval_expr(&self, expr: &Expr) -> Result<XPathValue, XPathError> {
+ match expr {
+ Expr::Number(n) => Ok(XPathValue::Number(*n)),
+ Expr::String(s) => Ok(XPathValue::String(s.clone())),
+ Expr::Variable(name) => self.eval_variable(name),
+ Expr::BinaryOp { op, left, right } => self.eval_binary_op(*op, left, right),
+ Expr::UnaryNeg(inner) => self.eval_unary_neg(inner),
+ Expr::FunctionCall { name, args } => self.eval_function(name, args),
+ Expr::Path { steps } => self.eval_relative_path(steps),
+ Expr::RootPath { steps } => self.eval_root_path(steps),
+ Expr::Filter { expr, predicates } => self.eval_filter(expr, predicates),
+ Expr::FilterPath { expr, steps } => self.eval_filter_path(expr, steps),
+ Expr::Union(left, right) => self.eval_union(left, right),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Variable lookup
+ // -----------------------------------------------------------------------
+
+ fn eval_variable(&self, name: &str) -> Result<XPathValue, XPathError> {
+ self.variables
+ .get(name)
+ .cloned()
+ .ok_or_else(|| XPathError::UndefinedVariable {
+ name: name.to_owned(),
+ })
+ }
+
+ // -----------------------------------------------------------------------
+ // Binary operations
+ // -----------------------------------------------------------------------
+
+ fn eval_binary_op(
+ &self,
+ op: BinaryOp,
+ left: &Expr,
+ right: &Expr,
+ ) -> Result<XPathValue, XPathError> {
+ match op {
+ BinaryOp::And => {
+ let lv = self.eval_expr(left)?;
+ if !self.value_to_boolean(&lv) {
+ return Ok(XPathValue::Boolean(false));
+ }
+ let rv = self.eval_expr(right)?;
+ Ok(XPathValue::Boolean(self.value_to_boolean(&rv)))
+ }
+ BinaryOp::Or => {
+ let lv = self.eval_expr(left)?;
+ if self.value_to_boolean(&lv) {
+ return Ok(XPathValue::Boolean(true));
+ }
+ let rv = self.eval_expr(right)?;
+ Ok(XPathValue::Boolean(self.value_to_boolean(&rv)))
+ }
+ BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
+ let lv = self.eval_expr(left)?;
+ let rv = self.eval_expr(right)?;
+ let ln = self.value_to_number(&lv);
+ let rn = self.value_to_number(&rv);
+ let result = match op {
+ BinaryOp::Add => ln + rn,
+ BinaryOp::Sub => ln - rn,
+ BinaryOp::Mul => ln * rn,
+ BinaryOp::Div => ln / rn,
+ BinaryOp::Mod => ln % rn,
+ _ => unreachable!(),
+ };
+ Ok(XPathValue::Number(result))
+ }
+ BinaryOp::Eq | BinaryOp::Neq => {
+ let lv = self.eval_expr(left)?;
+ let rv = self.eval_expr(right)?;
+ Ok(XPathValue::Boolean(self.compare_equality(op, &lv, &rv)))
+ }
+ BinaryOp::Lt | BinaryOp::Lte | BinaryOp::Gt | BinaryOp::Gte => {
+ let lv = self.eval_expr(left)?;
+ let rv = self.eval_expr(right)?;
+ let result = self.compare_relational(op, &lv, &rv);
+ Ok(XPathValue::Boolean(result))
+ }
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Unary negation
+ // -----------------------------------------------------------------------
+
+ fn eval_unary_neg(&self, inner: &Expr) -> Result<XPathValue, XPathError> {
+ let val = self.eval_expr(inner)?;
+ Ok(XPathValue::Number(-self.value_to_number(&val)))
+ }
+
+ // -----------------------------------------------------------------------
+ // Location paths
+ // -----------------------------------------------------------------------
+
+ fn eval_relative_path(&self, steps: &[Step]) -> Result<XPathValue, XPathError> {
+ self.eval_steps_from(vec![self.context_node], steps)
+ }
+
+ /// Applies location path `steps` to an initial node-set.
+ ///
+ /// Shared by relative paths, absolute paths, and filter-path expressions
+ /// (e.g., `(//a)[1]/@href`). Handles the
+ /// `descendant-or-self::node()/child::X` fusion.
+ fn eval_steps_from(
+ &self,
+ mut nodes: Vec<XPathNode>,
+ steps: &[Step],
+ ) -> Result<XPathValue, XPathError> {
+ let mut i = 0;
+ while i < steps.len() {
+ let step = &steps[i];
+ // Optimization: fuse descendant-or-self::node()/child::X into
+ // descendant::X — avoids materializing the huge intermediate
+ // node-set that `//` produces.
+ if let Some(fused) = Self::try_fuse_descendant_child(steps, i) {
+ nodes = self.apply_step(&nodes, &fused)?;
+ i += 2; // skip both steps
+ } else {
+ nodes = self.apply_step(&nodes, step)?;
+ i += 1;
+ }
+ }
+ Ok(XPathValue::NodeSet(nodes))
+ }
+
+ /// Evaluates a filter expression followed by a relative location path,
+ /// e.g., `(//a)[1]/@href`: the filter yields a node-set, and the steps
+ /// are applied to it like any other location path continuation.
+ fn eval_filter_path(&self, expr: &Expr, steps: &[Step]) -> Result<XPathValue, XPathError> {
+ let val = self.eval_expr(expr)?;
+ let nodes = match val {
+ XPathValue::NodeSet(ns) => ns,
+ other => {
+ return Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ });
+ }
+ };
+ self.eval_steps_from(nodes, steps)
+ }
+
+ /// Tries to fuse `descendant-or-self::node()` + `child::X` at position `i`
+ /// into a single `descendant::X` step when the child step has no
+ /// predicates. Predicates must retain their per-parent proximity context,
+ /// so fusing `//*[1]` would be observably wrong.
+ fn try_fuse_descendant_child(steps: &[Step], i: usize) -> Option<Step> {
+ if i + 1 >= steps.len() {
+ return None;
+ }
+ let first = &steps[i];
+ let second = &steps[i + 1];
+ // Pattern: descendant-or-self::node() with no predicates,
+ // followed by child::X (with or without predicates).
+ if first.axis == Axis::DescendantOrSelf
+ && first.node_test == NodeTest::Node
+ && first.predicates.is_empty()
+ && second.axis == Axis::Child
+ && second.predicates.is_empty()
+ {
+ Some(Step {
+ axis: Axis::Descendant,
+ node_test: second.node_test.clone(),
+ predicates: second.predicates.clone(),
+ })
+ } else {
+ None
+ }
+ }
+
+ fn eval_root_path(&self, steps: &[Step]) -> Result<XPathValue, XPathError> {
+ self.eval_steps_from(vec![XPathNode::Node(self.doc.root())], steps)
+ }
+
+ /// Applies a single step to every node in `input`, producing a new node
+ /// set in document order with duplicates removed.
+ fn apply_step(&self, input: &[XPathNode], step: &Step) -> Result<Vec<XPathNode>, XPathError> {
+ let mut result: Vec<XPathNode> = Vec::new();
+
+ if step.predicates.is_empty() {
+ if input.len() == 1 {
+ // Fast path: single input node — no dedup needed.
+ self.expand_axis_filtered(input[0], step.axis, &step.node_test, &mut result);
+ } else {
+ // Multiple input nodes — need dedup via HashSet.
+ let mut seen = HashSet::new();
+ for &node in input {
+ self.expand_axis_filtered_dedup(
+ node,
+ step.axis,
+ &step.node_test,
+ &mut result,
+ &mut seen,
+ );
+ }
+ }
+ } else {
+ // Predicates filter the node-set generated for EACH context node
+ // separately, with proximity positions relative to that
+ // per-context set (XPath 1.0 §2.4/§3.3): //a/b[1] selects the
+ // first b of every a. The per-context results are then merged
+ // with duplicates removed.
+ let mut seen: HashSet<XPathNode> = HashSet::new();
+ for &node in input {
+ let mut per_node = Vec::new();
+ self.expand_axis_filtered(node, step.axis, &step.node_test, &mut per_node);
+ for pred in &step.predicates {
+ per_node = self.apply_predicate(&per_node, pred)?;
+ }
+ if input.len() == 1 {
+ result = per_node;
+ break;
+ }
+ for n in per_node {
+ if seen.insert(n) {
+ result.push(n);
+ }
+ }
+ }
+ }
+
+ // Each context node contributes a separately evaluated axis set. Their
+ // concatenation is not necessarily document ordered (notably the
+ // child step after `//`), while libxml returns node-sets in document
+ // order. Reverse-axis proximity was already applied above.
+ sort_document_order(&mut result);
+
+ Ok(result)
+ }
+
+ // -----------------------------------------------------------------------
+ // Fused axis expansion + node test filtering
+ // -----------------------------------------------------------------------
+
+ /// Expands axis from `node`, filters by `test`, and pushes matching nodes
+ /// directly into `result`. No intermediate Vec allocation.
+ #[allow(clippy::too_many_lines)]
+ fn expand_axis_filtered(
+ &self,
+ node: XPathNode,
+ axis: Axis,
+ test: &NodeTest,
+ result: &mut Vec<XPathNode>,
+ ) {
+ let node = match node {
+ XPathNode::Attribute { owner, index } => {
+ self.expand_axis_from_attribute(owner, index, axis, test, result);
+ return;
+ }
+ XPathNode::Node(id) => id,
+ };
+ if axis == Axis::Attribute {
+ self.push_matching_attributes(node, test, result);
+ return;
+ }
+ if axis == Axis::Namespace {
+ result.extend(
+ self.apply_namespace_node_test(node, test)
+ .into_iter()
+ .map(XPathNode::Node),
+ );
+ return;
+ }
+
+ // Fast path for Name test on element-scanning axes: inline the name
+ // check to avoid per-node function call overhead through
+ // node_matches_test. This is the hottest path for queries like
+ // //entry/title or /root/child.
+ //
+ // Only use the fast path when no namespace bindings are registered,
+ // because namespace-aware matching needs the full matches_element_name
+ // logic.
+ if let NodeTest::Name(name) = test {
+ if self.namespaces.is_empty() {
+ match axis {
+ Axis::Child => {
+ for child in self.doc.children(node) {
+ if let NodeKind::Element {
+ name: elem_name, ..
+ } = &self.doc.node(child).kind
+ {
+ if elem_name == name {
+ result.push(XPathNode::Node(child));
+ }
+ }
+ }
+ return;
+ }
+ Axis::Descendant => {
+ for desc in self.doc.descendants(node) {
+ if let NodeKind::Element {
+ name: elem_name, ..
+ } = &self.doc.node(desc).kind
+ {
+ if elem_name == name {
+ result.push(XPathNode::Node(desc));
+ }
+ }
+ }
+ return;
+ }
+ Axis::DescendantOrSelf => {
+ if let NodeKind::Element {
+ name: elem_name, ..
+ } = &self.doc.node(node).kind
+ {
+ if elem_name == name {
+ result.push(XPathNode::Node(node));
+ }
+ }
+ for desc in self.doc.descendants(node) {
+ if let NodeKind::Element {
+ name: elem_name, ..
+ } = &self.doc.node(desc).kind
+ {
+ if elem_name == name {
+ result.push(XPathNode::Node(desc));
+ }
+ }
+ }
+ return;
+ }
+ _ => {} // fall through to generic path
+ }
+ }
+ }
+
+ match axis {
+ Axis::Child => {
+ for child in self.doc.children(node) {
+ if self.node_matches_test(child, test, axis) {
+ result.push(XPathNode::Node(child));
+ }
+ }
+ }
+ Axis::Descendant => {
+ for desc in self.doc.descendants(node) {
+ if self.node_matches_test(desc, test, axis) {
+ result.push(XPathNode::Node(desc));
+ }
+ }
+ }
+ Axis::DescendantOrSelf => {
+ if self.node_matches_test(node, test, axis) {
+ result.push(XPathNode::Node(node));
+ }
+ for desc in self.doc.descendants(node) {
+ if self.node_matches_test(desc, test, axis) {
+ result.push(XPathNode::Node(desc));
+ }
+ }
+ }
+ Axis::Self_ => {
+ if self.node_matches_test(node, test, axis) {
+ result.push(XPathNode::Node(node));
+ }
+ }
+ Axis::Parent => {
+ if let Some(p) = self.doc.parent(node) {
+ if self.node_matches_test(p, test, axis) {
+ result.push(XPathNode::Node(p));
+ }
+ }
+ }
+ _ => {
+ // For less common axes, fall back to expand + filter
+ let axis_nodes = self.expand_axis(node, axis);
+ for id in axis_nodes {
+ if self.node_matches_test(id, test, axis) {
+ result.push(XPathNode::Node(id));
+ }
+ }
+ }
+ }
+ }
+
+ /// Like `expand_axis_filtered` but with deduplication via `seen` `HashSet`.
+ fn expand_axis_filtered_dedup(
+ &self,
+ node: XPathNode,
+ axis: Axis,
+ test: &NodeTest,
+ result: &mut Vec<XPathNode>,
+ seen: &mut HashSet<XPathNode>,
+ ) {
+ // Expand into a scratch vec, then dedup-push. Axis expansion from a
+ // single node never yields duplicates, so dedup is only needed
+ // across input nodes.
+ let mut scratch = Vec::new();
+ self.expand_axis_filtered(node, axis, test, &mut scratch);
+ for n in scratch {
+ if seen.insert(n) {
+ result.push(n);
+ }
+ }
+ }
+
+ /// Expands an axis from an attribute node (`XPath` 1.0 section 2.2):
+ /// the owner element is the attribute's parent, and attributes have no
+ /// children and are not siblings of any node.
+ fn expand_axis_from_attribute(
+ &self,
+ owner: NodeId,
+ index: u32,
+ axis: Axis,
+ test: &NodeTest,
+ result: &mut Vec<XPathNode>,
+ ) {
+ match axis {
+ Axis::Parent if self.node_matches_test(owner, test, axis) => {
+ result.push(XPathNode::Node(owner));
+ }
+ Axis::Ancestor => {
+ let mut current = Some(owner);
+ while let Some(n) = current {
+ if self.node_matches_test(n, test, axis) {
+ result.push(XPathNode::Node(n));
+ }
+ current = self.doc.parent(n);
+ }
+ }
+ Axis::Self_ | Axis::AncestorOrSelf | Axis::DescendantOrSelf => {
+ // The principal node type of these axes is element, so only
+ // node() matches the attribute itself (XPath 1.0 §2.3).
+ if *test == NodeTest::Node {
+ result.push(XPathNode::Attribute { owner, index });
+ }
+ if axis == Axis::AncestorOrSelf {
+ let mut current = Some(owner);
+ while let Some(n) = current {
+ if self.node_matches_test(n, test, axis) {
+ result.push(XPathNode::Node(n));
+ }
+ current = self.doc.parent(n);
+ }
+ }
+ }
+ Axis::Following => {
+ // libxml anchors an attribute's following axis after its
+ // owner element, excluding that owner's descendants.
+ for id in self.following_nodes(owner) {
+ if self.node_matches_test(id, test, axis) {
+ result.push(XPathNode::Node(id));
+ }
+ }
+ }
+ Axis::Preceding => {
+ for id in self.preceding_nodes(owner) {
+ if self.node_matches_test(id, test, axis) {
+ result.push(XPathNode::Node(id));
+ }
+ }
+ }
+ // Child, Descendant, Attribute, Namespace, FollowingSibling,
+ // PrecedingSibling: empty for attribute nodes.
+ _ => {}
+ }
+ }
+
+ /// Expands the attribute axis of an element: one entry per matching
+ /// attribute, in attribute-list order.
+ ///
+ /// Namespace declarations (`xmlns`, `xmlns:*`) are not attribute nodes
+ /// in the `XPath` 1.0 data model (section 5.3) and are skipped.
+ fn push_matching_attributes(
+ &self,
+ element: NodeId,
+ test: &NodeTest,
+ result: &mut Vec<XPathNode>,
+ ) {
+ for (i, attr) in self.doc.attributes(element).iter().enumerate() {
+ if attr.prefix.as_deref() == Some("xmlns")
+ || (attr.prefix.is_none() && attr.name == "xmlns")
+ {
+ continue;
+ }
+ let matches = match test {
+ NodeTest::Name(name) => self.attr_name_matches(attr, name),
+ NodeTest::Wildcard | NodeTest::Node => true,
+ NodeTest::PrefixWildcard(prefix) => {
+ if let Some(uri) = self.namespaces.get(prefix.as_str()) {
+ attr.namespace.as_deref() == Some(uri.as_str())
+ } else {
+ attr.prefix.as_deref() == Some(prefix.as_str())
+ }
+ }
+ _ => false,
+ };
+ if matches {
+ #[allow(clippy::cast_possible_truncation)]
+ result.push(XPathNode::Attribute {
+ owner: element,
+ index: i as u32,
+ });
+ }
+ }
+ }
+
+ /// Tests an attribute against a name test.
+ ///
+ /// A `prefix:local` test matches namespace-aware when the prefix is
+ /// registered via [`set_namespace`](Self::set_namespace), and by literal
+ /// prefix otherwise. An unprefixed test matches on the local name
+ /// (matching the evaluator's historical behavior for element names).
+ fn attr_name_matches(&self, attr: &Attribute, name: &str) -> bool {
+ if let Some(colon) = name.find(':') {
+ let prefix = &name[..colon];
+ let local = &name[colon + 1..];
+ if let Some(uri) = self.namespaces.get(prefix) {
+ return attr.namespace.as_deref() == Some(uri.as_str()) && attr.name == local;
+ }
+ return attr.prefix.as_deref() == Some(prefix) && attr.name == local;
+ }
+ attr.name == name
+ }
+
+ // -----------------------------------------------------------------------
+ // Axis expansion (for uncommon axes)
+ // -----------------------------------------------------------------------
+
+ /// Returns all candidate nodes along the given axis from `node`.
+ fn expand_axis(&self, node: NodeId, axis: Axis) -> Vec<NodeId> {
+ match axis {
+ Axis::Child => self.doc.children(node).collect(),
+ Axis::Descendant => self.doc.descendants(node).collect(),
+ Axis::Parent => self.doc.parent(node).into_iter().collect(),
+ Axis::Ancestor => {
+ let mut result = Vec::new();
+ let mut current = self.doc.parent(node);
+ while let Some(p) = current {
+ result.push(p);
+ current = self.doc.parent(p);
+ }
+ result
+ }
+ Axis::FollowingSibling => {
+ let mut result = Vec::new();
+ let mut current = self.doc.next_sibling(node);
+ while let Some(s) = current {
+ result.push(s);
+ current = self.doc.next_sibling(s);
+ }
+ result
+ }
+ Axis::PrecedingSibling => {
+ let mut result = Vec::new();
+ let mut current = self.doc.prev_sibling(node);
+ while let Some(s) = current {
+ result.push(s);
+ current = self.doc.prev_sibling(s);
+ }
+ result
+ }
+ Axis::Following => self.following_nodes(node),
+ Axis::Preceding => self.preceding_nodes(node),
+ Axis::Attribute => {
+ // Attributes are not tree nodes in our arena. We return an
+ // empty vec here; attribute axis handling is done via
+ // `apply_node_test` which inspects the element's attributes
+ // directly.
+ Vec::new()
+ }
+ Axis::Namespace => {
+ // Namespace axis handled via apply_namespace_node_test
+ // in the fused paths. Fallback here for completeness.
+ Vec::new()
+ }
+ Axis::Self_ => vec![node],
+ Axis::DescendantOrSelf => {
+ let mut result = vec![node];
+ result.extend(self.doc.descendants(node));
+ result
+ }
+ Axis::AncestorOrSelf => {
+ let mut result = vec![node];
+ let mut current = self.doc.parent(node);
+ while let Some(p) = current {
+ result.push(p);
+ current = self.doc.parent(p);
+ }
+ result
+ }
+ }
+ }
+
+ /// Returns all nodes after `node` in document order, excluding descendants.
+ fn following_nodes(&self, node: NodeId) -> Vec<NodeId> {
+ let mut result = Vec::new();
+ // First, try following siblings and their subtrees
+ let mut current = self.doc.next_sibling(node);
+ while let Some(s) = current {
+ result.push(s);
+ result.extend(self.doc.descendants(s));
+ current = self.doc.next_sibling(s);
+ }
+ // Then walk up ancestors and collect their following siblings
+ let mut ancestor = self.doc.parent(node);
+ while let Some(anc) = ancestor {
+ let mut sib = self.doc.next_sibling(anc);
+ while let Some(s) = sib {
+ result.push(s);
+ result.extend(self.doc.descendants(s));
+ sib = self.doc.next_sibling(s);
+ }
+ ancestor = self.doc.parent(anc);
+ }
+ result
+ }
+
+ /// Returns all nodes before `node` in document order, excluding ancestors.
+ fn preceding_nodes(&self, node: NodeId) -> Vec<NodeId> {
+ let mut result = Vec::new();
+ // Preceding siblings and their subtrees (in reverse document order)
+ let mut current = self.doc.prev_sibling(node);
+ while let Some(s) = current {
+ // Add descendants first (they come after `s` in document order)
+ let descs: Vec<NodeId> = self.doc.descendants(s).collect();
+ for &d in descs.iter().rev() {
+ result.push(d);
+ }
+ result.push(s);
+ current = self.doc.prev_sibling(s);
+ }
+ // Walk up ancestors and collect their preceding siblings
+ let mut ancestor = self.doc.parent(node);
+ while let Some(anc) = ancestor {
+ let mut sib = self.doc.prev_sibling(anc);
+ while let Some(s) = sib {
+ let descs: Vec<NodeId> = self.doc.descendants(s).collect();
+ for &d in descs.iter().rev() {
+ result.push(d);
+ }
+ result.push(s);
+ sib = self.doc.prev_sibling(s);
+ }
+ ancestor = self.doc.parent(anc);
+ }
+ result
+ }
+
+ // -----------------------------------------------------------------------
+ // Node test filtering
+ // -----------------------------------------------------------------------
+
+ /// Tests whether a name test matches an element, accounting for namespace
+ /// prefix bindings when available.
+ ///
+ /// When the name contains a colon and namespace bindings are registered,
+ /// splits the name into prefix + local, resolves the prefix to a URI,
+ /// and compares against the element's namespace URI and local name.
+ /// Otherwise, falls back to direct string comparison.
+ #[inline]
+ fn matches_element_name(&self, name: &str, elem: &NodeKind) -> bool {
+ if let NodeKind::Element {
+ name: elem_name,
+ namespace,
+ ..
+ } = elem
+ {
+ // If the XPath name has a prefix and we have namespace bindings,
+ // do namespace-aware matching.
+ if let Some(colon_pos) = name.find(':') {
+ if !self.namespaces.is_empty() {
+ let prefix = &name[..colon_pos];
+ let local = &name[colon_pos + 1..];
+ if let Some(uri) = self.namespaces.get(prefix) {
+ return namespace.as_deref() == Some(uri.as_str()) && elem_name == local;
+ }
+ }
+ }
+ // Default: direct string comparison (matches existing behavior)
+ elem_name == name
+ } else {
+ false
+ }
+ }
+
+ /// Checks whether a single node matches a node test for a given axis.
+ #[inline]
+ fn node_matches_test(&self, id: NodeId, test: &NodeTest, axis: Axis) -> bool {
+ let node = self.doc.node(id);
+ match test {
+ NodeTest::Name(name) => match &node.kind {
+ kind @ NodeKind::Element { .. } => self.matches_element_name(name, kind),
+ NodeKind::ProcessingInstruction { target, .. }
+ if axis == Axis::Child
+ || axis == Axis::Descendant
+ || axis == Axis::DescendantOrSelf =>
+ {
+ target == name
+ }
+ _ => false,
+ },
+ NodeTest::Wildcard => {
+ // Wildcard matches any element on most axes; on the attribute
+ // axis it matches any attribute (handled separately).
+ matches!(node.kind, NodeKind::Element { .. })
+ }
+ NodeTest::PrefixWildcard(prefix) => match &node.kind {
+ NodeKind::Element {
+ namespace,
+ prefix: elem_prefix,
+ ..
+ } => {
+ // If we have namespace bindings, resolve the prefix to a URI
+ // and match against the element's namespace.
+ if let Some(uri) = self.namespaces.get(prefix.as_str()) {
+ namespace.as_deref() == Some(uri.as_str())
+ } else {
+ elem_prefix.as_deref() == Some(prefix.as_str())
+ }
+ }
+ _ => false,
+ },
+ NodeTest::Node => true,
+ NodeTest::Text => matches!(node.kind, NodeKind::Text { .. } | NodeKind::CData { .. }),
+ NodeTest::Comment => matches!(node.kind, NodeKind::Comment { .. }),
+ NodeTest::ProcessingInstruction(opt_name) => match &node.kind {
+ NodeKind::ProcessingInstruction { target, .. } => opt_name
+ .as_ref()
+ .map_or(true, |expected| target == expected),
+ _ => false,
+ },
+ }
+ }
+
+ /// Handles the namespace axis: returns the element's `NodeId` if the
+ /// element has any in-scope namespace bindings that match `test`.
+ ///
+ /// Namespace nodes in `XPath` 1.0 (section 5.4) represent namespace
+ /// bindings in scope on an element. Each element has one namespace node
+ /// for every namespace prefix in scope, plus the implicit `xml` prefix.
+ ///
+ /// Since namespace nodes are not tree nodes in our arena, we follow the
+ /// same pattern as the attribute axis: return the element's own `NodeId`
+ /// when a match is found.
+ fn apply_namespace_node_test(&self, element: NodeId, test: &NodeTest) -> Vec<NodeId> {
+ if !matches!(self.doc.node(element).kind, NodeKind::Element { .. }) {
+ return Vec::new();
+ }
+
+ // Collect in-scope namespace prefixes by walking from the element up
+ // to the root, respecting the closest declaration for each prefix.
+ let mut ns_map: Vec<(Option<&str>, &str)> = Vec::new();
+ let mut seen_prefixes: HashSet<Option<&str>> = HashSet::new();
+
+ let mut current = Some(element);
+ while let Some(id) = current {
+ for attr in self.doc.attributes(id) {
+ if attr.name == "xmlns" && attr.prefix.is_none() {
+ // Default namespace declaration: xmlns="..."
+ if seen_prefixes.insert(None) && !attr.value.is_empty() {
+ ns_map.push((None, &attr.value));
+ }
+ } else if attr.prefix.as_deref() == Some("xmlns") {
+ // Prefixed namespace declaration: xmlns:prefix="..."
+ // The local name (attr.name) is the namespace prefix.
+ if seen_prefixes.insert(Some(attr.name.as_str())) {
+ ns_map.push((Some(attr.name.as_str()), &attr.value));
+ }
+ }
+ }
+ current = self.doc.parent(id);
+ }
+
+ // The xml prefix is always implicitly in scope.
+ if seen_prefixes.insert(Some("xml")) {
+ ns_map.push((Some("xml"), "http://www.w3.org/XML/1998/namespace"));
+ }
+
+ match test {
+ NodeTest::Name(name) => {
+ // Match a specific namespace prefix
+ let target: Option<&str> = if name.is_empty() {
+ None
+ } else {
+ Some(name.as_str())
+ };
+ if ns_map.iter().any(|(prefix, _)| *prefix == target) {
+ vec![element]
+ } else {
+ Vec::new()
+ }
+ }
+ NodeTest::Wildcard | NodeTest::Node => {
+ // Return the element once if any namespace bindings exist.
+ if ns_map.is_empty() {
+ Vec::new()
+ } else {
+ vec![element]
+ }
+ }
+ _ => Vec::new(),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Predicate evaluation
+ // -----------------------------------------------------------------------
+
+ /// Applies a predicate to a node set, filtering down to nodes where the
+ /// predicate is true.
+ ///
+ /// Per `XPath` 1.0 section 2.4, if the predicate evaluates to a number,
+ /// it is compared to the context position (positional predicate). Otherwise
+ /// it is converted to boolean.
+ fn apply_predicate(
+ &self,
+ nodes: &[XPathNode],
+ predicate: &Expr,
+ ) -> Result<Vec<XPathNode>, XPathError> {
+ let size = nodes.len();
+ let mut result = Vec::new();
+
+ // Fast path for positional predicates like [1], [last()], etc.
+ // If the predicate is a numeric literal, we can skip evaluating
+ // it for every node.
+ if let Expr::Number(n) = predicate {
+ // Convert float position to 1-based integer index.
+ // XPath positions are 1-based, so [1] means the first node.
+ let pos = *n;
+ if pos >= 1.0 && pos.fract() == 0.0 {
+ // Safe: we checked pos is a non-negative integer that fits in usize range.
+ // Node sets can never exceed u32::MAX nodes (arena limit), so no precision loss.
+ #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+ let idx = pos as usize - 1;
+ if let Some(&node) = nodes.get(idx) {
+ result.push(node);
+ }
+ }
+ return Ok(result);
+ }
+
+ for (i, &node) in nodes.iter().enumerate() {
+ let ctx = XPathContext {
+ doc: self.doc,
+ context_node: node,
+ context_position: i + 1, // 1-based
+ context_size: size,
+ // Share the variables reference — avoid cloning the HashMap.
+ // HashMap::new() doesn't allocate, so this is free when empty.
+ variables: if self.variables.is_empty() {
+ HashMap::new()
+ } else {
+ self.variables.clone()
+ },
+ namespaces: self.namespaces.clone(),
+ };
+ let val = ctx.eval_expr(predicate)?;
+ let keep = match &val {
+ XPathValue::Number(n) => {
+ // Positional predicate: [1] means first node
+ #[allow(clippy::float_cmp, clippy::cast_precision_loss)]
+ let pos_match = *n == (i + 1) as f64;
+ pos_match
+ }
+ _ => self.value_to_boolean(&val),
+ };
+ if keep {
+ result.push(node);
+ }
+ }
+
+ Ok(result)
+ }
+
+ // -----------------------------------------------------------------------
+ // Filter expressions
+ // -----------------------------------------------------------------------
+
+ fn eval_filter(&self, expr: &Expr, predicates: &[Expr]) -> Result<XPathValue, XPathError> {
+ let val = self.eval_expr(expr)?;
+ let mut nodes = match val {
+ XPathValue::NodeSet(ns) => ns,
+ other => {
+ return Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ });
+ }
+ };
+
+ for pred in predicates {
+ nodes = self.apply_predicate(&nodes, pred)?;
+ }
+
+ Ok(XPathValue::NodeSet(nodes))
+ }
+
+ // -----------------------------------------------------------------------
+ // Union
+ // -----------------------------------------------------------------------
+
+ fn eval_union(&self, left: &Expr, right: &Expr) -> Result<XPathValue, XPathError> {
+ let lv = self.eval_expr(left)?;
+ let rv = self.eval_expr(right)?;
+
+ let mut lnodes = match lv {
+ XPathValue::NodeSet(ns) => ns,
+ other => {
+ return Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ });
+ }
+ };
+ let rnodes = match rv {
+ XPathValue::NodeSet(ns) => ns,
+ other => {
+ return Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ });
+ }
+ };
+
+ // Merge, dedup, sort
+ let seen: HashSet<XPathNode> = lnodes.iter().copied().collect();
+ for id in rnodes {
+ if !seen.contains(&id) {
+ lnodes.push(id);
+ }
+ }
+ sort_document_order(&mut lnodes);
+
+ Ok(XPathValue::NodeSet(lnodes))
+ }
+
+ // -----------------------------------------------------------------------
+ // Function dispatch
+ // -----------------------------------------------------------------------
+
+ fn eval_function(&self, name: &str, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ match name {
+ // Node-set functions
+ "last" => self.fn_last(args),
+ "position" => self.fn_position(args),
+ "count" => self.fn_count(args),
+ "local-name" => self.fn_local_name(args),
+ "namespace-uri" => self.fn_namespace_uri(args),
+ "name" => self.fn_name(args),
+
+ // String functions
+ "string" => self.fn_string(args),
+ "concat" => self.fn_concat(args),
+ "starts-with" => self.fn_starts_with(args),
+ "contains" => self.fn_contains(args),
+ "substring-before" => self.fn_substring_before(args),
+ "substring-after" => self.fn_substring_after(args),
+ "substring" => self.fn_substring(args),
+ "string-length" => self.fn_string_length(args),
+ "normalize-space" => self.fn_normalize_space(args),
+ "translate" => self.fn_translate(args),
+
+ // Boolean functions
+ "boolean" => self.fn_boolean(args),
+ "not" => self.fn_not(args),
+ "true" => self.fn_true(args),
+ "false" => self.fn_false(args),
+ "lang" => self.fn_lang(args),
+
+ // Number functions
+ "number" => self.fn_number(args),
+ "sum" => self.fn_sum(args),
+ "floor" => self.fn_floor(args),
+ "ceiling" => self.fn_ceiling(args),
+ "round" => self.fn_round(args),
+
+ // id() - stub
+ "id" => self.fn_id(args),
+
+ // XPath 2.0 / XSD functions commonly used in Schematron
+ "matches" => self.fn_matches(args),
+ "replace" => self.fn_replace(args),
+ "tokenize" => self.fn_tokenize(args),
+
+ // XPath 2.0 string functions
+ "upper-case" => self.fn_upper_case(args),
+ "lower-case" => self.fn_lower_case(args),
+ "ends-with" => self.fn_ends_with(args),
+ "string-join" => self.fn_string_join(args),
+
+ // XPath 2.0 sequence/numeric functions
+ "empty" => self.fn_empty(args),
+ "exists" => self.fn_exists(args),
+ "abs" => self.fn_abs(args),
+ "min" => self.fn_min(args),
+ "max" => self.fn_max(args),
+ "reverse" => self.fn_reverse(args),
+
+ _ => Err(XPathError::UndefinedFunction {
+ name: name.to_owned(),
+ }),
+ }
+ }
+
+ // -- Node-set functions -------------------------------------------------
+
+ #[allow(clippy::cast_precision_loss)]
+ fn fn_last(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("last", args, 0)?;
+ Ok(XPathValue::Number(self.context_size as f64))
+ }
+
+ #[allow(clippy::cast_precision_loss)]
+ fn fn_position(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("position", args, 0)?;
+ Ok(XPathValue::Number(self.context_position as f64))
+ }
+
+ #[allow(clippy::cast_precision_loss)]
+ fn fn_count(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("count", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(ns) => Ok(XPathValue::Number(ns.len() as f64)),
+ other => Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ }),
+ }
+ }
+
+ fn fn_local_name(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() > 1 {
+ return Err(XPathError::InvalidArgCount {
+ function: "local-name".to_owned(),
+ expected: 1,
+ found: args.len(),
+ });
+ }
+ let node = if args.is_empty() {
+ self.context_node
+ } else {
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(ns) if !ns.is_empty() => ns[0],
+ XPathValue::NodeSet(_) => return Ok(XPathValue::String(String::new())),
+ other => {
+ return Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ });
+ }
+ }
+ };
+ if let XPathNode::Attribute { owner, index } = node {
+ let local = self.attr(owner, index).map(|a| a.name.clone());
+ return Ok(XPathValue::String(local.unwrap_or_default()));
+ }
+ let name = self.doc.node_name(node.anchor()).unwrap_or("");
+ // Strip prefix if present (local-name returns the part after ':')
+ let local = name.split(':').next_back().unwrap_or(name);
+ Ok(XPathValue::String(local.to_owned()))
+ }
+
+ fn fn_namespace_uri(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() > 1 {
+ return Err(XPathError::InvalidArgCount {
+ function: "namespace-uri".to_owned(),
+ expected: 1,
+ found: args.len(),
+ });
+ }
+ let node = if args.is_empty() {
+ self.context_node
+ } else {
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(ns) if !ns.is_empty() => ns[0],
+ XPathValue::NodeSet(_) => return Ok(XPathValue::String(String::new())),
+ other => {
+ return Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ });
+ }
+ }
+ };
+ if let XPathNode::Attribute { owner, index } = node {
+ let uri = self.attr(owner, index).and_then(|a| a.namespace.clone());
+ return Ok(XPathValue::String(uri.unwrap_or_default()));
+ }
+ let uri = self.doc.node_namespace(node.anchor()).unwrap_or("");
+ Ok(XPathValue::String(uri.to_owned()))
+ }
+
+ fn fn_name(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() > 1 {
+ return Err(XPathError::InvalidArgCount {
+ function: "name".to_owned(),
+ expected: 1,
+ found: args.len(),
+ });
+ }
+ let node = if args.is_empty() {
+ self.context_node
+ } else {
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(ns) if !ns.is_empty() => ns[0],
+ XPathValue::NodeSet(_) => return Ok(XPathValue::String(String::new())),
+ other => {
+ return Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ });
+ }
+ }
+ };
+ if let XPathNode::Attribute { owner, index } = node {
+ let qname = self.attr(owner, index).map(|a| match &a.prefix {
+ Some(prefix) => format!("{prefix}:{}", a.name),
+ None => a.name.clone(),
+ });
+ return Ok(XPathValue::String(qname.unwrap_or_default()));
+ }
+ let name = self.doc.node_name(node.anchor()).unwrap_or("");
+ Ok(XPathValue::String(name.to_owned()))
+ }
+
+ // -- String functions ---------------------------------------------------
+
+ fn fn_string(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() > 1 {
+ return Err(XPathError::InvalidArgCount {
+ function: "string".to_owned(),
+ expected: 1,
+ found: args.len(),
+ });
+ }
+ if args.is_empty() {
+ let sv = self.string_value(self.context_node);
+ return Ok(XPathValue::String(sv));
+ }
+ let val = self.eval_expr(&args[0])?;
+ Ok(XPathValue::String(self.value_to_string(&val)))
+ }
+
+ fn fn_concat(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() < 2 {
+ return Err(XPathError::InvalidArgCount {
+ function: "concat".to_owned(),
+ expected: 2,
+ found: args.len(),
+ });
+ }
+ let mut result = String::new();
+ for arg in args {
+ let val = self.eval_expr(arg)?;
+ result.push_str(&self.value_to_string(&val));
+ }
+ Ok(XPathValue::String(result))
+ }
+
+ fn fn_starts_with(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("starts-with", args, 2)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ let prefix = self.value_to_string(&self.eval_expr(&args[1])?);
+ Ok(XPathValue::Boolean(s.starts_with(prefix.as_str())))
+ }
+
+ fn fn_contains(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("contains", args, 2)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ let sub = self.value_to_string(&self.eval_expr(&args[1])?);
+ Ok(XPathValue::Boolean(s.contains(sub.as_str())))
+ }
+
+ fn fn_substring_before(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("substring-before", args, 2)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ let sub = self.value_to_string(&self.eval_expr(&args[1])?);
+ let result = s
+ .find(sub.as_str())
+ .map_or_else(String::new, |pos| s[..pos].to_owned());
+ Ok(XPathValue::String(result))
+ }
+
+ fn fn_substring_after(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("substring-after", args, 2)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ let sub = self.value_to_string(&self.eval_expr(&args[1])?);
+ let result = s
+ .find(sub.as_str())
+ .map_or_else(String::new, |pos| s[(pos + sub.len())..].to_owned());
+ Ok(XPathValue::String(result))
+ }
+
+ /// `XPath` `substring(string, number, number?)` per section 4.2.
+ ///
+ /// Uses `XPath` rounding: `round()` each numeric argument, 1-based indexing.
+ /// The substring starts at position `round(arg2)` and has length
+ /// `round(arg3)` if provided.
+ fn fn_substring(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() < 2 || args.len() > 3 {
+ return Err(XPathError::InvalidArgCount {
+ function: "substring".to_owned(),
+ expected: 2,
+ found: args.len(),
+ });
+ }
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ let pos = self.value_to_number(&self.eval_expr(&args[1])?);
+ let len = if args.len() == 3 {
+ Some(self.value_to_number(&self.eval_expr(&args[2])?))
+ } else {
+ None
+ };
+
+ // XPath substring is 1-based with special rounding rules
+ let rounded_pos = xpath_round(pos);
+ let chars: Vec<char> = s.chars().collect();
+ #[allow(clippy::cast_precision_loss)]
+ let str_len = chars.len() as f64;
+
+ // Compute start and end indices (1-based, may be NaN/Inf)
+ let start = rounded_pos;
+ let end = len.map_or(str_len + 1.0, |l| rounded_pos + xpath_round(l));
+
+ // Handle NaN: if start or end is NaN, return empty string
+ if start.is_nan() || end.is_nan() {
+ return Ok(XPathValue::String(String::new()));
+ }
+
+ #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+ let actual_start = (start - 1.0).max(0.0) as usize;
+ #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+ let actual_end = (end - 1.0).min(str_len).max(0.0) as usize;
+
+ if actual_start >= actual_end || actual_start >= chars.len() {
+ return Ok(XPathValue::String(String::new()));
+ }
+
+ let result: String = chars[actual_start..actual_end].iter().collect();
+ Ok(XPathValue::String(result))
+ }
+
+ fn fn_string_length(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() > 1 {
+ return Err(XPathError::InvalidArgCount {
+ function: "string-length".to_owned(),
+ expected: 1,
+ found: args.len(),
+ });
+ }
+ let s = if args.is_empty() {
+ self.string_value(self.context_node)
+ } else {
+ self.value_to_string(&self.eval_expr(&args[0])?)
+ };
+ #[allow(clippy::cast_precision_loss)]
+ let len = s.chars().count() as f64;
+ Ok(XPathValue::Number(len))
+ }
+
+ /// `normalize-space(string?)` per `XPath` 1.0 section 4.2.
+ ///
+ /// Strips leading and trailing whitespace and collapses sequences of
+ /// whitespace characters to a single space.
+ fn fn_normalize_space(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() > 1 {
+ return Err(XPathError::InvalidArgCount {
+ function: "normalize-space".to_owned(),
+ expected: 1,
+ found: args.len(),
+ });
+ }
+ let s = if args.is_empty() {
+ self.string_value(self.context_node)
+ } else {
+ self.value_to_string(&self.eval_expr(&args[0])?)
+ };
+ let normalized: String = s.split_whitespace().collect::<Vec<_>>().join(" ");
+ Ok(XPathValue::String(normalized))
+ }
+
+ /// `translate(string, string, string)` per `XPath` 1.0 section 4.2.
+ ///
+ /// Replaces characters in the first string that appear in the second string
+ /// with the corresponding character in the third string. Characters with no
+ /// corresponding replacement are removed.
+ fn fn_translate(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("translate", args, 3)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ let from = self.value_to_string(&self.eval_expr(&args[1])?);
+ let to = self.value_to_string(&self.eval_expr(&args[2])?);
+
+ let from_chars: Vec<char> = from.chars().collect();
+ let to_chars: Vec<char> = to.chars().collect();
+
+ let result: String = s
+ .chars()
+ .filter_map(|c| {
+ if let Some(pos) = from_chars.iter().position(|&fc| fc == c) {
+ to_chars.get(pos).copied()
+ } else {
+ Some(c)
+ }
+ })
+ .collect();
+ Ok(XPathValue::String(result))
+ }
+
+ // -- Boolean functions --------------------------------------------------
+
+ fn fn_boolean(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("boolean", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ Ok(XPathValue::Boolean(self.value_to_boolean(&val)))
+ }
+
+ fn fn_not(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("not", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ Ok(XPathValue::Boolean(!self.value_to_boolean(&val)))
+ }
+
+ #[allow(clippy::unused_self)]
+ fn fn_true(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("true", args, 0)?;
+ Ok(XPathValue::Boolean(true))
+ }
+
+ #[allow(clippy::unused_self)]
+ fn fn_false(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("false", args, 0)?;
+ Ok(XPathValue::Boolean(false))
+ }
+
+ fn fn_lang(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("lang", args, 1)?;
+ let target = self.value_to_string(&self.eval_expr(&args[0])?);
+ let target_lower = target.to_lowercase();
+
+ // Walk ancestors looking for xml:lang attribute
+ let mut node = Some(self.context_node.anchor());
+ while let Some(n) = node {
+ if let Some(lang) = self.doc.attribute(n, "xml:lang") {
+ let lang_lower = lang.to_lowercase();
+ if lang_lower == target_lower || lang_lower.starts_with(&format!("{target_lower}-"))
+ {
+ return Ok(XPathValue::Boolean(true));
+ }
+ return Ok(XPathValue::Boolean(false));
+ }
+ node = self.doc.parent(n);
+ }
+ Ok(XPathValue::Boolean(false))
+ }
+
+ // -- Number functions ---------------------------------------------------
+
+ fn fn_number(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() > 1 {
+ return Err(XPathError::InvalidArgCount {
+ function: "number".to_owned(),
+ expected: 1,
+ found: args.len(),
+ });
+ }
+ if args.is_empty() {
+ let sv = self.string_value(self.context_node);
+ return Ok(XPathValue::Number(parse_xpath_number(&sv)));
+ }
+ let val = self.eval_expr(&args[0])?;
+ Ok(XPathValue::Number(self.value_to_number(&val)))
+ }
+
+ fn fn_sum(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("sum", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(ns) => {
+ let total: f64 = ns
+ .iter()
+ .map(|&n| parse_xpath_number(&self.string_value(n)))
+ .sum();
+ Ok(XPathValue::Number(total))
+ }
+ other => Err(XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: other.type_name().to_owned(),
+ }),
+ }
+ }
+
+ fn fn_floor(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("floor", args, 1)?;
+ let n = self.value_to_number(&self.eval_expr(&args[0])?);
+ Ok(XPathValue::Number(n.floor()))
+ }
+
+ fn fn_ceiling(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("ceiling", args, 1)?;
+ let n = self.value_to_number(&self.eval_expr(&args[0])?);
+ Ok(XPathValue::Number(n.ceil()))
+ }
+
+ /// `round(number)` per `XPath` 1.0 section 4.4.
+ ///
+ /// Rounds to the nearest integer, with halfway cases going to positive
+ /// infinity (e.g., `round(0.5)` = 1, `round(-0.5)` = 0).
+ fn fn_round(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("round", args, 1)?;
+ let n = self.value_to_number(&self.eval_expr(&args[0])?);
+ Ok(XPathValue::Number(xpath_round(n)))
+ }
+
+ /// `id(object)` — selects elements by their ID attribute value.
+ ///
+ /// When the argument is a node-set, the string-value of each node is used
+ /// as a whitespace-separated list of IDs. When the argument is any other
+ /// type, it is converted to a string and treated as a whitespace-separated
+ /// list of IDs. Returns the elements whose ID matches, in document order.
+ ///
+ /// See `XPath` 1.0 section 4.1.
+ fn fn_id(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("id", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ let mut result = Vec::new();
+ let mut seen = HashSet::new();
+
+ let id_strings: Vec<String> = match &val {
+ XPathValue::NodeSet(nodes) => nodes.iter().map(|&n| self.string_value(n)).collect(),
+ other => vec![self.value_to_string(other)],
+ };
+
+ for id_str in &id_strings {
+ for token in id_str.split_whitespace() {
+ if let Some(node) = self.doc.element_by_id(token) {
+ if seen.insert(node) {
+ result.push(XPathNode::Node(node));
+ }
+ }
+ }
+ }
+
+ sort_document_order(&mut result);
+ Ok(XPathValue::NodeSet(result))
+ }
+
+ // -- XPath 2.0 functions (commonly used in Schematron) ------------------
+
+ /// `matches(string, pattern)` or `matches(string, pattern, flags)`.
+ ///
+ /// Returns true if the string matches the regular expression pattern.
+ /// See `XPath` 2.0 Functions and Operators section 7.6.2.
+ fn fn_matches(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() < 2 || args.len() > 3 {
+ return Err(XPathError::InvalidArgCount {
+ function: "matches".to_owned(),
+ expected: 2,
+ found: args.len(),
+ });
+ }
+ let input = self.value_to_string(&self.eval_expr(&args[0])?);
+ let pattern = self.value_to_string(&self.eval_expr(&args[1])?);
+ let flags = if args.len() == 3 {
+ self.value_to_string(&self.eval_expr(&args[2])?)
+ } else {
+ String::new()
+ };
+ match super::regex::xpath_matches(&input, &pattern, &flags) {
+ Ok(result) => Ok(XPathValue::Boolean(result)),
+ Err(e) => Err(XPathError::InternalError {
+ message: format!("regex error in matches(): {e}"),
+ }),
+ }
+ }
+
+ /// `replace(string, pattern, replacement)` or with flags.
+ ///
+ /// Replaces all matches of `pattern` in `string` with `replacement`.
+ /// See `XPath` 2.0 F&O section 7.6.3.
+ fn fn_replace(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.len() < 3 || args.len() > 4 {
+ return Err(XPathError::InvalidArgCount {
+ function: "replace".to_owned(),
+ expected: 3,
+ found: args.len(),
+ });
+ }
+ let input = self.value_to_string(&self.eval_expr(&args[0])?);
+ let pattern = self.value_to_string(&self.eval_expr(&args[1])?);
+ let replacement = self.value_to_string(&self.eval_expr(&args[2])?);
+ let flags = if args.len() == 4 {
+ self.value_to_string(&self.eval_expr(&args[3])?)
+ } else {
+ String::new()
+ };
+ match super::regex::xpath_replace(&input, &pattern, &replacement, &flags) {
+ Ok(result) => Ok(XPathValue::String(result)),
+ Err(e) => Err(XPathError::InternalError {
+ message: format!("regex error in replace(): {e}"),
+ }),
+ }
+ }
+
+ /// `tokenize(string, pattern)` or with flags.
+ ///
+ /// Splits `string` on occurrences of `pattern`.
+ /// See `XPath` 2.0 F&O section 7.6.4.
+ fn fn_tokenize(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.is_empty() || args.len() > 3 {
+ return Err(XPathError::InvalidArgCount {
+ function: "tokenize".to_owned(),
+ expected: 2,
+ found: args.len(),
+ });
+ }
+ let input = self.value_to_string(&self.eval_expr(&args[0])?);
+ let pattern = if args.len() >= 2 {
+ self.value_to_string(&self.eval_expr(&args[1])?)
+ } else {
+ r"\s+".to_string()
+ };
+ let flags = if args.len() == 3 {
+ self.value_to_string(&self.eval_expr(&args[2])?)
+ } else {
+ String::new()
+ };
+ match super::regex::xpath_tokenize(&input, &pattern, &flags) {
+ Ok(tokens) => {
+ // Return as a NodeSet-like structure. Since tokenize returns
+ // strings not nodes, return as a String (joining with space)
+ // for XPath 1.0 compatibility. In a full XPath 2.0 impl this
+ // would return a sequence of strings.
+ Ok(XPathValue::String(tokens.join(" ")))
+ }
+ Err(e) => Err(XPathError::InternalError {
+ message: format!("regex error in tokenize(): {e}"),
+ }),
+ }
+ }
+
+ // -- XPath 2.0 string functions -------------------------------------------
+
+ /// `upper-case(string)` — converts to uppercase.
+ fn fn_upper_case(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("upper-case", args, 1)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ Ok(XPathValue::String(s.to_uppercase()))
+ }
+
+ /// `lower-case(string)` — converts to lowercase.
+ fn fn_lower_case(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("lower-case", args, 1)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ Ok(XPathValue::String(s.to_lowercase()))
+ }
+
+ /// `ends-with(string, suffix)` — tests if string ends with suffix.
+ fn fn_ends_with(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("ends-with", args, 2)?;
+ let s = self.value_to_string(&self.eval_expr(&args[0])?);
+ let suffix = self.value_to_string(&self.eval_expr(&args[1])?);
+ Ok(XPathValue::Boolean(s.ends_with(&suffix)))
+ }
+
+ /// `string-join(sequence, separator)` — joins strings with a separator.
+ ///
+ /// In our `XPath` 1.0-based model, operates on a node-set by joining
+ /// each node's string value.
+ fn fn_string_join(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ if args.is_empty() || args.len() > 2 {
+ return Err(XPathError::InvalidArgCount {
+ function: "string-join".to_owned(),
+ expected: 2,
+ found: args.len(),
+ });
+ }
+ let val = self.eval_expr(&args[0])?;
+ let sep = if args.len() == 2 {
+ self.value_to_string(&self.eval_expr(&args[1])?)
+ } else {
+ String::new()
+ };
+ match &val {
+ XPathValue::NodeSet(nodes) => {
+ let strings: Vec<String> = nodes.iter().map(|&n| self.string_value(n)).collect();
+ Ok(XPathValue::String(strings.join(&sep)))
+ }
+ XPathValue::String(s) => Ok(XPathValue::String(s.clone())),
+ other => Ok(XPathValue::String(other.to_xpath_string())),
+ }
+ }
+
+ // -- XPath 2.0 sequence/boolean functions ---------------------------------
+
+ /// `empty(sequence)` — returns true if the node-set is empty.
+ fn fn_empty(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("empty", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(ns) => Ok(XPathValue::Boolean(ns.is_empty())),
+ XPathValue::String(s) => Ok(XPathValue::Boolean(s.is_empty())),
+ _ => Ok(XPathValue::Boolean(false)),
+ }
+ }
+
+ /// `exists(sequence)` — returns true if the node-set is non-empty.
+ fn fn_exists(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("exists", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(ns) => Ok(XPathValue::Boolean(!ns.is_empty())),
+ XPathValue::String(s) => Ok(XPathValue::Boolean(!s.is_empty())),
+ _ => Ok(XPathValue::Boolean(true)),
+ }
+ }
+
+ /// `abs(number)` — absolute value.
+ fn fn_abs(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("abs", args, 1)?;
+ let n = self.value_to_number(&self.eval_expr(&args[0])?);
+ Ok(XPathValue::Number(n.abs()))
+ }
+
+ /// `min(node-set)` — minimum numeric value of node string values.
+ fn fn_min(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("min", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(nodes) if nodes.is_empty() => Ok(XPathValue::Number(f64::NAN)),
+ XPathValue::NodeSet(nodes) => {
+ let mut min = f64::INFINITY;
+ for &n in nodes {
+ let v = parse_xpath_number(&self.string_value(n));
+ if v.is_nan() {
+ return Ok(XPathValue::Number(f64::NAN));
+ }
+ if v < min {
+ min = v;
+ }
+ }
+ Ok(XPathValue::Number(min))
+ }
+ other => Ok(XPathValue::Number(self.value_to_number(other))),
+ }
+ }
+
+ /// `max(node-set)` — maximum numeric value of node string values.
+ fn fn_max(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("max", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ match &val {
+ XPathValue::NodeSet(nodes) if nodes.is_empty() => Ok(XPathValue::Number(f64::NAN)),
+ XPathValue::NodeSet(nodes) => {
+ let mut max = f64::NEG_INFINITY;
+ for &n in nodes {
+ let v = parse_xpath_number(&self.string_value(n));
+ if v.is_nan() {
+ return Ok(XPathValue::Number(f64::NAN));
+ }
+ if v > max {
+ max = v;
+ }
+ }
+ Ok(XPathValue::Number(max))
+ }
+ other => Ok(XPathValue::Number(self.value_to_number(other))),
+ }
+ }
+
+ /// `reverse(node-set)` — returns the node-set in reverse document order.
+ fn fn_reverse(&self, args: &[Expr]) -> Result<XPathValue, XPathError> {
+ check_arg_count("reverse", args, 1)?;
+ let val = self.eval_expr(&args[0])?;
+ match val {
+ XPathValue::NodeSet(mut nodes) => {
+ nodes.reverse();
+ Ok(XPathValue::NodeSet(nodes))
+ }
+ other => Ok(other),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Type conversion helpers (with document access)
+ // -----------------------------------------------------------------------
+
+ /// Converts a value to boolean per `XPath` 1.0 section 4.3.
+ #[allow(clippy::unused_self)]
+ fn value_to_boolean(&self, val: &XPathValue) -> bool {
+ val.to_boolean()
+ }
+
+ /// Converts a value to number per `XPath` 1.0 section 4.4.
+ ///
+ /// For node-sets, computes the string-value of the first node first.
+ fn value_to_number(&self, val: &XPathValue) -> f64 {
+ match val {
+ XPathValue::NodeSet(ns) => {
+ if ns.is_empty() {
+ f64::NAN
+ } else {
+ let sv = self.string_value(ns[0]);
+ parse_xpath_number(&sv)
+ }
+ }
+ _ => val.to_number(),
+ }
+ }
+
+ /// Converts a value to string per `XPath` 1.0 section 4.2.
+ ///
+ /// For node-sets, computes the string-value of the first node in document
+ /// order.
+ fn value_to_string(&self, val: &XPathValue) -> String {
+ match val {
+ XPathValue::NodeSet(ns) => {
+ if ns.is_empty() {
+ String::new()
+ } else {
+ self.string_value(ns[0])
+ }
+ }
+ _ => val.to_xpath_string(),
+ }
+ }
+
+ /// Computes the string-value of a node per `XPath` 1.0 section 5.
+ ///
+ /// - Root / Element: concatenation of all descendant text nodes
+ /// - Attribute: the attribute value
+ /// - Text / CDATA: the text content
+ /// - Comment: the comment text
+ /// - PI: the PI data
+ fn string_value(&self, node: XPathNode) -> String {
+ let node = match node {
+ XPathNode::Attribute { owner, index } => {
+ return self
+ .attr(owner, index)
+ .map(|a| a.value.clone())
+ .unwrap_or_default();
+ }
+ XPathNode::Node(id) => id,
+ };
+ let kind = &self.doc.node(node).kind;
+ match kind {
+ // EntityRef: the expansion lives in the node's children, so the
+ // string-value is the same concatenation of descendant text.
+ NodeKind::Document | NodeKind::Element { .. } | NodeKind::EntityRef { .. } => {
+ self.doc.text_content(node)
+ }
+ NodeKind::Text { content }
+ | NodeKind::CData { content }
+ | NodeKind::Comment { content } => content.clone(),
+ NodeKind::ProcessingInstruction { data, .. } => {
+ data.as_deref().unwrap_or("").to_owned()
+ }
+ NodeKind::DocumentType { .. } => String::new(),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Comparison helpers
+ // -----------------------------------------------------------------------
+
+ /// Compares two values with `=` or `!=` per `XPath` 1.0 section 3.4.
+ ///
+ /// When either operand is a node-set (and the other is not a boolean),
+ /// both operators are existential: the result is true iff *some* node
+ /// satisfies the predicate. `!=` is therefore **not** the negation of
+ /// `=` — an empty node-set compares false under both operators, and a
+ /// multi-node set can satisfy both at once. A node-set compared against
+ /// a boolean is converted to a boolean first, and scalar operands are
+ /// compared directly.
+ #[allow(clippy::float_cmp)]
+ fn compare_equality(&self, op: BinaryOp, lhs: &XPathValue, rhs: &XPathValue) -> bool {
+ let ne = op == BinaryOp::Neq;
+ let str_cmp = |a: &str, b: &str| (a == b) != ne;
+ let num_cmp = |a: f64, b: f64| (a == b) != ne;
+ let bool_cmp = |a: bool, b: bool| (a == b) != ne;
+ match (lhs, rhs) {
+ // node-set = node-set
+ (XPathValue::NodeSet(lns), XPathValue::NodeSet(rns)) => {
+ for &ln in lns {
+ let lsv = self.string_value(ln);
+ for &rn in rns {
+ let rsv = self.string_value(rn);
+ if str_cmp(&lsv, &rsv) {
+ return true;
+ }
+ }
+ }
+ false
+ }
+ // node-set = boolean
+ (XPathValue::NodeSet(ns), XPathValue::Boolean(b))
+ | (XPathValue::Boolean(b), XPathValue::NodeSet(ns)) => bool_cmp(!ns.is_empty(), *b),
+ // node-set = number
+ (XPathValue::NodeSet(ns), XPathValue::Number(n))
+ | (XPathValue::Number(n), XPathValue::NodeSet(ns)) => ns
+ .iter()
+ .any(|&node| num_cmp(parse_xpath_number(&self.string_value(node)), *n)),
+ // node-set = string
+ (XPathValue::NodeSet(ns), XPathValue::String(s))
+ | (XPathValue::String(s), XPathValue::NodeSet(ns)) => {
+ ns.iter().any(|&node| str_cmp(&self.string_value(node), s))
+ }
+ // Both booleans
+ (XPathValue::Boolean(a), XPathValue::Boolean(b)) => bool_cmp(*a, *b),
+ // If either is boolean, convert both to boolean
+ (XPathValue::Boolean(_), _) | (_, XPathValue::Boolean(_)) => {
+ bool_cmp(lhs.to_boolean(), rhs.to_boolean())
+ }
+ // If either is number, convert both to number
+ (XPathValue::Number(a), XPathValue::Number(b)) => num_cmp(*a, *b),
+ (XPathValue::Number(_), _) | (_, XPathValue::Number(_)) => {
+ num_cmp(self.value_to_number(lhs), self.value_to_number(rhs))
+ }
+ // Otherwise compare as strings
+ _ => str_cmp(&self.value_to_string(lhs), &self.value_to_string(rhs)),
+ }
+ }
+
+ /// Compares two values relationally per `XPath` 1.0 section 3.4.
+ fn compare_relational(&self, op: BinaryOp, lhs: &XPathValue, rhs: &XPathValue) -> bool {
+ let cmp = |a: f64, b: f64| -> bool {
+ match op {
+ BinaryOp::Lt => a < b,
+ BinaryOp::Lte => a <= b,
+ BinaryOp::Gt => a > b,
+ BinaryOp::Gte => a >= b,
+ _ => false,
+ }
+ };
+
+ match (lhs, rhs) {
+ // node-set <op> node-set
+ (XPathValue::NodeSet(lns), XPathValue::NodeSet(rns)) => {
+ for &ln in lns {
+ let lv = parse_xpath_number(&self.string_value(ln));
+ for &rn in rns {
+ let rv = parse_xpath_number(&self.string_value(rn));
+ if cmp(lv, rv) {
+ return true;
+ }
+ }
+ }
+ false
+ }
+ // node-set <op> number
+ (XPathValue::NodeSet(ns), XPathValue::Number(n)) => ns
+ .iter()
+ .any(|&node| cmp(parse_xpath_number(&self.string_value(node)), *n)),
+ (XPathValue::Number(n), XPathValue::NodeSet(ns)) => ns
+ .iter()
+ .any(|&node| cmp(*n, parse_xpath_number(&self.string_value(node)))),
+ // node-set <op> string
+ (XPathValue::NodeSet(ns), XPathValue::String(s)) => {
+ let rn = parse_xpath_number(s);
+ ns.iter()
+ .any(|&node| cmp(parse_xpath_number(&self.string_value(node)), rn))
+ }
+ (XPathValue::String(s), XPathValue::NodeSet(ns)) => {
+ let ln = parse_xpath_number(s);
+ ns.iter()
+ .any(|&node| cmp(ln, parse_xpath_number(&self.string_value(node))))
+ }
+ // node-set <op> boolean -- convert node-set to boolean, then to number
+ (XPathValue::NodeSet(ns), _) => {
+ let lv = if ns.is_empty() { 0.0 } else { 1.0 };
+ let rv = self.value_to_number(rhs);
+ cmp(lv, rv)
+ }
+ (_, XPathValue::NodeSet(ns)) => {
+ let lv = self.value_to_number(lhs);
+ let rv = if ns.is_empty() { 0.0 } else { 1.0 };
+ cmp(lv, rv)
+ }
+ // Otherwise compare as numbers
+ _ => cmp(self.value_to_number(lhs), self.value_to_number(rhs)),
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Helper functions
+// ---------------------------------------------------------------------------
+
+/// Sorts a node-set into document order using the arena index as a proxy.
+///
+/// Since nodes are allocated in document order during parsing, the arena
+/// index (encoded in `NodeId`) directly reflects document order; attribute
+/// nodes sort just after their owner element, by attribute index.
+fn sort_document_order(nodes: &mut [XPathNode]) {
+ nodes.sort_unstable();
+}
+
+/// Rounds a number using `XPath` rounding rules: round half toward positive
+/// infinity.
+///
+/// Per `XPath` 1.0 section 4.4: `round(-0.5)` = 0, `round(0.5)` = 1.
+fn xpath_round(n: f64) -> f64 {
+ if n.is_nan() || n.is_infinite() {
+ return n;
+ }
+ // XPath round: round half toward positive infinity
+ // This is equivalent to floor(n + 0.5)
+ (n + 0.5).floor()
+}
+
+/// Parses a string into an `XPath` number per section 4.4.
+fn parse_xpath_number(s: &str) -> f64 {
+ let trimmed = s.trim();
+ if trimmed.is_empty() {
+ return f64::NAN;
+ }
+ trimmed.parse::<f64>().unwrap_or(f64::NAN)
+}
+
+/// Checks that a function was called with the expected number of arguments.
+fn check_arg_count(name: &str, args: &[Expr], expected: usize) -> Result<(), XPathError> {
+ if args.len() != expected {
+ return Err(XPathError::InvalidArgCount {
+ function: name.to_owned(),
+ expected,
+ found: args.len(),
+ });
+ }
+ Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+#[allow(clippy::float_cmp, clippy::unwrap_used)]
+mod tests {
+ use super::*;
+ use crate::xpath::parser::parse;
+
+ /// Helper: parse XML, get root element, evaluate `XPath` expression.
+ fn eval_xpath(xml: &str, xpath: &str) -> XPathValue {
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+ let expr = parse(xpath).unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ ctx.evaluate(&expr).unwrap()
+ }
+
+ /// Helper: evaluate `XPath` from the document root (not the root element).
+ fn eval_xpath_from_doc_root(xml: &str, xpath: &str) -> XPathValue {
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root();
+ let expr = parse(xpath).unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ ctx.evaluate(&expr).unwrap()
+ }
+
+ /// Helper: evaluate and return the count of nodes in a node-set.
+ fn eval_count(xml: &str, xpath: &str) -> usize {
+ match eval_xpath(xml, xpath) {
+ XPathValue::NodeSet(ns) => ns.len(),
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ // -- Arithmetic ---------------------------------------------------------
+
+ #[test]
+ fn test_arithmetic_add() {
+ let result = eval_xpath("<r/>", "1 + 2");
+ assert_eq!(result, XPathValue::Number(3.0));
+ }
+
+ #[test]
+ fn test_arithmetic_multiply() {
+ let result = eval_xpath("<r/>", "3 * 4");
+ assert_eq!(result, XPathValue::Number(12.0));
+ }
+
+ #[test]
+ fn test_arithmetic_div() {
+ let result = eval_xpath("<r/>", "10 div 3");
+ match result {
+ XPathValue::Number(n) => assert!((n - 10.0 / 3.0).abs() < 1e-10),
+ _ => panic!("expected number"),
+ }
+ }
+
+ #[test]
+ fn test_arithmetic_mod() {
+ let result = eval_xpath("<r/>", "10 mod 3");
+ assert_eq!(result, XPathValue::Number(1.0));
+ }
+
+ #[test]
+ fn test_arithmetic_sub() {
+ let result = eval_xpath("<r/>", "5 - 3");
+ assert_eq!(result, XPathValue::Number(2.0));
+ }
+
+ // -- Comparisons --------------------------------------------------------
+
+ #[test]
+ fn test_comparison_eq() {
+ let result = eval_xpath("<r/>", "1 = 1");
+ assert_eq!(result, XPathValue::Boolean(true));
+
+ let result = eval_xpath("<r/>", "1 = 2");
+ assert_eq!(result, XPathValue::Boolean(false));
+ }
+
+ #[test]
+ fn test_comparison_neq() {
+ let result = eval_xpath("<r/>", "'a' != 'b'");
+ assert_eq!(result, XPathValue::Boolean(true));
+
+ let result = eval_xpath("<r/>", "'a' != 'a'");
+ assert_eq!(result, XPathValue::Boolean(false));
+ }
+
+ // Regression tests for issue #44: with a node-set operand, `!=` is its
+ // own existential test (XPath 1.0 §3.4), not the negation of `=`.
+ const NEQ_DOC: &str =
+ "<r><a x='1'>one</a><a x='2'>two</a><g><b>p</b><b>q</b></g><h><b>p</b><b>p</b></h></r>";
+
+ #[test]
+ fn test_neq_empty_nodeset_is_false() {
+ // An empty node-set satisfies neither `=` nor `!=`.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere != 'x'"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere != 1"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere != //a"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere != //nothere"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere = 'x'"),
+ XPathValue::Boolean(false)
+ );
+ }
+
+ #[test]
+ fn test_neq_nodeset_string_existential() {
+ // The node "one" makes `//a != 'two'` true, while the node "two"
+ // makes `//a = 'two'` true as well: both hold simultaneously.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//a != 'two'"),
+ XPathValue::Boolean(true)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//a = 'two'"),
+ XPathValue::Boolean(true)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//a = 'two' and //a != 'two'"),
+ XPathValue::Boolean(true)
+ );
+ // Single-node sets behave like scalars.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//g/b[1] != 'p'"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//g/b[2] != 'p'"),
+ XPathValue::Boolean(true)
+ );
+ }
+
+ #[test]
+ fn test_neq_attribute_nodeset_number() {
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//a/@x != 1"),
+ XPathValue::Boolean(true)
+ );
+ assert_eq!(eval_xpath(NEQ_DOC, "//a/@x = 1"), XPathValue::Boolean(true));
+ }
+
+ #[test]
+ fn test_neq_absent_attribute_is_false() {
+ // An attribute step matching nothing is an EMPTY node-set, so both
+ // `=` and `!=` are false — not a String("") sentinel that would
+ // make `!=` true through the scalar branch.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//g/@missing != 'v'"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//g/@missing = 'v'"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//g/@missing != 5"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere/@x != 'v'"),
+ XPathValue::Boolean(false)
+ );
+ // A predicate on a missing attribute selects nothing.
+ assert_eq!(eval_count(NEQ_DOC, "//*[@missing != 'v']"), 0);
+ // string() of an absent attribute is still the empty string.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "string(//g/@missing)"),
+ XPathValue::String(String::new())
+ );
+ }
+
+ // -- First-class attribute nodes (issue #47) ----------------------------
+
+ #[test]
+ fn test_attr_vs_attr_comparison_not_clobbered() {
+ // Two attribute node-sets in one comparison must each keep their own
+ // values: x = {1,2}, y = {3,3} has an unequal pair, so != is true.
+ let xml = "<r><a x='1' y='3'/><a x='2' y='3'/></r>";
+ assert_eq!(
+ eval_xpath(xml, "//a/@x != //a/@y"),
+ XPathValue::Boolean(true)
+ );
+ // x = {1,3}, y = {2,4} share no value, so = is false.
+ let xml2 = "<r><a x='1' y='2'/><a x='3' y='4'/></r>";
+ assert_eq!(
+ eval_xpath(xml2, "//a/@x = //a/@y"),
+ XPathValue::Boolean(false)
+ );
+ // And a genuinely shared value makes = true.
+ let xml3 = "<r><a x='1' y='2'/><a x='3' y='1'/></r>";
+ assert_eq!(
+ eval_xpath(xml3, "//a/@x = //a/@y"),
+ XPathValue::Boolean(true)
+ );
+ }
+
+ #[test]
+ fn test_count_single_attribute_filter_path() {
+ // A single-match attribute step is a node-set of one attribute node,
+ // usable in node-set contexts like count().
+ let xml = "<r><a href='u1'/><a/></r>";
+ assert_eq!(
+ eval_xpath(xml, "count((//a)[1]/@href)"),
+ XPathValue::Number(1.0)
+ );
+ assert_eq!(eval_xpath(xml, "count(//a/@href)"), XPathValue::Number(1.0));
+ }
+
+ #[test]
+ fn test_attribute_wildcard_counts_all_attributes() {
+ // @* yields one node per attribute — not one per element.
+ let xml = "<r><a x='1' y='2' z='3'/><b w='4'/></r>";
+ assert_eq!(eval_xpath(xml, "count(//@*)"), XPathValue::Number(4.0));
+ assert_eq!(eval_count(xml, "//a/@*"), 3);
+ // sum() over the wildcard sees every value.
+ assert_eq!(eval_xpath(xml, "sum(//@*)"), XPathValue::Number(10.0));
+ }
+
+ #[test]
+ fn test_attribute_wildcard_excludes_namespace_declarations() {
+ // xmlns/xmlns:* are namespace declarations, not attribute nodes
+ // (XPath 1.0 §5.3).
+ let xml = "<r xmlns:p='urn:p' id='1'><p:a p:x='2'/></r>";
+ assert_eq!(eval_count(xml, "//@*"), 2);
+ }
+
+ #[test]
+ fn test_attribute_node_name_functions() {
+ let xml = "<r xmlns:p='urn:p'><a p:href='u1'/></r>";
+ assert_eq!(
+ eval_xpath(xml, "name(//a/@*)"),
+ XPathValue::String("p:href".to_owned())
+ );
+ assert_eq!(
+ eval_xpath(xml, "local-name(//a/@*)"),
+ XPathValue::String("href".to_owned())
+ );
+ assert_eq!(
+ eval_xpath(xml, "namespace-uri(//a/@*)"),
+ XPathValue::String("urn:p".to_owned())
+ );
+ }
+
+ #[test]
+ fn test_attribute_parent_axis() {
+ let xml = "<r><a x='1'/></r>";
+ assert_eq!(
+ eval_xpath(xml, "name(//a/@x/..)"),
+ XPathValue::String("a".to_owned())
+ );
+ assert_eq!(eval_count(xml, "//a/@x/ancestor::*"), 2);
+ }
+
+ #[test]
+ fn test_attribute_predicate_on_attribute_step() {
+ // Predicates over attribute node-sets see the attribute's own
+ // string-value as the context node.
+ let xml = "<r><a x='1'/><a x='2'/><a x='3'/></r>";
+ assert_eq!(eval_count(xml, "//a/@x[. > 1]"), 2);
+ assert_eq!(
+ eval_xpath(xml, "string(//a/@x[. = '2'])"),
+ XPathValue::String("2".to_owned())
+ );
+ }
+
+ #[test]
+ fn test_union_of_elements_and_attributes() {
+ // Mixed node-sets sort in document order with an attribute directly
+ // after its owner element.
+ let xml = "<r><a x='1'>t</a></r>";
+ let XPathValue::NodeSet(ns) = eval_xpath(xml, "//a | //a/@x") else {
+ panic!("expected node-set");
+ };
+ assert_eq!(ns.len(), 2);
+ assert!(!ns[0].is_attribute());
+ assert!(ns[1].is_attribute());
+ assert_eq!(ns[1].anchor(), ns[0].anchor());
+ }
+
+ #[test]
+ fn test_mixed_attribute_input_document_order() {
+ // Axis expansions from inputs that mix elements and attributes must
+ // come out in document order.
+ let xml = "<root><e a='1'><c1/><c2/></e></root>";
+ let XPathValue::NodeSet(ns) = eval_xpath(xml, "(//e | //@a)/descendant-or-self::node()")
+ else {
+ panic!("expected node-set");
+ };
+ // Document order: e, @a, c1, c2.
+ assert_eq!(ns.len(), 4);
+ assert!(!ns[0].is_attribute());
+ assert!(ns[1].is_attribute());
+ assert_eq!(
+ eval_xpath(xml, "string(((//e | //@a)/descendant-or-self::node())[2])"),
+ XPathValue::String("1".to_owned())
+ );
+
+ let xml2 = "<root><e a='1'><child/></e><after/></root>";
+ assert_eq!(
+ eval_xpath(xml2, "name(((//e | //@a)/following::*)[1])"),
+ XPathValue::String("after".to_owned())
+ );
+ }
+
+ #[test]
+ fn test_step_predicate_position_is_per_context_node() {
+ // XPath 1.0 §2.4: a step predicate filters the node-set generated
+ // for each context node separately — //a/b[1] selects the FIRST b
+ // of EVERY a, not the first of the merged set.
+ let xml = "<root><a><b>1</b><b>2</b></a><a><b>3</b><b>4</b></a></root>";
+ assert_eq!(eval_count(xml, "//a/b[1]"), 2);
+ assert_eq!(eval_count(xml, "//a/b[last()]"), 2);
+ assert_eq!(eval_count(xml, "//a/b[2]"), 2);
+ // The parenthesized form applies the position globally.
+ assert_eq!(eval_count(xml, "(//a/b)[1]"), 1);
+
+ // Same semantics over attribute steps.
+ let xml2 = "<root><a p='1' q='2'/><a p='3' q='4'/></root>";
+ assert_eq!(eval_count(xml2, "//a/@*[1]"), 2);
+ assert_eq!(eval_count(xml2, "//a/@*[last()]"), 2);
+ assert_eq!(eval_xpath(xml2, "sum(//a/@*[1])"), XPathValue::Number(4.0));
+
+ // Predicates on the step after `//` also keep the proximity context
+ // of each descendant-or-self node.
+ assert_eq!(eval_count(xml, "//*[1]"), 4);
+ assert_eq!(eval_count(xml, "//a[last()]"), 1);
+ }
+
+ #[test]
+ fn test_prefixed_attribute_name_test() {
+ // A prefixed attribute name test matches by literal prefix without
+ // bindings, and namespace-aware with bindings.
+ let xml = "<r xmlns:xl='http://www.w3.org/1999/xlink'><a xl:href='u1'/></r>";
+ assert_eq!(
+ eval_xpath(xml, "string(//a/@xl:href)"),
+ XPathValue::String("u1".to_owned())
+ );
+ }
+
+ #[test]
+ fn test_count_of_absent_attribute_filter_path() {
+ // count() over a filter-path attribute step with no matches must
+ // return 0, not a type error.
+ let xml = "<r><a href='u1'/><a/></r>";
+ assert_eq!(
+ eval_xpath(xml, "count((//a)/@missing)"),
+ XPathValue::Number(0.0)
+ );
+ }
+
+ #[test]
+ fn test_neq_nodeset_nodeset() {
+ // g/b = {p, q}, h/b = {p, p}: the pair (q, p) is unequal.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//g/b != //h/b"),
+ XPathValue::Boolean(true)
+ );
+ // h/b vs itself: every pair is (p, p), so no unequal pair exists.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//h/b != //h/b"),
+ XPathValue::Boolean(false)
+ );
+ }
+
+ #[test]
+ fn test_neq_in_predicate() {
+ // Only <g> has a b child whose string-value differs from 'p'.
+ assert_eq!(eval_count(NEQ_DOC, "//*[b != 'p']"), 1);
+ }
+
+ #[test]
+ fn test_neq_nodeset_boolean_stays_negation() {
+ // Node-set vs boolean converts the node-set to a boolean first
+ // (XPath 1.0 §3.4), so `!=` IS plain negation there.
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere != true()"),
+ XPathValue::Boolean(true)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//nothere != false()"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//a != true()"),
+ XPathValue::Boolean(false)
+ );
+ assert_eq!(
+ eval_xpath(NEQ_DOC, "//a != false()"),
+ XPathValue::Boolean(true)
+ );
+ }
+
+ // -- Filter-path expressions (issue #20) --------------------------------
+
+ #[test]
+ fn test_filter_path_attribute_value() {
+ // Regression test for issue #20: `string((//span/a)[1]/@href)` must
+ // return the attribute value, not the anchor's text content.
+ let xml =
+ "<r><span class='titleline'><a href='https://x.example/'>Link Text</a></span></r>";
+ let result = eval_xpath(xml, "string((//span[@class='titleline']/a)[1]/@href)");
+ assert_eq!(result, XPathValue::String("https://x.example/".to_owned()));
+ }
+
+ #[test]
+ fn test_filter_path_element_step() {
+ // `(//a)/b` navigates to the b children; `(//a)[b]` filters the a
+ // elements by the existence of a b child. They must differ.
+ let xml = "<r><a><b>1</b><b>2</b></a><a/></r>";
+ assert_eq!(eval_count(xml, "(//a)/b"), 2);
+ assert_eq!(eval_count(xml, "(//a)[b]"), 1);
+ }
+
+ #[test]
+ fn test_filter_path_double_slash() {
+ let xml = "<r><a><b><c>deep</c></b></a><a><c>direct</c></a></r>";
+ assert_eq!(eval_count(xml, "(//a)[1]//c"), 1);
+ assert_eq!(eval_count(xml, "(//a)//c"), 2);
+ }
+
+ #[test]
+ fn test_filter_path_parent_step() {
+ let xml = "<r><a><b/></a></r>";
+ let result = eval_xpath(xml, "name((//b)[1]/..)");
+ assert_eq!(result, XPathValue::String("a".to_owned()));
+ }
+
+ #[test]
+ fn test_filter_path_non_nodeset_is_type_error() {
+ // A location-path continuation on a non-node-set is a type error.
+ let doc = Document::parse_str("<r/>").unwrap();
+ let root = doc.root_element().unwrap();
+ let expr = parse("('str')/a").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let err = ctx.evaluate(&expr).unwrap_err();
+ assert!(
+ matches!(err, XPathError::TypeError { .. }),
+ "expected TypeError, got: {err:?}"
+ );
+ }
+
+ #[test]
+ fn test_neq_scalar_nan() {
+ // NaN is unequal to everything, including itself.
+ assert_eq!(
+ eval_xpath("<r/>", "number('foo') != number('foo')"),
+ XPathValue::Boolean(true)
+ );
+ assert_eq!(
+ eval_xpath("<r/>", "number('foo') = number('foo')"),
+ XPathValue::Boolean(false)
+ );
+ }
+
+ #[test]
+ fn test_comparison_lt_gt() {
+ let result = eval_xpath("<r/>", "1 < 2");
+ assert_eq!(result, XPathValue::Boolean(true));
+
+ let result = eval_xpath("<r/>", "2 > 1");
+ assert_eq!(result, XPathValue::Boolean(true));
+
+ let result = eval_xpath("<r/>", "2 < 1");
+ assert_eq!(result, XPathValue::Boolean(false));
+ }
+
+ // -- Boolean operators --------------------------------------------------
+
+ #[test]
+ fn test_boolean_and() {
+ let result = eval_xpath("<r/>", "true() and false()");
+ assert_eq!(result, XPathValue::Boolean(false));
+
+ let result = eval_xpath("<r/>", "true() and true()");
+ assert_eq!(result, XPathValue::Boolean(true));
+ }
+
+ #[test]
+ fn test_boolean_or() {
+ let result = eval_xpath("<r/>", "true() or false()");
+ assert_eq!(result, XPathValue::Boolean(true));
+
+ let result = eval_xpath("<r/>", "false() or false()");
+ assert_eq!(result, XPathValue::Boolean(false));
+ }
+
+ // -- String functions ---------------------------------------------------
+
+ #[test]
+ fn test_concat() {
+ let result = eval_xpath("<r/>", "concat('a', 'b')");
+ assert_eq!(result, XPathValue::String("ab".to_owned()));
+
+ let result = eval_xpath("<r/>", "concat('a', 'b', 'c')");
+ assert_eq!(result, XPathValue::String("abc".to_owned()));
+ }
+
+ #[test]
+ fn test_string_length() {
+ let result = eval_xpath("<r/>", "string-length('hello')");
+ assert_eq!(result, XPathValue::Number(5.0));
+ }
+
+ #[test]
+ fn test_contains() {
+ let result = eval_xpath("<r/>", "contains('hello', 'ell')");
+ assert_eq!(result, XPathValue::Boolean(true));
+
+ let result = eval_xpath("<r/>", "contains('hello', 'xyz')");
+ assert_eq!(result, XPathValue::Boolean(false));
+ }
+
+ #[test]
+ fn test_starts_with() {
+ let result = eval_xpath("<r/>", "starts-with('hello', 'hel')");
+ assert_eq!(result, XPathValue::Boolean(true));
+
+ let result = eval_xpath("<r/>", "starts-with('hello', 'xyz')");
+ assert_eq!(result, XPathValue::Boolean(false));
+ }
+
+ #[test]
+ fn test_substring() {
+ // substring('12345', 2, 3) = '234'
+ let result = eval_xpath("<r/>", "substring('12345', 2, 3)");
+ assert_eq!(result, XPathValue::String("234".to_owned()));
+
+ // substring('12345', 2) = '2345'
+ let result = eval_xpath("<r/>", "substring('12345', 2)");
+ assert_eq!(result, XPathValue::String("2345".to_owned()));
+ }
+
+ #[test]
+ fn test_normalize_space() {
+ let result = eval_xpath("<r/>", "normalize-space(' hello world ')");
+ assert_eq!(result, XPathValue::String("hello world".to_owned()));
+ }
+
+ #[test]
+ fn test_translate() {
+ let result = eval_xpath("<r/>", "translate('bar', 'abc', 'ABC')");
+ assert_eq!(result, XPathValue::String("BAr".to_owned()));
+ }
+
+ #[test]
+ fn test_substring_before_after() {
+ let result = eval_xpath("<r/>", "substring-before('1999/04/01', '/')");
+ assert_eq!(result, XPathValue::String("1999".to_owned()));
+
+ let result = eval_xpath("<r/>", "substring-after('1999/04/01', '/')");
+ assert_eq!(result, XPathValue::String("04/01".to_owned()));
+ }
+
+ // -- Number functions ---------------------------------------------------
+
+ #[test]
+ fn test_floor() {
+ let result = eval_xpath("<r/>", "floor(1.5)");
+ assert_eq!(result, XPathValue::Number(1.0));
+
+ let result = eval_xpath("<r/>", "floor(-1.5)");
+ assert_eq!(result, XPathValue::Number(-2.0));
+ }
+
+ #[test]
+ fn test_ceiling() {
+ let result = eval_xpath("<r/>", "ceiling(1.5)");
+ assert_eq!(result, XPathValue::Number(2.0));
+
+ let result = eval_xpath("<r/>", "ceiling(-1.5)");
+ assert_eq!(result, XPathValue::Number(-1.0));
+ }
+
+ #[test]
+ fn test_round() {
+ let result = eval_xpath("<r/>", "round(1.5)");
+ assert_eq!(result, XPathValue::Number(2.0));
+
+ let result = eval_xpath("<r/>", "round(-0.5)");
+ assert_eq!(result, XPathValue::Number(0.0));
+
+ let result = eval_xpath("<r/>", "round(2.5)");
+ assert_eq!(result, XPathValue::Number(3.0));
+ }
+
+ // -- count(), position(), last() ----------------------------------------
+
+ #[test]
+ fn test_count() {
+ let result = eval_xpath("<r><a/><b/><c/></r>", "count(*)");
+ assert_eq!(result, XPathValue::Number(3.0));
+ }
+
+ #[test]
+ fn test_position_and_last() {
+ // position() and last() in the default singleton context
+ let result = eval_xpath("<r/>", "position()");
+ assert_eq!(result, XPathValue::Number(1.0));
+
+ let result = eval_xpath("<r/>", "last()");
+ assert_eq!(result, XPathValue::Number(1.0));
+ }
+
+ // -- Path evaluation ----------------------------------------------------
+
+ #[test]
+ fn test_simple_child_path() {
+ let count = eval_count("<r><a/><b/><c/></r>", "a");
+ assert_eq!(count, 1);
+ }
+
+ #[test]
+ fn test_root_path() {
+ let xml = "<root><child>text</child></root>";
+ let result = eval_xpath_from_doc_root(xml, "/root/child");
+ match &result {
+ XPathValue::NodeSet(ns) => assert_eq!(ns.len(), 1),
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ #[test]
+ fn test_descendant_axis() {
+ // //child matches anywhere in the tree
+ let xml = "<r><a><b/></a></r>";
+ let result = eval_xpath_from_doc_root(xml, "//b");
+ match &result {
+ XPathValue::NodeSet(ns) => assert_eq!(ns.len(), 1),
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ #[test]
+ fn test_parent_axis() {
+ // child/.. should go back to the parent
+ let xml = "<r><a><b/></a></r>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root_elem = doc.root_element().unwrap();
+ // Navigate to <a>
+ let a = doc.children(root_elem).next().unwrap();
+ // Navigate to <b>
+ let b = doc.children(a).next().unwrap();
+
+ let expr = parse("..").unwrap();
+ let ctx = XPathContext::new(&doc, b);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert_eq!(ns.len(), 1);
+ assert_eq!(ns[0], XPathNode::Node(a));
+ }
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ #[test]
+ fn test_self_axis() {
+ let xml = "<r><a/></r>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root_elem = doc.root_element().unwrap();
+
+ let expr = parse(".").unwrap();
+ let ctx = XPathContext::new(&doc, root_elem);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert_eq!(ns.len(), 1);
+ assert_eq!(ns[0], XPathNode::Node(root_elem));
+ }
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ // -- Predicates ---------------------------------------------------------
+
+ #[test]
+ fn test_positional_predicate() {
+ let xml = "<r><a/><b/><c/></r>";
+ let count = eval_count(xml, "*[1]");
+ assert_eq!(count, 1);
+ }
+
+ #[test]
+ fn test_last_predicate() {
+ let xml = "<r><a/><b/><c/></r>";
+ let count = eval_count(xml, "*[last()]");
+ assert_eq!(count, 1);
+ }
+
+ #[test]
+ fn test_attribute_predicate() {
+ let xml = r#"<r><a id="x"/><a id="y"/></r>"#;
+ let doc = Document::parse_str(xml).unwrap();
+ let root_elem = doc.root_element().unwrap();
+ let expr = parse("a[@id='x']").unwrap();
+ let ctx = XPathContext::new(&doc, root_elem);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert_eq!(ns.len(), 1);
+ // Check it's the right element
+ assert_eq!(doc.attribute(ns[0].anchor(), "id"), Some("x"));
+ }
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ // -- Variables -----------------------------------------------------------
+
+ #[test]
+ fn test_variable() {
+ let xml = "<r/>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+ let expr = parse("$x + 1").unwrap();
+ let mut ctx = XPathContext::new(&doc, root);
+ ctx.set_variable("x", XPathValue::Number(41.0));
+ let result = ctx.evaluate(&expr).unwrap();
+ assert_eq!(result, XPathValue::Number(42.0));
+ }
+
+ #[test]
+ fn test_undefined_variable_error() {
+ let xml = "<r/>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+ let expr = parse("$undefined").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr);
+ assert!(result.is_err());
+ }
+
+ // -- Union ---------------------------------------------------------------
+
+ #[test]
+ fn test_union() {
+ let xml = "<r><a/><b/></r>";
+ let count = eval_count(xml, "a | b");
+ assert_eq!(count, 2);
+ }
+
+ // -- Complex expression --------------------------------------------------
+
+ #[test]
+ fn test_complex_book_price() {
+ let xml = r"<store>
+ <book><title>A</title><price>30</price></book>
+ <book><title>B</title><price>40</price></book>
+ </store>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root_elem = doc.root_element().unwrap();
+ // Count books with price > 35
+ let expr = parse("count(book[price > 35])").unwrap();
+ let ctx = XPathContext::new(&doc, root_elem);
+ let result = ctx.evaluate(&expr).unwrap();
+ assert_eq!(result, XPathValue::Number(1.0));
+ }
+
+ // -- String value of nodes -----------------------------------------------
+
+ #[test]
+ fn test_string_function_on_context() {
+ let xml = "<r>hello</r>";
+ let result = eval_xpath(xml, "string()");
+ assert_eq!(result, XPathValue::String("hello".to_owned()));
+ }
+
+ // -- Deep path traversal -------------------------------------------------
+
+ #[test]
+ fn test_deep_path_traversal() {
+ let xml = "<a><b><c><d>deep</d></c></b></a>";
+ let result = eval_xpath_from_doc_root(xml, "/a/b/c/d");
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert_eq!(ns.len(), 1);
+ let doc = Document::parse_str(xml).unwrap();
+ assert_eq!(doc.text_content(ns[0].anchor()), "deep");
+ }
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ // -- Unary negation ------------------------------------------------------
+
+ #[test]
+ fn test_unary_neg() {
+ let result = eval_xpath("<r/>", "-(3)");
+ assert_eq!(result, XPathValue::Number(-3.0));
+ }
+
+ // -- Not function --------------------------------------------------------
+
+ #[test]
+ fn test_not() {
+ let result = eval_xpath("<r/>", "not(true())");
+ assert_eq!(result, XPathValue::Boolean(false));
+
+ let result = eval_xpath("<r/>", "not(false())");
+ assert_eq!(result, XPathValue::Boolean(true));
+ }
+
+ // -- Name functions ------------------------------------------------------
+
+ #[test]
+ fn test_name_function() {
+ let xml = "<root/>";
+ let result = eval_xpath(xml, "name()");
+ assert_eq!(result, XPathValue::String("root".to_owned()));
+ }
+
+ #[test]
+ fn test_local_name_function() {
+ let xml = "<root/>";
+ let result = eval_xpath(xml, "local-name()");
+ assert_eq!(result, XPathValue::String("root".to_owned()));
+ }
+
+ // -- Sum function --------------------------------------------------------
+
+ #[test]
+ fn test_sum() {
+ let xml = "<r><n>1</n><n>2</n><n>3</n></r>";
+ let result = eval_xpath(xml, "sum(n)");
+ assert_eq!(result, XPathValue::Number(6.0));
+ }
+
+ // -- Following/Preceding sibling axes ------------------------------------
+
+ #[test]
+ fn test_following_sibling() {
+ let xml = "<r><a/><b/><c/></r>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root_elem = doc.root_element().unwrap();
+ let a = doc.children(root_elem).next().unwrap();
+
+ let expr = parse("following-sibling::*").unwrap();
+ let ctx = XPathContext::new(&doc, a);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => assert_eq!(ns.len(), 2), // b and c
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ #[test]
+ fn test_preceding_sibling() {
+ let xml = "<r><a/><b/><c/></r>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root_elem = doc.root_element().unwrap();
+ let children: Vec<_> = doc.children(root_elem).collect();
+ let c = children[2]; // <c/>
+
+ let expr = parse("preceding-sibling::*").unwrap();
+ let ctx = XPathContext::new(&doc, c);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => assert_eq!(ns.len(), 2), // a and b
+ _ => panic!("expected node-set"),
+ }
+ }
+
+ // -- id() function -------------------------------------------------------
+
+ #[test]
+ fn test_xpath_id_single() {
+ let mut doc = Document::parse_str(
+ r#"<root><item id="x">Hello</item><item id="y">World</item></root>"#,
+ )
+ .unwrap();
+ // Populate the id_map
+ let root = doc.root_element().unwrap();
+ let children: Vec<_> = doc.children(root).collect();
+ doc.set_id("x", children[0]);
+ doc.set_id("y", children[1]);
+
+ let expr = parse("id('x')").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert_eq!(ns.len(), 1);
+ assert_eq!(doc.node_name(ns[0].anchor()), Some("item"));
+ assert_eq!(doc.text_content(ns[0].anchor()), "Hello");
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_xpath_id_multiple_space_separated() {
+ let mut doc =
+ Document::parse_str(r#"<root><a id="p">1</a><b id="q">2</b><c id="r">3</c></root>"#)
+ .unwrap();
+ let root = doc.root_element().unwrap();
+ let children: Vec<_> = doc.children(root).collect();
+ doc.set_id("p", children[0]);
+ doc.set_id("q", children[1]);
+ doc.set_id("r", children[2]);
+
+ let expr = parse("id('p r')").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert_eq!(ns.len(), 2);
+ assert_eq!(doc.node_name(ns[0].anchor()), Some("a"));
+ assert_eq!(doc.node_name(ns[1].anchor()), Some("c"));
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_xpath_id_unknown_returns_empty() {
+ let doc = Document::parse_str("<root/>").unwrap();
+ let root = doc.root_element().unwrap();
+
+ let expr = parse("id('nonexistent')").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => assert!(ns.is_empty()),
+ other => panic!("expected empty node-set, got {other:?}"),
+ }
+ }
+
+ // -- Namespace axis -------------------------------------------------------
+
+ #[test]
+ fn test_namespace_axis_with_declaration() {
+ let xml = r#"<root xmlns:ns="http://example.com"><child/></root>"#;
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+
+ // namespace::ns should match because ns is in scope
+ let expr = parse("namespace::ns").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => assert!(!ns.is_empty(), "expected namespace::ns to match"),
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_namespace_axis_inherited() {
+ let xml = r#"<root xmlns:ns="http://example.com"><child/></root>"#;
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+ let child = doc.first_child(root).unwrap();
+
+ // namespace::ns should be in scope on child (inherited from root)
+ let expr = parse("namespace::ns").unwrap();
+ let ctx = XPathContext::new(&doc, child);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert!(!ns.is_empty(), "expected namespace::ns to be inherited");
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_namespace_axis_xml_always_in_scope() {
+ let xml = "<root/>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+
+ // namespace::xml should always be in scope
+ let expr = parse("namespace::xml").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert!(
+ !ns.is_empty(),
+ "expected namespace::xml to always be in scope"
+ );
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_namespace_axis_wildcard() {
+ let xml = r#"<root xmlns:a="http://a" xmlns:b="http://b"><child/></root>"#;
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+
+ // namespace::* should return non-empty (a, b, xml are all in scope)
+ let expr = parse("namespace::*").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert!(!ns.is_empty(), "expected namespace::* to match");
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_namespace_axis_nonexistent_prefix() {
+ let xml = "<root/>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+
+ // namespace::nonexistent should return empty
+ let expr = parse("namespace::nonexistent").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert!(ns.is_empty(), "expected no match for nonexistent prefix");
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_namespace_axis_on_text_node() {
+ let xml = "<root>text</root>";
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+ let text = doc.first_child(root).unwrap();
+
+ // namespace axis on a text node should return empty
+ let expr = parse("namespace::*").unwrap();
+ let ctx = XPathContext::new(&doc, text);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert!(ns.is_empty(), "namespace axis on text node should be empty");
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+
+ #[test]
+ fn test_namespace_axis_default_namespace() {
+ let xml = r#"<root xmlns="http://default"><child/></root>"#;
+ let doc = Document::parse_str(xml).unwrap();
+ let root = doc.root_element().unwrap();
+
+ // namespace::* should include the default namespace
+ let expr = parse("namespace::*").unwrap();
+ let ctx = XPathContext::new(&doc, root);
+ let result = ctx.evaluate(&expr).unwrap();
+ match &result {
+ XPathValue::NodeSet(ns) => {
+ assert!(!ns.is_empty(), "expected default namespace to be in scope");
+ }
+ other => panic!("expected node-set, got {other:?}"),
+ }
+ }
+}
diff --git a/browser/vendor/xmloxide/src/xpath/lexer.rs b/browser/vendor/xmloxide/src/xpath/lexer.rs
new file mode 100644
index 000000000..2014563d4
--- /dev/null
+++ b/browser/vendor/xmloxide/src/xpath/lexer.rs
@@ -0,0 +1,1099 @@
+//! `XPath` 1.0 expression tokenizer.
+//!
+//! This module implements a lexer for `XPath` 1.0 expressions as specified in
+//! <https://www.w3.org/TR/xpath-10/#exprlex>. The lexer converts an `XPath`
+//! expression string into a sequence of [`Token`]s that can be consumed by
+//! the parser.
+//!
+//! # Disambiguation Rules
+//!
+//! The `XPath` 1.0 specification (section 3.7) defines several disambiguation
+//! rules that the lexer must apply:
+//!
+//! - `*` is treated as a multiply operator (not a name test) when the
+//! preceding token could end an operand.
+//! - A name followed by `(` is a function name or node type test.
+//! - A name followed by `::` is an axis name.
+//! - Otherwise, a name is a `NameTest`.
+
+use std::fmt;
+
+/// An error that occurred during `XPath` lexing or parsing.
+#[derive(Debug, Clone)]
+pub struct XPathError {
+ /// Human-readable error message.
+ pub message: String,
+ /// 0-based byte offset in the expression where the error occurred.
+ pub position: usize,
+}
+
+impl fmt::Display for XPathError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "XPath error at position {}: {}",
+ self.position, self.message
+ )
+ }
+}
+
+impl std::error::Error for XPathError {}
+
+/// The set of node type names recognized as node type tests.
+///
+/// When one of these names appears before `(`, it is a node type test rather
+/// than a function call. See `XPath` 1.0 section 3.7.
+const NODE_TYPE_NAMES: &[&str] = &["comment", "text", "processing-instruction", "node"];
+
+/// A token produced by the `XPath` lexer.
+///
+/// See `XPath` 1.0 section 3.7 for the full token grammar.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Token {
+ /// `(` -- left parenthesis.
+ LeftParen,
+ /// `)` -- right parenthesis.
+ RightParen,
+ /// `[` -- left bracket (predicate open).
+ LeftBracket,
+ /// `]` -- right bracket (predicate close).
+ RightBracket,
+ /// `.` -- current node (abbreviated step).
+ Dot,
+ /// `..` -- parent node (abbreviated step).
+ DotDot,
+ /// `@` -- attribute axis abbreviation.
+ At,
+ /// `,` -- argument separator in function calls.
+ Comma,
+ /// `::` -- axis separator.
+ ColonColon,
+ /// `/` -- child step separator.
+ Slash,
+ /// `//` -- descendant-or-self step abbreviation.
+ DoubleSlash,
+ /// `|` -- union operator.
+ Pipe,
+ /// `+` -- addition operator.
+ Plus,
+ /// `-` -- subtraction or unary negation.
+ Minus,
+ /// `*` -- multiplication operator (disambiguation from name test
+ /// is handled by the lexer based on context).
+ Star,
+ /// `=` -- equality comparison.
+ Equal,
+ /// `!=` -- inequality comparison.
+ NotEqual,
+ /// `<` -- less-than comparison.
+ LessThan,
+ /// `<=` -- less-than-or-equal comparison.
+ LessThanEqual,
+ /// `>` -- greater-than comparison.
+ GreaterThan,
+ /// `>=` -- greater-than-or-equal comparison.
+ GreaterThanEqual,
+ /// `and` keyword operator.
+ And,
+ /// `or` keyword operator.
+ Or,
+ /// `mod` keyword operator.
+ Mod,
+ /// `div` keyword operator.
+ Div,
+ /// A numeric literal (e.g., `42`, `3.5`, `.5`).
+ Number(f64),
+ /// A string literal (e.g., `"hello"` or `'world'`).
+ Literal(String),
+ /// A qualified name used as a name test (e.g., `foo`, `svg:rect`).
+ Name(String),
+ /// A variable reference (e.g., `$var`). The string is the name without `$`.
+ VariableReference(String),
+ /// A function name (name that appeared before `(`).
+ FunctionName(String),
+ /// A node type test keyword (e.g., `node`, `text`, `comment`,
+ /// `processing-instruction`).
+ NodeType(String),
+ /// An axis name (name that appeared before `::`).
+ AxisName(String),
+}
+
+impl fmt::Display for Token {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::LeftParen => f.write_str("("),
+ Self::RightParen => f.write_str(")"),
+ Self::LeftBracket => f.write_str("["),
+ Self::RightBracket => f.write_str("]"),
+ Self::Dot => f.write_str("."),
+ Self::DotDot => f.write_str(".."),
+ Self::At => f.write_str("@"),
+ Self::Comma => f.write_str(","),
+ Self::ColonColon => f.write_str("::"),
+ Self::Slash => f.write_str("/"),
+ Self::DoubleSlash => f.write_str("//"),
+ Self::Pipe => f.write_str("|"),
+ Self::Plus => f.write_str("+"),
+ Self::Minus => f.write_str("-"),
+ Self::Star => f.write_str("*"),
+ Self::Equal => f.write_str("="),
+ Self::NotEqual => f.write_str("!="),
+ Self::LessThan => f.write_str("<"),
+ Self::LessThanEqual => f.write_str("<="),
+ Self::GreaterThan => f.write_str(">"),
+ Self::GreaterThanEqual => f.write_str(">="),
+ Self::And => f.write_str("and"),
+ Self::Or => f.write_str("or"),
+ Self::Mod => f.write_str("mod"),
+ Self::Div => f.write_str("div"),
+ Self::Number(n) => write!(f, "{n}"),
+ Self::Literal(s) => write!(f, "\"{s}\""),
+ Self::Name(s) | Self::FunctionName(s) | Self::NodeType(s) | Self::AxisName(s) => {
+ write!(f, "{s}")
+ }
+ Self::VariableReference(s) => write!(f, "${s}"),
+ }
+ }
+}
+
+/// `XPath` 1.0 expression tokenizer.
+///
+/// The lexer processes an `XPath` expression string and produces a sequence of
+/// [`Token`]s. It handles the disambiguation rules from `XPath` 1.0 section 3.7
+/// to correctly distinguish between operators and name tests for `*`, and
+/// between function names, node type tests, axis names, and plain name tests.
+///
+/// # Examples
+///
+/// ```ignore
+/// use xmloxide::xpath::lexer::Lexer;
+///
+/// let mut lexer = Lexer::new("child::p[@class='intro']");
+/// let tokens = lexer.tokenize().unwrap();
+/// ```
+pub struct Lexer<'a> {
+ /// The input expression as bytes for efficient indexing.
+ input: &'a [u8],
+ /// Current byte offset into the input.
+ pos: usize,
+}
+
+impl<'a> Lexer<'a> {
+ /// Creates a new lexer for the given `XPath` expression string.
+ #[must_use]
+ pub fn new(input: &'a str) -> Self {
+ Self {
+ input: input.as_bytes(),
+ pos: 0,
+ }
+ }
+
+ /// Tokenizes the entire input expression into a sequence of tokens.
+ ///
+ /// Applies the `XPath` 1.0 disambiguation rules (section 3.7) to correctly
+ /// classify tokens based on their context.
+ ///
+ /// # Errors
+ ///
+ /// Returns [`XPathError`] if the input contains an invalid token, such as
+ /// an unterminated string literal or an unexpected character.
+ pub fn tokenize(&mut self) -> Result<Vec<Token>, XPathError> {
+ let mut raw_tokens = Vec::new();
+
+ loop {
+ self.skip_whitespace();
+ if self.pos >= self.input.len() {
+ break;
+ }
+ let token = self.next_raw_token()?;
+ raw_tokens.push(token);
+ }
+
+ Ok(Self::disambiguate(raw_tokens))
+ }
+
+ /// Reads the next raw token from the input.
+ ///
+ /// At this stage, names are all emitted as `Name`, and `*` is always
+ /// emitted as `Star`. Disambiguation happens in a second pass.
+ fn next_raw_token(&mut self) -> Result<Token, XPathError> {
+ let ch = self
+ .peek_byte()
+ .ok_or_else(|| self.error("unexpected end of input"))?;
+
+ match ch {
+ b'(' => {
+ self.advance();
+ Ok(Token::LeftParen)
+ }
+ b')' => {
+ self.advance();
+ Ok(Token::RightParen)
+ }
+ b'[' => {
+ self.advance();
+ Ok(Token::LeftBracket)
+ }
+ b']' => {
+ self.advance();
+ Ok(Token::RightBracket)
+ }
+ b'@' => {
+ self.advance();
+ Ok(Token::At)
+ }
+ b',' => {
+ self.advance();
+ Ok(Token::Comma)
+ }
+ b'|' => {
+ self.advance();
+ Ok(Token::Pipe)
+ }
+ b'+' => {
+ self.advance();
+ Ok(Token::Plus)
+ }
+ b'-' => {
+ self.advance();
+ Ok(Token::Minus)
+ }
+ b'=' => {
+ self.advance();
+ Ok(Token::Equal)
+ }
+ b'*' => {
+ self.advance();
+ Ok(Token::Star)
+ }
+ b':' => self.read_colon_colon(),
+ b'.' => self.read_dot_or_number(),
+ b'/' => Ok(self.read_slash()),
+ b'!' => self.read_not_equal(),
+ b'<' => Ok(self.read_less_than()),
+ b'>' => Ok(self.read_greater_than()),
+ b'"' | b'\'' => self.read_string_literal(),
+ b'$' => self.read_variable_reference(),
+ b'0'..=b'9' => self.read_number(),
+ _ if is_name_start_char(ch) => Ok(self.read_name()),
+ _ => Err(self.error(&format!("unexpected character '{}'", char::from(ch)))),
+ }
+ }
+
+ /// Reads a `.` (`Dot`) or `..` (`DotDot`) token, or a number starting with `.`.
+ fn read_dot_or_number(&mut self) -> Result<Token, XPathError> {
+ self.advance(); // consume the first '.'
+
+ if self.peek_byte() == Some(b'.') {
+ self.advance();
+ return Ok(Token::DotDot);
+ }
+
+ // Check if this is a number like .5
+ if matches!(self.peek_byte(), Some(b'0'..=b'9')) {
+ let start = self.pos - 1; // include the '.'
+ self.advance_while(|b| b.is_ascii_digit());
+ let text = self.slice_from(start);
+ let value = text
+ .parse::<f64>()
+ .map_err(|_| make_error(start, &format!("invalid number literal: {text}")))?;
+ return Ok(Token::Number(value));
+ }
+
+ Ok(Token::Dot)
+ }
+
+ /// Reads a `/` or `//` token.
+ fn read_slash(&mut self) -> Token {
+ self.advance(); // consume '/'
+ if self.peek_byte() == Some(b'/') {
+ self.advance();
+ Token::DoubleSlash
+ } else {
+ Token::Slash
+ }
+ }
+
+ /// Reads the `::` (axis separator) token.
+ fn read_colon_colon(&mut self) -> Result<Token, XPathError> {
+ let start = self.pos;
+ self.advance(); // consume first ':'
+ if self.peek_byte() == Some(b':') {
+ self.advance();
+ Ok(Token::ColonColon)
+ } else {
+ Err(make_error(start, "expected ':' after ':'"))
+ }
+ }
+
+ /// Reads the `!=` token.
+ fn read_not_equal(&mut self) -> Result<Token, XPathError> {
+ let start = self.pos;
+ self.advance(); // consume '!'
+ if self.peek_byte() == Some(b'=') {
+ self.advance();
+ Ok(Token::NotEqual)
+ } else {
+ Err(make_error(start, "expected '=' after '!'"))
+ }
+ }
+
+ /// Reads `<` or `<=`.
+ fn read_less_than(&mut self) -> Token {
+ self.advance(); // consume '<'
+ if self.peek_byte() == Some(b'=') {
+ self.advance();
+ Token::LessThanEqual
+ } else {
+ Token::LessThan
+ }
+ }
+
+ /// Reads `>` or `>=`.
+ fn read_greater_than(&mut self) -> Token {
+ self.advance(); // consume '>'
+ if self.peek_byte() == Some(b'=') {
+ self.advance();
+ Token::GreaterThanEqual
+ } else {
+ Token::GreaterThan
+ }
+ }
+
+ /// Reads a string literal (single or double quoted).
+ ///
+ /// See `XPath` 1.0 section 3.5: a `Literal` is `'"' [^"]* '"'` or
+ /// `"'" [^']* "'"`.
+ fn read_string_literal(&mut self) -> Result<Token, XPathError> {
+ let start = self.pos;
+ let quote = self
+ .peek_byte()
+ .ok_or_else(|| self.error("unexpected end of input"))?;
+ self.advance(); // consume opening quote
+
+ let content_start = self.pos;
+ self.advance_while(|b| b != quote);
+
+ if self.pos >= self.input.len() {
+ return Err(make_error(start, "unterminated string literal"));
+ }
+
+ let content = self.slice_from(content_start).to_string();
+ self.advance(); // consume closing quote
+
+ Ok(Token::Literal(content))
+ }
+
+ /// Reads a variable reference (`$name`).
+ ///
+ /// See `XPath` 1.0 section 3.1.
+ fn read_variable_reference(&mut self) -> Result<Token, XPathError> {
+ let start = self.pos;
+ self.advance(); // consume '$'
+
+ if !self.peek_byte().is_some_and(is_name_start_char) {
+ return Err(make_error(start, "expected name after '$'"));
+ }
+
+ let name_start = self.pos;
+ self.advance_while(is_name_char);
+
+ // Handle QName (prefix:localname)
+ if self.peek_byte() == Some(b':')
+ && self
+ .peek_byte_at(self.pos + 1)
+ .is_some_and(|b| b != b':' && is_name_start_char(b))
+ {
+ self.advance(); // consume ':'
+ self.advance_while(is_name_char);
+ let full_name = self.slice_from(name_start);
+ return Ok(Token::VariableReference(full_name.to_string()));
+ }
+
+ let name = self.slice_from(name_start);
+ Ok(Token::VariableReference(name.to_string()))
+ }
+
+ /// Reads a numeric literal.
+ ///
+ /// See `XPath` 1.0 section 3.5: a `Number` is `Digits ('.' Digits?)?` or
+ /// `'.' Digits`.
+ fn read_number(&mut self) -> Result<Token, XPathError> {
+ let start = self.pos;
+ self.advance_while(|b| b.is_ascii_digit());
+
+ // Check for decimal point
+ if self.peek_byte() == Some(b'.') {
+ self.advance();
+ self.advance_while(|b| b.is_ascii_digit());
+ }
+
+ let text = self.slice_from(start);
+ let value = text
+ .parse::<f64>()
+ .map_err(|_| make_error(start, &format!("invalid number literal: {text}")))?;
+ Ok(Token::Number(value))
+ }
+
+ /// Reads a name token (`NCName` or `QName`).
+ ///
+ /// At this stage, the token is always emitted as `Name`. The disambiguation
+ /// pass will reclassify it as `FunctionName`, `NodeType`, or `AxisName`
+ /// based on the following token.
+ fn read_name(&mut self) -> Token {
+ let start = self.pos;
+ self.advance_while(is_name_char);
+
+ // Check for QName (prefix:localname) or prefix:* -- but not prefix::axis
+ if self.peek_byte() == Some(b':') {
+ let next = self.peek_byte_at(self.pos + 1);
+ if next.is_some_and(|b| b != b':' && is_name_start_char(b)) {
+ // prefix:localname
+ self.advance(); // consume ':'
+ self.advance_while(is_name_char);
+ } else if next == Some(b'*') {
+ // prefix:* (namespace wildcard)
+ self.advance(); // consume ':'
+ self.advance(); // consume '*'
+ }
+ }
+
+ let name = self.slice_from(start);
+ Token::Name(name.to_string())
+ }
+
+ /// Applies the `XPath` 1.0 disambiguation rules (section 3.7).
+ ///
+ /// This function reclassifies raw tokens based on their context:
+ /// - `*` after an operand-ending token becomes `Star` (multiply operator);
+ /// otherwise it remains `Name("*")` (name test).
+ /// - A `Name` followed by `(` becomes `FunctionName` or `NodeType`.
+ /// - A `Name` followed by `::` becomes `AxisName`.
+ /// - `and`, `or`, `mod`, `div` after operand-ending tokens become operators.
+ fn disambiguate(raw_tokens: Vec<Token>) -> Vec<Token> {
+ let len = raw_tokens.len();
+ let mut result = Vec::with_capacity(len);
+
+ for (i, token) in raw_tokens.into_iter().enumerate() {
+ let preceding_is_operand = if i == 0 {
+ false
+ } else {
+ is_operand_ending(&result[result.len() - 1])
+ };
+
+ match token {
+ Token::Star if !preceding_is_operand => {
+ // When * is not preceded by an operand-ending token, it's
+ // a name test wildcard, not a multiply operator.
+ result.push(Token::Name("*".to_string()));
+ }
+ other => result.push(other),
+ }
+ }
+
+ // Second pass: now that we have the full list, apply name disambiguation.
+ disambiguate_names(&mut result);
+
+ result
+ }
+
+ // --- Utility methods ---
+
+ /// Returns the byte at the current position, or `None` if at end.
+ fn peek_byte(&self) -> Option<u8> {
+ self.input.get(self.pos).copied()
+ }
+
+ /// Returns the byte at the given position, or `None` if out of bounds.
+ fn peek_byte_at(&self, pos: usize) -> Option<u8> {
+ self.input.get(pos).copied()
+ }
+
+ /// Advances the position by one byte.
+ fn advance(&mut self) {
+ self.pos += 1;
+ }
+
+ /// Advances while the predicate holds for the current byte.
+ fn advance_while<F: Fn(u8) -> bool>(&mut self, pred: F) {
+ while self.pos < self.input.len() && pred(self.input[self.pos]) {
+ self.pos += 1;
+ }
+ }
+
+ /// Skips ASCII whitespace characters.
+ fn skip_whitespace(&mut self) {
+ self.advance_while(|b| b.is_ascii_whitespace());
+ }
+
+ /// Returns the substring from `start` to the current position.
+ fn slice_from(&self, start: usize) -> &str {
+ // The input was originally a &str so it is valid UTF-8. We only
+ // split at ASCII byte boundaries, preserving UTF-8 validity.
+ // Using the safe `from_utf8` to avoid any unsafe code.
+ std::str::from_utf8(&self.input[start..self.pos]).unwrap_or("")
+ }
+
+ /// Creates an error at the current position.
+ fn error(&self, message: &str) -> XPathError {
+ make_error(self.pos, message)
+ }
+}
+
+/// Creates an [`XPathError`] at the given position.
+fn make_error(position: usize, message: &str) -> XPathError {
+ XPathError {
+ message: message.to_string(),
+ position,
+ }
+}
+
+/// Second-pass disambiguation for names, function names, node types,
+/// axis names, and keyword operators.
+fn disambiguate_names(tokens: &mut [Token]) {
+ let len = tokens.len();
+ let mut i = 0;
+ while i < len {
+ // Check if current token is a Name
+ if let Token::Name(ref name) = tokens[i] {
+ let name_clone = name.clone();
+
+ // Determine if the preceding token ends an operand
+ let preceding_is_operand = if i == 0 {
+ false
+ } else {
+ is_operand_ending(&tokens[i - 1])
+ };
+
+ // Look ahead to next token (whitespace is already stripped).
+ let next = tokens.get(i + 1);
+
+ if preceding_is_operand {
+ // After an operand, these names are operators.
+ match name_clone.as_str() {
+ "and" => tokens[i] = Token::And,
+ "or" => tokens[i] = Token::Or,
+ "mod" => tokens[i] = Token::Mod,
+ "div" => tokens[i] = Token::Div,
+ "*" => {
+ // * after operand is multiply
+ tokens[i] = Token::Star;
+ }
+ _ => {}
+ }
+ } else if matches!(next, Some(Token::LeftParen)) {
+ // Name followed by '(' -- function name or node type test
+ if NODE_TYPE_NAMES.contains(&name_clone.as_str()) {
+ tokens[i] = Token::NodeType(name_clone);
+ } else {
+ tokens[i] = Token::FunctionName(name_clone);
+ }
+ } else if matches!(next, Some(Token::ColonColon)) {
+ // Name followed by '::' -- axis name
+ tokens[i] = Token::AxisName(name_clone);
+ }
+ }
+
+ i += 1;
+ }
+}
+
+/// Returns `true` if the given token could end an operand.
+///
+/// Per `XPath` 1.0 section 3.7, the preceding token determines whether `*` is
+/// a multiply operator. If the preceding token is one that could end an
+/// expression or name test, then `*` is multiply. If there is no preceding
+/// token, or the preceding token is an operator or punctuation, then `*` is
+/// a name test (wildcard).
+fn is_operand_ending(token: &Token) -> bool {
+ matches!(
+ token,
+ Token::RightParen
+ | Token::RightBracket
+ | Token::Dot
+ | Token::DotDot
+ | Token::Number(_)
+ | Token::Literal(_)
+ | Token::Name(_)
+ | Token::VariableReference(_)
+ | Token::NodeType(_)
+ | Token::Star
+ )
+}
+
+/// Returns `true` if the byte is a valid name start character.
+///
+/// For simplicity, we accept ASCII letters and `_`. A full implementation
+/// would also accept Unicode letters per the XML `NameStartChar` production,
+/// but `XPath` names in practice are ASCII.
+fn is_name_start_char(b: u8) -> bool {
+ b.is_ascii_alphabetic() || b == b'_'
+}
+
+/// Returns `true` if the byte is a valid name continuation character.
+///
+/// Accepts letters, digits, `-`, `_`, and `.`. The hyphen is included
+/// because `XPath` axis names like `descendant-or-self` use hyphens, and we
+/// consume the full name before disambiguation. The dot is included for
+/// names that contain dots, though it is not part of XML `NCName`.
+fn is_name_char(b: u8) -> bool {
+ b.is_ascii_alphanumeric() || b == b'_' || b == b'-' || b == b'.'
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ /// Helper to tokenize and return the token vector, panicking on error.
+ fn tokenize(input: &str) -> Vec<Token> {
+ let mut lexer = Lexer::new(input);
+ lexer.tokenize().unwrap()
+ }
+
+ #[test]
+ fn test_tokenize_simple_path() {
+ let tokens = tokenize("child::p");
+ assert_eq!(tokens.len(), 3);
+ assert_eq!(tokens[0], Token::AxisName("child".to_string()));
+ assert_eq!(tokens[1], Token::ColonColon);
+ assert_eq!(tokens[2], Token::Name("p".to_string()));
+ }
+
+ #[test]
+ fn test_tokenize_abbreviated_path() {
+ let tokens = tokenize("/html/body");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Slash,
+ Token::Name("html".to_string()),
+ Token::Slash,
+ Token::Name("body".to_string()),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_double_slash() {
+ let tokens = tokenize("//div");
+ assert_eq!(
+ tokens,
+ vec![Token::DoubleSlash, Token::Name("div".to_string()),]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_predicate() {
+ let tokens = tokenize("p[1]");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("p".to_string()),
+ Token::LeftBracket,
+ Token::Number(1.0),
+ Token::RightBracket,
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_attribute_access() {
+ let tokens = tokenize("@class");
+ assert_eq!(tokens, vec![Token::At, Token::Name("class".to_string()),]);
+ }
+
+ #[test]
+ fn test_tokenize_function_call() {
+ let tokens = tokenize("contains(name, 'foo')");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::FunctionName("contains".to_string()),
+ Token::LeftParen,
+ Token::Name("name".to_string()),
+ Token::Comma,
+ Token::Literal("foo".to_string()),
+ Token::RightParen,
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_node_type() {
+ let tokens = tokenize("text()");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::NodeType("text".to_string()),
+ Token::LeftParen,
+ Token::RightParen,
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_all_node_types() {
+ for name in &["node", "text", "comment", "processing-instruction"] {
+ let input = format!("{name}()");
+ let tokens = tokenize(&input);
+ assert_eq!(tokens[0], Token::NodeType((*name).to_string()));
+ }
+ }
+
+ #[test]
+ fn test_tokenize_string_literals() {
+ let tokens = tokenize(r#""hello""#);
+ assert_eq!(tokens, vec![Token::Literal("hello".to_string())]);
+
+ let tokens = tokenize("'world'");
+ assert_eq!(tokens, vec![Token::Literal("world".to_string())]);
+ }
+
+ #[test]
+ fn test_tokenize_number_literals() {
+ let tokens = tokenize("42");
+ assert_eq!(tokens, vec![Token::Number(42.0)]);
+
+ let tokens = tokenize("3.5");
+ assert_eq!(tokens, vec![Token::Number(3.5)]);
+
+ let tokens = tokenize(".5");
+ assert_eq!(tokens, vec![Token::Number(0.5)]);
+
+ let tokens = tokenize("0.0");
+ assert_eq!(tokens, vec![Token::Number(0.0)]);
+ }
+
+ #[test]
+ fn test_tokenize_variable_reference() {
+ let tokens = tokenize("$foo");
+ assert_eq!(tokens, vec![Token::VariableReference("foo".to_string())]);
+ }
+
+ #[test]
+ fn test_tokenize_comparison_operators() {
+ let tokens = tokenize("a = b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::Equal,
+ Token::Name("b".to_string()),
+ ]
+ );
+
+ let tokens = tokenize("a != b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::NotEqual,
+ Token::Name("b".to_string()),
+ ]
+ );
+
+ let tokens = tokenize("a < b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::LessThan,
+ Token::Name("b".to_string()),
+ ]
+ );
+
+ let tokens = tokenize("a <= b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::LessThanEqual,
+ Token::Name("b".to_string()),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_arithmetic() {
+ let tokens = tokenize("1 + 2");
+ assert_eq!(
+ tokens,
+ vec![Token::Number(1.0), Token::Plus, Token::Number(2.0),]
+ );
+
+ let tokens = tokenize("a - b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::Minus,
+ Token::Name("b".to_string()),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_star_as_wildcard() {
+ // * at the start of an expression is a name test (wildcard), not multiply
+ let tokens = tokenize("*");
+ assert_eq!(tokens, vec![Token::Name("*".to_string())]);
+
+ // * after / is a name test
+ let tokens = tokenize("/*");
+ assert_eq!(tokens, vec![Token::Slash, Token::Name("*".to_string())]);
+ }
+
+ #[test]
+ fn test_tokenize_star_as_multiply() {
+ // * after a name (operand-ending) is multiply
+ let tokens = tokenize("a * b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::Star,
+ Token::Name("b".to_string()),
+ ]
+ );
+
+ // * after ) is multiply
+ let tokens = tokenize("count(x) * 2");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::FunctionName("count".to_string()),
+ Token::LeftParen,
+ Token::Name("x".to_string()),
+ Token::RightParen,
+ Token::Star,
+ Token::Number(2.0),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_keyword_operators() {
+ // 'and' and 'or' after operand-ending tokens are operators
+ let tokens = tokenize("a and b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::And,
+ Token::Name("b".to_string()),
+ ]
+ );
+
+ let tokens = tokenize("a or b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::Or,
+ Token::Name("b".to_string()),
+ ]
+ );
+
+ let tokens = tokenize("a div b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::Div,
+ Token::Name("b".to_string()),
+ ]
+ );
+
+ let tokens = tokenize("a mod b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::Mod,
+ Token::Name("b".to_string()),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_dot_and_dotdot() {
+ let tokens = tokenize("./.. ");
+ assert_eq!(tokens, vec![Token::Dot, Token::Slash, Token::DotDot,]);
+ }
+
+ #[test]
+ fn test_tokenize_complex_expression() {
+ let tokens = tokenize("//div[@class='main']/p[position() > 1]");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::DoubleSlash,
+ Token::Name("div".to_string()),
+ Token::LeftBracket,
+ Token::At,
+ Token::Name("class".to_string()),
+ Token::Equal,
+ Token::Literal("main".to_string()),
+ Token::RightBracket,
+ Token::Slash,
+ Token::Name("p".to_string()),
+ Token::LeftBracket,
+ Token::FunctionName("position".to_string()),
+ Token::LeftParen,
+ Token::RightParen,
+ Token::GreaterThan,
+ Token::Number(1.0),
+ Token::RightBracket,
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_union_operator() {
+ let tokens = tokenize("a | b");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::Pipe,
+ Token::Name("b".to_string()),
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_qname() {
+ let tokens = tokenize("svg:rect");
+ assert_eq!(tokens, vec![Token::Name("svg:rect".to_string())]);
+ }
+
+ #[test]
+ fn test_tokenize_axis_specifier() {
+ let tokens = tokenize("ancestor-or-self::node()");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::AxisName("ancestor-or-self".to_string()),
+ Token::ColonColon,
+ Token::NodeType("node".to_string()),
+ Token::LeftParen,
+ Token::RightParen,
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_empty_input() {
+ let tokens = tokenize("");
+ assert!(tokens.is_empty());
+ }
+
+ #[test]
+ fn test_tokenize_whitespace_only() {
+ let tokens = tokenize(" \t\n ");
+ assert!(tokens.is_empty());
+ }
+
+ #[test]
+ fn test_tokenize_unterminated_string_error() {
+ let mut lexer = Lexer::new("\"unterminated");
+ let result = lexer.tokenize();
+ assert!(result.is_err());
+ if let Err(err) = result {
+ assert!(err.message.contains("unterminated"));
+ }
+ }
+
+ #[test]
+ fn test_tokenize_invalid_char_after_bang() {
+ let mut lexer = Lexer::new("!x");
+ let result = lexer.tokenize();
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_tokenize_variable_reference_qname() {
+ let tokens = tokenize("$ns:var");
+ assert_eq!(tokens, vec![Token::VariableReference("ns:var".to_string())]);
+ }
+
+ #[test]
+ fn test_xpath_error_display() {
+ let err = XPathError {
+ message: "test error".to_string(),
+ position: 5,
+ };
+ assert_eq!(err.to_string(), "XPath error at position 5: test error");
+ }
+
+ #[test]
+ fn test_token_display() {
+ assert_eq!(Token::LeftParen.to_string(), "(");
+ assert_eq!(Token::RightParen.to_string(), ")");
+ assert_eq!(Token::Slash.to_string(), "/");
+ assert_eq!(Token::DoubleSlash.to_string(), "//");
+ assert_eq!(Token::Star.to_string(), "*");
+ assert_eq!(Token::Number(2.5).to_string(), "2.5");
+ assert_eq!(Token::Literal("hi".to_string()).to_string(), "\"hi\"");
+ assert_eq!(Token::VariableReference("x".to_string()).to_string(), "$x");
+ }
+
+ #[test]
+ fn test_tokenize_multiple_predicates() {
+ let tokens = tokenize("p[1][@class]");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("p".to_string()),
+ Token::LeftBracket,
+ Token::Number(1.0),
+ Token::RightBracket,
+ Token::LeftBracket,
+ Token::At,
+ Token::Name("class".to_string()),
+ Token::RightBracket,
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_nested_function_calls() {
+ let tokens = tokenize("concat(substring(a, 1), 'x')");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::FunctionName("concat".to_string()),
+ Token::LeftParen,
+ Token::FunctionName("substring".to_string()),
+ Token::LeftParen,
+ Token::Name("a".to_string()),
+ Token::Comma,
+ Token::Number(1.0),
+ Token::RightParen,
+ Token::Comma,
+ Token::Literal("x".to_string()),
+ Token::RightParen,
+ ]
+ );
+ }
+
+ #[test]
+ fn test_tokenize_unary_minus() {
+ let tokens = tokenize("-5");
+ assert_eq!(tokens, vec![Token::Minus, Token::Number(5.0),]);
+ }
+
+ #[test]
+ fn test_tokenize_greater_than_equal() {
+ let tokens = tokenize("a >= 10");
+ assert_eq!(
+ tokens,
+ vec![
+ Token::Name("a".to_string()),
+ Token::GreaterThanEqual,
+ Token::Number(10.0),
+ ]
+ );
+ }
+}
diff --git a/browser/vendor/xmloxide/src/xpath/mod.rs b/browser/vendor/xmloxide/src/xpath/mod.rs
new file mode 100644
index 000000000..14c7eda00
--- /dev/null
+++ b/browser/vendor/xmloxide/src/xpath/mod.rs
@@ -0,0 +1,81 @@
+//! `XPath` 1.0 query language implementation.
+//!
+//! This module provides an implementation of the `XPath` 1.0 specification
+//! (<https://www.w3.org/TR/xpath-10/>), including expression parsing and
+//! evaluation against an XML document tree.
+//!
+//! # Quick Start
+//!
+//! ```
+//! use xmloxide::Document;
+//! use xmloxide::xpath::{evaluate, XPathValue};
+//!
+//! let doc = Document::parse_str("<root><a>1</a><b>2</b></root>").unwrap();
+//! let root = doc.root_element().unwrap();
+//! let result = evaluate(&doc, root, "count(*)").unwrap();
+//! assert_eq!(result.to_number(), 2.0);
+//! ```
+//!
+//! # Known Limitations
+//!
+//! - The `namespace::` axis returns the element's `NodeId` when in-scope
+//! namespaces match. Namespace nodes are not materialized as separate
+//! nodes (attribute nodes are — see [`types::XPathNode`]).
+//!
+//! # Submodules
+//!
+//! - [`ast`]: Abstract syntax tree types for parsed `XPath` expressions.
+//! - [`lexer`]: Tokenizer for `XPath` expression strings.
+//! - [`types`]: `XPath` value types and comparison helpers.
+//! - [`parser`]: Recursive descent parser for `XPath` expressions.
+//! - [`eval`]: Expression evaluator against a document tree.
+
+pub mod ast;
+pub mod eval;
+pub mod lexer;
+pub mod parser;
+pub(crate) mod regex;
+pub mod types;
+
+pub use eval::XPathContext;
+pub use types::{XPathError, XPathNode, XPathValue};
+
+use crate::tree::{Document, NodeId};
+
+/// Evaluates an `XPath` 1.0 expression against a document node.
+///
+/// This is a convenience function that parses the expression and evaluates it
+/// in a single call. For evaluating the same expression against multiple
+/// context nodes, use [`parser::parse`] and [`XPathContext::evaluate`]
+/// separately to avoid re-parsing.
+///
+/// # Examples
+///
+/// ```
+/// use xmloxide::Document;
+/// use xmloxide::xpath::{evaluate, XPathValue};
+///
+/// let doc = Document::parse_str("<root><child>Hello</child></root>").unwrap();
+/// let root = doc.root_element().unwrap();
+///
+/// // Count child elements
+/// let result = evaluate(&doc, root, "count(*)").unwrap();
+/// assert_eq!(result.to_number(), 1.0);
+///
+/// // Get text content
+/// let result = evaluate(&doc, root, "string(child)").unwrap();
+/// assert_eq!(result.to_xpath_string(), "Hello");
+/// ```
+///
+/// # Errors
+///
+/// Returns [`XPathError`] if the expression is malformed or evaluation fails.
+pub fn evaluate(
+ doc: &Document,
+ context_node: NodeId,
+ expression: &str,
+) -> Result<XPathValue, XPathError> {
+ let expr = parser::parse(expression)?;
+ let ctx = XPathContext::new(doc, context_node);
+ ctx.evaluate(&expr)
+}
diff --git a/browser/vendor/xmloxide/src/xpath/parser.rs b/browser/vendor/xmloxide/src/xpath/parser.rs
new file mode 100644
index 000000000..641b6ba37
--- /dev/null
+++ b/browser/vendor/xmloxide/src/xpath/parser.rs
@@ -0,0 +1,1500 @@
+//! `XPath` 1.0 expression parser.
+//!
+//! This module implements a recursive descent parser for `XPath` 1.0 expressions
+//! as specified in <https://www.w3.org/TR/xpath-10/#section-Grammar>. The parser
+//! consumes a `Vec<Token>` (produced by the [`super::lexer::Lexer`]) and
+//! produces an [`Expr`] AST.
+//!
+//! # Operator Precedence
+//!
+//! From lowest to highest:
+//! 1. `or`
+//! 2. `and`
+//! 3. `=`, `!=` (equality)
+//! 4. `<`, `<=`, `>`, `>=` (relational)
+//! 5. `+`, `-` (additive)
+//! 6. `*`, `div`, `mod` (multiplicative)
+//! 7. Unary `-`
+//! 8. `|` (union)
+//! 9. Filter expressions (primary expression with predicates)
+//! 10. Path expressions (location paths)
+//!
+//! # Grammar Productions
+//!
+//! The parser follows the `XPath` 1.0 grammar closely, with each grammar
+//! production implemented as a method on the internal `Parser` struct.
+
+use super::ast::{Axis, BinaryOp, Expr, NodeTest, Step};
+use super::lexer::{Lexer, Token, XPathError};
+
+/// Parses an `XPath` expression string into an AST.
+///
+/// This function tokenizes the input using the [`Lexer`] and then parses the
+/// token stream into an [`Expr`] AST using a recursive descent parser.
+///
+/// # Errors
+///
+/// Returns [`XPathError`] if the input is not a valid `XPath` 1.0 expression.
+/// The error includes a human-readable message and the byte offset where the
+/// error was detected.
+///
+/// # Examples
+///
+/// ```ignore
+/// use xmloxide::xpath::parser::parse;
+///
+/// let expr = parse("/html/body/p").unwrap();
+/// let expr = parse("//book[@price > 10.00]").unwrap();
+/// ```
+pub fn parse(input: &str) -> Result<Expr, XPathError> {
+ let mut lexer = Lexer::new(input);
+ let tokens = lexer.tokenize()?;
+
+ if tokens.is_empty() {
+ return Err(XPathError {
+ message: "empty XPath expression".to_string(),
+ position: 0,
+ });
+ }
+
+ let mut parser = Parser::new(tokens);
+ let expr = parser.parse_expr()?;
+
+ if parser.pos < parser.tokens.len() {
+ return Err(parser.error(&format!(
+ "unexpected token '{}' after expression",
+ parser.tokens[parser.pos]
+ )));
+ }
+
+ Ok(expr)
+}
+
+/// Internal recursive descent parser for `XPath` 1.0 token streams.
+struct Parser {
+ /// The token stream produced by the lexer.
+ tokens: Vec<Token>,
+ /// Current position in the token stream.
+ pos: usize,
+}
+
+impl Parser {
+ /// Creates a new parser for the given token stream.
+ fn new(tokens: Vec<Token>) -> Self {
+ Self { tokens, pos: 0 }
+ }
+
+ // -----------------------------------------------------------------------
+ // Token access helpers
+ // -----------------------------------------------------------------------
+
+ /// Returns a reference to the current token, or `None` if at end.
+ fn peek(&self) -> Option<&Token> {
+ self.tokens.get(self.pos)
+ }
+
+ /// Returns `true` if the current token matches the given token.
+ fn check(&self, token: &Token) -> bool {
+ self.peek() == Some(token)
+ }
+
+ /// Consumes the current token if it matches `token`, returning `true`.
+ /// Returns `false` without consuming if it does not match.
+ fn eat(&mut self, token: &Token) -> bool {
+ if self.check(token) {
+ self.pos += 1;
+ true
+ } else {
+ false
+ }
+ }
+
+ /// Consumes the current token if it matches `token`, or returns an error.
+ fn expect(&mut self, token: &Token) -> Result<(), XPathError> {
+ if self.eat(token) {
+ Ok(())
+ } else {
+ Err(self.error(&format!(
+ "expected '{}', found {}",
+ token,
+ self.describe_current()
+ )))
+ }
+ }
+
+ /// Advances the parser by one token and returns the consumed token.
+ fn advance(&mut self) -> Option<Token> {
+ if self.pos < self.tokens.len() {
+ let token = self.tokens[self.pos].clone();
+ self.pos += 1;
+ Some(token)
+ } else {
+ None
+ }
+ }
+
+ /// Returns a human-readable description of the current token (for errors).
+ fn describe_current(&self) -> String {
+ self.peek()
+ .map_or_else(|| "end of expression".to_string(), |t| format!("'{t}'"))
+ }
+
+ /// Creates an error at the current position.
+ fn error(&self, message: &str) -> XPathError {
+ XPathError {
+ message: message.to_string(),
+ position: self.pos,
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Grammar productions
+ // -----------------------------------------------------------------------
+
+ /// Parses an `XPath` expression.
+ ///
+ /// ```text
+ /// Expr ::= OrExpr
+ /// ```
+ /// See `XPath` 1.0 section 3.
+ fn parse_expr(&mut self) -> Result<Expr, XPathError> {
+ self.parse_or_expr()
+ }
+
+ /// Parses an `or` expression.
+ ///
+ /// ```text
+ /// OrExpr ::= AndExpr ('or' AndExpr)*
+ /// ```
+ /// See `XPath` 1.0 section 3.4.
+ fn parse_or_expr(&mut self) -> Result<Expr, XPathError> {
+ let mut left = self.parse_and_expr()?;
+ while self.eat(&Token::Or) {
+ let right = self.parse_and_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Or,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ }
+ Ok(left)
+ }
+
+ /// Parses an `and` expression.
+ ///
+ /// ```text
+ /// AndExpr ::= EqualityExpr ('and' EqualityExpr)*
+ /// ```
+ /// See `XPath` 1.0 section 3.4.
+ fn parse_and_expr(&mut self) -> Result<Expr, XPathError> {
+ let mut left = self.parse_equality_expr()?;
+ while self.eat(&Token::And) {
+ let right = self.parse_equality_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::And,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ }
+ Ok(left)
+ }
+
+ /// Parses an equality expression.
+ ///
+ /// ```text
+ /// EqualityExpr ::= RelationalExpr (('=' | '!=') RelationalExpr)*
+ /// ```
+ /// See `XPath` 1.0 section 3.4.
+ fn parse_equality_expr(&mut self) -> Result<Expr, XPathError> {
+ let mut left = self.parse_relational_expr()?;
+ loop {
+ if self.eat(&Token::Equal) {
+ let right = self.parse_relational_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Eq,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else if self.eat(&Token::NotEqual) {
+ let right = self.parse_relational_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Neq,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else {
+ break;
+ }
+ }
+ Ok(left)
+ }
+
+ /// Parses a relational expression.
+ ///
+ /// ```text
+ /// RelationalExpr ::= AdditiveExpr (('<' | '<=' | '>' | '>=') AdditiveExpr)*
+ /// ```
+ /// See `XPath` 1.0 section 3.4.
+ fn parse_relational_expr(&mut self) -> Result<Expr, XPathError> {
+ let mut left = self.parse_additive_expr()?;
+ loop {
+ let op = if self.eat(&Token::LessThan) {
+ Some(BinaryOp::Lt)
+ } else if self.eat(&Token::LessThanEqual) {
+ Some(BinaryOp::Lte)
+ } else if self.eat(&Token::GreaterThan) {
+ Some(BinaryOp::Gt)
+ } else if self.eat(&Token::GreaterThanEqual) {
+ Some(BinaryOp::Gte)
+ } else {
+ None
+ };
+ if let Some(op) = op {
+ let right = self.parse_additive_expr()?;
+ left = Expr::BinaryOp {
+ op,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else {
+ break;
+ }
+ }
+ Ok(left)
+ }
+
+ /// Parses an additive expression.
+ ///
+ /// ```text
+ /// AdditiveExpr ::= MultiplicativeExpr (('+' | '-') MultiplicativeExpr)*
+ /// ```
+ /// See `XPath` 1.0 section 3.5.
+ fn parse_additive_expr(&mut self) -> Result<Expr, XPathError> {
+ let mut left = self.parse_multiplicative_expr()?;
+ loop {
+ if self.eat(&Token::Plus) {
+ let right = self.parse_multiplicative_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Add,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else if self.eat(&Token::Minus) {
+ let right = self.parse_multiplicative_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Sub,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else {
+ break;
+ }
+ }
+ Ok(left)
+ }
+
+ /// Parses a multiplicative expression.
+ ///
+ /// ```text
+ /// MultiplicativeExpr ::= UnaryExpr (('*' | 'div' | 'mod') UnaryExpr)*
+ /// ```
+ /// See `XPath` 1.0 section 3.5.
+ fn parse_multiplicative_expr(&mut self) -> Result<Expr, XPathError> {
+ let mut left = self.parse_unary_expr()?;
+ loop {
+ if self.eat(&Token::Star) {
+ let right = self.parse_unary_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Mul,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else if self.eat(&Token::Div) {
+ let right = self.parse_unary_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Div,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else if self.eat(&Token::Mod) {
+ let right = self.parse_unary_expr()?;
+ left = Expr::BinaryOp {
+ op: BinaryOp::Mod,
+ left: Box::new(left),
+ right: Box::new(right),
+ };
+ } else {
+ break;
+ }
+ }
+ Ok(left)
+ }
+
+ /// Parses a unary expression.
+ ///
+ /// ```text
+ /// UnaryExpr ::= '-'* UnionExpr
+ /// ```
+ /// See `XPath` 1.0 section 3.5.
+ fn parse_unary_expr(&mut self) -> Result<Expr, XPathError> {
+ if self.eat(&Token::Minus) {
+ let inner = self.parse_unary_expr()?;
+ Ok(Expr::UnaryNeg(Box::new(inner)))
+ } else {
+ self.parse_union_expr()
+ }
+ }
+
+ /// Parses a union expression.
+ ///
+ /// ```text
+ /// UnionExpr ::= PathExpr ('|' PathExpr)*
+ /// ```
+ /// See `XPath` 1.0 section 3.3.
+ fn parse_union_expr(&mut self) -> Result<Expr, XPathError> {
+ let mut left = self.parse_path_expr()?;
+ while self.eat(&Token::Pipe) {
+ let right = self.parse_path_expr()?;
+ left = Expr::Union(Box::new(left), Box::new(right));
+ }
+ Ok(left)
+ }
+
+ /// Parses a path expression.
+ ///
+ /// ```text
+ /// PathExpr ::= LocationPath
+ /// | FilterExpr
+ /// | FilterExpr '/' RelativeLocationPath
+ /// | FilterExpr '//' RelativeLocationPath
+ /// ```
+ ///
+ /// The tricky part is distinguishing location paths from filter expressions.
+ /// A location path starts with `/`, `//`, `.`, `..`, `@`, an axis name, a
+ /// node type, or a name test. A filter expression starts with a primary
+ /// expression (variable, literal, number, function call, or parenthesized
+ /// expression).
+ ///
+ /// See `XPath` 1.0 section 3.3.
+ fn parse_path_expr(&mut self) -> Result<Expr, XPathError> {
+ match self.peek() {
+ // Tokens that start a location path: `/`, `//`, `.`, `..`, `@`,
+ // axis names, node types, or name tests.
+ Some(
+ Token::Slash
+ | Token::DoubleSlash
+ | Token::Dot
+ | Token::DotDot
+ | Token::At
+ | Token::AxisName(_)
+ | Token::NodeType(_)
+ | Token::Name(_),
+ ) => self.parse_location_path(),
+
+ // Primary expressions: variable, literal, number, function call,
+ // or parenthesized expression. These start filter expressions.
+ Some(
+ Token::VariableReference(_)
+ | Token::Literal(_)
+ | Token::Number(_)
+ | Token::LeftParen
+ | Token::FunctionName(_),
+ ) => {
+ let expr = self.parse_filter_expr()?;
+
+ // A filter expression can be followed by '/' or '//' to
+ // extend it with a relative location path.
+ if self.check(&Token::Slash) || self.check(&Token::DoubleSlash) {
+ self.parse_filter_path_continuation(expr)
+ } else {
+ Ok(expr)
+ }
+ }
+
+ _ => Err(self.error(&format!(
+ "expected expression, found {}",
+ self.describe_current()
+ ))),
+ }
+ }
+
+ /// Parses the `'/' relative_path` or `'//' relative_path` continuation
+ /// after a filter expression.
+ ///
+ /// Produces an [`Expr::FilterPath`] holding the filter expression and
+ /// the continuation steps; the evaluator applies the steps to the
+ /// filter's node-set result. See `XPath` 1.0 section 3.3 (`PathExpr`).
+ fn parse_filter_path_continuation(&mut self, filter: Expr) -> Result<Expr, XPathError> {
+ let mut steps = Vec::new();
+
+ if self.eat(&Token::DoubleSlash) {
+ // '//' is shorthand for /descendant-or-self::node()/
+ steps.push(Step {
+ axis: Axis::DescendantOrSelf,
+ node_test: NodeTest::Node,
+ predicates: Vec::new(),
+ });
+ } else {
+ self.expect(&Token::Slash)?;
+ }
+
+ // Parse the relative location path
+ self.parse_relative_location_path_into(&mut steps)?;
+
+ Ok(Expr::FilterPath {
+ expr: Box::new(filter),
+ steps,
+ })
+ }
+
+ /// Parses a filter expression.
+ ///
+ /// ```text
+ /// FilterExpr ::= PrimaryExpr Predicate*
+ /// ```
+ /// See `XPath` 1.0 section 3.3.
+ fn parse_filter_expr(&mut self) -> Result<Expr, XPathError> {
+ let expr = self.parse_primary_expr()?;
+ let predicates = self.parse_predicates()?;
+
+ if predicates.is_empty() {
+ Ok(expr)
+ } else {
+ Ok(Expr::Filter {
+ expr: Box::new(expr),
+ predicates,
+ })
+ }
+ }
+
+ /// Parses a primary expression.
+ ///
+ /// ```text
+ /// PrimaryExpr ::= VariableReference
+ /// | '(' Expr ')'
+ /// | Literal
+ /// | Number
+ /// | FunctionCall
+ /// ```
+ /// See `XPath` 1.0 section 3.5.
+ fn parse_primary_expr(&mut self) -> Result<Expr, XPathError> {
+ match self.peek().cloned() {
+ Some(Token::VariableReference(name)) => {
+ self.pos += 1;
+ Ok(Expr::Variable(name))
+ }
+ Some(Token::Literal(value)) => {
+ self.pos += 1;
+ Ok(Expr::String(value))
+ }
+ Some(Token::Number(value)) => {
+ self.pos += 1;
+ Ok(Expr::Number(value))
+ }
+ Some(Token::LeftParen) => {
+ self.pos += 1; // consume '('
+ let expr = self.parse_expr()?;
+ self.expect(&Token::RightParen)?;
+ Ok(expr)
+ }
+ Some(Token::FunctionName(_)) => self.parse_function_call(),
+ _ => Err(self.error(&format!(
+ "expected primary expression, found {}",
+ self.describe_current()
+ ))),
+ }
+ }
+
+ /// Parses a function call.
+ ///
+ /// ```text
+ /// FunctionCall ::= FunctionName '(' (Argument (',' Argument)*)? ')'
+ /// Argument ::= Expr
+ /// ```
+ /// See `XPath` 1.0 section 3.2.
+ fn parse_function_call(&mut self) -> Result<Expr, XPathError> {
+ let Some(Token::FunctionName(name)) = self.advance() else {
+ return Err(self.error("expected function name"));
+ };
+ self.expect(&Token::LeftParen)?;
+
+ let mut args = Vec::new();
+ if !self.check(&Token::RightParen) {
+ args.push(self.parse_expr()?);
+ while self.eat(&Token::Comma) {
+ args.push(self.parse_expr()?);
+ }
+ }
+
+ self.expect(&Token::RightParen)?;
+
+ Ok(Expr::FunctionCall { name, args })
+ }
+
+ /// Parses a location path.
+ ///
+ /// ```text
+ /// LocationPath ::= RelativeLocationPath
+ /// | AbsoluteLocationPath
+ /// AbsoluteLocationPath ::= '/' RelativeLocationPath?
+ /// | AbbreviatedAbsoluteLocationPath
+ /// AbbreviatedAbsoluteLocationPath ::= '//' RelativeLocationPath
+ /// ```
+ /// See `XPath` 1.0 section 2.
+ fn parse_location_path(&mut self) -> Result<Expr, XPathError> {
+ if self.check(&Token::Slash) {
+ self.pos += 1; // consume '/'
+ let mut steps = Vec::new();
+
+ // Check if there's a relative location path after '/'
+ if self.is_step_start() {
+ self.parse_relative_location_path_into(&mut steps)?;
+ }
+
+ Ok(Expr::RootPath { steps })
+ } else if self.eat(&Token::DoubleSlash) {
+ // '//' is shorthand for '/descendant-or-self::node()/'
+ let mut steps = vec![Step {
+ axis: Axis::DescendantOrSelf,
+ node_test: NodeTest::Node,
+ predicates: Vec::new(),
+ }];
+ self.parse_relative_location_path_into(&mut steps)?;
+ Ok(Expr::RootPath { steps })
+ } else {
+ // Relative location path
+ let mut steps = Vec::new();
+ self.parse_relative_location_path_into(&mut steps)?;
+ Ok(Expr::Path { steps })
+ }
+ }
+
+ /// Parses a relative location path, appending steps to the provided vector.
+ ///
+ /// ```text
+ /// RelativeLocationPath ::= Step
+ /// | RelativeLocationPath '/' Step
+ /// | AbbreviatedRelativeLocationPath
+ /// AbbreviatedRelativeLocationPath ::= RelativeLocationPath '//' Step
+ /// ```
+ /// See `XPath` 1.0 section 2.
+ fn parse_relative_location_path_into(
+ &mut self,
+ steps: &mut Vec<Step>,
+ ) -> Result<(), XPathError> {
+ steps.push(self.parse_step()?);
+
+ loop {
+ if self.eat(&Token::DoubleSlash) {
+ // '//' inserts a descendant-or-self::node() step
+ steps.push(Step {
+ axis: Axis::DescendantOrSelf,
+ node_test: NodeTest::Node,
+ predicates: Vec::new(),
+ });
+ steps.push(self.parse_step()?);
+ } else if self.eat(&Token::Slash) {
+ // Only continue if the next token can start a step
+ if self.is_step_start() {
+ steps.push(self.parse_step()?);
+ } else {
+ // Trailing slash with no step -- put it back
+ self.pos -= 1;
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Returns `true` if the current token can begin a location step.
+ fn is_step_start(&self) -> bool {
+ matches!(
+ self.peek(),
+ Some(
+ Token::Dot
+ | Token::DotDot
+ | Token::At
+ | Token::Name(_)
+ | Token::NodeType(_)
+ | Token::AxisName(_)
+ )
+ )
+ }
+
+ /// Parses a single step in a location path.
+ ///
+ /// ```text
+ /// Step ::= AxisSpecifier NodeTest Predicate*
+ /// | AbbreviatedStep
+ /// AbbreviatedStep ::= '.' | '..'
+ /// ```
+ /// See `XPath` 1.0 section 2.1.
+ fn parse_step(&mut self) -> Result<Step, XPathError> {
+ // Handle abbreviated steps
+ if self.eat(&Token::Dot) {
+ // '.' is shorthand for self::node()
+ return Ok(Step {
+ axis: Axis::Self_,
+ node_test: NodeTest::Node,
+ predicates: Vec::new(),
+ });
+ }
+ if self.eat(&Token::DotDot) {
+ // '..' is shorthand for parent::node()
+ return Ok(Step {
+ axis: Axis::Parent,
+ node_test: NodeTest::Node,
+ predicates: Vec::new(),
+ });
+ }
+
+ // Parse axis specifier
+ let axis = self.parse_axis_specifier();
+
+ // Parse node test
+ let node_test = self.parse_node_test()?;
+
+ // Parse predicates
+ let predicates = self.parse_predicates()?;
+
+ Ok(Step {
+ axis,
+ node_test,
+ predicates,
+ })
+ }
+
+ /// Parses an axis specifier.
+ ///
+ /// ```text
+ /// AxisSpecifier ::= AxisName '::'
+ /// | AbbreviatedAxisSpecifier
+ /// AbbreviatedAxisSpecifier ::= '@'?
+ /// ```
+ /// See `XPath` 1.0 section 2.2.
+ fn parse_axis_specifier(&mut self) -> Axis {
+ if self.eat(&Token::At) {
+ // '@' is shorthand for attribute::
+ return Axis::Attribute;
+ }
+
+ // Check for AxisName '::'
+ if let Some(Token::AxisName(name)) = self.peek().cloned() {
+ if self.tokens.get(self.pos + 1) == Some(&Token::ColonColon) {
+ if let Some(axis) = Axis::parse(&name) {
+ self.pos += 2; // consume axis name and '::'
+ return axis;
+ }
+ }
+ }
+
+ // Default axis is child
+ Axis::Child
+ }
+
+ /// Parses a node test.
+ ///
+ /// ```text
+ /// NodeTest ::= NameTest
+ /// | NodeType '(' ')'
+ /// | 'processing-instruction' '(' Literal ')'
+ /// NameTest ::= '*'
+ /// | NCName ':' '*'
+ /// | QName
+ /// ```
+ /// See `XPath` 1.0 section 2.3.
+ fn parse_node_test(&mut self) -> Result<NodeTest, XPathError> {
+ match self.peek().cloned() {
+ Some(Token::NodeType(name)) => {
+ self.pos += 1; // consume node type name
+ self.expect(&Token::LeftParen)?;
+
+ let node_test = match name.as_str() {
+ "node" => {
+ self.expect(&Token::RightParen)?;
+ NodeTest::Node
+ }
+ "text" => {
+ self.expect(&Token::RightParen)?;
+ NodeTest::Text
+ }
+ "comment" => {
+ self.expect(&Token::RightParen)?;
+ NodeTest::Comment
+ }
+ "processing-instruction" => {
+ // Optional literal argument
+ if let Some(Token::Literal(target)) = self.peek().cloned() {
+ self.pos += 1;
+ self.expect(&Token::RightParen)?;
+ NodeTest::ProcessingInstruction(Some(target))
+ } else {
+ self.expect(&Token::RightParen)?;
+ NodeTest::ProcessingInstruction(None)
+ }
+ }
+ _ => {
+ return Err(self.error(&format!("unknown node type: {name}")));
+ }
+ };
+
+ Ok(node_test)
+ }
+ Some(Token::Name(name)) => {
+ self.pos += 1;
+ if name == "*" {
+ Ok(NodeTest::Wildcard)
+ } else if let Some(prefix) = name.strip_suffix(":*") {
+ Ok(NodeTest::PrefixWildcard(prefix.to_string()))
+ } else {
+ Ok(NodeTest::Name(name))
+ }
+ }
+ _ => Err(self.error(&format!(
+ "expected node test, found {}",
+ self.describe_current()
+ ))),
+ }
+ }
+
+ /// Parses zero or more predicates.
+ ///
+ /// ```text
+ /// Predicate ::= '[' PredicateExpr ']'
+ /// PredicateExpr ::= Expr
+ /// ```
+ /// See `XPath` 1.0 section 2.4.
+ fn parse_predicates(&mut self) -> Result<Vec<Expr>, XPathError> {
+ let mut predicates = Vec::new();
+ while self.check(&Token::LeftBracket) {
+ self.pos += 1; // consume '['
+ let expr = self.parse_expr()?;
+ self.expect(&Token::RightBracket)?;
+ predicates.push(expr);
+ }
+ Ok(predicates)
+ }
+}
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ // -----------------------------------------------------------------------
+ // Helper for concise test assertions
+ // -----------------------------------------------------------------------
+
+ /// Parses the input and returns the AST, panicking on error.
+ fn p(input: &str) -> Expr {
+ parse(input).unwrap()
+ }
+
+ /// Asserts that parsing the input fails.
+ fn assert_parse_error(input: &str) {
+ assert!(parse(input).is_err(), "expected parse error for: {input}");
+ }
+
+ // -----------------------------------------------------------------------
+ // Simple paths
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_root_only() {
+ // `/` alone is a valid XPath selecting the root node
+ let expr = p("/");
+ match expr {
+ Expr::RootPath { ref steps } => assert!(steps.is_empty()),
+ _ => panic!("expected RootPath, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_absolute_path_single_step() {
+ // `/root`
+ let expr = p("/root");
+ match expr {
+ Expr::RootPath { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].axis, Axis::Child);
+ assert_eq!(steps[0].node_test, NodeTest::Name("root".to_string()));
+ }
+ _ => panic!("expected RootPath, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_relative_path() {
+ // `root/child`
+ let expr = p("root/child");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 2);
+ assert_eq!(steps[0].node_test, NodeTest::Name("root".to_string()));
+ assert_eq!(steps[1].node_test, NodeTest::Name("child".to_string()));
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_double_slash_path() {
+ // `//child`
+ let expr = p("//child");
+ match expr {
+ Expr::RootPath { ref steps } => {
+ assert_eq!(steps.len(), 2);
+ // First step is the implicit descendant-or-self::node()
+ assert_eq!(steps[0].axis, Axis::DescendantOrSelf);
+ assert_eq!(steps[0].node_test, NodeTest::Node);
+ // Second step is child::child
+ assert_eq!(steps[1].axis, Axis::Child);
+ assert_eq!(steps[1].node_test, NodeTest::Name("child".to_string()));
+ }
+ _ => panic!("expected RootPath, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Abbreviated syntax
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_dot() {
+ // `.` is self::node()
+ let expr = p(".");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].axis, Axis::Self_);
+ assert_eq!(steps[0].node_test, NodeTest::Node);
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_dotdot() {
+ // `..` is parent::node()
+ let expr = p("..");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].axis, Axis::Parent);
+ assert_eq!(steps[0].node_test, NodeTest::Node);
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_at_attribute() {
+ // `@attr` is attribute::attr
+ let expr = p("@attr");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].axis, Axis::Attribute);
+ assert_eq!(steps[0].node_test, NodeTest::Name("attr".to_string()));
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_dot_double_slash_child() {
+ // `.//child` is self::node() / descendant-or-self::node() / child::child
+ let expr = p(".//child");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 3);
+ assert_eq!(steps[0].axis, Axis::Self_);
+ assert_eq!(steps[0].node_test, NodeTest::Node);
+ assert_eq!(steps[1].axis, Axis::DescendantOrSelf);
+ assert_eq!(steps[1].node_test, NodeTest::Node);
+ assert_eq!(steps[2].axis, Axis::Child);
+ assert_eq!(steps[2].node_test, NodeTest::Name("child".to_string()));
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Predicates
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_predicate_numeric() {
+ // `child[1]`
+ let expr = p("child[1]");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].node_test, NodeTest::Name("child".to_string()));
+ assert_eq!(steps[0].predicates.len(), 1);
+ match &steps[0].predicates[0] {
+ Expr::Number(n) => assert!((n - 1.0).abs() < f64::EPSILON),
+ other => panic!("expected Number predicate, got: {other:?}"),
+ }
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_predicate_attribute_eq() {
+ // `child[@id='x']`
+ let expr = p("child[@id='x']");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].predicates.len(), 1);
+ match &steps[0].predicates[0] {
+ Expr::BinaryOp { op, left, right } => {
+ assert_eq!(*op, BinaryOp::Eq);
+ // LHS should be @id (attribute::id path)
+ match left.as_ref() {
+ Expr::Path { steps } => {
+ assert_eq!(steps[0].axis, Axis::Attribute);
+ assert_eq!(steps[0].node_test, NodeTest::Name("id".to_string()));
+ }
+ other => panic!("expected Path for @id, got: {other:?}"),
+ }
+ // RHS should be 'x'
+ match right.as_ref() {
+ Expr::String(s) => assert_eq!(s, "x"),
+ other => panic!("expected String 'x', got: {other:?}"),
+ }
+ }
+ other => panic!("expected BinaryOp predicate, got: {other:?}"),
+ }
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_predicate_function_call() {
+ // `child[position()=1]`
+ let expr = p("child[position()=1]");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].predicates.len(), 1);
+ match &steps[0].predicates[0] {
+ Expr::BinaryOp { op, left, .. } => {
+ assert_eq!(*op, BinaryOp::Eq);
+ match left.as_ref() {
+ Expr::FunctionCall { name, args } => {
+ assert_eq!(name, "position");
+ assert!(args.is_empty());
+ }
+ other => panic!("expected FunctionCall, got: {other:?}"),
+ }
+ }
+ other => panic!("expected BinaryOp, got: {other:?}"),
+ }
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Operators
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_addition() {
+ // `1 + 2`
+ let expr = p("1 + 2");
+ match expr {
+ Expr::BinaryOp { op, left, right } => {
+ assert_eq!(op, BinaryOp::Add);
+ match (*left, *right) {
+ (Expr::Number(l), Expr::Number(r)) => {
+ assert!((l - 1.0).abs() < f64::EPSILON);
+ assert!((r - 2.0).abs() < f64::EPSILON);
+ }
+ (l, r) => panic!("expected Number operands, got: {l:?}, {r:?}"),
+ }
+ }
+ _ => panic!("expected BinaryOp, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_equality() {
+ // `a = b`
+ let expr = p("a = b");
+ match expr {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::Eq),
+ _ => panic!("expected BinaryOp Eq, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_and() {
+ // `a and b`
+ let expr = p("a and b");
+ match expr {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::And),
+ _ => panic!("expected BinaryOp And, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_or() {
+ // `a or b`
+ let expr = p("a or b");
+ match expr {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::Or),
+ _ => panic!("expected BinaryOp Or, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Function calls
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_function_call_count() {
+ // `count(//node)`
+ let expr = p("count(//node)");
+ match expr {
+ Expr::FunctionCall { name, args } => {
+ assert_eq!(name, "count");
+ assert_eq!(args.len(), 1);
+ }
+ _ => panic!("expected FunctionCall, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_function_call_string_length() {
+ // `string-length('hello')`
+ let expr = p("string-length('hello')");
+ match expr {
+ Expr::FunctionCall { name, args } => {
+ assert_eq!(name, "string-length");
+ assert_eq!(args.len(), 1);
+ match &args[0] {
+ Expr::String(s) => assert_eq!(s, "hello"),
+ other => panic!("expected String arg, got: {other:?}"),
+ }
+ }
+ _ => panic!("expected FunctionCall, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_function_call_concat() {
+ // `concat('a', 'b', 'c')`
+ let expr = p("concat('a', 'b', 'c')");
+ match expr {
+ Expr::FunctionCall { name, args } => {
+ assert_eq!(name, "concat");
+ assert_eq!(args.len(), 3);
+ for (i, expected) in ["a", "b", "c"].iter().enumerate() {
+ match &args[i] {
+ Expr::String(s) => assert_eq!(s, *expected),
+ other => panic!("expected String arg, got: {other:?}"),
+ }
+ }
+ }
+ _ => panic!("expected FunctionCall, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Complex expressions
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_complex_predicate_with_comparison() {
+ // `//book[@price > 10.00]`
+ let expr = p("//book[@price > 10.00]");
+ match expr {
+ Expr::RootPath { ref steps } => {
+ // descendant-or-self::node(), child::book[@price > 10]
+ assert_eq!(steps.len(), 2);
+ assert_eq!(steps[1].node_test, NodeTest::Name("book".to_string()));
+ assert_eq!(steps[1].predicates.len(), 1);
+ match &steps[1].predicates[0] {
+ Expr::BinaryOp { op, .. } => assert_eq!(*op, BinaryOp::Gt),
+ other => panic!("expected BinaryOp Gt, got: {other:?}"),
+ }
+ }
+ _ => panic!("expected RootPath, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_complex_path_with_last() {
+ // `/root/child[last()]/text()`
+ let expr = p("/root/child[last()]/text()");
+ match expr {
+ Expr::RootPath { ref steps } => {
+ assert_eq!(steps.len(), 3);
+ assert_eq!(steps[0].node_test, NodeTest::Name("root".to_string()));
+ assert_eq!(steps[1].node_test, NodeTest::Name("child".to_string()));
+ assert_eq!(steps[1].predicates.len(), 1);
+ match &steps[1].predicates[0] {
+ Expr::FunctionCall { name, args } => {
+ assert_eq!(name, "last");
+ assert!(args.is_empty());
+ }
+ other => panic!("expected FunctionCall last(), got: {other:?}"),
+ }
+ assert_eq!(steps[2].node_test, NodeTest::Text);
+ }
+ _ => panic!("expected RootPath, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Union
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_union() {
+ // `a | b`
+ let expr = p("a | b");
+ match expr {
+ Expr::Union(left, right) => {
+ match *left {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps[0].node_test, NodeTest::Name("a".to_string()));
+ }
+ _ => panic!("expected Path for left union operand"),
+ }
+ match *right {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps[0].node_test, NodeTest::Name("b".to_string()));
+ }
+ _ => panic!("expected Path for right union operand"),
+ }
+ }
+ _ => panic!("expected Union, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Variables
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_variable_plus_number() {
+ // `$x + 1`
+ let expr = p("$x + 1");
+ match expr {
+ Expr::BinaryOp { op, left, right } => {
+ assert_eq!(op, BinaryOp::Add);
+ match *left {
+ Expr::Variable(ref name) => assert_eq!(name, "x"),
+ _ => panic!("expected Variable"),
+ }
+ match *right {
+ Expr::Number(n) => assert!((n - 1.0).abs() < f64::EPSILON),
+ _ => panic!("expected Number"),
+ }
+ }
+ _ => panic!("expected BinaryOp, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Nested/parenthesized expressions
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_parenthesized_expr() {
+ // `(1 + 2) * 3`
+ let expr = p("(1 + 2) * 3");
+ match expr {
+ Expr::BinaryOp { op, left, right } => {
+ assert_eq!(op, BinaryOp::Mul);
+ match *left {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::Add),
+ _ => panic!("expected inner BinaryOp Add"),
+ }
+ match *right {
+ Expr::Number(n) => assert!((n - 3.0).abs() < f64::EPSILON),
+ _ => panic!("expected Number 3"),
+ }
+ }
+ _ => panic!("expected BinaryOp, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Processing instructions
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_processing_instruction_with_target() {
+ // `processing-instruction('xml-stylesheet')`
+ let expr = p("processing-instruction('xml-stylesheet')");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(
+ steps[0].node_test,
+ NodeTest::ProcessingInstruction(Some("xml-stylesheet".to_string()))
+ );
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_processing_instruction_no_target() {
+ // `processing-instruction()`
+ let expr = p("processing-instruction()");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].node_test, NodeTest::ProcessingInstruction(None));
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Wildcards
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_wildcard() {
+ // `*` matches any element
+ let expr = p("*");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].node_test, NodeTest::Wildcard);
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Multiple predicates
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_multiple_predicates() {
+ // `child[1][@type='x']`
+ let expr = p("child[1][@type='x']");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].predicates.len(), 2);
+ match &steps[0].predicates[0] {
+ Expr::Number(n) => assert!((n - 1.0).abs() < f64::EPSILON),
+ other => panic!("expected Number predicate, got: {other:?}"),
+ }
+ match &steps[0].predicates[1] {
+ Expr::BinaryOp { op, .. } => assert_eq!(*op, BinaryOp::Eq),
+ other => panic!("expected BinaryOp Eq predicate, got: {other:?}"),
+ }
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Operator precedence
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_operator_precedence() {
+ // `1 + 2 * 3` should be `1 + (2 * 3)` due to precedence
+ let expr = p("1 + 2 * 3");
+ match expr {
+ Expr::BinaryOp { op, left, right } => {
+ assert_eq!(op, BinaryOp::Add);
+ match *left {
+ Expr::Number(n) => assert!((n - 1.0).abs() < f64::EPSILON),
+ _ => panic!("expected Number 1"),
+ }
+ match *right {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::Mul),
+ _ => panic!("expected inner Mul"),
+ }
+ }
+ _ => panic!("expected BinaryOp, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Explicit axis syntax
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_explicit_axis() {
+ // `descendant::div`
+ let expr = p("descendant::div");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].axis, Axis::Descendant);
+ assert_eq!(steps[0].node_test, NodeTest::Name("div".to_string()));
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Error cases
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_empty_expression_error() {
+ assert_parse_error("");
+ }
+
+ #[test]
+ fn test_parse_unexpected_token_error() {
+ assert_parse_error(")");
+ }
+
+ #[test]
+ fn test_parse_unclosed_paren_error() {
+ assert_parse_error("(1 + 2");
+ }
+
+ #[test]
+ fn test_parse_unclosed_bracket_error() {
+ assert_parse_error("child[1");
+ }
+
+ // -----------------------------------------------------------------------
+ // Additional coverage
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_unary_negation() {
+ // `-5`
+ let expr = p("-5");
+ match expr {
+ Expr::UnaryNeg(inner) => match *inner {
+ Expr::Number(n) => assert!((n - 5.0).abs() < f64::EPSILON),
+ _ => panic!("expected Number inside UnaryNeg"),
+ },
+ _ => panic!("expected UnaryNeg, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_double_negation() {
+ // `--5`
+ let expr = p("--5");
+ match expr {
+ Expr::UnaryNeg(inner) => match *inner {
+ Expr::UnaryNeg(_) => {} // correct: double negation
+ _ => panic!("expected nested UnaryNeg"),
+ },
+ _ => panic!("expected UnaryNeg, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_string_literal() {
+ let expr = p("'hello'");
+ match expr {
+ Expr::String(s) => assert_eq!(s, "hello"),
+ _ => panic!("expected String, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_number_literal() {
+ let expr = p("42.5");
+ match expr {
+ Expr::Number(n) => assert!((n - 42.5).abs() < f64::EPSILON),
+ _ => panic!("expected Number, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_comment_node_test() {
+ let expr = p("comment()");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps[0].node_test, NodeTest::Comment);
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_node_node_test() {
+ let expr = p("node()");
+ match expr {
+ Expr::Path { ref steps } => {
+ assert_eq!(steps[0].node_test, NodeTest::Node);
+ }
+ _ => panic!("expected Path, got: {expr:?}"),
+ }
+ }
+
+ #[test]
+ fn test_parse_or_precedence_over_and() {
+ // `a and b or c and d` should be `(a and b) or (c and d)`
+ let expr = p("a and b or c and d");
+ match expr {
+ Expr::BinaryOp { op, left, right } => {
+ assert_eq!(op, BinaryOp::Or);
+ match *left {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::And),
+ _ => panic!("expected left And"),
+ }
+ match *right {
+ Expr::BinaryOp { op, .. } => assert_eq!(op, BinaryOp::And),
+ _ => panic!("expected right And"),
+ }
+ }
+ _ => panic!("expected BinaryOp Or, got: {expr:?}"),
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Filter-path expressions (issue #20)
+ // -----------------------------------------------------------------------
+
+ #[test]
+ fn test_parse_filter_path_continuation() {
+ // `(//a)[1]/@href`: a filter expression followed by a relative
+ // location path must parse to FilterPath, not to a predicate.
+ let (inner, steps) = match p("(//a)[1]/@href") {
+ Expr::FilterPath { expr, steps } => (expr, steps),
+ other => panic!("expected FilterPath, got: {other:?}"),
+ };
+ match *inner {
+ Expr::Filter { ref predicates, .. } => assert_eq!(predicates.len(), 1),
+ ref other => panic!("expected inner Filter, got: {other:?}"),
+ }
+ assert_eq!(steps.len(), 1);
+ assert_eq!(steps[0].axis, Axis::Attribute);
+ assert_eq!(steps[0].node_test, NodeTest::Name("href".to_string()));
+ }
+
+ #[test]
+ fn test_parse_filter_path_vs_predicate_distinct() {
+ // `(//a)/b` (path continuation) and `(//a)[b]` (predicate) must
+ // produce different ASTs — they mean different things.
+ let path = p("(//a)/b");
+ assert!(
+ matches!(path, Expr::FilterPath { .. }),
+ "expected FilterPath, got: {path:?}"
+ );
+ let filter = p("(//a)[b]");
+ assert!(
+ matches!(filter, Expr::Filter { .. }),
+ "expected Filter, got: {filter:?}"
+ );
+ }
+}
diff --git a/browser/vendor/xmloxide/src/xpath/regex.rs b/browser/vendor/xmloxide/src/xpath/regex.rs
new file mode 100644
index 000000000..2b5057236
--- /dev/null
+++ b/browser/vendor/xmloxide/src/xpath/regex.rs
@@ -0,0 +1,893 @@
+//! Simple regular expression engine for `XPath` `matches()` function.
+//!
+//! Implements a subset of XSD/XPath regular expressions sufficient for
+//! common Schematron validation patterns. This avoids depending on the
+//! `regex` crate per the project's dependencies policy.
+//!
+//! # Supported Syntax
+//!
+//! - `.` — any character (except newline by default)
+//! - `\d`, `\D` — digit / non-digit
+//! - `\s`, `\S` — whitespace / non-whitespace
+//! - `\w`, `\W` — word character / non-word character
+//! - `\n`, `\r`, `\t`, `\\`, `\.` — escape sequences
+//! - `[abc]`, `[a-z]`, `[^a-z]` — character classes
+//! - `*`, `+`, `?` — greedy quantifiers
+//! - `{n}`, `{n,}`, `{n,m}` — counted quantifiers
+//! - `|` — alternation
+//! - `(` `)` — grouping
+//! - `^`, `$` — anchors (only meaningful with flag-based matching)
+
+/// Matches `input` against `pattern` (XSD/XPath regex semantics).
+///
+/// By default, the pattern is anchored to match the **entire** string
+/// (`XPath` `matches()` semantics: the pattern is implicitly `^...$`
+/// unless the caller opts out). The `flags` parameter supports:
+///
+/// - `s` — dot matches newline
+/// - `m` — `^`/`$` match line boundaries (not just string boundaries)
+/// - `i` — case-insensitive matching
+/// - `x` — ignore whitespace in pattern
+///
+/// Returns `true` if the input matches the pattern.
+pub fn xpath_matches(input: &str, pattern: &str, flags: &str) -> Result<bool, String> {
+ let dot_all = flags.contains('s');
+ let case_insensitive = flags.contains('i');
+
+ let compiled = compile(pattern, case_insensitive)?;
+
+ // XPath matches() checks if the pattern matches any substring,
+ // NOT the entire string (unlike XSD's pattern facet).
+ // Per XPath 2.0 F&O section 7.6.2: "returns true if $input matches
+ // the regular expression".
+ for start in 0..=input.len() {
+ if !input.is_char_boundary(start) {
+ continue;
+ }
+ if try_match(&compiled, input, start, dot_all, case_insensitive) {
+ return Ok(true);
+ }
+ }
+ Ok(false)
+}
+
+/// Replaces all occurrences of `pattern` in `input` with `replacement`.
+///
+/// Supports `$0` in the replacement string to refer to the whole match.
+/// Per `XPath` 2.0 F&O section 7.6.3.
+pub fn xpath_replace(
+ input: &str,
+ pattern: &str,
+ replacement: &str,
+ flags: &str,
+) -> Result<String, String> {
+ let dot_all = flags.contains('s');
+ let case_insensitive = flags.contains('i');
+ let compiled = compile(pattern, case_insensitive)?;
+
+ let mut result = String::new();
+ let mut pos = 0;
+
+ while pos <= input.len() {
+ if let Some((start, end)) =
+ find_first_match(&compiled, input, pos, dot_all, case_insensitive)
+ {
+ // Append text before the match
+ result.push_str(&input[pos..start]);
+ // Append replacement (with $0 expansion)
+ for ch in replacement.chars() {
+ result.push(ch);
+ }
+ // Advance past the match (avoid infinite loop on zero-length match)
+ pos = if end == start { end + 1 } else { end };
+ } else {
+ // No more matches — append remainder
+ result.push_str(&input[pos..]);
+ break;
+ }
+ }
+
+ Ok(result)
+}
+
+/// Splits `input` on occurrences of `pattern`, returning the pieces.
+///
+/// Per `XPath` 2.0 F&O section 7.6.4.
+pub fn xpath_tokenize(input: &str, pattern: &str, flags: &str) -> Result<Vec<String>, String> {
+ let dot_all = flags.contains('s');
+ let case_insensitive = flags.contains('i');
+ let compiled = compile(pattern, case_insensitive)?;
+
+ if input.is_empty() {
+ return Ok(vec![]);
+ }
+
+ let mut tokens = Vec::new();
+ let mut pos = 0;
+
+ while pos <= input.len() {
+ if let Some((start, end)) =
+ find_first_match(&compiled, input, pos, dot_all, case_insensitive)
+ {
+ // Zero-length match at current position — skip to avoid infinite loop
+ if end == start {
+ if pos < input.len() {
+ // Include one char and continue
+ let ch = input[pos..].chars().next().unwrap_or(' ');
+ tokens.push(input[pos..pos + ch.len_utf8()].to_string());
+ pos += ch.len_utf8();
+ } else {
+ break;
+ }
+ continue;
+ }
+ tokens.push(input[pos..start].to_string());
+ pos = end;
+ } else {
+ tokens.push(input[pos..].to_string());
+ break;
+ }
+ }
+
+ Ok(tokens)
+}
+
+/// Finds the first match of `compiled` pattern in `input` starting at `from`.
+/// Returns `Some((start, end))` byte positions, or `None`.
+fn find_first_match(
+ compiled: &[Quantified],
+ input: &str,
+ from: usize,
+ dot_all: bool,
+ ci: bool,
+) -> Option<(usize, usize)> {
+ for start in from..=input.len() {
+ if !input.is_char_boundary(start) {
+ continue;
+ }
+ if let Some(end) = match_seq(compiled, 0, input, start, dot_all, ci) {
+ return Some((start, end));
+ }
+ }
+ None
+}
+
+// ---------------------------------------------------------------------------
+// Compiled regex representation
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+enum RegexNode {
+ /// Match a single literal character.
+ Literal(char),
+ /// Match any character (`.`).
+ Dot,
+ /// Match a character class.
+ CharClass {
+ ranges: Vec<(char, char)>,
+ negated: bool,
+ },
+ /// Shorthand: `\d`
+ Digit,
+ /// Shorthand: `\D`
+ NonDigit,
+ /// Shorthand: `\s`
+ Whitespace,
+ /// Shorthand: `\S`
+ NonWhitespace,
+ /// Shorthand: `\w`
+ WordChar,
+ /// Shorthand: `\W`
+ NonWordChar,
+ /// A group of alternatives separated by `|`.
+ Alternation(Vec<Vec<Quantified>>),
+}
+
+#[derive(Debug, Clone)]
+struct Quantified {
+ node: RegexNode,
+ quantifier: Quantifier,
+}
+
+#[derive(Debug, Clone)]
+enum Quantifier {
+ /// Exactly once (no quantifier).
+ Once,
+ /// `?` — zero or one.
+ ZeroOrOne,
+ /// `*` — zero or more.
+ ZeroOrMore,
+ /// `+` — one or more.
+ OneOrMore,
+ /// `{n}` — exactly n.
+ Exact(usize),
+ /// `{n,}` — at least n.
+ AtLeast(usize),
+ /// `{n,m}` — between n and m.
+ Between(usize, usize),
+}
+
+// ---------------------------------------------------------------------------
+// Pattern compiler
+// ---------------------------------------------------------------------------
+
+fn compile(pattern: &str, case_insensitive: bool) -> Result<Vec<Quantified>, String> {
+ let chars: Vec<char> = pattern.chars().collect();
+ let (result, pos) = parse_alternation(&chars, 0, case_insensitive)?;
+ if pos != chars.len() {
+ return Err(format!("unexpected character at position {pos}"));
+ }
+ Ok(result)
+}
+
+fn parse_alternation(
+ chars: &[char],
+ start: usize,
+ ci: bool,
+) -> Result<(Vec<Quantified>, usize), String> {
+ let mut alternatives: Vec<Vec<Quantified>> = Vec::new();
+ let (first, mut pos) = parse_sequence(chars, start, ci)?;
+ alternatives.push(first);
+
+ while pos < chars.len() && chars[pos] == '|' {
+ pos += 1;
+ let (alt, new_pos) = parse_sequence(chars, pos, ci)?;
+ alternatives.push(alt);
+ pos = new_pos;
+ }
+
+ if alternatives.len() == 1 {
+ Ok((alternatives.into_iter().next().unwrap_or_default(), pos))
+ } else {
+ Ok((
+ vec![Quantified {
+ node: RegexNode::Alternation(alternatives),
+ quantifier: Quantifier::Once,
+ }],
+ pos,
+ ))
+ }
+}
+
+fn parse_sequence(
+ chars: &[char],
+ mut pos: usize,
+ ci: bool,
+) -> Result<(Vec<Quantified>, usize), String> {
+ let mut items = Vec::new();
+ while pos < chars.len() {
+ match chars[pos] {
+ '|' | ')' => break,
+ '(' => {
+ pos += 1;
+ let (group, new_pos) = parse_alternation(chars, pos, ci)?;
+ if new_pos >= chars.len() || chars[new_pos] != ')' {
+ return Err("unmatched '('".to_string());
+ }
+ pos = new_pos + 1;
+ // The group is a single alternation node, apply quantifier to it
+ let q = parse_quantifier(chars, &mut pos);
+ if group.len() == 1 {
+ items.push(Quantified {
+ node: group
+ .into_iter()
+ .next()
+ .unwrap_or(Quantified {
+ node: RegexNode::Literal('\0'),
+ quantifier: Quantifier::Once,
+ })
+ .node,
+ quantifier: q,
+ });
+ } else {
+ // Multi-element group → wrap in alternation with single branch
+ items.push(Quantified {
+ node: RegexNode::Alternation(vec![group]),
+ quantifier: q,
+ });
+ }
+ }
+ '\\' => {
+ let node = parse_escape(chars, &mut pos)?;
+ let q = parse_quantifier(chars, &mut pos);
+ items.push(Quantified {
+ node,
+ quantifier: q,
+ });
+ }
+ '[' => {
+ let node = parse_char_class(chars, &mut pos, ci)?;
+ let q = parse_quantifier(chars, &mut pos);
+ items.push(Quantified {
+ node,
+ quantifier: q,
+ });
+ }
+ '.' => {
+ pos += 1;
+ let q = parse_quantifier(chars, &mut pos);
+ items.push(Quantified {
+ node: RegexNode::Dot,
+ quantifier: q,
+ });
+ }
+ '^' | '$' => {
+ // Anchors — skip them (we try all start positions anyway)
+ pos += 1;
+ }
+ ch => {
+ pos += 1;
+ let q = parse_quantifier(chars, &mut pos);
+ let lit = if ci { ch.to_ascii_lowercase() } else { ch };
+ items.push(Quantified {
+ node: RegexNode::Literal(lit),
+ quantifier: q,
+ });
+ }
+ }
+ }
+ Ok((items, pos))
+}
+
+fn parse_escape(chars: &[char], pos: &mut usize) -> Result<RegexNode, String> {
+ *pos += 1; // skip '\'
+ if *pos >= chars.len() {
+ return Err("trailing backslash".to_string());
+ }
+ let ch = chars[*pos];
+ *pos += 1;
+ Ok(match ch {
+ 'd' => RegexNode::Digit,
+ 'D' => RegexNode::NonDigit,
+ 's' => RegexNode::Whitespace,
+ 'S' => RegexNode::NonWhitespace,
+ 'w' => RegexNode::WordChar,
+ 'W' => RegexNode::NonWordChar,
+ 'n' => RegexNode::Literal('\n'),
+ 'r' => RegexNode::Literal('\r'),
+ 't' => RegexNode::Literal('\t'),
+ _ => RegexNode::Literal(ch), // \., \\, \[, etc.
+ })
+}
+
+fn parse_char_class(chars: &[char], pos: &mut usize, ci: bool) -> Result<RegexNode, String> {
+ *pos += 1; // skip '['
+ let negated = *pos < chars.len() && chars[*pos] == '^';
+ if negated {
+ *pos += 1;
+ }
+
+ let mut ranges = Vec::new();
+ while *pos < chars.len() && chars[*pos] != ']' {
+ let start_ch = if chars[*pos] == '\\' {
+ *pos += 1;
+ if *pos >= chars.len() {
+ return Err("trailing backslash in character class".to_string());
+ }
+ let esc = chars[*pos];
+ *pos += 1;
+ match esc {
+ 'n' => '\n',
+ 'r' => '\r',
+ 't' => '\t',
+ 'd' | 'D' | 's' | 'S' | 'w' | 'W' => {
+ // Shorthand in class — expand
+ let shorthand_ranges = shorthand_to_ranges(esc);
+ ranges.extend(shorthand_ranges);
+ continue;
+ }
+ _ => esc,
+ }
+ } else {
+ let ch = chars[*pos];
+ *pos += 1;
+ ch
+ };
+
+ if *pos + 1 < chars.len() && chars[*pos] == '-' && chars[*pos + 1] != ']' {
+ *pos += 1; // skip '-'
+ let end_ch = if chars[*pos] == '\\' {
+ *pos += 1;
+ if *pos >= chars.len() {
+ return Err("trailing backslash in character class".to_string());
+ }
+ let esc = chars[*pos];
+ *pos += 1;
+ match esc {
+ 'n' => '\n',
+ 'r' => '\r',
+ 't' => '\t',
+ _ => esc,
+ }
+ } else {
+ let ch = chars[*pos];
+ *pos += 1;
+ ch
+ };
+ let (lo, hi) = if ci {
+ (start_ch.to_ascii_lowercase(), end_ch.to_ascii_lowercase())
+ } else {
+ (start_ch, end_ch)
+ };
+ ranges.push((lo, hi));
+ } else {
+ let lit = if ci {
+ start_ch.to_ascii_lowercase()
+ } else {
+ start_ch
+ };
+ ranges.push((lit, lit));
+ }
+ }
+ if *pos < chars.len() {
+ *pos += 1; // skip ']'
+ } else {
+ return Err("unmatched '['".to_string());
+ }
+ Ok(RegexNode::CharClass { ranges, negated })
+}
+
+fn shorthand_to_ranges(ch: char) -> Vec<(char, char)> {
+ match ch {
+ 'd' => vec![('0', '9')],
+ 'D' => vec![('\0', '/'), (':', char::MAX)],
+ 's' => vec![(' ', ' '), ('\t', '\t'), ('\n', '\n'), ('\r', '\r')],
+ 'S' => vec![('!', char::MAX)], // simplified
+ 'w' => vec![('a', 'z'), ('A', 'Z'), ('0', '9'), ('_', '_')],
+ 'W' => vec![
+ ('\0', '/'),
+ (':', '@'),
+ ('[', '^'),
+ ('`', '`'),
+ ('{', char::MAX),
+ ],
+ _ => vec![],
+ }
+}
+
+fn parse_quantifier(chars: &[char], pos: &mut usize) -> Quantifier {
+ if *pos >= chars.len() {
+ return Quantifier::Once;
+ }
+ match chars[*pos] {
+ '?' => {
+ *pos += 1;
+ Quantifier::ZeroOrOne
+ }
+ '*' => {
+ *pos += 1;
+ Quantifier::ZeroOrMore
+ }
+ '+' => {
+ *pos += 1;
+ Quantifier::OneOrMore
+ }
+ '{' => {
+ let start = *pos;
+ *pos += 1;
+ if let Some(q) = parse_counted_quantifier(chars, pos) {
+ q
+ } else {
+ *pos = start; // revert
+ Quantifier::Once
+ }
+ }
+ _ => Quantifier::Once,
+ }
+}
+
+fn parse_counted_quantifier(chars: &[char], pos: &mut usize) -> Option<Quantifier> {
+ let n = parse_uint(chars, pos)?;
+ if *pos >= chars.len() {
+ return None;
+ }
+ if chars[*pos] == '}' {
+ *pos += 1;
+ return Some(Quantifier::Exact(n));
+ }
+ if chars[*pos] != ',' {
+ return None;
+ }
+ *pos += 1; // skip ','
+ if *pos >= chars.len() {
+ return None;
+ }
+ if chars[*pos] == '}' {
+ *pos += 1;
+ return Some(Quantifier::AtLeast(n));
+ }
+ let m = parse_uint(chars, pos)?;
+ if *pos < chars.len() && chars[*pos] == '}' {
+ *pos += 1;
+ Some(Quantifier::Between(n, m))
+ } else {
+ None
+ }
+}
+
+fn parse_uint(chars: &[char], pos: &mut usize) -> Option<usize> {
+ let start = *pos;
+ while *pos < chars.len() && chars[*pos].is_ascii_digit() {
+ *pos += 1;
+ }
+ if *pos == start {
+ return None;
+ }
+ chars[start..*pos].iter().collect::<String>().parse().ok()
+}
+
+// ---------------------------------------------------------------------------
+// Matching engine (backtracking)
+// ---------------------------------------------------------------------------
+
+fn try_match(pattern: &[Quantified], input: &str, start: usize, dot_all: bool, ci: bool) -> bool {
+ match_seq(pattern, 0, input, start, dot_all, ci).is_some()
+}
+
+/// Tries to match `pattern[pat_idx..]` against `input[input_pos..]`.
+/// Returns the end position in input if successful.
+fn match_seq(
+ pattern: &[Quantified],
+ pat_idx: usize,
+ input: &str,
+ input_pos: usize,
+ dot_all: bool,
+ ci: bool,
+) -> Option<usize> {
+ if pat_idx >= pattern.len() {
+ return Some(input_pos);
+ }
+
+ let item = &pattern[pat_idx];
+ match &item.quantifier {
+ Quantifier::Once => {
+ let end = match_node_once(&item.node, input, input_pos, dot_all, ci)?;
+ match_seq(pattern, pat_idx + 1, input, end, dot_all, ci)
+ }
+ Quantifier::ZeroOrOne => {
+ // Try matching once first (greedy)
+ if let Some(end) = match_node_once(&item.node, input, input_pos, dot_all, ci) {
+ if let Some(result) = match_seq(pattern, pat_idx + 1, input, end, dot_all, ci) {
+ return Some(result);
+ }
+ }
+ // Try matching zero times
+ match_seq(pattern, pat_idx + 1, input, input_pos, dot_all, ci)
+ }
+ Quantifier::ZeroOrMore => match_greedy(
+ &item.node,
+ pattern,
+ pat_idx,
+ input,
+ input_pos,
+ 0,
+ usize::MAX,
+ dot_all,
+ ci,
+ ),
+ Quantifier::OneOrMore => match_greedy(
+ &item.node,
+ pattern,
+ pat_idx,
+ input,
+ input_pos,
+ 1,
+ usize::MAX,
+ dot_all,
+ ci,
+ ),
+ Quantifier::Exact(n) => match_greedy(
+ &item.node, pattern, pat_idx, input, input_pos, *n, *n, dot_all, ci,
+ ),
+ Quantifier::AtLeast(n) => match_greedy(
+ &item.node,
+ pattern,
+ pat_idx,
+ input,
+ input_pos,
+ *n,
+ usize::MAX,
+ dot_all,
+ ci,
+ ),
+ Quantifier::Between(n, m) => match_greedy(
+ &item.node, pattern, pat_idx, input, input_pos, *n, *m, dot_all, ci,
+ ),
+ }
+}
+
+/// Greedy matching: consume as many as possible (up to max), then backtrack.
+#[allow(clippy::too_many_arguments)]
+fn match_greedy(
+ node: &RegexNode,
+ pattern: &[Quantified],
+ pat_idx: usize,
+ input: &str,
+ start: usize,
+ min: usize,
+ max: usize,
+ dot_all: bool,
+ ci: bool,
+) -> Option<usize> {
+ // Collect all possible match positions
+ let mut positions = vec![start];
+ let mut pos = start;
+ let mut count = 0;
+ while count < max {
+ if let Some(end) = match_node_once(node, input, pos, dot_all, ci) {
+ positions.push(end);
+ pos = end;
+ count += 1;
+ } else {
+ break;
+ }
+ }
+
+ // Try from most matches (greedy) down to min
+ for i in (min..=positions.len().saturating_sub(1)).rev() {
+ if let Some(result) = match_seq(pattern, pat_idx + 1, input, positions[i], dot_all, ci) {
+ return Some(result);
+ }
+ }
+ None
+}
+
+/// Tries to match a single node at the given position.
+/// Returns the position after the match, or None.
+fn match_node_once(
+ node: &RegexNode,
+ input: &str,
+ pos: usize,
+ dot_all: bool,
+ ci: bool,
+) -> Option<usize> {
+ match node {
+ RegexNode::Literal(expected) => {
+ let ch = get_char(input, pos)?;
+ let matched = if ci {
+ ch.eq_ignore_ascii_case(expected)
+ } else {
+ ch == *expected
+ };
+ matched.then(|| pos + ch.len_utf8())
+ }
+ RegexNode::Dot => {
+ let ch = get_char(input, pos)?;
+ (ch != '\n' || dot_all).then(|| pos + ch.len_utf8())
+ }
+ RegexNode::CharClass { ranges, negated } => {
+ let ch = get_char(input, pos)?;
+ let test_ch = if ci { ch.to_ascii_lowercase() } else { ch };
+ let in_class = ranges
+ .iter()
+ .any(|&(lo, hi)| test_ch >= lo && test_ch <= hi);
+ (in_class ^ negated).then(|| pos + ch.len_utf8())
+ }
+ RegexNode::Digit => {
+ let ch = get_char(input, pos)?;
+ ch.is_ascii_digit().then(|| pos + ch.len_utf8())
+ }
+ RegexNode::NonDigit => {
+ let ch = get_char(input, pos)?;
+ (!ch.is_ascii_digit()).then(|| pos + ch.len_utf8())
+ }
+ RegexNode::Whitespace => {
+ let ch = get_char(input, pos)?;
+ ch.is_ascii_whitespace().then(|| pos + ch.len_utf8())
+ }
+ RegexNode::NonWhitespace => {
+ let ch = get_char(input, pos)?;
+ (!ch.is_ascii_whitespace()).then(|| pos + ch.len_utf8())
+ }
+ RegexNode::WordChar => {
+ let ch = get_char(input, pos)?;
+ (ch.is_ascii_alphanumeric() || ch == '_').then(|| pos + ch.len_utf8())
+ }
+ RegexNode::NonWordChar => {
+ let ch = get_char(input, pos)?;
+ (!ch.is_ascii_alphanumeric() && ch != '_').then(|| pos + ch.len_utf8())
+ }
+ RegexNode::Alternation(alternatives) => {
+ for alt in alternatives {
+ if let Some(end) = match_seq(alt, 0, input, pos, dot_all, ci) {
+ return Some(end);
+ }
+ }
+ None
+ }
+ }
+}
+
+fn get_char(input: &str, pos: usize) -> Option<char> {
+ input[pos..].chars().next()
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+#[allow(clippy::unwrap_used)]
+mod tests {
+ use super::*;
+
+ fn matches(input: &str, pattern: &str) -> bool {
+ xpath_matches(input, pattern, "").unwrap()
+ }
+
+ fn matches_flags(input: &str, pattern: &str, flags: &str) -> bool {
+ xpath_matches(input, pattern, flags).unwrap()
+ }
+
+ #[test]
+ fn test_literal() {
+ assert!(matches("hello", "hello"));
+ assert!(matches("hello world", "hello"));
+ assert!(!matches("world", "hello"));
+ }
+
+ #[test]
+ fn test_dot() {
+ assert!(matches("a", "."));
+ assert!(matches("abc", "a.c"));
+ assert!(!matches("ac", "a.c"));
+ }
+
+ #[test]
+ fn test_quantifiers() {
+ assert!(matches("aaa", "a+"));
+ assert!(matches("", "a*"));
+ assert!(matches("a", "a?"));
+ assert!(matches("", "a?"));
+ assert!(!matches("", "a+"));
+ }
+
+ #[test]
+ fn test_char_class() {
+ assert!(matches("a", "[abc]"));
+ assert!(matches("b", "[abc]"));
+ assert!(!matches("d", "[abc]"));
+ assert!(matches("m", "[a-z]"));
+ assert!(!matches("M", "[a-z]"));
+ }
+
+ #[test]
+ fn test_negated_class() {
+ assert!(!matches("a", "[^abc]"));
+ assert!(matches("d", "[^abc]"));
+ }
+
+ #[test]
+ fn test_shorthand() {
+ assert!(matches("5", "\\d"));
+ assert!(!matches("a", "\\d"));
+ assert!(matches("a", "\\D"));
+ assert!(matches(" ", "\\s"));
+ assert!(matches("a", "\\w"));
+ }
+
+ #[test]
+ fn test_counted_quantifier() {
+ assert!(matches("aa", "a{2}"));
+ assert!(!matches("a", "a{2}"));
+ assert!(matches("aaa", "a{2,}"));
+ assert!(matches("aa", "a{2,4}"));
+ assert!(matches("aaaa", "a{2,4}"));
+ assert!(!matches("a", "a{2,4}"));
+ }
+
+ #[test]
+ fn test_alternation() {
+ assert!(matches("cat", "cat|dog"));
+ assert!(matches("dog", "cat|dog"));
+ assert!(!matches("bird", "cat|dog"));
+ }
+
+ #[test]
+ fn test_grouping() {
+ assert!(matches("abab", "(ab)+"));
+ assert!(matches("abc", "(ab)+")); // substring match — "ab" prefix matches
+ assert!(!matches("cd", "(ab)+"));
+ }
+
+ #[test]
+ fn test_country_code_pattern() {
+ // Common Schematron pattern for ISO country codes
+ assert!(matches("US", "[A-Z]{2}"));
+ assert!(matches("GB", "[A-Z]{2}"));
+ assert!(!matches("us", "[A-Z]{2}"));
+ assert!(!matches("U", "[A-Z]{2}"));
+ }
+
+ #[test]
+ fn test_invoice_id_pattern() {
+ assert!(matches("INV-2026-001", "[A-Z]+-\\d+-\\d+"));
+ assert!(!matches("inv-2026-001", "[A-Z]+-\\d+-\\d+"));
+ }
+
+ #[test]
+ fn test_email_like_pattern() {
+ assert!(matches("user@example.com", ".+@.+\\..+"));
+ assert!(!matches("noatsign", ".+@.+\\..+"));
+ }
+
+ #[test]
+ fn test_case_insensitive() {
+ assert!(matches_flags("Hello", "hello", "i"));
+ assert!(matches_flags("HELLO", "hello", "i"));
+ assert!(matches_flags("us", "[A-Z]{2}", "i"));
+ }
+
+ #[test]
+ fn test_substring_match() {
+ // XPath matches() checks for substring match, not full string match
+ assert!(matches("hello world", "world"));
+ assert!(matches("abc123def", "\\d+"));
+ }
+
+ #[test]
+ fn test_escaped_special() {
+ assert!(matches("a.b", "a\\.b"));
+ assert!(!matches("axb", "a\\.b"));
+ assert!(matches("a\\b", "a\\\\b"));
+ }
+
+ #[test]
+ fn test_empty_pattern() {
+ assert!(matches("anything", ""));
+ assert!(matches("", ""));
+ }
+
+ // -- replace tests --
+
+ fn replace(input: &str, pattern: &str, replacement: &str) -> String {
+ xpath_replace(input, pattern, replacement, "").unwrap()
+ }
+
+ #[test]
+ fn test_replace_literal() {
+ assert_eq!(replace("hello world", "world", "rust"), "hello rust");
+ }
+
+ #[test]
+ fn test_replace_pattern() {
+ assert_eq!(replace("abc123def", "\\d+", "NUM"), "abcNUMdef");
+ }
+
+ #[test]
+ fn test_replace_multiple() {
+ assert_eq!(replace("a-b-c", "-", "_"), "a_b_c");
+ }
+
+ #[test]
+ fn test_replace_no_match() {
+ assert_eq!(replace("hello", "xyz", "!"), "hello");
+ }
+
+ // -- tokenize tests --
+
+ fn tokenize(input: &str, pattern: &str) -> Vec<String> {
+ xpath_tokenize(input, pattern, "").unwrap()
+ }
+
+ #[test]
+ fn test_tokenize_whitespace() {
+ assert_eq!(tokenize("a b c", "\\s+"), vec!["a", "b", "c"]);
+ }
+
+ #[test]
+ fn test_tokenize_comma() {
+ assert_eq!(tokenize("one,two,three", ","), vec!["one", "two", "three"]);
+ }
+
+ #[test]
+ fn test_tokenize_empty() {
+ let result: Vec<String> = tokenize("", ",");
+ assert!(result.is_empty());
+ }
+
+ #[test]
+ fn test_tokenize_no_match() {
+ assert_eq!(tokenize("hello", ","), vec!["hello"]);
+ }
+}
diff --git a/browser/vendor/xmloxide/src/xpath/types.rs b/browser/vendor/xmloxide/src/xpath/types.rs
new file mode 100644
index 000000000..fa7c27b16
--- /dev/null
+++ b/browser/vendor/xmloxide/src/xpath/types.rs
@@ -0,0 +1,1007 @@
+//! `XPath` 1.0 value type system.
+//!
+//! This module implements the four core data types defined in the `XPath` 1.0
+//! specification (<https://www.w3.org/TR/xpath-10/#section-Data-Model>):
+//! boolean, number, string, and node-set.
+//!
+//! It also provides type conversion methods per `XPath` 1.0 sections 4.1
+//! through 4.4, comparison helpers per section 3.4, and number formatting
+//! rules per the spec's string conversion requirements.
+
+use crate::tree::NodeId;
+use std::fmt;
+
+// ---------------------------------------------------------------------------
+// XPathNode
+// ---------------------------------------------------------------------------
+
+/// A node in an `XPath` node-set.
+///
+/// The `XPath` 1.0 data model (section 5) includes attribute nodes, but the
+/// tree arena stores attributes inline on their owner element rather than as
+/// tree nodes. This enum lets node-sets carry both kinds: ordinary tree
+/// nodes by [`NodeId`], and attributes by owner element plus position in the
+/// element's attribute list.
+///
+/// Ordering follows document order: an attribute sorts immediately after its
+/// owner element (and before the element's children — sufficient for the
+/// stable, consistent ordering `XPath` 1.0 section 5.3 requires), and
+/// attributes of the same element sort by attribute index.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum XPathNode {
+ /// A tree node (element, text, comment, PI, or the document root).
+ Node(NodeId),
+ /// An attribute node, identified by its owner element and its index in
+ /// the element's attribute list.
+ Attribute {
+ /// The element that carries the attribute.
+ owner: NodeId,
+ /// The index of the attribute in the owner's attribute list.
+ index: u32,
+ },
+}
+
+impl XPathNode {
+ /// Returns the tree node this entry anchors to: the node itself, or the
+ /// owner element for an attribute.
+ #[must_use]
+ pub fn anchor(self) -> NodeId {
+ match self {
+ Self::Node(id) => id,
+ Self::Attribute { owner, .. } => owner,
+ }
+ }
+
+ /// Returns the inner [`NodeId`] if this is a tree node, or `None` for
+ /// an attribute.
+ #[must_use]
+ pub fn as_tree_node(self) -> Option<NodeId> {
+ match self {
+ Self::Node(id) => Some(id),
+ Self::Attribute { .. } => None,
+ }
+ }
+
+ /// Returns `true` if this entry is an attribute node.
+ #[must_use]
+ pub fn is_attribute(self) -> bool {
+ matches!(self, Self::Attribute { .. })
+ }
+
+ /// Document-order sort key: `(anchor, is-attribute, attribute-index)`.
+ ///
+ /// Relies on the arena property that `NodeId`s of a parsed document are
+ /// allocated in document order.
+ fn sort_key(self) -> (NodeId, u8, u32) {
+ match self {
+ Self::Node(id) => (id, 0, 0),
+ Self::Attribute { owner, index } => (owner, 1, index),
+ }
+ }
+}
+
+impl Ord for XPathNode {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.sort_key().cmp(&other.sort_key())
+ }
+}
+
+impl PartialOrd for XPathNode {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ Some(self.cmp(other))
+ }
+}
+
+impl From<NodeId> for XPathNode {
+ fn from(id: NodeId) -> Self {
+ Self::Node(id)
+ }
+}
+
+// ---------------------------------------------------------------------------
+// XPathValue
+// ---------------------------------------------------------------------------
+
+/// An `XPath` 1.0 value.
+///
+/// The `XPath` specification defines exactly four data types. Every expression
+/// evaluates to one of these variants.
+/// See <https://www.w3.org/TR/xpath-10/#section-Data-Model>.
+#[derive(Debug, Clone)]
+pub enum XPathValue {
+ /// A boolean value (`true` or `false`).
+ ///
+ /// See `XPath` 1.0 section 4.3.
+ Boolean(bool),
+
+ /// A number (IEEE 754 double-precision floating-point).
+ ///
+ /// Numbers follow IEEE 754 semantics including NaN, positive and
+ /// negative infinity, and negative zero. See `XPath` 1.0 section 4.4.
+ Number(f64),
+
+ /// A string (a sequence of UCS characters).
+ ///
+ /// See `XPath` 1.0 section 4.2.
+ String(String),
+
+ /// An ordered set of nodes.
+ ///
+ /// Node-sets are ordered in document order and may contain both tree
+ /// nodes and attribute nodes (see [`XPathNode`]). Duplicates should not
+ /// appear (the caller is responsible for deduplication). See `XPath` 1.0
+ /// section 3.3.
+ NodeSet(Vec<XPathNode>),
+}
+
+impl XPathValue {
+ // -- Type conversion methods (`XPath` 1.0 sections 4.1-4.4) -------------
+
+ /// Converts this value to a boolean.
+ ///
+ /// Conversion rules per `XPath` 1.0 section 4.3:
+ /// - **boolean**: identity
+ /// - **number**: `false` if the number is zero or NaN, `true` otherwise
+ /// - **string**: `false` if the string is empty, `true` otherwise
+ /// - **node-set**: `false` if the node-set is empty, `true` otherwise
+ #[must_use]
+ pub fn to_boolean(&self) -> bool {
+ match self {
+ Self::Boolean(b) => *b,
+ Self::Number(n) => *n != 0.0 && !n.is_nan(),
+ Self::String(s) => !s.is_empty(),
+ Self::NodeSet(nodes) => !nodes.is_empty(),
+ }
+ }
+
+ /// Converts this value to a number.
+ ///
+ /// Conversion rules per `XPath` 1.0 section 4.4:
+ /// - **number**: identity
+ /// - **boolean**: `true` becomes `1.0`, `false` becomes `0.0`
+ /// - **string**: parsed as an IEEE 754 number; unparseable strings become NaN
+ /// - **node-set**: the string-value of the first node in document order is
+ /// converted as a string; an empty node-set converts to NaN
+ ///
+ /// Note: the node-set conversion requires a `Document` to compute
+ /// string-values. Without one, we return NaN as a fallback. For full
+ /// node-set conversion, use
+ /// [`to_number_with_string_value`](Self::to_number_with_string_value).
+ #[must_use]
+ pub fn to_number(&self) -> f64 {
+ match self {
+ Self::Number(n) => *n,
+ Self::Boolean(b) => {
+ if *b {
+ 1.0
+ } else {
+ 0.0
+ }
+ }
+ Self::String(s) => parse_xpath_number(s),
+ Self::NodeSet(_) => {
+ // Without a Document reference we cannot compute the
+ // string-value of the first node. Return NaN as a safe
+ // fallback; callers that hold a Document should use
+ // `to_number_with_string_value` instead.
+ f64::NAN
+ }
+ }
+ }
+
+ /// Converts this value to a number, using a pre-computed string-value
+ /// for the first node in a node-set.
+ ///
+ /// This is the correct conversion for node-sets when the caller has access
+ /// to the `Document` and can supply the string-value of the first node.
+ /// For non-node-set values, the `first_node_string_value` parameter is
+ /// ignored.
+ #[must_use]
+ pub fn to_number_with_string_value(&self, first_node_string_value: Option<&str>) -> f64 {
+ match self {
+ Self::NodeSet(_) => first_node_string_value.map_or(f64::NAN, parse_xpath_number),
+ _ => self.to_number(),
+ }
+ }
+
+ /// Converts this value to a string per the `XPath` `string()` function.
+ ///
+ /// Conversion rules per `XPath` 1.0 section 4.2:
+ /// - **string**: identity
+ /// - **boolean**: `"true"` or `"false"`
+ /// - **number**: formatted per `XPath` number-to-string rules (see
+ /// [`format_xpath_number`])
+ /// - **node-set**: the string-value of the first node in document order;
+ /// an empty node-set yields the empty string
+ ///
+ /// Note: the node-set conversion requires a `Document` to compute
+ /// string-values. Without one, we return the empty string for node-sets.
+ /// For full conversion, use
+ /// [`to_string_with_string_value`](Self::to_string_with_string_value).
+ #[must_use]
+ pub fn to_xpath_string(&self) -> String {
+ match self {
+ Self::String(s) => s.clone(),
+ Self::Boolean(b) => {
+ if *b {
+ "true".to_owned()
+ } else {
+ "false".to_owned()
+ }
+ }
+ Self::Number(n) => format_xpath_number(*n),
+ Self::NodeSet(_) => {
+ // Without a Document we cannot compute string-values.
+ String::new()
+ }
+ }
+ }
+
+ /// Converts this value to a string, using a pre-computed string-value
+ /// for the first node in a node-set.
+ ///
+ /// For non-node-set values the `first_node_string_value` parameter is
+ /// ignored.
+ #[must_use]
+ pub fn to_string_with_string_value(&self, first_node_string_value: Option<&str>) -> String {
+ match self {
+ Self::NodeSet(_) => first_node_string_value.map_or_else(String::new, str::to_owned),
+ _ => self.to_xpath_string(),
+ }
+ }
+
+ /// Returns a reference to the inner node-set if this value is a
+ /// `NodeSet`, or `None` otherwise.
+ #[must_use]
+ pub fn as_node_set(&self) -> Option<&Vec<XPathNode>> {
+ match self {
+ Self::NodeSet(nodes) => Some(nodes),
+ _ => None,
+ }
+ }
+
+ /// Returns a human-readable name for the type of this value.
+ ///
+ /// Useful for error messages.
+ #[must_use]
+ pub fn type_name(&self) -> &'static str {
+ match self {
+ Self::Boolean(_) => "boolean",
+ Self::Number(_) => "number",
+ Self::String(_) => "string",
+ Self::NodeSet(_) => "node-set",
+ }
+ }
+}
+
+impl fmt::Display for XPathValue {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Boolean(b) => {
+ if *b {
+ write!(f, "true")
+ } else {
+ write!(f, "false")
+ }
+ }
+ Self::Number(n) => write!(f, "{}", format_xpath_number(*n)),
+ Self::String(s) => write!(f, "{s}"),
+ Self::NodeSet(nodes) => write!(f, "<node-set of {} nodes>", nodes.len()),
+ }
+ }
+}
+
+impl PartialEq for XPathValue {
+ #[allow(clippy::float_cmp)]
+ fn eq(&self, other: &Self) -> bool {
+ match (self, other) {
+ (Self::Boolean(a), Self::Boolean(b)) => a == b,
+ (Self::Number(a), Self::Number(b)) => {
+ // NaN != NaN per IEEE 754 and XPath spec
+ a == b
+ }
+ (Self::String(a), Self::String(b)) => a == b,
+ (Self::NodeSet(a), Self::NodeSet(b)) => a == b,
+ _ => false,
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Number formatting (XPath 1.0 section 4.2, number-to-string conversion)
+// ---------------------------------------------------------------------------
+
+/// Formats an `f64` as a string per the `XPath` number-to-string rules.
+///
+/// Formatting rules per `XPath` 1.0 section 4.2 (the `string()` function
+/// applied to numbers):
+/// - NaN produces `"NaN"`
+/// - Positive infinity produces `"Infinity"`
+/// - Negative infinity produces `"-Infinity"`
+/// - Negative zero produces `"0"` (not `"-0"`)
+/// - If the number is an integer (no fractional part), it is formatted
+/// without a decimal point (e.g., `1.0` becomes `"1"`)
+/// - Otherwise, standard decimal notation is used with no trailing zeros
+#[must_use]
+pub fn format_xpath_number(n: f64) -> String {
+ if n.is_nan() {
+ return "NaN".to_owned();
+ }
+ if n.is_infinite() {
+ return if n.is_sign_positive() {
+ "Infinity".to_owned()
+ } else {
+ "-Infinity".to_owned()
+ };
+ }
+ // Negative zero: XPath requires "0", not "-0".
+ if n == 0.0 {
+ return "0".to_owned();
+ }
+ // If the number is a mathematical integer, format without decimal point.
+ // We check with fract() == 0.0 AND that the number is within the safe
+ // integer range for f64 so that very large floats don't produce overly
+ // long strings.
+ #[allow(clippy::float_cmp, clippy::cast_possible_truncation)]
+ if n.fract() == 0.0 && n.abs() < 1e18 {
+ // Format as integer (no decimal point).
+ return format!("{}", n as i64);
+ }
+ // General decimal formatting. Rust's default f64 Display uses enough
+ // digits to round-trip, which matches XPath's requirement of producing
+ // a string that converts back to the same number.
+ format!("{n}")
+}
+
+// ---------------------------------------------------------------------------
+// Number parsing (for string-to-number conversion)
+// ---------------------------------------------------------------------------
+
+/// Parses a string into an `XPath` number.
+///
+/// `XPath` 1.0 section 4.4 defines the `number()` function for strings:
+/// the string is trimmed of leading/trailing whitespace and parsed as
+/// an optional sign, digits, optional decimal point, and optional
+/// fractional digits. Anything that does not match produces NaN.
+///
+/// Note: the `XPath` string-to-number conversion is stricter than Rust's
+/// `f64::parse` in some respects (no hex, no exponent notation), but
+/// more lenient in others (leading/trailing whitespace is allowed). We use
+/// `f64::parse` on the trimmed string as a reasonable approximation.
+fn parse_xpath_number(s: &str) -> f64 {
+ let trimmed = s.trim();
+ if trimmed.is_empty() {
+ return f64::NAN;
+ }
+ trimmed.parse::<f64>().unwrap_or(f64::NAN)
+}
+
+// ---------------------------------------------------------------------------
+// XPathError
+// ---------------------------------------------------------------------------
+
+/// An error that can occur during `XPath` expression parsing or evaluation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum XPathError {
+ /// A type mismatch occurred (e.g., expected a node-set but got a string).
+ TypeError {
+ /// The type that was expected.
+ expected: String,
+ /// The type that was actually found.
+ found: String,
+ },
+
+ /// A variable reference used a name that has no binding in the current
+ /// context.
+ UndefinedVariable {
+ /// The name of the undefined variable (without the `$` prefix).
+ name: String,
+ },
+
+ /// A function call used a name that is not a core `XPath` function and has
+ /// no extension binding.
+ UndefinedFunction {
+ /// The name of the undefined function.
+ name: String,
+ },
+
+ /// A function was called with the wrong number of arguments.
+ InvalidArgCount {
+ /// The name of the function.
+ function: String,
+ /// The number of arguments expected.
+ expected: usize,
+ /// The number of arguments that were actually provided.
+ found: usize,
+ },
+
+ /// The `XPath` expression could not be parsed.
+ InvalidExpression {
+ /// A description of the parse error.
+ message: String,
+ },
+
+ /// An unexpected internal error occurred during evaluation.
+ InternalError {
+ /// A description of the internal error.
+ message: String,
+ },
+}
+
+impl fmt::Display for XPathError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::TypeError { expected, found } => {
+ write!(f, "type error: expected {expected}, found {found}")
+ }
+ Self::UndefinedVariable { name } => {
+ write!(f, "undefined variable: ${name}")
+ }
+ Self::UndefinedFunction { name } => {
+ write!(f, "undefined function: {name}()")
+ }
+ Self::InvalidArgCount {
+ function,
+ expected,
+ found,
+ } => {
+ write!(
+ f,
+ "invalid argument count for {function}(): \
+ expected {expected}, found {found}"
+ )
+ }
+ Self::InvalidExpression { message } => {
+ write!(f, "invalid XPath expression: {message}")
+ }
+ Self::InternalError { message } => {
+ write!(f, "internal XPath error: {message}")
+ }
+ }
+ }
+}
+
+impl std::error::Error for XPathError {}
+
+impl From<super::lexer::XPathError> for XPathError {
+ fn from(err: super::lexer::XPathError) -> Self {
+ Self::InvalidExpression {
+ message: err.to_string(),
+ }
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Comparison helpers (XPath 1.0 section 3.4)
+// ---------------------------------------------------------------------------
+
+/// Compares two values for equality using `XPath` 1.0 section 3.4 rules.
+///
+/// The comparison semantics depend on the types of the operands:
+/// - If either operand is a boolean, the other is converted to boolean.
+/// - If either operand is a number, the other is converted to a number.
+/// - Otherwise, both are converted to strings.
+///
+/// Node-set comparisons are handled specially: when comparing a node-set to
+/// a non-node-set value, the comparison is true if any node's string-value
+/// satisfies the comparison against the other value.
+///
+/// This function does not handle node-set comparisons (which require access
+/// to the document for string-value computation). For those, use
+/// [`compare_values_with_string_values`].
+///
+/// Returns `None` if the comparison involves a node-set (since we cannot
+/// compute string-values without a `Document`).
+#[must_use]
+pub fn compare_values_eq(lhs: &XPathValue, rhs: &XPathValue) -> Option<bool> {
+ // Node-set comparisons require document access for string-values
+ if matches!(lhs, XPathValue::NodeSet(_)) || matches!(rhs, XPathValue::NodeSet(_)) {
+ return None;
+ }
+ Some(compare_non_nodeset_eq(lhs, rhs))
+}
+
+/// Compares two non-node-set values for equality.
+///
+/// Per `XPath` 1.0 section 3.4:
+/// - If either is a boolean, compare as booleans.
+/// - Else if either is a number, compare as numbers.
+/// - Else compare as strings.
+#[allow(clippy::float_cmp)]
+fn compare_non_nodeset_eq(lhs: &XPathValue, rhs: &XPathValue) -> bool {
+ // If either is boolean, compare as booleans.
+ if matches!(lhs, XPathValue::Boolean(_)) || matches!(rhs, XPathValue::Boolean(_)) {
+ return lhs.to_boolean() == rhs.to_boolean();
+ }
+ // If either is a number, compare as numbers.
+ if matches!(lhs, XPathValue::Number(_)) || matches!(rhs, XPathValue::Number(_)) {
+ let ln = lhs.to_number();
+ let rn = rhs.to_number();
+ return ln == rn;
+ }
+ // Otherwise compare as strings.
+ lhs.to_xpath_string() == rhs.to_xpath_string()
+}
+
+/// Compares two values for equality, using pre-computed string-values
+/// for nodes in node-sets.
+///
+/// `lhs_strings` and `rhs_strings` supply the string-values for each node
+/// in the respective node-set (in the same order as the nodes appear in the
+/// `NodeSet` vector). For non-node-set operands, the corresponding strings
+/// parameter is ignored.
+///
+/// This implements the full `XPath` 1.0 section 3.4 equality semantics,
+/// including node-set-to-node-set and node-set-to-scalar comparisons.
+#[must_use]
+#[allow(clippy::float_cmp)]
+pub fn compare_values_with_string_values(
+ lhs: &XPathValue,
+ rhs: &XPathValue,
+ lhs_strings: &[String],
+ rhs_strings: &[String],
+) -> bool {
+ match (lhs, rhs) {
+ // node-set = node-set: true if any pair of string-values are equal
+ (XPathValue::NodeSet(_), XPathValue::NodeSet(_)) => {
+ for ls in lhs_strings {
+ for rs in rhs_strings {
+ if ls == rs {
+ return true;
+ }
+ }
+ }
+ false
+ }
+
+ // node-set = boolean: convert node-set to boolean first
+ (XPathValue::NodeSet(nodes), XPathValue::Boolean(b))
+ | (XPathValue::Boolean(b), XPathValue::NodeSet(nodes)) => nodes.is_empty() != *b,
+
+ // node-set = number: convert each node's string-value to a number
+ (XPathValue::NodeSet(_), XPathValue::Number(n)) => {
+ lhs_strings.iter().any(|sv| parse_xpath_number(sv) == *n)
+ }
+ (XPathValue::Number(n), XPathValue::NodeSet(_)) => {
+ rhs_strings.iter().any(|sv| parse_xpath_number(sv) == *n)
+ }
+
+ // node-set = string: compare each node's string-value to the string
+ (XPathValue::NodeSet(_), XPathValue::String(s)) => lhs_strings.iter().any(|sv| sv == s),
+ (XPathValue::String(s), XPathValue::NodeSet(_)) => rhs_strings.iter().any(|sv| sv == s),
+
+ // non-node-set comparisons
+ _ => compare_non_nodeset_eq(lhs, rhs),
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+#[allow(clippy::float_cmp, clippy::unwrap_used)]
+mod tests {
+ use super::*;
+ use crate::tree::{Document, NodeKind};
+
+ /// Helper to create a `NodeId` for testing purposes by allocating a real
+ /// node in a document arena.
+ fn make_node_id_in_doc(doc: &mut Document) -> NodeId {
+ doc.create_node(NodeKind::Text {
+ content: String::new(),
+ })
+ }
+
+ // -- Boolean conversion -------------------------------------------------
+
+ #[test]
+ fn test_to_boolean_from_boolean() {
+ assert!(XPathValue::Boolean(true).to_boolean());
+ assert!(!XPathValue::Boolean(false).to_boolean());
+ }
+
+ #[test]
+ fn test_to_boolean_from_number() {
+ assert!(XPathValue::Number(1.0).to_boolean());
+ assert!(XPathValue::Number(-1.0).to_boolean());
+ assert!(XPathValue::Number(0.5).to_boolean());
+ // Zero and NaN are false
+ assert!(!XPathValue::Number(0.0).to_boolean());
+ assert!(!XPathValue::Number(-0.0).to_boolean());
+ assert!(!XPathValue::Number(f64::NAN).to_boolean());
+ }
+
+ #[test]
+ fn test_to_boolean_from_string() {
+ assert!(XPathValue::String("hello".to_owned()).to_boolean());
+ assert!(XPathValue::String(" ".to_owned()).to_boolean());
+ assert!(!XPathValue::String(String::new()).to_boolean());
+ }
+
+ #[test]
+ fn test_to_boolean_from_nodeset() {
+ let mut doc = Document::new();
+ let id = make_node_id_in_doc(&mut doc);
+ assert!(XPathValue::NodeSet(vec![id.into()]).to_boolean());
+ assert!(!XPathValue::NodeSet(vec![]).to_boolean());
+ }
+
+ // -- Number conversion --------------------------------------------------
+
+ #[test]
+ fn test_to_number_from_number() {
+ assert_eq!(XPathValue::Number(42.0).to_number(), 42.0);
+ assert!(XPathValue::Number(f64::NAN).to_number().is_nan());
+ }
+
+ #[test]
+ fn test_to_number_from_boolean() {
+ assert_eq!(XPathValue::Boolean(true).to_number(), 1.0);
+ assert_eq!(XPathValue::Boolean(false).to_number(), 0.0);
+ }
+
+ #[test]
+ fn test_to_number_from_string() {
+ assert_eq!(XPathValue::String("42".to_owned()).to_number(), 42.0);
+ assert_eq!(XPathValue::String(" 3.5 ".to_owned()).to_number(), 3.5);
+ assert_eq!(XPathValue::String("-7".to_owned()).to_number(), -7.0);
+ assert!(XPathValue::String("not a number".to_owned())
+ .to_number()
+ .is_nan());
+ assert!(XPathValue::String(String::new()).to_number().is_nan());
+ }
+
+ #[test]
+ fn test_to_number_from_nodeset_without_doc() {
+ let mut doc = Document::new();
+ let id = make_node_id_in_doc(&mut doc);
+ assert!(XPathValue::NodeSet(vec![id.into()]).to_number().is_nan());
+ }
+
+ #[test]
+ fn test_to_number_with_string_value() {
+ let mut doc = Document::new();
+ let id = make_node_id_in_doc(&mut doc);
+ let val = XPathValue::NodeSet(vec![id.into()]);
+ assert_eq!(val.to_number_with_string_value(Some("42")), 42.0);
+ assert!(val.to_number_with_string_value(Some("abc")).is_nan());
+ assert!(val.to_number_with_string_value(None).is_nan());
+ }
+
+ // -- String conversion --------------------------------------------------
+
+ #[test]
+ fn test_to_xpath_string_from_string() {
+ assert_eq!(
+ XPathValue::String("hello".to_owned()).to_xpath_string(),
+ "hello"
+ );
+ }
+
+ #[test]
+ fn test_to_xpath_string_from_boolean() {
+ assert_eq!(XPathValue::Boolean(true).to_xpath_string(), "true");
+ assert_eq!(XPathValue::Boolean(false).to_xpath_string(), "false");
+ }
+
+ #[test]
+ fn test_to_xpath_string_from_number() {
+ assert_eq!(XPathValue::Number(1.0).to_xpath_string(), "1");
+ assert_eq!(XPathValue::Number(-1.0).to_xpath_string(), "-1");
+ assert_eq!(XPathValue::Number(0.0).to_xpath_string(), "0");
+ assert_eq!(XPathValue::Number(1.5).to_xpath_string(), "1.5");
+ assert_eq!(XPathValue::Number(f64::NAN).to_xpath_string(), "NaN");
+ assert_eq!(
+ XPathValue::Number(f64::INFINITY).to_xpath_string(),
+ "Infinity"
+ );
+ assert_eq!(
+ XPathValue::Number(f64::NEG_INFINITY).to_xpath_string(),
+ "-Infinity"
+ );
+ }
+
+ // -- Number formatting edge cases ---------------------------------------
+
+ #[test]
+ fn test_format_xpath_number_negative_zero() {
+ // XPath requires that -0 formats as "0", not "-0"
+ assert_eq!(format_xpath_number(-0.0), "0");
+ }
+
+ #[test]
+ fn test_format_xpath_number_integers() {
+ assert_eq!(format_xpath_number(0.0), "0");
+ assert_eq!(format_xpath_number(1.0), "1");
+ assert_eq!(format_xpath_number(-1.0), "-1");
+ assert_eq!(format_xpath_number(100.0), "100");
+ assert_eq!(format_xpath_number(999_999.0), "999999");
+ }
+
+ #[test]
+ fn test_format_xpath_number_fractional() {
+ assert_eq!(format_xpath_number(1.5), "1.5");
+ assert_eq!(format_xpath_number(0.1), "0.1");
+ assert_eq!(format_xpath_number(-2.75), "-2.75");
+ }
+
+ #[test]
+ fn test_format_xpath_number_special_values() {
+ assert_eq!(format_xpath_number(f64::NAN), "NaN");
+ assert_eq!(format_xpath_number(f64::INFINITY), "Infinity");
+ assert_eq!(format_xpath_number(f64::NEG_INFINITY), "-Infinity");
+ }
+
+ // -- as_node_set --------------------------------------------------------
+
+ #[test]
+ fn test_as_node_set() {
+ let mut doc = Document::new();
+ let id = make_node_id_in_doc(&mut doc);
+ let ns = XPathValue::NodeSet(vec![id.into()]);
+ assert!(ns.as_node_set().is_some());
+ assert_eq!(ns.as_node_set().unwrap().len(), 1);
+
+ assert!(XPathValue::Boolean(true).as_node_set().is_none());
+ assert!(XPathValue::Number(1.0).as_node_set().is_none());
+ assert!(XPathValue::String("x".to_owned()).as_node_set().is_none());
+ }
+
+ // -- type_name ----------------------------------------------------------
+
+ #[test]
+ fn test_type_name() {
+ assert_eq!(XPathValue::Boolean(true).type_name(), "boolean");
+ assert_eq!(XPathValue::Number(0.0).type_name(), "number");
+ assert_eq!(XPathValue::String(String::new()).type_name(), "string");
+ assert_eq!(XPathValue::NodeSet(vec![]).type_name(), "node-set");
+ }
+
+ // -- Display ------------------------------------------------------------
+
+ #[test]
+ fn test_display() {
+ let mut doc = Document::new();
+ let id1 = make_node_id_in_doc(&mut doc);
+ let id2 = make_node_id_in_doc(&mut doc);
+
+ assert_eq!(XPathValue::Boolean(true).to_string(), "true");
+ assert_eq!(XPathValue::Boolean(false).to_string(), "false");
+ assert_eq!(XPathValue::Number(42.0).to_string(), "42");
+ assert_eq!(XPathValue::String("hi".to_owned()).to_string(), "hi");
+ assert_eq!(
+ XPathValue::NodeSet(vec![id1.into(), id2.into()]).to_string(),
+ "<node-set of 2 nodes>"
+ );
+ }
+
+ // -- PartialEq ----------------------------------------------------------
+
+ #[test]
+ fn test_partial_eq() {
+ assert_eq!(XPathValue::Boolean(true), XPathValue::Boolean(true));
+ assert_ne!(XPathValue::Boolean(true), XPathValue::Boolean(false));
+ assert_eq!(XPathValue::Number(1.0), XPathValue::Number(1.0));
+ // NaN != NaN
+ assert_ne!(XPathValue::Number(f64::NAN), XPathValue::Number(f64::NAN));
+ assert_eq!(
+ XPathValue::String("a".to_owned()),
+ XPathValue::String("a".to_owned())
+ );
+ // Different variants are never equal via PartialEq
+ assert_ne!(XPathValue::Boolean(true), XPathValue::Number(1.0));
+ }
+
+ // -- Comparison helpers -------------------------------------------------
+
+ #[test]
+ fn test_compare_values_eq_booleans() {
+ let t = XPathValue::Boolean(true);
+ let f = XPathValue::Boolean(false);
+ assert_eq!(compare_values_eq(&t, &t), Some(true));
+ assert_eq!(compare_values_eq(&t, &f), Some(false));
+ }
+
+ #[test]
+ fn test_compare_values_eq_boolean_coercion() {
+ // When one operand is boolean, the other is converted to boolean
+ let t = XPathValue::Boolean(true);
+ let num = XPathValue::Number(42.0); // to_boolean() -> true
+ assert_eq!(compare_values_eq(&t, &num), Some(true));
+
+ let f = XPathValue::Boolean(false);
+ let zero = XPathValue::Number(0.0); // to_boolean() -> false
+ assert_eq!(compare_values_eq(&f, &zero), Some(true));
+ }
+
+ #[test]
+ fn test_compare_values_eq_number_and_string() {
+ // When one is number and other is string, convert string to number
+ let num = XPathValue::Number(42.0);
+ let s = XPathValue::String("42".to_owned());
+ assert_eq!(compare_values_eq(&num, &s), Some(true));
+
+ let bad = XPathValue::String("abc".to_owned());
+ assert_eq!(compare_values_eq(&num, &bad), Some(false));
+ }
+
+ #[test]
+ fn test_compare_values_eq_strings() {
+ let a = XPathValue::String("hello".to_owned());
+ let b = XPathValue::String("hello".to_owned());
+ let c = XPathValue::String("world".to_owned());
+ assert_eq!(compare_values_eq(&a, &b), Some(true));
+ assert_eq!(compare_values_eq(&a, &c), Some(false));
+ }
+
+ #[test]
+ fn test_compare_values_eq_with_nodeset_returns_none() {
+ let mut doc = Document::new();
+ let id = make_node_id_in_doc(&mut doc);
+ let ns = XPathValue::NodeSet(vec![id.into()]);
+ let s = XPathValue::String("x".to_owned());
+ assert_eq!(compare_values_eq(&ns, &s), None);
+ assert_eq!(compare_values_eq(&s, &ns), None);
+ }
+
+ #[test]
+ fn test_compare_with_string_values_nodeset_to_string() {
+ let mut doc = Document::new();
+ let id1 = make_node_id_in_doc(&mut doc);
+ let id2 = make_node_id_in_doc(&mut doc);
+ let ns = XPathValue::NodeSet(vec![id1.into(), id2.into()]);
+ let s = XPathValue::String("hello".to_owned());
+ let node_strings = vec!["world".to_owned(), "hello".to_owned()];
+
+ assert!(compare_values_with_string_values(
+ &ns,
+ &s,
+ &node_strings,
+ &[]
+ ));
+ }
+
+ #[test]
+ fn test_compare_with_string_values_nodeset_to_number() {
+ let mut doc = Document::new();
+ let id1 = make_node_id_in_doc(&mut doc);
+ let id2 = make_node_id_in_doc(&mut doc);
+ let ns = XPathValue::NodeSet(vec![id1.into(), id2.into()]);
+ let n = XPathValue::Number(42.0);
+ let node_strings = vec!["10".to_owned(), "42".to_owned()];
+
+ assert!(compare_values_with_string_values(
+ &ns,
+ &n,
+ &node_strings,
+ &[]
+ ));
+ }
+
+ #[test]
+ fn test_compare_with_string_values_nodeset_to_boolean() {
+ let mut doc = Document::new();
+ let id = make_node_id_in_doc(&mut doc);
+ let ns = XPathValue::NodeSet(vec![id.into()]);
+ let b = XPathValue::Boolean(true);
+
+ assert!(compare_values_with_string_values(&ns, &b, &[], &[]));
+
+ let empty_ns = XPathValue::NodeSet(vec![]);
+ assert!(!compare_values_with_string_values(&empty_ns, &b, &[], &[]));
+ }
+
+ #[test]
+ fn test_compare_with_string_values_nodeset_to_nodeset() {
+ let mut doc = Document::new();
+ let id1 = make_node_id_in_doc(&mut doc);
+ let id2 = make_node_id_in_doc(&mut doc);
+ let ns1 = XPathValue::NodeSet(vec![id1.into()]);
+ let ns2 = XPathValue::NodeSet(vec![id2.into()]);
+
+ let strings1 = vec!["hello".to_owned()];
+ let strings2 = vec!["hello".to_owned()];
+
+ assert!(compare_values_with_string_values(
+ &ns1, &ns2, &strings1, &strings2,
+ ));
+
+ let strings2_diff = vec!["world".to_owned()];
+ assert!(!compare_values_with_string_values(
+ &ns1,
+ &ns2,
+ &strings1,
+ &strings2_diff,
+ ));
+ }
+
+ // -- XPathError Display -------------------------------------------------
+
+ #[test]
+ fn test_xpath_error_display_type_error() {
+ let err = XPathError::TypeError {
+ expected: "node-set".to_owned(),
+ found: "string".to_owned(),
+ };
+ assert_eq!(
+ err.to_string(),
+ "type error: expected node-set, found string"
+ );
+ }
+
+ #[test]
+ fn test_xpath_error_display_undefined_variable() {
+ let err = XPathError::UndefinedVariable {
+ name: "foo".to_owned(),
+ };
+ assert_eq!(err.to_string(), "undefined variable: $foo");
+ }
+
+ #[test]
+ fn test_xpath_error_display_undefined_function() {
+ let err = XPathError::UndefinedFunction {
+ name: "my-func".to_owned(),
+ };
+ assert_eq!(err.to_string(), "undefined function: my-func()");
+ }
+
+ #[test]
+ fn test_xpath_error_display_invalid_arg_count() {
+ let err = XPathError::InvalidArgCount {
+ function: "substring".to_owned(),
+ expected: 2,
+ found: 5,
+ };
+ assert_eq!(
+ err.to_string(),
+ "invalid argument count for substring(): expected 2, found 5"
+ );
+ }
+
+ #[test]
+ fn test_xpath_error_display_invalid_expression() {
+ let err = XPathError::InvalidExpression {
+ message: "unexpected token ')'".to_owned(),
+ };
+ assert_eq!(
+ err.to_string(),
+ "invalid XPath expression: unexpected token ')'"
+ );
+ }
+
+ #[test]
+ fn test_xpath_error_display_internal_error() {
+ let err = XPathError::InternalError {
+ message: "stack overflow".to_owned(),
+ };
+ assert_eq!(err.to_string(), "internal XPath error: stack overflow");
+ }
+
+ #[test]
+ fn test_xpath_error_is_error_trait() {
+ let err = XPathError::TypeError {
+ expected: "boolean".to_owned(),
+ found: "number".to_owned(),
+ };
+ let _: &dyn std::error::Error = &err;
+ }
+
+ // -- to_string_with_string_value ----------------------------------------
+
+ #[test]
+ fn test_to_string_with_string_value_nodeset() {
+ let mut doc = Document::new();
+ let id = make_node_id_in_doc(&mut doc);
+ let val = XPathValue::NodeSet(vec![id.into()]);
+ assert_eq!(val.to_string_with_string_value(Some("hello")), "hello");
+ assert_eq!(val.to_string_with_string_value(None), "");
+ }
+
+ #[test]
+ fn test_to_string_with_string_value_non_nodeset() {
+ let val = XPathValue::Number(42.0);
+ // The string value parameter is ignored for non-node-set values
+ assert_eq!(val.to_string_with_string_value(Some("ignored")), "42");
+ }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5cabd5e79..3f7d56fd2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -23,9 +23,15 @@ importers:
esbuild:
specifier: ^0.25.0
version: 0.25.12
+ react:
+ specifier: ^19.2.6
+ version: 19.2.7
typescript:
specifier: ^5.9.2
version: 5.9.3
+ vitest:
+ specifier: ^4.1.6
+ version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@25.9.5)(@vitest/coverage-v8@4.1.10)(vite@8.1.5(@types/node@25.9.5)(jiti@2.7.0))
canvas/ui:
dependencies:
]]></plaintext></word></div> 