Specs: add TODO for renaming insertBefore; rename appendSingle()

sky/specs/elements.md

 Sky DOM APIs
 ============
 
 ```dart
 SKY MODULE
 <!-- part of sky:core -->
 
 <script>
 // ELEMENT TREE API
 
 abstract class Node extends EventTarget {
   @override
   external List<EventTarget> getEventDispatchChain(); // O(N) in number of ancestors across shadow trees
   // implements EventTarget.getEventDispatchChain()
   // returns the event dispatch chain (including handling shadow trees)
 
   external Root get owner; // O(1)
 
   external ParentNode get parentNode; // O(1)
   external Element get parentElement; // O(1) // if parentNode isn't an element, returns null
   external Node get previousSibling; // O(1)
   external Node get nextSibling; // O(1)
 
   // the following all throw if parentNode is null
   external void insertBefore(List nodes); // O(N) in number of arguments plus all their descendants
   external void insertAfter(List nodes); // O(N) in number of arguments plus all their descendants
+  // TODO(ianh): rename insertBefore() and insertAfter() since the Web has an insertBefore() that means
+  // something else. What's a good name, though?
   external void replaceWith(List nodes); // O(N) in number of descendants plus arguments plus all their descendants
   // nodes must be String, Text, or Element
 
   external void remove(); // O(N) in number of descendants
 
   // called when parentNode changes
   // this is why insertBefore(), append(), et al, are O(N) -- the whole affected subtree is walked
   // mutating the element tree from within this is strongly discouraged, since it will result in the
   // callbacks being invoked while the element tree is in a different state than implied by the callbacks
   external void parentChangeCallback(ParentNode oldParent, ParentNode newParent, Node previousSibling, Node nextSibling); // O(N) in descendants
@@ skipping 32 matching lines @@
 abstract class ParentNode extends Node {
   external Node get firstChild; // O(1)
   external Node get lastChild; // O(1)
 
   // Returns a new List every time.
   external List<Node> getChildren(); // O(N) in number of child nodes
   external List<Element> getChildElements(); // O(N) in number of child nodes
   // TODO(ianh): might not be necessary if we have the parser drop unnecessary whitespace text nodes
 
   external void append(List nodes); // O(N) in number of arguments plus all their descendants
-  external void appendSingle(Node nodes); // O(N) in number of descandants
+  external void appendChild(Node child); // O(N) in number of descandants
   external void prepend(List nodes); // O(N) in number of arguments plus all their descendants
   external void replaceChildrenWith(List nodes); // O(N) in number of descendants plus arguments plus all their descendants
   // nodes must be String, Text, or Element
 }
 
 class Attr {
   const Attr (this.name, [this.value = '']); // O(1)
   final String name; // O(1)
   final String value; // O(1)
 }
@@ skipping 200 matching lines @@
   external bool matches(Element element); // O(F())
   external Element find(node root); // O(N*F())+O(M) where N is the number of descendants and M the average depth of the tree
   external List<Element> findAll(Node root); // O(N*F())+O(N*M) where N is the number of descendants and M the average depth of the tree
   // find() and findAll() throw if the root is not one of the following:
   //  - Element
   //  - Fragment
   //  - Root
 }
 </script>
 ```