dommy 0.14.0 → 0.16.0

data/lib/dommy/internal/input_type.rb

@@ -13,8 +13,8 @@ module Dommy
     # mid-week, so steps measure from 1970-W01) lived three methods away from
     # the code that converts a week string. Here a type is one class.
     #
-    # Only the numeric surface lives here. Value sanitization stays on the
-    # element, where it reads other attributes (`multiple` for email).
+    # Only the numeric and Date surface lives here. Value sanitization stays on
+    # the element, where it reads other attributes (`multiple` for email).
     class InputType
       # The type `name` stands for. An unknown or non-numeric type answers the
       # one that has no numbers, so callers never branch on nil. REGISTRY and
@@ -25,6 +25,10 @@ module Dommy
       # Whether valueAsNumber / stepUp / stepDown apply at all.
       def numeric? = true
 
+      # Whether valueAsDate applies: date, month, week and time only. A
+      # datetime-local value names no instant (it has no time zone).
+      def date? = false
+
       # How many of the number's units one step is worth.
       def scale_factor = 1
 
@@ -51,6 +55,14 @@ module Dommy
       # the one that knows which type to name in the error.
       def from_number(_number) = raise(NotImplementedError)
 
+      # The value string as a Date's time value (ms since the epoch), or NaN
+      # when it is not one. The number valueAsNumber reads, for every date type
+      # but month, which counts months.
+      def to_date_value(text) = to_number(text)
+
+      # A Date's time value as the value string.
+      def from_date_value(time_value) = from_number(time_value)
+
       # A `min`/`max` attribute as a number, or nil when it is not one. The
       # non-numeric type parses nothing, so this is nil for it too.
       def boundary(text) = nan_to_nil(to_number(text))
@@ -74,9 +86,21 @@ module Dommy
 
       VALID_FLOAT = /\A-?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][-+]?\d+)?\z/
 
+      # Float(string), raising ArgumentError for what is no number. A number
+      # past a double's range comes out as ±Infinity, which every caller
+      # already reads as no valid number; Ruby warns about it in verbose mode,
+      # so the warning is held off for the conversion.
+      def self.float(string)
+        verbose = $VERBOSE
+        $VERBOSE = nil
+        Float(string)
+      ensure
+        $VERBOSE = verbose
+      end
+
       def to_number(text)
         string = text.to_s
-        VALID_FLOAT.match?(string) ? (Float(string) rescue ::Float::NAN) : ::Float::NAN
+        VALID_FLOAT.match?(string) ? NumberInputType.float(string) : ::Float::NAN
       end
 
       def from_number(number)
@@ -85,7 +109,7 @@ module Dommy
         number == number.to_i ? number.to_i.to_s : number.to_s
       end
 
-      def boundary(text) = (Float(text) rescue nil)
+      def boundary(text) = (NumberInputType.float(text) rescue nil)
     end
 
     # A range always reads as a number: an unparseable value is the midpoint of
@@ -94,24 +118,46 @@ module Dommy
 
       def value_of(text, element)
         number = to_number(text)
-        low = (Float(element.get_attribute("min").to_s) rescue 0.0)
-        high = (Float(element.get_attribute("max").to_s) rescue 100.0)
-        number = nil if number.nan?
-        number ||= high < low ? low : low + (high - low) / 2.0
-        number.clamp(low, high)
+        low = finite_attribute(element, "min") || 0.0
+        high = finite_attribute(element, "max") || 100.0
+        number = high < low ? low : low / 2.0 + high / 2.0 unless number.finite?
+        number = [number, low].max
+        number = [number, high].min if high >= low
+        return number if element.__internal_attribute_value__("step") == "any"
+
+        step = finite_attribute(element, "step")
+        step = default_step unless step&.positive?
+        base = finite_attribute(element, "min") || finite_attribute(element, "value") || step_base
+        # Round in decimal arithmetic so a valid 0.6 at step 0.1 does not
+        # become 0.6000000000000001, and tiny steps cannot overflow the ratio.
+        number = number.to_s.to_r
+        base = base.to_s.to_r
+        step = step.to_s.to_r
+        offset = (number - base) / step
+        candidates = [offset.floor, offset.ceil].map { |n| base + n * step }
+          .select { |n| n >= low && (high < low || n <= high) }
+        (candidates.min_by { |n| [(n - number).abs, -n] } || number).to_f
+      end
+
+      private
+
+      def finite_attribute(element, name)
+        number = to_number(element.__internal_attribute_value__(name).to_s)
+        number if number.finite?
       end
     end
 
     class DateInputType < InputType
 
       def scale_factor = 86_400_000
+      def date? = true
 
       def to_number(text)
-        match = /\A(\d{4,})-(\d{2})-(\d{2})\z/.match(text.to_s.strip)
+        match = /\A(\d{4,})-(\d{2})-(\d{2})\z/.match(text.to_s)
         return ::Float::NAN unless match
 
         year, month, day = match[1].to_i, match[2].to_i, match[3].to_i
-        return ::Float::NAN if year < 1 || !::Date.valid_date?(year, month, day)
+        return ::Float::NAN if year < 1 || !::Date.valid_date?(year, month, day, ::Date::GREGORIAN)
 
         ::Time.utc(year, month, day).to_i * 1000.0
       end
@@ -127,13 +173,15 @@ module Dommy
 
     end
 
+    # A time is the time of day; as a Date it falls on 1970-01-01 UTC.
     class TimeInputType < InputType
 
       def scale_factor = 1000
+      def date? = true
       def default_step = 60.0
 
       def to_number(text)
-        match = /\A(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?\z/.match(text.to_s.strip)
+        match = /\A(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?\z/.match(text.to_s)
         return ::Float::NAN unless match
 
         hour, minute, second = match[1].to_i, match[2].to_i, match[3].to_i
@@ -171,12 +219,12 @@ module Dommy
         # The date/time separator may be "T" or a space (the "parse a local date
         # and time string" algorithm accepts both).
         match = /\A(\d{4,})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?\z/
-          .match(text.to_s.strip)
+          .match(text.to_s)
         return ::Float::NAN unless match
 
         year, month, day = match[1].to_i, match[2].to_i, match[3].to_i
         hour, minute, second = match[4].to_i, match[5].to_i, match[6].to_i
-        return ::Float::NAN if year < 1 || !::Date.valid_date?(year, month, day)
+        return ::Float::NAN if year < 1 || !::Date.valid_date?(year, month, day, ::Date::GREGORIAN)
         return ::Float::NAN if hour > 23 || minute > 59 || second > 59
 
         fraction = match[7] ? match[7].ljust(3, "0").to_i : 0
@@ -184,10 +232,10 @@ module Dommy
       end
 
       def from_number(number)
-        return "" if number.nan?
+        return "" unless number.finite? && number.abs <= Bridge::Date::MAX_TIME_VALUE
 
         time = utc_time_from_ms(number)
-        return "" if time.year < 1 || time.year > 9999
+        return "" if time.year < 1
 
         base = format("%04d-%02d-%02dT%02d:%02d", time.year, time.month, time.day, time.hour, time.min)
         fraction = (number % 1000).to_i
@@ -196,7 +244,7 @@ module Dommy
         elsif fraction.zero?
           base + format(":%02d", time.sec)
         else
-          base + format(":%02d.%03d", time.sec, fraction)
+          base + format(":%02d.%03d", time.sec, fraction).sub(/0+\z/, "")
         end
       rescue ::RangeError, ::ArgumentError, ::FloatDomainError
         ""
@@ -208,8 +256,10 @@ module Dommy
     # its scale is 1.
     class MonthInputType < InputType
 
+      def date? = true
+
       def to_number(text)
-        match = /\A(\d{4,})-(\d{2})\z/.match(text.to_s.strip)
+        match = /\A(\d{4,})-(\d{2})\z/.match(text.to_s)
         return ::Float::NAN unless match
 
         year, month = match[1].to_i, match[2].to_i
@@ -226,11 +276,31 @@ module Dommy
         format("%04d-%02d", year, (months % 12) + 1)
       end
 
+      # As a Date, a month is the UTC midnight that starts it.
+      def to_date_value(text)
+        months = to_number(text)
+        return months if months.nan?
+
+        months = months.to_i
+        ::Time.utc(1970 + months.fdiv(12).floor, (months % 12) + 1).to_i * 1000.0
+      end
+
+      def from_date_value(time_value)
+        return "" unless time_value.finite?
+
+        time = utc_time_from_ms(time_value)
+        format("%04d-%02d", time.year, time.month)
+      rescue ::RangeError, ::ArgumentError, ::FloatDomainError
+        ""
+      end
+
     end
 
+    # As a Date, a week is the UTC midnight of its Monday.
     class WeekInputType < InputType
 
       def scale_factor = 604_800_000
+      def date? = true
 
       # The epoch falls mid-week, so a week control aligns to the Monday of
       # 1970-W01; measuring from 0 would report every whole week as a step
@@ -238,14 +308,14 @@ module Dommy
       def step_base = to_number("1970-W01")
 
       def to_number(text)
-        match = /\A(\d{4,})-W(\d{2})\z/.match(text.to_s.strip)
+        match = /\A(\d{4,})-W(\d{2})\z/.match(text.to_s)
         return ::Float::NAN unless match
 
         year, week = match[1].to_i, match[2].to_i
         return ::Float::NAN if year < 1 || week < 1
 
         # Date.commercial raises for a week beyond the ISO year's 52/53 weeks.
-        date = ::Date.commercial(year, week, 1)
+        date = ::Date.commercial(year, week, 1, ::Date::GREGORIAN)
         ::Time.utc(date.year, date.month, date.day).to_i * 1000.0
       rescue ::ArgumentError
         ::Float::NAN

data/lib/dommy/internal/insertion_point.rb

@@ -13,6 +13,30 @@ module Dommy
     module InsertionPoint
       module_function
 
+      # WHATWG "convert nodes into a node" in `document`, for the variadic
+      # methods (ChildNode's, ParentNode's and the Document's own): two or
+      # more arguments are appended, in order, to a new DocumentFragment —
+      # strings as new Text nodes — and the fragment stands for them. That
+      # append moves each node out of wherever it was and checks it as any
+      # append does, so it can fail half way (a doctype or a Document among
+      # the arguments): the nodes appended by then stay in the fragment, out of
+      # the tree, as the spec has it. One argument is left as it is: a string
+      # becomes a Text node where it is inserted, and a node moves only then.
+      #
+      # Spec: https://dom.spec.whatwg.org/#converting-nodes-into-a-node
+      def convert_nodes_into_a_node(document, args)
+        return args if args.size < 2
+
+        fragment = document.create_document_fragment
+        args.each do |arg|
+          case arg
+          when Dommy::Node then fragment.append_child(arg)
+          when String then fragment.append_child(document.create_text_node(arg))
+          end
+        end
+        [fragment]
+      end
+
       # Insert step 1's count: how many nodes `args` will contribute once
       # converted. A DocumentFragment expands to its children, a String becomes
       # one Text node, and anything without a backing node contributes nothing.
@@ -21,9 +45,9 @@ module Dommy
       def count(args)
         args.sum do |arg|
           case arg
-          when Fragment then arg.__dommy_backend_node__.children.to_a.size
+          when Fragment then arg.__dommy_backend_node__.child_count
           when String then 1
-          else arg.respond_to?(:__dommy_backend_node__) ? 1 : 0
+          else arg.is_a?(Node) && arg.__dommy_backend_node__ ? 1 : 0
           end
         end
       end
@@ -32,7 +56,7 @@ module Dommy
       # or the parent's last child when appending. Measured before anything
       # moves. Returns the backend node; the caller wraps it.
       def previous_sibling(parent, ref)
-        ref ? ref.previous_sibling : parent.children.to_a.last
+        ref ? ref.previous_sibling : parent.last_child
       end
 
       # Advance `ref` past any node that is itself being inserted: it is about

data/lib/dommy/internal/js_number.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # ECMAScript's Number::toString(x) with radix 10 — what JS's `String(x)`
+    # gives, and what HTML calls "the best representation of the number as a
+    # floating-point number" (the string a double reflection, a meter or a
+    # number input writes). Ruby's Float#to_s picks the same shortest
+    # round-trip digits but lays them out differently ("1.0e-10", "5.0",
+    # "1.0e+16"), so this re-lays them out by the ECMAScript rules:
+    #
+    #   to_string(5.0)    # => "5"
+    #   to_string(-0.0)   # => "0"
+    #   to_string(1e21)   # => "1e+21"
+    #   to_string(1e-7)   # => "1e-7"
+    #   to_string(1.5e-6) # => "0.0000015"
+    #   to_string(1e25)   # => "1e+25"
+    #
+    # Spec: https://tc39.es/ecma262/#sec-numeric-types-number-tostring
+    module JsNumber
+      module_function
+
+      def to_string(number)
+        x = Float(number)
+        return "NaN" if x.nan?
+        return x.positive? ? "Infinity" : "-Infinity" if x.infinite?
+        return "0" if x.zero? # +0 and -0 alike
+        return "-#{to_string(-x)}" if x.negative?
+
+        digits, n = shortest_digits(x)
+        k = digits.length
+        if k <= n && n <= 21
+          digits + ("0" * (n - k))
+        elsif n.positive? && n <= 21
+          "#{digits[0, n]}.#{digits[n..]}"
+        elsif n > -6 && n <= 0
+          "0.#{"0" * -n}#{digits}"
+        else
+          exponent = n - 1
+          sign = exponent.negative? ? "-" : "+"
+          mantissa = k == 1 ? digits : "#{digits[0]}.#{digits[1..]}"
+          "#{mantissa}e#{sign}#{exponent.abs}"
+        end
+      end
+
+      # [s, n] for a finite positive x: the shortest digit string s (no leading
+      # or trailing zeros) with x = 0.s × 10^n — ECMAScript's k digits and n.
+      # Float#to_s already chose the digits; this only reads them back out.
+      def shortest_digits(x)
+        mantissa, exponent = x.to_s.split("e")
+        int_part, frac_part = mantissa.split(".")
+        all = int_part + frac_part.to_s
+        point = int_part.length + exponent.to_i
+        stripped = all.sub(/\A0+/, "")
+        point -= all.length - stripped.length
+        [stripped.sub(/0+\z/, ""), point]
+      end
+    end
+  end
+end

data/lib/dommy/internal/light_dismiss.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # HTML's light dismiss: "run light dismiss activities" for a trusted
+    # pointerdown or pointerup — "light dismiss open popovers" (§6.12) and
+    # "light dismiss open dialogs" (the dialog element). Pointer Events calls
+    # it as the user presses and releases the pointer, before the pointer
+    # event is dispatched; Dommy's Interaction layer does the same for its
+    # clicks.
+    #
+    # A press records the topmost popover (and the nearest open dialog) the
+    # pointer went down in; the release, when it lands in the same one,
+    # closes the auto and hint popovers above it, and requests to close the
+    # topmost `closedby=any` dialog when that is not the dialog clicked.
+    module LightDismiss
+      module_function
+
+      # Run light dismiss activities for `event` (a trusted PointerEvent of
+      # type pointerdown or pointerup) aimed at `target`. `backdrop` says the
+      # pointer hit a modal dialog's ::backdrop rather than its box — the
+      # coordinates were outside the dialog.
+      def run(event, target, backdrop: false)
+        return unless event.__js_get__("isTrusted") == true
+        return unless target.is_a?(Node)
+
+        light_dismiss_open_popovers(event.type, target)
+        light_dismiss_open_dialogs(event.type, target, backdrop)
+        nil
+      end
+
+      # HTML "light dismiss open popovers".
+      def light_dismiss_open_popovers(type, target)
+        document = target.owner_document
+        stack = document.__internal_popover_stack__
+        return if stack.topmost_auto_or_hint.nil?
+
+        case type
+        when "pointerdown"
+          document.__internal_popover_pointerdown_target__ = topmost_clicked_popover(target)
+        when "pointerup"
+          ancestor = topmost_clicked_popover(target)
+          same_target = ancestor.equal?(document.__internal_popover_pointerdown_target__)
+          document.__internal_popover_pointerdown_target__ = nil
+          return unless same_target
+
+          stack.hide_popovers_until(ancestor, false, true)
+        end
+      end
+
+      # HTML "light dismiss open dialogs".
+      def light_dismiss_open_dialogs(type, target, backdrop)
+        document = target.owner_document
+        open_dialogs = document.__internal_open_dialogs__
+        return if open_dialogs.empty?
+
+        ancestor = nearest_clicked_dialog(target, backdrop)
+        case type
+        when "pointerdown"
+          document.__internal_dialog_pointerdown_target__ = ancestor
+        when "pointerup"
+          same_target = ancestor.equal?(document.__internal_dialog_pointerdown_target__)
+          document.__internal_dialog_pointerdown_target__ = nil
+          return unless same_target
+
+          topmost = open_dialogs.last
+          return if ancestor.equal?(topmost)
+          return unless topmost.closed_by == "any"
+
+          topmost.__internal_request_close_watcher__(false)
+        end
+      end
+
+      # HTML "nearest clicked dialog": nil for a hit on an open modal
+      # dialog's backdrop, else the nearest open dialog among the target's
+      # flat-tree inclusive ancestors.
+      def nearest_clicked_dialog(target, backdrop)
+        return nil if backdrop && open_dialog?(target) && target.__internal_modal__?
+
+        node = target
+        until node.nil?
+          return node if open_dialog?(node)
+
+          node = flat_tree_parent(node)
+        end
+        nil
+      end
+
+      # HTML "topmost clicked popover".
+      def topmost_clicked_popover(node)
+        clicked = nearest_inclusive_open_popover(node)
+        target = nearest_inclusive_target_popover(node)
+        stack_position(clicked) > stack_position(target) ? clicked : target
+      end
+
+      # HTML "nearest inclusive open popover".
+      def nearest_inclusive_open_popover(node)
+        current = node
+        until current.nil?
+          if current.respond_to?(:__internal_popover_opened_mode__) && current.__internal_popover_opened_mode__ &&
+              current.__internal_popover_showing__?
+            return current
+          end
+
+          current = flat_tree_parent(current)
+        end
+        nil
+      end
+
+      # HTML "nearest inclusive target popover".
+      def nearest_inclusive_target_popover(node)
+        current = node
+        until current.nil?
+          popover = target_popover(current)
+          if popover && %w[auto hint].include?(popover.popover) && popover.__internal_popover_showing__?
+            return popover
+          end
+
+          current = flat_tree_parent(current)
+        end
+        nil
+      end
+
+      # HTML "get the target popover": what a button's commandfor names, when
+      # its command is a popover one, else its popover target element.
+      def target_popover(node)
+        return nil unless node.is_a?(HTMLElement)
+
+        popover_target = node.respond_to?(:__internal_popover_target_element__) ? node.__internal_popover_target_element__ : nil
+        return popover_target unless node.is_a?(HTMLButtonElement)
+        return nil if node.__internal_actually_disabled__
+
+        target = node.command_for_element
+        return popover_target if target.nil?
+
+        if node.form
+          return nil if node.__internal_submit_button_state__?
+          return nil if %w[reset auto].include?(node.type_state)
+        end
+        return nil unless HTMLButtonElement::POPOVER_COMMANDS.include?(node.command)
+        return nil unless target.is_a?(HTMLElement) && !target.popover.nil?
+
+        target
+      end
+
+      # HTML "get the popover stack position".
+      def stack_position(popover)
+        return 0 if popover.nil?
+
+        stack = popover.owner_document.__internal_popover_stack__
+        hint = stack.list("hint")
+        auto = stack.list("auto")
+        if (index = hint.index { |p| p.equal?(popover) })
+          return index + auto.size + 1
+        end
+        if (index = auto.index { |p| p.equal?(popover) })
+          return index + 1
+        end
+
+        0
+      end
+
+      def open_dialog?(node)
+        node.is_a?(HTMLDialogElement) && node.__internal_has_attribute__?("open")
+      end
+
+      # A node's parent in the flat tree, up to the document element.
+      def flat_tree_parent(node)
+        parent = Focusability.flat_tree_parent(node)
+        parent.is_a?(Element) ? parent : nil
+      end
+
+      private_class_method :light_dismiss_open_popovers, :light_dismiss_open_dialogs, :nearest_clicked_dialog,
+        :topmost_clicked_popover, :nearest_inclusive_open_popover, :nearest_inclusive_target_popover,
+        :target_popover, :stack_position, :open_dialog?, :flat_tree_parent
+    end
+  end
+end

data/lib/dommy/internal/literal_lookup.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "infra"
+
+module Dommy
+  module Internal
+    # getElementById, getElementsByClassName and getElementsByName: each
+    # compares an attribute with a string, and none of them takes a CSS
+    # selector. A value that would be special in one — a digit first, `.`, `:`,
+    # a quote, a backslash, a newline, NUL — must still be found and never
+    # raise, so these read the backend tree rather than compose a selector
+    # string from their argument (getElementById uses the backend's id
+    # selector as an index, and checks what it answers).
+    module LiteralLookup
+      module_function
+
+      # The first backend element under `bnode` whose `id` is `id`, in tree
+      # order. An id with selector-special characters (e.g. React's `useId`
+      # values like `:rjm:`) is escaped into a valid id-selector ident for the
+      # backend's engine (#selector_ident). In a quirks-mode document that
+      # engine matches an id selector ASCII case-insensitively, as CSS asks,
+      # while getElementById still compares case-sensitively: its answer is
+      # kept only when the id is exactly `id`, and otherwise the exact one is
+      # looked for among the rest it matches. No escape spells U+0000 (it
+      # reads as U+FFFD), so an id holding it is found by comparing the
+      # attribute itself. An element's id, like its classes and its name, is
+      # the attribute of that name in no namespace (#attribute).
+      def element_by_id(bnode, id)
+        return bnode.css("[id]").find { |n| attribute(n, "id") == id } if id.include?("\u0000")
+
+        selector = "##{selector_ident(id)}"
+        first = bnode.at_css(selector)
+        return first if first.nil? || attribute(first, "id") == id
+
+        bnode.css(selector).find { |n| attribute(n, "id") == id }
+      end
+
+      # The class tokens getElementsByClassName looks for in `names`.
+      def class_tokens(names) = Infra.split_on_ascii_whitespace(names)
+
+      # The backend elements under `root`, a node of `document`, whose class
+      # list contains every one of `tokens`, compared directly: a token may
+      # hold anything but ASCII whitespace (`1`, `a.b`, `a:b`, `[x]`, a quote,
+      # NUL). In a quirks-mode document they compare ASCII case-insensitively.
+      # The backend's own class selector narrows the candidates first (see
+      # #class_candidates).
+      def elements_with_classes(document, root, tokens)
+        quirks = document.quirks_mode?
+        wanted = quirks ? tokens.map { |t| t.downcase(:ascii) } : tokens
+        class_candidates(document, root, tokens).select do |n|
+          classes = Infra.split_on_ascii_whitespace(attribute(n, "class"))
+          classes = classes.map { |c| c.downcase(:ascii) } if quirks
+          wanted.all? { |t| classes.include?(t) }
+        end
+      end
+
+      # A superset of the elements with every one of `tokens`: what the
+      # backend's class selector, the tokens escaped by #selector_ident,
+      # matches — natively, where the comparison above runs in Ruby. That
+      # selector compares exactly where the backend parsed a document in
+      # no-quirks mode and ASCII case-insensitively where it parsed one in
+      # quirks mode; Dommy takes the document's mode from that parse, so the
+      # selector is never stricter than the comparison above — but a superset
+      # must not rest on that, so a quirks-mode `document` over a backend that
+      # does not fold scans instead. It cannot spell U+0000 (an escape of it
+      # reads as U+FFFD); then too every element with a class is a candidate.
+      def class_candidates(document, root, tokens)
+        backend_folds = !document.quirks_mode? || Backend.quirks_mode?(document.backend_doc)
+        return root.css("[class]") if !backend_folds || tokens.any? { |t| t.include?("\u0000") }
+
+        root.css(tokens.map { |t| ".#{selector_ident(t)}" }.join)
+      end
+
+      # `value` as an ident a selector can carry whatever it holds: every code
+      # point but an ASCII letter, an underscore, and (after the first) a
+      # digit or U+002D written as a hex escape. CSS.escape is not enough —
+      # it leaves a non-ASCII code point as it is, and css-syntax-3 counts
+      # only some of them as ident code points (§4.2), so a class or an id of
+      # U+00A0 or U+3000 would make an invalid selector.
+      def selector_ident(value)
+        value.each_char.with_index.map do |c, i|
+          plain = i.zero? ? c.match?(/[A-Za-z_]/) : c.match?(/[A-Za-z0-9_-]/)
+          plain ? c : "\\#{c.ord.to_s(16)} "
+        end.join
+      end
+
+      # The HTML elements under `bnode` whose `name` is `name`. Only elements
+      # in the HTML namespace count: an SVG or MathML element with a `name`
+      # attribute is not one getElementsByName finds.
+      #
+      # Spec: https://html.spec.whatwg.org/multipage/dom.html#dom-document-getelementsbyname
+      def elements_named(bnode, name)
+        bnode.css("[name]").select { |n| Backend.namespace_uri(n) == Namespaces::HTML && attribute(n, "name") == name }
+      end
+
+      # The value of `node`'s attribute `name` in no namespace: an `id`,
+      # `class` or `name` set with setAttributeNS("urn:x", …) is none of them.
+      def attribute(node, name) = Backend.no_namespace_attribute_value(node, name)
+
+      private_class_method :class_candidates, :selector_ident, :attribute
+    end
+  end
+end

data/lib/dommy/internal/mime_type.rb

@@ -19,6 +19,14 @@ module Dommy
 
       module_function
 
+      # Whether the essence names an XML MIME type: text/xml, application/xml,
+      # or any subtype ending in "+xml" (image/svg+xml, application/xhtml+xml).
+      # https://mimesniff.spec.whatwg.org/#xml-mime-type
+      def xml?(essence)
+        essence = essence.to_s
+        essence == "text/xml" || essence == "application/xml" || essence.end_with?("+xml")
+      end
+
       # The value of `name` among the MIME type's parameters, or nil. The name
       # is ASCII case-insensitive; a quoted value comes back unquoted.
       def parameter(mime_type, name)