Specs: handle (in the parser) the case of an element constructor being

sky/specs/dom.md

 Sky DOM APIs
 ============
 
 ```javascript
 
 // DOM
 
 typedef ChildNode (Element or Text);
 typedef ChildArgument (Element or Text or String);
 
@@ skipping 59 matching lines @@
   readonly attribute String tagName; // O(1)
 
   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
+  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);
@@ skipping 191 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
 }
 ```