diff --git a/lib/client-assets.php b/lib/client-assets.php
index cde5919bab1af..46c8e4933122c 100644
--- a/lib/client-assets.php
+++ b/lib/client-assets.php
@@ -203,6 +203,13 @@ function gutenberg_register_scripts_and_styles() {
 		filemtime( gutenberg_dir_path() . 'build/dom/index.js' ),
 		true
 	);
+	wp_register_script(
+		'wp-spec-parser',
+		gutenberg_url( 'build/spec-parser/index.js' ),
+		array(),
+		filemtime( gutenberg_dir_path() . 'build/spec-parser/index.js' ),
+		true
+	);
 	wp_add_inline_script(
 		'wp-dom',
 		gutenberg_get_script_polyfill( array(
@@ -290,7 +297,7 @@ function gutenberg_register_scripts_and_styles() {
 	wp_register_script(
 		'wp-blocks',
 		gutenberg_url( 'build/blocks/index.js' ),
-		array( 'wp-blob', 'wp-deprecated', 'wp-dom', 'wp-element', 'wp-hooks', 'wp-i18n', 'wp-shortcode', 'wp-data', 'lodash' ),
+		array( 'wp-blob', 'wp-deprecated', 'wp-dom', 'wp-element', 'wp-hooks', 'wp-i18n', 'wp-shortcode', 'wp-spec-parser', 'wp-data', 'lodash' ),
 		filemtime( gutenberg_dir_path() . 'build/blocks/index.js' ),
 		true
 	);
diff --git a/packages/spec-parser/index.js b/packages/spec-parser/index.js
index 6df34dd8169da..95a476bc3cbdb 100644
--- a/packages/spec-parser/index.js
+++ b/packages/spec-parser/index.js
@@ -3,424 +3,398 @@
  *
  * http://pegjs.org/
  */
+(function(root, factory) {
+  if (typeof define === "function" && define.amd) {
+    define([], factory);
+  } else if (typeof module === "object" && module.exports) {
+    module.exports = factory();
+  }
+})(this, function() {
+  "use strict";
 
-"use strict";
-
-function peg$subclass(child, parent) {
-  function ctor() { this.constructor = child; }
-  ctor.prototype = parent.prototype;
-  child.prototype = new ctor();
-}
+  function peg$subclass(child, parent) {
+    function ctor() { this.constructor = child; }
+    ctor.prototype = parent.prototype;
+    child.prototype = new ctor();
+  }
 
-function peg$SyntaxError(message, expected, found, location) {
-  this.message  = message;
-  this.expected = expected;
-  this.found    = found;
-  this.location = location;
-  this.name     = "SyntaxError";
+  function peg$SyntaxError(message, expected, found, location) {
+    this.message  = message;
+    this.expected = expected;
+    this.found    = found;
+    this.location = location;
+    this.name     = "SyntaxError";
 
-  if (typeof Error.captureStackTrace === "function") {
-    Error.captureStackTrace(this, peg$SyntaxError);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, peg$SyntaxError);
+    }
   }
-}
 
-peg$subclass(peg$SyntaxError, Error);
+  peg$subclass(peg$SyntaxError, Error);
 
-peg$SyntaxError.buildMessage = function(expected, found) {
-  var DESCRIBE_EXPECTATION_FNS = {
-        literal: function(expectation) {
-          return "\"" + literalEscape(expectation.text) + "\"";
-        },
+  peg$SyntaxError.buildMessage = function(expected, found) {
+    var DESCRIBE_EXPECTATION_FNS = {
+          literal: function(expectation) {
+            return "\"" + literalEscape(expectation.text) + "\"";
+          },
 
-        "class": function(expectation) {
-          var escapedParts = "",
-              i;
+          "class": function(expectation) {
+            var escapedParts = "",
+                i;
 
-          for (i = 0; i < expectation.parts.length; i++) {
-            escapedParts += expectation.parts[i] instanceof Array
-              ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
-              : classEscape(expectation.parts[i]);
-          }
+            for (i = 0; i < expectation.parts.length; i++) {
+              escapedParts += expectation.parts[i] instanceof Array
+                ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
+                : classEscape(expectation.parts[i]);
+            }
 
-          return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
-        },
+            return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
+          },
 
-        any: function(expectation) {
-          return "any character";
-        },
+          any: function(expectation) {
+            return "any character";
+          },
 
-        end: function(expectation) {
-          return "end of input";
-        },
+          end: function(expectation) {
+            return "end of input";
+          },
 
-        other: function(expectation) {
-          return expectation.description;
-        }
-      };
+          other: function(expectation) {
+            return expectation.description;
+          }
+        };
 
-  function hex(ch) {
-    return ch.charCodeAt(0).toString(16).toUpperCase();
-  }
+    function hex(ch) {
+      return ch.charCodeAt(0).toString(16).toUpperCase();
+    }
 
-  function literalEscape(s) {
-    return s
-      .replace(/\\/g, '\\\\')
-      .replace(/"/g,  '\\"')
-      .replace(/\0/g, '\\0')
-      .replace(/\t/g, '\\t')
-      .replace(/\n/g, '\\n')
-      .replace(/\r/g, '\\r')
-      .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
-      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
-  }
+    function literalEscape(s) {
+      return s
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g,  '\\"')
+        .replace(/\0/g, '\\0')
+        .replace(/\t/g, '\\t')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
+        .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
+    }
 
-  function classEscape(s) {
-    return s
-      .replace(/\\/g, '\\\\')
-      .replace(/\]/g, '\\]')
-      .replace(/\^/g, '\\^')
-      .replace(/-/g,  '\\-')
-      .replace(/\0/g, '\\0')
-      .replace(/\t/g, '\\t')
-      .replace(/\n/g, '\\n')
-      .replace(/\r/g, '\\r')
-      .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
-      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
-  }
+    function classEscape(s) {
+      return s
+        .replace(/\\/g, '\\\\')
+        .replace(/\]/g, '\\]')
+        .replace(/\^/g, '\\^')
+        .replace(/-/g,  '\\-')
+        .replace(/\0/g, '\\0')
+        .replace(/\t/g, '\\t')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
+        .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
+    }
 
-  function describeExpectation(expectation) {
-    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
-  }
+    function describeExpectation(expectation) {
+      return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+    }
 
-  function describeExpected(expected) {
-    var descriptions = new Array(expected.length),
-        i, j;
+    function describeExpected(expected) {
+      var descriptions = new Array(expected.length),
+          i, j;
 
-    for (i = 0; i < expected.length; i++) {
-      descriptions[i] = describeExpectation(expected[i]);
-    }
+      for (i = 0; i < expected.length; i++) {
+        descriptions[i] = describeExpectation(expected[i]);
+      }
 
-    descriptions.sort();
+      descriptions.sort();
 
-    if (descriptions.length > 0) {
-      for (i = 1, j = 1; i < descriptions.length; i++) {
-        if (descriptions[i - 1] !== descriptions[i]) {
-          descriptions[j] = descriptions[i];
-          j++;
+      if (descriptions.length > 0) {
+        for (i = 1, j = 1; i < descriptions.length; i++) {
+          if (descriptions[i - 1] !== descriptions[i]) {
+            descriptions[j] = descriptions[i];
+            j++;
+          }
         }
+        descriptions.length = j;
       }
-      descriptions.length = j;
-    }
 
-    switch (descriptions.length) {
-      case 1:
-        return descriptions[0];
+      switch (descriptions.length) {
+        case 1:
+          return descriptions[0];
 
-      case 2:
-        return descriptions[0] + " or " + descriptions[1];
+        case 2:
+          return descriptions[0] + " or " + descriptions[1];
 
-      default:
-        return descriptions.slice(0, -1).join(", ")
-          + ", or "
-          + descriptions[descriptions.length - 1];
+        default:
+          return descriptions.slice(0, -1).join(", ")
+            + ", or "
+            + descriptions[descriptions.length - 1];
+      }
     }
-  }
-
-  function describeFound(found) {
-    return found ? "\"" + literalEscape(found) + "\"" : "end of input";
-  }
-
-  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
-};
 
-function peg$parse(input, options) {
-  options = options !== void 0 ? options : {};
+    function describeFound(found) {
+      return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+    }
 
-  var peg$FAILED = {},
+    return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+  };
+
+  function peg$parse(input, options) {
+    options = options !== void 0 ? options : {};
+
+    var peg$FAILED = {},
+
+        peg$startRuleFunctions = { Block_List: peg$parseBlock_List },
+        peg$startRuleFunction  = peg$parseBlock_List,
+
+        peg$c0 = peg$anyExpectation(),
+        peg$c1 = function(pre, b, html) { /** <?php return array( $b, $html ); ?> **/ return [ b, html ] },
+        peg$c2 = function(pre, bs, post) { /** <?php return peg_join_blocks( $pre, $bs, $post ); ?> **/
+            return joinBlocks( pre, bs, post );
+          },
+        peg$c3 = "<!--",
+        peg$c4 = peg$literalExpectation("<!--", false),
+        peg$c5 = "wp:",
+        peg$c6 = peg$literalExpectation("wp:", false),
+        peg$c7 = function(blockName, a) {
+            /** <?php return $a; ?> **/
+            return a;
+          },
+        peg$c8 = "/-->",
+        peg$c9 = peg$literalExpectation("/-->", false),
+        peg$c10 = function(blockName, attrs) {
+            /** <?php
+            return array(
+              'blockName'  => $blockName,
+              'attrs'      => $attrs,
+              'innerBlocks' => array(),
+              'innerHTML' => '',
+            );
+            ?> **/
+
+            return {
+              blockName: blockName,
+              attrs: attrs,
+              innerBlocks: [],
+              innerHTML: ''
+            };
+          },
+        peg$c11 = function(s, children, e) {
+            /** <?php
+            list( $innerHTML, $innerBlocks ) = peg_array_partition( $children, 'is_string' );
+
+            return array(
+              'blockName'  => $s['blockName'],
+              'attrs'      => $s['attrs'],
+              'innerBlocks'  => $innerBlocks,
+              'innerHTML'  => implode( '', $innerHTML ),
+            );
+            ?> **/
+
+            var innerContent = partition( function( a ) { return 'string' === typeof a }, children );
+            var innerHTML = innerContent[ 0 ];
+            var innerBlocks = innerContent[ 1 ];
+
+            return {
+              blockName: s.blockName,
+              attrs: s.attrs,
+              innerBlocks: innerBlocks,
+              innerHTML: innerHTML.join( '' )
+            };
+          },
+        peg$c12 = "-->",
+        peg$c13 = peg$literalExpectation("-->", false),
+        peg$c14 = function(blockName, attrs) {
+            /** <?php
+            return array(
+              'blockName' => $blockName,
+              'attrs'     => $attrs,
+            );
+            ?> **/
+
+            return {
+              blockName: blockName,
+              attrs: attrs
+            };
+          },
+        peg$c15 = "/wp:",
+        peg$c16 = peg$literalExpectation("/wp:", false),
+        peg$c17 = function(blockName) {
+            /** <?php
+            return array(
+              'blockName' => $blockName,
+            );
+            ?> **/
+
+            return {
+              blockName: blockName
+            };
+          },
+        peg$c18 = "/",
+        peg$c19 = peg$literalExpectation("/", false),
+        peg$c20 = function(type) {
+            /** <?php return "core/$type"; ?> **/
+            return 'core/' + type;
+          },
+        peg$c21 = /^[a-z]/,
+        peg$c22 = peg$classExpectation([["a", "z"]], false, false),
+        peg$c23 = /^[a-z0-9_\-]/,
+        peg$c24 = peg$classExpectation([["a", "z"], ["0", "9"], "_", "-"], false, false),
+        peg$c25 = peg$otherExpectation("JSON-encoded attributes embedded in a block's opening comment"),
+        peg$c26 = "{",
+        peg$c27 = peg$literalExpectation("{", false),
+        peg$c28 = "}",
+        peg$c29 = peg$literalExpectation("}", false),
+        peg$c30 = "",
+        peg$c31 = function(attrs) {
+            /** <?php return json_decode( $attrs, true ); ?> **/
+            return maybeJSON( attrs );
+          },
+        peg$c32 = /^[ \t\r\n]/,
+        peg$c33 = peg$classExpectation([" ", "\t", "\r", "\n"], false, false),
+
+        peg$currPos          = 0,
+        peg$savedPos         = 0,
+        peg$posDetailsCache  = [{ line: 1, column: 1 }],
+        peg$maxFailPos       = 0,
+        peg$maxFailExpected  = [],
+        peg$silentFails      = 0,
+
+        peg$result;
+
+    if ("startRule" in options) {
+      if (!(options.startRule in peg$startRuleFunctions)) {
+        throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+      }
 
-      peg$startRuleFunctions = { Block_List: peg$parseBlock_List },
-      peg$startRuleFunction  = peg$parseBlock_List,
+      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+    }
 
-      peg$c0 = peg$anyExpectation(),
-      peg$c1 = function(pre, b, html) { /** <?php return array( $b, $html ); ?> **/ return [ b, html ] },
-      peg$c2 = function(pre, bs, post) { /** <?php return peg_join_blocks( $pre, $bs, $post ); ?> **/
-          return joinBlocks( pre, bs, post );
-        },
-      peg$c3 = "<!--",
-      peg$c4 = peg$literalExpectation("<!--", false),
-      peg$c5 = "wp:",
-      peg$c6 = peg$literalExpectation("wp:", false),
-      peg$c7 = function(blockName, a) {
-          /** <?php return $a; ?> **/
-          return a;
-        },
-      peg$c8 = "/-->",
-      peg$c9 = peg$literalExpectation("/-->", false),
-      peg$c10 = function(blockName, attrs) {
-          /** <?php
-          return array(
-            'blockName'  => $blockName,
-            'attrs'      => $attrs,
-            'innerBlocks' => array(),
-            'innerHTML' => '',
-          );
-          ?> **/
-
-          return {
-            blockName: blockName,
-            attrs: attrs,
-            innerBlocks: [],
-            innerHTML: ''
-          };
-        },
-      peg$c11 = function(s, children, e) {
-          /** <?php
-          list( $innerHTML, $innerBlocks ) = peg_array_partition( $children, 'is_string' );
-
-          return array(
-            'blockName'  => $s['blockName'],
-            'attrs'      => $s['attrs'],
-            'innerBlocks'  => $innerBlocks,
-            'innerHTML'  => implode( '', $innerHTML ),
-          );
-          ?> **/
-
-          var innerContent = partition( function( a ) { return 'string' === typeof a }, children );
-          var innerHTML = innerContent[ 0 ];
-          var innerBlocks = innerContent[ 1 ];
-
-          return {
-            blockName: s.blockName,
-            attrs: s.attrs,
-            innerBlocks: innerBlocks,
-            innerHTML: innerHTML.join( '' )
-          };
-        },
-      peg$c12 = "-->",
-      peg$c13 = peg$literalExpectation("-->", false),
-      peg$c14 = function(blockName, attrs) {
-          /** <?php
-          return array(
-            'blockName' => $blockName,
-            'attrs'     => $attrs,
-          );
-          ?> **/
-
-          return {
-            blockName: blockName,
-            attrs: attrs
-          };
-        },
-      peg$c15 = "/wp:",
-      peg$c16 = peg$literalExpectation("/wp:", false),
-      peg$c17 = function(blockName) {
-          /** <?php
-          return array(
-            'blockName' => $blockName,
-          );
-          ?> **/
-
-          return {
-            blockName: blockName
-          };
-        },
-      peg$c18 = "/",
-      peg$c19 = peg$literalExpectation("/", false),
-      peg$c20 = function(type) {
-          /** <?php return "core/$type"; ?> **/
-          return 'core/' + type;
-        },
-      peg$c21 = /^[a-z]/,
-      peg$c22 = peg$classExpectation([["a", "z"]], false, false),
-      peg$c23 = /^[a-z0-9_\-]/,
-      peg$c24 = peg$classExpectation([["a", "z"], ["0", "9"], "_", "-"], false, false),
-      peg$c25 = peg$otherExpectation("JSON-encoded attributes embedded in a block's opening comment"),
-      peg$c26 = "{",
-      peg$c27 = peg$literalExpectation("{", false),
-      peg$c28 = "}",
-      peg$c29 = peg$literalExpectation("}", false),
-      peg$c30 = "",
-      peg$c31 = function(attrs) {
-          /** <?php return json_decode( $attrs, true ); ?> **/
-          return maybeJSON( attrs );
-        },
-      peg$c32 = /^[ \t\r\n]/,
-      peg$c33 = peg$classExpectation([" ", "\t", "\r", "\n"], false, false),
+    function text() {
+      return input.substring(peg$savedPos, peg$currPos);
+    }
 
-      peg$currPos          = 0,
-      peg$savedPos         = 0,
-      peg$posDetailsCache  = [{ line: 1, column: 1 }],
-      peg$maxFailPos       = 0,
-      peg$maxFailExpected  = [],
-      peg$silentFails      = 0,
+    function location() {
+      return peg$computeLocation(peg$savedPos, peg$currPos);
+    }
 
-      peg$result;
+    function expected(description, location) {
+      location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
 
-  if ("startRule" in options) {
-    if (!(options.startRule in peg$startRuleFunctions)) {
-      throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+      throw peg$buildStructuredError(
+        [peg$otherExpectation(description)],
+        input.substring(peg$savedPos, peg$currPos),
+        location
+      );
     }
 
-    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
-  }
-
-  function text() {
-    return input.substring(peg$savedPos, peg$currPos);
-  }
+    function error(message, location) {
+      location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
 
-  function location() {
-    return peg$computeLocation(peg$savedPos, peg$currPos);
-  }
+      throw peg$buildSimpleError(message, location);
+    }
 
-  function expected(description, location) {
-    location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
+    function peg$literalExpectation(text, ignoreCase) {
+      return { type: "literal", text: text, ignoreCase: ignoreCase };
+    }
 
-    throw peg$buildStructuredError(
-      [peg$otherExpectation(description)],
-      input.substring(peg$savedPos, peg$currPos),
-      location
-    );
-  }
+    function peg$classExpectation(parts, inverted, ignoreCase) {
+      return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
+    }
 
-  function error(message, location) {
-    location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
+    function peg$anyExpectation() {
+      return { type: "any" };
+    }
 
-    throw peg$buildSimpleError(message, location);
-  }
+    function peg$endExpectation() {
+      return { type: "end" };
+    }
 
-  function peg$literalExpectation(text, ignoreCase) {
-    return { type: "literal", text: text, ignoreCase: ignoreCase };
-  }
+    function peg$otherExpectation(description) {
+      return { type: "other", description: description };
+    }
 
-  function peg$classExpectation(parts, inverted, ignoreCase) {
-    return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
-  }
+    function peg$computePosDetails(pos) {
+      var details = peg$posDetailsCache[pos], p;
 
-  function peg$anyExpectation() {
-    return { type: "any" };
-  }
+      if (details) {
+        return details;
+      } else {
+        p = pos - 1;
+        while (!peg$posDetailsCache[p]) {
+          p--;
+        }
 
-  function peg$endExpectation() {
-    return { type: "end" };
-  }
+        details = peg$posDetailsCache[p];
+        details = {
+          line:   details.line,
+          column: details.column
+        };
 
-  function peg$otherExpectation(description) {
-    return { type: "other", description: description };
-  }
+        while (p < pos) {
+          if (input.charCodeAt(p) === 10) {
+            details.line++;
+            details.column = 1;
+          } else {
+            details.column++;
+          }
 
-  function peg$computePosDetails(pos) {
-    var details = peg$posDetailsCache[pos], p;
+          p++;
+        }
 
-    if (details) {
-      return details;
-    } else {
-      p = pos - 1;
-      while (!peg$posDetailsCache[p]) {
-        p--;
+        peg$posDetailsCache[pos] = details;
+        return details;
       }
+    }
 
-      details = peg$posDetailsCache[p];
-      details = {
-        line:   details.line,
-        column: details.column
-      };
+    function peg$computeLocation(startPos, endPos) {
+      var startPosDetails = peg$computePosDetails(startPos),
+          endPosDetails   = peg$computePosDetails(endPos);
 
-      while (p < pos) {
-        if (input.charCodeAt(p) === 10) {
-          details.line++;
-          details.column = 1;
-        } else {
-          details.column++;
+      return {
+        start: {
+          offset: startPos,
+          line:   startPosDetails.line,
+          column: startPosDetails.column
+        },
+        end: {
+          offset: endPos,
+          line:   endPosDetails.line,
+          column: endPosDetails.column
         }
-
-        p++;
-      }
-
-      peg$posDetailsCache[pos] = details;
-      return details;
+      };
     }
-  }
 
-  function peg$computeLocation(startPos, endPos) {
-    var startPosDetails = peg$computePosDetails(startPos),
-        endPosDetails   = peg$computePosDetails(endPos);
-
-    return {
-      start: {
-        offset: startPos,
-        line:   startPosDetails.line,
-        column: startPosDetails.column
-      },
-      end: {
-        offset: endPos,
-        line:   endPosDetails.line,
-        column: endPosDetails.column
-      }
-    };
-  }
+    function peg$fail(expected) {
+      if (peg$currPos < peg$maxFailPos) { return; }
 
-  function peg$fail(expected) {
-    if (peg$currPos < peg$maxFailPos) { return; }
+      if (peg$currPos > peg$maxFailPos) {
+        peg$maxFailPos = peg$currPos;
+        peg$maxFailExpected = [];
+      }
 
-    if (peg$currPos > peg$maxFailPos) {
-      peg$maxFailPos = peg$currPos;
-      peg$maxFailExpected = [];
+      peg$maxFailExpected.push(expected);
     }
 
-    peg$maxFailExpected.push(expected);
-  }
+    function peg$buildSimpleError(message, location) {
+      return new peg$SyntaxError(message, null, null, location);
+    }
 
-  function peg$buildSimpleError(message, location) {
-    return new peg$SyntaxError(message, null, null, location);
-  }
+    function peg$buildStructuredError(expected, found, location) {
+      return new peg$SyntaxError(
+        peg$SyntaxError.buildMessage(expected, found),
+        expected,
+        found,
+        location
+      );
+    }
 
-  function peg$buildStructuredError(expected, found, location) {
-    return new peg$SyntaxError(
-      peg$SyntaxError.buildMessage(expected, found),
-      expected,
-      found,
-      location
-    );
-  }
+    function peg$parseBlock_List() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
 
-  function peg$parseBlock_List() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
-
-    s0 = peg$currPos;
-    s1 = peg$currPos;
-    s2 = [];
-    s3 = peg$currPos;
-    s4 = peg$currPos;
-    peg$silentFails++;
-    s5 = peg$parseBlock();
-    peg$silentFails--;
-    if (s5 === peg$FAILED) {
-      s4 = void 0;
-    } else {
-      peg$currPos = s4;
-      s4 = peg$FAILED;
-    }
-    if (s4 !== peg$FAILED) {
-      if (input.length > peg$currPos) {
-        s5 = input.charAt(peg$currPos);
-        peg$currPos++;
-      } else {
-        s5 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c0); }
-      }
-      if (s5 !== peg$FAILED) {
-        s4 = [s4, s5];
-        s3 = s4;
-      } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
-      }
-    } else {
-      peg$currPos = s3;
-      s3 = peg$FAILED;
-    }
-    while (s3 !== peg$FAILED) {
-      s2.push(s3);
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = [];
       s3 = peg$currPos;
       s4 = peg$currPos;
       peg$silentFails++;
@@ -451,101 +425,46 @@ function peg$parse(input, options) {
         peg$currPos = s3;
         s3 = peg$FAILED;
       }
-    }
-    if (s2 !== peg$FAILED) {
-      s1 = input.substring(s1, peg$currPos);
-    } else {
-      s1 = s2;
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = [];
-      s3 = peg$currPos;
-      s4 = peg$parseBlock();
-      if (s4 !== peg$FAILED) {
-        s5 = peg$currPos;
-        s6 = [];
-        s7 = peg$currPos;
-        s8 = peg$currPos;
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        s4 = peg$currPos;
         peg$silentFails++;
-        s9 = peg$parseBlock();
+        s5 = peg$parseBlock();
         peg$silentFails--;
-        if (s9 === peg$FAILED) {
-          s8 = void 0;
+        if (s5 === peg$FAILED) {
+          s4 = void 0;
         } else {
-          peg$currPos = s8;
-          s8 = peg$FAILED;
+          peg$currPos = s4;
+          s4 = peg$FAILED;
         }
-        if (s8 !== peg$FAILED) {
+        if (s4 !== peg$FAILED) {
           if (input.length > peg$currPos) {
-            s9 = input.charAt(peg$currPos);
+            s5 = input.charAt(peg$currPos);
             peg$currPos++;
           } else {
-            s9 = peg$FAILED;
+            s5 = peg$FAILED;
             if (peg$silentFails === 0) { peg$fail(peg$c0); }
           }
-          if (s9 !== peg$FAILED) {
-            s8 = [s8, s9];
-            s7 = s8;
-          } else {
-            peg$currPos = s7;
-            s7 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s7;
-          s7 = peg$FAILED;
-        }
-        while (s7 !== peg$FAILED) {
-          s6.push(s7);
-          s7 = peg$currPos;
-          s8 = peg$currPos;
-          peg$silentFails++;
-          s9 = peg$parseBlock();
-          peg$silentFails--;
-          if (s9 === peg$FAILED) {
-            s8 = void 0;
-          } else {
-            peg$currPos = s8;
-            s8 = peg$FAILED;
-          }
-          if (s8 !== peg$FAILED) {
-            if (input.length > peg$currPos) {
-              s9 = input.charAt(peg$currPos);
-              peg$currPos++;
-            } else {
-              s9 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$c0); }
-            }
-            if (s9 !== peg$FAILED) {
-              s8 = [s8, s9];
-              s7 = s8;
-            } else {
-              peg$currPos = s7;
-              s7 = peg$FAILED;
-            }
+          if (s5 !== peg$FAILED) {
+            s4 = [s4, s5];
+            s3 = s4;
           } else {
-            peg$currPos = s7;
-            s7 = peg$FAILED;
+            peg$currPos = s3;
+            s3 = peg$FAILED;
           }
-        }
-        if (s6 !== peg$FAILED) {
-          s5 = input.substring(s5, peg$currPos);
-        } else {
-          s5 = s6;
-        }
-        if (s5 !== peg$FAILED) {
-          peg$savedPos = s3;
-          s4 = peg$c1(s1, s4, s5);
-          s3 = s4;
         } else {
           peg$currPos = s3;
           s3 = peg$FAILED;
         }
+      }
+      if (s2 !== peg$FAILED) {
+        s1 = input.substring(s1, peg$currPos);
       } else {
-        peg$currPos = s3;
-        s3 = peg$FAILED;
+        s1 = s2;
       }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
+      if (s1 !== peg$FAILED) {
+        s2 = [];
         s3 = peg$currPos;
         s4 = peg$parseBlock();
         if (s4 !== peg$FAILED) {
@@ -631,19 +550,97 @@ function peg$parse(input, options) {
           peg$currPos = s3;
           s3 = peg$FAILED;
         }
-      }
-      if (s2 !== peg$FAILED) {
-        s3 = peg$currPos;
-        s4 = [];
-        if (input.length > peg$currPos) {
-          s5 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c0); }
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$currPos;
+          s4 = peg$parseBlock();
+          if (s4 !== peg$FAILED) {
+            s5 = peg$currPos;
+            s6 = [];
+            s7 = peg$currPos;
+            s8 = peg$currPos;
+            peg$silentFails++;
+            s9 = peg$parseBlock();
+            peg$silentFails--;
+            if (s9 === peg$FAILED) {
+              s8 = void 0;
+            } else {
+              peg$currPos = s8;
+              s8 = peg$FAILED;
+            }
+            if (s8 !== peg$FAILED) {
+              if (input.length > peg$currPos) {
+                s9 = input.charAt(peg$currPos);
+                peg$currPos++;
+              } else {
+                s9 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c0); }
+              }
+              if (s9 !== peg$FAILED) {
+                s8 = [s8, s9];
+                s7 = s8;
+              } else {
+                peg$currPos = s7;
+                s7 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s7;
+              s7 = peg$FAILED;
+            }
+            while (s7 !== peg$FAILED) {
+              s6.push(s7);
+              s7 = peg$currPos;
+              s8 = peg$currPos;
+              peg$silentFails++;
+              s9 = peg$parseBlock();
+              peg$silentFails--;
+              if (s9 === peg$FAILED) {
+                s8 = void 0;
+              } else {
+                peg$currPos = s8;
+                s8 = peg$FAILED;
+              }
+              if (s8 !== peg$FAILED) {
+                if (input.length > peg$currPos) {
+                  s9 = input.charAt(peg$currPos);
+                  peg$currPos++;
+                } else {
+                  s9 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c0); }
+                }
+                if (s9 !== peg$FAILED) {
+                  s8 = [s8, s9];
+                  s7 = s8;
+                } else {
+                  peg$currPos = s7;
+                  s7 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s7;
+                s7 = peg$FAILED;
+              }
+            }
+            if (s6 !== peg$FAILED) {
+              s5 = input.substring(s5, peg$currPos);
+            } else {
+              s5 = s6;
+            }
+            if (s5 !== peg$FAILED) {
+              peg$savedPos = s3;
+              s4 = peg$c1(s1, s4, s5);
+              s3 = s4;
+            } else {
+              peg$currPos = s3;
+              s3 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
         }
-        while (s5 !== peg$FAILED) {
-          s4.push(s5);
+        if (s2 !== peg$FAILED) {
+          s3 = peg$currPos;
+          s4 = [];
           if (input.length > peg$currPos) {
             s5 = input.charAt(peg$currPos);
             peg$currPos++;
@@ -651,16 +648,29 @@ function peg$parse(input, options) {
             s5 = peg$FAILED;
             if (peg$silentFails === 0) { peg$fail(peg$c0); }
           }
-        }
-        if (s4 !== peg$FAILED) {
-          s3 = input.substring(s3, peg$currPos);
-        } else {
-          s3 = s4;
-        }
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s1 = peg$c2(s1, s2, s3);
-          s0 = s1;
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            if (input.length > peg$currPos) {
+              s5 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c0); }
+            }
+          }
+          if (s4 !== peg$FAILED) {
+            s3 = input.substring(s3, peg$currPos);
+          } else {
+            s3 = s4;
+          }
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c2(s1, s2, s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -669,82 +679,82 @@ function peg$parse(input, options) {
         peg$currPos = s0;
         s0 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
+
+      return s0;
     }
 
-    return s0;
-  }
+    function peg$parseBlock() {
+      var s0;
 
-  function peg$parseBlock() {
-    var s0;
+      s0 = peg$parseBlock_Void();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseBlock_Balanced();
+      }
 
-    s0 = peg$parseBlock_Void();
-    if (s0 === peg$FAILED) {
-      s0 = peg$parseBlock_Balanced();
+      return s0;
     }
 
-    return s0;
-  }
-
-  function peg$parseBlock_Void() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+    function peg$parseBlock_Void() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 4) === peg$c3) {
-      s1 = peg$c3;
-      peg$currPos += 4;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$c4); }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parse__();
-      if (s2 !== peg$FAILED) {
-        if (input.substr(peg$currPos, 3) === peg$c5) {
-          s3 = peg$c5;
-          peg$currPos += 3;
-        } else {
-          s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c6); }
-        }
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseBlock_Name();
-          if (s4 !== peg$FAILED) {
-            s5 = peg$parse__();
-            if (s5 !== peg$FAILED) {
-              s6 = peg$currPos;
-              s7 = peg$parseBlock_Attributes();
-              if (s7 !== peg$FAILED) {
-                s8 = peg$parse__();
-                if (s8 !== peg$FAILED) {
-                  peg$savedPos = s6;
-                  s7 = peg$c7(s4, s7);
-                  s6 = s7;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 4) === peg$c3) {
+        s1 = peg$c3;
+        peg$currPos += 4;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c4); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parse__();
+        if (s2 !== peg$FAILED) {
+          if (input.substr(peg$currPos, 3) === peg$c5) {
+            s3 = peg$c5;
+            peg$currPos += 3;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c6); }
+          }
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parseBlock_Name();
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parse__();
+              if (s5 !== peg$FAILED) {
+                s6 = peg$currPos;
+                s7 = peg$parseBlock_Attributes();
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parse__();
+                  if (s8 !== peg$FAILED) {
+                    peg$savedPos = s6;
+                    s7 = peg$c7(s4, s7);
+                    s6 = s7;
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
                 } else {
                   peg$currPos = s6;
                   s6 = peg$FAILED;
                 }
-              } else {
-                peg$currPos = s6;
-                s6 = peg$FAILED;
-              }
-              if (s6 === peg$FAILED) {
-                s6 = null;
-              }
-              if (s6 !== peg$FAILED) {
-                if (input.substr(peg$currPos, 4) === peg$c8) {
-                  s7 = peg$c8;
-                  peg$currPos += 4;
-                } else {
-                  s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$c9); }
+                if (s6 === peg$FAILED) {
+                  s6 = null;
                 }
-                if (s7 !== peg$FAILED) {
-                  peg$savedPos = s0;
-                  s1 = peg$c10(s4, s6);
-                  s0 = s1;
+                if (s6 !== peg$FAILED) {
+                  if (input.substr(peg$currPos, 4) === peg$c8) {
+                    s7 = peg$c8;
+                    peg$currPos += 4;
+                  } else {
+                    s7 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c9); }
+                  }
+                  if (s7 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s1 = peg$c10(s4, s6);
+                    s0 = s1;
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -769,62 +779,17 @@ function peg$parse(input, options) {
         peg$currPos = s0;
         s0 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
 
-    return s0;
-  }
+      return s0;
+    }
 
-  function peg$parseBlock_Balanced() {
-    var s0, s1, s2, s3, s4, s5, s6;
+    function peg$parseBlock_Balanced() {
+      var s0, s1, s2, s3, s4, s5, s6;
 
-    s0 = peg$currPos;
-    s1 = peg$parseBlock_Start();
-    if (s1 !== peg$FAILED) {
-      s2 = [];
-      s3 = peg$parseBlock();
-      if (s3 === peg$FAILED) {
-        s3 = peg$currPos;
-        s4 = peg$currPos;
-        s5 = peg$currPos;
-        peg$silentFails++;
-        s6 = peg$parseBlock_End();
-        peg$silentFails--;
-        if (s6 === peg$FAILED) {
-          s5 = void 0;
-        } else {
-          peg$currPos = s5;
-          s5 = peg$FAILED;
-        }
-        if (s5 !== peg$FAILED) {
-          if (input.length > peg$currPos) {
-            s6 = input.charAt(peg$currPos);
-            peg$currPos++;
-          } else {
-            s6 = peg$FAILED;
-            if (peg$silentFails === 0) { peg$fail(peg$c0); }
-          }
-          if (s6 !== peg$FAILED) {
-            s5 = [s5, s6];
-            s4 = s5;
-          } else {
-            peg$currPos = s4;
-            s4 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s4;
-          s4 = peg$FAILED;
-        }
-        if (s4 !== peg$FAILED) {
-          s3 = input.substring(s3, peg$currPos);
-        } else {
-          s3 = s4;
-        }
-      }
-      while (s3 !== peg$FAILED) {
-        s2.push(s3);
+      s0 = peg$currPos;
+      s1 = peg$parseBlock_Start();
+      if (s1 !== peg$FAILED) {
+        s2 = [];
         s3 = peg$parseBlock();
         if (s3 === peg$FAILED) {
           s3 = peg$currPos;
@@ -864,13 +829,58 @@ function peg$parse(input, options) {
             s3 = s4;
           }
         }
-      }
-      if (s2 !== peg$FAILED) {
-        s3 = peg$parseBlock_End();
-        if (s3 !== peg$FAILED) {
-          peg$savedPos = s0;
-          s1 = peg$c11(s1, s2, s3);
-          s0 = s1;
+        while (s3 !== peg$FAILED) {
+          s2.push(s3);
+          s3 = peg$parseBlock();
+          if (s3 === peg$FAILED) {
+            s3 = peg$currPos;
+            s4 = peg$currPos;
+            s5 = peg$currPos;
+            peg$silentFails++;
+            s6 = peg$parseBlock_End();
+            peg$silentFails--;
+            if (s6 === peg$FAILED) {
+              s5 = void 0;
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+            if (s5 !== peg$FAILED) {
+              if (input.length > peg$currPos) {
+                s6 = input.charAt(peg$currPos);
+                peg$currPos++;
+              } else {
+                s6 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c0); }
+              }
+              if (s6 !== peg$FAILED) {
+                s5 = [s5, s6];
+                s4 = s5;
+              } else {
+                peg$currPos = s4;
+                s4 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s4;
+              s4 = peg$FAILED;
+            }
+            if (s4 !== peg$FAILED) {
+              s3 = input.substring(s3, peg$currPos);
+            } else {
+              s3 = s4;
+            }
+          }
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parseBlock_End();
+          if (s3 !== peg$FAILED) {
+            peg$savedPos = s0;
+            s1 = peg$c11(s1, s2, s3);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -879,71 +889,71 @@ function peg$parse(input, options) {
         peg$currPos = s0;
         s0 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
 
-    return s0;
-  }
+      return s0;
+    }
 
-  function peg$parseBlock_Start() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8;
+    function peg$parseBlock_Start() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8;
 
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 4) === peg$c3) {
-      s1 = peg$c3;
-      peg$currPos += 4;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$c4); }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parse__();
-      if (s2 !== peg$FAILED) {
-        if (input.substr(peg$currPos, 3) === peg$c5) {
-          s3 = peg$c5;
-          peg$currPos += 3;
-        } else {
-          s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c6); }
-        }
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseBlock_Name();
-          if (s4 !== peg$FAILED) {
-            s5 = peg$parse__();
-            if (s5 !== peg$FAILED) {
-              s6 = peg$currPos;
-              s7 = peg$parseBlock_Attributes();
-              if (s7 !== peg$FAILED) {
-                s8 = peg$parse__();
-                if (s8 !== peg$FAILED) {
-                  peg$savedPos = s6;
-                  s7 = peg$c7(s4, s7);
-                  s6 = s7;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 4) === peg$c3) {
+        s1 = peg$c3;
+        peg$currPos += 4;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c4); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parse__();
+        if (s2 !== peg$FAILED) {
+          if (input.substr(peg$currPos, 3) === peg$c5) {
+            s3 = peg$c5;
+            peg$currPos += 3;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c6); }
+          }
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parseBlock_Name();
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parse__();
+              if (s5 !== peg$FAILED) {
+                s6 = peg$currPos;
+                s7 = peg$parseBlock_Attributes();
+                if (s7 !== peg$FAILED) {
+                  s8 = peg$parse__();
+                  if (s8 !== peg$FAILED) {
+                    peg$savedPos = s6;
+                    s7 = peg$c7(s4, s7);
+                    s6 = s7;
+                  } else {
+                    peg$currPos = s6;
+                    s6 = peg$FAILED;
+                  }
                 } else {
                   peg$currPos = s6;
                   s6 = peg$FAILED;
                 }
-              } else {
-                peg$currPos = s6;
-                s6 = peg$FAILED;
-              }
-              if (s6 === peg$FAILED) {
-                s6 = null;
-              }
-              if (s6 !== peg$FAILED) {
-                if (input.substr(peg$currPos, 3) === peg$c12) {
-                  s7 = peg$c12;
-                  peg$currPos += 3;
-                } else {
-                  s7 = peg$FAILED;
-                  if (peg$silentFails === 0) { peg$fail(peg$c13); }
+                if (s6 === peg$FAILED) {
+                  s6 = null;
                 }
-                if (s7 !== peg$FAILED) {
-                  peg$savedPos = s0;
-                  s1 = peg$c14(s4, s6);
-                  s0 = s1;
+                if (s6 !== peg$FAILED) {
+                  if (input.substr(peg$currPos, 3) === peg$c12) {
+                    s7 = peg$c12;
+                    peg$currPos += 3;
+                  } else {
+                    s7 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c13); }
+                  }
+                  if (s7 !== peg$FAILED) {
+                    peg$savedPos = s0;
+                    s1 = peg$c14(s4, s6);
+                    s0 = s1;
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
                 } else {
                   peg$currPos = s0;
                   s0 = peg$FAILED;
@@ -968,51 +978,51 @@ function peg$parse(input, options) {
         peg$currPos = s0;
         s0 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
-    }
 
-    return s0;
-  }
+      return s0;
+    }
 
-  function peg$parseBlock_End() {
-    var s0, s1, s2, s3, s4, s5, s6;
+    function peg$parseBlock_End() {
+      var s0, s1, s2, s3, s4, s5, s6;
 
-    s0 = peg$currPos;
-    if (input.substr(peg$currPos, 4) === peg$c3) {
-      s1 = peg$c3;
-      peg$currPos += 4;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$c4); }
-    }
-    if (s1 !== peg$FAILED) {
-      s2 = peg$parse__();
-      if (s2 !== peg$FAILED) {
-        if (input.substr(peg$currPos, 4) === peg$c15) {
-          s3 = peg$c15;
-          peg$currPos += 4;
-        } else {
-          s3 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c16); }
-        }
-        if (s3 !== peg$FAILED) {
-          s4 = peg$parseBlock_Name();
-          if (s4 !== peg$FAILED) {
-            s5 = peg$parse__();
-            if (s5 !== peg$FAILED) {
-              if (input.substr(peg$currPos, 3) === peg$c12) {
-                s6 = peg$c12;
-                peg$currPos += 3;
-              } else {
-                s6 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$c13); }
-              }
-              if (s6 !== peg$FAILED) {
-                peg$savedPos = s0;
-                s1 = peg$c17(s4);
-                s0 = s1;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 4) === peg$c3) {
+        s1 = peg$c3;
+        peg$currPos += 4;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c4); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parse__();
+        if (s2 !== peg$FAILED) {
+          if (input.substr(peg$currPos, 4) === peg$c15) {
+            s3 = peg$c15;
+            peg$currPos += 4;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c16); }
+          }
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parseBlock_Name();
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parse__();
+              if (s5 !== peg$FAILED) {
+                if (input.substr(peg$currPos, 3) === peg$c12) {
+                  s6 = peg$c12;
+                  peg$currPos += 3;
+                } else {
+                  s6 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c13); }
+                }
+                if (s6 !== peg$FAILED) {
+                  peg$savedPos = s0;
+                  s1 = peg$c17(s4);
+                  s0 = s1;
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
               } else {
                 peg$currPos = s0;
                 s0 = peg$FAILED;
@@ -1033,44 +1043,44 @@ function peg$parse(input, options) {
         peg$currPos = s0;
         s0 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s0;
-      s0 = peg$FAILED;
+
+      return s0;
     }
 
-    return s0;
-  }
+    function peg$parseBlock_Name() {
+      var s0;
 
-  function peg$parseBlock_Name() {
-    var s0;
+      s0 = peg$parseNamespaced_Block_Name();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parseCore_Block_Name();
+      }
 
-    s0 = peg$parseNamespaced_Block_Name();
-    if (s0 === peg$FAILED) {
-      s0 = peg$parseCore_Block_Name();
+      return s0;
     }
 
-    return s0;
-  }
-
-  function peg$parseNamespaced_Block_Name() {
-    var s0, s1, s2, s3, s4;
+    function peg$parseNamespaced_Block_Name() {
+      var s0, s1, s2, s3, s4;
 
-    s0 = peg$currPos;
-    s1 = peg$currPos;
-    s2 = peg$parseBlock_Name_Part();
-    if (s2 !== peg$FAILED) {
-      if (input.charCodeAt(peg$currPos) === 47) {
-        s3 = peg$c18;
-        peg$currPos++;
-      } else {
-        s3 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c19); }
-      }
-      if (s3 !== peg$FAILED) {
-        s4 = peg$parseBlock_Name_Part();
-        if (s4 !== peg$FAILED) {
-          s2 = [s2, s3, s4];
-          s1 = s2;
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$parseBlock_Name_Part();
+      if (s2 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 47) {
+          s3 = peg$c18;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c19); }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parseBlock_Name_Part();
+          if (s4 !== peg$FAILED) {
+            s2 = [s2, s3, s4];
+            s1 = s2;
+          } else {
+            peg$currPos = s1;
+            s1 = peg$FAILED;
+          }
         } else {
           peg$currPos = s1;
           s1 = peg$FAILED;
@@ -1079,62 +1089,49 @@ function peg$parse(input, options) {
         peg$currPos = s1;
         s1 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s1;
-      s1 = peg$FAILED;
-    }
-    if (s1 !== peg$FAILED) {
-      s0 = input.substring(s0, peg$currPos);
-    } else {
-      s0 = s1;
+      if (s1 !== peg$FAILED) {
+        s0 = input.substring(s0, peg$currPos);
+      } else {
+        s0 = s1;
+      }
+
+      return s0;
     }
 
-    return s0;
-  }
+    function peg$parseCore_Block_Name() {
+      var s0, s1, s2;
 
-  function peg$parseCore_Block_Name() {
-    var s0, s1, s2;
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$parseBlock_Name_Part();
+      if (s2 !== peg$FAILED) {
+        s1 = input.substring(s1, peg$currPos);
+      } else {
+        s1 = s2;
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c20(s1);
+      }
+      s0 = s1;
 
-    s0 = peg$currPos;
-    s1 = peg$currPos;
-    s2 = peg$parseBlock_Name_Part();
-    if (s2 !== peg$FAILED) {
-      s1 = input.substring(s1, peg$currPos);
-    } else {
-      s1 = s2;
-    }
-    if (s1 !== peg$FAILED) {
-      peg$savedPos = s0;
-      s1 = peg$c20(s1);
+      return s0;
     }
-    s0 = s1;
-
-    return s0;
-  }
 
-  function peg$parseBlock_Name_Part() {
-    var s0, s1, s2, s3, s4;
+    function peg$parseBlock_Name_Part() {
+      var s0, s1, s2, s3, s4;
 
-    s0 = peg$currPos;
-    s1 = peg$currPos;
-    if (peg$c21.test(input.charAt(peg$currPos))) {
-      s2 = input.charAt(peg$currPos);
-      peg$currPos++;
-    } else {
-      s2 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$c22); }
-    }
-    if (s2 !== peg$FAILED) {
-      s3 = [];
-      if (peg$c23.test(input.charAt(peg$currPos))) {
-        s4 = input.charAt(peg$currPos);
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      if (peg$c21.test(input.charAt(peg$currPos))) {
+        s2 = input.charAt(peg$currPos);
         peg$currPos++;
       } else {
-        s4 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c24); }
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c22); }
       }
-      while (s4 !== peg$FAILED) {
-        s3.push(s4);
+      if (s2 !== peg$FAILED) {
+        s3 = [];
         if (peg$c23.test(input.charAt(peg$currPos))) {
           s4 = input.charAt(peg$currPos);
           peg$currPos++;
@@ -1142,128 +1139,52 @@ function peg$parse(input, options) {
           s4 = peg$FAILED;
           if (peg$silentFails === 0) { peg$fail(peg$c24); }
         }
-      }
-      if (s3 !== peg$FAILED) {
-        s2 = [s2, s3];
-        s1 = s2;
+        while (s4 !== peg$FAILED) {
+          s3.push(s4);
+          if (peg$c23.test(input.charAt(peg$currPos))) {
+            s4 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c24); }
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s2 = [s2, s3];
+          s1 = s2;
+        } else {
+          peg$currPos = s1;
+          s1 = peg$FAILED;
+        }
       } else {
         peg$currPos = s1;
         s1 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s1;
-      s1 = peg$FAILED;
-    }
-    if (s1 !== peg$FAILED) {
-      s0 = input.substring(s0, peg$currPos);
-    } else {
-      s0 = s1;
-    }
+      if (s1 !== peg$FAILED) {
+        s0 = input.substring(s0, peg$currPos);
+      } else {
+        s0 = s1;
+      }
 
-    return s0;
-  }
+      return s0;
+    }
 
-  function peg$parseBlock_Attributes() {
-    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
+    function peg$parseBlock_Attributes() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
 
-    peg$silentFails++;
-    s0 = peg$currPos;
-    s1 = peg$currPos;
-    s2 = peg$currPos;
-    if (input.charCodeAt(peg$currPos) === 123) {
-      s3 = peg$c26;
-      peg$currPos++;
-    } else {
-      s3 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$c27); }
-    }
-    if (s3 !== peg$FAILED) {
-      s4 = [];
-      s5 = peg$currPos;
-      s6 = peg$currPos;
       peg$silentFails++;
-      s7 = peg$currPos;
-      if (input.charCodeAt(peg$currPos) === 125) {
-        s8 = peg$c28;
+      s0 = peg$currPos;
+      s1 = peg$currPos;
+      s2 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 123) {
+        s3 = peg$c26;
         peg$currPos++;
       } else {
-        s8 = peg$FAILED;
-        if (peg$silentFails === 0) { peg$fail(peg$c29); }
-      }
-      if (s8 !== peg$FAILED) {
-        s9 = peg$parse__();
-        if (s9 !== peg$FAILED) {
-          s10 = peg$c30;
-          if (s10 !== peg$FAILED) {
-            if (input.charCodeAt(peg$currPos) === 47) {
-              s11 = peg$c18;
-              peg$currPos++;
-            } else {
-              s11 = peg$FAILED;
-              if (peg$silentFails === 0) { peg$fail(peg$c19); }
-            }
-            if (s11 === peg$FAILED) {
-              s11 = null;
-            }
-            if (s11 !== peg$FAILED) {
-              if (input.substr(peg$currPos, 3) === peg$c12) {
-                s12 = peg$c12;
-                peg$currPos += 3;
-              } else {
-                s12 = peg$FAILED;
-                if (peg$silentFails === 0) { peg$fail(peg$c13); }
-              }
-              if (s12 !== peg$FAILED) {
-                s8 = [s8, s9, s10, s11, s12];
-                s7 = s8;
-              } else {
-                peg$currPos = s7;
-                s7 = peg$FAILED;
-              }
-            } else {
-              peg$currPos = s7;
-              s7 = peg$FAILED;
-            }
-          } else {
-            peg$currPos = s7;
-            s7 = peg$FAILED;
-          }
-        } else {
-          peg$currPos = s7;
-          s7 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s7;
-        s7 = peg$FAILED;
-      }
-      peg$silentFails--;
-      if (s7 === peg$FAILED) {
-        s6 = void 0;
-      } else {
-        peg$currPos = s6;
-        s6 = peg$FAILED;
-      }
-      if (s6 !== peg$FAILED) {
-        if (input.length > peg$currPos) {
-          s7 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s7 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c0); }
-        }
-        if (s7 !== peg$FAILED) {
-          s6 = [s6, s7];
-          s5 = s6;
-        } else {
-          peg$currPos = s5;
-          s5 = peg$FAILED;
-        }
-      } else {
-        peg$currPos = s5;
-        s5 = peg$FAILED;
+        s3 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c27); }
       }
-      while (s5 !== peg$FAILED) {
-        s4.push(s5);
+      if (s3 !== peg$FAILED) {
+        s4 = [];
         s5 = peg$currPos;
         s6 = peg$currPos;
         peg$silentFails++;
@@ -1347,18 +1268,107 @@ function peg$parse(input, options) {
           peg$currPos = s5;
           s5 = peg$FAILED;
         }
-      }
-      if (s4 !== peg$FAILED) {
-        if (input.charCodeAt(peg$currPos) === 125) {
-          s5 = peg$c28;
-          peg$currPos++;
-        } else {
-          s5 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c29); }
+        while (s5 !== peg$FAILED) {
+          s4.push(s5);
+          s5 = peg$currPos;
+          s6 = peg$currPos;
+          peg$silentFails++;
+          s7 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 125) {
+            s8 = peg$c28;
+            peg$currPos++;
+          } else {
+            s8 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c29); }
+          }
+          if (s8 !== peg$FAILED) {
+            s9 = peg$parse__();
+            if (s9 !== peg$FAILED) {
+              s10 = peg$c30;
+              if (s10 !== peg$FAILED) {
+                if (input.charCodeAt(peg$currPos) === 47) {
+                  s11 = peg$c18;
+                  peg$currPos++;
+                } else {
+                  s11 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c19); }
+                }
+                if (s11 === peg$FAILED) {
+                  s11 = null;
+                }
+                if (s11 !== peg$FAILED) {
+                  if (input.substr(peg$currPos, 3) === peg$c12) {
+                    s12 = peg$c12;
+                    peg$currPos += 3;
+                  } else {
+                    s12 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c13); }
+                  }
+                  if (s12 !== peg$FAILED) {
+                    s8 = [s8, s9, s10, s11, s12];
+                    s7 = s8;
+                  } else {
+                    peg$currPos = s7;
+                    s7 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s7;
+                  s7 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s7;
+                s7 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s7;
+              s7 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s7;
+            s7 = peg$FAILED;
+          }
+          peg$silentFails--;
+          if (s7 === peg$FAILED) {
+            s6 = void 0;
+          } else {
+            peg$currPos = s6;
+            s6 = peg$FAILED;
+          }
+          if (s6 !== peg$FAILED) {
+            if (input.length > peg$currPos) {
+              s7 = input.charAt(peg$currPos);
+              peg$currPos++;
+            } else {
+              s7 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c0); }
+            }
+            if (s7 !== peg$FAILED) {
+              s6 = [s6, s7];
+              s5 = s6;
+            } else {
+              peg$currPos = s5;
+              s5 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s5;
+            s5 = peg$FAILED;
+          }
         }
-        if (s5 !== peg$FAILED) {
-          s3 = [s3, s4, s5];
-          s2 = s3;
+        if (s4 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 125) {
+            s5 = peg$c28;
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c29); }
+          }
+          if (s5 !== peg$FAILED) {
+            s3 = [s3, s4, s5];
+            s2 = s3;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
         } else {
           peg$currPos = s2;
           s2 = peg$FAILED;
@@ -1367,234 +1377,231 @@ function peg$parse(input, options) {
         peg$currPos = s2;
         s2 = peg$FAILED;
       }
-    } else {
-      peg$currPos = s2;
-      s2 = peg$FAILED;
-    }
-    if (s2 !== peg$FAILED) {
-      s1 = input.substring(s1, peg$currPos);
-    } else {
-      s1 = s2;
-    }
-    if (s1 !== peg$FAILED) {
-      peg$savedPos = s0;
-      s1 = peg$c31(s1);
-    }
-    s0 = s1;
-    peg$silentFails--;
-    if (s0 === peg$FAILED) {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$c25); }
-    }
+      if (s2 !== peg$FAILED) {
+        s1 = input.substring(s1, peg$currPos);
+      } else {
+        s1 = s2;
+      }
+      if (s1 !== peg$FAILED) {
+        peg$savedPos = s0;
+        s1 = peg$c31(s1);
+      }
+      s0 = s1;
+      peg$silentFails--;
+      if (s0 === peg$FAILED) {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c25); }
+      }
 
-    return s0;
-  }
+      return s0;
+    }
 
-  function peg$parse__() {
-    var s0, s1;
+    function peg$parse__() {
+      var s0, s1;
 
-    s0 = [];
-    if (peg$c32.test(input.charAt(peg$currPos))) {
-      s1 = input.charAt(peg$currPos);
-      peg$currPos++;
-    } else {
-      s1 = peg$FAILED;
-      if (peg$silentFails === 0) { peg$fail(peg$c33); }
-    }
-    if (s1 !== peg$FAILED) {
-      while (s1 !== peg$FAILED) {
-        s0.push(s1);
-        if (peg$c32.test(input.charAt(peg$currPos))) {
-          s1 = input.charAt(peg$currPos);
-          peg$currPos++;
-        } else {
-          s1 = peg$FAILED;
-          if (peg$silentFails === 0) { peg$fail(peg$c33); }
+      s0 = [];
+      if (peg$c32.test(input.charAt(peg$currPos))) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c33); }
+      }
+      if (s1 !== peg$FAILED) {
+        while (s1 !== peg$FAILED) {
+          s0.push(s1);
+          if (peg$c32.test(input.charAt(peg$currPos))) {
+            s1 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c33); }
+          }
         }
+      } else {
+        s0 = peg$FAILED;
       }
-    } else {
-      s0 = peg$FAILED;
+
+      return s0;
     }
 
-    return s0;
-  }
 
 
+    /*
+     *
+     *    _____       _             _
+     *   / ____|     | |           | |
+     *  | |  __ _   _| |_ ___ _ __ | |__   ___ _ __ __ _
+     *  | | |_ | | | | __/ _ \ '_ \| '_ \ / _ \ '__/ _` |
+     *  | |__| | |_| | ||  __/ | | | |_) |  __/ | | (_| |
+     *   \_____|\__,_|\__\___|_| |_|_.__/ \___|_|  \__, |
+     *                                              __/ |
+     *                  GRAMMAR                    |___/
+     *
+     *
+     * Welcome to the grammar file for Gutenberg posts!
+     *
+     * Please don't be distracted by the functions at the top
+     * here - they're just helpers for the grammar below. We
+     * try to keep them as minimal and simple as possible,
+     * but the parser generator forces us to declare them at
+     * the beginning of the file.
+     *
+     * What follows is the official specification grammar for
+     * documents created or edited in Gutenberg. It starts at
+     * the top-level rule `Block_List`
+     *
+     * The grammar is defined by a series of _rules_ and ways
+     * to return matches on those rules. It's a _PEG_, a
+     * parsing expression grammar, which simply means that for
+     * each of our rules we have a set of sub-rules to match
+     * on and the generated parser will try them in order
+     * until it finds the first match.
+     *
+     * This grammar is a _specification_ (with as little actual
+     * code as we can get away with) which is used by the
+     * parser generator to generate the actual _parser_ which
+     * is used by Gutenberg. We generate two parsers: one in
+     * JavaScript for use the browser and one in PHP for
+     * WordPress itself. PEG parser generators are available
+     * in many languages, though different libraries may require
+     * some translation of this grammar into their syntax.
+     *
+     * For more information:
+     * @see https://pegjs.org
+     * @see https://en.wikipedia.org/wiki/Parsing_expression_grammar
+     *
+     */
+
+    /** <?php
+    // The `maybeJSON` function is not needed in PHP because its return semantics
+    // are the same as `json_decode`
+
+    // array arguments are backwards because of PHP
+    if ( ! function_exists( 'peg_array_partition' ) ) {
+        function peg_array_partition( $array, $predicate ) {
+            $truthy = array();
+            $falsey = array();
+
+            foreach ( $array as $item ) {
+                call_user_func( $predicate, $item )
+                    ? $truthy[] = $item
+                    : $falsey[] = $item;
+            }
 
-  /*
-   *
-   *    _____       _             _
-   *   / ____|     | |           | |
-   *  | |  __ _   _| |_ ___ _ __ | |__   ___ _ __ __ _
-   *  | | |_ | | | | __/ _ \ '_ \| '_ \ / _ \ '__/ _` |
-   *  | |__| | |_| | ||  __/ | | | |_) |  __/ | | (_| |
-   *   \_____|\__,_|\__\___|_| |_|_.__/ \___|_|  \__, |
-   *                                              __/ |
-   *                  GRAMMAR                    |___/
-   *
-   *
-   * Welcome to the grammar file for Gutenberg posts!
-   *
-   * Please don't be distracted by the functions at the top
-   * here - they're just helpers for the grammar below. We
-   * try to keep them as minimal and simple as possible,
-   * but the parser generator forces us to declare them at
-   * the beginning of the file.
-   *
-   * What follows is the official specification grammar for
-   * documents created or edited in Gutenberg. It starts at
-   * the top-level rule `Block_List`
-   *
-   * The grammar is defined by a series of _rules_ and ways
-   * to return matches on those rules. It's a _PEG_, a
-   * parsing expression grammar, which simply means that for
-   * each of our rules we have a set of sub-rules to match
-   * on and the generated parser will try them in order
-   * until it finds the first match.
-   *
-   * This grammar is a _specification_ (with as little actual
-   * code as we can get away with) which is used by the
-   * parser generator to generate the actual _parser_ which
-   * is used by Gutenberg. We generate two parsers: one in
-   * JavaScript for use the browser and one in PHP for
-   * WordPress itself. PEG parser generators are available
-   * in many languages, though different libraries may require
-   * some translation of this grammar into their syntax.
-   *
-   * For more information:
-   * @see https://pegjs.org
-   * @see https://en.wikipedia.org/wiki/Parsing_expression_grammar
-   *
-   */
-
-  /** <?php
-  // The `maybeJSON` function is not needed in PHP because its return semantics
-  // are the same as `json_decode`
-
-  // array arguments are backwards because of PHP
-  if ( ! function_exists( 'peg_array_partition' ) ) {
-      function peg_array_partition( $array, $predicate ) {
-          $truthy = array();
-          $falsey = array();
-
-          foreach ( $array as $item ) {
-              call_user_func( $predicate, $item )
-                  ? $truthy[] = $item
-                  : $falsey[] = $item;
-          }
+            return array( $truthy, $falsey );
+        }
+    }
 
-          return array( $truthy, $falsey );
-      }
-  }
+    if ( ! function_exists( 'peg_join_blocks' ) ) {
+        function peg_join_blocks( $pre, $tokens, $post ) {
+            $blocks = array();
 
-  if ( ! function_exists( 'peg_join_blocks' ) ) {
-      function peg_join_blocks( $pre, $tokens, $post ) {
-          $blocks = array();
+            if ( ! empty( $pre ) ) {
+                $blocks[] = array( 'attrs' => array(), 'innerHTML' => $pre );
+            }
 
-          if ( ! empty( $pre ) ) {
-              $blocks[] = array( 'attrs' => array(), 'innerHTML' => $pre );
-          }
+            foreach ( $tokens as $token ) {
+                list( $token, $html ) = $token;
 
-          foreach ( $tokens as $token ) {
-              list( $token, $html ) = $token;
+                $blocks[] = $token;
 
-              $blocks[] = $token;
+                if ( ! empty( $html ) ) {
+                    $blocks[] = array( 'attrs' => array(), 'innerHTML' => $html );
+                }
+            }
 
-              if ( ! empty( $html ) ) {
-                  $blocks[] = array( 'attrs' => array(), 'innerHTML' => $html );
-              }
-          }
+            if ( ! empty( $post ) ) {
+                $blocks[] = array( 'attrs' => array(), 'innerHTML' => $post );
+            }
 
-          if ( ! empty( $post ) ) {
-              $blocks[] = array( 'attrs' => array(), 'innerHTML' => $post );
-          }
+            return $blocks;
+        }
+    }
 
-          return $blocks;
-      }
-  }
+    ?> **/
 
-  ?> **/
+    function freeform( s ) {
+        return s.length && {
+            attrs: {},
+            innerHTML: s
+        };
+    }
 
-  function freeform( s ) {
-      return s.length && {
-          attrs: {},
-          innerHTML: s
-      };
-  }
+    function joinBlocks( pre, tokens, post ) {
+        var blocks = [], i, l, html, item, token;
 
-  function joinBlocks( pre, tokens, post ) {
-      var blocks = [], i, l, html, item, token;
+        if ( pre.length ) {
+            blocks.push( freeform( pre ) );
+        }
 
-      if ( pre.length ) {
-          blocks.push( freeform( pre ) );
-      }
+        for ( i = 0, l = tokens.length; i < l; i++ ) {
+            item = tokens[ i ];
+            token = item[ 0 ];
+            html = item[ 1 ];
 
-      for ( i = 0, l = tokens.length; i < l; i++ ) {
-          item = tokens[ i ];
-          token = item[ 0 ];
-          html = item[ 1 ];
+            blocks.push( token );
+            if ( html.length ) {
+                blocks.push( freeform( html ) );
+            }
+        }
 
-          blocks.push( token );
-          if ( html.length ) {
-              blocks.push( freeform( html ) );
-          }
-      }
+        if ( post.length ) {
+            blocks.push( freeform( post ) );
+        }
 
-      if ( post.length ) {
-          blocks.push( freeform( post ) );
-      }
+        return blocks;
+    }
 
-      return blocks;
-  }
+    function maybeJSON( s ) {
+        try {
+            return JSON.parse( s );
+        } catch (e) {
+            return null;
+        }
+    }
 
-  function maybeJSON( s ) {
-      try {
-          return JSON.parse( s );
-      } catch (e) {
-          return null;
-      }
-  }
+    function partition( predicate, list ) {
+        var i, l, item;
+        var truthy = [];
+        var falsey = [];
 
-  function partition( predicate, list ) {
-      var i, l, item;
-      var truthy = [];
-      var falsey = [];
+        // nod to performance over a simpler reduce
+        // and clone model we could have taken here
+        for ( i = 0, l = list.length; i < l; i++ ) {
+            item = list[ i ];
 
-      // nod to performance over a simpler reduce
-      // and clone model we could have taken here
-      for ( i = 0, l = list.length; i < l; i++ ) {
-          item = list[ i ];
+            predicate( item )
+                ? truthy.push( item )
+                : falsey.push( item )
+        };
 
-          predicate( item )
-              ? truthy.push( item )
-              : falsey.push( item )
-      };
+        return [ truthy, falsey ];
+    }
 
-      return [ truthy, falsey ];
-  }
 
 
+    peg$result = peg$startRuleFunction();
 
-  peg$result = peg$startRuleFunction();
+    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+      return peg$result;
+    } else {
+      if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+        peg$fail(peg$endExpectation());
+      }
 
-  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
-    return peg$result;
-  } else {
-    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
-      peg$fail(peg$endExpectation());
+      throw peg$buildStructuredError(
+        peg$maxFailExpected,
+        peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
+        peg$maxFailPos < input.length
+          ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
+          : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
+      );
     }
-
-    throw peg$buildStructuredError(
-      peg$maxFailExpected,
-      peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
-      peg$maxFailPos < input.length
-        ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
-        : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
-    );
   }
-}
 
-module.exports = {
-  SyntaxError: peg$SyntaxError,
-  parse:       peg$parse
-};
+  return {
+    SyntaxError: peg$SyntaxError,
+    parse:       peg$parse
+  };
+});
diff --git a/packages/spec-parser/package.json b/packages/spec-parser/package.json
index 5d4badf195db4..cbbff0881f990 100644
--- a/packages/spec-parser/package.json
+++ b/packages/spec-parser/package.json
@@ -23,6 +23,6 @@
 		"access": "public"
 	},
 	"scripts": {
-		"build": "pegjs -o ./index.js ./grammar.pegjs"
+		"build": "pegjs --format umd -o ./index.js ./grammar.pegjs"
 	}
 }
diff --git a/webpack.config.js b/webpack.config.js
index 9336b2a5bf734..9d6c6dfb26534 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -102,6 +102,7 @@ const gutenbergPackages = [
 	'keycodes',
 	'plugins',
 	'shortcode',
+	'spec-parser',
 	'viewport',
 ];