Specs: Yet Another Gesture Model (mark IV). This one handles

sky/specs/dom.md

 Sky DOM APIs
 ============
 
 ```javascript
 
-// DOM
+// Element Tree
 
 typedef ChildNode (Element or Text);
 typedef ChildArgument (Element or Text or String);
 
 abstract class Node : EventTarget { // implemented in C++
   readonly attribute TreeScope? ownerScope; // O(1)
 
   readonly attribute ParentNode? parentNode; // O(1)
   readonly attribute Element? parentElement; // O(1) // if parentNode isn't an element, returns null
   readonly attribute ChildNode? previousSibling; // O(1)
@@ skipping 99 matching lines @@
   Element? findId(String id); // O(1)
 }
 
 class ShadowRoot : TreeScope {
   constructor (Element host); // O(1) // note that there is no way in the API to use a newly created ShadowRoot
   readonly attribute Element host; // O(1)
 }
 
 class Document : TreeScope {
   constructor (ChildArguments... nodes); // O(N) in number of arguments plus all their descendants
+}
+
+class ApplicationDocument : Document {
+  constructor (GestureManager gestureManager, ChildArguments... nodes); // O(N) in number of /nodes/ arguments plus all their descendants
 
   virtual LayoutManagerConstructor getLayoutManager(); // O(1)
     // returns sky.rootLayoutManager;
+
+  readonly attribute GestureManager gestureManager;
 }
 
 attribute LayoutManagerConstructor rootLayoutManager; // O(1)
   // initially configured to return BlockLayoutManager
 
 
 // BUILT-IN ELEMENTS
 
 class ImportElement : Element {
   constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
@@ skipping 145 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
 }
 ```