Specs: Initial hack at extensible style/layout

sky/specs/apis.md

 APIs
 ====
 
 The Sky core API
 ----------------
 
 ```javascript
 module 'sky:core' {
 
   // EVENTS
@@ skipping 133 matching lines @@
     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
   }
 
 
   // BUILT-IN ELEMENTS
 
   class ImportElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "import"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class TemplateElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "template"
     constructor attribute Boolean shadow; // O(1) // false
 
     readonly attribute DocumentFragment content; // O(1)
   }
   class ScriptElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "script"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class StyleElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "style"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class ContentElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "content"
     constructor attribute Boolean shadow; // O(1) // false
 
     Array<Node> getDistributedNodes(); // O(N) in distributed nodes
   }
   class ImgElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "img"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class DivElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "div"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class SpanElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "span"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class IframeElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "iframe"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class TElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "t"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class AElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "a"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class TitleElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "title"
     constructor attribute Boolean shadow; // O(1) // false
   }
   class ErrorElement : Element {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
     constructor attribute String tagName; // O(1) // "error"
     constructor attribute Boolean shadow; // O(1) // false
   }
 
 
 
   // MODULES
 
   callback InternalElementConstructor void (Module module);
   dictionary ElementRegistration {
     String tagName;
     Boolean shadow = false;
     InternalElementConstructor? constructor = null;
   }
 
   interface ElementConstructor {
-    constructor (Dictionary attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
+    constructor (Dictionary<String> attributes, ChildArguments... nodes); // O(M+N), M = number of attributes, N = number of nodes plus all their descendants
     constructor (ChildArguments... nodes); // shorthand
-    constructor (Dictionary attributes); // shorthand
+    constructor (Dictionary<String> attributes); // shorthand
     constructor (); // shorthand
 
     constructor attribute String tagName;
     constructor attribute Boolean shadow;
   }
 
   abstract class AbstractModule : EventTarget {
     readonly attribute Document document; // O(1) // the Documentof the module or application
     Promise<any> import(String url); // O(Yikes) // returns the module's exports
 
@@ skipping 158 matching lines @@
   foo[debug.Bar]
 </script>
 ```
 
 ### Types ###
 
 The following types are available:
 
 * ``Integer`` - WebIDL ``long long``
 * ``Float`` - WebIDL ``double``
+* ``Infinity`` - singleton type with value ``Infinity``
 * ``String`` - WebIDL ``USVString``
 * ``Boolean`` - WebIDL ``boolean``
 # ``Object`` - WebIDL ``object`` (``ClassName`` can be used as a literal for this type)
 * ``ClassName`` - an instance of the class ClassName
 * ``DictionaryName`` - an instance of the dictionary DictionaryName
 * ``Promise<Type>`` - WebIDL ``Promise<T>``
+* ``Generator<Type>`` - An ECMAScript generator function that returns data of the given type
 * ``Array<Type>`` - WebIDL ``sequence<T>``
-* ``Dictionary`` - unordered set of name-value String-String pairs with no duplicate names
+* ``Dictionary<Type>`` - unordered set of name-value String-Type pairs with no duplicate names
 * ``Type?`` - union of Type and the singleton type with value ``null`` (WebIDL nullable)
 * ``(Type1 or Type2)`` - union of Type1 and Type2 (WebIDL union)
 * ``any`` - union of all types (WebIDL ``any``)
 
 Methods that return nothing (undefined, in JS) use the keyword "void"
 instead of a type.
 
 
 TODO(ianh): Define in detail how this actually works
 
@@ skipping 19 matching lines @@
   the core mojo fabric JS API   sky:mojo:fabric:core
   the asyncWait/cancelWait mojo fabric JS API (interface to IPC thread)  sky:mojo:fabric:ipc
   the mojom for the shell, proxying through C++ so that the shell pipe isn't exposed  sky:mojo:shell
   the sky API  sky:core
   the sky debug symbols for private APIs  sky:debug
 ```
 
 TODO(ianh): determine if we want to separate the "this" from the
 Document, especially for Modules, so that exposing a module's element
 doesn't expose the module's exports attribute.