Docs: fix markdown in various files, update the README mildly

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 74 matching lines @@
 
 6. Switch to the **expect a string** state.
 
 
 ### Tokeniser states ###
 
 #### **Signature** state ####
 
 If the current character is...
 
-* '```#```': If the _parsing context_ is not an Application, switch to
+* '``#``': If the _parsing context_ is not an Application, switch to
   the _failed signature_ state. Otherwise, expect the string
-  "```#!mojo mojo:sky```", with _after signature_ as the _success_
+  "``#!mojo mojo:sky``", with _after signature_ as the _success_
   state and _failed signature_ as the _failure_ state.
 
-* '```S```': If the _parsing context_ is not a Module, switch to the
+* '``S``': If the _parsing context_ is not a Module, switch to the
   _failed signature_ state. Otherwise, expect the string
-  "```SKY MODULE```", with _after signature_ as the _success_ state,
+  "``SKY MODULE``", with _after signature_ as the _success_ state,
   and _failed signature_ as the _failure_ state.
 
 * Anything else: Jump to the **failed signature** state.
 
 
 #### **Expect a string** state ####
 
 If the current character is not the same as the <i>index</i>th character in
 _expectation_, then switch to the _failure_ state.
 
@@ skipping 22 matching lines @@
 If the current character is...
 
 * U+000A: Consume the character and switch to the **data** state.
 * Anything else: Consume the character and stay in this state.
 
 
 ### **Data** state ###
 
 If the current character is...
 
-* '```<```': Consume the character and switch to the **tag open** state.
+* '``<``': Consume the character and switch to the **tag open** state.
 
-* '```&```': Consume the character and switch to the **character
+* '``&``': Consume the character and switch to the **character
   reference** state, with the _return state_ set to the **data**
   state, the _extra terminating character_ unset (or set to U+0000,
   which has the same effect), and the _emitting operation_ being to
   emit a character token for the given character.
 
 * Anything else: Emit the current input character as a character
   token. Consume the character. Stay in this state.
 
 
 ### **Script raw data** state ###
 
 If the current character is...
 
-* '```<```': Consume the character and switch to the **script raw
+* '``<``': Consume the character and switch to the **script raw
   data: close 1** state.
 
 * Anything else: Emit the current input character as a character
   token. Consume the character. Stay in this state.
 
 
 ### **Script raw data: close 1** state ###
 
 If the current character is...
 
-* '```/```': Consume the character and switch to the **script raw
+* '``/``': Consume the character and switch to the **script raw
   data: close 2** state.
 
-* Anything else: Emit '```<```' character tokens. Consume the
+* Anything else: Emit '``<``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Script raw data: close 2** state ###
 
 If the current character is...
 
-* '```s```': Consume the character and switch to the **script raw
+* '``s``': Consume the character and switch to the **script raw
   data: close 3** state.
 
-* Anything else: Emit '```</```' character tokens. Consume the
+* Anything else: Emit '``</``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Script raw data: close 3** state ###
 
 If the current character is...
 
-* '```c```': Consume the character and switch to the **script raw
+* '``c``': Consume the character and switch to the **script raw
   data: close 4** state.
 
-* Anything else: Emit '```</s```' character tokens. Consume the
+* Anything else: Emit '``</s``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Script raw data: close 4** state ###
 
 If the current character is...
 
-* '```r```': Consume the character and switch to the **script raw
+* '``r``': Consume the character and switch to the **script raw
   data: close 5** state.
 
-* Anything else: Emit '```</sc```' character tokens. Consume the
+* Anything else: Emit '``</sc``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Script raw data: close 5** state ###
 
 If the current character is...
 
-* '```i```': Consume the character and switch to the **script raw
+* '``i``': Consume the character and switch to the **script raw
   data: close 6** state.
 
-* Anything else: Emit '```</scr```' character tokens. Consume the
+* Anything else: Emit '``</scr``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Script raw data: close 6** state ###
 
 If the current character is...
 
-* '```p```': Consume the character and switch to the **script raw
+* '``p``': Consume the character and switch to the **script raw
   data: close 7** state.
 
-* Anything else: Emit '```</scri```' character tokens. Consume the
+* Anything else: Emit '``</scri``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Script raw data: close 7** state ###
 
 If the current character is...
 
-* '```t```': Consume the character and switch to the **script raw
+* '``t``': Consume the character and switch to the **script raw
   data: close 8** state.
 
-* Anything else: Emit '```</scrip```' character tokens. Consume the
+* Anything else: Emit '``</scrip``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Script raw data: close 8** state ###
 
 If the current character is...
 
-* U+0020, U+000A, '```/```', '```>```': Create an end tag token, and
-  let its tag name be the string '```script```'. Switch to the
+* U+0020, U+000A, '``/``', '``>``': Create an end tag token, and
+  let its tag name be the string '``script``'. Switch to the
   **before attribute name** state without consuming the character.
 
-* Anything else: Emit '```</script```' character tokens. Consume the
+* Anything else: Emit '``</script``' character tokens. Consume the
   character. Switch to the **script raw data** state.
 
 
 ### **Style raw data** state ###
 
 If the current character is...
 
-* '```<```': Consume the character and switch to the **style raw
+* '``<``': Consume the character and switch to the **style raw
   data: close 1** state.
 
 * Anything else: Emit the current input character as a character
   token. Consume the character. Stay in this state.
 
 
 ### **Style raw data: close 1** state ###
 
 If the current character is...
 
-* '```/```': Consume the character and switch to the **style raw
+* '``/``': Consume the character and switch to the **style raw
   data: close 2** state.
 
-* Anything else: Emit '```<```' character tokens. Consume the
+* Anything else: Emit '``<``' character tokens. Consume the
   character. Switch to the **style raw data** state.
 
 
 ### **Style raw data: close 2** state ###
 
 If the current character is...
 
-* '```s```': Consume the character and switch to the **style raw
+* '``s``': Consume the character and switch to the **style raw
   data: close 3** state.
 
-* Anything else: Emit '```</```' character tokens. Consume the
+* Anything else: Emit '``</``' character tokens. Consume the
   character. Switch to the **style raw data** state.
 
 
 ### **Style raw data: close 3** state ###
 
 If the current character is...
 
-* '```t```': Consume the character and switch to the **style raw
+* '``t``': Consume the character and switch to the **style raw
   data: close 4** state.
 
-* Anything else: Emit '```</s```' character tokens. Consume the
+* Anything else: Emit '``</s``' character tokens. Consume the
   character. Switch to the **style raw data** state.
 
 
 ### **Style raw data: close 4** state ###
 
 If the current character is...
 
-* '```y```': Consume the character and switch to the **style raw
+* '``y``': Consume the character and switch to the **style raw
   data: close 5** state.
 
-* Anything else: Emit '```</st```' character tokens. Consume the
+* Anything else: Emit '``</st``' character tokens. Consume the
   character. Switch to the **style raw data** state.
 
 
 ### **Style raw data: close 5** state ###
 
 If the current character is...
 
-* '```l```': Consume the character and switch to the **style raw
+* '``l``': Consume the character and switch to the **style raw
   data: close 6** state.
 
-* Anything else: Emit '```</sty```' character tokens. Consume the
+* Anything else: Emit '``</sty``' character tokens. Consume the
   character. Switch to the **style raw data** state.
 
 
 ### **Style raw data: close 6** state ###
 
 If the current character is...
 
-* '```e```': Consume the character and switch to the **style raw
+* '``e``': Consume the character and switch to the **style raw
   data: close 7** state.
 
-* Anything else: Emit '```</styl```' character tokens. Consume the
+* Anything else: Emit '``</styl``' character tokens. Consume the
   character. Switch to the **style raw data** state.
 
 
 ### **Style raw data: close 7** state ###
 
 If the current character is...
 
-* U+0020, U+000A, '```/```', '```>```': Create an end tag token, and
-  let its tag name be the string '```style```'. Switch to the
+* U+0020, U+000A, '``/``', '``>``': Create an end tag token, and
+  let its tag name be the string '``style``'. Switch to the
   **before attribute name** state without consuming the character.
 
-* Anything else: Emit '```</style```' character tokens. Consume the
+* Anything else: Emit '``</style``' character tokens. Consume the
   character. Switch to the **style raw data** state.
 
 
 ### **Tag open** state ###
 
 If the current character is...
 
-* '```!```': Consume the character and switch to the **comment start
+* '``!``': Consume the character and switch to the **comment start
   1** state.
 
-* '```/```': Consume the character and switch to the **close tag
+* '``/``': Consume the character and switch to the **close tag
   state** state.
 
-* '```>```': Emit character tokens for '```<>```'. Consume the current
+* '``>``': Emit character tokens for '``<>``'. Consume the current
   character. Switch to the **data** state.
 
-* '```0```'..'```9```', '```a```'..'```z```', '```A```'..'```Z```',
-  '```-```', '```_```', '```.```': Create a start tag token, let its
+* '``0``'..'``9``', '``a``'..'``z``', '``A``'..'``Z``',
+  '``-``', '``_``', '``.``': Create a start 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 token for '```<```'. Switch to the
+* 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
+* '``>``': Emit character tokens for '``</>``'. Consume the current
   character. Switch to the **data** state.
 
-* '```0```'..'```9```', '```a```'..'```z```', '```A```'..'```Z```',
-  '```-```', '```_```', '```.```': Create an end tag token, let its
+* '``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
+* Anything else: Emit the character tokens for '``</``'. Switch to
   the **data** state without consuming the current character.
 
 
 ### **Tag name** state ###
 
 If the current character is...
 
 * U+0020, U+000A: Consume the current character. Switch to the
   **before attribute name** state.
 
-* '```/```': Consume the current character. Switch to the **void tag**
+* '``/``': Consume the current character. Switch to the **void tag**
   state.
 
-* '```>```': Consume the current character. Switch to the **after
+* '``>``': Consume the current character. Switch to the **after
   tag** state.
 
 * Anything else: Append the current character to the tag name, and
   consume the current character. Stay in this state.
 
 
 ### **Void tag** state ###
 
 If the current character is...
 
-* '```>```': Consume the current character. Switch to the **after void
+* '``>``': Consume the current character. Switch to the **after void
   tag** state.
 
 * Anything else: Switch to the **before attribute name** state without
   consuming the current character.
 
 
 ### **Before attribute name** state ###
 
 If the current character is...
 
 * U+0020, U+000A: Consume the current character. Stay in this state.
 
-* '```/```': Consume the current character. Switch to the **void tag**
+* '``/``': Consume the current character. Switch to the **void tag**
   state.
 
-* '```>```': Consume the current character. Switch to the **after
+* '``>``': Consume the current character. Switch to the **after
   tag** state.
 
 * Anything else: Create a new attribute in the tag token, and set its
   name to the current character. Consume the current character. Switch
   to the **attribute name** state.
 
 
 ### **Attribute name** state ###
 
 If the current character is...
 
 * U+0020, U+000A: Consume the current character. Switch to the **after
   attribute name** state.
 
-* '```/```': Consume the current character. Switch to the **void tag**
+* '``/``': Consume the current character. Switch to the **void tag**
   state.
 
-* '```=```': Consume the current character. Switch to the **before
+* '``=``': Consume the current character. Switch to the **before
   attribute value** state.
 
-* '```>```': Consume the current character. Switch to the **after
+* '``>``': Consume the current character. Switch to the **after
   tag** state.
 
 * Anything else: Append the current character to the most recently
   added attribute's name, and consume the current character. Stay in
   this state.
 
 
 ### **After attribute name** state ###
 
 If the current character is...
 
 * U+0020, U+000A: Consume the current character. Stay in this state.
 
-* '```/```': Consume the current character. Switch to the **void tag**
+* '``/``': Consume the current character. Switch to the **void tag**
   state.
 
-* '```=```': Consume the current character. Switch to the **before
+* '``=``': Consume the current character. Switch to the **before
   attribute value** state.
 
-* '```>```': Consume the current character. Switch to the **after
+* '``>``': Consume the current character. Switch to the **after
   tag** state.
 
 * Anything else: Create a new attribute in the tag token, and set its
   name to the current character. Consume the current character. Switch
   to the **attribute name** state.
 
 
 ### **Before attribute value** state ###
 
 If the current character is...
 
 * U+0020, U+000A: Consume the current character. Stay in this state.
 
-* '```>```': Consume the current character. Switch to the **after
+* '``>``': Consume the current character. Switch to the **after
   tag** state.
 
-* '```'```': Consume the current character. Switch to the
+* '``'``': Consume the current character. Switch to the
   **single-quoted attribute value** state.
 
-* '```"```': Consume the current character. Switch to the
+* '``"``': Consume the current character. Switch to the
   **double-quoted attribute value** state.
 
 * Anything else: Set the value of the most recently added attribute to
   the current character. Consume the current character. Switch to the
   **unquoted attribute value** state.
 
 
 ### **Single-quoted attribute value** state ###
 
 If the current character is...
 
-* '```'```': Consume the current character. Switch to the
+* '``'``': Consume the current character. Switch to the
   **before attribute name** state.
 
-* '```&```': Consume the character and switch to the **character
+* '``&``': Consume the character and switch to the **character
   reference** state, with the _return state_ set to the
   **single-quoted attribute value** state, the _extra terminating
-  character_ set to '```'```', and the _emitting operation_ being to
+  character_ set to '``'``', and the _emitting operation_ being to
   append the given character to the value of the most recently added
   attribute.
 
 * Anything else: Append the current character to the value of the most
   recently added attribute. Consume the current character. Stay in
   this state.
 
 
 ### **Double-quoted attribute value** state ###
 
 If the current character is...
 
-* '```"```': Consume the current character. Switch to the
+* '``"``': Consume the current character. Switch to the
   **before attribute name** state.
 
-* '```&```': Consume the character and switch to the **character
+* '``&``': Consume the character and switch to the **character
   reference** state, with the _return state_ set to the
   **double-quoted attribute value** state, the _extra terminating
-  character_ set to '```"```', and the _emitting operation_ being to
+  character_ set to '``"``', and the _emitting operation_ being to
   append the given character to the value of the most recently added
   attribute.
 
 * Anything else: Append the current character to the value of the most
   recently added attribute. Consume the current character. Stay in
   this state.
 
 
 ### **Unquoted attribute value** state ###
 
 If the current character is...
 
 * U+0020, U+000A: Consume the current character. Switch to the
   **before attribute name** state.
 
-* '```>```': Consume the current character. Switch to the **data**
+* '``>``': Consume the current character. Switch to the **data**
   state. Switch to the **after tag** state.
 
-* '```&```': Consume the character and switch to the **character
+* '``&``': Consume the character and switch to the **character
   reference** state, with the _return state_ set to the **unquoted
   attribute value** state, the _extra terminating character_ unset (or
   set to U+0000, which has the same effect), and the _emitting
   operation_ being to append the given character to the value of the
   most recently added attribute.
 
 * 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 and 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 and 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.
 
 Switch to the **data** state.
 
 
 ### **Comment start 1** state ###
 
 If the current character is...
 
-* '```-```': Consume the character and switch to the **comment start
+* '``-``': Consume the character and switch to the **comment start
   2** state.
 
-* '```>```': Emit character tokens for '```<!>```'. Consume the
+* '``>``': Emit character tokens for '``<!>``'. Consume the
   current character. Switch to the **data** state.
 
 
 ### **Comment start 2** state ###
 
 If the current character is...
 
-* '```-```': Consume the character and switch to the **comment**
+* '``-``': Consume the character and switch to the **comment**
   state.
 
-* '```>```': Emit character tokens for '```<!->```'. Consume the
+* '``>``': Emit character tokens for '``<!->``'. Consume the
   current character. Switch to the **data** state.
 
 
 ### **Comment** state ###
 
 If the current character is...
 
-* '```-```': Consume the character and switch to the **comment end 1**
+* '``-``': Consume the character and switch to the **comment end 1**
   state.
 
 * Anything else: Consume the character and switch to the **comment**
   state.
 
 
 ### **Comment end 1** state ###
 
 If the current character is...
 
-* '```-```': Consume the character, switch to the **comment end 2**
+* '``-``': Consume the character, switch to the **comment end 2**
   state.
 
 * Anything else: Consume the character, and switch to the **comment**
   state.
 
 
 ### **Comment end 2** state ###
 
 If the current character is...
 
-* '```>```': Consume the character and switch to the **data** state.
+* '``>``': Consume the character and switch to the **data** state.
 
-* '```-```': Consume the character, but stay in this state.
+* '``-``': Consume the character, but stay in this state.
 
 * Anything else: Consume the character, and switch to the **comment**
   state.
 
 
 ### **Character reference** state ###
 
-Let _raw value_ be the string '```&```'.
+Let _raw value_ be the string '``&``'.
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```#```': Consume the character, and switch to the **numeric
+* '``#``': Consume the character, and switch to the **numeric
   character reference** state.
 
-* '```l```': Consume the character and switch to the **named character
+* '``l``': Consume the character and switch to the **named character
   reference L** state.
 
-* '```a```': Consume the character and switch to the **named character
+* '``a``': Consume the character and switch to the **named character
   reference A** state.
 
-* '```g```': Consume the character and switch to the **named character
+* '``g``': Consume the character and switch to the **named character
   reference G** state.
 
-* '```q```': Consume the character and switch to the **named character
+* '``q``': Consume the character and switch to the **named character
   reference Q** state.
 
-* Any other character in the range '```0```'..'```9```',
-  '```a```'..'```f```', '```A```'..'```F```': Consume the character
+* Any other character in the range '``0``'..'``9``',
+  '``a``'..'``f``', '``A``'..'``F``': Consume the character
   and switch to the **bad named character reference** state.
 
 * Anything else: Run the _emitting operation_ for all but the last
   character in _raw value_, and switch to the **data state** without
   consuming the current character.
 
 
 ### **Numeric character reference** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```x```', '```X```': Let _value_ be zero, consume the character,
+* '``x``', '``X``': Let _value_ be zero, consume the character,
   and switch to the **hexadecimal numeric character reference** state.
 
-* '```0```'..'```9```': Let _value_ be the numeric value of the
+* '``0``'..'``9``': Let _value_ be the numeric value of the
   current character interpreted as a decimal digit, consume the
   character, and switch to the **decimal numeric character reference**
   state.
 
 * Anything else: Run the _emitting operation_ for all but the last
   character in _raw value_, and switch to the **data state** without
   consuming the current character.
 
 
 ### **Hexadecimal numeric character reference** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```0```'..'```9```', '```a```'..'```f```', '```A```'..'```F```':
+* '``0``'..'``9``', '``a``'..'``f``', '``A``'..'``F``':
   Let _value_ be sixteen times _value_ plus the numeric value of the
   current character interpreted as a hexadecimal digit.
 
-* '```;```': Consume the character. If _value_ is between 0x0001 and
+* '``;``': Consume the character. If _value_ is between 0x0001 and
   0x10FFFF inclusive, but is not between 0xD800 and 0xDFFF inclusive,
   run the _emitting operation_ with a unicode character having the
   scalar value _value_; otherwise, run the _emitting operation_ with
   the character U+FFFD. Then, in either case, switch to the _return
   state_.
 
 * Anything else: Run the _emitting operation_ for all but the last
   character in _raw value_, and switch to the **data state** without
   consuming the current character.
 
 
 ### **Decimal numeric character reference** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```0```'..'```9```': Let _value_ be ten times _value_ plus the
+* '``0``'..'``9``': Let _value_ be ten times _value_ plus the
   numeric value of the current character interpreted as a decimal
   digit.
 
-* '```;```': Consume the character. If _value_ is between 0x0001 and
+* '``;``': Consume the character. If _value_ is between 0x0001 and
   0x10FFFF inclusive, but is not between 0xD800 and 0xDFFF inclusive,
   run the _emitting operation_ with a unicode character having the
   scalar value _value_; otherwise, run the _emitting operation_ with
   the character U+FFFD. Then, in either case, switch to the _return
   state_.
 
 * Anything else: Run the _emitting operation_ for all but the last
   character in _raw value_, and switch to the **data state** without
   consuming the current character.
 
 
 ### **Named character reference L** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```t```': Let _character_ be '```<```', consume the current
+* '``t``': Let _character_ be '``<``', consume the current
   character, and switch to the **after named character reference**
   state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference A** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```p```': Consume the current character and switch to the **named
+* '``p``': Consume the current character and switch to the **named
   character reference AP** state.
 
-* '```m```': Consume the current character and switch to the **named
+* '``m``': Consume the current character and switch to the **named
   character reference AM** state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference AM** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```p```': Let _character_ be '```&```', consume the current
+* '``p``': Let _character_ be '``&``', consume the current
   character, and switch to the **after named character reference**
   state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference AP** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```o```': Consume the current character and switch to the **named
+* '``o``': Consume the current character and switch to the **named
   character reference APO** state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference APO** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```s```': Let _character_ be '```'```', consume the current
+* '``s``': Let _character_ be '``'``', consume the current
   character, and switch to the **after named character reference**
   state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference G** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```t```': Let _character_ be '```>```', consume the current
+* '``t``': Let _character_ be '``>``', consume the current
   character, and switch to the **after named character reference**
   state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference Q** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```u```': Consume the current character and switch to the **named
+* '``u``': Consume the current character and switch to the **named
   character reference QU** state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference QU** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```o```': Consume the current character and switch to the **named
+* '``o``': Consume the current character and switch to the **named
   character reference QUO** state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **Named character reference QUO** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```t```': Let _character_ be '```"```', consume the current
+* '``t``': Let _character_ be '``"``', consume the current
   character, and switch to the **after named character reference**
   state.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the character.
 
 
 ### **After named character reference** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```;```': Consume the character. Run the _emitting operation_ with
+* '``;``': Consume the character. Run the _emitting operation_ with
   the character _character_. Switch to the _return state_.
 
 * The _extra terminating character_: Run the _emitting operation_ with
   the character U+FFFD. Switch to the _return state_ without consuming
   the current character.
 
 * Anything else: Switch to the _bad named character reference_ state
   without consuming the current character.
 
 
 ### **Bad named character reference** state ###
 
 Append the current character to _raw value_.
 
 If the current character is...
 
-* '```;```': Consume the character. Run the _emitting operation_ with
+* '``;``': Consume the character. Run the _emitting operation_ with
   the character U+FFFD. Switch to the _return state_.
 
 * The _extra terminating character_: Switch to the _return state_
   without consuming the current character.
 
-* Any other character in the range '```0```'..'```9```',
-  '```a```'..'```f```', '```A```'..'```F```': Consume the character
+* Any other character in the range '``0``'..'``9``',
+  '``a``'..'``f``', '``A``'..'``F``': Consume the character
   and stay in this state.
 
 * Anything else: Run the _emitting operation_ for all but the last
   character in _raw value_, and switch to the **data state** without
   consuming the current character.
 
 
 Token cleanup stage
 -------------------
 
@@ skipping 18 matching lines @@
 
 To construct a node tree from a _sequence of tokens_ and a document
 _document_:
 
 1. Initialize the _stack of open nodes_ to be _document_.
 2. Consider each token _token_ in the _sequence of tokens_ in turn, as
    follows. If a token is to be skipped, then jump straight to the
    next token, without doing any more work with the skipped token.
    - If _token_ is a string token,
      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
+        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. Create an element _node_ with tag name and attributes given by
         the token.
      2. Append _node_ to the top node in the _stack of open nodes_.
    - If _token_ is an end tag token:
      1. Let _node_ be the topmost node in the _stack of open nodes_
         whose tag name is the same as the token's tag name, if any. If
         there isn't one, skip this token.
-     2. If there's a ```template``` element in the _stack of open
+     2. If there's a ``template`` element in the _stack of open
         nodes_ above _node_, then skip this token.
      3. Pop nodes from the _stack of open nodes_ until _node_ has been
         popped.
-     4. If _node_'s tag name is ```script```, then yield until there
+     4. If _node_'s tag name is ``script``, then yield until there
         are no pending import loads, then execute the script given by
         the element's contents.
 3. Yield until there are no pending import loads.
-3. Fire a ```load``` event at the _parsing context_ object.
+3. Fire a ``load`` event at the _parsing context_ object.