Specs: Text nodes can also be distributed, so getDestinationInsertionPoints() needs to be on Node, …

sky/specs/dom.md

 Sky DOM APIs
 ============
 
 ```javascript
 
 // DOM
 
 typedef ChildNode (Element or Text);
 typedef ChildArgument (Element or Text or String);
 
@@ skipping 13 matching lines @@
   void insertAfter(ChildArgument... nodes); // O(N) in number of arguments plus all their descendants
   void replaceWith(ChildArgument... nodes); // O(N) in number of descendants plus arguments plus all their descendants
   void remove(); // O(N) in number of descendants
   Node cloneNode(Boolean deep = false); // O(1) if deep=false, O(N) in the number of descendants if deep=true
 
   // called when parentNode changes
   virtual void parentChangeCallback(ParentNode? oldParent, ParentNode? newParent, ChildNode? previousSibling, ChildNode? nextSibling); // O(N) in descendants (calls attached/detached)
   virtual void attachedCallback(); // noop
   virtual void detachedCallback(); // noop
 
+  Array<ContentElement> getDestinationInsertionPoints(); // O(N) in number of insertion points the node is in
+    // returns the <content> elements to which this element was distributed
+
   readonly attribute ElementStyleDeclarationList? style; // O(1)
     // for nodes that aren't reachable from the Application Document, returns null
     // (so in particular orphaned subtrees and nodes in module documents don't have one)
     //  -- should be updated when the node's parent chain changes (same time as, e.g.,
     //     the id hashtable is updated)
     // also always returns null for ContentElement elements and ShadowRoot nodes
   readonly attribute RenderNode? renderNode; // O(1)
     // this will be null until the first time it is rendered
     // it becomes null again when it is taken out of the rendering (see style.md)
   abstract virtual LayoutManagerConstructor getLayoutManager(); // O(1)
@@ skipping 27 matching lines @@
 
   Boolean hasAttribute(String name); // O(N) in number of attributes
   String getAttribute(String name); // O(N) in number of attributes
   void setAttribute(String name, String value = ''); // O(N) in number of attributes
   void removeAttribute(String name); // O(N) in number of attributes
 
   // Returns a new Array and new Attr instances every time.
   Array<Attr> getAttributes(); // O(N) in number of attributes
 
   readonly attribute ShadowRoot? shadowRoot; // O(1) // returns the shadow root // TODO(ianh): Should this be mutable? It would help explain how it gets set...
-  Array<ContentElement> getDestinationInsertionPoints(); // O(N) in number of insertion points the node is in
 
   virtual void endTagParsedCallback(); // noop
   virtual void attributeChangeCallback(String name, String? oldValue, String? newValue); // noop
   // TODO(ianh): does a node ever need to know when it's been redistributed?
 
   virtual LayoutManagerConstructor getLayoutManager(); // O(1)
     // default implementation looks up the 'display' property and returns the value:
     //   if (renderNode)
     //     return renderNode.getProperty(phDisplay);
     //   return null;
@@ skipping 190 matching lines @@
 
   Boolean matches(Element element); // O(F())
   Element? find(Element root); // O(N*F())+O(M) where N is the number of descendants and M the average depth of the tree
   Element? find(DocumentFragment root); // O(N*F())+O(M) where N is the number of descendants and M the average depth of the tree
   Element? find(TreeScope root); // O(N*F()) where N is the number of descendants
   Array<Element> findAll(Element root); // O(N*F())+O(N*M) where N is the number of descendants and M the average depth of the tree
   Array<Element> findAll(DocumentFragment root); // O(N*F())+O(N*M) where N is the number of descendants and M the average depth of the tree
   Array<Element> findAll(TreeScope root); // O(N*F()) where N is the number of descendants
 }
 ```