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

dommy 0.7.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 (69) hide show

checksums.yaml +4 -4
data/lib/dommy/animation.rb +9 -1
data/lib/dommy/attr.rb +192 -39
data/lib/dommy/backend/nokogiri_adapter.rb +76 -0
data/lib/dommy/backend/nokolexbor_adapter.rb +37 -0
data/lib/dommy/backend.rb +46 -0
data/lib/dommy/blob.rb +28 -9
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/cookie_store.rb +3 -1
data/lib/dommy/crypto.rb +7 -1
data/lib/dommy/css.rb +46 -0
data/lib/dommy/custom_elements.rb +27 -3
data/lib/dommy/data_transfer.rb +4 -0
data/lib/dommy/document.rb +615 -48
data/lib/dommy/dom_parser.rb +28 -15
data/lib/dommy/element.rb +999 -471
data/lib/dommy/event.rb +260 -96
data/lib/dommy/event_source.rb +6 -2
data/lib/dommy/fetch.rb +505 -43
data/lib/dommy/file_reader.rb +11 -3
data/lib/dommy/form_data.rb +2 -0
data/lib/dommy/history.rb +43 -8
data/lib/dommy/html_collection.rb +55 -2
data/lib/dommy/html_elements.rb +102 -1519
data/lib/dommy/internal/css_pseudo_handlers.rb +109 -0
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_wrapper_cache.rb +62 -27
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/url_parser.rb +677 -0
data/lib/dommy/intersection_observer.rb +2 -0
data/lib/dommy/location.rb +2 -0
data/lib/dommy/media_query_list.rb +7 -1
data/lib/dommy/message_channel.rb +32 -2
data/lib/dommy/mutation_observer.rb +55 -12
data/lib/dommy/navigator.rb +26 -12
data/lib/dommy/node.rb +158 -28
data/lib/dommy/notification.rb +3 -1
data/lib/dommy/performance.rb +4 -0
data/lib/dommy/performance_observer.rb +2 -0
data/lib/dommy/promise.rb +14 -14
data/lib/dommy/range.rb +74 -5
data/lib/dommy/resize_observer.rb +2 -0
data/lib/dommy/scheduler.rb +34 -13
data/lib/dommy/shadow_root.rb +23 -54
data/lib/dommy/storage.rb +2 -0
data/lib/dommy/streams.rb +18 -27
data/lib/dommy/svg_elements.rb +204 -3606
data/lib/dommy/text_codec.rb +174 -21
data/lib/dommy/tree_walker.rb +255 -66
data/lib/dommy/url.rb +287 -449
data/lib/dommy/url_pattern.rb +2 -0
data/lib/dommy/version.rb +1 -1
data/lib/dommy/web_socket.rb +37 -7
data/lib/dommy/window.rb +202 -213
data/lib/dommy/worker.rb +7 -7
data/lib/dommy/xml_http_request.rb +15 -5
data/lib/dommy.rb +7 -0
metadata +12 -3

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,7 +304,7 @@ 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.
@@ -59,12 +319,33 @@ module Dommy
       @cookie_jar = Internal::CookieJar.new
       @template_content_registry = Internal::TemplateContentRegistry.new(self)
       @mutation_coordinator = Internal::MutationCoordinator.new(self, @observer_manager)
+      @node_iterators = []
       @nokogiri_doc = nokogiri_doc || Backend.parse("<!doctype html><html><head></head><body></body></html>")
-      body_node = @nokogiri_doc.at_css("body")
-      @body = wrap_node(body_node) if body_node
       @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) -----
     def title
@@ -76,13 +357,23 @@ 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
@@ -185,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
@@ -200,7 +500,18 @@ 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 __internal_set_active_element__(el)
@@ -226,6 +537,25 @@ 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.
@@ -340,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.
@@ -348,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
@@ -374,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.
@@ -382,8 +827,9 @@ module Dommy
       fragment = Parser.fragment(html, owner_doc: @nokogiri_doc)
       removed = []
       added = fragment.children.to_a
-      added.each { |node| @body.__dommy_backend_node__.add_child(node) }
-      notify_child_list_mutation(target_node: @body.__dommy_backend_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
@@ -411,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
@@ -422,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"
@@ -436,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"
@@ -455,6 +908,33 @@ module Dommy
         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"
@@ -465,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"
@@ -486,26 +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
-    # Methods routed through __js_call__ (keep in sync with its when-arms).
-    JS_METHOD_NAMES = %w[
+    include Bridge::Methods
+    js_methods %w[
       exitFullscreen startViewTransition createElement createElementNS createTextNode
-      createComment createDocumentFragment querySelector querySelectorAll getElementById
-      getElementsByClassName getElementsByTagName getElementsByName createAttribute
-      createAttributeNS createTreeWalker createNodeIterator createEvent importNode adoptNode
-      hasFocus getSelection elementFromPoint queryCommandSupported addEventListener
-      removeEventListener dispatchEvent write open close
-    ].freeze
-    def __js_method_names__
-      JS_METHOD_NAMES
-    end
+      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"
@@ -528,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"
@@ -547,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"
@@ -567,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"
@@ -664,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
@@ -679,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)
@@ -736,7 +1307,7 @@ module Dommy
     def clone_into_doc(source, deep)
       copy = if source.element?
         new_el = Backend.create_element(source.name, @nokogiri_doc)
-        source.attribute_nodes.each { |a| new_el[a.name] = a.value }
+        Backend.attribute_nodes(source).each { |a| new_el[a.name] = a.value }
         new_el
       elsif source.text?
         Backend.create_text(source.content, @nokogiri_doc)
@@ -816,12 +1387,8 @@ module Dommy
       end
     end
-    # Methods routed through __js_call__ (keep in sync with its when-arms).
-    JS_METHOD_NAMES = %w[skipTransition].freeze
-    def __js_method_names__
-      JS_METHOD_NAMES
-    end
+    include Bridge::Methods
+    js_methods %w[skipTransition]
     def __js_call__(method, _args)
       case method
       when "skipTransition"