RubyGems - dommy - Versions diffs - 0.6.0 → 0.8.0 - Mend

dommy 0.6.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (75) hide show

checksums.yaml +4 -4
data/README.md +30 -38
data/lib/dommy/animation.rb +10 -2
data/lib/dommy/attr.rb +197 -32
data/lib/dommy/backend/nokogiri_adapter.rb +127 -0
data/lib/dommy/backend/nokolexbor_adapter.rb +117 -0
data/lib/dommy/backend.rb +175 -0
data/lib/dommy/blob.rb +30 -11
data/lib/dommy/bridge/constructor_registry.rb +28 -0
data/lib/dommy/bridge/methods.rb +57 -0
data/lib/dommy/bridge.rb +97 -0
data/lib/dommy/callable_invoker.rb +36 -0
data/lib/dommy/compression_streams.rb +4 -4
data/lib/dommy/cookie_store.rb +4 -2
data/lib/dommy/crypto.rb +16 -9
data/lib/dommy/css.rb +53 -7
data/lib/dommy/custom_elements.rb +33 -9
data/lib/dommy/data_transfer.rb +4 -0
data/lib/dommy/document.rb +693 -60
data/lib/dommy/dom_parser.rb +29 -15
data/lib/dommy/element.rb +1147 -438
data/lib/dommy/event.rb +279 -79
data/lib/dommy/event_source.rb +14 -10
data/lib/dommy/fetch.rb +509 -39
data/lib/dommy/file_reader.rb +14 -6
data/lib/dommy/form_data.rb +3 -3
data/lib/dommy/history.rb +46 -8
data/lib/dommy/html_collection.rb +59 -6
data/lib/dommy/html_elements.rb +153 -1502
data/lib/dommy/internal/css_pseudo_handlers.rb +137 -0
data/lib/dommy/internal/dom_matching.rb +3 -3
data/lib/dommy/internal/global_functions.rb +26 -0
data/lib/dommy/internal/idna.rb +16 -7
data/lib/dommy/internal/ipv4_parser.rb +22 -7
data/lib/dommy/internal/mutation_coordinator.rb +11 -2
data/lib/dommy/internal/namespaces.rb +70 -0
data/lib/dommy/internal/node_equality.rb +86 -0
data/lib/dommy/internal/node_traversal.rb +1 -1
data/lib/dommy/internal/node_wrapper_cache.rb +77 -31
data/lib/dommy/internal/observable_callback.rb +1 -5
data/lib/dommy/internal/parent_node.rb +126 -0
data/lib/dommy/internal/reflected_attributes.rb +103 -13
data/lib/dommy/internal/selector_parser.rb +664 -0
data/lib/dommy/internal/template_content_registry.rb +6 -6
data/lib/dommy/internal/url_parser.rb +677 -0
data/lib/dommy/intersection_observer.rb +4 -2
data/lib/dommy/location.rb +10 -4
data/lib/dommy/media_query_list.rb +10 -4
data/lib/dommy/message_channel.rb +41 -11
data/lib/dommy/mutation_observer.rb +76 -23
data/lib/dommy/navigator.rb +38 -24
data/lib/dommy/node.rb +158 -16
data/lib/dommy/notification.rb +6 -4
data/lib/dommy/parser.rb +13 -13
data/lib/dommy/performance.rb +4 -0
data/lib/dommy/performance_observer.rb +4 -2
data/lib/dommy/promise.rb +14 -14
data/lib/dommy/range.rb +74 -5
data/lib/dommy/resize_observer.rb +4 -2
data/lib/dommy/scheduler.rb +34 -13
data/lib/dommy/shadow_root.rb +31 -60
data/lib/dommy/storage.rb +2 -0
data/lib/dommy/streams.rb +40 -49
data/lib/dommy/svg_elements.rb +204 -3606
data/lib/dommy/text_codec.rb +178 -25
data/lib/dommy/tree_walker.rb +270 -81
data/lib/dommy/url.rb +305 -450
data/lib/dommy/url_pattern.rb +2 -0
data/lib/dommy/version.rb +1 -1
data/lib/dommy/web_socket.rb +49 -19
data/lib/dommy/window.rb +205 -203
data/lib/dommy/worker.rb +12 -12
data/lib/dommy/xml_http_request.rb +32 -7
data/lib/dommy.rb +19 -2
metadata +22 -27

data/lib/dommy/document.rb CHANGED Viewed

@@ -11,28 +11,288 @@ require_relative "internal/observer_manager"
 require_relative "internal/template_content_registry"
 module Dommy
-  # Stub DocumentType (`<!doctype html>`) — exposes `name` and `nodeType=10`.
-  # Real browsers also expose `publicId` / `systemId` which we leave empty
-  # since HTML5 doctypes don't carry those.
+  # DocumentType (`<!doctype html>`) — exposes name / publicId / systemId and
+  # nodeType=10. HTML5 doctypes carry empty public/system IDs, but
+  # `implementation.createDocumentType` can set them.
   class DocumentType
     include Node
     attr_reader :name
-    def initialize(name)
+    # `owner_document:` links a live doctype (document.doctype) to its document so
+    # the ChildNode methods (remove/before/after/replaceWith) act on the tree; a
+    # standalone doctype (DOMImplementation.createDocumentType) has none, so those
+    # methods are no-ops per spec.
+    def initialize(name, public_id = "", system_id = "", owner_document: nil)
       @name = name.to_s
+      @public_id = public_id.to_s
+      @system_id = system_id.to_s
+      @owner_document = owner_document
+    end
+    # ChildNode mixin — the doctype's parent is the document.
+    def remove
+      @owner_document&.__internal_remove_doctype__(self)
+      nil
+    end
+    def before(*nodes)
+      return nil unless @owner_document
+      @owner_document.__internal_insert_at_doctype__(nodes, after: false)
+      nil
+    end
+    def after(*nodes)
+      return nil unless @owner_document
+      @owner_document.__internal_insert_at_doctype__(nodes, after: true)
+      nil
+    end
+    def replace_with(*nodes)
+      return nil unless @owner_document
+      @owner_document.__internal_insert_at_doctype__(nodes, after: false)
+      remove
+      nil
     end
     def __js_get__(key)
       case key
       when "name"
         @name
+      when "nodeName"
+        # WHATWG: a DocumentType's nodeName is its name.
+        @name
       when "nodeType"
         10
       when "publicId"
-        ""
+        @public_id
       when "systemId"
-        ""
+        @system_id
+      end
+    end
+    include EventTarget
+    def __internal_event_parent__
+      nil
+    end
+    include Bridge::Methods
+    js_methods %w[isEqualNode isSameNode getRootNode hasChildNodes normalize compareDocumentPosition
+      appendChild insertBefore removeChild replaceChild before after replaceWith remove
+      addEventListener removeEventListener dispatchEvent]
+    def __js_call__(method, args)
+      case method
+      when "hasChildNodes"
+        false
+      when "isEqualNode"
+        is_equal_node(args[0])
+      when "isSameNode"
+        is_same_node(args[0])
+      when "getRootNode"
+        get_root_node(args[0])
+      when "compareDocumentPosition"
+        compare_document_position(args[0])
+      when "appendChild", "insertBefore"
+        raise DOMException::HierarchyRequestError, "a DocumentType may not have children"
+      when "removeChild", "replaceChild"
+        raise DOMException::NotFoundError, "the node to be removed is not a child of this node"
+      when "before"
+        before(*args)
+      when "after"
+        after(*args)
+      when "replaceWith"
+        replace_with(*args)
+      when "remove"
+        remove
+      when "normalize"
+        nil
+      when "addEventListener"
+        add_event_listener(args[0], args[1], args[2])
+      when "removeEventListener"
+        remove_event_listener(args[0], args[1], args[2])
+      when "dispatchEvent"
+        dispatch_event(args[0])
+      end
+    end
+  end
+  # ProcessingInstruction (`<?target data?>`) — a CharacterData-like node with a
+  # `target`; created via `document.createProcessingInstruction`.
+  class ProcessingInstruction
+    include Node
+    attr_reader :target
+    def initialize(target, data)
+      @target = target.to_s
+      @data = data.to_s
+    end
+    include EventTarget
+    def data = @data
+    def __js_get__(key)
+      case key
+      when "target"
+        @target
+      when "data", "nodeValue", "textContent"
+        @data
+      when "nodeName"
+        @target
+      when "nodeType"
+        7
+      when "length"
+        @data.length
+      end
+    end
+    def __js_set__(key, value)
+      case key
+      when "data", "nodeValue", "textContent"
+        @data = value.to_s
+      else
+        return Bridge::UNHANDLED
+      end
+      nil
+    end
+    # A PI is CharacterData: its data methods are string operations on @data.
+    def substring_data(offset, count)
+      o = offset.to_i
+      raise DOMException::IndexSizeError, "offset out of bounds" if o.negative? || o > @data.length
+      @data[o, count.to_i] || ""
+    end
+    def append_data(value)
+      @data += value.to_s
+      nil
+    end
+    def insert_data(offset, value)
+      o = offset.to_i
+      raise DOMException::IndexSizeError, "offset out of bounds" if o.negative? || o > @data.length
+      @data = @data[0, o].to_s + value.to_s + (@data[o..] || "")
+      nil
+    end
+    def delete_data(offset, count)
+      o = offset.to_i
+      raise DOMException::IndexSizeError, "offset out of bounds" if o.negative? || o > @data.length
+      @data = @data[0, o].to_s + (@data[(o + count.to_i)..] || "")
+      nil
+    end
+    def replace_data(offset, count, value)
+      delete_data(offset, count)
+      insert_data(offset, value)
+      nil
+    end
+    def __internal_event_parent__
+      nil
+    end
+    include Bridge::Methods
+    js_methods %w[isEqualNode isSameNode getRootNode normalize hasChildNodes
+      appendData insertData deleteData replaceData substringData compareDocumentPosition
+      appendChild insertBefore removeChild replaceChild before after replaceWith remove
+      addEventListener removeEventListener dispatchEvent]
+    def __js_call__(method, args)
+      case method
+      when "hasChildNodes"
+        false
+      when "isEqualNode"
+        is_equal_node(args[0])
+      when "isSameNode"
+        is_same_node(args[0])
+      when "getRootNode"
+        get_root_node(args[0])
+      when "compareDocumentPosition"
+        compare_document_position(args[0])
+      when "appendChild", "insertBefore"
+        raise DOMException::HierarchyRequestError, "a ProcessingInstruction may not have children"
+      when "removeChild", "replaceChild"
+        raise DOMException::NotFoundError, "the node to be removed is not a child of this node"
+      when "before", "after", "replaceWith", "remove"
+        # ChildNode mixin: a created PI has no parent, so these are no-ops per
+        # spec (they act only when the node is inserted in a tree).
+        nil
+      when "normalize"
+        nil
+      when "substringData"
+        substring_data(args[0], args[1])
+      when "appendData"
+        append_data(args[0])
+      when "insertData"
+        insert_data(args[0], args[1])
+      when "deleteData"
+        delete_data(args[0], args[1])
+      when "replaceData"
+        replace_data(args[0], args[1], args[2])
+      when "addEventListener"
+        add_event_listener(args[0], args[1], args[2])
+      when "removeEventListener"
+        remove_event_listener(args[0], args[1], args[2])
+      when "dispatchEvent"
+        dispatch_event(args[0])
+      end
+    end
+  end
+  # `document.implementation` — the DOMImplementation. Only the node factories
+  # WPT exercises are provided; createDocument/createHTMLDocument are not yet
+  # implemented (foreign documents).
+  class DOMImplementation
+    def initialize(document)
+      @document = document
+    end
+    def create_document_type(qualified_name, public_id, system_id)
+      DocumentType.new(qualified_name, public_id, system_id)
+    end
+    # createDocument(namespace, qualifiedName, doctype?) — a fresh XML document,
+    # with a document element (namespace, qualifiedName) when qualifiedName is
+    # non-empty. (The doctype argument is accepted but not stored, as document
+    # equality compares only structure that survives wrap_node.)
+    def create_document(namespace, qualified_name, _doctype = nil)
+      doc = Document.new(nil, nokogiri_doc: Backend.document_class.new)
+      qn = qualified_name.to_s
+      unless qn.empty?
+        el = doc.send(:create_element_ns, namespace, qualified_name)
+        doc.nokogiri_doc.root = el.__dommy_backend_node__
+      end
+      doc
+    end
+    # createHTMLDocument(title?) — a fresh HTML document (doctype + html > head,
+    # body), with an optional <title>.
+    def create_html_document(title = nil)
+      doc = Document.new(nil, nokogiri_doc: Backend.parse("<!DOCTYPE html><html><head></head><body></body></html>"))
+      doc.title = title.to_s unless title.nil? || title.equal?(Bridge::UNDEFINED)
+      doc
+    end
+    def __js_get__(_key) = nil
+    include Bridge::Methods
+    js_methods %w[createDocumentType createDocument createHTMLDocument]
+    def __js_call__(method, args)
+      case method
+      when "createDocumentType"
+        create_document_type(args[0], args[1], args[2])
+      when "createDocument"
+        create_document(args[0], args[1], args[2])
+      when "createHTMLDocument"
+        create_html_document(args[0])
       end
     end
   end
@@ -44,8 +304,11 @@ module Dommy
     include EventTarget
     include Node
-    attr_reader :body, :nokogiri_doc
+    attr_reader :nokogiri_doc
     attr_accessor :default_view
+    # content_type defaults to "text/html"; settable so an integration layer
+    # can reflect the response Content-Type. Read-only over the JS bridge.
+    attr_accessor :content_type
     def initialize(host = nil, nokogiri_doc: nil, default_view: nil)
       @host = host
@@ -56,9 +319,31 @@ module Dommy
       @cookie_jar = Internal::CookieJar.new
       @template_content_registry = Internal::TemplateContentRegistry.new(self)
       @mutation_coordinator = Internal::MutationCoordinator.new(self, @observer_manager)
-      @nokogiri_doc = nokogiri_doc || Nokogiri::HTML5("<!doctype html><html><head></head><body></body></html>")
-      body_node = @nokogiri_doc.at_css("body")
-      @body = wrap_node(body_node) if body_node
+      @node_iterators = []
+      @nokogiri_doc = nokogiri_doc || Backend.parse("<!doctype html><html><head></head><body></body></html>")
+      @content_type = "text/html"
+    end
+    # Whether this is an "HTML document" in the DOM sense (created by the HTML
+    # parser / `text/html`), as opposed to an XML document. It drives the
+    # case-folding rules: `createElement` lowercases names and `Element#tagName`
+    # uppercases HTML-namespace names only in an HTML document. An XML or XHTML
+    # document (e.g. an `application/xhtml+xml` / `text/xml` resource) preserves
+    # case.
+    def html_document?
+      @content_type == "text/html"
+    end
+    # `document.compatMode` — "CSS1Compat" in no-quirks mode, "BackCompat" in
+    # quirks mode. A missing doctype is quirks; a bare `<!DOCTYPE html>` (no
+    # public/system identifier) is no-quirks. (The full quirks algorithm keys off
+    # specific legacy public ids; this covers the common cases.)
+    def compat_mode
+      dt = @nokogiri_doc.internal_subset
+      return "BackCompat" unless dt
+      return "CSS1Compat" if dt.name.to_s.downcase == "html" && dt.external_id.nil?
+      "BackCompat"
     end
     # ----- Public Ruby API (snake_case) -----
@@ -72,13 +357,38 @@ module Dommy
     end
     def document_element
-      wrap_node(@nokogiri_doc.at_css("html"))
+      # The document's root element — `<html>` for HTML, the actual root for XML.
+      wrap_node(@nokogiri_doc.root)
     end
     def head
       wrap_node(@nokogiri_doc.at_css("head"))
     end
+    # Resolve `body` fresh from the tree (not memoized) so it tracks a swapped
+    # `<body>` — e.g. Turbo's page render does
+    # `documentElement.replaceChild(newBody, body)`, after which a stale cached
+    # wrapper would keep returning the detached old body. wrap_node caches by
+    # node, so identity (`document.body === document.body`) still holds.
+    def body
+      wrap_node(@nokogiri_doc.at_css("body"))
+    end
+    # Serialize the whole document to HTML (including the doctype).
+    def to_html
+      @nokogiri_doc.to_html
+    end
+    # XPath queries returning wrapped nodes (Element / TextNode / etc).
+    def at_xpath(expression)
+      node = @nokogiri_doc.at_xpath(expression)
+      node && wrap_node(node)
+    end
+    def xpath(expression)
+      @nokogiri_doc.xpath(expression).map { |node| wrap_node(node) }
+    end
     # `document.URL` / `documentURI` — both return location.href in
     # real browsers (legacy aliases of the same field).
     def url
@@ -116,6 +426,15 @@ module Dommy
       view.location.__js_get__("hostname").to_s
     end
+    # `document.origin` — serialized origin of the document URL, mirroring
+    # `window.location.origin`. Empty when there is no associated window.
+    def origin
+      view = @default_view
+      return "" unless view&.location
+      view.location.__js_get__("origin").to_s
+    end
     # `document.referrer` — Dommy never has a referring page, so this
     # is always empty.
     def referrer
@@ -157,6 +476,15 @@ module Dommy
       end
     end
+    # All child nodes of the document (doctype + document element, …), as a live,
+    # cached NodeList — unlike `children`, which is element-only. Cached so
+    # `document.childNodes === document.childNodes` and mutations are reflected.
+    def child_nodes
+      @live_child_nodes ||= LiveNodeList.new do
+        @nokogiri_doc.children.map { |n| wrap_node(n) }.compact
+      end
+    end
     def child_element_count
       children.size
     end
@@ -172,10 +500,21 @@ module Dommy
     # Currently-focused element (or body if none). Updated via
     # `el.focus()` / `el.blur()`.
     def active_element
-      @active_element || @body
+      @active_element || body
+    end
+    # `document.contains(node)` — true if `node` is the document itself or any
+    # node attached to its tree (per Node.contains, which all nodes including the
+    # document expose). Per spec, false for null / a non-Node.
+    def contains?(other)
+      return true if other.equal?(self)
+      return false unless other.respond_to?(:__dommy_backend_node__)
+      node = other.__dommy_backend_node__
+      node.document == @nokogiri_doc && node.ancestors.include?(@nokogiri_doc)
     end
-    def __set_active_element__(el)
+    def __internal_set_active_element__(el)
       @active_element = el
     end
@@ -198,13 +537,32 @@ module Dommy
       TreeWalker.new(root, what_to_show, filter)
     end
+    # WebIDL `unsigned long whatToShow = 0xFFFFFFFF`: an omitted or `undefined`
+    # argument uses the default; `null` coerces to 0; otherwise ToUint32.
+    def coerce_what_to_show(args, index)
+      return NodeFilter::SHOW_ALL if args.length <= index
+      value = args[index]
+      return NodeFilter::SHOW_ALL if defined?(Bridge::UNDEFINED) && value.equal?(Bridge::UNDEFINED)
+      return 0 if value.nil?
+      value.to_i % (2**32)
+    end
+    # A `null`/`undefined` filter argument means "no filter".
+    def normalize_filter(value)
+      return nil if value.nil?
+      return nil if defined?(Bridge::UNDEFINED) && value.equal?(Bridge::UNDEFINED)
+      value
+    end
     # Copy a node from another document into this one. The returned
     # 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)
-      return nil unless node.respond_to?(:__node__)
+      return nil unless node.respond_to?(:__dommy_backend_node__)
-      copy = clone_into_doc(node.__node__, deep)
+      copy = clone_into_doc(node.__dommy_backend_node__, deep)
       wrap_node(copy)
     end
@@ -212,17 +570,32 @@ module Dommy
     # node is detached from its previous owner and its ownerDocument
     # becomes this. Returns the (possibly re-wrapped) node.
     def adopt_node(node)
-      return nil unless node.respond_to?(:__node__)
+      return nil unless node.respond_to?(:__dommy_backend_node__)
-      src = node.__node__
+      src = node.__dommy_backend_node__
       src.unlink if src.parent
-      moved = if src.document == @nokogiri_doc
-        src
-      else
-        clone_into_doc(src, true)
-      end
-      wrap_node(moved)
+      # Same document: just return the wrapper after the detach above.
+      return wrap_node(src) if src.document == @nokogiri_doc
+      # Cross-document: Nokogiri reassigns `src.document` when src is
+      # added under a node owned by another document. We transiently
+      # attach to our root, then unlink so src ends up free-floating
+      # but now belongs to @nokogiri_doc. The underlying Ruby object
+      # identity is preserved.
+      src_doc_wrapper = node.instance_variable_get(:@document)
+      @nokogiri_doc.root.add_child(src)
+      src.unlink
+      # Move the caller's Dommy wrapper from the source document's
+      # wrapper cache into ours, and re-point its @document. This
+      # keeps `adopt_node(x).equal?(x)` true across documents.
+      node.instance_variable_set(:@document, self)
+      if src_doc_wrapper.respond_to?(:__internal_reset_wrapper__)
+        src_doc_wrapper.__internal_reset_wrapper__(src)
+      end
+      @node_wrapper_cache.register(src, node)
+      node
     end
     # Legacy `document.createEvent("EventName")` factory. Returns an
@@ -268,7 +641,7 @@ module Dommy
     # is the read side.
     attr_reader :fullscreen_element
-    def __set_fullscreen_element__(element)
+    def __internal_set_fullscreen_element__(element)
       previous = @fullscreen_element
       @fullscreen_element = element
       return if previous == element
@@ -297,7 +670,11 @@ module Dommy
     # `document.createNodeIterator(root, whatToShow?, filter?)` —
     # flat depth-first iteration.
     def create_node_iterator(root, what_to_show = NodeFilter::SHOW_ALL, filter = nil)
-      NodeIterator.new(root, what_to_show, filter)
+      iterator = NodeIterator.new(root, what_to_show, filter)
+      # Track live iterators so node removal can run the "NodeIterator
+      # pre-removing steps" (adjusting referenceNode) before a node detaches.
+      @node_iterators << iterator
+      iterator
     end
     # Minimal DocumentType — represents the `<!doctype html>` line.
@@ -305,7 +682,114 @@ module Dommy
     # stub object whose only useful field is `name`. Tests just need
     # `nodeType == 10`.
     def doctype
-      @doctype ||= DocumentType.new("html")
+      return nil if @doctype_removed
+      @doctype ||= DocumentType.new("html", owner_document: self)
+    end
+    def implementation
+      @implementation ||= DOMImplementation.new(self)
+    end
+    def create_processing_instruction(target, data)
+      ProcessingInstruction.new(target, data)
+    end
+    # Append a node as a child of the document itself (e.g. a comment alongside
+    # the document element). Adopts the node into this document.
+    def append_child(node)
+      return node unless node.respond_to?(:__dommy_backend_node__)
+      @nokogiri_doc.add_child(node.__dommy_backend_node__)
+      node
+    end
+    # ParentNode / Node mutation on the document's direct children (the doctype
+    # and the document element). Operate on the Nokogiri document node; string
+    # arguments (which would need a text child the document can't hold) are
+    # ignored rather than raising.
+    def document_insert(args, prepend:)
+      nodes = args.filter_map { |a| backend_node(a) }
+      if prepend && (first = @nokogiri_doc.children.first)
+        nodes.reverse_each { |n| first.add_previous_sibling(n) }
+      else
+        nodes.each { |n| @nokogiri_doc.add_child(n) }
+      end
+      nil
+    end
+    def document_replace_children(args)
+      @nokogiri_doc.children.each(&:unlink)
+      args.filter_map { |a| backend_node(a) }.each { |n| @nokogiri_doc.add_child(n) }
+      nil
+    end
+    def document_remove_child(node)
+      # The doctype is synthesized from the Nokogiri DTD rather than wrapped as a
+      # tree node, so remove the internal subset directly.
+      return __internal_remove_doctype__(node) if node.is_a?(DocumentType)
+      bn = backend_node(node)
+      raise DOMException::NotFoundError, "node is not a child of this document" unless bn && bn.parent == @nokogiri_doc
+      bn.unlink
+      node
+    end
+    def document_insert_before(node, ref)
+      bn = backend_node(node)
+      return node unless bn
+      ref_node = ref && backend_node(ref)
+      if ref_node && ref_node.parent == @nokogiri_doc
+        ref_node.add_previous_sibling(bn)
+      else
+        @nokogiri_doc.add_child(bn)
+      end
+      node
+    end
+    def document_replace_child(new_child, old_child)
+      old_bn = backend_node(old_child)
+      raise DOMException::NotFoundError, "node is not a child of this document" unless old_bn && old_bn.parent == @nokogiri_doc
+      new_bn = backend_node(new_child)
+      old_bn.add_previous_sibling(new_bn) if new_bn
+      old_bn.unlink
+      old_child
+    end
+    # Called by DocumentType#remove — the doctype is synthesized from the DTD, so
+    # remove the internal subset and mark it gone.
+    def __internal_remove_doctype__(_doctype)
+      @doctype_removed = true
+      @nokogiri_doc.internal_subset&.unlink
+      nil
+    end
+    # Called by DocumentType#before/#after — insert `nodes` before the doctype
+    # (at the document start) or after it (just before the document element).
+    def __internal_insert_at_doctype__(nodes, after:)
+      bns = nodes.filter_map { |n| backend_node(n) }
+      if after
+        root = @nokogiri_doc.root
+        root ? bns.each { |n| root.add_previous_sibling(n) } : bns.each { |n| @nokogiri_doc.add_child(n) }
+      else
+        first = @nokogiri_doc.children.first
+        first ? bns.reverse_each { |n| first.add_previous_sibling(n) } : bns.each { |n| @nokogiri_doc.add_child(n) }
+      end
+      nil
+    end
+    # `document.cloneNode(deep)` → a fresh Document over a (deep) copy of the
+    # Nokogiri tree, preserving the content type.
+    def clone_node(deep)
+      copy = deep ? @nokogiri_doc.dup : Backend.document_class.new
+      Document.new(nil, nokogiri_doc: copy).tap { |d| d.content_type = @content_type }
+    end
+    def backend_node(node)
+      node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__ : nil
     end
     # Delegate to CookieJar
@@ -331,6 +815,10 @@ module Dommy
       @node_wrapper_cache.get_elements_by_name(name)
     end
+    def get_elements_by_tag_name_ns(namespace, local_name)
+      HTMLCollection.elements_by_tag_name_ns(@nokogiri_doc, self, namespace, local_name)
+    end
     # `document.write(html)` — legacy API. Appends parsed nodes to the
     # body. Real browsers only re-stream the DOM during initial parse;
     # this stub is enough for tests that fire write() during teardown.
@@ -339,8 +827,9 @@ module Dommy
       fragment = Parser.fragment(html, owner_doc: @nokogiri_doc)
       removed = []
       added = fragment.children.to_a
-      added.each { |node| @body.__node__.add_child(node) }
-      notify_child_list_mutation(target_node: @body.__node__, added_nodes: added, removed_nodes: removed)
+      body_node = body.__dommy_backend_node__
+      added.each { |node| body_node.add_child(node) }
+      notify_child_list_mutation(target_node: body_node, added_nodes: added, removed_nodes: removed)
       nil
     end
@@ -368,6 +857,10 @@ module Dommy
       @node_wrapper_cache.create_comment(text)
     end
+    def create_cdata_section(text)
+      @node_wrapper_cache.create_cdata_section(text)
+    end
     def create_document_fragment
       @node_wrapper_cache.create_document_fragment
     end
@@ -379,11 +872,13 @@ module Dommy
     def __js_get__(key)
       case key
       when "body"
-        @body
+        body
       when "head"
         head
       when "doctype"
         doctype
+      when "implementation"
+        implementation
       when "defaultView"
         @default_view
       when "fullscreenElement"
@@ -393,7 +888,8 @@ module Dommy
       when "scrollingElement"
         wrap_node(@nokogiri_doc.at_css("html"))
       when "documentElement"
-        wrap_node(@nokogiri_doc.at_css("html"))
+        # The document's root element — `<html>` for HTML, the actual root for XML.
+        wrap_node(@nokogiri_doc.root)
       when "title"
         read_title
       when "cookie"
@@ -408,6 +904,37 @@ module Dommy
         base_uri
       when "domain"
         domain
+      when "origin"
+        origin
+      when "contentType"
+        content_type
+      when "location"
+        # document.location is the same Location object as window.location.
+        @default_view&.__js_get__("location")
+      when "characterSet", "charset", "inputEncoding"
+        # The DOM is held as Ruby strings (UTF-8); we don't model other encodings.
+        "UTF-8"
+      when "dir"
+        document_element&.get_attribute("dir") || ""
+      when "designMode"
+        @design_mode || "off"
+      when "lastModified"
+        @last_modified || "01/01/1970 00:00:00"
+      when "readyState"
+        # The document is fully parsed by the time scripts run against it (there
+        # is no incremental network parse), so it is always "complete". Code that
+        # gates on `document.readyState === "loading"` (e.g. Turbo's preloader)
+        # therefore takes the already-loaded path.
+        "complete"
+      when "visibilityState"
+        # There's no real viewport/tab; the document is treated as the visible,
+        # foreground page (so `nextRepaint`-style code uses requestAnimationFrame,
+        # and `=== "visible"` checks pass).
+        "visible"
+      when "hidden"
+        false
+      when "compatMode"
+        compat_mode
       when "referrer"
         referrer
       when "links"
@@ -418,8 +945,28 @@ module Dommy
         scripts
       when "images"
         images
+      when "embeds", "plugins"
+        # Both reflect the same list of <embed> elements.
+        HTMLCollection.new { @nokogiri_doc.css("embed").map { |n| wrap_node(n) }.compact }
+      when "anchors"
+        # Historically `<a name>` (with a name attribute), not every link.
+        HTMLCollection.new { @nokogiri_doc.css("a[name]").map { |n| wrap_node(n) }.compact }
+      when "styleSheets"
+        # No CSS engine; expose an empty (but present + iterable) StyleSheetList
+        # so `document.styleSheets.length` / iteration don't blow up.
+        NodeList.new
       when "children"
         children
+      when "childNodes"
+        child_nodes
+      when "firstChild"
+        child_nodes.to_a.first
+      when "lastChild"
+        child_nodes.to_a.last
+      when "parentNode", "parentElement", "nextSibling", "previousSibling", "ownerDocument"
+        # A document is the tree root: no parent or siblings, and its
+        # ownerDocument is null per spec.
+        nil
       when "childElementCount"
         child_element_count
       when "firstElementChild"
@@ -439,13 +986,62 @@ module Dommy
         write_title(value.to_s)
       when "cookie"
         self.cookie = value.to_s
+      when "dir"
+        document_element&.set_attribute("dir", value.to_s)
+      when "designMode"
+        # Enumerated: only "on"/"off" (case-insensitive), else ignored.
+        v = value.to_s.downcase
+        @design_mode = v if %w[on off].include?(v)
+      when "location"
+        # `document.location = url` navigates, same as `location.href = url`.
+        loc = @default_view&.__js_get__("location")
+        loc&.__js_set__("href", value)
+      else
+        return Bridge::UNHANDLED
       end
       nil
     end
+    include Bridge::Methods
+    js_methods %w[
+      exitFullscreen startViewTransition createElement createElementNS createTextNode
+      createComment createCDATASection createProcessingInstruction createDocumentFragment querySelector querySelectorAll getElementById
+      getElementsByClassName getElementsByTagName getElementsByTagNameNS getElementsByName createAttribute
+      createAttributeNS createTreeWalker createNodeIterator createRange createEvent importNode
+      adoptNode hasFocus getSelection elementFromPoint queryCommandSupported addEventListener
+      removeEventListener dispatchEvent write writeln open close isEqualNode appendChild
+      hasChildNodes contains append prepend replaceChildren removeChild insertBefore replaceChild
+      cloneNode normalize
+    ]
     def __js_call__(method, args)
       case method
+      when "hasChildNodes"
+        @nokogiri_doc.children.any?
+      when "contains"
+        contains?(args[0])
+      when "isEqualNode"
+        is_equal_node(args[0])
+      when "appendChild"
+        append_child(args[0])
+      when "append"
+        document_insert(args, prepend: false)
+      when "prepend"
+        document_insert(args, prepend: true)
+      when "replaceChildren"
+        document_replace_children(args)
+      when "removeChild"
+        document_remove_child(args[0])
+      when "insertBefore"
+        document_insert_before(args[0], args[1])
+      when "replaceChild"
+        document_replace_child(args[0], args[1])
+      when "cloneNode"
+        clone_node(args[0])
+      when "normalize"
+        nil # the document has no text children to merge
+      when "writeln"
+        write(*(args + ["\n"]))
       when "exitFullscreen"
         exit_fullscreen
       when "startViewTransition"
@@ -468,16 +1064,22 @@ module Dommy
         create_text_node(args[0])
       when "createComment"
         create_comment(args[0])
+      when "createCDATASection"
+        create_cdata_section(args[0])
+      when "createProcessingInstruction"
+        create_processing_instruction(args[0], args[1])
       when "createDocumentFragment"
         create_document_fragment
       when "querySelector"
-        query_selector(args[0])
+        query_selector(Internal.css_query_arg!(args))
       when "querySelectorAll"
-        query_selector_all(args[0])
+        query_selector_all(Internal.css_query_arg!(args))
       when "getElementById"
         get_element_by_id(args[0])
       when "getElementsByClassName"
         get_elements_by_class_name(args[0])
+      when "getElementsByTagNameNS"
+        get_elements_by_tag_name_ns(args[0], args[1])
       when "getElementsByTagName"
         get_elements_by_tag_name(args[0])
       when "getElementsByName"
@@ -487,9 +1089,11 @@ module Dommy
       when "createAttributeNS"
         create_attribute_ns(args[0], args[1])
       when "createTreeWalker"
-        create_tree_walker(args[0], args[1] || NodeFilter::SHOW_ALL, args[2])
+        create_tree_walker(args[0], coerce_what_to_show(args, 1), normalize_filter(args[2]))
       when "createNodeIterator"
-        create_node_iterator(args[0], args[1] || NodeFilter::SHOW_ALL, args[2])
+        create_node_iterator(args[0], coerce_what_to_show(args, 1), normalize_filter(args[2]))
+      when "createRange"
+        create_range
       when "createEvent"
         create_event(args[0])
       when "importNode"
@@ -507,7 +1111,7 @@ module Dommy
       when "addEventListener"
         add_event_listener(args[0], args[1], args[2])
       when "removeEventListener"
-        remove_event_listener(args[0], args[1])
+        remove_event_listener(args[0], args[1], args[2])
       when "dispatchEvent"
         dispatch_event(args[0])
       when "write"
@@ -521,7 +1125,7 @@ module Dommy
       end
     end
-    def __event_parent__
+    def __internal_event_parent__
       @default_view
     end
@@ -533,7 +1137,7 @@ module Dommy
     # Clear the cached wrapper so the next `wrap_node` creates a new
     # one. Used by `customElements.define` to upgrade nodes that were
     # constructed before the registration landed.
-    def __reset_wrapper__(nokogiri_node)
+    def __internal_reset_wrapper__(nokogiri_node)
       @node_wrapper_cache.reset_wrapper(nokogiri_node)
     end
@@ -543,15 +1147,15 @@ module Dommy
     # node back to its shadow boundary.
     # Delegate to ShadowRootRegistry
-    def __register_shadow_fragment__(fragment_node, shadow_root)
+    def __internal_register_shadow_fragment__(fragment_node, shadow_root)
       @shadow_registry.register(fragment_node, shadow_root)
     end
-    def __shadow_root_for_fragment__(fragment_node)
+    def __internal_shadow_root_for_fragment__(fragment_node)
       @shadow_registry.find_for_fragment(fragment_node)
     end
-    def __shadow_root_containing__(node)
+    def __internal_shadow_root_containing__(node)
       @shadow_registry.find_enclosing(node)
     end
@@ -560,23 +1164,23 @@ module Dommy
     # break the whole mutation pipeline.
     # Delegate to MutationCoordinator
-    def __notify_connected__(element)
+    def __internal_notify_connected__(element)
       @mutation_coordinator.notify_connected(element)
     end
-    def __notify_disconnected__(element)
+    def __internal_notify_disconnected__(element)
       @mutation_coordinator.notify_disconnected(element)
     end
-    def __notify_connected_subtree__(nk)
+    def __internal_notify_connected_subtree__(nk)
       @mutation_coordinator.notify_connected_subtree(nk)
     end
-    def __notify_disconnected_subtree__(nk)
+    def __internal_notify_disconnected_subtree__(nk)
       @mutation_coordinator.notify_disconnected_subtree(nk)
     end
-    def __notify_attribute_changed__(element, name, old_value, new_value)
+    def __internal_notify_attribute_changed__(element, name, old_value, new_value)
       @mutation_coordinator.notify_attribute_changed(element, name, old_value, new_value)
     end
@@ -604,11 +1208,43 @@ module Dommy
       )
     end
-    def notify_attribute_mutation(target_node:, attribute_name:, old_value:)
+    # Unlink a backend node from its parent and queue a childList removal record
+    # capturing the node's position (previous/next sibling) BEFORE the unlink, so
+    # the record's previousSibling/nextSibling are correct (the coordinator can't
+    # recover them once the node is detached). Used by every remove path.
+    def remove_node_with_notify(node)
+      parent = node.parent
+      return unless parent
+      prev_w = node.previous_sibling && wrap_node(node.previous_sibling)
+      next_w = node.next_sibling && wrap_node(node.next_sibling)
+      run_node_iterator_pre_remove(node)
+      node.unlink
+      notify_child_list_mutation(
+        target_node: parent,
+        added_nodes: [],
+        removed_nodes: [node],
+        previous_sibling: prev_w,
+        next_sibling: next_w
+      )
+    end
+    # Run the "NodeIterator pre-removing steps" for every live iterator before
+    # `backend_node` is detached, so referenceNode/pointerBeforeReferenceNode
+    # stay valid. `backend_node` must still be attached (tree intact) here.
+    def run_node_iterator_pre_remove(backend_node)
+      return if @node_iterators.empty?
+      removed = wrap_node(backend_node)
+      @node_iterators.each { |iter| iter.pre_remove(removed) }
+    end
+    def notify_attribute_mutation(target_node:, attribute_name:, old_value:, namespace: nil)
       @mutation_coordinator.notify_attribute_mutation(
         target_node: target_node,
         attribute_name: attribute_name,
-        old_value: old_value
+        old_value: old_value,
+        namespace: namespace
       )
     end
@@ -619,11 +1255,6 @@ module Dommy
       )
     end
-    # Spec-permitted name pattern (XML "Name" production restricted to
-    # ASCII for practicality). Used by `createElement` and
-    # `createAttribute` to validate the argument.
-    NAME_RE = /\A[A-Za-z_][\w\-.:]*\z/.freeze
     # Delegate factory methods to NodeWrapperCache
     def create_element(name)
@@ -675,17 +1306,17 @@ module Dommy
     # adoptNode for cross-document transfer.
     def clone_into_doc(source, deep)
       copy = if source.element?
-        new_el = Nokogiri::XML::Node.new(source.name, @nokogiri_doc)
-        source.attribute_nodes.each { |a| new_el[a.name] = a.value }
+        new_el = Backend.create_element(source.name, @nokogiri_doc)
+        Backend.attribute_nodes(source).each { |a| new_el[a.name] = a.value }
         new_el
       elsif source.text?
-        Nokogiri::XML::Text.new(source.content, @nokogiri_doc)
-      elsif source.is_a?(Nokogiri::XML::Comment)
-        Nokogiri::XML::Comment.new(@nokogiri_doc, source.content)
+        Backend.create_text(source.content, @nokogiri_doc)
+      elsif source.is_a?(Backend.comment_class)
+        Backend.create_comment(source.content, @nokogiri_doc)
       else
         # Fallback: serialize + reparse via fragment for unusual types.
         fragment = Parser.fragment(source.to_html, owner_doc: @nokogiri_doc)
-        fragment.children.first || Nokogiri::XML::Text.new("", @nokogiri_doc)
+        fragment.children.first || Backend.create_text("", @nokogiri_doc)
       end
       if deep && source.respond_to?(:children)
@@ -709,12 +1340,12 @@ module Dommy
       title = head.at_css("title")
       unless title
-        title = Nokogiri::XML::Node.new("title", @nokogiri_doc)
+        title = Backend.create_element("title", @nokogiri_doc)
         head.add_child(title)
       end
       title.children.each(&:unlink)
-      title.add_child(Nokogiri::XML::Text.new(value, @nokogiri_doc))
+      title.add_child(Backend.create_text(value, @nokogiri_doc))
     end
   end
@@ -756,6 +1387,8 @@ module Dommy
       end
     end
+    include Bridge::Methods
+    js_methods %w[skipTransition]
     def __js_call__(method, _args)
       case method
       when "skipTransition"