Add whitespace to reduce noise in next patch

Author: lukewagner

design/mvp/Binary.md

@@ -148,61 +148,61 @@ Notes:
   means that the maximum `ct` in an MVP `alias` declarator is `1`.
 
 ```
-type          ::= dt:<deftype>                         => (type dt)
-deftype       ::= dvt:<defvaltype>                     => dvt
-                | ft:<functype>                        => ft
-                | ct:<componenttype>                   => ct
-                | it:<instancetype>                    => it
-primvaltype   ::= 0x7f                                 => bool
-                | 0x7e                                 => s8
-                | 0x7d                                 => u8
-                | 0x7c                                 => s16
-                | 0x7b                                 => u16
-                | 0x7a                                 => s32
-                | 0x79                                 => u32
-                | 0x78                                 => s64
-                | 0x77                                 => u64
-                | 0x76                                 => float32
-                | 0x75                                 => float64
-                | 0x74                                 => char
-                | 0x73                                 => string
-defvaltype    ::= pvt:<primvaltype>                    => pvt
-                | 0x72 nt*:vec(<namedvaltype>)         => (record (field nt)*)
-                | 0x71 case*:vec(<case>)               => (variant case*)
-                | 0x70 t:<valtype>                     => (list t)
-                | 0x6f t*:vec(<valtype>)               => (tuple t*)
-                | 0x6e n*:vec(<name>)                  => (flags n*)
-                | 0x6d n*:vec(<name>)                  => (enum n*)
-                | 0x6c t*:vec(<valtype>)               => (union t*)
-                | 0x6b t:<valtype>                     => (option t)
-                | 0x6a t?:<casetype> u?:<casetype>     => (result t? (error u)?)
-namedvaltype  ::= n:<name> t:<valtype>                 => n t
-case          ::= n:<name> t?:<casetype> 0x0           => (case n t?)
-                | n:<name> t?:<casetype> 0x1 i:<u32>   => (case n t? (refines case-label[i]))
-casetype      ::= 0x00                                 =>
-                | 0x01 t:<valtype>                     => t
-valtype       ::= i:<typeidx>                          => i
-                | pvt:<primvaltype>                    => pvt
-functype      ::= 0x40 p*:<funcvec> r*:<funcvec>       => (func (param p)* (result r)*)
-funcvec       ::= 0x00 t:<valtype>                     => [t]
-                | 0x01 nt*:vec(<namedvaltype>)         => nt*
-componenttype ::= 0x41 cd*:vec(<componentdecl>)        => (component cd*)
-instancetype  ::= 0x42 id*:vec(<instancedecl>)         => (instance id*)
-componentdecl ::= 0x03 id:<importdecl>                 => id
-                | id:<instancedecl>                    => id
-instancedecl  ::= 0x00 t:<core:type>                   => t
-                | 0x01 t:<type>                        => t
-                | 0x02 a:<alias>                       => a
-                | 0x04 ed:<exportdecl>                 => ed
-importdecl    ::= n:<name> ed:<externdesc>             => (import n ed)
-exportdecl    ::= n:<name> ed:<externdesc>             => (export n ed)
-externdesc    ::= 0x00 0x11 i:<core:typeidx>           => (core module (type i))
-                | 0x01 i:<typeidx>                     => (func (type i))
-                | 0x02 t:<valtype>                     => (value t)
-                | 0x03 b:<typebound>                   => (type b)
-                | 0x04 i:<typeidx>                     => (instance (type i))
-                | 0x05 i:<typeidx>                     => (component (type i))
-typebound     ::= 0x00 i:<typeidx>                     => (eq i)
+type          ::= dt:<deftype>                            => (type dt)
+deftype       ::= dvt:<defvaltype>                        => dvt
+                | ft:<functype>                           => ft
+                | ct:<componenttype>                      => ct
+                | it:<instancetype>                       => it
+primvaltype   ::= 0x7f                                    => bool
+                | 0x7e                                    => s8
+                | 0x7d                                    => u8
+                | 0x7c                                    => s16
+                | 0x7b                                    => u16
+                | 0x7a                                    => s32
+                | 0x79                                    => u32
+                | 0x78                                    => s64
+                | 0x77                                    => u64
+                | 0x76                                    => float32
+                | 0x75                                    => float64
+                | 0x74                                    => char
+                | 0x73                                    => string
+defvaltype    ::= pvt:<primvaltype>                       => pvt
+                | 0x72 nt*:vec(<namedvaltype>)            => (record (field nt)*)
+                | 0x71 case*:vec(<case>)                  => (variant case*)
+                | 0x70 t:<valtype>                        => (list t)
+                | 0x6f t*:vec(<valtype>)                  => (tuple t*)
+                | 0x6e n*:vec(<name>)                     => (flags n*)
+                | 0x6d n*:vec(<name>)                     => (enum n*)
+                | 0x6c t*:vec(<valtype>)                  => (union t*)
+                | 0x6b t:<valtype>                        => (option t)
+                | 0x6a t?:<casetype> u?:<casetype>        => (result t? (error u)?)
+namedvaltype  ::= n:<name> t:<valtype>                    => n t
+case          ::= n:<name> t?:<casetype> 0x0              => (case n t?)
+                | n:<name> t?:<casetype> 0x1 i:<u32>      => (case n t? (refines case-label[i]))
+casetype      ::= 0x00                                    =>
+                | 0x01 t:<valtype>                        => t
+valtype       ::= i:<typeidx>                             => i
+                | pvt:<primvaltype>                       => pvt
+functype      ::= 0x40 p*:<funcvec> r*:<funcvec>          => (func (param p)* (result r)*)
+funcvec       ::= 0x00 t:<valtype>                        => [t]
+                | 0x01 nt*:vec(<namedvaltype>)            => nt*
+componenttype ::= 0x41 cd*:vec(<componentdecl>)           => (component cd*)
+instancetype  ::= 0x42 id*:vec(<instancedecl>)            => (instance id*)
+componentdecl ::= 0x03 id:<importdecl>                    => id
+                | id:<instancedecl>                       => id
+instancedecl  ::= 0x00 t:<core:type>                      => t
+                | 0x01 t:<type>                           => t
+                | 0x02 a:<alias>                          => a
+                | 0x04 ed:<exportdecl>                    => ed
+importdecl    ::= n:<name> ed:<externdesc>                => (import n ed)
+exportdecl    ::= n:<name> ed:<externdesc>                => (export n ed)
+externdesc    ::= 0x00 0x11 i:<core:typeidx>              => (core module (type i))
+                | 0x01 i:<typeidx>                        => (func (type i))
+                | 0x02 t:<valtype>                        => (value t)
+                | 0x03 b:<typebound>                      => (type b)
+                | 0x04 i:<typeidx>                        => (instance (type i))
+                | 0x05 i:<typeidx>                        => (component (type i))
+typebound     ::= 0x00 i:<typeidx>                        => (eq i)
 ```
 Notes:
 * The type opcodes follow the same negative-SLEB128 scheme as Core WebAssembly,