Specs: Make </> automatically close the last open tag, so you don't have to repeat yourself all the…

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.
 
-- tokenising, which converts these characters into three kinds of
-  tokens: character tokens, start tag tokens, and end tag tokens.
-  Character tokens have a single character value. Tag tokens have a
-  tag name, and a list of name/value pairs known as attributes.
+- tokenising, which converts these characters into four kinds of
+  tokens: character tokens, start tag tokens, end tag tokens, and
+  automatic end tag tokens. Character tokens have a single character
+  value. Start and end tag tokens have a tag name, and a list of
+  name/value pairs known as attributes.
 
 - token cleanup, which converts sequences of character tokens into
   string tokens, and removes duplicate attributes in tag tokens.
 
 - tree construction, which converts these tokens into a tree of nodes.
 
 Later stages cannot affect earlier stages.
 
 When a sequence of bytes is to be parsed, there is always a defined
 _parsing context_, which is either an Application object or a Module
@@ skipping 339 matching lines @@
   switch to the **tag name** state.
 
 * Anything else: Emit the character token for '``<``'. Switch to the
   **data** state without consuming the current character.
 
 
 #### **Close tag** state ####
 
 If the current character is...
 
-* '``>``': Emit character tokens for '``</>``'. Consume the current
-  character. Switch to the **data** state.
+* '``>``': Emit an automatic end tag token. Switch to the **data**
+  state.
 
 * '``0``'..'``9``', '``a``'..'``z``', '``A``'..'``Z``',
   '``-``', '``_``', '``.``': Create an end tag token, let its
   tag name be the current character, consume the current character and
   switch to the **tag name** state.
 
 * Anything else: Emit the character tokens for '``</``'. Switch to
   the **data** state without consuming the current character.
 
 
@@ skipping 159 matching lines @@
 * Anything else: Append the current character to the value of the most
   recently added attribute. Consume the current character. Stay in
   this state.
 
 
 #### **After tag** state ####
 
 Emit the tag token.
 
 If the tag token was a start tag token and the tag name was
-'``script``', then and switch to the **script raw data** state.
+'``script``', then switch to the **script raw data** state.
 
 If the tag token was a start tag token and the tag name was
-'``style``', then and switch to the **style raw data** state.
+'``style``', then switch to the **style raw data** state.
 
 Otherwise, switch to the **data** state.
 
 
 #### **After void tag** state ####
 
 Emit the tag token.
 
 If the tag token is a start tag token, emit an end tag token with the
 same tag name.
@@ skipping 256 matching lines @@
         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_, if any.
 4. Yield until _imported modules_ has no promises.
 5. Fire a ``load`` event at the _parsing context_ object.