dommy 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2b9f635d1029acc7e1340657ba8440f4c4df5623e386389cd36718ef4dec95f
-  data.tar.gz: 4b1d5aa007bf64ef0b2fdc20353d7511c4d74fec8ce54eb692a295dabfe28f05
+  metadata.gz: ab840b2c863131b5f20d7be40f28028bec227fb490688b4b0f26157058c0ea68
+  data.tar.gz: a87acf4824167a08eae696de0ffe504cdf808d9085176e084b3e4f3d225e5c7a
 SHA512:
-  metadata.gz: fcf29d56432325690f2dd4f8ede45bd4f87daa439c26b0a040a08d4c1263383b073e9e5879b4451c36b30cf97921753dc43a5197685d120e3468fb02c64d1705
-  data.tar.gz: 888bd534c0f1d4e53ebf4d875ed52d7fcf329efb410fa8ed9482caf772504fbe5a90d323bf568fce85c95456d3fe1e61e3f5cc49172e41a145fa8d477cffa2ab
+  metadata.gz: db29082c6b8b686eb762aa53f3ae213b40da69210732c99a53f15a1f18318a326fd6bcf4c65fcfa4abc27dc41bebff0b16164682b7d18e7fed7a44415a9bb7e6
+  data.tar.gz: 71669401a09832106ec301e0b2d4747fb7782b2ac2514fbf4cfbf625358695f0c498561cbd3efb565b7b2abbaf43b4b2068dbe5f1831523a74ec25dc2c2e1435

data/README.md

@@ -1,6 +1,6 @@
 # Dommy
 
-Dommy is a pure Ruby DOM polyfill built on [Nokogiri::HTML5](https://nokogiri.org/), inspired by happy-dom and jsdom.
+Dommy is a pure Ruby DOM polyfill built on [Makiri](https://github.com/takahashim/makiri), inspired by happy-dom and jsdom.
 It gives Ruby tests a browser style DOM with events, MutationObserver, Custom Elements, Shadow DOM, the File API, timers, and Storage, without requiring a real browser.
 
 ## Quick start
@@ -170,8 +170,8 @@ end
 
 Supported Capybara-style options: `text:` / `exact:` / `count:` (Integer or Range) / `visible:` / `href:` / `with:` / `type:`. `wait:` is accepted and ignored (Dommy is synchronous).
 
-> [!CAUTION]
-> `:visible` is HTML-level only. Dommy has no CSS engine, so `display: none` set via a CSS class is **not** detected. Detection covers the `hidden` attribute, `<input type=hidden>`, non-rendering ancestors (`head`/`script`/`style`/`template`), and inline `style="display: none"` / `visibility: hidden`. If you toggle visibility through a CSS class, assert on the class instead (`have_dom_class("hidden")`) or keep that spec on Capybara + a real browser.
+> [!NOTE]
+> `:visible` understands CSS stylesheets when the `makiri` gem is available (its bundled lexbor provides the CSS parser — the default backend already is makiri): `display: none` / `visibility: hidden` / `opacity: 0` set via a class in a `<style>` sheet is detected, on the element or an ancestor, alongside the HTML-level signals (`hidden` attribute, `<input type=hidden>`, non-rendering ancestors, inline styles). There is still **no layout engine**: geometry-dependent invisibility (zero size, off-screen, overlap) and media-query-conditional rules are not evaluated, and `getComputedStyle` returns computed (not used) values — `width: auto` stays `"auto"`. Without makiri, detection falls back to the HTML-level signals only.
 
 ## What's in scope
 

data/lib/dommy/animation.rb

@@ -45,6 +45,8 @@ module Dommy
       case key
       when "target"
         @target
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -206,6 +208,8 @@ module Dommy
         ready
       when "id"
         @id
+      else
+        Bridge::ABSENT
       end
     end
 

data/lib/dommy/attr.rb

@@ -8,7 +8,7 @@ module Dommy
   #
   # We represent two states:
   #   - "owned" — the Attr is attached to an Element. value reads/writes
-  #     go through the element's Nokogiri attribute slot.
+  #     go through the element's Makiri attribute slot.
   #   - "detached" — created via `document.createAttribute(name)` but
   #     not yet attached. Value is stored locally; `setAttributeNode`
   #     transfers it to an element.
@@ -33,11 +33,15 @@ module Dommy
         @prefix = prefix
         @local_name = (local_name || qname.split(":", 2).last).to_s
       else
-        # Null-namespace (HTML) attributes are lower-cased, as before.
-        @name = qname.downcase
+        # Null-namespace attribute: use the qualified name verbatim. The casing is
+        # already decided by the caller — the backend stores `setAttribute` names
+        # lower-cased (HTML) but preserves `setAttributeNS("", "FOO")` as "FOO",
+        # and `createAttribute` lower-cases up front — so re-downcasing here would
+        # wrongly fold a case-preserved null-namespace attribute.
+        @name = qname
         @namespace_uri = nil
         @prefix = nil
-        @local_name = @name
+        @local_name = local_name ? local_name.to_s : @name
       end
     end
 
@@ -96,6 +100,8 @@ module Dommy
       when "specified"
         # Legacy/useless attribute — always true (WHATWG DOM).
         true
+      else
+        Bridge::ABSENT
       end
     end
 
@@ -162,7 +168,7 @@ module Dommy
   # `.getNamedItem(name)`, `.removeNamedItem(name)`, `.setNamedItem(attr)`,
   # plus property-style access (`attributes.id`, `attributes.class`).
   #
-  # NamedNodeMap is *live* — it re-reads the element's Nokogiri
+  # NamedNodeMap is *live* — it re-reads the element's Makiri
   # attributes on every access so DOM mutations are reflected.
   class NamedNodeMap
     include Enumerable

data/lib/dommy/backend/makiri_adapter.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "makiri"
+
+module Dommy
+  module Backend
+    # Makiri (Lexbor-based) backend. HTML5 parsing and CSS selectors via
+    # Lexbor, plus a native XPath 1.0 engine, with no libxml2 dependency.
+    # Makiri splits its document model into `Makiri::HTML::Document` (case-folding,
+    # html/head/body) and `Makiri::XML::Document` (case-preserving, namespaces,
+    # CDATA); both share the `Makiri::Document` / `Makiri::Node` bases used here
+    # for `is_a?` checks. HTML parses go through HTML::Document; `new Document()` /
+    # createDocument go through XML::Document.
+    module Makiri
+      # Class references for `is_a?` / type-checking (the shared bases, so both
+      # HTML and XML node subclasses match).
+      Element = ::Makiri::Element
+      Document = ::Makiri::Document
+      Text = ::Makiri::Text
+      Comment = ::Makiri::Comment
+      CDATASection = ::Makiri::CDATASection
+      ProcessingInstruction = ::Makiri::ProcessingInstruction
+      DocumentFragment = ::Makiri::DocumentFragment
+      Node = ::Makiri::Node
+
+      # A minimal namespace wrapper exposing the same `href` API that Nokogiri's
+      # Namespace object has, so calling code treats both backends uniformly.
+      Namespace = Struct.new(:href)
+
+      HTML_NAMESPACE_URI = "http://www.w3.org/1999/xhtml"
+
+      # Throwaway attribute used to bind `:scope` to a context element — Lexbor
+      # has no `:scope`, so a scoped query temporarily marks the element and
+      # rewrites `:scope` to an attribute selector, removing the mark after.
+      SCOPE_ATTR = "data-dommy-scope"
+
+      module_function
+
+      # Makiri clones natively (import_node + template fixup), preserving the
+      # node's namespace and attributes and carrying <template> contents.
+      def clone_node(node, deep:)
+        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
+        doc = ::Makiri::HTML::Document.parse("")
+        doc.children.to_a.each(&:unlink)
+        doc
+      end
+
+      # A fresh, empty XML-backed document — the backing for `new Document()` /
+      # createDocument, which the DOM defines as XML documents. An XML backing
+      # gives them case preservation, real CDATA nodes (nodeType 4) and namespace
+      # tracking. Makiri's cross-kind `import_node` translates between the HTML and
+      # XML node representations, so a node created here can still be adopted into
+      # the main HTML tree (and vice versa) — which is why an XML backing no longer
+      # blocks the cross-tree inserts WPT performs.
+      def empty_xml_document
+        ::Makiri::XML::Document.new
+      end
+
+      # An empty document matching `doc`'s kind, for a shallow document clone
+      # (cloneNode(false) on a document must keep the same flavor).
+      def empty_document_like(doc)
+        doc.is_a?(::Makiri::XML::Document) ? empty_xml_document : empty_document
+      end
+
+      # Lexbor seeds even an empty parse with an <html> shell and has no `root=`,
+      # so clear the existing children before adopting `node` as the root.
+      def set_document_root(doc, node)
+        doc.children.to_a.each(&:unlink)
+        doc.add_child(node)
+      end
+
+      # Makiri can't move a node between document arenas, so adoption imports a
+      # detached copy owned by `target_doc`. The caller reseats the wrapper onto
+      # this returned node, preserving Dommy-level identity.
+      #
+      # Gap absorption: Lexbor's HTML serializer has no CDATA case (it errors on a
+      # CDATA node) and Lexbor is a pinned upstream submodule, so Makiri's
+      # cross-kind import_node fails closed when bringing an XML CDATASection into
+      # an HTML document. Rather than let that surface as an error, degrade the
+      # node to a text node carrying the same data — the data a spec-faithful HTML
+      # serializer emits anyway (CDATASection is a Text subtype). The caller
+      # reseats the Dommy CDATASection wrapper onto this node, so `nodeType`
+      # stays 4 at the DOM level; only the backing node (and thus serialization)
+      # is text. An XML target keeps a real CDATA node. This handles a directly
+      # adopted CDATA node (a CDATA descendant inside an adopted element subtree
+      # is rare, untested, and still fails closed in the backend).
+      def adopt(node, target_doc)
+        if node.is_a?(::Makiri::CDATASection) && !target_doc.is_a?(::Makiri::XML::Document)
+          return target_doc.create_text_node(node.text)
+        end
+
+        target_doc.import_node(node, true)
+      end
+
+      # Lexbor arenas can't move a node between documents — a foreign node must be
+      # imported (see #adopt) before insertion.
+      def moves_nodes_across_documents?
+        false
+      end
+
+      # CSS query honoring Dommy's custom pseudo-classes. Lexbor handles
+      # `:disabled`/`:enabled`/`:checked` natively, so only `:scope` needs help:
+      # when `scope_node` is given and the selector uses `:scope`, bind it to
+      # that element via a temporary attribute.
+      def select_all(node, selector, scope_node: nil)
+        with_scope(selector, scope_node) { |sel| node.css(sel) }
+      end
+
+      def select_first(node, selector, scope_node: nil)
+        with_scope(selector, scope_node) { |sel| node.at_css(sel) }
+      end
+
+      def with_scope(selector, scope_node)
+        return yield(selector) unless scope_node && selector.include?(":scope")
+
+        scope_node[SCOPE_ATTR] = ""
+        begin
+          yield(selector.gsub(":scope", "[#{SCOPE_ATTR}]"))
+        ensure
+          scope_node.remove_attribute(SCOPE_ATTR)
+        end
+      end
+
+      # Makiri hands out a fresh Ruby wrapper on each traversal, so object_id is
+      # not stable; pointer_id (the underlying lxb_dom_node_t pointer) is. Safe
+      # as an identity key because Makiri detaches but never frees nodes — the
+      # document arena owns them — so a live node's pointer is never recycled.
+      def identity_key(node)
+        node.pointer_id
+      end
+
+      def parse(html)
+        ::Makiri::HTML::Document.parse(html.to_s)
+      end
+
+      # XML parse (DOMParser `text/xml` / `application/xml`): a real XML document,
+      # so element/attribute case is preserved, namespaces are tracked, and CDATA
+      # round-trips. The parsed tree is self-contained (not mixed into the HTML
+      # tree), so the HTML/XML node-kind split doesn't bite here.
+      def parse_xml(xml)
+        ::Makiri::XML::Document.parse(xml.to_s)
+      end
+
+      def fragment(html, owner_doc:)
+        ::Makiri::DocumentFragment.parse(html.to_s)
+      end
+
+      def create_element(name, doc)
+        # Mint from the owning document so HTML docs lower-case the name and XML
+        # docs preserve its case.
+        doc.create_element(name)
+      end
+
+      def create_text(content, doc)
+        doc.create_text_node(content)
+      end
+
+      def create_comment(content, doc)
+        doc.create_comment(content)
+      end
+
+      # CDATASection (nodeType 4). A genuine XML document — including a
+      # `new Document()` / createDocument document, now XML-backed (see
+      # #empty_xml_document) — mints a real CDATA node and the XML serializer emits
+      # `<![CDATA[…]]>`. `Document#create_cdata_section` rejects HTML documents up
+      # front (NotSupportedError, per spec), so the text-node fallback below is a
+      # defensive guard for any non-XML backend that still slips through (Lexbor's
+      # HTML serializer raises on a native CDATA node, so a text node keeps
+      # serialization safe).
+      def create_cdata(content, doc)
+        if doc.is_a?(::Makiri::XML::Document)
+          doc.create_cdata(content)
+        else
+          doc.create_text_node(content)
+        end
+      end
+
+      # The backend class for a CDATA node, so the wrapper routes it to
+      # CDATASectionNode (it is a Text subtype, matched before Text).
+      def cdata_class
+        ::Makiri::CDATASection
+      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.
+      def create_processing_instruction(target, data, doc)
+        doc.create_processing_instruction(target, data)
+      end
+
+      def processing_instruction_class
+        ::Makiri::ProcessingInstruction
+      end
+
+      # Makiri doesn't track XML namespaces. We synthesize one for SVG by
+      # walking ancestors — necessary so `element_class_for` routes SVG
+      # tags to their specialized classes.
+      # The element's namespace, from Lexbor's own namespace tracking (HTML /
+      # SVG / MathML). nil for the HTML namespace, so Element#namespace_uri
+      # falls back to its HTML default (and the wrapper is allocated only for
+      # genuine foreign content).
+      def namespace_of(node)
+        return nil unless node.respond_to?(:namespace_uri)
+
+        uri = node.namespace_uri
+        return nil if uri.nil? || uri.empty? || uri == HTML_NAMESPACE_URI
+
+        Namespace.new(uri)
+      end
+
+      # Bind a *prefixed* element's namespace so the prefix resolves. An XML
+      # document resolves an element's prefix from xmlns declarations at insertion
+      # time, so a prefixed element (createElementNS / createDocument with a
+      # qualified name like "foo:div") must carry an xmlns:prefix declaration or
+      # the insert fails with an unbound-prefix error. The namespaceURI itself is
+      # tracked on the Dommy wrapper, so the unprefixed case needs nothing here —
+      # and must add no attribute, lest a spurious xmlns surface in the DOM view
+      # (attributes/isEqualNode). An HTML (Lexbor) document tracks the namespace
+      # natively and needs no declaration either. (This was a blanket no-op back
+      # when new Document()/createDocument were HTML-backed; XML-backing them
+      # surfaced the prefixed-element gap.)
+      def add_namespace_definition(node, prefix, href)
+        return if prefix.nil? || prefix.empty?
+        return unless node.document.is_a?(::Makiri::XML::Document)
+
+        node["xmlns:#{prefix}"] = href.to_s
+        nil
+      end
+
+      def namespace_definitions(_node)
+        # Makiri tracks no XML namespace declarations.
+        []
+      end
+
+      # Lexbor keeps <template> contents in a separate content fragment rather
+      # than the normal child chain.
+      def template_content_nodes(node)
+        cf = node.respond_to?(:content_fragment) ? node.content_fragment : nil
+        cf ? cf.children.to_a : []
+      end
+
+      # ----- Namespaced attributes -----
+      # Lexbor (Makiri >= 0.2) tracks the attribute's own namespace: set_attribute_ns
+      # records it (splitting prefix/local), and the attr node reports
+      # namespace_uri/prefix/local_name. So *AttributeNS matches on (namespace,
+      # local name) faithfully.
+
+      def get_attribute_ns(node, namespace, local_name)
+        attr_by_ns(node, namespace, local_name)&.value
+      end
+
+      def has_attribute_ns?(node, namespace, local_name)
+        !attr_by_ns(node, namespace, local_name).nil?
+      end
+
+      def set_attribute_ns(node, namespace, _prefix, _local_name, qualified_name, value)
+        node.set_attribute_ns(presence(namespace), qualified_name.to_s, value.to_s)
+        value.to_s
+      end
+
+      def remove_attribute_ns(node, namespace, local_name)
+        # Remove by (namespace, local name) — removing by qualified name is
+        # ambiguous once same-name/different-namespace attributes coexist.
+        node.remove_attribute_ns(presence(namespace), local_name.to_s)
+        nil
+      end
+
+      def attribute_ns_info(attr_node)
+        {
+          namespace_uri: presence(attr_node.namespace_uri),
+          prefix: presence(attr_node.prefix),
+          local_name: attr_node.local_name,
+          qualified_name: attr_node.name,
+          value: attr_node.value,
+        }
+      end
+
+      def attribute_nodes(node)
+        node.attribute_nodes
+      end
+
+      # Attribute node matching (namespace, local name) case-sensitively; a
+      # null/empty namespace matches a null-namespace attribute.
+      def attr_by_ns(node, namespace, local_name)
+        want_ns = presence(namespace)
+        want_local = local_name.to_s
+        node.attribute_nodes.find do |a|
+          a.local_name == want_local && presence(a.namespace_uri) == want_ns
+        end
+      end
+
+      def presence(value)
+        return nil if value.nil?
+
+        s = value.to_s
+        s.empty? ? nil : s
+      end
+
+      # Internal helper — visible to allow testing.
+      def in_svg_subtree?(node)
+        return true if node.name.to_s.downcase == "svg"
+
+        current = node.parent
+        while current
+          return true if current.respond_to?(:name) && current.name.to_s.downcase == "svg"
+          current = current.respond_to?(:parent) ? current.parent : nil
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/dommy/backend.rb

@@ -2,24 +2,23 @@
 
 module Dommy
   # `Dommy::Backend` — pluggable HTML parser abstraction. Lets Dommy
-  # work with either Nokogiri (mature, full namespace support) or
-  # Nokolexbor (faster, HTML5-only). Internally, all DOM library
+  # work with Makiri (Lexbor-based, HTML5-only). Internally, all DOM library
   # code goes through this facade rather than referencing the parser
   # directly.
   #
-  # Defaults to Nokogiri if available, else Nokolexbor.
+  # Defaults to Makiri.
   #
   # Switching backends:
   #
   #   require "dommy"
-  #   Dommy::Backend.use(:nokolexbor)
+  #   Dommy::Backend.use(:makiri)
   #
   # Or set directly:
   #
-  #   Dommy::Backend.current = Dommy::Backend::Nokolexbor
+  #   Dommy::Backend.current = Dommy::Backend::Makiri
   #
   # All adapters must implement the same interface — see
-  # `Backend::Nokogiri` for the canonical reference.
+  # `Backend::Makiri` for the canonical reference.
   module Backend
     class BackendNotAvailable < StandardError
     end
@@ -33,32 +32,100 @@ module Dommy
 
       def use(name)
         @current = case name.to_sym
-        when :nokogiri
-          require_relative "backend/nokogiri_adapter"
-          Nokogiri
-        when :nokolexbor
-          require_relative "backend/nokolexbor_adapter"
-          Nokolexbor
+        when :makiri
+          require_relative "backend/makiri_adapter"
+          Makiri
         else
-          raise ArgumentError, "Unknown backend: #{name.inspect}. Use :nokogiri or :nokolexbor."
+          raise ArgumentError, "Unknown backend: #{name.inspect}. Use :makiri."
         end
       end
 
+      # Stable per-document identity key for a backend node, used to cache DOM
+      # wrappers and key per-node side tables. Makiri mints a fresh wrapper per traversal
+      # but never frees nodes (arena-owned), so it keys on the stable node pointer.
+      def identity_key(node)
+        current.identity_key(node)
+      end
+
+      # Deep (or shallow) copy of an element/node, detached and owned by the
+      # same document — the backing for DOM cloneNode.
+      def clone_node(node, deep:)
+        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
+      end
+
+      # A fresh, empty XML-backed document — for `new Document()` / createDocument,
+      # which the DOM defines as XML documents (case-preserving, real CDATA
+      # nodeType, namespaces).
+      def empty_xml_document
+        current.empty_xml_document
+      end
+
+      # An empty backing document matching `doc`'s kind (HTML stays HTML, XML stays
+      # XML) — for a shallow document clone, whose result keeps the source flavor.
+      def empty_document_like(doc)
+        current.empty_document_like(doc)
+      end
+
+      # Bring `node` (already detached from its old tree) into `target_doc`,
+      # returning the backend node now owned by `target_doc`. Makiri can't move a node
+      # between arenas, so it imports a copy — callers must reseat any wrapper
+      # onto the returned node.
+      def adopt(node, target_doc)
+        current.adopt(node, target_doc)
+      end
+
+      # Whether the backend can move a node between documents in place or must adopt a copy first
+      # (Lexbor's arenas can't move a node, so inserting a foreign node requires importing
+      # it). Lets callers skip a needless — and on an empty target, root-less and
+      # therefore crashing — adoption on backends that don't need it.
+      def moves_nodes_across_documents?
+        current.respond_to?(:moves_nodes_across_documents?) ? current.moves_nodes_across_documents? : true
+      end
+
+      # CSS query that honors Dommy's custom pseudo-classes
+      # (`:disabled`/`:enabled`/`:checked`/`:scope`). Each backend applies its
+      # own mechanism (Lexbor native pseudos plus a
+      # `:scope` rewrite). `scope_node` binds `:scope` to that element.
+      def select_all(node, selector, scope_node: nil)
+        current.select_all(node, selector, scope_node: scope_node)
+      end
+
+      def select_first(node, selector, scope_node: nil)
+        current.select_first(node, selector, scope_node: scope_node)
+      end
+
       # Delegate calls so internal code can use `Backend.parse(...)`.
       def parse(html)
         current.parse(html)
       end
 
-      # Parse XML input into an XML document. Backends without a real XML parser
-      # (HTML-only, e.g. Nokolexbor) fall back to the HTML parser.
+      # Parse XML input into an XML document.
+      # fall back to the HTML parser.
       def parse_xml(xml)
-        current.respond_to?(:parse_xml) ? current.parse_xml(xml) : current.parse(xml)
+        current.parse_xml(xml)
       end
 
       def fragment(html, owner_doc:)
         current.fragment(html, owner_doc: owner_doc)
       end
 
+      # Make `node` the sole document element of `doc` (used by
+      # DOMImplementation.createDocument). Lexbor-backed documents are seeded with an <html> shell
+      # that must be cleared first.
+      def set_document_root(doc, node)
+        current.set_document_root(doc, node)
+      end
+
       def create_element(name, doc)
         current.create_element(name, doc)
       end
@@ -81,16 +148,40 @@ module Dommy
         current.respond_to?(:cdata_class) ? current.cdata_class : nil
       end
 
+      # ProcessingInstruction node (`<?target data?>`). Supported by every
+      # backend Dommy ships (both Makiri document families), so — unlike CDATA —
+      # there is no text-node fallback.
+      def create_processing_instruction(target, data, doc)
+        current.create_processing_instruction(target, data, doc)
+      end
+
+      def processing_instruction_class
+        current.processing_instruction_class
+      end
+
       def namespace_of(node)
         current.namespace_of(node)
       end
 
+      # The element's in-scope namespace declarations (each responds to
+      # `prefix`/`href`). Empty on backends without an XML namespace model.
+      def namespace_definitions(node)
+        current.namespace_definitions(node)
+      end
+
+      # The content child nodes of a `<template>` element. HTML5 parsers model
+      # template contents differently — Lexbor/Makiri in a separate content fragment — so reading them goes
+      # through the backend. Used by the template-content registry's migration.
+      def template_content_nodes(node)
+        current.template_content_nodes(node)
+      end
+
       def add_namespace_definition(node, prefix, href)
         current.add_namespace_definition(node, prefix, href)
       end
 
       # Namespaced attribute access (DOM *AttributeNS). `namespace` is an href
-      # String or nil. Nokolexbor degrades to qualified-name (null-namespace).
+      # String or nil.
       def get_attribute_ns(node, namespace, local_name)
         current.get_attribute_ns(node, namespace, local_name)
       end
@@ -148,25 +239,15 @@ module Dommy
       private
 
       def detect_default
-        try_nokogiri ||
-          try_nokolexbor ||
-          raise(BackendNotAvailable, "Dommy requires either 'nokogiri' or 'nokolexbor' gem to be installed.")
-      end
-
-      def try_nokogiri
-        require "nokogiri"
-
-        require_relative "backend/nokogiri_adapter"
-        Nokogiri
-      rescue LoadError
-        nil
+        try_makiri ||
+          raise(BackendNotAvailable, "Dommy requires either 'makiri' gem to be installed.")
       end
 
-      def try_nokolexbor
-        require "nokolexbor"
+      def try_makiri
+        require "makiri"
 
-        require_relative "backend/nokolexbor_adapter"
-        Nokolexbor
+        require_relative "backend/makiri_adapter"
+        Makiri
       rescue LoadError
         nil
       end

data/lib/dommy/blob.rb

@@ -63,6 +63,8 @@ module Dommy
         @size
       when "type"
         @type
+      else
+        Bridge::ABSENT
       end
     end
 

data/lib/dommy/bridge.rb

@@ -37,6 +37,17 @@ module Dommy
     def UNDEFINED.inspect = "#<Dommy::Bridge::UNDEFINED>"
     UNDEFINED.freeze
 
+    # The sentinel a `__js_get__` returns for a GENUINELY-ABSENT property (a key
+    # the object does not have), as distinct from a present property whose value
+    # is `nil`/JS null or `UNDEFINED`/JS undefined. It marshals to JS `undefined`
+    # for the value, but the proxy reports `("x" in obj) === false` for it — so
+    # feature detection like `isUndefined(window.Vue)` AND `"Vue" in window` are
+    # both correct. (UNDEFINED means present-but-undefined → reported present.)
+    ABSENT = Object.new
+    def ABSENT.to_s = "undefined"
+    def ABSENT.inspect = "#<Dommy::Bridge::ABSENT>"
+    ABSENT.freeze
+
     # An opaque handle to a JS-side value that Ruby only stores and hands back
     # (an AbortSignal's reason, a CustomEvent's detail). A non-plain JS object
     # (Error, class instance, …) crosses as one of these instead of being