dommy 0.11.0 → 0.12.0

data/lib/dommy/element.rb

@@ -21,6 +21,19 @@ module Dommy
 
     # Public Ruby API (DocumentFragment surface)
 
+    # Node.cloneNode: a fresh, empty fragment, and — when `deep` — a clone of
+    # each child appended in tree order ("clone a node" step 5). Cloning the
+    # children one by one rather than re-parsing the fragment's serialization
+    # keeps each of them its own interface: a comment stays a comment, and a
+    # processing instruction does not come back as one.
+    def clone_node(deep = false)
+      copy = @document.create_document_fragment
+      return copy unless deep
+
+      child_nodes.each { |child| copy.append_child(child.clone_node(true)) }
+      copy
+    end
+
     def children
       element_children
     end
@@ -152,9 +165,7 @@ module Dommy
       when "isDefaultNamespace"
         is_default_namespace(args[0])
       when "cloneNode"
-        deep = args.empty? ? false : !!args[0]
-        deep ? @document.wrap_node(Parser.fragment(@__node__.to_html, owner_doc: @document.backend_doc)) : @document
-          .wrap_node(Parser.fragment("", owner_doc: @document.backend_doc))
+        clone_node(args.first)
       when "querySelector"
         query_selector(Internal.css_query_arg!(args))
       when "querySelectorAll"
@@ -227,7 +238,7 @@ module Dommy
     end
 
     def insert_before(node, ref)
-      coerce_node_argument!(node)
+      Internal::WebIDL.node!(node)
       ensure_pre_insertion_validity!(node, ref)
       ref_bn = ref.respond_to?(:__dommy_backend_node__) ? ref.__dommy_backend_node__ : nil
       ref_bn = nil unless ref_bn && ref_bn.parent == @__node__
@@ -250,7 +261,7 @@ module Dommy
     end
 
     def replace_child(new_child, old_child)
-      coerce_node_argument!(new_child)
+      Internal::WebIDL.node!(new_child)
       # WHATWG "replace" step 1 runs the full ensure-pre-insertion-validity,
       # whose step 2 (node is an inclusive ancestor of parent — a cycle) comes
       # BEFORE step 3 (the reference child's parentage). So
@@ -726,12 +737,20 @@ module Dommy
       super
     end
 
+    # Node.cloneNode. CharacterData has no children, so `deep` decides nothing:
+    # the copy is a new node of the SAME interface carrying the same data, owned
+    # by this node's document. Each subclass builds its own kind — a CDATASection
+    # that cloned to a Text would be the wrong node.
+    def clone_node(_deep = false)
+      @document.create_text_node(@__node__.text)
+    end
+
     # Own __js_call__ methods, on top of CharacterDataNode's.
     js_methods %w[cloneNode]
     def __js_call__(method, args)
       case method
       when "cloneNode"
-        @document.create_text_node(@__node__.text)
+        clone_node(args.first)
       else
         super
       end
@@ -744,6 +763,10 @@ module Dommy
     def node_type
       4
     end
+
+    def clone_node(_deep = false)
+      @document.create_cdata_section(@__node__.content)
+    end
   end
 
   class CommentNode < CharacterDataNode
@@ -751,12 +774,16 @@ module Dommy
       8
     end
 
+    def clone_node(_deep = false)
+      @document.create_comment(@__node__.content)
+    end
+
     # Own __js_call__ methods, on top of CharacterDataNode's.
     js_methods %w[cloneNode]
     def __js_call__(method, args)
       case method
       when "cloneNode"
-        @document.create_comment(@__node__.content)
+        clone_node(args.first)
       else
         super
       end
@@ -791,12 +818,16 @@ module Dommy
       end
     end
 
+    def clone_node(_deep = false)
+      @document.create_processing_instruction(@__node__.target, @__node__.content)
+    end
+
     # Own __js_call__ methods, on top of CharacterDataNode's.
     js_methods %w[cloneNode]
     def __js_call__(method, args)
       case method
       when "cloneNode"
-        @document.create_processing_instruction(@__node__.target, @__node__.content)
+        clone_node(args.first)
       else
         super
       end
@@ -1688,7 +1719,7 @@ module Dommy
     # inside a shadow tree, returns that ShadowRoot. Otherwise walks
     # until we hit the Nokogiri Document (then returns the Document).
     def root_node(options = nil)
-      composed = options.is_a?(Hash) && EventTarget.js_truthy?(options.key?("composed") ? options["composed"] : options[:composed])
+      composed = Node.composed_option?(options)
       sr = @document.__internal_shadow_root_containing__(@__node__)
       if sr
         # Default: the shadow root is the root. `composed: true` is
@@ -1786,8 +1817,24 @@ module Dommy
       attributes.set_named_item(attr)
     end
 
+    # setAttributeNodeNS is defined as the very same steps as setAttributeNode
+    # ("set an attribute"): the namespace is the Attr's own, so there is nothing
+    # left for the NS form to do differently. The JS bridge already routed it
+    # here; this is the Ruby caller's way in.
+    def set_attribute_node_ns(attr)
+      set_attribute_node(attr)
+    end
+
+    # removeAttributeNode step 1: "If this's attribute list does not contain
+    # attr, throw a NotFoundError." What counts is the Attr itself, not its
+    # name — one that belongs to another element, or to none, is not in this
+    # list even when this element has an attribute of the same name.
     def remove_attribute_node(attr)
-      return nil unless attr.respond_to?(:name)
+      owner = attr.owner_element if attr.respond_to?(:owner_element)
+      unless owner.equal?(self)
+        raise DOMException::NotFoundError,
+          "the attribute #{attr.respond_to?(:name) ? attr.name.inspect : attr.inspect} is not this element's"
+      end
 
       attributes.remove_named_item(attr.name)
     end
@@ -1982,7 +2029,7 @@ module Dommy
         raise DOMException::NotSupportedError, "<#{tag}> cannot host a shadow root"
       end
 
-      raise DOMException::NotSupportedError, "Shadow root already attached" if @__shadow_root
+      raise DOMException::NotSupportedError, "Shadow root already attached" if __internal_shadow_root__
 
       opts = options.is_a?(Hash) ? options : {}
       mode_raw = opts.key?("mode") ? opts["mode"] : opts[:mode]
@@ -2007,16 +2054,18 @@ module Dommy
     # `el.shadowRoot` — returns the attached ShadowRoot only when
     # mode is "open"; closed shadows are hidden from external code.
     def shadow_root
-      return nil unless @__shadow_root
-      return nil if @__shadow_root.mode == "closed"
+      root = __internal_shadow_root__
+      return nil if root.nil? || root.mode == "closed"
 
-      @__shadow_root
+      root
     end
 
     # Internal — gives access to the shadow root regardless of mode.
-    # Used by event composition / `composedPath()`.
+    # Used by event composition / `composedPath()`. The document's registry
+    # answers for a wrapper that is not the one attachShadow ran on: a custom
+    # element upgrade replaces the host's wrapper, not its shadow root.
     def __internal_shadow_root__
-      @__shadow_root
+      @__shadow_root ||= @document.__internal_shadow_root_for_host__(@__node__)
     end
 
     # `el.insertAdjacentElement(position, element)` — DOM spec positions:
@@ -3261,7 +3310,7 @@ module Dommy
     end
 
     def insert_before(child, reference)
-      coerce_node_argument!(child)
+      Internal::WebIDL.node!(child)
       # WHATWG pre-insert validates the reference the CALLER gave (step 1), and
       # only then, in step 3, replaces it with the node's next sibling when it is
       # the node being inserted — so "insert x before x" doesn't move x. Doing
@@ -3299,7 +3348,7 @@ module Dommy
     end
 
     def remove_child(child)
-      coerce_node_argument!(child)
+      Internal::WebIDL.node!(child)
       node = unwrap_dom_node(child)
       unless node&.parent == @__node__
         raise DOMException::NotFoundError, "node is not a child of this element"
@@ -3315,8 +3364,8 @@ module Dommy
     # MutationObserver of both changes in one record so observers
     # see the swap atomically.
     def replace_child(new_child, old_child)
-      coerce_node_argument!(new_child)
-      coerce_node_argument!(old_child)
+      Internal::WebIDL.node!(new_child)
+      Internal::WebIDL.node!(old_child)
       # replaceChild shares the pre-insertion checks (ancestor, node type,
       # doctype placement); the reference child here is old_child, so step 3
       # also enforces that it is actually a child (NotFoundError otherwise).

data/lib/dommy/event.rb

@@ -377,8 +377,11 @@ module Dommy
       node.is_a?(ShadowRoot) && node.mode == "closed"
     end
 
+    # Every node answers getRootNode — a CharacterData node and a Document as
+    # much as an Element, whose override also finds its shadow root. A Window
+    # has no root.
     def root_of(node)
-      node.respond_to?(:root_node) ? node.root_node : nil
+      node.respond_to?(:get_root_node) ? node.get_root_node : nil
     end
 
     # `phase` is :capture (capture listeners), :bubble (non-capture), or :both
@@ -1373,7 +1376,7 @@ module Dommy
   # `InputEvent` — fired by `input` / `beforeinput`. Carries `data`
   # (the inserted text, if any) and `inputType` (insertText,
   # deleteContentBackward, etc.).
-  class InputEvent < Event
+  class InputEvent < UIEvent
     def initialize(type, init = nil)
       super
       @data = read_init(init, "data")
@@ -1581,7 +1584,7 @@ module Dommy
   # touchcancel. Carries three TouchLists plus modifier keys.
   #
   # Spec: https://w3c.github.io/touch-events/#touchevent-interface
-  class TouchEvent < Event
+  class TouchEvent < UIEvent
     def initialize(type, init = nil)
       super
       @touches = TouchList.new(Array(read_init(init, "touches") || []))

data/lib/dommy/internal/child_node.rb

@@ -137,11 +137,7 @@ module Dommy
       def validate_insert_before_ref!(args)
         raise Bridge::TypeError, "insertBefore requires 2 arguments." if args.length < 2
 
-        ref = args[1]
-        return if ref.nil? || (defined?(Bridge::UNDEFINED) && ref.equal?(Bridge::UNDEFINED))
-        return if ref.is_a?(Dommy::Node)
-
-        raise Bridge::TypeError, "The reference child is not a Node."
+        WebIDL.nullable_node!(args[1])
       end
 
       private

data/lib/dommy/internal/leaf_node.rb

@@ -26,23 +26,17 @@ module Dommy
       end
 
       def remove_child(node)
-        coerce_leaf_node_argument!(node)
+        WebIDL.node!(node)
         raise DOMException::NotFoundError, "the node to be removed is not a child of this node"
       end
 
       private
 
       def reject_leaf_insertion!(node)
-        coerce_leaf_node_argument!(node)
+        WebIDL.node!(node)
         raise DOMException::HierarchyRequestError, leaf_insertion_message
       end
 
-      # WebIDL coerces the Node argument first: a null / non-Node value is a
-      # TypeError before any DOM step runs.
-      def coerce_leaf_node_argument!(value)
-        raise Bridge::TypeError, "Argument is not a Node." unless value.is_a?(Dommy::Node)
-      end
-
       def leaf_insertion_message
         "this node type does not support children"
       end

data/lib/dommy/internal/mutation_coordinator.rb

@@ -37,20 +37,24 @@ module Dommy
         nil
       end
 
-      # Walk a subtree and fire connected/disconnected callbacks for all elements
+      # Connected callbacks, connected scripts and blank-iframe loads for every
+      # element among the subtree's shadow-including inclusive descendants, in
+      # shadow-including tree order — so the custom elements in an inserted
+      # host's shadow tree connect too.
       def notify_connected_subtree(nk)
-        return unless nk.respond_to?(:element?)
-
-        if nk.element?
-          wrapped = @document.wrap_node(nk)
-          if wrapped
-            notify_connected(wrapped)
-            run_connected_script(wrapped)
-            fire_blank_iframe_load(wrapped)
-          end
+        each_shadow_including_element(nk) do |element|
+          notify_connected(element)
+          run_connected_script(element)
+          fire_blank_iframe_load(element)
         end
+      end
 
-        nk.children.each { |c| notify_connected_subtree(c) } if nk.respond_to?(:children)
+      # The wrapped elements of the document's shadow-including walk.
+      def each_shadow_including_element(nk)
+        @document.__internal_each_shadow_including_element__(nk) do |element_node|
+          wrapped = @document.wrap_node(element_node)
+          yield wrapped if wrapped
+        end
       end
 
       # A srcless ("blank"/about:blank) `<iframe>` connected to the document gets
@@ -133,15 +137,32 @@ module Dommy
         scheduler ? scheduler.queue_microtask(run) : run.call
       end
 
-      def notify_disconnected_subtree(nk)
-        return unless nk.respond_to?(:element?)
+      # WHATWG "move": each custom element among the moved node's
+      # shadow-including inclusive descendants, in shadow-including tree order,
+      # gets connectedMoveCallback. The caller checks that the new parent is
+      # connected.
+      def notify_moved_subtree(nk)
+        each_shadow_including_element(nk) { |element| notify_moved(element) }
+      end
 
-        if nk.element?
-          wrapped = @document.wrap_node(nk)
-          notify_disconnected(wrapped) if wrapped
+      # HTML "enqueue a custom element callback reaction": a definition without
+      # connectedMoveCallback runs disconnectedCallback and then connectedCallback
+      # in its place. (A JS-defined element always answers the Ruby method; the
+      # bridge falls back on the JS side.)
+      def notify_moved(element)
+        if element.respond_to?(:connected_move_callback)
+          element.connected_move_callback
+        else
+          notify_disconnected(element)
+          notify_connected(element)
         end
+      rescue StandardError
+        nil
+      end
 
-        nk.children.each { |c| notify_disconnected_subtree(c) } if nk.respond_to?(:children)
+      # Disconnected callbacks, over the same shadow-including walk.
+      def notify_disconnected_subtree(nk)
+        each_shadow_including_element(nk) { |element| notify_disconnected(element) }
       end
 
       def notify_attribute_changed(element, name, old_value, new_value, namespace = nil)
@@ -251,12 +272,18 @@ module Dommy
       end
 
       # Fire MutationObserver childList records
+      # `moving:` marks the records of a move (moveBefore). A move runs neither
+      # the insertion nor the removing steps, so the connected / disconnected
+      # walk below — lifecycle callbacks, script execution, blank-iframe load —
+      # is skipped for it; its custom element reactions are the move's own
+      # (notify_moved_subtree).
       def notify_child_list_mutation(
         target_node:,
         added_nodes:,
         removed_nodes:,
         previous_sibling: nil,
-        next_sibling: nil
+        next_sibling: nil,
+        moving: false
       )
         @document.__internal_note_tree_mutation__
         target = @document.wrap_node(target_node)
@@ -269,7 +296,7 @@ module Dommy
         # connectedCallback fires only when connected). So skip the O(subtree)
         # walk for mutations within a still-detached tree — the common case
         # during bulk DOM construction, where nothing in the walk can fire.
-        if !target.respond_to?(:is_connected?) || target.is_connected?
+        if !moving && (!target.respond_to?(:is_connected?) || target.is_connected?)
           added_nodes.each { |nk| notify_connected_subtree(nk) }
           removed_nodes.each { |nk| notify_disconnected_subtree(nk) }
         end

data/lib/dommy/internal/node_wrapper_cache.rb

@@ -278,8 +278,15 @@ module Dommy
         end
       end
 
-      # Clear cached wrapper (used by customElements.define for upgrades)
+      # Clear cached wrapper (used by customElements.define for upgrades).
+      # An upgrade replaces a node's wrapper without mutating the tree, so
+      # nothing bumps `dom_generation` and the query cache would keep handing
+      # out the wrapper this just retired — a `querySelector` after the upgrade
+      # would answer with the element's pre-upgrade self. Drop the memoized
+      # results too. Upgrades are rare (a handful per page), so clearing the
+      # whole cache costs less than tracking which selectors matched the node.
       def reset_wrapper(nokogiri_node)
+        @query_cache.clear
         @wrappers.delete(identity_key(nokogiri_node))
       end
 
@@ -420,6 +427,7 @@ module Dommy
         ruby_custom = custom_klass if custom_klass.is_a?(::Class)
         klass = ruby_custom || Dommy.element_class_for(local_name || node.name, ns)
         instance = klass.new(@document, node)
+        adjust_svg_tag_name(instance, node, ns) if local_name.nil?
 
         @wrappers[identity_key(node)] = instance
 
@@ -434,6 +442,20 @@ module Dommy
         instance
       end
 
+      # HTML's "adjust SVG tag name" (§13.2.6.5), the parser step that gives
+      # `<feMerge>` its camel case back after the tokenizer lower-cased it. The
+      # backend keeps the lower-case name, so — exactly as for the case
+      # createElementNS preserves — the adjusted name lives on the wrapper.
+      # Only names the parser produced are adjusted: createElementNS says what
+      # the local name is and passes it in, and an XML document is parsed
+      # verbatim to begin with.
+      def adjust_svg_tag_name(instance, node, namespace)
+        return unless namespace == Element::SVG_NAMESPACE && @document.html_document?
+
+        adjusted = Dommy::SVG_ADJUSTED_TAG_NAMES[node.name]
+        instance.__internal_set_namespace__(namespace, nil, adjusted, adjusted) if adjusted
+      end
+
       def custom_element_class_for(tag_name)
         # Custom elements are registered on window, not document.
         # Access via default_view if available.

data/lib/dommy/internal/parent_node.rb

@@ -19,7 +19,7 @@ module Dommy
       # `appendChild(child)` — detach the node(s) from any current parent
       # and append to the end of this node's child list.
       def append_child(child)
-        coerce_node_argument!(child)
+        WebIDL.node!(child)
         ensure_pre_insertion_validity!(child, nil)
         # An append has a null reference child, so insert step 5 shifts nothing;
         # convert_for_insert still routes through it so every insertion site
@@ -120,7 +120,8 @@ module Dommy
       # primitive underneath it.
       #
       # A move is NOT remove + insert. It runs neither the removing steps nor
-      # the insertion steps (so no disconnected/connected callbacks fire), it
+      # the insertion steps: a custom element gets connectedMoveCallback (or, with
+      # none defined, disconnectedCallback then connectedCallback) instead, it
       # never adopts — step 1 requires the same shadow-including root, so the
       # node document cannot change — and it carries its own validity checks
       # instead of "ensure pre-insertion validity". What it does share is the
@@ -129,7 +130,8 @@ module Dommy
       #
       # Spec: https://dom.spec.whatwg.org/#dom-parentnode-movebefore
       def move_before(node, child = nil)
-        coerce_node_argument!(node)
+        WebIDL.node!(node)
+        WebIDL.nullable_node!(child)
         bn = insertion_backend_node(node)
         ref_bn = insertion_backend_node(child)
         # moveBefore step 2: a reference child that IS the node moves out of the
@@ -149,7 +151,7 @@ module Dommy
         # Steps 10-11 and 14. detach_node runs the live range and NodeIterator
         # pre-remove steps and then unlinks, without queuing a record — the move
         # queues its own pair at the end (steps 23-24).
-        @document.detach_node(bn)
+        @document.detach_node(bn, moving: true)
 
         ref_bn = nil if ref_bn && ref_bn.parent != @__node__
         # Step 16 — measured after the removal, which step 14 has already done.
@@ -160,69 +162,16 @@ module Dommy
 
         # Steps 23-24: one record for the old parent, one for the new.
         notify_move_records(bn, old_parent, old_previous, old_next, new_previous, ref_bn)
+        # Step 19.3's custom element reactions, run as the call returns — only
+        # when the new parent is connected.
+        @document.__internal_notify_moved_subtree__(bn) if node.get_root_node({ "composed" => true }).is_a?(Dommy::Document)
         node
       end
 
-      # Node#normalize — merge each run of adjacent exclusive Text descendants
-      # into its first node (preserving that node's identity, so a JS reference
-      # to it survives) and drop empty Text nodes. Recurses the whole subtree,
-      # so it works for Element, DocumentFragment, and ShadowRoot alike.
-      #
-      # A run is merged one sibling at a time: append the sibling's data to the
-      # survivor (a characterData record), hand its live range boundaries over,
-      # remove it (a childList record), then the next. Read literally, the spec
-      # concatenates every sibling's data first (steps 3-4, one "replace data")
-      # and removes them afterwards (step 7), which would queue ONE
-      # characterData record per run. Every shipping engine merges pairwise
-      # instead — Blink, WebCore and Gecko all answer [characterData, childList,
-      # characterData, childList, …] for a run of four text nodes, confirmed by
-      # running the same script in Chromium 141, WebKitGTK 2.52.6 and Firefox —
-      # and the WPT suite fixes only the childList side, so the records follow
-      # the engines. The tree and every live range boundary end up exactly where
-      # the spec's steps put them: a boundary in a later sibling (or on the
-      # parent, pointing at one) is shifted down by each earlier removal and
-      # then handed over at the survivor's length of that moment, which is the
-      # same offset the batch steps compute up front.
-      # https://github.com/takahashim/dommy/issues/24
+      # Node.normalize(). The algorithm lives on the Document, which is a
+      # receiver too.
       def normalize
-        text_nodes = []
-        @__node__.traverse { |node| text_nodes << node if node.respond_to?(:text?) && node.text? }
-
-        text_nodes.each do |node|
-          next unless node.parent # already removed as part of an earlier run
-
-          if node.content.to_s.empty?
-            @document.remove_node_with_notify(node)
-            next
-          end
-
-          sib = node.next
-          while sib.respond_to?(:text?) && sib.text?
-            following = sib.next
-            data = sib.content.to_s
-            # The offset the sibling's data lands at inside the survivor — the
-            # length of what it already holds, measured before the append.
-            length = @document.wrap_node(node).length
-            # An empty sibling has nothing to append: the engines skip the data
-            # step for it (Gecko checks the length, Blink and WebCore behave the
-            # same), so it is removed without a characterData record. Its range
-            # boundaries still move to the survivor's join.
-            unless data.empty?
-              old = node.content.to_s
-              node.content = old + data
-              @document.notify_character_data_mutation(target_node: node, old_value: old)
-            end
-            # WHATWG normalize() step 6: the merged-away sibling hands its live
-            # range boundaries to the survivor at that offset BEFORE it is
-            # removed, or the plain removing steps would strand them on the
-            # parent.
-            @document.__internal_ranges_normalize_merge__(node, sib, length)
-            @document.remove_node_with_notify(sib)
-            sib = following
-          end
-        end
-
-        nil
+        @document.__internal_normalize__(@__node__)
       end
 
       private
@@ -342,12 +291,12 @@ module Dommy
         if old_parent
           @document.notify_child_list_mutation(
             target_node: old_parent, added_nodes: [], removed_nodes: [bn],
-            previous_sibling: wrap.call(old_previous), next_sibling: wrap.call(old_next)
+            previous_sibling: wrap.call(old_previous), next_sibling: wrap.call(old_next), moving: true
           )
         end
         @document.notify_child_list_mutation(
           target_node: @__node__, added_nodes: [bn], removed_nodes: [],
-          previous_sibling: wrap.call(new_previous), next_sibling: wrap.call(ref_bn)
+          previous_sibling: wrap.call(new_previous), next_sibling: wrap.call(ref_bn), moving: true
         )
       end
 
@@ -406,15 +355,6 @@ module Dommy
         false
       end
 
-      # WebIDL coercion for an `appendChild`/`insertBefore`/`replaceChild`
-      # argument typed `Node`: a null / undefined / non-Node value is a
-      # TypeError before any DOM step runs.
-      def coerce_node_argument!(value)
-        return value if value.is_a?(Dommy::Node)
-
-        raise Bridge::TypeError, "Argument is not a Node."
-      end
-
       # WHATWG "ensure pre-insertion validity" for an element-like parent
       # (Element / DocumentFragment / ShadowRoot — never a Document, so the
       # document-only constraints in step 6 don't apply here). Steps run in

data/lib/dommy/internal/range_text_serializer.rb

@@ -65,8 +65,9 @@ module Dommy
         end
       end
 
+      # A Text node in the spec's sense, which a CDATASection is too.
       def text_node?(node)
-        node.respond_to?(:node_type) && node.node_type == 3
+        node.respond_to?(:node_type) && [3, 4].include?(node.node_type)
       end
     end
   end

data/lib/dommy/internal/selector_ast.rb

@@ -69,6 +69,23 @@ module Dommy
 
       TypeSelector = Struct.new(:namespace, :name) do
         def specificity = TYPE
+
+        # HTML matches a type selector against an HTML element by lowercasing
+        # the SELECTOR (see SelectorMatcher#matches_type?). Computed once per
+        # parsed selector — the matcher asks per element per query, and the AST
+        # it asks is the cached one.
+        def ascii_lowercased_name
+          @ascii_lowercased_name ||= name.to_s.downcase(:ascii)
+        end
+
+        # A name with no ASCII uppercase in it — nearly every selector ever
+        # written — is its own lowercased form, so HTML's rule and an exact
+        # comparison agree and the matcher need not ask what it is looking at.
+        def already_ascii_lowercase?
+          return @already_ascii_lowercase unless @already_ascii_lowercase.nil?
+
+          @already_ascii_lowercase = name.to_s == ascii_lowercased_name
+        end
       end
 
       UniversalSelector = Struct.new(:namespace) do