dommy 0.8.0 → 0.9.0

data/lib/dommy/internal/css/ua_stylesheet.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "parser"
+
+module Dommy
+  module Internal
+    module CSS
+      # The minimal UA stylesheet (HTML Standard, Rendering section): the
+      # non-rendering / hidden defaults that visibility detection depends on,
+      # display type defaults, and details/dialog behavior. Kept deliberately
+      # small — anything an author sheet usually overrides anyway is omitted.
+      #
+      # Selectors must stay within what both DOM backends can match
+      # (so no case-insensitive attribute flags, no state pseudo-classes).
+      module UAStylesheet
+        TEXT = <<~CSS
+          [hidden] { display: none }
+          area, base, basefont, datalist, head, link, meta, noembed,
+          noframes, param, rp, script, style, template, title { display: none }
+          input[type="hidden"] { display: none }
+          dialog:not([open]) { display: none }
+          details:not([open]) > *:not(summary) { display: none }
+
+          html, body, address, article, aside, blockquote, details, dialog,
+          dd, div, dl, dt, fieldset, figcaption, figure, footer, form,
+          h1, h2, h3, h4, h5, h6, header, hgroup, hr, legend, main, nav, ol, p,
+          pre, section, summary, ul { display: block }
+          li { display: list-item }
+          table { display: table }
+          caption { display: table-caption }
+          colgroup { display: table-column-group }
+          col { display: table-column }
+          thead { display: table-header-group }
+          tbody { display: table-row-group }
+          tfoot { display: table-footer-group }
+          tr { display: table-row }
+          td, th { display: table-cell }
+
+          b, strong { font-weight: 700 }
+          i, em, cite, var, dfn { font-style: italic }
+          pre, code, kbd, samp { font-family: monospace }
+          center { text-align: center }
+        CSS
+
+        module_function
+
+        def rules
+          @rules ||= Parser.parse(TEXT).freeze
+        end
+      end
+    end
+  end
+end

data/lib/dommy/internal/css_pseudo_handlers.rb

@@ -2,47 +2,11 @@
 
 module Dommy
   module Internal
-    # Custom Nokogiri pseudo-class handlers so CSS selectors like
-    # `:disabled` / `:enabled` / `:checked` work in query_selector(_all).
-    # Nokogiri calls the method named after the pseudo-class with the current
-    # node list and expects the filtered list back. Receives raw Nokogiri
-    # nodes (not Dommy wrappers).
-    class CSSPseudoHandlers < BasicObject
-      include ::Kernel
-
-      def disabled(list)
-        list.find_all { |node| node.has_attribute?("disabled") }
-      end
-
-      def enabled(list)
-        list.find_all { |node| !node.has_attribute?("disabled") }
-      end
-
-      def checked(list)
-        list.find_all { |node| node.has_attribute?("checked") }
-      end
-    end
-
-    CSS_PSEUDO_HANDLERS = CSSPseudoHandlers.new
-
-    # Adds `:scope` support. Nokogiri compiles `:scope` into a custom XPath
-    # function `nokogiri:scope(.)`, calling it as `scope(node_set)`; a scoped
-    # query (`el.querySelector(":scope > p")`) resolves it to the context
-    # element, so only that element matches. One instance per query — it carries
-    # the context node.
-    class ScopedCSSPseudoHandlers < CSSPseudoHandlers
-      def initialize(scope_node)
-        @scope_node = scope_node
-      end
-
-      def scope(list)
-        list.find_all { |node| node.pointer_id == @scope_node.pointer_id }
-      end
-    end
-
-    def self.scoped_pseudo_handlers(scope_node)
-      ScopedCSSPseudoHandlers.new(scope_node)
-    end
+    # CSS selector validation and sanitization shared by all backends. The
+    # custom pseudo-class *evaluation* (`:disabled`/`:enabled`/`:checked`/
+    # `:scope`) is backend-specific and lives in each backend adapter (see
+    # `Backend.select_all`); what stays here is the backend-independent grammar
+    # checking and the backend-safe rewriting that precedes every query.
 
     # The complete set of CSS pseudo-classes (+ the four legacy single-colon
     # pseudo-elements). A `:identifier` outside this set is an unknown selector
@@ -99,14 +63,291 @@ module Dommy
     def self.backend_safe_selector(selector)
       # First drop clauses whose subject is a pseudo-element (`::before`,
       # `:first-line`) — they match no element, and the backend can't compile
-      # `::`. Then drop the escaped-colon attribute clauses below.
+      # `::`. Then normalise two valid-but-backend-unfriendly forms before the
+      # escaped-colon handling: a trailing unclosed `[`/`(` (CSS closes these at
+      # EOF) and namespace prefixes (`*|attr`, `|el` — in an HTML document every
+      # node/attribute is in the null namespace, so the prefix is matched away).
       s = SelectorParser.matchable_selector(selector.to_s)
+      s = strip_namespace_prefixes(close_open_brackets(s))
+      # `:visited` never matches without browsing history (which Dommy doesn't
+      # model), so reduce it to a never-match — and, as a bonus, drop the
+      # dependency on a backend that can't compile `:visited` (lexbor) while
+      # `:link` (an unvisited link) is matched normally.
+      s = s.gsub(/:visited(?![\w-])/, ":not(*)") if s.include?(":visited")
+      # Neither backend's selector engine implements `:lang()` (lexbor registers
+      # it but its parse handler is a deliberate fail-stub). Strip it for the
+      # backend; the caller post-filters matches with #lang_match? — see the
+      # query methods.
+      s = s.gsub(LANG_PSEUDO, "") if s =~ /:lang\(/i
+      # `:target` (the element referenced by the document's URL fragment) is also
+      # unsupported by the backends; strip it and post-filter by id. A bare
+      # `:target` collapses to the universal selector.
+      if s =~ /:target(?![\w-])/
+        s = s.gsub(/:target(?![\w-])/, "")
+        s = "*" if s.strip.empty?
+      end
+      # Both backends treat `:enabled` / `:disabled` as always-true (matching
+      # every element, not just disableable form controls), so strip them and
+      # post-filter with #enableable?/#form_control_disabled? — see the query
+      # methods. A standalone occurrence (`#x :enabled`) becomes the universal
+      # selector so the combinator keeps a subject.
+      if s =~ ENABLED_DISABLED_PSEUDO
+        s = s.gsub(/(^|[\s>+~,(])\s*:(?:enabled|disabled)(?![\w-])/) { "#{Regexp.last_match(1)}*" }
+        s = s.gsub(ENABLED_DISABLED_PSEUDO, "")
+        s = "*" if s.strip.empty?
+      end
+      # Legacy backend-safe rewriting for callers that still delegate to a
+      # backend selector engine. The primary DOM query and cascade paths use
+      # SelectorMatcher and do not strip state pseudo-classes.
+      if s =~ STATE_PSEUDO
+        s = broaden_state_pseudo_functions(s)
+        s = s.gsub(/(^|[\s>+~,(])\s*:(?:hover|focus-within|focus-visible|focus|checked)(?![\w-])/) { "#{Regexp.last_match(1)}*" }
+        s = s.gsub(STATE_PSEUDO, "")
+        s = "*" if s.strip.empty?
+      end
       return s unless s.include?('\\') && s.match?(ATTR_ESCAPED_COLON)
 
       kept = split_selector_list(s).reject { |clause| clause.match?(ATTR_ESCAPED_COLON) }
       kept.empty? ? ":not(*)" : kept.join(", ")
     end
 
+    # The argument of a `:lang(X)` pseudo-class, when the selector has exactly
+    # one distinct one (the common `#x:lang(en)` shape); nil when there is none.
+    # Multiple distinct languages can't be recovered from the result set alone,
+    # so those fall back to the stripped backend selector (which over-matches).
+    LANG_PSEUDO = /:lang\(\s*("?)([^)"']*)\1\s*\)/i
+    def self.lang_pseudo_value(selector)
+      langs = selector.to_s.scan(LANG_PSEUDO).map { |m| m[1].strip.downcase }.reject(&:empty?).uniq
+      langs.size == 1 ? langs.first : nil
+    end
+
+    # `:lang(x)` matching (BCP47 extended filtering): an element's content
+    # language is the value of the nearest `lang` attribute on it or an
+    # ancestor, and `:lang(x)` matches when that language equals `x` or begins
+    # with `x` + "-" (case-insensitively). No `lang` in the chain → no match.
+    def self.lang_match?(backend_node, lang)
+      actual = nearest_lang(backend_node)
+      return false unless actual
+
+      a = actual.downcase
+      a == lang || a.start_with?("#{lang}-")
+    end
+
+    # The disableable form-control elements `:enabled` / `:disabled` apply to.
+    ENABLEABLE_ELEMENTS = %w[button input select textarea optgroup option fieldset].freeze
+    ENABLED_DISABLED_PSEUDO = /:(?:enabled|disabled)(?![\w-])/
+
+    # State pseudo-classes evaluated by post-filter against DOM state
+    # (longest alternatives first so :focus doesn't shadow :focus-within).
+    STATE_PSEUDO = /:(?:hover|focus-within|focus-visible|focus|checked)(?![\w-])/
+
+    # Run a backend selector evaluation with the shared error policy:
+    # - an "Unregistered function" means a valid pseudo the backend compiled
+    #   but can't evaluate (`:active`, `:invalid`, …) → degrade to no match
+    #   (returns []),
+    # - a backend syntax complaint becomes a DOMException::SyntaxError,
+    # - anything else propagates.
+    def self.with_selector_errors(selector)
+      yield
+    rescue ::StandardError => e
+      return [] if e.message.include?("Unregistered function")
+
+      if (defined?(::Nokogiri::CSS::SyntaxError) && e.is_a?(::Nokogiri::CSS::SyntaxError)) || e.message.include?("unexpected")
+        raise DOMException::SyntaxError, "'#{selector}' is not a valid selector."
+      end
+
+      raise
+    end
+
+    # `:hover` matches the hovered element and all its ancestors; same shape
+    # for `:focus-within` against the focused element.
+    def self.self_or_ancestor_of?(backend_node, target, document)
+      element = document.wrap_node(backend_node)
+      return false unless element
+
+      element == target || (element.respond_to?(:contains?) && element.contains?(target))
+    end
+
+    # `:checked`'s checkedness/selectedness is live state, not the attribute:
+    # checkbox/radio inputs match on the checked property (which defaults to
+    # the attribute), <option> on selectedness.
+    def self.checked_state?(element)
+      return false unless element
+
+      case element.tag_name
+      when "INPUT"
+        %w[checkbox radio].include?(element.respond_to?(:type) ? element.type.to_s : "") &&
+          element.respond_to?(:checked) && !!element.checked
+      when "OPTION"
+        element.respond_to?(:selected) && !!element.selected
+      else
+        false
+      end
+    end
+
+    # `:enabled` / `:disabled` apply only to disableable form controls — not to
+    # links or any other element, which the backends wrongly match.
+    def self.enableable?(backend_node)
+      ENABLEABLE_ELEMENTS.include?(backend_node.name.to_s.downcase)
+    end
+
+    # A form control is disabled when it carries the `disabled` attribute, or — for
+    # an <option> — its containing <optgroup> is disabled. (The disabled-<fieldset>
+    # descendant propagation is not modeled.)
+    def self.form_control_disabled?(backend_node)
+      return true unless backend_node["disabled"].nil?
+
+      if backend_node.name.to_s.downcase == "option"
+        parent = backend_node.respond_to?(:parent) ? backend_node.parent : nil
+        return true if parent.respond_to?(:name) &&
+                       parent.name.to_s.downcase == "optgroup" && !parent["disabled"].nil?
+      end
+      false
+    end
+
+    # The id referenced by the document's URL fragment (`:target`), or nil when
+    # there is no fragment.
+    def self.target_id(document)
+      view = document.respond_to?(:default_view) ? document.default_view : nil
+      loc = view.respond_to?(:location) ? view.location : nil if view
+      hash = loc&.__js_get__("hash").to_s
+      hash.start_with?("#") && hash.length > 1 ? hash[1..] : nil
+    end
+
+    def self.nearest_lang(backend_node)
+      node = backend_node
+      while node
+        if node.respond_to?(:element?) && node.element?
+          v = node["lang"]
+          return v if v && !v.to_s.empty?
+        end
+        node = node.respond_to?(:parent) ? node.parent : nil
+      end
+      nil
+    end
+
+    STATE_FUNCTIONS = %w[not is where has].freeze
+
+    # If a functional pseudo-class contains a state pseudo, dropping only the
+    # state token changes logic (`:not(:hover)` -> `:not(*)`). Drop the whole
+    # function for candidate collection instead; the structural filter above
+    # restores exact semantics.
+    def self.broaden_state_pseudo_functions(selector)
+      s = selector.to_s
+      out = +""
+      i = 0
+      while i < s.length
+        fn = STATE_FUNCTIONS.find do |name|
+          token = s[i, name.length + 2]
+          token && token.casecmp?(":#{name}(")
+        end
+        if fn
+          close = matching_paren_index(s, i + fn.length + 1)
+          if close && s[i..close] =~ STATE_PSEUDO
+            i = close + 1
+            next
+          end
+        end
+        out << s[i]
+        i += 1
+      end
+      out
+    end
+
+    def self.matching_paren_index(string, open_index)
+      depth = 0
+      quote = nil
+      esc = false
+      i = open_index
+      while i < string.length
+        ch = string[i]
+        if esc
+          esc = false
+        elsif ch == "\\"
+          esc = true
+        elsif quote
+          quote = nil if ch == quote
+        elsif ch == '"' || ch == "'"
+          quote = ch
+        elsif ch == "("
+          depth += 1
+        elsif ch == ")"
+          depth -= 1
+          return i if depth.zero?
+        end
+        i += 1
+      end
+      nil
+    end
+
+    # Append the closers for any `[`/`(` left open outside a string — CSS
+    # tokenizing implicitly closes them at EOF, so `[align="center"` is the valid
+    # `[align="center"]`, but the backend selector engines reject the unclosed
+    # form. String contents and escapes are skipped.
+    def self.close_open_brackets(selector)
+      sq = 0
+      pr = 0
+      quote = nil
+      esc = false
+      selector.each_char do |ch|
+        if esc
+          esc = false
+        elsif ch == "\\"
+          esc = true
+        elsif quote
+          quote = nil if ch == quote
+        elsif ch == '"' || ch == "'"
+          quote = ch
+        elsif ch == "["
+          sq += 1
+        elsif ch == "]"
+          sq -= 1 if sq.positive?
+        elsif ch == "("
+          pr += 1
+        elsif ch == ")"
+          pr -= 1 if pr.positive?
+        end
+      end
+      selector + ("]" * sq) + (")" * pr)
+    end
+
+    # Drop CSS namespace prefixes (`*|`, `|`) that precede a type or attribute
+    # name. An HTML document has only the HTML / null namespaces, so `*|x`
+    # (any namespace) and `|x` (no namespace) both reduce to `x`. Leaves the
+    # `|=` attribute matcher and the `||` column combinator intact, and never
+    # touches a `|` inside a string.
+    def self.strip_namespace_prefixes(selector)
+      out = +""
+      quote = nil
+      esc = false
+      chars = selector.chars
+      i = 0
+      while i < chars.length
+        ch = chars[i]
+        if esc
+          out << ch
+          esc = false
+        elsif ch == "\\"
+          out << ch
+          esc = true
+        elsif quote
+          out << ch
+          quote = nil if ch == quote
+        elsif ch == '"' || ch == "'"
+          quote = ch
+          out << ch
+        elsif ch == "*" && chars[i + 1] == "|" && chars[i + 2] != "=" && chars[i + 2] != "|"
+          i += 1 # skip the `*`; the `|` is handled next iteration
+        elsif ch == "|" && chars[i + 1] != "=" && chars[i + 1] != "|" && out[-1] != "|"
+          # bare namespace separator — drop it (not `|=`, not `||`)
+        else
+          out << ch
+        end
+        i += 1
+      end
+      out
+    end
+
     # Split a selector list on top-level commas only (commas inside [...], (...),
     # or quotes are part of a single complex selector and must not split it).
     def self.split_selector_list(selector)

data/lib/dommy/internal/css_rule_text.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Splits raw stylesheet text into individual rule slices and pulls a
+    # single rule apart into its prelude (selector / at-rule condition) and
+    # body — enough to back the CSSOM CSSRule accessors (selectorText, style,
+    # nested cssRules) without re-tokenizing the whole grammar. Each slice is
+    # kept verbatim so CSSRule#cssText round-trips the source until mutated.
+    #
+    # This is deliberately a lightweight scanner (it tracks brace depth,
+    # string literals and `/* */` comments); the cascade's correctness still
+    # comes from lexbor. It exists only to give JS-visible CSSOM introspection.
+    module CSSRuleText
+      module_function
+
+      # Top-level rule slices in source order, each stripped of surrounding
+      # whitespace. Block rules (`sel { ... }`, `@media ... { ... }`) span to
+      # their matching `}`; statement at-rules (`@import ...;`) span to `;`.
+      #
+      # Scans over the BINARY bytes, not the UTF-8 characters: every byte we
+      # branch on ({ } " ' / * ; \\ and ASCII whitespace) is 7-bit, and a UTF-8
+      # multibyte sequence is wholly bytes >= 0x80 — none of which collide with
+      # those, so the structure is read identically while `bytes[i]` stays O(1)
+      # (UTF-8 `String#[i]` is O(i), making the whole scan O(n^2) — the dominant
+      # cost on a large stylesheet). Slice boundaries always land on a 7-bit byte
+      # (a delimiter) or a UTF-8 lead byte (the first non-space of a prelude), so
+      # each byteslice is a whole-character substring; re-tag it UTF-8 on the way
+      # out so the verbatim rule text round-trips unchanged.
+      def split_rules(text)
+        bytes = text.to_s.b
+        rules = []
+        start = nil
+        depth = 0
+        string = nil
+        i = 0
+        len = bytes.length
+
+        while i < len
+          ch = bytes[i]
+
+          if string
+            if ch == "\\"
+              i += 2
+              next
+            end
+            string = nil if ch == string
+            i += 1
+            next
+          end
+
+          if ch == "/" && bytes[i + 1] == "*"
+            close = bytes.index("*/", i + 2)
+            i = (close || len - 2) + 2
+            next
+          end
+
+          case ch
+          when '"', "'"
+            start ||= i
+            string = ch
+          when "{"
+            start ||= i
+            depth += 1
+          when "}"
+            depth -= 1 if depth.positive?
+            if depth.zero? && start
+              rules << bytes[start..i]
+              start = nil
+            end
+          when ";"
+            if depth.zero? && start
+              rules << bytes[start..i]
+              start = nil
+            end
+          else
+            start ||= i unless ch.match?(/\s/)
+          end
+
+          i += 1
+        end
+
+        rules << bytes[start..] if start
+        rules.map { |slice| slice.force_encoding(Encoding::UTF_8).strip }.reject(&:empty?)
+      end
+
+      # [prelude, body] for one rule slice. `body` is the text between the
+      # outermost braces, or nil for a braceless statement at-rule. `prelude`
+      # is the selector list (style rule) or the at-rule keyword + condition.
+      #
+      # Walks the BINARY bytes for the same reason as #split_rules: the brace
+      # scan is O(1) per byte instead of O(i) per UTF-8 character. Brace indices
+      # land on the 7-bit `{`/`}`, so every byteslice is a whole-character
+      # substring; re-tag the pieces UTF-8.
+      def split_rule(text)
+        bytes = text.to_s.b
+        brace = top_level_brace(bytes)
+        return [bytes.force_encoding(Encoding::UTF_8).sub(/;\s*\z/, "").strip, nil] unless brace
+
+        prelude = bytes[0...brace].force_encoding(Encoding::UTF_8).strip
+        close = matching_brace(bytes, brace)
+        body = bytes[(brace + 1)...(close || bytes.length)].to_s.force_encoding(Encoding::UTF_8)
+        [prelude, body]
+      end
+
+      # The at-rule keyword (lowercased, without `@`) of a prelude, or nil for
+      # a plain style rule.
+      def at_keyword(prelude)
+        match = prelude.to_s.match(/\A@(-?[a-z][a-z-]*)/i)
+        match && match[1].downcase
+      end
+
+      # Index of the first `{` at brace depth 0, skipping strings and comments.
+      def top_level_brace(text)
+        scan_braces(text, 0) { |ch, i| return i if ch == "{" }
+        nil
+      end
+
+      # Index of the `}` matching the `{` at `open`, skipping nested braces,
+      # strings and comments. nil when unterminated.
+      def matching_brace(text, open)
+        depth = 0
+        scan_braces(text, open) do |ch, i|
+          depth += 1 if ch == "{"
+          if ch == "}"
+            depth -= 1
+            return i if depth.zero?
+          end
+        end
+        nil
+      end
+
+      # Walk `text` from `from`, yielding [char, index] for each `{`/`}` that
+      # lies outside string literals and `/* */` comments.
+      def scan_braces(text, from)
+        string = nil
+        i = from
+        len = text.length
+        while i < len
+          ch = text[i]
+          if string
+            if ch == "\\"
+              i += 2
+              next
+            end
+            string = nil if ch == string
+          elsif ch == "/" && text[i + 1] == "*"
+            i = (text.index("*/", i + 2) || len - 2) + 2
+            next
+          elsif ch == '"' || ch == "'"
+            string = ch
+          elsif ch == "{" || ch == "}"
+            yield ch, i
+          end
+          i += 1
+        end
+      end
+    end
+  end
+end

data/lib/dommy/internal/dom_matching.rb

@@ -83,13 +83,13 @@ module Dommy
         end
       end
 
-      # Best-effort visibility check using HTML-level signals only.
-      # Does NOT evaluate CSS stylesheets — `display: none` via class
-      # is NOT detected. See README for details and workarounds.
-      #
-      # Detects: `hidden` attribute, `<input type=hidden>`, non-rendering
-      # ancestors (head/script/style/template), inline `display:none` /
-      # `visibility:hidden` on element or any ancestor.
+      # Visibility check. Fast HTML-level signals first (`hidden` attribute,
+      # `<input type=hidden>`, non-rendering ancestors, inline
+      # `display:none` / `visibility:hidden`); when the document carries
+      # author CSS and the makiri-backed parser is available, stylesheet-
+      # driven `display:none` / `visibility:hidden` (e.g. via a class) is
+      # detected through the computed style as well. No layout: geometry-
+      # dependent invisibility stays out of scope.
       def visible?(element)
         return true unless element.respond_to?(:__dommy_backend_node__)
 
@@ -101,9 +101,40 @@ module Dommy
           return false if node_invisible_self?(ancestor)
         end
 
+        css_visible?(element)
+      end
+
+      # CSS-aware extension of visible?, consulted only when the document
+      # has author CSS (Cascade.author_css? keeps sheetless documents on the
+      # fast path). `display: none` on the element or any ancestor hides;
+      # computed `visibility: hidden/collapse` (inherited, overridable by a
+      # descendant's `visibility: visible`) hides.
+      def css_visible?(element)
+        document = element.respond_to?(:owner_document) ? element.owner_document : nil
+        return true unless document && CSS::Cascade.author_css?(document)
+
+        return false if %w[hidden collapse].include?(CSS::Cascade.computed_style(element)["visibility"])
+
+        current = element
+        while current
+          styles = CSS::Cascade.computed_style(current)
+          return false if styles["display"] == "none"
+          # Zero effective opacity is invisible (Selenium's displayed
+          # algorithm); a zero anywhere in the chain zeroes the product.
+          return false if opacity_zero?(styles["opacity"])
+          current = current.respond_to?(:parent_element) ? current.parent_element : nil
+        end
+
         true
       end
 
+      def opacity_zero?(value)
+        text = value.to_s.strip
+        return false unless text.match?(/\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)%?\z/)
+
+        text.to_f <= 0
+      end
+
       # Filter elements by Capybara-style :visible option.
       # @param elements [Array]
       # @param visible [:visible, :all, :hidden, true, false, nil]
@@ -128,14 +159,54 @@ module Dommy
         return true if node.respond_to?(:name) && node.name == "input" && node["type"] == "hidden"
 
         style = node["style"].to_s
-        style.match?(/display\s*:\s*none/i) || style.match?(/visibility\s*:\s*hidden/i)
+        style.match?(/display\s*:\s*none/i) ||
+          style.match?(/visibility\s*:\s*hidden/i) ||
+          # Inline zero opacity hides too — keeps the fast path consistent
+          # with the CSS-aware check on sheetless documents.
+          style.match?(INLINE_ZERO_OPACITY)
       end
 
+      # opacity: 0 / 0.0 / .0 / 0% (and nothing else) as an inline value.
+      INLINE_ZERO_OPACITY = /opacity\s*:\s*\+?(?:0+(?:\.0*)?|\.0+)%?\s*(?:[;!]|\z)/i
+
       def non_rendering_tag?(node)
         node.respond_to?(:name) && %w[head script style template].include?(node.name)
       end
 
-      private_class_method :node_invisible_self?, :non_rendering_tag?
+      # Tags whose text never renders, so it must not count as page text.
+      NON_RENDERED_TEXT_TAGS = %w[head script style template noscript].freeze
+
+      # Visible text of a node's subtree: like `text_content`, but excluding
+      # subtrees that never render (script/style/head/template/noscript).
+      # Mirrors what a browser exposes to `has_text?` / text filters, so JSON
+      # embedded in a `<script data-page>` (Inertia/Turbo) or inline CSS is not
+      # mistaken for visible page text.
+      def rendered_text(node)
+        return "" if node.nil?
+
+        out = +""
+        append_rendered_text(node, out)
+        out
+      end
+
+      def append_rendered_text(node, out)
+        return unless node.respond_to?(:child_nodes)
+
+        node.child_nodes.each do |child|
+          # Element wrappers don't expose node_type as a Ruby method (it lives
+          # on the JS bridge), so branch on class: recurse into rendered
+          # elements, take character data verbatim, skip comments.
+          if child.is_a?(Dommy::Element)
+            next if NON_RENDERED_TEXT_TAGS.include?(child.local_name.to_s.downcase)
+
+            append_rendered_text(child, out)
+          elsif child.respond_to?(:node_type) && child.node_type == Dommy::Node::TEXT_NODE
+            out << child.text_content.to_s
+          end
+        end
+      end
+
+      private_class_method :node_invisible_self?, :non_rendering_tag?, :append_rendered_text
     end
   end
 end