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

sky/specs/parsing.md

 Parsing
 =======
 
 Parsing in Sky is a strict pipeline consisting of five stages:
 
 - decoding, which converts incoming bytes into Unicode characters
   using UTF-8.
 
 - normalising, which manipulates the sequence of characters.
 
@@ skipping 784 matching lines @@
      1. If the value of the token contains only U+0020 and U+000A
         characters, and there is no ``t`` element on the _stack of
         open nodes_, then skip the token.
      2. Create a text node _node_ whose character data is the value of
         the token.
      3. Append _node_ to the top node in the _stack of open nodes_.
    - If _token_ is a start tag token,
      1. If the tag name isn't a registered tag name, then yield until
         _imported modules_ contains no entries with unresolved
         promises.
-     2. If the tag name is registered, create an element _node_ with
-        tag name and attributes given by the token. Otherwise, create
-        an element with the tag name "error" and the attributes given
-        by the token.
-     3. Append _node_ to the top node in the _stack of open nodes_.
-     4. Push _node_ onto the top of the _stack of open nodes_.
-     5. If _node_ is a ``template`` element, then:
+     2. If the tag name is not registered, then let the ErrorElement
+        constructor from sky:core be the element constructor.
+        Otherwise, let the element constructor be the registered
+        element's constructor for that tag name in this module.
+     3. Create an element _node_ with the attributes given by the
+        token by calling the constructor.
+     4. If _node_ is not an Element object, then let the constructor
+        be the ErrorElement constructor and return to the previous
+        step.
+     5. Append _node_ to the top node in the _stack of open nodes_.
+     6. Push _node_ onto the top of the _stack of open nodes_.
+     7. If _node_ is a ``template`` element, then:
         1. Let _fragment_ be the ``DocumentFragment`` object that the
            ``template`` element uses as its template contents container.
         2. Push _fragment_ onto the top of the _stack of open nodes_.
         If _node_ is an ``import`` element, then:
         1. Let ``url`` be the value of _node_'s ``src`` attribute.
         2. Call ``parsing context``'s ``importModule()`` method,
            passing it ``url``.
         3. Add the returned promise to _imported modules_; if _node_
            has an ``as`` attribute, associate the entry with that
            name.
    - If _token_ is an end tag token:
      1. If the tag name is registered, let _tag name_ be that tag
         name. Otherwise, let _tag name_ be "error".
      2. Let _node_ be the topmost node in the _stack of open nodes_
         whose tag name is _tag name_, if any. If there isn't one, skip
         this token.
      3. If there's a ``template`` element in the _stack of open
         nodes_ above _node_, then skip this token.
      4. Pop nodes from the _stack of open nodes_ until _node_ has been
         popped.
      5. If _node_'s tag name is ``script``, then yield until _imported
         modules_ contains no entries with unresolved promises, then
         execute the script given by the element's contents, using the
         associated names as appropriate.
    - If _token_ is an automatic end tag token:
      1. Pop the top node from the _stack of open nodes_, unless it is
         the document.
 4. Yield until _imported modules_ has no promises.
 5. Fire a ``load`` event at the _parsing context_ object.