dommy 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47c59ce209a6e63313db2b6685126910463abfc26020ec5f24a7b7494b67b10f
-  data.tar.gz: 43980f4f5eb7b2c5bfe76e41bd2786e9c8cad571df1eb882e0e6d5107fbe04c6
+  metadata.gz: 6306b86751026b1b48072c497fd34cd008c5b0bfe1838ae62ab3896d89a2aa3f
+  data.tar.gz: 817d56deed527b5f2718242937bb1a30a7d22738ca8f09276750505cf9368b5a
 SHA512:
-  metadata.gz: b2627fa8969554f7ecb7a04ed16c331a77e604b44a9ca9e95412a89e48412744a3dd606892255e93eb56988cfda5214000a15821bbc5eb6ed7d18701740b3262
-  data.tar.gz: 632bddbea02093111566d46ba9fc44af35ed17879bf9921c4ad477a138d44b83e2c2761337d34f5bdfa31cc150353a4b7afe47b0cca8d817e79eda95d7b556ad
+  metadata.gz: bfce9a98c80d522db534045b6ee378d0bdfb8e1f03646173e4fc74fd5e8ed46e35e723fe4ce5f7828cdab9d71b6e567c2022ad63d01f2f70af8a0baf0acd34cf
+  data.tar.gz: 6b0aa54054201df72970198f18450268d53cbe434b3da15bd9b49cd68eb98b9d94ae1acf80d40b668706052385fa8597e4580b683c472760ee970a10ee13d2f4

data/lib/dommy/backend/makiri_adapter.rb

@@ -43,18 +43,6 @@ module Dommy
         node.clone_node(deep)
       end
 
-      # Makiri documents have no node-level clone; re-parsing the serialized
-      # document reproduces the full tree. Dispatch on the document kind so an XML
-      # document round-trips through the XML parser (case/namespaces/CDATA) and an
-      # HTML document through the HTML parser.
-      def clone_document(doc)
-        if doc.is_a?(::Makiri::XML::Document)
-          ::Makiri::XML::Document.parse(doc.to_xml)
-        else
-          ::Makiri::HTML::Document.parse(doc.to_html)
-        end
-      end
-
       # A fresh, empty HTML-backed document (children dropped so it starts with no
       # documentElement). The backing for a shallow clone of an HTML document.
       def empty_document
@@ -233,8 +221,8 @@ module Dommy
       end
 
       # Both Makiri document families (HTML and XML) mint a real PI node and
-      # serialize it (HTML as `<?target data>`, XML as `<?target data?>`), so PIs
-      # — unlike CDATA — need no HTML-document fallback.
+      # serialize it as `<?target data?>`, so PIs — unlike CDATA — need no
+      # HTML-document fallback.
       def create_processing_instruction(target, data, doc)
         doc.create_processing_instruction(target, data)
       end

data/lib/dommy/backend.rb

@@ -53,11 +53,6 @@ module Dommy
         current.clone_node(node, deep: deep)
       end
 
-      # Deep copy of a whole document (DOM cloneNode on the document).
-      def clone_document(doc)
-        current.clone_document(doc)
-      end
-
       # A fresh, empty HTML-backed document.
       def empty_document
         current.empty_document

data/lib/dommy/custom_elements.rb

@@ -86,19 +86,16 @@ module Dommy
       promise
     end
 
-    # Walk `root`'s subtree and re-wrap any nodes whose tag is now
+    # Walk `root`'s shadow-including subtree and re-wrap any nodes whose tag is now
     # registered; fires `connectedCallback` for each upgraded node
     # that's currently attached to a document tree.
     def upgrade(root)
       return nil unless root.respond_to?(:__dommy_backend_node__)
 
-      walk_descendants(root.__dommy_backend_node__) do |nk|
-        next unless nk.element?
+      @window.document.__internal_each_shadow_including_element__(root.__dommy_backend_node__) do |nk|
         next unless @definitions.key?(nk.name)
 
-        # Force re-wrap by clearing the document's cached wrapper.
-        @window.document.__internal_reset_wrapper__(nk)
-        wrapped = @window.document.wrap_node(nk)
+        wrapped = rewrap_for_upgrade(@window.document, nk)
         next unless wrapped
 
         replay_observed_attributes(wrapped)
@@ -137,6 +134,22 @@ module Dommy
       list&.each { |p| p.fulfill(klass) }
     end
 
+    # Re-wrap `nk` as its definition's class, or nil when there is nothing to
+    # upgrade. An element that is already an instance of the class is left alone:
+    # upgrading an element that is already custom does nothing. The new wrapper
+    # is told which one it replaces, because a script may hold the element — a
+    # JS-defined element upgrades that reference in place.
+    def rewrap_for_upgrade(doc, nk)
+      previous = doc.__internal_peek_wrapper__(nk)
+      klass = @definitions[nk.name]
+      return nil if klass.is_a?(Module) && previous.is_a?(klass)
+
+      doc.__internal_reset_wrapper__(nk)
+      wrapped = doc.wrap_node(nk)
+      wrapped.__internal_upgraded_from__(previous) if previous && wrapped.respond_to?(:__internal_upgraded_from__)
+      wrapped
+    end
+
     # When define() lands after the matching element is already in
     # the document, those nodes need upgrading: re-wrap them with the
     # new class and fire connectedCallback.
@@ -145,11 +158,11 @@ module Dommy
       # Match by tag name rather than interpolating `name` into a CSS selector:
       # a spec-valid custom element name may contain "." (a CSS class selector
       # char) or other metacharacters, which would corrupt the query.
-      doc.backend_doc.css("*").each do |nk|
+      # Shadow trees included, in shadow-including tree order (define step 18).
+      doc.__internal_each_shadow_including_element__(doc.backend_doc) do |nk|
         next unless nk.name == name
 
-        doc.__internal_reset_wrapper__(nk)
-        wrapped = doc.wrap_node(nk)
+        wrapped = rewrap_for_upgrade(doc, nk)
         next unless wrapped
 
         replay_observed_attributes(wrapped)
@@ -178,12 +191,5 @@ module Dommy
         )
       end
     end
-
-    def walk_descendants(node, &blk)
-      yield node
-      return unless node.respond_to?(:children)
-
-      node.children.each { |c| walk_descendants(c, &blk) }
-    end
   end
 end

data/lib/dommy/document.rb

@@ -141,6 +141,12 @@ module Dommy
     end
     private :synthetic_insert
 
+    # A doctype is connected when its tree is a document's; a synthetic one is
+    # never in a tree at all.
+    def is_connected?
+      get_root_node.is_a?(Dommy::Document)
+    end
+
     def __js_get__(key)
       case key
       when "name"
@@ -168,6 +174,8 @@ module Dommy
         NodeList.new
       when "firstChild", "lastChild"
         nil
+      when "isConnected"
+        is_connected?
       end
     end
 
@@ -954,15 +962,7 @@ module Dommy
     # Ruby Proc, a JS-bridge callable, or an object with
     # `accept_node` / `acceptNode`.
     def create_tree_walker(root, what_to_show = NodeFilter::SHOW_ALL, filter = nil)
-      TreeWalker.new(require_node_root(root), what_to_show, filter)
-    end
-
-    # The `root` of a TreeWalker / NodeIterator is a non-nullable WebIDL `Node`:
-    # a null or non-Node argument is a TypeError before construction.
-    def require_node_root(root)
-      return root if root.is_a?(Dommy::Node)
-
-      raise Bridge::TypeError, "createTreeWalker/createNodeIterator root must be a Node"
+      TreeWalker.new(Internal::WebIDL.node!(root), what_to_show, filter)
     end
 
     # WebIDL `unsigned long whatToShow = 0xFFFFFFFF`: an omitted or `undefined`
@@ -988,6 +988,12 @@ module Dommy
     # wrapper is owned by `this`. Per spec, the source node is left
     # in place. `deep: true` copies the entire subtree.
     def import_node(node, deep = false)
+      # Step 1: "If node is a document or shadow root, throw a
+      # NotSupportedError." Neither has anywhere to go in another document.
+      if node.is_a?(Document) || node.is_a?(ShadowRoot)
+        raise DOMException::NotSupportedError, "a #{node.is_a?(Document) ? "document" : "shadow root"} cannot be imported"
+      end
+
       # An Attr is a Node but not a backend-tree node: it is copied by rebuilding
       # it here with the same qualified name, namespace, prefix and value, owned
       # by no element (importNode never attaches the copy to anything).
@@ -1105,7 +1111,11 @@ module Dommy
 
     alias has_focus has_focus?
 
+    # A document without a browsing context (one built by DOMParser or
+    # createHTMLDocument) has no selection.
     def get_selection
+      return nil unless @default_view
+
       @__selection ||= Selection.new(self)
     end
 
@@ -1147,7 +1157,7 @@ module Dommy
     # `document.createNodeIterator(root, whatToShow?, filter?)` —
     # flat depth-first iteration.
     def create_node_iterator(root, what_to_show = NodeFilter::SHOW_ALL, filter = nil)
-      root = require_node_root(root)
+      root = Internal::WebIDL.node!(root)
       iterator = NodeIterator.new(root, what_to_show, filter)
       # The "NodeIterator pre-removing steps" run for iterators whose root's node
       # document is the removed node's document. Track the iterator on the root's
@@ -1348,6 +1358,8 @@ module Dommy
     #
     # Spec: https://dom.spec.whatwg.org/#dom-parentnode-movebefore
     def move_before(node, child = nil)
+      Internal::WebIDL.node!(node)
+      Internal::WebIDL.nullable_node!(child)
       bn = move_backend_node(node)
       ref_bn = move_backend_node(child)
       ref_bn = ref_bn.next_sibling if ref_bn && bn && ref_bn == bn
@@ -1356,7 +1368,7 @@ module Dommy
       old_parent = bn.parent
       old_previous = bn.previous_sibling
       old_next = bn.next_sibling
-      detach_node(bn)                                             # steps 10-11, 14
+      detach_node(bn, moving: true)                               # steps 10-11, 14
       ref_bn = nil if ref_bn && ref_bn.parent != @backend_doc
       __internal_ranges_will_insert__(@backend_doc, ref_bn, 1)    # step 16
       new_previous = ref_bn ? ref_bn.previous_sibling : @backend_doc.children.to_a.last
@@ -1365,11 +1377,12 @@ module Dommy
         notify_child_list_mutation(
           target_node: old_parent, added_nodes: [], removed_nodes: [bn],
           previous_sibling: old_previous && wrap_node(old_previous),
-          next_sibling: old_next && wrap_node(old_next)
+          next_sibling: old_next && wrap_node(old_next), moving: true
         )
       end
       notify_document_child_list(added: [bn], previous_sibling: new_previous && wrap_node(new_previous),
-                                 next_sibling: ref_bn && wrap_node(ref_bn))
+                                 next_sibling: ref_bn && wrap_node(ref_bn), moving: true)
+      __internal_notify_moved_subtree__(bn)                        # step 19.3, into a document
       nil
     end
 
@@ -1582,11 +1595,18 @@ module Dommy
       nil
     end
 
-    # `document.cloneNode(deep)` → a fresh Document over a (deep) copy of the
-    # Makiri tree, preserving the content type.
+    # `document.cloneNode(deep)` → a fresh Document of the same kind, keeping
+    # the content type. "Clone a single node" creates a document EMPTY, and a
+    # deep clone then copies the original's children into it — so nothing
+    # sprouts an html/head/body of its own, and a document with no children
+    # clones to one with no children.
     def clone_node(deep)
-      copy = deep ? Backend.clone_document(@backend_doc) : Backend.empty_document_like(@backend_doc)
-      Document.new(nil, backend_doc: copy).tap { |d| d.content_type = @content_type }
+      copy = Document.new(nil, backend_doc: Backend.empty_document_like(@backend_doc))
+      copy.content_type = @content_type
+      return copy unless deep
+
+      child_nodes.each { |child| copy.append_child(copy.import_node(child, true)) }
+      copy
     end
 
     def backend_node(node)
@@ -1987,9 +2007,7 @@ module Dommy
         document_remove_child(args[0])
       when "insertBefore"
         raise Bridge::TypeError, "insertBefore requires 2 arguments." if args.length < 2
-        unless args[1].nil? || args[1].equal?(Bridge::UNDEFINED) || args[1].is_a?(Dommy::Node)
-          raise Bridge::TypeError, "The reference child is not a Node."
-        end
+        Internal::WebIDL.nullable_node!(args[1])
 
         document_insert_before(args[0], args[1])
       when "replaceChild"
@@ -2002,7 +2020,7 @@ module Dommy
       when "cloneNode"
         clone_node(args[0])
       when "normalize"
-        nil # the document has no text children to merge
+        normalize
       when "writeln"
         write(*(args + ["\n"]))
       when "exitFullscreen"
@@ -2208,6 +2226,33 @@ module Dommy
       @shadow_registry.find_for_fragment(fragment_node)
     end
 
+    def __internal_shadow_root_for_host__(host_node)
+      @shadow_registry.find_for_host(host_node)
+    end
+
+    # Every element among `root`'s shadow-including inclusive descendants, as
+    # backend nodes, in shadow-including tree order: an element, then the shadow
+    # tree it hosts, then its children. The whole list, shadow trees included, is
+    # taken before the first element is yielded. Callbacks run synchronously here,
+    # and one that attaches a shadow root or inserts elements triggers those
+    # changes' own reactions; walking into them as well would run them twice.
+    def __internal_each_shadow_including_element__(root, &block)
+      shadow_including_elements(root).each(&block)
+      nil
+    end
+
+    def shadow_including_elements(root, list = [])
+      elements = root.respond_to?(:element?) && root.element? ? [root] : []
+      elements.concat(root.css("*").to_a) if root.respond_to?(:css)
+      elements.each do |element|
+        list << element
+        shadow = @shadow_registry.find_for_host(element)
+        shadow_including_elements(shadow.__dommy_backend_node__, list) if shadow
+      end
+      list
+    end
+    private :shadow_including_elements
+
     def __internal_shadow_root_containing__(node)
       @shadow_registry.find_enclosing(node)
     end
@@ -2235,6 +2280,12 @@ module Dommy
       @mutation_coordinator.notify_connected_subtree(nk)
     end
 
+    # The custom element reactions of a move (moveBefore), for a node that ended
+    # up connected.
+    def __internal_notify_moved_subtree__(nk)
+      @mutation_coordinator.notify_moved_subtree(nk)
+    end
+
     def __internal_notify_disconnected_subtree__(nk)
       @mutation_coordinator.notify_disconnected_subtree(nk)
     end
@@ -2260,14 +2311,16 @@ module Dommy
       added_nodes:,
       removed_nodes:,
       previous_sibling: nil,
-      next_sibling: nil
+      next_sibling: nil,
+      moving: false
     )
       @mutation_coordinator.notify_child_list_mutation(
         target_node: target_node,
         added_nodes: added_nodes,
         removed_nodes: removed_nodes,
         previous_sibling: previous_sibling,
-        next_sibling: next_sibling
+        next_sibling: next_sibling,
+        moving: moving
       )
     end
 
@@ -2302,13 +2355,14 @@ module Dommy
       node && wrap_node(node)
     end
 
-    def notify_document_child_list(added: [], removed: [], previous_sibling: nil, next_sibling: nil)
+    def notify_document_child_list(added: [], removed: [], previous_sibling: nil, next_sibling: nil, moving: false)
       notify_child_list_mutation(
         target_node: @backend_doc,
         added_nodes: added,
         removed_nodes: removed,
         previous_sibling: previous_sibling,
-        next_sibling: next_sibling
+        next_sibling: next_sibling,
+        moving: moving
       )
     end
 
@@ -2316,10 +2370,18 @@ module Dommy
     # batch several removals into one childList record (replaceChildren,
     # textContent=, replaceChild) use this and queue the record themselves;
     # `remove_node_with_notify` is this plus a per-node record.
-    def detach_node(node)
+    #
+    # `moving:` marks the first half of the "move" primitive (moveBefore). A
+    # move takes the node out of its old parent's children only to put it
+    # straight back into the same shadow-including tree: it never leaves the
+    # document, so nothing that reacts to a removal from the document may run.
+    def detach_node(node, moving: false)
       pre_remove_node(node)
       add_transient_observers_for(node)
       node.unlink
+      # A removal can take a shadow tree, and a selection range in it, out of
+      # the document without moving the range; the selection lets go of it.
+      @__selection&.__internal_node_removed__ unless moving
       node
     end
 
@@ -2455,6 +2517,73 @@ module Dommy
       end
     end
 
+    # Node.normalize() on the document: every Text run in the tree.
+    def normalize
+      __internal_normalize__(@backend_doc)
+    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 serves Element, DocumentFragment, ShadowRoot and the Document 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
+    def __internal_normalize__(root)
+      text_nodes = []
+      root.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?
+          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 = 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
+            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.
+          __internal_ranges_normalize_merge__(node, sib, length)
+          remove_node_with_notify(sib)
+          sib = following
+        end
+      end
+
+      nil
+    end
+
     def __internal_ranges_replaced_data__(node, offset, count, new_length)
       return unless live_ranges?
 
@@ -2574,40 +2703,105 @@ module Dommy
     # `deep: true` recurses into children. Used by importNode and
     # adoptNode for cross-document transfer.
     def clone_into_doc(source, deep, source_document = self)
-      copy = if source.element?
-        new_el = Backend.create_element(source.name, @backend_doc)
-        Backend.attribute_nodes(source).each { |a| new_el[a.name] = a.value }
-        new_el
+      copy = clone_single_node_into_doc(source, source_document)
+
+      if source.element? && source.name == "template"
+        # A <template>'s contents live in a separate content fragment, not its
+        # child list, so the generic deep pass over `children` misses them.
+        clone_template_content(source, copy, source_document) if deep
+      elsif deep && source.respond_to?(:children)
+        source.children.each do |child|
+          copy.add_child(clone_into_doc(child, true, source_document))
+        end
+      end
+
+      copy
+    end
+
+    # "Clone a single node" (§4.4): the copy implements the SAME interface as
+    # the original — a ProcessingInstruction clones to one, not to the comment
+    # its serialization looks like — and carries the same data. Elements are
+    # cloned by #clone_element_into_doc; children are the caller's business.
+    def clone_single_node_into_doc(source, source_document)
+      if source.element?
+        clone_element_into_doc(source, source_document)
+      elsif (cdata = Backend.cdata_class) && source.is_a?(cdata)
+        # CDATA is a Text subtype in the backend, so ask about it first.
+        Backend.create_cdata(source.content, @backend_doc)
       elsif source.text?
         Backend.create_text(source.content, @backend_doc)
       elsif source.is_a?(Backend.comment_class)
         Backend.create_comment(source.content, @backend_doc)
+      elsif source.is_a?(Backend.processing_instruction_class)
+        Backend.create_processing_instruction(source.target, source.content, @backend_doc)
       elsif source.is_a?(Backend.document_fragment_class)
         # A DocumentFragment clones to a fragment (its children are appended by
-        # the deep pass below), NOT to its first child — `importNode(<template>
+        # the deep pass), NOT to its first child — `importNode(<template>
         # .content, true)` must return a fragment so `.firstElementChild` works
         # (Vue/Alpine x-for clone template content this way). Built via the
         # document's own `fragment` (as TemplateContentRegistry does) rather than
         # `document_fragment_class.new`, so it works on backends whose fragment
         # class isn't directly instantiable (Makiri).
         Parser.fragment("", owner_doc: @backend_doc)
+      elsif (doctype = Backend.document_type_class) && source.is_a?(doctype)
+        wrapper = source_document.wrap_node(source)
+        Backend.create_document_type(wrapper.name, wrapper.public_id, wrapper.system_id, @backend_doc)
       else
-        # Fallback: serialize + reparse via fragment for unusual types.
-        fragment = Parser.fragment(source.to_html, owner_doc: @backend_doc)
-        fragment.children.first || Backend.create_text("", @backend_doc)
+        Backend.create_text("", @backend_doc)
       end
+    end
 
-      if source.element? && source.name == "template"
-        # A <template>'s contents live in a separate content fragment, not its
-        # child list, so the generic deep pass over `children` misses them.
-        clone_template_content(source, copy, source_document) if deep
-      elsif deep && source.respond_to?(:children)
-        source.children.each do |child|
-          copy.add_child(clone_into_doc(child, true, source_document))
+    # An element's copy keeps its namespace, its prefix and the exact spelling
+    # of its local name. None of that is on the backend node — the HTML backend
+    # tracks no namespace for an element script created, and createElementNS's
+    # case lives on the wrapper — so the original is read through its wrapper
+    # and the copy is given the same metadata.
+    def clone_element_into_doc(source, source_document)
+      wrapper = source_document.wrap_node(source)
+      namespace, prefix, local, qualified = clone_name_parts(wrapper, source)
+      copy = Backend.create_element_loose(qualified, prefix, local, namespace, @backend_doc) ||
+        Backend.create_element(source.name, @backend_doc)
+      copy_attributes_into(source, copy)
+      note_cloned_element_namespace(copy, namespace, prefix, local, qualified)
+      copy
+    end
+
+    # The four parts of the original's name — namespace, prefix, local name and
+    # qualified name. The wrapper's own metadata has them whenever there is
+    # anything to carry (createElementNS's case and prefix, an XML document's,
+    # the HTML parser's SVG names); otherwise the element is an unprefixed one
+    # whose namespace the backend knows.
+    def clone_name_parts(wrapper, source)
+      meta = wrapper.__internal_namespace_metadata__ if wrapper.respond_to?(:__internal_namespace_metadata__)
+      return meta if meta
+
+      local = wrapper ? wrapper.local_name.to_s : source.name
+      [wrapper&.namespace_uri, nil, local, local]
+    end
+
+    # "Clone a single node" step 2.1 clones the attributes one by one, so each
+    # keeps its own namespace and prefix — an `xml:b` must not flatten into an
+    # attribute whose local name is the qualified string "xml:b".
+    def copy_attributes_into(source, copy)
+      Backend.attribute_nodes(source).each do |attr|
+        info = Backend.attribute_ns_info(attr)
+        if info[:namespace_uri]
+          Backend.set_attribute_ns(copy, info[:namespace_uri], info[:prefix], info[:local_name],
+            info[:qualified_name], info[:value])
+        else
+          copy[info[:qualified_name]] = info[:value]
         end
       end
+      nil
+    end
 
-      copy
+    # Give the copy's wrapper the namespace metadata whenever the backend node
+    # alone would report something else (see #clone_element_into_doc).
+    def note_cloned_element_namespace(copy, namespace, prefix, local, qualified)
+      derived = Backend.namespace_of(copy)&.href || (html_document? ? Element::HTML_NAMESPACE : nil)
+      return if derived == namespace && prefix.nil? && local == copy.name
+
+      wrap_cloned_element_ns(copy, namespace, prefix, local, qualified)
     end
 
     # Clone a <template>'s content into a fragment registered as `copy`'s