@podlite/schema 0.0.69 → 0.0.71

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (114) hide show
  1. package/CHANGELOG.podlite +96 -0
  2. package/esm/ast-helpers.d.ts +11 -0
  3. package/esm/ast-helpers.js +279 -27
  4. package/esm/ast-helpers.js.map +1 -1
  5. package/esm/ast-inerator.js +1 -1
  6. package/esm/block-names.d.ts +2 -2
  7. package/esm/block-names.js +7 -0
  8. package/esm/block-names.js.map +1 -1
  9. package/esm/blocks-helpers.d.ts +1 -1
  10. package/esm/blocks-helpers.js +3 -1
  11. package/esm/blocks-helpers.js.map +1 -1
  12. package/esm/exportAny.js +5 -5
  13. package/esm/exportHtml.js +95 -38
  14. package/esm/exportHtml.js.map +1 -1
  15. package/esm/exportMarkdown.js +120 -35
  16. package/esm/exportMarkdown.js.map +1 -1
  17. package/esm/grammar.js +588 -454
  18. package/esm/grammar.js.map +1 -1
  19. package/esm/guard.js +12 -2
  20. package/esm/guard.js.map +1 -1
  21. package/esm/helpers/blockName.d.ts +8 -0
  22. package/esm/helpers/blockName.js +60 -0
  23. package/esm/helpers/blockName.js.map +1 -0
  24. package/esm/helpers/configPropagation.d.ts +12 -2
  25. package/esm/helpers/configPropagation.js +51 -13
  26. package/esm/helpers/configPropagation.js.map +1 -1
  27. package/esm/helpers/corePlugins.d.ts +1 -1
  28. package/esm/helpers/corePlugins.js +7 -5
  29. package/esm/helpers/corePlugins.js.map +1 -1
  30. package/esm/helpers/handlers.js +3 -3
  31. package/esm/helpers/ids.js +1 -1
  32. package/esm/helpers/makeInterator.js +3 -2
  33. package/esm/helpers/makeInterator.js.map +1 -1
  34. package/esm/helpers/makeTransformer.js +1 -1
  35. package/esm/helpers/parseAttributes.js +1 -1
  36. package/esm/index.d.ts +13 -3
  37. package/esm/index.js +59 -47
  38. package/esm/index.js.map +1 -1
  39. package/esm/pluggableParser.d.ts +6 -2
  40. package/esm/pluggableParser.js +15 -15
  41. package/esm/pluggableParser.js.map +1 -1
  42. package/esm/plugin-clean-location.js +1 -1
  43. package/esm/plugin-data-table.js +7 -8
  44. package/esm/plugin-data-table.js.map +1 -1
  45. package/esm/plugin-defn-fill-term.js +1 -1
  46. package/esm/plugin-formatting-codes.js +70 -29
  47. package/esm/plugin-formatting-codes.js.map +1 -1
  48. package/esm/plugin-group-items.js +1 -1
  49. package/esm/plugin-set.js +15 -18
  50. package/esm/plugin-set.js.map +1 -1
  51. package/esm/plugin-tables.js +8 -3
  52. package/esm/plugin-tables.js.map +1 -1
  53. package/esm/query-helpers.js +1 -1
  54. package/esm/selectors.d.ts +25 -8
  55. package/esm/selectors.js +399 -142
  56. package/esm/selectors.js.map +1 -1
  57. package/esm/set-assign.d.ts +17 -0
  58. package/esm/set-assign.js +143 -0
  59. package/esm/set-assign.js.map +1 -0
  60. package/esm/test-display.d.ts +3 -0
  61. package/esm/test-display.js +58 -0
  62. package/esm/test-display.js.map +1 -0
  63. package/esm/toc-caption.d.ts +7 -0
  64. package/esm/toc-caption.js +23 -0
  65. package/esm/toc-caption.js.map +1 -0
  66. package/esm/types.d.ts +16 -1
  67. package/esm/version.d.ts +1 -1
  68. package/esm/version.js +1 -1
  69. package/esm/writerHtml.js +1 -1
  70. package/esm/writerMarkdown.js +1 -1
  71. package/lib/ast-helpers.d.ts +11 -0
  72. package/lib/ast-helpers.js +279 -26
  73. package/lib/block-names.d.ts +2 -2
  74. package/lib/block-names.js +7 -0
  75. package/lib/blocks-helpers.d.ts +1 -1
  76. package/lib/blocks-helpers.js +3 -1
  77. package/lib/exportHtml.js +84 -27
  78. package/lib/exportMarkdown.js +111 -26
  79. package/lib/grammar.js +588 -454
  80. package/lib/guard.js +11 -1
  81. package/lib/helpers/blockName.d.ts +8 -0
  82. package/lib/helpers/blockName.js +66 -0
  83. package/lib/helpers/configPropagation.d.ts +12 -2
  84. package/lib/helpers/configPropagation.js +54 -14
  85. package/lib/helpers/corePlugins.d.ts +1 -1
  86. package/lib/helpers/corePlugins.js +4 -2
  87. package/lib/helpers/makeInterator.js +3 -2
  88. package/lib/index.d.ts +13 -3
  89. package/lib/index.js +33 -6
  90. package/lib/pluggableParser.d.ts +6 -2
  91. package/lib/pluggableParser.js +5 -5
  92. package/lib/plugin-data-table.js +4 -5
  93. package/lib/plugin-formatting-codes.js +65 -24
  94. package/lib/plugin-set.js +15 -18
  95. package/lib/plugin-tables.js +6 -1
  96. package/lib/selectors.d.ts +25 -8
  97. package/lib/selectors.js +401 -141
  98. package/lib/set-assign.d.ts +17 -0
  99. package/lib/set-assign.js +150 -0
  100. package/lib/test-display.d.ts +3 -0
  101. package/lib/test-display.js +67 -0
  102. package/lib/toc-caption.d.ts +7 -0
  103. package/lib/toc-caption.js +27 -0
  104. package/lib/types.d.ts +16 -1
  105. package/lib/version.d.ts +1 -1
  106. package/lib/version.js +1 -1
  107. package/package.json +3 -3
  108. package/schema/AstTree.json +160 -0
  109. package/schema/PodliteDocument.json +160 -0
  110. package/esm/helpers/makeQuery.test.d.ts +0 -1
  111. package/esm/helpers/makeQuery.test.js +0 -51
  112. package/esm/helpers/makeQuery.test.js.map +0 -1
  113. package/lib/helpers/makeQuery.test.d.ts +0 -1
  114. package/lib/helpers/makeQuery.test.js +0 -51
package/esm/grammar.js CHANGED
@@ -113,47 +113,49 @@ function peg$parse(input, options) {
113
113
  type: 'ambient',
114
114
  location: location()
115
115
  };
116
- }, peg$c6 = /^[ \xA0\u2001\t\f\u2008]/, peg$c7 = peg$classExpectation([" ", "\xA0", "\u2001", "\t", "\f", "\u2008"], false, false), peg$c8 = /^[ \t\f]/, peg$c9 = peg$classExpectation([" ", "\t", "\f"], false, false), peg$c10 = /^[\n\r]/, peg$c11 = peg$classExpectation(["\n", "\r"], false, false), peg$c12 = function (text) { return text; }, peg$c13 = /^[^\n\r]/, peg$c14 = peg$classExpectation(["\n", "\r"], true, false), peg$c15 = "\n", peg$c16 = peg$literalExpectation("\n", false), peg$c17 = "\r", peg$c18 = peg$literalExpectation("\r", false), peg$c19 = function () { return { type: 'blankline' }; }, peg$c20 = "=begin ", peg$c21 = peg$literalExpectation("=begin ", false), peg$c22 = "=end ", peg$c23 = peg$literalExpectation("=end ", false), peg$c24 = "=for ", peg$c25 = peg$literalExpectation("=for ", false), peg$c26 = "=config", peg$c27 = peg$literalExpectation("=config", false), peg$c28 = "=alias", peg$c29 = peg$literalExpectation("=alias", false), peg$c30 = function (name) { return isSupportedBlockName(name); }, peg$c31 = function (name) { return name; }, peg$c32 = "=", peg$c33 = peg$literalExpectation("=", false), peg$c34 = peg$otherExpectation("text"), peg$c35 = function () { return text(); }, peg$c36 = function () {
116
+ }, peg$c6 = /^[ \xA0\u2001\t\f\u2008]/, peg$c7 = peg$classExpectation([" ", "\xA0", "\u2001", "\t", "\f", "\u2008"], false, false), peg$c8 = /^[ \t\f]/, peg$c9 = peg$classExpectation([" ", "\t", "\f"], false, false), peg$c10 = /^[\n\r]/, peg$c11 = peg$classExpectation(["\n", "\r"], false, false), peg$c12 = function (text) { return text; }, peg$c13 = /^[^\n\r]/, peg$c14 = peg$classExpectation(["\n", "\r"], true, false), peg$c15 = "\n", peg$c16 = peg$literalExpectation("\n", false), peg$c17 = "\r", peg$c18 = peg$literalExpectation("\r", false), peg$c19 = function () { return { type: 'blankline' }; }, peg$c20 = "=begin ", peg$c21 = peg$literalExpectation("=begin ", false), peg$c22 = "=end ", peg$c23 = peg$literalExpectation("=end ", false), peg$c24 = "=for ", peg$c25 = peg$literalExpectation("=for ", false), peg$c26 = "=config", peg$c27 = peg$literalExpectation("=config", false), peg$c28 = "=alias", peg$c29 = peg$literalExpectation("=alias", false), peg$c30 = function (name) { return isSupportedBlockName(name); }, peg$c31 = function (name) { return name; }, peg$c32 = "=", peg$c33 = peg$literalExpectation("=", false), peg$c34 = peg$otherExpectation("text"), peg$c35 = function () {
117
+ noteUnknownDirective(options, text(), location());
118
+ return text();
119
+ }, peg$c36 = function () { return text(); }, peg$c37 = function () {
117
120
  addDiagnostic(options, "Line looks like a directive but could not be read; it stays as text", location(), 'directive-unreadable');
121
+ noteRecognition(options, { kind: 'unreadable-directive', location: location() });
118
122
  return { type: "para", value: text(), error: true, location: location() };
119
- }, peg$c37 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c38 = function (code) { return [code]; }, peg$c39 = /^[ \t]/, peg$c40 = peg$classExpectation([" ", "\t"], false, false), peg$c41 = ",", peg$c42 = peg$literalExpectation(",", false), peg$c43 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c44 = /^[a-zA-Z0-9]/, peg$c45 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false), peg$c46 = /^[a-zA-Z0-9_\-]/, peg$c47 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false), peg$c48 = function (attr) { return !attr.dropped; }, peg$c49 = function (attr) { return { [attr.name]: attr.value }; }, peg$c50 = "=>", peg$c51 = peg$literalExpectation("=>", false), peg$c52 = function (name, value) { return { [name]: value }; }, peg$c53 = function (pair, pairs) { return { ...pair, ...pairs }; }, peg$c54 = function (code) { return code; }, peg$c55 = ":", peg$c56 = peg$literalExpectation(":", false), peg$c57 = /^[!]/, peg$c58 = peg$classExpectation(["!"], false, false), peg$c59 = "allow", peg$c60 = peg$literalExpectation("allow", false), peg$c61 = "<", peg$c62 = peg$literalExpectation("<", false), peg$c63 = ">", peg$c64 = peg$literalExpectation(">", false), peg$c65 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c66 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c67 = function (isFalse, key, value) { return { name: 'allow', ...value, ...(isFalse ? { isFalse: true } : {}) }; }, peg$c68 = /^[^ \t\r\n,<>[\]{}()'"]/, peg$c69 = peg$classExpectation([" ", "\t", "\r", "\n", ",", "<", ">", "[", "]", "{", "}", "(", ")", "'", "\""], true, false), peg$c70 = function (first, i) { return i; }, peg$c71 = function (first, rest) { return flattenDeep([first, ...rest]); }, peg$c72 = function (i) { return i; }, peg$c73 = function (all) { return all; }, peg$c74 = function (res) { return [res]; }, peg$c75 = function () { return []; }, peg$c76 = "{", peg$c77 = peg$literalExpectation("{", false), peg$c78 = "}", peg$c79 = peg$literalExpectation("}", false), peg$c80 = function (isFalse, key, hash) { return { value: hash, type: "map" }; }, peg$c81 = function (isFalse, key) { return { value: {}, type: "map" }; }, peg$c82 = function (isFalse, key) { return { unreadable: true, location: location() }; }, peg$c83 = "[", peg$c84 = peg$literalExpectation("[", false), peg$c85 = "]", peg$c86 = peg$literalExpectation("]", false), peg$c87 = function (isFalse, key) {
123
+ }, peg$c38 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c39 = function (code) { return [code]; }, peg$c40 = /^[ \t]/, peg$c41 = peg$classExpectation([" ", "\t"], false, false), peg$c42 = ",", peg$c43 = peg$literalExpectation(",", false), peg$c44 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c45 = /^[a-zA-Z0-9]/, peg$c46 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false), peg$c47 = /^[a-zA-Z0-9_\-]/, peg$c48 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false), peg$c49 = function (attr) { return !attr.dropped; }, peg$c50 = function (attr) { return { [attr.name]: attr.value }; }, peg$c51 = "=>", peg$c52 = peg$literalExpectation("=>", false), peg$c53 = function (name, value) { return { [name]: value }; }, peg$c54 = function (pair, pairs) { return { ...pair, ...pairs }; }, peg$c55 = function (code) { return code; }, peg$c56 = ":", peg$c57 = peg$literalExpectation(":", false), peg$c58 = /^[!]/, peg$c59 = peg$classExpectation(["!"], false, false), peg$c60 = "allow", peg$c61 = peg$literalExpectation("allow", false), peg$c62 = "<", peg$c63 = peg$literalExpectation("<", false), peg$c64 = ">", peg$c65 = peg$literalExpectation(">", false), peg$c66 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c67 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c68 = function (isFalse, key, value) { return { name: 'allow', ...value, ...(isFalse ? { isFalse: true } : {}) }; }, peg$c69 = /^[^ \t\r\n,<>[\]{}()'"]/, peg$c70 = peg$classExpectation([" ", "\t", "\r", "\n", ",", "<", ">", "[", "]", "{", "}", "(", ")", "'", "\""], true, false), peg$c71 = function (first, i) { return i; }, peg$c72 = function (first, rest) { return flattenDeep([first, ...rest]); }, peg$c73 = function (i) { return i; }, peg$c74 = function (all) { return all; }, peg$c75 = function (res) { return [res]; }, peg$c76 = function () { return []; }, peg$c77 = "{", peg$c78 = peg$literalExpectation("{", false), peg$c79 = "}", peg$c80 = peg$literalExpectation("}", false), peg$c81 = function (isFalse, key, hash) { return { value: hash, type: "map" }; }, peg$c82 = function (isFalse, key) { return { value: {}, type: "map" }; }, peg$c83 = function (isFalse, key) { return { unreadable: true, location: location() }; }, peg$c84 = "[", peg$c85 = peg$literalExpectation("[", false), peg$c86 = "]", peg$c87 = peg$literalExpectation("]", false), peg$c88 = function (isFalse, key) {
120
124
  return {
121
125
  unreadable: true,
122
126
  location: location(),
123
127
  message: "Square brackets are not an attribute value form; write a list with angle brackets or parentheses"
124
128
  };
125
- }, peg$c88 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c89 = /^[']/, peg$c90 = peg$classExpectation(["'"], false, false), peg$c91 = /^[^'\n\r]/, peg$c92 = peg$classExpectation(["'", "\n", "\r"], true, false), peg$c93 = function (isFalse, key, text) { return { value: text, type: "string" }; }, peg$c94 = /^["]/, peg$c95 = peg$classExpectation(["\""], false, false), peg$c96 = /^[^"\n\r]/, peg$c97 = peg$classExpectation(["\"", "\n", "\r"], true, false), peg$c98 = function (isFalse, key, text) { return { value: text.trim(), type: "string" }; }, peg$c99 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c100 = "(", peg$c101 = peg$literalExpectation("(", false), peg$c102 = function (isFalse, key, array) {
129
+ }, peg$c89 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c90 = /^[']/, peg$c91 = peg$classExpectation(["'"], false, false), peg$c92 = /^[^'\n\r]/, peg$c93 = peg$classExpectation(["'", "\n", "\r"], true, false), peg$c94 = function (isFalse, key, text) { return { value: text, type: "string" }; }, peg$c95 = /^["]/, peg$c96 = peg$classExpectation(["\""], false, false), peg$c97 = /^[^"\n\r]/, peg$c98 = peg$classExpectation(["\"", "\n", "\r"], true, false), peg$c99 = function (isFalse, key, text) { return { value: text.trim(), type: "string" }; }, peg$c100 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c101 = "(", peg$c102 = peg$literalExpectation("(", false), peg$c103 = function (isFalse, key, array) {
126
130
  return (array.length > 1)
127
131
  ? { type: 'array', value: array }
128
132
  : { type: valueKind(array[0]), value: array[0] };
129
- }, peg$c103 = ")", peg$c104 = peg$literalExpectation(")", false), peg$c105 = function (isFalse, key, res) { return res; }, peg$c106 = function (isFalse, key) {
133
+ }, peg$c104 = ")", peg$c105 = peg$literalExpectation(")", false), peg$c106 = function (isFalse, key, res) { return res; }, peg$c107 = function (isFalse, key) {
130
134
  return {
131
135
  unreadable: true,
132
136
  location: location(),
133
137
  message: "Bare text in parentheses; quote it or use a number"
134
138
  };
135
- }, peg$c107 = "\uFF62", peg$c108 = peg$literalExpectation("\uFF62", false), peg$c109 = /^[^\uFF63\n\r]/, peg$c110 = peg$classExpectation(["\uFF63", "\n", "\r"], true, false), peg$c111 = "\uFF63", peg$c112 = peg$literalExpectation("\uFF63", false), peg$c113 = function (isFalse, key) {
139
+ }, peg$c108 = "\uFF62", peg$c109 = peg$literalExpectation("\uFF62", false), peg$c110 = /^[^\uFF63\n\r]/, peg$c111 = peg$classExpectation(["\uFF63", "\n", "\r"], true, false), peg$c112 = "\uFF63", peg$c113 = peg$literalExpectation("\uFF63", false), peg$c114 = function (isFalse, key) {
136
140
  return {
137
141
  unreadable: true,
138
142
  location: location(),
139
143
  message: "Value is not closed; only a bracketed value may continue on the next configuration line"
140
144
  };
141
- }, peg$c114 = function (isFalse, key) {
145
+ }, peg$c115 = function (isFalse, key) {
142
146
  return {
143
147
  value: !isFalse,
144
148
  type: "boolean"
145
149
  };
146
- }, peg$c115 = function (isFalse, key, value) {
150
+ }, peg$c116 = function (isFalse, key, value) {
147
151
  if (value.unreadable) {
148
152
  addDiagnostic(options, value.message || `cannot read the value of :${key}`, value.location);
149
153
  return { name: key, dropped: true };
150
154
  }
151
155
  return { name: key, ...value, ...(isFalse && value.type !== 'boolean' ? { isFalse: true } : {}) };
152
- }, peg$c116 = function (first, rest) { return rest; }, peg$c117 = function (first, cont, unread) { return keepReadable(flattenDeep([...first, ...cont])); }, peg$c118 = function () { addDiagnostic(options, "Configuration continuation line could not be read", location()); }, peg$c119 = /^[^'"]/, peg$c120 = peg$classExpectation(["'", "\""], true, false), peg$c121 = function (text) { return text; }, peg$c122 = /^[0-9]/, peg$c123 = peg$classExpectation([["0", "9"]], false, false), peg$c124 = /^[\-+]/, peg$c125 = peg$classExpectation(["-", "+"], false, false), peg$c126 = "True", peg$c127 = peg$literalExpectation("True", false), peg$c128 = function () { return true; }, peg$c129 = "False", peg$c130 = peg$literalExpectation("False", false), peg$c131 = function () { return false; }, peg$c132 = ".", peg$c133 = peg$literalExpectation(".", false), peg$c134 = /^[eE]/, peg$c135 = peg$classExpectation(["e", "E"], false, false), peg$c136 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c137 = function (number) { return parseInt(number, 10); }, peg$c138 = function (vmargin, name, config) {
153
- return ((name.match(/code|comment|formula|output|input|markdown|picture|toc|data/))
154
- ||
155
- isNamedBlock(name));
156
- }, peg$c139 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c140 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c141 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c142 = function (vmargin, name, config, content, vmargin2, ename) {
156
+ }, peg$c117 = function (first, rest) { return rest; }, peg$c118 = function (first, cont, unread) { return keepReadable(flattenDeep([...first, ...cont])); }, peg$c119 = function () { addDiagnostic(options, "Configuration continuation line could not be read", location()); }, peg$c120 = /^[^'"]/, peg$c121 = peg$classExpectation(["'", "\""], true, false), peg$c122 = function (text) { return text; }, peg$c123 = /^[0-9]/, peg$c124 = peg$classExpectation([["0", "9"]], false, false), peg$c125 = /^[\-+]/, peg$c126 = peg$classExpectation(["-", "+"], false, false), peg$c127 = "True", peg$c128 = peg$literalExpectation("True", false), peg$c129 = function () { return true; }, peg$c130 = "False", peg$c131 = peg$literalExpectation("False", false), peg$c132 = function () { return false; }, peg$c133 = ".", peg$c134 = peg$literalExpectation(".", false), peg$c135 = /^[eE]/, peg$c136 = peg$classExpectation(["e", "E"], false, false), peg$c137 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c138 = function (number) { return parseInt(number, 10); }, peg$c139 = function (vmargin, name, config) {
157
+ return isRawBlock(name);
158
+ }, peg$c140 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c141 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c142 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c143 = function (vmargin, name, config, content, vmargin2, ename) {
157
159
  const type = 'block';
158
160
  return {
159
161
  type: type,
@@ -161,29 +163,29 @@ function peg$parse(input, options) {
161
163
  name,
162
164
  margin: vmargin
163
165
  };
164
- }, peg$c143 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c144 = function (vmargin, name, config, content, vmargin2, res) {
166
+ }, peg$c144 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c145 = function (vmargin, name, config, content, vmargin2, res) {
165
167
  return {
166
168
  ...res,
167
169
  text: text(),
168
170
  config,
169
171
  location: location()
170
172
  };
171
- }, peg$c145 = /^[\-+=_|]/, peg$c146 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c147 = function () { return { type: 'separator', text: text() }; }, peg$c148 = function () { return options.isDelimited; }, peg$c149 = function () {
173
+ }, peg$c146 = /^[\-+=_|]/, peg$c147 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c148 = function () { return { type: 'separator', text: text() }; }, peg$c149 = function () { return options.isDelimited; }, peg$c150 = function () {
172
174
  return {
173
175
  type: 'separator',
174
176
  text: text()
175
177
  };
176
- }, peg$c150 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c151 = function () {
178
+ }, peg$c151 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c152 = function () {
177
179
  // reset separator count and its accum
178
180
  options.separators = [];
179
181
  return true;
180
- }, peg$c152 = function (head, t) {
182
+ }, peg$c153 = function (head, t) {
181
183
  options.separators.push(t.text);
182
184
  return t;
183
- }, peg$c153 = function (head, separator, rowtext, t) {
185
+ }, peg$c154 = function (head, separator, rowtext, t) {
184
186
  options.separators.push(t.text);
185
187
  return t;
186
- }, peg$c154 = function (head, separator, rowtext, bseparator) {
188
+ }, peg$c155 = function (head, separator, rowtext, bseparator) {
187
189
  return [
188
190
  {
189
191
  name: 'row',
@@ -192,14 +194,14 @@ function peg$parse(input, options) {
192
194
  },
193
195
  bseparator
194
196
  ];
195
- }, peg$c155 = function (head, separator, singleRow) { return [singleRow]; }, peg$c156 = function (head, separator, rest) {
197
+ }, peg$c156 = function (head, separator, singleRow) { return [singleRow]; }, peg$c157 = function (head, separator, rest) {
196
198
  // if more then 1 separator and it equal - table doesn't have header
197
199
  if (options.separators.length > 1) {
198
200
  // check if separators equal (for table without header)
199
201
  return !options.separators.every(val => val === options.separators[0]);
200
202
  }
201
203
  return true;
202
- }, peg$c157 = function (head, separator, rest) {
204
+ }, peg$c158 = function (head, separator, rest) {
203
205
  return [
204
206
  {
205
207
  name: 'head',
@@ -209,7 +211,7 @@ function peg$parse(input, options) {
209
211
  separator,
210
212
  ...flattenDeep(rest)
211
213
  ];
212
- }, peg$c158 = function (rowtest, bseparator) {
214
+ }, peg$c159 = function (rowtest, bseparator) {
213
215
  return [
214
216
  {
215
217
  name: 'row',
@@ -218,37 +220,37 @@ function peg$parse(input, options) {
218
220
  },
219
221
  bseparator
220
222
  ];
221
- }, peg$c159 = function (rest) {
223
+ }, peg$c160 = function (rest) {
222
224
  return [...flattenDeep(rest)];
223
- }, peg$c160 = function (vmargin, name, config) { return name === 'table'; }, peg$c161 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c162 = function (vmargin, name, config, nodes) { return nodes; }, peg$c163 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c164 = function (vmargin, name, config, content, vmargin2, ename) {
225
+ }, peg$c161 = function (vmargin, name, config) { return name === 'table'; }, peg$c162 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c163 = function (vmargin, name, config, nodes) { return nodes; }, peg$c164 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c165 = function (vmargin, name, config, content, vmargin2, ename) {
224
226
  return {
225
227
  type: 'block',
226
228
  content,
227
229
  name,
228
230
  margin: vmargin
229
231
  };
230
- }, peg$c165 = function (vmargin, name, config, content, vmargin2, res) {
232
+ }, peg$c166 = function (vmargin, name, config, content, vmargin2, res) {
231
233
  return {
232
234
  ...res,
233
235
  text: text(),
234
236
  config,
235
237
  location: location()
236
238
  };
237
- }, peg$c166 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c167 = function (vmargin, name, config, t) { return t; }, peg$c168 = function (vmargin, name, config, content, vmargin2, ename) {
239
+ }, peg$c167 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c168 = function (vmargin, name, config, t) { return t; }, peg$c169 = function (vmargin, name, config, content, vmargin2, ename) {
238
240
  return {
239
241
  type: 'block',
240
242
  content: content,
241
243
  name,
242
244
  margin: vmargin
243
245
  };
244
- }, peg$c169 = function (vmargin, name, config, content, vmargin2, res) {
246
+ }, peg$c170 = function (vmargin, name, config, content, vmargin2, res) {
245
247
  return {
246
248
  ...res,
247
249
  text: text(),
248
250
  config,
249
251
  location: location()
250
252
  };
251
- }, peg$c170 = function (vmargin, name, config, nodes) { return nodes; }, peg$c171 = function (vmargin, name, config, tvmargin, text) {
253
+ }, peg$c171 = function (vmargin, name, config, nodes) { return nodes; }, peg$c172 = function (vmargin, name, config, tvmargin, text) {
252
254
  const type = name.match(/pod|nested|item|code|defn/)
253
255
  &&
254
256
  (tvmargin.length - vmargin.length) > 0 ? 'code' : 'para';
@@ -264,20 +266,20 @@ function peg$parse(input, options) {
264
266
  ],
265
267
  location: location(),
266
268
  };
267
- }, peg$c172 = function (vmargin, name, config, content, vmargin2, ename) {
269
+ }, peg$c173 = function (vmargin, name, config, content, vmargin2, ename) {
268
270
  return {
269
271
  type: 'block',
270
272
  content,
271
273
  name,
272
274
  margin: vmargin,
273
275
  };
274
- }, peg$c173 = function (vmargin, name, config, content, vmargin2, res) {
276
+ }, peg$c174 = function (vmargin, name, config, content, vmargin2, res) {
275
277
  return {
276
278
  ...res,
277
279
  config,
278
280
  location: location(),
279
281
  };
280
- }, peg$c174 = function () {
282
+ }, peg$c175 = function () {
281
283
  return {
282
284
  text: text(),
283
285
  type: 'para',
@@ -290,11 +292,9 @@ function peg$parse(input, options) {
290
292
  ],
291
293
  location: location(),
292
294
  };
293
- }, peg$c175 = function () { return { empty: 1 }; }, peg$c176 = /^[s]/, peg$c177 = peg$classExpectation(["s"], false, false), peg$c178 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c179 = function (vmargin, name) {
294
- return ((name.match(/code|comment|formula|output|input|markdown|picture|toc|data/))
295
- ||
296
- isNamedBlock(name));
297
- }, peg$c180 = function (vmargin, name, content) {
295
+ }, peg$c176 = function () { return { empty: 1 }; }, peg$c177 = /^[s]/, peg$c178 = peg$classExpectation(["s"], false, false), peg$c179 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c180 = function (vmargin, name) {
296
+ return isRawBlock(name);
297
+ }, peg$c181 = function (vmargin, name, content) {
298
298
  return {
299
299
  margin: vmargin,
300
300
  type: 'block',
@@ -303,7 +303,7 @@ function peg$parse(input, options) {
303
303
  config: [],
304
304
  location: location()
305
305
  };
306
- }, peg$c181 = function (vmargin, name) { return name === 'table'; }, peg$c182 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c183 = function (vmargin, name, content) {
306
+ }, peg$c182 = function (vmargin, name) { return name === 'table'; }, peg$c183 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c184 = function (vmargin, name, content) {
307
307
  return {
308
308
  margin: vmargin,
309
309
  type: 'block',
@@ -313,7 +313,7 @@ function peg$parse(input, options) {
313
313
  config: [],
314
314
  location: location()
315
315
  };
316
- }, peg$c184 = function (vmargin, name, first_line, content_rest) {
316
+ }, peg$c185 = function (vmargin, name, first_line, content_rest) {
317
317
  const content = (first_line === "\n" ? "" : first_line) + content_rest;
318
318
  return {
319
319
  margin: vmargin,
@@ -336,7 +336,7 @@ function peg$parse(input, options) {
336
336
  name,
337
337
  location: location()
338
338
  };
339
- }, peg$c185 = "= ", peg$c186 = peg$literalExpectation("= ", false), peg$c187 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c188 = function (attrs) { return { kind: 'attrs', attrs }; }, peg$c189 = function (name, value) { return { kind: 'alias', name, value }; }, peg$c190 = function (v) { return { kind: 'value', value: v }; }, peg$c191 = function (seg) { return seg; }, peg$c192 = "=set", peg$c193 = peg$literalExpectation("=set", false), peg$c194 = function (vmargin, first, cont) {
339
+ }, peg$c186 = "= ", peg$c187 = peg$literalExpectation("= ", false), peg$c188 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c189 = function (attrs) { return { kind: 'attrs', attrs }; }, peg$c190 = function (name, value) { return { kind: 'alias', name, value }; }, peg$c191 = function (v) { return { kind: 'value', value: v }; }, peg$c192 = function (seg) { return seg; }, peg$c193 = "=set", peg$c194 = peg$literalExpectation("=set", false), peg$c195 = function (vmargin, first, cont) {
340
340
  const items = [];
341
341
  let pending = null;
342
342
  const flush = () => {
@@ -366,21 +366,21 @@ function peg$parse(input, options) {
366
366
  margin: vmargin,
367
367
  location: location()
368
368
  };
369
- }, peg$c195 = function (vmargin, marker, name, replacement) {
369
+ }, peg$c196 = function (vmargin, marker, name, replacement) {
370
370
  return {
371
371
  name,
372
372
  type: 'alias',
373
373
  replacement,
374
374
  margin: vmargin
375
375
  };
376
- }, peg$c196 = /^[A-Z]/, peg$c197 = peg$classExpectation([["A", "Z"]], false, false), peg$c198 = "<>", peg$c199 = peg$literalExpectation("<>", false), peg$c200 = function (vmargin, marker, name, config) {
376
+ }, peg$c197 = /^[A-Z]/, peg$c198 = peg$classExpectation([["A", "Z"]], false, false), peg$c199 = "<>", peg$c200 = peg$literalExpectation("<>", false), peg$c201 = function (vmargin, marker, name, config) {
377
377
  return {
378
378
  name,
379
379
  type: 'config',
380
380
  config,
381
381
  margin: vmargin
382
382
  };
383
- }, peg$c201 = "=boundary", peg$c202 = peg$literalExpectation("=boundary", false), peg$c203 = function (vmargin, marker, config) {
383
+ }, peg$c202 = "=boundary", peg$c203 = peg$literalExpectation("=boundary", false), peg$c204 = function (vmargin, marker, config) {
384
384
  return {
385
385
  name: 'boundary',
386
386
  type: 'block',
@@ -389,11 +389,9 @@ function peg$parse(input, options) {
389
389
  margin: vmargin,
390
390
  location: location()
391
391
  };
392
- }, peg$c204 = function (vmargin, marker, name, config) {
393
- return ((name.match(/code|comment|formula|output|input|markdown|picture|toc|data/))
394
- ||
395
- isNamedBlock(name));
396
- }, peg$c205 = function (vmargin, marker, name, config, content) {
392
+ }, peg$c205 = function (vmargin, marker, name, config) {
393
+ return isRawBlock(name);
394
+ }, peg$c206 = function (vmargin, marker, name, config, content) {
397
395
  return {
398
396
  type: 'block',
399
397
  content: content === "" ? [] : [{ type: 'verbatim', value: content }],
@@ -402,7 +400,7 @@ function peg$parse(input, options) {
402
400
  config,
403
401
  location: location()
404
402
  };
405
- }, peg$c206 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c207 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c208 = function (vmargin, marker, name, config, content) {
403
+ }, peg$c207 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c208 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c209 = function (vmargin, marker, name, config, content) {
406
404
  return {
407
405
  type: 'block',
408
406
  content: content === "" ? [] : content,
@@ -411,7 +409,7 @@ function peg$parse(input, options) {
411
409
  config,
412
410
  location: location()
413
411
  };
414
- }, peg$c209 = function (vmargin, marker, name, config, content) {
412
+ }, peg$c210 = function (vmargin, marker, name, config, content) {
415
413
  return {
416
414
  type: 'block',
417
415
  content: content === "" ? []
@@ -434,7 +432,7 @@ function peg$parse(input, options) {
434
432
  config,
435
433
  location: location()
436
434
  };
437
- }, peg$c210 = /^[a-zA-Z]/, peg$c211 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c212 = peg$otherExpectation("whitespace"), peg$c213 = /^[\r\n \t\f]/, peg$c214 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c215 = peg$otherExpectation("space characters"), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result;
435
+ }, peg$c211 = /^[a-zA-Z]/, peg$c212 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c213 = peg$otherExpectation("whitespace"), peg$c214 = /^[\r\n \t\f]/, peg$c215 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c216 = peg$otherExpectation("space characters"), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result;
438
436
  if ("startRule" in options) {
439
437
  if (!(options.startRule in peg$startRuleFunctions)) {
440
438
  throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -1401,7 +1399,7 @@ function peg$parse(input, options) {
1401
1399
  s2 = peg$parseEOL();
1402
1400
  if (s2 !== peg$FAILED) {
1403
1401
  peg$savedPos = s0;
1404
- s1 = peg$c35();
1402
+ s1 = peg$c36();
1405
1403
  s0 = s1;
1406
1404
  }
1407
1405
  else {
@@ -1415,6 +1413,106 @@ function peg$parse(input, options) {
1415
1413
  }
1416
1414
  return s0;
1417
1415
  }
1416
+ function peg$parseplain_line() {
1417
+ var s0, s1, s2, s3, s4, s5, s6;
1418
+ s0 = peg$currPos;
1419
+ s1 = peg$currPos;
1420
+ peg$silentFails++;
1421
+ s2 = peg$currPos;
1422
+ s3 = peg$parse_();
1423
+ if (s3 !== peg$FAILED) {
1424
+ s4 = peg$parsemarkerConfig();
1425
+ if (s4 === peg$FAILED) {
1426
+ s4 = peg$parsemarkerAlias();
1427
+ if (s4 === peg$FAILED) {
1428
+ s4 = peg$currPos;
1429
+ s5 = peg$parsemarkers();
1430
+ if (s5 !== peg$FAILED) {
1431
+ s6 = peg$parsestrictIdentifier();
1432
+ if (s6 !== peg$FAILED) {
1433
+ s5 = [s5, s6];
1434
+ s4 = s5;
1435
+ }
1436
+ else {
1437
+ peg$currPos = s4;
1438
+ s4 = peg$FAILED;
1439
+ }
1440
+ }
1441
+ else {
1442
+ peg$currPos = s4;
1443
+ s4 = peg$FAILED;
1444
+ }
1445
+ if (s4 === peg$FAILED) {
1446
+ s4 = peg$parsemarkerAbbreviatedBlock();
1447
+ }
1448
+ }
1449
+ }
1450
+ if (s4 !== peg$FAILED) {
1451
+ s3 = [s3, s4];
1452
+ s2 = s3;
1453
+ }
1454
+ else {
1455
+ peg$currPos = s2;
1456
+ s2 = peg$FAILED;
1457
+ }
1458
+ }
1459
+ else {
1460
+ peg$currPos = s2;
1461
+ s2 = peg$FAILED;
1462
+ }
1463
+ if (s2 === peg$FAILED) {
1464
+ s2 = peg$parseblankline();
1465
+ }
1466
+ peg$silentFails--;
1467
+ if (s2 === peg$FAILED) {
1468
+ s1 = void 0;
1469
+ }
1470
+ else {
1471
+ peg$currPos = s1;
1472
+ s1 = peg$FAILED;
1473
+ }
1474
+ if (s1 !== peg$FAILED) {
1475
+ s2 = peg$currPos;
1476
+ s3 = [];
1477
+ s4 = peg$parseText();
1478
+ if (s4 !== peg$FAILED) {
1479
+ while (s4 !== peg$FAILED) {
1480
+ s3.push(s4);
1481
+ s4 = peg$parseText();
1482
+ }
1483
+ }
1484
+ else {
1485
+ s3 = peg$FAILED;
1486
+ }
1487
+ if (s3 !== peg$FAILED) {
1488
+ s2 = input.substring(s2, peg$currPos);
1489
+ }
1490
+ else {
1491
+ s2 = s3;
1492
+ }
1493
+ if (s2 !== peg$FAILED) {
1494
+ s3 = peg$parseEOL();
1495
+ if (s3 !== peg$FAILED) {
1496
+ peg$savedPos = s0;
1497
+ s1 = peg$c36();
1498
+ s0 = s1;
1499
+ }
1500
+ else {
1501
+ peg$currPos = s0;
1502
+ s0 = peg$FAILED;
1503
+ }
1504
+ }
1505
+ else {
1506
+ peg$currPos = s0;
1507
+ s0 = peg$FAILED;
1508
+ }
1509
+ }
1510
+ else {
1511
+ peg$currPos = s0;
1512
+ s0 = peg$FAILED;
1513
+ }
1514
+ return s0;
1515
+ }
1418
1516
  function peg$parseerror_para() {
1419
1517
  var s0, s1, s2, s3, s4, s5;
1420
1518
  s0 = peg$currPos;
@@ -1510,7 +1608,7 @@ function peg$parse(input, options) {
1510
1608
  s2 = peg$parseEOL();
1511
1609
  if (s2 !== peg$FAILED) {
1512
1610
  peg$savedPos = s0;
1513
- s1 = peg$c36();
1611
+ s1 = peg$c37();
1514
1612
  s0 = s1;
1515
1613
  }
1516
1614
  else {
@@ -1544,7 +1642,7 @@ function peg$parse(input, options) {
1544
1642
  s3 = peg$parsearray_codes();
1545
1643
  if (s3 !== peg$FAILED) {
1546
1644
  peg$savedPos = s0;
1547
- s1 = peg$c37(s1, s3);
1645
+ s1 = peg$c38(s1, s3);
1548
1646
  s0 = s1;
1549
1647
  }
1550
1648
  else {
@@ -1566,7 +1664,7 @@ function peg$parse(input, options) {
1566
1664
  s1 = peg$parseFCode();
1567
1665
  if (s1 !== peg$FAILED) {
1568
1666
  peg$savedPos = s0;
1569
- s1 = peg$c38(s1);
1667
+ s1 = peg$c39(s1);
1570
1668
  }
1571
1669
  s0 = s1;
1572
1670
  }
@@ -1601,27 +1699,27 @@ function peg$parse(input, options) {
1601
1699
  }
1602
1700
  if (s2 !== peg$FAILED) {
1603
1701
  s3 = [];
1604
- if (peg$c39.test(input.charAt(peg$currPos))) {
1702
+ if (peg$c40.test(input.charAt(peg$currPos))) {
1605
1703
  s4 = input.charAt(peg$currPos);
1606
1704
  peg$currPos++;
1607
1705
  }
1608
1706
  else {
1609
1707
  s4 = peg$FAILED;
1610
1708
  if (peg$silentFails === 0) {
1611
- peg$fail(peg$c40);
1709
+ peg$fail(peg$c41);
1612
1710
  }
1613
1711
  }
1614
1712
  if (s4 !== peg$FAILED) {
1615
1713
  while (s4 !== peg$FAILED) {
1616
1714
  s3.push(s4);
1617
- if (peg$c39.test(input.charAt(peg$currPos))) {
1715
+ if (peg$c40.test(input.charAt(peg$currPos))) {
1618
1716
  s4 = input.charAt(peg$currPos);
1619
1717
  peg$currPos++;
1620
1718
  }
1621
1719
  else {
1622
1720
  s4 = peg$FAILED;
1623
1721
  if (peg$silentFails === 0) {
1624
- peg$fail(peg$c40);
1722
+ peg$fail(peg$c41);
1625
1723
  }
1626
1724
  }
1627
1725
  }
@@ -1704,13 +1802,13 @@ function peg$parse(input, options) {
1704
1802
  s3 = peg$parsegap();
1705
1803
  if (s3 !== peg$FAILED) {
1706
1804
  if (input.charCodeAt(peg$currPos) === 44) {
1707
- s4 = peg$c41;
1805
+ s4 = peg$c42;
1708
1806
  peg$currPos++;
1709
1807
  }
1710
1808
  else {
1711
1809
  s4 = peg$FAILED;
1712
1810
  if (peg$silentFails === 0) {
1713
- peg$fail(peg$c42);
1811
+ peg$fail(peg$c43);
1714
1812
  }
1715
1813
  }
1716
1814
  if (s4 !== peg$FAILED) {
@@ -1738,7 +1836,7 @@ function peg$parse(input, options) {
1738
1836
  s3 = peg$parsearray_items();
1739
1837
  if (s3 !== peg$FAILED) {
1740
1838
  peg$savedPos = s0;
1741
- s1 = peg$c43(s1, s3);
1839
+ s1 = peg$c44(s1, s3);
1742
1840
  s0 = s1;
1743
1841
  }
1744
1842
  else {
@@ -1760,7 +1858,7 @@ function peg$parse(input, options) {
1760
1858
  s1 = peg$parseitem();
1761
1859
  if (s1 !== peg$FAILED) {
1762
1860
  peg$savedPos = s0;
1763
- s1 = peg$c38(s1);
1861
+ s1 = peg$c39(s1);
1764
1862
  }
1765
1863
  s0 = s1;
1766
1864
  }
@@ -1771,27 +1869,27 @@ function peg$parse(input, options) {
1771
1869
  s0 = peg$currPos;
1772
1870
  s1 = peg$currPos;
1773
1871
  s2 = [];
1774
- if (peg$c44.test(input.charAt(peg$currPos))) {
1872
+ if (peg$c45.test(input.charAt(peg$currPos))) {
1775
1873
  s3 = input.charAt(peg$currPos);
1776
1874
  peg$currPos++;
1777
1875
  }
1778
1876
  else {
1779
1877
  s3 = peg$FAILED;
1780
1878
  if (peg$silentFails === 0) {
1781
- peg$fail(peg$c45);
1879
+ peg$fail(peg$c46);
1782
1880
  }
1783
1881
  }
1784
1882
  if (s3 !== peg$FAILED) {
1785
1883
  while (s3 !== peg$FAILED) {
1786
1884
  s2.push(s3);
1787
- if (peg$c44.test(input.charAt(peg$currPos))) {
1885
+ if (peg$c45.test(input.charAt(peg$currPos))) {
1788
1886
  s3 = input.charAt(peg$currPos);
1789
1887
  peg$currPos++;
1790
1888
  }
1791
1889
  else {
1792
1890
  s3 = peg$FAILED;
1793
1891
  if (peg$silentFails === 0) {
1794
- peg$fail(peg$c45);
1892
+ peg$fail(peg$c46);
1795
1893
  }
1796
1894
  }
1797
1895
  }
@@ -1801,26 +1899,26 @@ function peg$parse(input, options) {
1801
1899
  }
1802
1900
  if (s2 !== peg$FAILED) {
1803
1901
  s3 = [];
1804
- if (peg$c46.test(input.charAt(peg$currPos))) {
1902
+ if (peg$c47.test(input.charAt(peg$currPos))) {
1805
1903
  s4 = input.charAt(peg$currPos);
1806
1904
  peg$currPos++;
1807
1905
  }
1808
1906
  else {
1809
1907
  s4 = peg$FAILED;
1810
1908
  if (peg$silentFails === 0) {
1811
- peg$fail(peg$c47);
1909
+ peg$fail(peg$c48);
1812
1910
  }
1813
1911
  }
1814
1912
  while (s4 !== peg$FAILED) {
1815
1913
  s3.push(s4);
1816
- if (peg$c46.test(input.charAt(peg$currPos))) {
1914
+ if (peg$c47.test(input.charAt(peg$currPos))) {
1817
1915
  s4 = input.charAt(peg$currPos);
1818
1916
  peg$currPos++;
1819
1917
  }
1820
1918
  else {
1821
1919
  s4 = peg$FAILED;
1822
1920
  if (peg$silentFails === 0) {
1823
- peg$fail(peg$c47);
1921
+ peg$fail(peg$c48);
1824
1922
  }
1825
1923
  }
1826
1924
  }
@@ -1853,7 +1951,7 @@ function peg$parse(input, options) {
1853
1951
  s2 = peg$parseattributes();
1854
1952
  if (s2 !== peg$FAILED) {
1855
1953
  peg$savedPos = peg$currPos;
1856
- s3 = peg$c48(s2);
1954
+ s3 = peg$c49(s2);
1857
1955
  if (s3) {
1858
1956
  s3 = void 0;
1859
1957
  }
@@ -1862,7 +1960,7 @@ function peg$parse(input, options) {
1862
1960
  }
1863
1961
  if (s3 !== peg$FAILED) {
1864
1962
  peg$savedPos = s0;
1865
- s1 = peg$c49(s2);
1963
+ s1 = peg$c50(s2);
1866
1964
  s0 = s1;
1867
1965
  }
1868
1966
  else {
@@ -1888,24 +1986,24 @@ function peg$parse(input, options) {
1888
1986
  s3 = peg$parsegap();
1889
1987
  if (s3 !== peg$FAILED) {
1890
1988
  if (input.charCodeAt(peg$currPos) === 44) {
1891
- s4 = peg$c41;
1989
+ s4 = peg$c42;
1892
1990
  peg$currPos++;
1893
1991
  }
1894
1992
  else {
1895
1993
  s4 = peg$FAILED;
1896
1994
  if (peg$silentFails === 0) {
1897
- peg$fail(peg$c42);
1995
+ peg$fail(peg$c43);
1898
1996
  }
1899
1997
  }
1900
1998
  if (s4 === peg$FAILED) {
1901
- if (input.substr(peg$currPos, 2) === peg$c50) {
1902
- s4 = peg$c50;
1999
+ if (input.substr(peg$currPos, 2) === peg$c51) {
2000
+ s4 = peg$c51;
1903
2001
  peg$currPos += 2;
1904
2002
  }
1905
2003
  else {
1906
2004
  s4 = peg$FAILED;
1907
2005
  if (peg$silentFails === 0) {
1908
- peg$fail(peg$c51);
2006
+ peg$fail(peg$c52);
1909
2007
  }
1910
2008
  }
1911
2009
  }
@@ -1915,7 +2013,7 @@ function peg$parse(input, options) {
1915
2013
  s6 = peg$parseitem();
1916
2014
  if (s6 !== peg$FAILED) {
1917
2015
  peg$savedPos = s0;
1918
- s1 = peg$c52(s2, s6);
2016
+ s1 = peg$c53(s2, s6);
1919
2017
  s0 = s1;
1920
2018
  }
1921
2019
  else {
@@ -1958,13 +2056,13 @@ function peg$parse(input, options) {
1958
2056
  s2 = peg$parsegap();
1959
2057
  if (s2 !== peg$FAILED) {
1960
2058
  if (input.charCodeAt(peg$currPos) === 44) {
1961
- s3 = peg$c41;
2059
+ s3 = peg$c42;
1962
2060
  peg$currPos++;
1963
2061
  }
1964
2062
  else {
1965
2063
  s3 = peg$FAILED;
1966
2064
  if (peg$silentFails === 0) {
1967
- peg$fail(peg$c42);
2065
+ peg$fail(peg$c43);
1968
2066
  }
1969
2067
  }
1970
2068
  if (s3 !== peg$FAILED) {
@@ -1973,7 +2071,7 @@ function peg$parse(input, options) {
1973
2071
  s5 = peg$parsearray_pairs();
1974
2072
  if (s5 !== peg$FAILED) {
1975
2073
  peg$savedPos = s0;
1976
- s1 = peg$c53(s1, s5);
2074
+ s1 = peg$c54(s1, s5);
1977
2075
  s0 = s1;
1978
2076
  }
1979
2077
  else {
@@ -2005,7 +2103,7 @@ function peg$parse(input, options) {
2005
2103
  s1 = peg$parsepair_item();
2006
2104
  if (s1 !== peg$FAILED) {
2007
2105
  peg$savedPos = s0;
2008
- s1 = peg$c54(s1);
2106
+ s1 = peg$c55(s1);
2009
2107
  }
2010
2108
  s0 = s1;
2011
2109
  }
@@ -2017,50 +2115,50 @@ function peg$parse(input, options) {
2017
2115
  s1 = peg$parse_();
2018
2116
  if (s1 !== peg$FAILED) {
2019
2117
  if (input.charCodeAt(peg$currPos) === 58) {
2020
- s2 = peg$c55;
2118
+ s2 = peg$c56;
2021
2119
  peg$currPos++;
2022
2120
  }
2023
2121
  else {
2024
2122
  s2 = peg$FAILED;
2025
2123
  if (peg$silentFails === 0) {
2026
- peg$fail(peg$c56);
2124
+ peg$fail(peg$c57);
2027
2125
  }
2028
2126
  }
2029
2127
  if (s2 !== peg$FAILED) {
2030
- if (peg$c57.test(input.charAt(peg$currPos))) {
2128
+ if (peg$c58.test(input.charAt(peg$currPos))) {
2031
2129
  s3 = input.charAt(peg$currPos);
2032
2130
  peg$currPos++;
2033
2131
  }
2034
2132
  else {
2035
2133
  s3 = peg$FAILED;
2036
2134
  if (peg$silentFails === 0) {
2037
- peg$fail(peg$c58);
2135
+ peg$fail(peg$c59);
2038
2136
  }
2039
2137
  }
2040
2138
  if (s3 === peg$FAILED) {
2041
2139
  s3 = null;
2042
2140
  }
2043
2141
  if (s3 !== peg$FAILED) {
2044
- if (input.substr(peg$currPos, 5) === peg$c59) {
2045
- s4 = peg$c59;
2142
+ if (input.substr(peg$currPos, 5) === peg$c60) {
2143
+ s4 = peg$c60;
2046
2144
  peg$currPos += 5;
2047
2145
  }
2048
2146
  else {
2049
2147
  s4 = peg$FAILED;
2050
2148
  if (peg$silentFails === 0) {
2051
- peg$fail(peg$c60);
2149
+ peg$fail(peg$c61);
2052
2150
  }
2053
2151
  }
2054
2152
  if (s4 !== peg$FAILED) {
2055
2153
  s5 = peg$currPos;
2056
2154
  if (input.charCodeAt(peg$currPos) === 60) {
2057
- s6 = peg$c61;
2155
+ s6 = peg$c62;
2058
2156
  peg$currPos++;
2059
2157
  }
2060
2158
  else {
2061
2159
  s6 = peg$FAILED;
2062
2160
  if (peg$silentFails === 0) {
2063
- peg$fail(peg$c62);
2161
+ peg$fail(peg$c63);
2064
2162
  }
2065
2163
  }
2066
2164
  if (s6 !== peg$FAILED) {
@@ -2071,18 +2169,18 @@ function peg$parse(input, options) {
2071
2169
  s9 = peg$parse_();
2072
2170
  if (s9 !== peg$FAILED) {
2073
2171
  if (input.charCodeAt(peg$currPos) === 62) {
2074
- s10 = peg$c63;
2172
+ s10 = peg$c64;
2075
2173
  peg$currPos++;
2076
2174
  }
2077
2175
  else {
2078
2176
  s10 = peg$FAILED;
2079
2177
  if (peg$silentFails === 0) {
2080
- peg$fail(peg$c64);
2178
+ peg$fail(peg$c65);
2081
2179
  }
2082
2180
  }
2083
2181
  if (s10 !== peg$FAILED) {
2084
2182
  peg$savedPos = s5;
2085
- s6 = peg$c65(s3, s4, s8);
2183
+ s6 = peg$c66(s3, s4, s8);
2086
2184
  s5 = s6;
2087
2185
  }
2088
2186
  else {
@@ -2112,31 +2210,31 @@ function peg$parse(input, options) {
2112
2210
  if (s5 === peg$FAILED) {
2113
2211
  s5 = peg$currPos;
2114
2212
  if (input.charCodeAt(peg$currPos) === 60) {
2115
- s6 = peg$c61;
2213
+ s6 = peg$c62;
2116
2214
  peg$currPos++;
2117
2215
  }
2118
2216
  else {
2119
2217
  s6 = peg$FAILED;
2120
2218
  if (peg$silentFails === 0) {
2121
- peg$fail(peg$c62);
2219
+ peg$fail(peg$c63);
2122
2220
  }
2123
2221
  }
2124
2222
  if (s6 !== peg$FAILED) {
2125
2223
  s7 = peg$parse_();
2126
2224
  if (s7 !== peg$FAILED) {
2127
2225
  if (input.charCodeAt(peg$currPos) === 62) {
2128
- s8 = peg$c63;
2226
+ s8 = peg$c64;
2129
2227
  peg$currPos++;
2130
2228
  }
2131
2229
  else {
2132
2230
  s8 = peg$FAILED;
2133
2231
  if (peg$silentFails === 0) {
2134
- peg$fail(peg$c64);
2232
+ peg$fail(peg$c65);
2135
2233
  }
2136
2234
  }
2137
2235
  if (s8 !== peg$FAILED) {
2138
2236
  peg$savedPos = s5;
2139
- s6 = peg$c66(s3, s4);
2237
+ s6 = peg$c67(s3, s4);
2140
2238
  s5 = s6;
2141
2239
  }
2142
2240
  else {
@@ -2158,7 +2256,7 @@ function peg$parse(input, options) {
2158
2256
  s6 = peg$parse_();
2159
2257
  if (s6 !== peg$FAILED) {
2160
2258
  peg$savedPos = s0;
2161
- s1 = peg$c67(s3, s4, s5);
2259
+ s1 = peg$c68(s3, s4, s5);
2162
2260
  s0 = s1;
2163
2261
  }
2164
2262
  else {
@@ -2196,27 +2294,27 @@ function peg$parse(input, options) {
2196
2294
  var s0, s1, s2;
2197
2295
  s0 = peg$currPos;
2198
2296
  s1 = [];
2199
- if (peg$c68.test(input.charAt(peg$currPos))) {
2297
+ if (peg$c69.test(input.charAt(peg$currPos))) {
2200
2298
  s2 = input.charAt(peg$currPos);
2201
2299
  peg$currPos++;
2202
2300
  }
2203
2301
  else {
2204
2302
  s2 = peg$FAILED;
2205
2303
  if (peg$silentFails === 0) {
2206
- peg$fail(peg$c69);
2304
+ peg$fail(peg$c70);
2207
2305
  }
2208
2306
  }
2209
2307
  if (s2 !== peg$FAILED) {
2210
2308
  while (s2 !== peg$FAILED) {
2211
2309
  s1.push(s2);
2212
- if (peg$c68.test(input.charAt(peg$currPos))) {
2310
+ if (peg$c69.test(input.charAt(peg$currPos))) {
2213
2311
  s2 = input.charAt(peg$currPos);
2214
2312
  peg$currPos++;
2215
2313
  }
2216
2314
  else {
2217
2315
  s2 = peg$FAILED;
2218
2316
  if (peg$silentFails === 0) {
2219
- peg$fail(peg$c69);
2317
+ peg$fail(peg$c70);
2220
2318
  }
2221
2319
  }
2222
2320
  }
@@ -2262,7 +2360,7 @@ function peg$parse(input, options) {
2262
2360
  s5 = peg$parselistItem();
2263
2361
  if (s5 !== peg$FAILED) {
2264
2362
  peg$savedPos = s3;
2265
- s4 = peg$c70(s1, s5);
2363
+ s4 = peg$c71(s1, s5);
2266
2364
  s3 = s4;
2267
2365
  }
2268
2366
  else {
@@ -2293,7 +2391,7 @@ function peg$parse(input, options) {
2293
2391
  s5 = peg$parselistItem();
2294
2392
  if (s5 !== peg$FAILED) {
2295
2393
  peg$savedPos = s3;
2296
- s4 = peg$c70(s1, s5);
2394
+ s4 = peg$c71(s1, s5);
2297
2395
  s3 = s4;
2298
2396
  }
2299
2397
  else {
@@ -2312,7 +2410,7 @@ function peg$parse(input, options) {
2312
2410
  }
2313
2411
  if (s2 !== peg$FAILED) {
2314
2412
  peg$savedPos = s0;
2315
- s1 = peg$c71(s1, s2);
2413
+ s1 = peg$c72(s1, s2);
2316
2414
  s0 = s1;
2317
2415
  }
2318
2416
  else {
@@ -2338,7 +2436,7 @@ function peg$parse(input, options) {
2338
2436
  s5 = peg$parse_();
2339
2437
  if (s5 !== peg$FAILED) {
2340
2438
  peg$savedPos = s2;
2341
- s3 = peg$c72(s4);
2439
+ s3 = peg$c73(s4);
2342
2440
  s2 = s3;
2343
2441
  }
2344
2442
  else {
@@ -2365,7 +2463,7 @@ function peg$parse(input, options) {
2365
2463
  s5 = peg$parse_();
2366
2464
  if (s5 !== peg$FAILED) {
2367
2465
  peg$savedPos = s2;
2368
- s3 = peg$c72(s4);
2466
+ s3 = peg$c73(s4);
2369
2467
  s2 = s3;
2370
2468
  }
2371
2469
  else {
@@ -2385,7 +2483,7 @@ function peg$parse(input, options) {
2385
2483
  }
2386
2484
  if (s1 !== peg$FAILED) {
2387
2485
  peg$savedPos = s0;
2388
- s1 = peg$c73(s1);
2486
+ s1 = peg$c74(s1);
2389
2487
  }
2390
2488
  s0 = s1;
2391
2489
  if (s0 === peg$FAILED) {
@@ -2393,7 +2491,7 @@ function peg$parse(input, options) {
2393
2491
  s1 = peg$parseitem();
2394
2492
  if (s1 !== peg$FAILED) {
2395
2493
  peg$savedPos = s0;
2396
- s1 = peg$c74(s1);
2494
+ s1 = peg$c75(s1);
2397
2495
  }
2398
2496
  s0 = s1;
2399
2497
  if (s0 === peg$FAILED) {
@@ -2401,7 +2499,7 @@ function peg$parse(input, options) {
2401
2499
  s1 = peg$parse_();
2402
2500
  if (s1 !== peg$FAILED) {
2403
2501
  peg$savedPos = s0;
2404
- s1 = peg$c75();
2502
+ s1 = peg$c76();
2405
2503
  }
2406
2504
  s0 = s1;
2407
2505
  }
@@ -2416,24 +2514,24 @@ function peg$parse(input, options) {
2416
2514
  s1 = peg$parse_();
2417
2515
  if (s1 !== peg$FAILED) {
2418
2516
  if (input.charCodeAt(peg$currPos) === 58) {
2419
- s2 = peg$c55;
2517
+ s2 = peg$c56;
2420
2518
  peg$currPos++;
2421
2519
  }
2422
2520
  else {
2423
2521
  s2 = peg$FAILED;
2424
2522
  if (peg$silentFails === 0) {
2425
- peg$fail(peg$c56);
2523
+ peg$fail(peg$c57);
2426
2524
  }
2427
2525
  }
2428
2526
  if (s2 !== peg$FAILED) {
2429
- if (peg$c57.test(input.charAt(peg$currPos))) {
2527
+ if (peg$c58.test(input.charAt(peg$currPos))) {
2430
2528
  s3 = input.charAt(peg$currPos);
2431
2529
  peg$currPos++;
2432
2530
  }
2433
2531
  else {
2434
2532
  s3 = peg$FAILED;
2435
2533
  if (peg$silentFails === 0) {
2436
- peg$fail(peg$c58);
2534
+ peg$fail(peg$c59);
2437
2535
  }
2438
2536
  }
2439
2537
  if (s3 === peg$FAILED) {
@@ -2444,13 +2542,13 @@ function peg$parse(input, options) {
2444
2542
  if (s4 !== peg$FAILED) {
2445
2543
  s5 = peg$currPos;
2446
2544
  if (input.charCodeAt(peg$currPos) === 123) {
2447
- s6 = peg$c76;
2545
+ s6 = peg$c77;
2448
2546
  peg$currPos++;
2449
2547
  }
2450
2548
  else {
2451
2549
  s6 = peg$FAILED;
2452
2550
  if (peg$silentFails === 0) {
2453
- peg$fail(peg$c77);
2551
+ peg$fail(peg$c78);
2454
2552
  }
2455
2553
  }
2456
2554
  if (s6 !== peg$FAILED) {
@@ -2461,18 +2559,18 @@ function peg$parse(input, options) {
2461
2559
  s9 = peg$parsegap();
2462
2560
  if (s9 !== peg$FAILED) {
2463
2561
  if (input.charCodeAt(peg$currPos) === 125) {
2464
- s10 = peg$c78;
2562
+ s10 = peg$c79;
2465
2563
  peg$currPos++;
2466
2564
  }
2467
2565
  else {
2468
2566
  s10 = peg$FAILED;
2469
2567
  if (peg$silentFails === 0) {
2470
- peg$fail(peg$c79);
2568
+ peg$fail(peg$c80);
2471
2569
  }
2472
2570
  }
2473
2571
  if (s10 !== peg$FAILED) {
2474
2572
  peg$savedPos = s5;
2475
- s6 = peg$c80(s3, s4, s8);
2573
+ s6 = peg$c81(s3, s4, s8);
2476
2574
  s5 = s6;
2477
2575
  }
2478
2576
  else {
@@ -2502,31 +2600,31 @@ function peg$parse(input, options) {
2502
2600
  if (s5 === peg$FAILED) {
2503
2601
  s5 = peg$currPos;
2504
2602
  if (input.charCodeAt(peg$currPos) === 123) {
2505
- s6 = peg$c76;
2603
+ s6 = peg$c77;
2506
2604
  peg$currPos++;
2507
2605
  }
2508
2606
  else {
2509
2607
  s6 = peg$FAILED;
2510
2608
  if (peg$silentFails === 0) {
2511
- peg$fail(peg$c77);
2609
+ peg$fail(peg$c78);
2512
2610
  }
2513
2611
  }
2514
2612
  if (s6 !== peg$FAILED) {
2515
2613
  s7 = peg$parsegap();
2516
2614
  if (s7 !== peg$FAILED) {
2517
2615
  if (input.charCodeAt(peg$currPos) === 125) {
2518
- s8 = peg$c78;
2616
+ s8 = peg$c79;
2519
2617
  peg$currPos++;
2520
2618
  }
2521
2619
  else {
2522
2620
  s8 = peg$FAILED;
2523
2621
  if (peg$silentFails === 0) {
2524
- peg$fail(peg$c79);
2622
+ peg$fail(peg$c80);
2525
2623
  }
2526
2624
  }
2527
2625
  if (s8 !== peg$FAILED) {
2528
2626
  peg$savedPos = s5;
2529
- s6 = peg$c81(s3, s4);
2627
+ s6 = peg$c82(s3, s4);
2530
2628
  s5 = s6;
2531
2629
  }
2532
2630
  else {
@@ -2546,13 +2644,13 @@ function peg$parse(input, options) {
2546
2644
  if (s5 === peg$FAILED) {
2547
2645
  s5 = peg$currPos;
2548
2646
  if (input.charCodeAt(peg$currPos) === 123) {
2549
- s6 = peg$c76;
2647
+ s6 = peg$c77;
2550
2648
  peg$currPos++;
2551
2649
  }
2552
2650
  else {
2553
2651
  s6 = peg$FAILED;
2554
2652
  if (peg$silentFails === 0) {
2555
- peg$fail(peg$c77);
2653
+ peg$fail(peg$c78);
2556
2654
  }
2557
2655
  }
2558
2656
  if (s6 !== peg$FAILED) {
@@ -2562,13 +2660,13 @@ function peg$parse(input, options) {
2562
2660
  s10 = peg$currPos;
2563
2661
  peg$silentFails++;
2564
2662
  if (input.charCodeAt(peg$currPos) === 125) {
2565
- s11 = peg$c78;
2663
+ s11 = peg$c79;
2566
2664
  peg$currPos++;
2567
2665
  }
2568
2666
  else {
2569
2667
  s11 = peg$FAILED;
2570
2668
  if (peg$silentFails === 0) {
2571
- peg$fail(peg$c79);
2669
+ peg$fail(peg$c80);
2572
2670
  }
2573
2671
  }
2574
2672
  if (s11 === peg$FAILED) {
@@ -2612,13 +2710,13 @@ function peg$parse(input, options) {
2612
2710
  s10 = peg$currPos;
2613
2711
  peg$silentFails++;
2614
2712
  if (input.charCodeAt(peg$currPos) === 125) {
2615
- s11 = peg$c78;
2713
+ s11 = peg$c79;
2616
2714
  peg$currPos++;
2617
2715
  }
2618
2716
  else {
2619
2717
  s11 = peg$FAILED;
2620
2718
  if (peg$silentFails === 0) {
2621
- peg$fail(peg$c79);
2719
+ peg$fail(peg$c80);
2622
2720
  }
2623
2721
  }
2624
2722
  if (s11 === peg$FAILED) {
@@ -2665,18 +2763,18 @@ function peg$parse(input, options) {
2665
2763
  }
2666
2764
  if (s7 !== peg$FAILED) {
2667
2765
  if (input.charCodeAt(peg$currPos) === 125) {
2668
- s8 = peg$c78;
2766
+ s8 = peg$c79;
2669
2767
  peg$currPos++;
2670
2768
  }
2671
2769
  else {
2672
2770
  s8 = peg$FAILED;
2673
2771
  if (peg$silentFails === 0) {
2674
- peg$fail(peg$c79);
2772
+ peg$fail(peg$c80);
2675
2773
  }
2676
2774
  }
2677
2775
  if (s8 !== peg$FAILED) {
2678
2776
  peg$savedPos = s5;
2679
- s6 = peg$c82(s3, s4);
2777
+ s6 = peg$c83(s3, s4);
2680
2778
  s5 = s6;
2681
2779
  }
2682
2780
  else {
@@ -2696,13 +2794,13 @@ function peg$parse(input, options) {
2696
2794
  if (s5 === peg$FAILED) {
2697
2795
  s5 = peg$currPos;
2698
2796
  if (input.charCodeAt(peg$currPos) === 91) {
2699
- s6 = peg$c83;
2797
+ s6 = peg$c84;
2700
2798
  peg$currPos++;
2701
2799
  }
2702
2800
  else {
2703
2801
  s6 = peg$FAILED;
2704
2802
  if (peg$silentFails === 0) {
2705
- peg$fail(peg$c84);
2803
+ peg$fail(peg$c85);
2706
2804
  }
2707
2805
  }
2708
2806
  if (s6 !== peg$FAILED) {
@@ -2712,13 +2810,13 @@ function peg$parse(input, options) {
2712
2810
  s10 = peg$currPos;
2713
2811
  peg$silentFails++;
2714
2812
  if (input.charCodeAt(peg$currPos) === 93) {
2715
- s11 = peg$c85;
2813
+ s11 = peg$c86;
2716
2814
  peg$currPos++;
2717
2815
  }
2718
2816
  else {
2719
2817
  s11 = peg$FAILED;
2720
2818
  if (peg$silentFails === 0) {
2721
- peg$fail(peg$c86);
2819
+ peg$fail(peg$c87);
2722
2820
  }
2723
2821
  }
2724
2822
  if (s11 === peg$FAILED) {
@@ -2762,13 +2860,13 @@ function peg$parse(input, options) {
2762
2860
  s10 = peg$currPos;
2763
2861
  peg$silentFails++;
2764
2862
  if (input.charCodeAt(peg$currPos) === 93) {
2765
- s11 = peg$c85;
2863
+ s11 = peg$c86;
2766
2864
  peg$currPos++;
2767
2865
  }
2768
2866
  else {
2769
2867
  s11 = peg$FAILED;
2770
2868
  if (peg$silentFails === 0) {
2771
- peg$fail(peg$c86);
2869
+ peg$fail(peg$c87);
2772
2870
  }
2773
2871
  }
2774
2872
  if (s11 === peg$FAILED) {
@@ -2815,18 +2913,18 @@ function peg$parse(input, options) {
2815
2913
  }
2816
2914
  if (s7 !== peg$FAILED) {
2817
2915
  if (input.charCodeAt(peg$currPos) === 93) {
2818
- s8 = peg$c85;
2916
+ s8 = peg$c86;
2819
2917
  peg$currPos++;
2820
2918
  }
2821
2919
  else {
2822
2920
  s8 = peg$FAILED;
2823
2921
  if (peg$silentFails === 0) {
2824
- peg$fail(peg$c86);
2922
+ peg$fail(peg$c87);
2825
2923
  }
2826
2924
  }
2827
2925
  if (s8 !== peg$FAILED) {
2828
2926
  peg$savedPos = s5;
2829
- s6 = peg$c87(s3, s4);
2927
+ s6 = peg$c88(s3, s4);
2830
2928
  s5 = s6;
2831
2929
  }
2832
2930
  else {
@@ -2846,13 +2944,13 @@ function peg$parse(input, options) {
2846
2944
  if (s5 === peg$FAILED) {
2847
2945
  s5 = peg$currPos;
2848
2946
  if (input.charCodeAt(peg$currPos) === 60) {
2849
- s6 = peg$c61;
2947
+ s6 = peg$c62;
2850
2948
  peg$currPos++;
2851
2949
  }
2852
2950
  else {
2853
2951
  s6 = peg$FAILED;
2854
2952
  if (peg$silentFails === 0) {
2855
- peg$fail(peg$c62);
2953
+ peg$fail(peg$c63);
2856
2954
  }
2857
2955
  }
2858
2956
  if (s6 !== peg$FAILED) {
@@ -2863,18 +2961,18 @@ function peg$parse(input, options) {
2863
2961
  s9 = peg$parse_();
2864
2962
  if (s9 !== peg$FAILED) {
2865
2963
  if (input.charCodeAt(peg$currPos) === 62) {
2866
- s10 = peg$c63;
2964
+ s10 = peg$c64;
2867
2965
  peg$currPos++;
2868
2966
  }
2869
2967
  else {
2870
2968
  s10 = peg$FAILED;
2871
2969
  if (peg$silentFails === 0) {
2872
- peg$fail(peg$c64);
2970
+ peg$fail(peg$c65);
2873
2971
  }
2874
2972
  }
2875
2973
  if (s10 !== peg$FAILED) {
2876
2974
  peg$savedPos = s5;
2877
- s6 = peg$c88(s3, s4, s8);
2975
+ s6 = peg$c89(s3, s4, s8);
2878
2976
  s5 = s6;
2879
2977
  }
2880
2978
  else {
@@ -2904,51 +3002,51 @@ function peg$parse(input, options) {
2904
3002
  if (s5 === peg$FAILED) {
2905
3003
  s5 = peg$currPos;
2906
3004
  if (input.charCodeAt(peg$currPos) === 60) {
2907
- s6 = peg$c61;
3005
+ s6 = peg$c62;
2908
3006
  peg$currPos++;
2909
3007
  }
2910
3008
  else {
2911
3009
  s6 = peg$FAILED;
2912
3010
  if (peg$silentFails === 0) {
2913
- peg$fail(peg$c62);
3011
+ peg$fail(peg$c63);
2914
3012
  }
2915
3013
  }
2916
3014
  if (s6 !== peg$FAILED) {
2917
3015
  s7 = peg$parse_();
2918
3016
  if (s7 !== peg$FAILED) {
2919
- if (peg$c89.test(input.charAt(peg$currPos))) {
3017
+ if (peg$c90.test(input.charAt(peg$currPos))) {
2920
3018
  s8 = input.charAt(peg$currPos);
2921
3019
  peg$currPos++;
2922
3020
  }
2923
3021
  else {
2924
3022
  s8 = peg$FAILED;
2925
3023
  if (peg$silentFails === 0) {
2926
- peg$fail(peg$c90);
3024
+ peg$fail(peg$c91);
2927
3025
  }
2928
3026
  }
2929
3027
  if (s8 !== peg$FAILED) {
2930
3028
  s9 = peg$currPos;
2931
3029
  s10 = [];
2932
- if (peg$c91.test(input.charAt(peg$currPos))) {
3030
+ if (peg$c92.test(input.charAt(peg$currPos))) {
2933
3031
  s11 = input.charAt(peg$currPos);
2934
3032
  peg$currPos++;
2935
3033
  }
2936
3034
  else {
2937
3035
  s11 = peg$FAILED;
2938
3036
  if (peg$silentFails === 0) {
2939
- peg$fail(peg$c92);
3037
+ peg$fail(peg$c93);
2940
3038
  }
2941
3039
  }
2942
3040
  while (s11 !== peg$FAILED) {
2943
3041
  s10.push(s11);
2944
- if (peg$c91.test(input.charAt(peg$currPos))) {
3042
+ if (peg$c92.test(input.charAt(peg$currPos))) {
2945
3043
  s11 = input.charAt(peg$currPos);
2946
3044
  peg$currPos++;
2947
3045
  }
2948
3046
  else {
2949
3047
  s11 = peg$FAILED;
2950
3048
  if (peg$silentFails === 0) {
2951
- peg$fail(peg$c92);
3049
+ peg$fail(peg$c93);
2952
3050
  }
2953
3051
  }
2954
3052
  }
@@ -2959,32 +3057,32 @@ function peg$parse(input, options) {
2959
3057
  s9 = s10;
2960
3058
  }
2961
3059
  if (s9 !== peg$FAILED) {
2962
- if (peg$c89.test(input.charAt(peg$currPos))) {
3060
+ if (peg$c90.test(input.charAt(peg$currPos))) {
2963
3061
  s10 = input.charAt(peg$currPos);
2964
3062
  peg$currPos++;
2965
3063
  }
2966
3064
  else {
2967
3065
  s10 = peg$FAILED;
2968
3066
  if (peg$silentFails === 0) {
2969
- peg$fail(peg$c90);
3067
+ peg$fail(peg$c91);
2970
3068
  }
2971
3069
  }
2972
3070
  if (s10 !== peg$FAILED) {
2973
3071
  s11 = peg$parse_();
2974
3072
  if (s11 !== peg$FAILED) {
2975
3073
  if (input.charCodeAt(peg$currPos) === 62) {
2976
- s12 = peg$c63;
3074
+ s12 = peg$c64;
2977
3075
  peg$currPos++;
2978
3076
  }
2979
3077
  else {
2980
3078
  s12 = peg$FAILED;
2981
3079
  if (peg$silentFails === 0) {
2982
- peg$fail(peg$c64);
3080
+ peg$fail(peg$c65);
2983
3081
  }
2984
3082
  }
2985
3083
  if (s12 !== peg$FAILED) {
2986
3084
  peg$savedPos = s5;
2987
- s6 = peg$c93(s3, s4, s9);
3085
+ s6 = peg$c94(s3, s4, s9);
2988
3086
  s5 = s6;
2989
3087
  }
2990
3088
  else {
@@ -3024,51 +3122,51 @@ function peg$parse(input, options) {
3024
3122
  if (s5 === peg$FAILED) {
3025
3123
  s5 = peg$currPos;
3026
3124
  if (input.charCodeAt(peg$currPos) === 60) {
3027
- s6 = peg$c61;
3125
+ s6 = peg$c62;
3028
3126
  peg$currPos++;
3029
3127
  }
3030
3128
  else {
3031
3129
  s6 = peg$FAILED;
3032
3130
  if (peg$silentFails === 0) {
3033
- peg$fail(peg$c62);
3131
+ peg$fail(peg$c63);
3034
3132
  }
3035
3133
  }
3036
3134
  if (s6 !== peg$FAILED) {
3037
3135
  s7 = peg$parse_();
3038
3136
  if (s7 !== peg$FAILED) {
3039
- if (peg$c94.test(input.charAt(peg$currPos))) {
3137
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3040
3138
  s8 = input.charAt(peg$currPos);
3041
3139
  peg$currPos++;
3042
3140
  }
3043
3141
  else {
3044
3142
  s8 = peg$FAILED;
3045
3143
  if (peg$silentFails === 0) {
3046
- peg$fail(peg$c95);
3144
+ peg$fail(peg$c96);
3047
3145
  }
3048
3146
  }
3049
3147
  if (s8 !== peg$FAILED) {
3050
3148
  s9 = peg$currPos;
3051
3149
  s10 = [];
3052
- if (peg$c96.test(input.charAt(peg$currPos))) {
3150
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3053
3151
  s11 = input.charAt(peg$currPos);
3054
3152
  peg$currPos++;
3055
3153
  }
3056
3154
  else {
3057
3155
  s11 = peg$FAILED;
3058
3156
  if (peg$silentFails === 0) {
3059
- peg$fail(peg$c97);
3157
+ peg$fail(peg$c98);
3060
3158
  }
3061
3159
  }
3062
3160
  while (s11 !== peg$FAILED) {
3063
3161
  s10.push(s11);
3064
- if (peg$c96.test(input.charAt(peg$currPos))) {
3162
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3065
3163
  s11 = input.charAt(peg$currPos);
3066
3164
  peg$currPos++;
3067
3165
  }
3068
3166
  else {
3069
3167
  s11 = peg$FAILED;
3070
3168
  if (peg$silentFails === 0) {
3071
- peg$fail(peg$c97);
3169
+ peg$fail(peg$c98);
3072
3170
  }
3073
3171
  }
3074
3172
  }
@@ -3079,32 +3177,32 @@ function peg$parse(input, options) {
3079
3177
  s9 = s10;
3080
3178
  }
3081
3179
  if (s9 !== peg$FAILED) {
3082
- if (peg$c94.test(input.charAt(peg$currPos))) {
3180
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3083
3181
  s10 = input.charAt(peg$currPos);
3084
3182
  peg$currPos++;
3085
3183
  }
3086
3184
  else {
3087
3185
  s10 = peg$FAILED;
3088
3186
  if (peg$silentFails === 0) {
3089
- peg$fail(peg$c95);
3187
+ peg$fail(peg$c96);
3090
3188
  }
3091
3189
  }
3092
3190
  if (s10 !== peg$FAILED) {
3093
3191
  s11 = peg$parse_();
3094
3192
  if (s11 !== peg$FAILED) {
3095
3193
  if (input.charCodeAt(peg$currPos) === 62) {
3096
- s12 = peg$c63;
3194
+ s12 = peg$c64;
3097
3195
  peg$currPos++;
3098
3196
  }
3099
3197
  else {
3100
3198
  s12 = peg$FAILED;
3101
3199
  if (peg$silentFails === 0) {
3102
- peg$fail(peg$c64);
3200
+ peg$fail(peg$c65);
3103
3201
  }
3104
3202
  }
3105
3203
  if (s12 !== peg$FAILED) {
3106
3204
  peg$savedPos = s5;
3107
- s6 = peg$c93(s3, s4, s9);
3205
+ s6 = peg$c94(s3, s4, s9);
3108
3206
  s5 = s6;
3109
3207
  }
3110
3208
  else {
@@ -3144,13 +3242,13 @@ function peg$parse(input, options) {
3144
3242
  if (s5 === peg$FAILED) {
3145
3243
  s5 = peg$currPos;
3146
3244
  if (input.charCodeAt(peg$currPos) === 60) {
3147
- s6 = peg$c61;
3245
+ s6 = peg$c62;
3148
3246
  peg$currPos++;
3149
3247
  }
3150
3248
  else {
3151
3249
  s6 = peg$FAILED;
3152
3250
  if (peg$silentFails === 0) {
3153
- peg$fail(peg$c62);
3251
+ peg$fail(peg$c63);
3154
3252
  }
3155
3253
  }
3156
3254
  if (s6 !== peg$FAILED) {
@@ -3162,24 +3260,24 @@ function peg$parse(input, options) {
3162
3260
  s11 = peg$currPos;
3163
3261
  peg$silentFails++;
3164
3262
  if (input.charCodeAt(peg$currPos) === 60) {
3165
- s12 = peg$c61;
3263
+ s12 = peg$c62;
3166
3264
  peg$currPos++;
3167
3265
  }
3168
3266
  else {
3169
3267
  s12 = peg$FAILED;
3170
3268
  if (peg$silentFails === 0) {
3171
- peg$fail(peg$c62);
3269
+ peg$fail(peg$c63);
3172
3270
  }
3173
3271
  }
3174
3272
  if (s12 === peg$FAILED) {
3175
3273
  if (input.charCodeAt(peg$currPos) === 62) {
3176
- s12 = peg$c63;
3274
+ s12 = peg$c64;
3177
3275
  peg$currPos++;
3178
3276
  }
3179
3277
  else {
3180
3278
  s12 = peg$FAILED;
3181
3279
  if (peg$silentFails === 0) {
3182
- peg$fail(peg$c64);
3280
+ peg$fail(peg$c65);
3183
3281
  }
3184
3282
  }
3185
3283
  if (s12 === peg$FAILED) {
@@ -3225,24 +3323,24 @@ function peg$parse(input, options) {
3225
3323
  s11 = peg$currPos;
3226
3324
  peg$silentFails++;
3227
3325
  if (input.charCodeAt(peg$currPos) === 60) {
3228
- s12 = peg$c61;
3326
+ s12 = peg$c62;
3229
3327
  peg$currPos++;
3230
3328
  }
3231
3329
  else {
3232
3330
  s12 = peg$FAILED;
3233
3331
  if (peg$silentFails === 0) {
3234
- peg$fail(peg$c62);
3332
+ peg$fail(peg$c63);
3235
3333
  }
3236
3334
  }
3237
3335
  if (s12 === peg$FAILED) {
3238
3336
  if (input.charCodeAt(peg$currPos) === 62) {
3239
- s12 = peg$c63;
3337
+ s12 = peg$c64;
3240
3338
  peg$currPos++;
3241
3339
  }
3242
3340
  else {
3243
3341
  s12 = peg$FAILED;
3244
3342
  if (peg$silentFails === 0) {
3245
- peg$fail(peg$c64);
3343
+ peg$fail(peg$c65);
3246
3344
  }
3247
3345
  }
3248
3346
  if (s12 === peg$FAILED) {
@@ -3294,18 +3392,18 @@ function peg$parse(input, options) {
3294
3392
  }
3295
3393
  if (s8 !== peg$FAILED) {
3296
3394
  if (input.charCodeAt(peg$currPos) === 62) {
3297
- s9 = peg$c63;
3395
+ s9 = peg$c64;
3298
3396
  peg$currPos++;
3299
3397
  }
3300
3398
  else {
3301
3399
  s9 = peg$FAILED;
3302
3400
  if (peg$silentFails === 0) {
3303
- peg$fail(peg$c64);
3401
+ peg$fail(peg$c65);
3304
3402
  }
3305
3403
  }
3306
3404
  if (s9 !== peg$FAILED) {
3307
3405
  peg$savedPos = s5;
3308
- s6 = peg$c98(s3, s4, s8);
3406
+ s6 = peg$c99(s3, s4, s8);
3309
3407
  s5 = s6;
3310
3408
  }
3311
3409
  else {
@@ -3330,31 +3428,31 @@ function peg$parse(input, options) {
3330
3428
  if (s5 === peg$FAILED) {
3331
3429
  s5 = peg$currPos;
3332
3430
  if (input.charCodeAt(peg$currPos) === 60) {
3333
- s6 = peg$c61;
3431
+ s6 = peg$c62;
3334
3432
  peg$currPos++;
3335
3433
  }
3336
3434
  else {
3337
3435
  s6 = peg$FAILED;
3338
3436
  if (peg$silentFails === 0) {
3339
- peg$fail(peg$c62);
3437
+ peg$fail(peg$c63);
3340
3438
  }
3341
3439
  }
3342
3440
  if (s6 !== peg$FAILED) {
3343
3441
  s7 = peg$parse_();
3344
3442
  if (s7 !== peg$FAILED) {
3345
3443
  if (input.charCodeAt(peg$currPos) === 62) {
3346
- s8 = peg$c63;
3444
+ s8 = peg$c64;
3347
3445
  peg$currPos++;
3348
3446
  }
3349
3447
  else {
3350
3448
  s8 = peg$FAILED;
3351
3449
  if (peg$silentFails === 0) {
3352
- peg$fail(peg$c64);
3450
+ peg$fail(peg$c65);
3353
3451
  }
3354
3452
  }
3355
3453
  if (s8 !== peg$FAILED) {
3356
3454
  peg$savedPos = s5;
3357
- s6 = peg$c99(s3, s4);
3455
+ s6 = peg$c100(s3, s4);
3358
3456
  s5 = s6;
3359
3457
  }
3360
3458
  else {
@@ -3374,13 +3472,13 @@ function peg$parse(input, options) {
3374
3472
  if (s5 === peg$FAILED) {
3375
3473
  s5 = peg$currPos;
3376
3474
  if (input.charCodeAt(peg$currPos) === 40) {
3377
- s6 = peg$c100;
3475
+ s6 = peg$c101;
3378
3476
  peg$currPos++;
3379
3477
  }
3380
3478
  else {
3381
3479
  s6 = peg$FAILED;
3382
3480
  if (peg$silentFails === 0) {
3383
- peg$fail(peg$c101);
3481
+ peg$fail(peg$c102);
3384
3482
  }
3385
3483
  }
3386
3484
  if (s6 !== peg$FAILED) {
@@ -3390,25 +3488,25 @@ function peg$parse(input, options) {
3390
3488
  s9 = peg$parsearray_items();
3391
3489
  if (s9 !== peg$FAILED) {
3392
3490
  peg$savedPos = s8;
3393
- s9 = peg$c102(s3, s4, s9);
3491
+ s9 = peg$c103(s3, s4, s9);
3394
3492
  }
3395
3493
  s8 = s9;
3396
3494
  if (s8 !== peg$FAILED) {
3397
3495
  s9 = peg$parsegap();
3398
3496
  if (s9 !== peg$FAILED) {
3399
3497
  if (input.charCodeAt(peg$currPos) === 41) {
3400
- s10 = peg$c103;
3498
+ s10 = peg$c104;
3401
3499
  peg$currPos++;
3402
3500
  }
3403
3501
  else {
3404
3502
  s10 = peg$FAILED;
3405
3503
  if (peg$silentFails === 0) {
3406
- peg$fail(peg$c104);
3504
+ peg$fail(peg$c105);
3407
3505
  }
3408
3506
  }
3409
3507
  if (s10 !== peg$FAILED) {
3410
3508
  peg$savedPos = s5;
3411
- s6 = peg$c105(s3, s4, s8);
3509
+ s6 = peg$c106(s3, s4, s8);
3412
3510
  s5 = s6;
3413
3511
  }
3414
3512
  else {
@@ -3438,31 +3536,31 @@ function peg$parse(input, options) {
3438
3536
  if (s5 === peg$FAILED) {
3439
3537
  s5 = peg$currPos;
3440
3538
  if (input.charCodeAt(peg$currPos) === 40) {
3441
- s6 = peg$c100;
3539
+ s6 = peg$c101;
3442
3540
  peg$currPos++;
3443
3541
  }
3444
3542
  else {
3445
3543
  s6 = peg$FAILED;
3446
3544
  if (peg$silentFails === 0) {
3447
- peg$fail(peg$c101);
3545
+ peg$fail(peg$c102);
3448
3546
  }
3449
3547
  }
3450
3548
  if (s6 !== peg$FAILED) {
3451
3549
  s7 = peg$parsegap();
3452
3550
  if (s7 !== peg$FAILED) {
3453
3551
  if (input.charCodeAt(peg$currPos) === 41) {
3454
- s8 = peg$c103;
3552
+ s8 = peg$c104;
3455
3553
  peg$currPos++;
3456
3554
  }
3457
3555
  else {
3458
3556
  s8 = peg$FAILED;
3459
3557
  if (peg$silentFails === 0) {
3460
- peg$fail(peg$c104);
3558
+ peg$fail(peg$c105);
3461
3559
  }
3462
3560
  }
3463
3561
  if (s8 !== peg$FAILED) {
3464
3562
  peg$savedPos = s5;
3465
- s6 = peg$c99(s3, s4);
3563
+ s6 = peg$c100(s3, s4);
3466
3564
  s5 = s6;
3467
3565
  }
3468
3566
  else {
@@ -3482,13 +3580,13 @@ function peg$parse(input, options) {
3482
3580
  if (s5 === peg$FAILED) {
3483
3581
  s5 = peg$currPos;
3484
3582
  if (input.charCodeAt(peg$currPos) === 40) {
3485
- s6 = peg$c100;
3583
+ s6 = peg$c101;
3486
3584
  peg$currPos++;
3487
3585
  }
3488
3586
  else {
3489
3587
  s6 = peg$FAILED;
3490
3588
  if (peg$silentFails === 0) {
3491
- peg$fail(peg$c101);
3589
+ peg$fail(peg$c102);
3492
3590
  }
3493
3591
  }
3494
3592
  if (s6 !== peg$FAILED) {
@@ -3497,13 +3595,13 @@ function peg$parse(input, options) {
3497
3595
  s8 = peg$currPos;
3498
3596
  s9 = peg$currPos;
3499
3597
  if (input.charCodeAt(peg$currPos) === 58) {
3500
- s10 = peg$c55;
3598
+ s10 = peg$c56;
3501
3599
  peg$currPos++;
3502
3600
  }
3503
3601
  else {
3504
3602
  s10 = peg$FAILED;
3505
3603
  if (peg$silentFails === 0) {
3506
- peg$fail(peg$c56);
3604
+ peg$fail(peg$c57);
3507
3605
  }
3508
3606
  }
3509
3607
  if (s10 !== peg$FAILED) {
@@ -3512,24 +3610,24 @@ function peg$parse(input, options) {
3512
3610
  s13 = peg$currPos;
3513
3611
  peg$silentFails++;
3514
3612
  if (input.charCodeAt(peg$currPos) === 41) {
3515
- s14 = peg$c103;
3613
+ s14 = peg$c104;
3516
3614
  peg$currPos++;
3517
3615
  }
3518
3616
  else {
3519
3617
  s14 = peg$FAILED;
3520
3618
  if (peg$silentFails === 0) {
3521
- peg$fail(peg$c104);
3619
+ peg$fail(peg$c105);
3522
3620
  }
3523
3621
  }
3524
3622
  if (s14 === peg$FAILED) {
3525
3623
  if (input.charCodeAt(peg$currPos) === 40) {
3526
- s14 = peg$c100;
3624
+ s14 = peg$c101;
3527
3625
  peg$currPos++;
3528
3626
  }
3529
3627
  else {
3530
3628
  s14 = peg$FAILED;
3531
3629
  if (peg$silentFails === 0) {
3532
- peg$fail(peg$c101);
3630
+ peg$fail(peg$c102);
3533
3631
  }
3534
3632
  }
3535
3633
  }
@@ -3571,24 +3669,24 @@ function peg$parse(input, options) {
3571
3669
  s13 = peg$currPos;
3572
3670
  peg$silentFails++;
3573
3671
  if (input.charCodeAt(peg$currPos) === 41) {
3574
- s14 = peg$c103;
3672
+ s14 = peg$c104;
3575
3673
  peg$currPos++;
3576
3674
  }
3577
3675
  else {
3578
3676
  s14 = peg$FAILED;
3579
3677
  if (peg$silentFails === 0) {
3580
- peg$fail(peg$c104);
3678
+ peg$fail(peg$c105);
3581
3679
  }
3582
3680
  }
3583
3681
  if (s14 === peg$FAILED) {
3584
3682
  if (input.charCodeAt(peg$currPos) === 40) {
3585
- s14 = peg$c100;
3683
+ s14 = peg$c101;
3586
3684
  peg$currPos++;
3587
3685
  }
3588
3686
  else {
3589
3687
  s14 = peg$FAILED;
3590
3688
  if (peg$silentFails === 0) {
3591
- peg$fail(peg$c101);
3689
+ peg$fail(peg$c102);
3592
3690
  }
3593
3691
  }
3594
3692
  }
@@ -3646,18 +3744,18 @@ function peg$parse(input, options) {
3646
3744
  }
3647
3745
  if (s8 !== peg$FAILED) {
3648
3746
  if (input.charCodeAt(peg$currPos) === 41) {
3649
- s9 = peg$c103;
3747
+ s9 = peg$c104;
3650
3748
  peg$currPos++;
3651
3749
  }
3652
3750
  else {
3653
3751
  s9 = peg$FAILED;
3654
3752
  if (peg$silentFails === 0) {
3655
- peg$fail(peg$c104);
3753
+ peg$fail(peg$c105);
3656
3754
  }
3657
3755
  }
3658
3756
  if (s9 !== peg$FAILED) {
3659
3757
  peg$savedPos = s5;
3660
- s6 = peg$c93(s3, s4, s8);
3758
+ s6 = peg$c94(s3, s4, s8);
3661
3759
  s5 = s6;
3662
3760
  }
3663
3761
  else {
@@ -3682,13 +3780,13 @@ function peg$parse(input, options) {
3682
3780
  if (s5 === peg$FAILED) {
3683
3781
  s5 = peg$currPos;
3684
3782
  if (input.charCodeAt(peg$currPos) === 40) {
3685
- s6 = peg$c100;
3783
+ s6 = peg$c101;
3686
3784
  peg$currPos++;
3687
3785
  }
3688
3786
  else {
3689
3787
  s6 = peg$FAILED;
3690
3788
  if (peg$silentFails === 0) {
3691
- peg$fail(peg$c101);
3789
+ peg$fail(peg$c102);
3692
3790
  }
3693
3791
  }
3694
3792
  if (s6 !== peg$FAILED) {
@@ -3698,13 +3796,13 @@ function peg$parse(input, options) {
3698
3796
  s10 = peg$currPos;
3699
3797
  peg$silentFails++;
3700
3798
  if (input.charCodeAt(peg$currPos) === 41) {
3701
- s11 = peg$c103;
3799
+ s11 = peg$c104;
3702
3800
  peg$currPos++;
3703
3801
  }
3704
3802
  else {
3705
3803
  s11 = peg$FAILED;
3706
3804
  if (peg$silentFails === 0) {
3707
- peg$fail(peg$c104);
3805
+ peg$fail(peg$c105);
3708
3806
  }
3709
3807
  }
3710
3808
  if (s11 === peg$FAILED) {
@@ -3748,13 +3846,13 @@ function peg$parse(input, options) {
3748
3846
  s10 = peg$currPos;
3749
3847
  peg$silentFails++;
3750
3848
  if (input.charCodeAt(peg$currPos) === 41) {
3751
- s11 = peg$c103;
3849
+ s11 = peg$c104;
3752
3850
  peg$currPos++;
3753
3851
  }
3754
3852
  else {
3755
3853
  s11 = peg$FAILED;
3756
3854
  if (peg$silentFails === 0) {
3757
- peg$fail(peg$c104);
3855
+ peg$fail(peg$c105);
3758
3856
  }
3759
3857
  }
3760
3858
  if (s11 === peg$FAILED) {
@@ -3801,18 +3899,18 @@ function peg$parse(input, options) {
3801
3899
  }
3802
3900
  if (s7 !== peg$FAILED) {
3803
3901
  if (input.charCodeAt(peg$currPos) === 41) {
3804
- s8 = peg$c103;
3902
+ s8 = peg$c104;
3805
3903
  peg$currPos++;
3806
3904
  }
3807
3905
  else {
3808
3906
  s8 = peg$FAILED;
3809
3907
  if (peg$silentFails === 0) {
3810
- peg$fail(peg$c104);
3908
+ peg$fail(peg$c105);
3811
3909
  }
3812
3910
  }
3813
3911
  if (s8 !== peg$FAILED) {
3814
3912
  peg$savedPos = s5;
3815
- s6 = peg$c106(s3, s4);
3913
+ s6 = peg$c107(s3, s4);
3816
3914
  s5 = s6;
3817
3915
  }
3818
3916
  else {
@@ -3831,39 +3929,39 @@ function peg$parse(input, options) {
3831
3929
  }
3832
3930
  if (s5 === peg$FAILED) {
3833
3931
  s5 = peg$currPos;
3834
- if (peg$c89.test(input.charAt(peg$currPos))) {
3932
+ if (peg$c90.test(input.charAt(peg$currPos))) {
3835
3933
  s6 = input.charAt(peg$currPos);
3836
3934
  peg$currPos++;
3837
3935
  }
3838
3936
  else {
3839
3937
  s6 = peg$FAILED;
3840
3938
  if (peg$silentFails === 0) {
3841
- peg$fail(peg$c90);
3939
+ peg$fail(peg$c91);
3842
3940
  }
3843
3941
  }
3844
3942
  if (s6 !== peg$FAILED) {
3845
3943
  s7 = peg$currPos;
3846
3944
  s8 = [];
3847
- if (peg$c91.test(input.charAt(peg$currPos))) {
3945
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3848
3946
  s9 = input.charAt(peg$currPos);
3849
3947
  peg$currPos++;
3850
3948
  }
3851
3949
  else {
3852
3950
  s9 = peg$FAILED;
3853
3951
  if (peg$silentFails === 0) {
3854
- peg$fail(peg$c92);
3952
+ peg$fail(peg$c93);
3855
3953
  }
3856
3954
  }
3857
3955
  while (s9 !== peg$FAILED) {
3858
3956
  s8.push(s9);
3859
- if (peg$c91.test(input.charAt(peg$currPos))) {
3957
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3860
3958
  s9 = input.charAt(peg$currPos);
3861
3959
  peg$currPos++;
3862
3960
  }
3863
3961
  else {
3864
3962
  s9 = peg$FAILED;
3865
3963
  if (peg$silentFails === 0) {
3866
- peg$fail(peg$c92);
3964
+ peg$fail(peg$c93);
3867
3965
  }
3868
3966
  }
3869
3967
  }
@@ -3874,19 +3972,19 @@ function peg$parse(input, options) {
3874
3972
  s7 = s8;
3875
3973
  }
3876
3974
  if (s7 !== peg$FAILED) {
3877
- if (peg$c89.test(input.charAt(peg$currPos))) {
3975
+ if (peg$c90.test(input.charAt(peg$currPos))) {
3878
3976
  s8 = input.charAt(peg$currPos);
3879
3977
  peg$currPos++;
3880
3978
  }
3881
3979
  else {
3882
3980
  s8 = peg$FAILED;
3883
3981
  if (peg$silentFails === 0) {
3884
- peg$fail(peg$c90);
3982
+ peg$fail(peg$c91);
3885
3983
  }
3886
3984
  }
3887
3985
  if (s8 !== peg$FAILED) {
3888
3986
  peg$savedPos = s5;
3889
- s6 = peg$c93(s3, s4, s7);
3987
+ s6 = peg$c94(s3, s4, s7);
3890
3988
  s5 = s6;
3891
3989
  }
3892
3990
  else {
@@ -3905,39 +4003,39 @@ function peg$parse(input, options) {
3905
4003
  }
3906
4004
  if (s5 === peg$FAILED) {
3907
4005
  s5 = peg$currPos;
3908
- if (peg$c94.test(input.charAt(peg$currPos))) {
4006
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3909
4007
  s6 = input.charAt(peg$currPos);
3910
4008
  peg$currPos++;
3911
4009
  }
3912
4010
  else {
3913
4011
  s6 = peg$FAILED;
3914
4012
  if (peg$silentFails === 0) {
3915
- peg$fail(peg$c95);
4013
+ peg$fail(peg$c96);
3916
4014
  }
3917
4015
  }
3918
4016
  if (s6 !== peg$FAILED) {
3919
4017
  s7 = peg$currPos;
3920
4018
  s8 = [];
3921
- if (peg$c96.test(input.charAt(peg$currPos))) {
4019
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3922
4020
  s9 = input.charAt(peg$currPos);
3923
4021
  peg$currPos++;
3924
4022
  }
3925
4023
  else {
3926
4024
  s9 = peg$FAILED;
3927
4025
  if (peg$silentFails === 0) {
3928
- peg$fail(peg$c97);
4026
+ peg$fail(peg$c98);
3929
4027
  }
3930
4028
  }
3931
4029
  while (s9 !== peg$FAILED) {
3932
4030
  s8.push(s9);
3933
- if (peg$c96.test(input.charAt(peg$currPos))) {
4031
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3934
4032
  s9 = input.charAt(peg$currPos);
3935
4033
  peg$currPos++;
3936
4034
  }
3937
4035
  else {
3938
4036
  s9 = peg$FAILED;
3939
4037
  if (peg$silentFails === 0) {
3940
- peg$fail(peg$c97);
4038
+ peg$fail(peg$c98);
3941
4039
  }
3942
4040
  }
3943
4041
  }
@@ -3948,19 +4046,19 @@ function peg$parse(input, options) {
3948
4046
  s7 = s8;
3949
4047
  }
3950
4048
  if (s7 !== peg$FAILED) {
3951
- if (peg$c94.test(input.charAt(peg$currPos))) {
4049
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3952
4050
  s8 = input.charAt(peg$currPos);
3953
4051
  peg$currPos++;
3954
4052
  }
3955
4053
  else {
3956
4054
  s8 = peg$FAILED;
3957
4055
  if (peg$silentFails === 0) {
3958
- peg$fail(peg$c95);
4056
+ peg$fail(peg$c96);
3959
4057
  }
3960
4058
  }
3961
4059
  if (s8 !== peg$FAILED) {
3962
4060
  peg$savedPos = s5;
3963
- s6 = peg$c93(s3, s4, s7);
4061
+ s6 = peg$c94(s3, s4, s7);
3964
4062
  s5 = s6;
3965
4063
  }
3966
4064
  else {
@@ -3980,38 +4078,38 @@ function peg$parse(input, options) {
3980
4078
  if (s5 === peg$FAILED) {
3981
4079
  s5 = peg$currPos;
3982
4080
  if (input.charCodeAt(peg$currPos) === 65378) {
3983
- s6 = peg$c107;
4081
+ s6 = peg$c108;
3984
4082
  peg$currPos++;
3985
4083
  }
3986
4084
  else {
3987
4085
  s6 = peg$FAILED;
3988
4086
  if (peg$silentFails === 0) {
3989
- peg$fail(peg$c108);
4087
+ peg$fail(peg$c109);
3990
4088
  }
3991
4089
  }
3992
4090
  if (s6 !== peg$FAILED) {
3993
4091
  s7 = peg$currPos;
3994
4092
  s8 = [];
3995
- if (peg$c109.test(input.charAt(peg$currPos))) {
4093
+ if (peg$c110.test(input.charAt(peg$currPos))) {
3996
4094
  s9 = input.charAt(peg$currPos);
3997
4095
  peg$currPos++;
3998
4096
  }
3999
4097
  else {
4000
4098
  s9 = peg$FAILED;
4001
4099
  if (peg$silentFails === 0) {
4002
- peg$fail(peg$c110);
4100
+ peg$fail(peg$c111);
4003
4101
  }
4004
4102
  }
4005
4103
  while (s9 !== peg$FAILED) {
4006
4104
  s8.push(s9);
4007
- if (peg$c109.test(input.charAt(peg$currPos))) {
4105
+ if (peg$c110.test(input.charAt(peg$currPos))) {
4008
4106
  s9 = input.charAt(peg$currPos);
4009
4107
  peg$currPos++;
4010
4108
  }
4011
4109
  else {
4012
4110
  s9 = peg$FAILED;
4013
4111
  if (peg$silentFails === 0) {
4014
- peg$fail(peg$c110);
4112
+ peg$fail(peg$c111);
4015
4113
  }
4016
4114
  }
4017
4115
  }
@@ -4023,18 +4121,18 @@ function peg$parse(input, options) {
4023
4121
  }
4024
4122
  if (s7 !== peg$FAILED) {
4025
4123
  if (input.charCodeAt(peg$currPos) === 65379) {
4026
- s8 = peg$c111;
4124
+ s8 = peg$c112;
4027
4125
  peg$currPos++;
4028
4126
  }
4029
4127
  else {
4030
4128
  s8 = peg$FAILED;
4031
4129
  if (peg$silentFails === 0) {
4032
- peg$fail(peg$c112);
4130
+ peg$fail(peg$c113);
4033
4131
  }
4034
4132
  }
4035
4133
  if (s8 !== peg$FAILED) {
4036
4134
  peg$savedPos = s5;
4037
- s6 = peg$c93(s3, s4, s7);
4135
+ s6 = peg$c94(s3, s4, s7);
4038
4136
  s5 = s6;
4039
4137
  }
4040
4138
  else {
@@ -4054,79 +4152,79 @@ function peg$parse(input, options) {
4054
4152
  if (s5 === peg$FAILED) {
4055
4153
  s5 = peg$currPos;
4056
4154
  if (input.charCodeAt(peg$currPos) === 60) {
4057
- s6 = peg$c61;
4155
+ s6 = peg$c62;
4058
4156
  peg$currPos++;
4059
4157
  }
4060
4158
  else {
4061
4159
  s6 = peg$FAILED;
4062
4160
  if (peg$silentFails === 0) {
4063
- peg$fail(peg$c62);
4161
+ peg$fail(peg$c63);
4064
4162
  }
4065
4163
  }
4066
4164
  if (s6 === peg$FAILED) {
4067
4165
  if (input.charCodeAt(peg$currPos) === 40) {
4068
- s6 = peg$c100;
4166
+ s6 = peg$c101;
4069
4167
  peg$currPos++;
4070
4168
  }
4071
4169
  else {
4072
4170
  s6 = peg$FAILED;
4073
4171
  if (peg$silentFails === 0) {
4074
- peg$fail(peg$c101);
4172
+ peg$fail(peg$c102);
4075
4173
  }
4076
4174
  }
4077
4175
  if (s6 === peg$FAILED) {
4078
4176
  if (input.charCodeAt(peg$currPos) === 123) {
4079
- s6 = peg$c76;
4177
+ s6 = peg$c77;
4080
4178
  peg$currPos++;
4081
4179
  }
4082
4180
  else {
4083
4181
  s6 = peg$FAILED;
4084
4182
  if (peg$silentFails === 0) {
4085
- peg$fail(peg$c77);
4183
+ peg$fail(peg$c78);
4086
4184
  }
4087
4185
  }
4088
4186
  if (s6 === peg$FAILED) {
4089
4187
  if (input.charCodeAt(peg$currPos) === 91) {
4090
- s6 = peg$c83;
4188
+ s6 = peg$c84;
4091
4189
  peg$currPos++;
4092
4190
  }
4093
4191
  else {
4094
4192
  s6 = peg$FAILED;
4095
4193
  if (peg$silentFails === 0) {
4096
- peg$fail(peg$c84);
4194
+ peg$fail(peg$c85);
4097
4195
  }
4098
4196
  }
4099
4197
  if (s6 === peg$FAILED) {
4100
- if (peg$c89.test(input.charAt(peg$currPos))) {
4198
+ if (peg$c90.test(input.charAt(peg$currPos))) {
4101
4199
  s6 = input.charAt(peg$currPos);
4102
4200
  peg$currPos++;
4103
4201
  }
4104
4202
  else {
4105
4203
  s6 = peg$FAILED;
4106
4204
  if (peg$silentFails === 0) {
4107
- peg$fail(peg$c90);
4205
+ peg$fail(peg$c91);
4108
4206
  }
4109
4207
  }
4110
4208
  if (s6 === peg$FAILED) {
4111
- if (peg$c94.test(input.charAt(peg$currPos))) {
4209
+ if (peg$c95.test(input.charAt(peg$currPos))) {
4112
4210
  s6 = input.charAt(peg$currPos);
4113
4211
  peg$currPos++;
4114
4212
  }
4115
4213
  else {
4116
4214
  s6 = peg$FAILED;
4117
4215
  if (peg$silentFails === 0) {
4118
- peg$fail(peg$c95);
4216
+ peg$fail(peg$c96);
4119
4217
  }
4120
4218
  }
4121
4219
  if (s6 === peg$FAILED) {
4122
4220
  if (input.charCodeAt(peg$currPos) === 65378) {
4123
- s6 = peg$c107;
4221
+ s6 = peg$c108;
4124
4222
  peg$currPos++;
4125
4223
  }
4126
4224
  else {
4127
4225
  s6 = peg$FAILED;
4128
4226
  if (peg$silentFails === 0) {
4129
- peg$fail(peg$c108);
4227
+ peg$fail(peg$c109);
4130
4228
  }
4131
4229
  }
4132
4230
  }
@@ -4221,7 +4319,7 @@ function peg$parse(input, options) {
4221
4319
  }
4222
4320
  if (s7 !== peg$FAILED) {
4223
4321
  peg$savedPos = s5;
4224
- s6 = peg$c113(s3, s4);
4322
+ s6 = peg$c114(s3, s4);
4225
4323
  s5 = s6;
4226
4324
  }
4227
4325
  else {
@@ -4238,7 +4336,7 @@ function peg$parse(input, options) {
4238
4336
  s6 = peg$parse_();
4239
4337
  if (s6 !== peg$FAILED) {
4240
4338
  peg$savedPos = s5;
4241
- s6 = peg$c114(s3, s4);
4339
+ s6 = peg$c115(s3, s4);
4242
4340
  }
4243
4341
  s5 = s6;
4244
4342
  }
@@ -4262,7 +4360,7 @@ function peg$parse(input, options) {
4262
4360
  s6 = peg$parse_();
4263
4361
  if (s6 !== peg$FAILED) {
4264
4362
  peg$savedPos = s0;
4265
- s1 = peg$c115(s3, s4, s5);
4363
+ s1 = peg$c116(s3, s4, s5);
4266
4364
  s0 = s1;
4267
4365
  }
4268
4366
  else {
@@ -4341,7 +4439,7 @@ function peg$parse(input, options) {
4341
4439
  s9 = peg$parsenewline();
4342
4440
  if (s9 !== peg$FAILED) {
4343
4441
  peg$savedPos = s4;
4344
- s5 = peg$c116(s1, s7);
4442
+ s5 = peg$c117(s1, s7);
4345
4443
  s4 = s5;
4346
4444
  }
4347
4445
  else {
@@ -4401,7 +4499,7 @@ function peg$parse(input, options) {
4401
4499
  s9 = peg$parsenewline();
4402
4500
  if (s9 !== peg$FAILED) {
4403
4501
  peg$savedPos = s4;
4404
- s5 = peg$c116(s1, s7);
4502
+ s5 = peg$c117(s1, s7);
4405
4503
  s4 = s5;
4406
4504
  }
4407
4505
  else {
@@ -4436,7 +4534,7 @@ function peg$parse(input, options) {
4436
4534
  }
4437
4535
  if (s4 !== peg$FAILED) {
4438
4536
  peg$savedPos = s0;
4439
- s1 = peg$c117(s1, s3, s4);
4537
+ s1 = peg$c118(s1, s3, s4);
4440
4538
  s0 = s1;
4441
4539
  }
4442
4540
  else {
@@ -4477,14 +4575,14 @@ function peg$parse(input, options) {
4477
4575
  }
4478
4576
  }
4479
4577
  if (s3 !== peg$FAILED) {
4480
- if (peg$c39.test(input.charAt(peg$currPos))) {
4578
+ if (peg$c40.test(input.charAt(peg$currPos))) {
4481
4579
  s4 = input.charAt(peg$currPos);
4482
4580
  peg$currPos++;
4483
4581
  }
4484
4582
  else {
4485
4583
  s4 = peg$FAILED;
4486
4584
  if (peg$silentFails === 0) {
4487
- peg$fail(peg$c40);
4585
+ peg$fail(peg$c41);
4488
4586
  }
4489
4587
  }
4490
4588
  if (s4 !== peg$FAILED) {
@@ -4510,7 +4608,7 @@ function peg$parse(input, options) {
4510
4608
  }
4511
4609
  if (s1 !== peg$FAILED) {
4512
4610
  peg$savedPos = s0;
4513
- s1 = peg$c118();
4611
+ s1 = peg$c119();
4514
4612
  }
4515
4613
  s0 = s1;
4516
4614
  return s0;
@@ -4520,27 +4618,27 @@ function peg$parse(input, options) {
4520
4618
  s0 = peg$currPos;
4521
4619
  s1 = peg$currPos;
4522
4620
  s2 = [];
4523
- if (peg$c119.test(input.charAt(peg$currPos))) {
4621
+ if (peg$c120.test(input.charAt(peg$currPos))) {
4524
4622
  s3 = input.charAt(peg$currPos);
4525
4623
  peg$currPos++;
4526
4624
  }
4527
4625
  else {
4528
4626
  s3 = peg$FAILED;
4529
4627
  if (peg$silentFails === 0) {
4530
- peg$fail(peg$c120);
4628
+ peg$fail(peg$c121);
4531
4629
  }
4532
4630
  }
4533
4631
  if (s3 !== peg$FAILED) {
4534
4632
  while (s3 !== peg$FAILED) {
4535
4633
  s2.push(s3);
4536
- if (peg$c119.test(input.charAt(peg$currPos))) {
4634
+ if (peg$c120.test(input.charAt(peg$currPos))) {
4537
4635
  s3 = input.charAt(peg$currPos);
4538
4636
  peg$currPos++;
4539
4637
  }
4540
4638
  else {
4541
4639
  s3 = peg$FAILED;
4542
4640
  if (peg$silentFails === 0) {
4543
- peg$fail(peg$c120);
4641
+ peg$fail(peg$c121);
4544
4642
  }
4545
4643
  }
4546
4644
  }
@@ -4556,7 +4654,7 @@ function peg$parse(input, options) {
4556
4654
  }
4557
4655
  if (s1 !== peg$FAILED) {
4558
4656
  peg$savedPos = s0;
4559
- s1 = peg$c121(s1);
4657
+ s1 = peg$c122(s1);
4560
4658
  }
4561
4659
  s0 = s1;
4562
4660
  return s0;
@@ -4565,27 +4663,27 @@ function peg$parse(input, options) {
4565
4663
  var s0, s1, s2;
4566
4664
  s0 = peg$currPos;
4567
4665
  s1 = [];
4568
- if (peg$c122.test(input.charAt(peg$currPos))) {
4666
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4569
4667
  s2 = input.charAt(peg$currPos);
4570
4668
  peg$currPos++;
4571
4669
  }
4572
4670
  else {
4573
4671
  s2 = peg$FAILED;
4574
4672
  if (peg$silentFails === 0) {
4575
- peg$fail(peg$c123);
4673
+ peg$fail(peg$c124);
4576
4674
  }
4577
4675
  }
4578
4676
  if (s2 !== peg$FAILED) {
4579
4677
  while (s2 !== peg$FAILED) {
4580
4678
  s1.push(s2);
4581
- if (peg$c122.test(input.charAt(peg$currPos))) {
4679
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4582
4680
  s2 = input.charAt(peg$currPos);
4583
4681
  peg$currPos++;
4584
4682
  }
4585
4683
  else {
4586
4684
  s2 = peg$FAILED;
4587
4685
  if (peg$silentFails === 0) {
4588
- peg$fail(peg$c123);
4686
+ peg$fail(peg$c124);
4589
4687
  }
4590
4688
  }
4591
4689
  }
@@ -4605,14 +4703,14 @@ function peg$parse(input, options) {
4605
4703
  var s0, s1, s2, s3, s4;
4606
4704
  s0 = peg$currPos;
4607
4705
  s1 = peg$currPos;
4608
- if (peg$c124.test(input.charAt(peg$currPos))) {
4706
+ if (peg$c125.test(input.charAt(peg$currPos))) {
4609
4707
  s2 = input.charAt(peg$currPos);
4610
4708
  peg$currPos++;
4611
4709
  }
4612
4710
  else {
4613
4711
  s2 = peg$FAILED;
4614
4712
  if (peg$silentFails === 0) {
4615
- peg$fail(peg$c125);
4713
+ peg$fail(peg$c126);
4616
4714
  }
4617
4715
  }
4618
4716
  if (s2 === peg$FAILED) {
@@ -4620,27 +4718,27 @@ function peg$parse(input, options) {
4620
4718
  }
4621
4719
  if (s2 !== peg$FAILED) {
4622
4720
  s3 = [];
4623
- if (peg$c122.test(input.charAt(peg$currPos))) {
4721
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4624
4722
  s4 = input.charAt(peg$currPos);
4625
4723
  peg$currPos++;
4626
4724
  }
4627
4725
  else {
4628
4726
  s4 = peg$FAILED;
4629
4727
  if (peg$silentFails === 0) {
4630
- peg$fail(peg$c123);
4728
+ peg$fail(peg$c124);
4631
4729
  }
4632
4730
  }
4633
4731
  if (s4 !== peg$FAILED) {
4634
4732
  while (s4 !== peg$FAILED) {
4635
4733
  s3.push(s4);
4636
- if (peg$c122.test(input.charAt(peg$currPos))) {
4734
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4637
4735
  s4 = input.charAt(peg$currPos);
4638
4736
  peg$currPos++;
4639
4737
  }
4640
4738
  else {
4641
4739
  s4 = peg$FAILED;
4642
4740
  if (peg$silentFails === 0) {
4643
- peg$fail(peg$c123);
4741
+ peg$fail(peg$c124);
4644
4742
  }
4645
4743
  }
4646
4744
  }
@@ -4672,36 +4770,36 @@ function peg$parse(input, options) {
4672
4770
  function peg$parseBoolean() {
4673
4771
  var s0, s1;
4674
4772
  s0 = peg$currPos;
4675
- if (input.substr(peg$currPos, 4) === peg$c126) {
4676
- s1 = peg$c126;
4773
+ if (input.substr(peg$currPos, 4) === peg$c127) {
4774
+ s1 = peg$c127;
4677
4775
  peg$currPos += 4;
4678
4776
  }
4679
4777
  else {
4680
4778
  s1 = peg$FAILED;
4681
4779
  if (peg$silentFails === 0) {
4682
- peg$fail(peg$c127);
4780
+ peg$fail(peg$c128);
4683
4781
  }
4684
4782
  }
4685
4783
  if (s1 !== peg$FAILED) {
4686
4784
  peg$savedPos = s0;
4687
- s1 = peg$c128();
4785
+ s1 = peg$c129();
4688
4786
  }
4689
4787
  s0 = s1;
4690
4788
  if (s0 === peg$FAILED) {
4691
4789
  s0 = peg$currPos;
4692
- if (input.substr(peg$currPos, 5) === peg$c129) {
4693
- s1 = peg$c129;
4790
+ if (input.substr(peg$currPos, 5) === peg$c130) {
4791
+ s1 = peg$c130;
4694
4792
  peg$currPos += 5;
4695
4793
  }
4696
4794
  else {
4697
4795
  s1 = peg$FAILED;
4698
4796
  if (peg$silentFails === 0) {
4699
- peg$fail(peg$c130);
4797
+ peg$fail(peg$c131);
4700
4798
  }
4701
4799
  }
4702
4800
  if (s1 !== peg$FAILED) {
4703
4801
  peg$savedPos = s0;
4704
- s1 = peg$c131();
4802
+ s1 = peg$c132();
4705
4803
  }
4706
4804
  s0 = s1;
4707
4805
  }
@@ -4715,13 +4813,13 @@ function peg$parse(input, options) {
4715
4813
  if (s2 !== peg$FAILED) {
4716
4814
  s3 = peg$currPos;
4717
4815
  if (input.charCodeAt(peg$currPos) === 46) {
4718
- s4 = peg$c132;
4816
+ s4 = peg$c133;
4719
4817
  peg$currPos++;
4720
4818
  }
4721
4819
  else {
4722
4820
  s4 = peg$FAILED;
4723
4821
  if (peg$silentFails === 0) {
4724
- peg$fail(peg$c133);
4822
+ peg$fail(peg$c134);
4725
4823
  }
4726
4824
  }
4727
4825
  if (s4 !== peg$FAILED) {
@@ -4743,14 +4841,14 @@ function peg$parse(input, options) {
4743
4841
  s3 = null;
4744
4842
  }
4745
4843
  if (s3 !== peg$FAILED) {
4746
- if (peg$c134.test(input.charAt(peg$currPos))) {
4844
+ if (peg$c135.test(input.charAt(peg$currPos))) {
4747
4845
  s4 = input.charAt(peg$currPos);
4748
4846
  peg$currPos++;
4749
4847
  }
4750
4848
  else {
4751
4849
  s4 = peg$FAILED;
4752
4850
  if (peg$silentFails === 0) {
4753
- peg$fail(peg$c135);
4851
+ peg$fail(peg$c136);
4754
4852
  }
4755
4853
  }
4756
4854
  if (s4 !== peg$FAILED) {
@@ -4790,13 +4888,13 @@ function peg$parse(input, options) {
4790
4888
  s2 = peg$parsenumber();
4791
4889
  if (s2 !== peg$FAILED) {
4792
4890
  if (input.charCodeAt(peg$currPos) === 46) {
4793
- s3 = peg$c132;
4891
+ s3 = peg$c133;
4794
4892
  peg$currPos++;
4795
4893
  }
4796
4894
  else {
4797
4895
  s3 = peg$FAILED;
4798
4896
  if (peg$silentFails === 0) {
4799
- peg$fail(peg$c133);
4897
+ peg$fail(peg$c134);
4800
4898
  }
4801
4899
  }
4802
4900
  if (s3 !== peg$FAILED) {
@@ -4831,39 +4929,39 @@ function peg$parse(input, options) {
4831
4929
  function peg$parseitem() {
4832
4930
  var s0, s1, s2, s3, s4;
4833
4931
  s0 = peg$currPos;
4834
- if (peg$c94.test(input.charAt(peg$currPos))) {
4932
+ if (peg$c95.test(input.charAt(peg$currPos))) {
4835
4933
  s1 = input.charAt(peg$currPos);
4836
4934
  peg$currPos++;
4837
4935
  }
4838
4936
  else {
4839
4937
  s1 = peg$FAILED;
4840
4938
  if (peg$silentFails === 0) {
4841
- peg$fail(peg$c95);
4939
+ peg$fail(peg$c96);
4842
4940
  }
4843
4941
  }
4844
4942
  if (s1 !== peg$FAILED) {
4845
4943
  s2 = peg$currPos;
4846
4944
  s3 = [];
4847
- if (peg$c96.test(input.charAt(peg$currPos))) {
4945
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4848
4946
  s4 = input.charAt(peg$currPos);
4849
4947
  peg$currPos++;
4850
4948
  }
4851
4949
  else {
4852
4950
  s4 = peg$FAILED;
4853
4951
  if (peg$silentFails === 0) {
4854
- peg$fail(peg$c97);
4952
+ peg$fail(peg$c98);
4855
4953
  }
4856
4954
  }
4857
4955
  while (s4 !== peg$FAILED) {
4858
4956
  s3.push(s4);
4859
- if (peg$c96.test(input.charAt(peg$currPos))) {
4957
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4860
4958
  s4 = input.charAt(peg$currPos);
4861
4959
  peg$currPos++;
4862
4960
  }
4863
4961
  else {
4864
4962
  s4 = peg$FAILED;
4865
4963
  if (peg$silentFails === 0) {
4866
- peg$fail(peg$c97);
4964
+ peg$fail(peg$c98);
4867
4965
  }
4868
4966
  }
4869
4967
  }
@@ -4874,19 +4972,19 @@ function peg$parse(input, options) {
4874
4972
  s2 = s3;
4875
4973
  }
4876
4974
  if (s2 !== peg$FAILED) {
4877
- if (peg$c94.test(input.charAt(peg$currPos))) {
4975
+ if (peg$c95.test(input.charAt(peg$currPos))) {
4878
4976
  s3 = input.charAt(peg$currPos);
4879
4977
  peg$currPos++;
4880
4978
  }
4881
4979
  else {
4882
4980
  s3 = peg$FAILED;
4883
4981
  if (peg$silentFails === 0) {
4884
- peg$fail(peg$c95);
4982
+ peg$fail(peg$c96);
4885
4983
  }
4886
4984
  }
4887
4985
  if (s3 !== peg$FAILED) {
4888
4986
  peg$savedPos = s0;
4889
- s1 = peg$c121(s2);
4987
+ s1 = peg$c122(s2);
4890
4988
  s0 = s1;
4891
4989
  }
4892
4990
  else {
@@ -4905,39 +5003,39 @@ function peg$parse(input, options) {
4905
5003
  }
4906
5004
  if (s0 === peg$FAILED) {
4907
5005
  s0 = peg$currPos;
4908
- if (peg$c89.test(input.charAt(peg$currPos))) {
5006
+ if (peg$c90.test(input.charAt(peg$currPos))) {
4909
5007
  s1 = input.charAt(peg$currPos);
4910
5008
  peg$currPos++;
4911
5009
  }
4912
5010
  else {
4913
5011
  s1 = peg$FAILED;
4914
5012
  if (peg$silentFails === 0) {
4915
- peg$fail(peg$c90);
5013
+ peg$fail(peg$c91);
4916
5014
  }
4917
5015
  }
4918
5016
  if (s1 !== peg$FAILED) {
4919
5017
  s2 = peg$currPos;
4920
5018
  s3 = [];
4921
- if (peg$c91.test(input.charAt(peg$currPos))) {
5019
+ if (peg$c92.test(input.charAt(peg$currPos))) {
4922
5020
  s4 = input.charAt(peg$currPos);
4923
5021
  peg$currPos++;
4924
5022
  }
4925
5023
  else {
4926
5024
  s4 = peg$FAILED;
4927
5025
  if (peg$silentFails === 0) {
4928
- peg$fail(peg$c92);
5026
+ peg$fail(peg$c93);
4929
5027
  }
4930
5028
  }
4931
5029
  while (s4 !== peg$FAILED) {
4932
5030
  s3.push(s4);
4933
- if (peg$c91.test(input.charAt(peg$currPos))) {
5031
+ if (peg$c92.test(input.charAt(peg$currPos))) {
4934
5032
  s4 = input.charAt(peg$currPos);
4935
5033
  peg$currPos++;
4936
5034
  }
4937
5035
  else {
4938
5036
  s4 = peg$FAILED;
4939
5037
  if (peg$silentFails === 0) {
4940
- peg$fail(peg$c92);
5038
+ peg$fail(peg$c93);
4941
5039
  }
4942
5040
  }
4943
5041
  }
@@ -4948,19 +5046,19 @@ function peg$parse(input, options) {
4948
5046
  s2 = s3;
4949
5047
  }
4950
5048
  if (s2 !== peg$FAILED) {
4951
- if (peg$c89.test(input.charAt(peg$currPos))) {
5049
+ if (peg$c90.test(input.charAt(peg$currPos))) {
4952
5050
  s3 = input.charAt(peg$currPos);
4953
5051
  peg$currPos++;
4954
5052
  }
4955
5053
  else {
4956
5054
  s3 = peg$FAILED;
4957
5055
  if (peg$silentFails === 0) {
4958
- peg$fail(peg$c90);
5056
+ peg$fail(peg$c91);
4959
5057
  }
4960
5058
  }
4961
5059
  if (s3 !== peg$FAILED) {
4962
5060
  peg$savedPos = s0;
4963
- s1 = peg$c121(s2);
5061
+ s1 = peg$c122(s2);
4964
5062
  s0 = s1;
4965
5063
  }
4966
5064
  else {
@@ -4984,7 +5082,7 @@ function peg$parse(input, options) {
4984
5082
  s1 = peg$parsefloatNumber();
4985
5083
  if (s1 !== peg$FAILED) {
4986
5084
  peg$savedPos = s0;
4987
- s1 = peg$c136(s1);
5085
+ s1 = peg$c137(s1);
4988
5086
  }
4989
5087
  s0 = s1;
4990
5088
  if (s0 === peg$FAILED) {
@@ -4992,7 +5090,7 @@ function peg$parse(input, options) {
4992
5090
  s1 = peg$parsenumber();
4993
5091
  if (s1 !== peg$FAILED) {
4994
5092
  peg$savedPos = s0;
4995
- s1 = peg$c137(s1);
5093
+ s1 = peg$c138(s1);
4996
5094
  }
4997
5095
  s0 = s1;
4998
5096
  }
@@ -5022,7 +5120,7 @@ function peg$parse(input, options) {
5022
5120
  s5 = peg$parsepod_configuration();
5023
5121
  if (s5 !== peg$FAILED) {
5024
5122
  peg$savedPos = peg$currPos;
5025
- s6 = peg$c138(s1, s3, s5);
5123
+ s6 = peg$c139(s1, s3, s5);
5026
5124
  if (s6) {
5027
5125
  s6 = void 0;
5028
5126
  }
@@ -5065,7 +5163,7 @@ function peg$parse(input, options) {
5065
5163
  s15 = peg$parsestrictIdentifier();
5066
5164
  if (s15 !== peg$FAILED) {
5067
5165
  peg$savedPos = peg$currPos;
5068
- s16 = peg$c139(s1, s3, s5, s9, s15);
5166
+ s16 = peg$c140(s1, s3, s5, s9, s15);
5069
5167
  if (s16) {
5070
5168
  s16 = void 0;
5071
5169
  }
@@ -5133,7 +5231,7 @@ function peg$parse(input, options) {
5133
5231
  }
5134
5232
  if (s10 !== peg$FAILED) {
5135
5233
  peg$savedPos = s8;
5136
- s9 = peg$c140(s1, s3, s5, s9, s10);
5234
+ s9 = peg$c141(s1, s3, s5, s9, s10);
5137
5235
  s8 = s9;
5138
5236
  }
5139
5237
  else {
@@ -5182,7 +5280,7 @@ function peg$parse(input, options) {
5182
5280
  s15 = peg$parsestrictIdentifier();
5183
5281
  if (s15 !== peg$FAILED) {
5184
5282
  peg$savedPos = peg$currPos;
5185
- s16 = peg$c139(s1, s3, s5, s9, s15);
5283
+ s16 = peg$c140(s1, s3, s5, s9, s15);
5186
5284
  if (s16) {
5187
5285
  s16 = void 0;
5188
5286
  }
@@ -5250,7 +5348,7 @@ function peg$parse(input, options) {
5250
5348
  }
5251
5349
  if (s10 !== peg$FAILED) {
5252
5350
  peg$savedPos = s8;
5253
- s9 = peg$c140(s1, s3, s5, s9, s10);
5351
+ s9 = peg$c141(s1, s3, s5, s9, s10);
5254
5352
  s8 = s9;
5255
5353
  }
5256
5354
  else {
@@ -5283,7 +5381,7 @@ function peg$parse(input, options) {
5283
5381
  s11 = peg$parsestrictIdentifier();
5284
5382
  if (s11 !== peg$FAILED) {
5285
5383
  peg$savedPos = peg$currPos;
5286
- s12 = peg$c141(s1, s3, s5, s7, s8, s11);
5384
+ s12 = peg$c142(s1, s3, s5, s7, s8, s11);
5287
5385
  if (s12) {
5288
5386
  s12 = void 0;
5289
5387
  }
@@ -5297,7 +5395,7 @@ function peg$parse(input, options) {
5297
5395
  }
5298
5396
  if (s13 !== peg$FAILED) {
5299
5397
  peg$savedPos = s9;
5300
- s10 = peg$c142(s1, s3, s5, s7, s8, s11);
5398
+ s10 = peg$c143(s1, s3, s5, s7, s8, s11);
5301
5399
  s9 = s10;
5302
5400
  }
5303
5401
  else {
@@ -5321,7 +5419,7 @@ function peg$parse(input, options) {
5321
5419
  }
5322
5420
  if (s9 !== peg$FAILED) {
5323
5421
  peg$savedPos = peg$currPos;
5324
- s10 = peg$c143(s1, s3, s5, s7, s8, s9);
5422
+ s10 = peg$c144(s1, s3, s5, s7, s8, s9);
5325
5423
  if (s10) {
5326
5424
  s10 = void 0;
5327
5425
  }
@@ -5330,7 +5428,7 @@ function peg$parse(input, options) {
5330
5428
  }
5331
5429
  if (s10 !== peg$FAILED) {
5332
5430
  peg$savedPos = s0;
5333
- s1 = peg$c144(s1, s3, s5, s7, s8, s9);
5431
+ s1 = peg$c145(s1, s3, s5, s7, s8, s9);
5334
5432
  s0 = s1;
5335
5433
  }
5336
5434
  else {
@@ -5431,14 +5529,14 @@ function peg$parse(input, options) {
5431
5529
  s3 = peg$currPos;
5432
5530
  s4 = [];
5433
5531
  s5 = peg$currPos;
5434
- if (peg$c145.test(input.charAt(peg$currPos))) {
5532
+ if (peg$c146.test(input.charAt(peg$currPos))) {
5435
5533
  s6 = input.charAt(peg$currPos);
5436
5534
  peg$currPos++;
5437
5535
  }
5438
5536
  else {
5439
5537
  s6 = peg$FAILED;
5440
5538
  if (peg$silentFails === 0) {
5441
- peg$fail(peg$c146);
5539
+ peg$fail(peg$c147);
5442
5540
  }
5443
5541
  }
5444
5542
  if (s6 !== peg$FAILED) {
@@ -5465,14 +5563,14 @@ function peg$parse(input, options) {
5465
5563
  while (s5 !== peg$FAILED) {
5466
5564
  s4.push(s5);
5467
5565
  s5 = peg$currPos;
5468
- if (peg$c145.test(input.charAt(peg$currPos))) {
5566
+ if (peg$c146.test(input.charAt(peg$currPos))) {
5469
5567
  s6 = input.charAt(peg$currPos);
5470
5568
  peg$currPos++;
5471
5569
  }
5472
5570
  else {
5473
5571
  s6 = peg$FAILED;
5474
5572
  if (peg$silentFails === 0) {
5475
- peg$fail(peg$c146);
5573
+ peg$fail(peg$c147);
5476
5574
  }
5477
5575
  }
5478
5576
  if (s6 !== peg$FAILED) {
@@ -5510,7 +5608,7 @@ function peg$parse(input, options) {
5510
5608
  s4 = peg$parseEOL();
5511
5609
  if (s4 !== peg$FAILED) {
5512
5610
  peg$savedPos = s0;
5513
- s1 = peg$c147();
5611
+ s1 = peg$c148();
5514
5612
  s0 = s1;
5515
5613
  }
5516
5614
  else {
@@ -5542,7 +5640,7 @@ function peg$parse(input, options) {
5542
5640
  if (s2 === peg$FAILED) {
5543
5641
  s2 = peg$currPos;
5544
5642
  peg$savedPos = peg$currPos;
5545
- s3 = peg$c148();
5643
+ s3 = peg$c149();
5546
5644
  if (s3) {
5547
5645
  s3 = void 0;
5548
5646
  }
@@ -5573,7 +5671,7 @@ function peg$parse(input, options) {
5573
5671
  }
5574
5672
  if (s1 !== peg$FAILED) {
5575
5673
  peg$savedPos = s0;
5576
- s1 = peg$c149();
5674
+ s1 = peg$c150();
5577
5675
  }
5578
5676
  s0 = s1;
5579
5677
  return s0;
@@ -5581,10 +5679,10 @@ function peg$parse(input, options) {
5581
5679
  function peg$parsetableRow() {
5582
5680
  var s0, s1;
5583
5681
  s0 = peg$currPos;
5584
- s1 = peg$parsetext_content();
5682
+ s1 = peg$parseplain_line();
5585
5683
  if (s1 !== peg$FAILED) {
5586
5684
  peg$savedPos = s0;
5587
- s1 = peg$c150(s1);
5685
+ s1 = peg$c151(s1);
5588
5686
  }
5589
5687
  s0 = s1;
5590
5688
  return s0;
@@ -5593,7 +5691,7 @@ function peg$parse(input, options) {
5593
5691
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
5594
5692
  s0 = peg$currPos;
5595
5693
  peg$savedPos = peg$currPos;
5596
- s1 = peg$c151();
5694
+ s1 = peg$c152();
5597
5695
  if (s1) {
5598
5696
  s1 = void 0;
5599
5697
  }
@@ -5676,7 +5774,7 @@ function peg$parse(input, options) {
5676
5774
  s4 = peg$parsetableHeadSeparator();
5677
5775
  if (s4 !== peg$FAILED) {
5678
5776
  peg$savedPos = s3;
5679
- s4 = peg$c152(s2, s4);
5777
+ s4 = peg$c153(s2, s4);
5680
5778
  }
5681
5779
  s3 = s4;
5682
5780
  if (s3 !== peg$FAILED) {
@@ -5757,12 +5855,12 @@ function peg$parse(input, options) {
5757
5855
  s8 = peg$parsetableBodyRowSeparator();
5758
5856
  if (s8 !== peg$FAILED) {
5759
5857
  peg$savedPos = s7;
5760
- s8 = peg$c153(s2, s3, s6, s8);
5858
+ s8 = peg$c154(s2, s3, s6, s8);
5761
5859
  }
5762
5860
  s7 = s8;
5763
5861
  if (s7 !== peg$FAILED) {
5764
5862
  peg$savedPos = s5;
5765
- s6 = peg$c154(s2, s3, s6, s7);
5863
+ s6 = peg$c155(s2, s3, s6, s7);
5766
5864
  s5 = s6;
5767
5865
  }
5768
5866
  else {
@@ -5803,7 +5901,7 @@ function peg$parse(input, options) {
5803
5901
  s8 = peg$parsetableRow();
5804
5902
  if (s8 !== peg$FAILED) {
5805
5903
  peg$savedPos = s5;
5806
- s6 = peg$c155(s2, s3, s8);
5904
+ s6 = peg$c156(s2, s3, s8);
5807
5905
  s5 = s6;
5808
5906
  }
5809
5907
  else {
@@ -5900,12 +5998,12 @@ function peg$parse(input, options) {
5900
5998
  s8 = peg$parsetableBodyRowSeparator();
5901
5999
  if (s8 !== peg$FAILED) {
5902
6000
  peg$savedPos = s7;
5903
- s8 = peg$c153(s2, s3, s6, s8);
6001
+ s8 = peg$c154(s2, s3, s6, s8);
5904
6002
  }
5905
6003
  s7 = s8;
5906
6004
  if (s7 !== peg$FAILED) {
5907
6005
  peg$savedPos = s5;
5908
- s6 = peg$c154(s2, s3, s6, s7);
6006
+ s6 = peg$c155(s2, s3, s6, s7);
5909
6007
  s5 = s6;
5910
6008
  }
5911
6009
  else {
@@ -5946,7 +6044,7 @@ function peg$parse(input, options) {
5946
6044
  s8 = peg$parsetableRow();
5947
6045
  if (s8 !== peg$FAILED) {
5948
6046
  peg$savedPos = s5;
5949
- s6 = peg$c155(s2, s3, s8);
6047
+ s6 = peg$c156(s2, s3, s8);
5950
6048
  s5 = s6;
5951
6049
  }
5952
6050
  else {
@@ -5971,7 +6069,7 @@ function peg$parse(input, options) {
5971
6069
  }
5972
6070
  if (s4 !== peg$FAILED) {
5973
6071
  peg$savedPos = peg$currPos;
5974
- s5 = peg$c156(s2, s3, s4);
6072
+ s5 = peg$c157(s2, s3, s4);
5975
6073
  if (s5) {
5976
6074
  s5 = void 0;
5977
6075
  }
@@ -5980,7 +6078,7 @@ function peg$parse(input, options) {
5980
6078
  }
5981
6079
  if (s5 !== peg$FAILED) {
5982
6080
  peg$savedPos = s0;
5983
- s1 = peg$c157(s2, s3, s4);
6081
+ s1 = peg$c158(s2, s3, s4);
5984
6082
  s0 = s1;
5985
6083
  }
5986
6084
  else {
@@ -6054,7 +6152,7 @@ function peg$parse(input, options) {
6054
6152
  }
6055
6153
  if (s4 !== peg$FAILED) {
6056
6154
  peg$savedPos = s2;
6057
- s3 = peg$c158(s3, s4);
6155
+ s3 = peg$c159(s3, s4);
6058
6156
  s2 = s3;
6059
6157
  }
6060
6158
  else {
@@ -6113,7 +6211,7 @@ function peg$parse(input, options) {
6113
6211
  }
6114
6212
  if (s4 !== peg$FAILED) {
6115
6213
  peg$savedPos = s2;
6116
- s3 = peg$c158(s3, s4);
6214
+ s3 = peg$c159(s3, s4);
6117
6215
  s2 = s3;
6118
6216
  }
6119
6217
  else {
@@ -6132,7 +6230,7 @@ function peg$parse(input, options) {
6132
6230
  }
6133
6231
  if (s1 !== peg$FAILED) {
6134
6232
  peg$savedPos = s0;
6135
- s1 = peg$c159(s1);
6233
+ s1 = peg$c160(s1);
6136
6234
  }
6137
6235
  s0 = s1;
6138
6236
  if (s0 === peg$FAILED) {
@@ -6172,7 +6270,7 @@ function peg$parse(input, options) {
6172
6270
  s5 = peg$parsepod_configuration();
6173
6271
  if (s5 !== peg$FAILED) {
6174
6272
  peg$savedPos = peg$currPos;
6175
- s6 = peg$c160(s1, s3, s5);
6273
+ s6 = peg$c161(s1, s3, s5);
6176
6274
  if (s6) {
6177
6275
  s6 = void 0;
6178
6276
  }
@@ -6181,7 +6279,7 @@ function peg$parse(input, options) {
6181
6279
  }
6182
6280
  if (s6 !== peg$FAILED) {
6183
6281
  peg$savedPos = peg$currPos;
6184
- s7 = peg$c161(s1, s3, s5);
6282
+ s7 = peg$c162(s1, s3, s5);
6185
6283
  if (s7) {
6186
6284
  s7 = void 0;
6187
6285
  }
@@ -6234,12 +6332,12 @@ function peg$parse(input, options) {
6234
6332
  }
6235
6333
  if (s9 !== peg$FAILED) {
6236
6334
  peg$savedPos = s8;
6237
- s9 = peg$c162(s1, s3, s5, s9);
6335
+ s9 = peg$c163(s1, s3, s5, s9);
6238
6336
  }
6239
6337
  s8 = s9;
6240
6338
  if (s8 !== peg$FAILED) {
6241
6339
  peg$savedPos = peg$currPos;
6242
- s9 = peg$c163(s1, s3, s5, s8);
6340
+ s9 = peg$c164(s1, s3, s5, s8);
6243
6341
  if (s9) {
6244
6342
  s9 = void 0;
6245
6343
  }
@@ -6262,7 +6360,7 @@ function peg$parse(input, options) {
6262
6360
  s13 = peg$parsestrictIdentifier();
6263
6361
  if (s13 !== peg$FAILED) {
6264
6362
  peg$savedPos = peg$currPos;
6265
- s14 = peg$c141(s1, s3, s5, s8, s10, s13);
6363
+ s14 = peg$c142(s1, s3, s5, s8, s10, s13);
6266
6364
  if (s14) {
6267
6365
  s14 = void 0;
6268
6366
  }
@@ -6276,7 +6374,7 @@ function peg$parse(input, options) {
6276
6374
  }
6277
6375
  if (s15 !== peg$FAILED) {
6278
6376
  peg$savedPos = s11;
6279
- s12 = peg$c164(s1, s3, s5, s8, s10, s13);
6377
+ s12 = peg$c165(s1, s3, s5, s8, s10, s13);
6280
6378
  s11 = s12;
6281
6379
  }
6282
6380
  else {
@@ -6300,7 +6398,7 @@ function peg$parse(input, options) {
6300
6398
  }
6301
6399
  if (s11 !== peg$FAILED) {
6302
6400
  peg$savedPos = s0;
6303
- s1 = peg$c165(s1, s3, s5, s8, s10, s11);
6401
+ s1 = peg$c166(s1, s3, s5, s8, s10, s11);
6304
6402
  s0 = s1;
6305
6403
  }
6306
6404
  else {
@@ -6380,7 +6478,7 @@ function peg$parse(input, options) {
6380
6478
  s5 = peg$parsepod_configuration();
6381
6479
  if (s5 !== peg$FAILED) {
6382
6480
  peg$savedPos = peg$currPos;
6383
- s6 = peg$c160(s1, s3, s5);
6481
+ s6 = peg$c161(s1, s3, s5);
6384
6482
  if (s6) {
6385
6483
  s6 = void 0;
6386
6484
  }
@@ -6389,7 +6487,7 @@ function peg$parse(input, options) {
6389
6487
  }
6390
6488
  if (s6 !== peg$FAILED) {
6391
6489
  peg$savedPos = peg$currPos;
6392
- s7 = peg$c166(s1, s3, s5);
6490
+ s7 = peg$c167(s1, s3, s5);
6393
6491
  if (s7) {
6394
6492
  s7 = void 0;
6395
6493
  }
@@ -6415,7 +6513,7 @@ function peg$parse(input, options) {
6415
6513
  }
6416
6514
  if (s11 !== peg$FAILED) {
6417
6515
  peg$savedPos = s8;
6418
- s9 = peg$c167(s1, s3, s5, s10);
6516
+ s9 = peg$c168(s1, s3, s5, s10);
6419
6517
  s8 = s9;
6420
6518
  }
6421
6519
  else {
@@ -6448,7 +6546,7 @@ function peg$parse(input, options) {
6448
6546
  s12 = peg$parsestrictIdentifier();
6449
6547
  if (s12 !== peg$FAILED) {
6450
6548
  peg$savedPos = peg$currPos;
6451
- s13 = peg$c141(s1, s3, s5, s8, s9, s12);
6549
+ s13 = peg$c142(s1, s3, s5, s8, s9, s12);
6452
6550
  if (s13) {
6453
6551
  s13 = void 0;
6454
6552
  }
@@ -6462,7 +6560,7 @@ function peg$parse(input, options) {
6462
6560
  }
6463
6561
  if (s14 !== peg$FAILED) {
6464
6562
  peg$savedPos = s10;
6465
- s11 = peg$c168(s1, s3, s5, s8, s9, s12);
6563
+ s11 = peg$c169(s1, s3, s5, s8, s9, s12);
6466
6564
  s10 = s11;
6467
6565
  }
6468
6566
  else {
@@ -6486,7 +6584,7 @@ function peg$parse(input, options) {
6486
6584
  }
6487
6585
  if (s10 !== peg$FAILED) {
6488
6586
  peg$savedPos = peg$currPos;
6489
- s11 = peg$c143(s1, s3, s5, s8, s9, s10);
6587
+ s11 = peg$c144(s1, s3, s5, s8, s9, s10);
6490
6588
  if (s11) {
6491
6589
  s11 = void 0;
6492
6590
  }
@@ -6495,7 +6593,7 @@ function peg$parse(input, options) {
6495
6593
  }
6496
6594
  if (s11 !== peg$FAILED) {
6497
6595
  peg$savedPos = s0;
6498
- s1 = peg$c169(s1, s3, s5, s8, s9, s10);
6596
+ s1 = peg$c170(s1, s3, s5, s8, s9, s10);
6499
6597
  s0 = s1;
6500
6598
  }
6501
6599
  else {
@@ -6618,7 +6716,7 @@ function peg$parse(input, options) {
6618
6716
  }
6619
6717
  if (s8 !== peg$FAILED) {
6620
6718
  peg$savedPos = s7;
6621
- s8 = peg$c170(s1, s3, s5, s8);
6719
+ s8 = peg$c171(s1, s3, s5, s8);
6622
6720
  }
6623
6721
  s7 = s8;
6624
6722
  if (s7 === peg$FAILED) {
@@ -6657,7 +6755,7 @@ function peg$parse(input, options) {
6657
6755
  }
6658
6756
  if (s9 !== peg$FAILED) {
6659
6757
  peg$savedPos = s7;
6660
- s8 = peg$c171(s1, s3, s5, s8, s9);
6758
+ s8 = peg$c172(s1, s3, s5, s8, s9);
6661
6759
  s7 = s8;
6662
6760
  }
6663
6761
  else {
@@ -6715,7 +6813,7 @@ function peg$parse(input, options) {
6715
6813
  }
6716
6814
  if (s8 !== peg$FAILED) {
6717
6815
  peg$savedPos = s7;
6718
- s8 = peg$c170(s1, s3, s5, s8);
6816
+ s8 = peg$c171(s1, s3, s5, s8);
6719
6817
  }
6720
6818
  s7 = s8;
6721
6819
  if (s7 === peg$FAILED) {
@@ -6754,7 +6852,7 @@ function peg$parse(input, options) {
6754
6852
  }
6755
6853
  if (s9 !== peg$FAILED) {
6756
6854
  peg$savedPos = s7;
6757
- s8 = peg$c171(s1, s3, s5, s8, s9);
6855
+ s8 = peg$c172(s1, s3, s5, s8, s9);
6758
6856
  s7 = s8;
6759
6857
  }
6760
6858
  else {
@@ -6784,7 +6882,7 @@ function peg$parse(input, options) {
6784
6882
  s10 = peg$parsestrictIdentifier();
6785
6883
  if (s10 !== peg$FAILED) {
6786
6884
  peg$savedPos = peg$currPos;
6787
- s11 = peg$c141(s1, s3, s5, s6, s7, s10);
6885
+ s11 = peg$c142(s1, s3, s5, s6, s7, s10);
6788
6886
  if (s11) {
6789
6887
  s11 = void 0;
6790
6888
  }
@@ -6798,7 +6896,7 @@ function peg$parse(input, options) {
6798
6896
  }
6799
6897
  if (s12 !== peg$FAILED) {
6800
6898
  peg$savedPos = s8;
6801
- s9 = peg$c172(s1, s3, s5, s6, s7, s10);
6899
+ s9 = peg$c173(s1, s3, s5, s6, s7, s10);
6802
6900
  s8 = s9;
6803
6901
  }
6804
6902
  else {
@@ -6822,7 +6920,7 @@ function peg$parse(input, options) {
6822
6920
  }
6823
6921
  if (s8 !== peg$FAILED) {
6824
6922
  peg$savedPos = peg$currPos;
6825
- s9 = peg$c143(s1, s3, s5, s6, s7, s8);
6923
+ s9 = peg$c144(s1, s3, s5, s6, s7, s8);
6826
6924
  if (s9) {
6827
6925
  s9 = void 0;
6828
6926
  }
@@ -6831,7 +6929,7 @@ function peg$parse(input, options) {
6831
6929
  }
6832
6930
  if (s9 !== peg$FAILED) {
6833
6931
  peg$savedPos = s0;
6834
- s1 = peg$c173(s1, s3, s5, s6, s7, s8);
6932
+ s1 = peg$c174(s1, s3, s5, s6, s7, s8);
6835
6933
  s0 = s1;
6836
6934
  }
6837
6935
  else {
@@ -6896,7 +6994,7 @@ function peg$parse(input, options) {
6896
6994
  }
6897
6995
  if (s1 !== peg$FAILED) {
6898
6996
  peg$savedPos = s0;
6899
- s1 = peg$c174();
6997
+ s1 = peg$c175();
6900
6998
  }
6901
6999
  s0 = s1;
6902
7000
  return s0;
@@ -6909,32 +7007,32 @@ function peg$parse(input, options) {
6909
7007
  s3 = peg$parseemptyline();
6910
7008
  if (s3 !== peg$FAILED) {
6911
7009
  peg$savedPos = s2;
6912
- s3 = peg$c175();
7010
+ s3 = peg$c176();
6913
7011
  }
6914
7012
  s2 = s3;
6915
7013
  if (s2 === peg$FAILED) {
6916
7014
  s2 = [];
6917
- if (peg$c176.test(input.charAt(peg$currPos))) {
7015
+ if (peg$c177.test(input.charAt(peg$currPos))) {
6918
7016
  s3 = input.charAt(peg$currPos);
6919
7017
  peg$currPos++;
6920
7018
  }
6921
7019
  else {
6922
7020
  s3 = peg$FAILED;
6923
7021
  if (peg$silentFails === 0) {
6924
- peg$fail(peg$c177);
7022
+ peg$fail(peg$c178);
6925
7023
  }
6926
7024
  }
6927
7025
  if (s3 !== peg$FAILED) {
6928
7026
  while (s3 !== peg$FAILED) {
6929
7027
  s2.push(s3);
6930
- if (peg$c176.test(input.charAt(peg$currPos))) {
7028
+ if (peg$c177.test(input.charAt(peg$currPos))) {
6931
7029
  s3 = input.charAt(peg$currPos);
6932
7030
  peg$currPos++;
6933
7031
  }
6934
7032
  else {
6935
7033
  s3 = peg$FAILED;
6936
7034
  if (peg$silentFails === 0) {
6937
- peg$fail(peg$c177);
7035
+ peg$fail(peg$c178);
6938
7036
  }
6939
7037
  }
6940
7038
  }
@@ -6953,32 +7051,32 @@ function peg$parse(input, options) {
6953
7051
  s3 = peg$parseemptyline();
6954
7052
  if (s3 !== peg$FAILED) {
6955
7053
  peg$savedPos = s2;
6956
- s3 = peg$c175();
7054
+ s3 = peg$c176();
6957
7055
  }
6958
7056
  s2 = s3;
6959
7057
  if (s2 === peg$FAILED) {
6960
7058
  s2 = [];
6961
- if (peg$c176.test(input.charAt(peg$currPos))) {
7059
+ if (peg$c177.test(input.charAt(peg$currPos))) {
6962
7060
  s3 = input.charAt(peg$currPos);
6963
7061
  peg$currPos++;
6964
7062
  }
6965
7063
  else {
6966
7064
  s3 = peg$FAILED;
6967
7065
  if (peg$silentFails === 0) {
6968
- peg$fail(peg$c177);
7066
+ peg$fail(peg$c178);
6969
7067
  }
6970
7068
  }
6971
7069
  if (s3 !== peg$FAILED) {
6972
7070
  while (s3 !== peg$FAILED) {
6973
7071
  s2.push(s3);
6974
- if (peg$c176.test(input.charAt(peg$currPos))) {
7072
+ if (peg$c177.test(input.charAt(peg$currPos))) {
6975
7073
  s3 = input.charAt(peg$currPos);
6976
7074
  peg$currPos++;
6977
7075
  }
6978
7076
  else {
6979
7077
  s3 = peg$FAILED;
6980
7078
  if (peg$silentFails === 0) {
6981
- peg$fail(peg$c177);
7079
+ peg$fail(peg$c178);
6982
7080
  }
6983
7081
  }
6984
7082
  }
@@ -6997,7 +7095,7 @@ function peg$parse(input, options) {
6997
7095
  }
6998
7096
  if (s1 !== peg$FAILED) {
6999
7097
  peg$savedPos = s0;
7000
- s1 = peg$c178(s1);
7098
+ s1 = peg$c179(s1);
7001
7099
  }
7002
7100
  s0 = s1;
7003
7101
  return s0;
@@ -7036,7 +7134,7 @@ function peg$parse(input, options) {
7036
7134
  }
7037
7135
  if (s5 !== peg$FAILED) {
7038
7136
  peg$savedPos = peg$currPos;
7039
- s6 = peg$c179(s1, s3);
7137
+ s6 = peg$c180(s1, s3);
7040
7138
  if (s6) {
7041
7139
  s6 = void 0;
7042
7140
  }
@@ -7059,7 +7157,7 @@ function peg$parse(input, options) {
7059
7157
  s10 = peg$FAILED;
7060
7158
  }
7061
7159
  if (s10 !== peg$FAILED) {
7062
- s11 = peg$parsetext_content();
7160
+ s11 = peg$parseplain_line();
7063
7161
  if (s11 !== peg$FAILED) {
7064
7162
  s10 = [s10, s11];
7065
7163
  s9 = s10;
@@ -7088,7 +7186,7 @@ function peg$parse(input, options) {
7088
7186
  s10 = peg$FAILED;
7089
7187
  }
7090
7188
  if (s10 !== peg$FAILED) {
7091
- s11 = peg$parsetext_content();
7189
+ s11 = peg$parseplain_line();
7092
7190
  if (s11 !== peg$FAILED) {
7093
7191
  s10 = [s10, s11];
7094
7192
  s9 = s10;
@@ -7111,7 +7209,7 @@ function peg$parse(input, options) {
7111
7209
  }
7112
7210
  if (s7 !== peg$FAILED) {
7113
7211
  peg$savedPos = s0;
7114
- s1 = peg$c180(s1, s3, s7);
7212
+ s1 = peg$c181(s1, s3, s7);
7115
7213
  s0 = s1;
7116
7214
  }
7117
7215
  else {
@@ -7184,7 +7282,7 @@ function peg$parse(input, options) {
7184
7282
  }
7185
7283
  if (s5 !== peg$FAILED) {
7186
7284
  peg$savedPos = peg$currPos;
7187
- s6 = peg$c181(s1, s3);
7285
+ s6 = peg$c182(s1, s3);
7188
7286
  if (s6) {
7189
7287
  s6 = void 0;
7190
7288
  }
@@ -7193,7 +7291,7 @@ function peg$parse(input, options) {
7193
7291
  }
7194
7292
  if (s6 !== peg$FAILED) {
7195
7293
  peg$savedPos = peg$currPos;
7196
- s7 = peg$c182(s1, s3);
7294
+ s7 = peg$c183(s1, s3);
7197
7295
  if (s7) {
7198
7296
  s7 = void 0;
7199
7297
  }
@@ -7204,7 +7302,7 @@ function peg$parse(input, options) {
7204
7302
  s8 = peg$parsetableContents();
7205
7303
  if (s8 !== peg$FAILED) {
7206
7304
  peg$savedPos = s0;
7207
- s1 = peg$c183(s1, s3, s8);
7305
+ s1 = peg$c184(s1, s3, s8);
7208
7306
  s0 = s1;
7209
7307
  }
7210
7308
  else {
@@ -7348,7 +7446,7 @@ function peg$parse(input, options) {
7348
7446
  }
7349
7447
  if (s6 !== peg$FAILED) {
7350
7448
  peg$savedPos = s0;
7351
- s1 = peg$c184(s1, s3, s5, s6);
7449
+ s1 = peg$c185(s1, s3, s5, s6);
7352
7450
  s0 = s1;
7353
7451
  }
7354
7452
  else {
@@ -7398,14 +7496,14 @@ function peg$parse(input, options) {
7398
7496
  s4 = peg$currPos;
7399
7497
  s5 = peg$parse_();
7400
7498
  if (s5 !== peg$FAILED) {
7401
- if (input.substr(peg$currPos, 2) === peg$c185) {
7402
- s6 = peg$c185;
7499
+ if (input.substr(peg$currPos, 2) === peg$c186) {
7500
+ s6 = peg$c186;
7403
7501
  peg$currPos += 2;
7404
7502
  }
7405
7503
  else {
7406
7504
  s6 = peg$FAILED;
7407
7505
  if (peg$silentFails === 0) {
7408
- peg$fail(peg$c186);
7506
+ peg$fail(peg$c187);
7409
7507
  }
7410
7508
  }
7411
7509
  if (s6 !== peg$FAILED) {
@@ -7428,7 +7526,7 @@ function peg$parse(input, options) {
7428
7526
  s10 = peg$parsenewline();
7429
7527
  if (s10 !== peg$FAILED) {
7430
7528
  peg$savedPos = s4;
7431
- s5 = peg$c116(s1, s8);
7529
+ s5 = peg$c117(s1, s8);
7432
7530
  s4 = s5;
7433
7531
  }
7434
7532
  else {
@@ -7465,14 +7563,14 @@ function peg$parse(input, options) {
7465
7563
  s4 = peg$currPos;
7466
7564
  s5 = peg$parse_();
7467
7565
  if (s5 !== peg$FAILED) {
7468
- if (input.substr(peg$currPos, 2) === peg$c185) {
7469
- s6 = peg$c185;
7566
+ if (input.substr(peg$currPos, 2) === peg$c186) {
7567
+ s6 = peg$c186;
7470
7568
  peg$currPos += 2;
7471
7569
  }
7472
7570
  else {
7473
7571
  s6 = peg$FAILED;
7474
7572
  if (peg$silentFails === 0) {
7475
- peg$fail(peg$c186);
7573
+ peg$fail(peg$c187);
7476
7574
  }
7477
7575
  }
7478
7576
  if (s6 !== peg$FAILED) {
@@ -7495,7 +7593,7 @@ function peg$parse(input, options) {
7495
7593
  s10 = peg$parsenewline();
7496
7594
  if (s10 !== peg$FAILED) {
7497
7595
  peg$savedPos = s4;
7498
- s5 = peg$c116(s1, s8);
7596
+ s5 = peg$c117(s1, s8);
7499
7597
  s4 = s5;
7500
7598
  }
7501
7599
  else {
@@ -7530,7 +7628,7 @@ function peg$parse(input, options) {
7530
7628
  }
7531
7629
  if (s3 !== peg$FAILED) {
7532
7630
  peg$savedPos = s0;
7533
- s1 = peg$c187(s1, s3);
7631
+ s1 = peg$c188(s1, s3);
7534
7632
  s0 = s1;
7535
7633
  }
7536
7634
  else {
@@ -7569,7 +7667,7 @@ function peg$parse(input, options) {
7569
7667
  s3 = peg$parseEOL();
7570
7668
  if (s3 !== peg$FAILED) {
7571
7669
  peg$savedPos = s0;
7572
- s1 = peg$c188(s1);
7670
+ s1 = peg$c189(s1);
7573
7671
  s0 = s1;
7574
7672
  }
7575
7673
  else {
@@ -7594,13 +7692,13 @@ function peg$parse(input, options) {
7594
7692
  s1 = peg$parse_();
7595
7693
  if (s1 !== peg$FAILED) {
7596
7694
  if (input.charCodeAt(peg$currPos) === 58) {
7597
- s2 = peg$c55;
7695
+ s2 = peg$c56;
7598
7696
  peg$currPos++;
7599
7697
  }
7600
7698
  else {
7601
7699
  s2 = peg$FAILED;
7602
7700
  if (peg$silentFails === 0) {
7603
- peg$fail(peg$c56);
7701
+ peg$fail(peg$c57);
7604
7702
  }
7605
7703
  }
7606
7704
  if (s2 !== peg$FAILED) {
@@ -7710,7 +7808,7 @@ function peg$parse(input, options) {
7710
7808
  s6 = peg$parseEOL();
7711
7809
  if (s6 !== peg$FAILED) {
7712
7810
  peg$savedPos = s0;
7713
- s1 = peg$c189(s3, s5);
7811
+ s1 = peg$c190(s3, s5);
7714
7812
  s0 = s1;
7715
7813
  }
7716
7814
  else {
@@ -7860,7 +7958,7 @@ function peg$parse(input, options) {
7860
7958
  s5 = peg$parseEOL();
7861
7959
  if (s5 !== peg$FAILED) {
7862
7960
  peg$savedPos = s3;
7863
- s4 = peg$c190(s4);
7961
+ s4 = peg$c191(s4);
7864
7962
  s3 = s4;
7865
7963
  }
7866
7964
  else {
@@ -7875,7 +7973,7 @@ function peg$parse(input, options) {
7875
7973
  }
7876
7974
  if (s3 !== peg$FAILED) {
7877
7975
  peg$savedPos = s0;
7878
- s1 = peg$c191(s3);
7976
+ s1 = peg$c192(s3);
7879
7977
  s0 = s1;
7880
7978
  }
7881
7979
  else {
@@ -7906,14 +8004,14 @@ function peg$parse(input, options) {
7906
8004
  s1 = s2;
7907
8005
  }
7908
8006
  if (s1 !== peg$FAILED) {
7909
- if (input.substr(peg$currPos, 4) === peg$c192) {
7910
- s2 = peg$c192;
8007
+ if (input.substr(peg$currPos, 4) === peg$c193) {
8008
+ s2 = peg$c193;
7911
8009
  peg$currPos += 4;
7912
8010
  }
7913
8011
  else {
7914
8012
  s2 = peg$FAILED;
7915
8013
  if (peg$silentFails === 0) {
7916
- peg$fail(peg$c193);
8014
+ peg$fail(peg$c194);
7917
8015
  }
7918
8016
  }
7919
8017
  if (s2 !== peg$FAILED) {
@@ -7942,7 +8040,7 @@ function peg$parse(input, options) {
7942
8040
  }
7943
8041
  if (s5 !== peg$FAILED) {
7944
8042
  peg$savedPos = s0;
7945
- s1 = peg$c194(s1, s4, s5);
8043
+ s1 = peg$c195(s1, s4, s5);
7946
8044
  s0 = s1;
7947
8045
  }
7948
8046
  else {
@@ -8010,7 +8108,7 @@ function peg$parse(input, options) {
8010
8108
  s6 = peg$parsealias_replacement_text();
8011
8109
  if (s6 !== peg$FAILED) {
8012
8110
  peg$savedPos = s0;
8013
- s1 = peg$c195(s1, s2, s4, s6);
8111
+ s1 = peg$c196(s1, s2, s4, s6);
8014
8112
  s0 = s1;
8015
8113
  }
8016
8114
  else {
@@ -8071,25 +8169,25 @@ function peg$parse(input, options) {
8071
8169
  if (s3 !== peg$FAILED) {
8072
8170
  s4 = peg$currPos;
8073
8171
  s5 = peg$currPos;
8074
- if (peg$c196.test(input.charAt(peg$currPos))) {
8172
+ if (peg$c197.test(input.charAt(peg$currPos))) {
8075
8173
  s6 = input.charAt(peg$currPos);
8076
8174
  peg$currPos++;
8077
8175
  }
8078
8176
  else {
8079
8177
  s6 = peg$FAILED;
8080
8178
  if (peg$silentFails === 0) {
8081
- peg$fail(peg$c197);
8179
+ peg$fail(peg$c198);
8082
8180
  }
8083
8181
  }
8084
8182
  if (s6 !== peg$FAILED) {
8085
- if (input.substr(peg$currPos, 2) === peg$c198) {
8086
- s7 = peg$c198;
8183
+ if (input.substr(peg$currPos, 2) === peg$c199) {
8184
+ s7 = peg$c199;
8087
8185
  peg$currPos += 2;
8088
8186
  }
8089
8187
  else {
8090
8188
  s7 = peg$FAILED;
8091
8189
  if (peg$silentFails === 0) {
8092
- peg$fail(peg$c199);
8190
+ peg$fail(peg$c200);
8093
8191
  }
8094
8192
  }
8095
8193
  if (s7 !== peg$FAILED) {
@@ -8120,7 +8218,7 @@ function peg$parse(input, options) {
8120
8218
  s6 = peg$parsepod_configuration();
8121
8219
  if (s6 !== peg$FAILED) {
8122
8220
  peg$savedPos = s0;
8123
- s1 = peg$c200(s1, s2, s4, s6);
8221
+ s1 = peg$c201(s1, s2, s4, s6);
8124
8222
  s0 = s1;
8125
8223
  }
8126
8224
  else {
@@ -8166,14 +8264,14 @@ function peg$parse(input, options) {
8166
8264
  s1 = s2;
8167
8265
  }
8168
8266
  if (s1 !== peg$FAILED) {
8169
- if (input.substr(peg$currPos, 9) === peg$c201) {
8170
- s2 = peg$c201;
8267
+ if (input.substr(peg$currPos, 9) === peg$c202) {
8268
+ s2 = peg$c202;
8171
8269
  peg$currPos += 9;
8172
8270
  }
8173
8271
  else {
8174
8272
  s2 = peg$FAILED;
8175
8273
  if (peg$silentFails === 0) {
8176
- peg$fail(peg$c202);
8274
+ peg$fail(peg$c203);
8177
8275
  }
8178
8276
  }
8179
8277
  if (s2 !== peg$FAILED) {
@@ -8182,7 +8280,7 @@ function peg$parse(input, options) {
8182
8280
  s4 = peg$parsepod_configuration();
8183
8281
  if (s4 !== peg$FAILED) {
8184
8282
  peg$savedPos = s0;
8185
- s1 = peg$c203(s1, s2, s4);
8283
+ s1 = peg$c204(s1, s2, s4);
8186
8284
  s0 = s1;
8187
8285
  }
8188
8286
  else {
@@ -8227,7 +8325,7 @@ function peg$parse(input, options) {
8227
8325
  s5 = peg$parsepod_configuration();
8228
8326
  if (s5 !== peg$FAILED) {
8229
8327
  peg$savedPos = peg$currPos;
8230
- s6 = peg$c204(s1, s2, s3, s5);
8328
+ s6 = peg$c205(s1, s2, s3, s5);
8231
8329
  if (s6) {
8232
8330
  s6 = void 0;
8233
8331
  }
@@ -8250,7 +8348,7 @@ function peg$parse(input, options) {
8250
8348
  s10 = peg$FAILED;
8251
8349
  }
8252
8350
  if (s10 !== peg$FAILED) {
8253
- s11 = peg$parsetext_content();
8351
+ s11 = peg$parseplain_line();
8254
8352
  if (s11 !== peg$FAILED) {
8255
8353
  s10 = [s10, s11];
8256
8354
  s9 = s10;
@@ -8279,7 +8377,7 @@ function peg$parse(input, options) {
8279
8377
  s10 = peg$FAILED;
8280
8378
  }
8281
8379
  if (s10 !== peg$FAILED) {
8282
- s11 = peg$parsetext_content();
8380
+ s11 = peg$parseplain_line();
8283
8381
  if (s11 !== peg$FAILED) {
8284
8382
  s10 = [s10, s11];
8285
8383
  s9 = s10;
@@ -8302,7 +8400,7 @@ function peg$parse(input, options) {
8302
8400
  }
8303
8401
  if (s7 !== peg$FAILED) {
8304
8402
  peg$savedPos = s0;
8305
- s1 = peg$c205(s1, s2, s3, s5, s7);
8403
+ s1 = peg$c206(s1, s2, s3, s5, s7);
8306
8404
  s0 = s1;
8307
8405
  }
8308
8406
  else {
@@ -8362,7 +8460,7 @@ function peg$parse(input, options) {
8362
8460
  s5 = peg$parsepod_configuration();
8363
8461
  if (s5 !== peg$FAILED) {
8364
8462
  peg$savedPos = peg$currPos;
8365
- s6 = peg$c206(s1, s2, s3, s5);
8463
+ s6 = peg$c207(s1, s2, s3, s5);
8366
8464
  if (s6) {
8367
8465
  s6 = void 0;
8368
8466
  }
@@ -8371,7 +8469,7 @@ function peg$parse(input, options) {
8371
8469
  }
8372
8470
  if (s6 !== peg$FAILED) {
8373
8471
  peg$savedPos = peg$currPos;
8374
- s7 = peg$c207(s1, s2, s3, s5);
8472
+ s7 = peg$c208(s1, s2, s3, s5);
8375
8473
  if (s7) {
8376
8474
  s7 = void 0;
8377
8475
  }
@@ -8382,7 +8480,7 @@ function peg$parse(input, options) {
8382
8480
  s8 = peg$parsetableContents();
8383
8481
  if (s8 !== peg$FAILED) {
8384
8482
  peg$savedPos = s0;
8385
- s1 = peg$c208(s1, s2, s3, s5, s8);
8483
+ s1 = peg$c209(s1, s2, s3, s5, s8);
8386
8484
  s0 = s1;
8387
8485
  }
8388
8486
  else {
@@ -8513,7 +8611,7 @@ function peg$parse(input, options) {
8513
8611
  }
8514
8612
  if (s6 !== peg$FAILED) {
8515
8613
  peg$savedPos = s0;
8516
- s1 = peg$c209(s1, s2, s3, s5, s6);
8614
+ s1 = peg$c210(s1, s2, s3, s5, s6);
8517
8615
  s0 = s1;
8518
8616
  }
8519
8617
  else {
@@ -8551,38 +8649,38 @@ function peg$parse(input, options) {
8551
8649
  var s0, s1, s2, s3, s4;
8552
8650
  s0 = peg$currPos;
8553
8651
  s1 = peg$currPos;
8554
- if (peg$c210.test(input.charAt(peg$currPos))) {
8652
+ if (peg$c211.test(input.charAt(peg$currPos))) {
8555
8653
  s2 = input.charAt(peg$currPos);
8556
8654
  peg$currPos++;
8557
8655
  }
8558
8656
  else {
8559
8657
  s2 = peg$FAILED;
8560
8658
  if (peg$silentFails === 0) {
8561
- peg$fail(peg$c211);
8659
+ peg$fail(peg$c212);
8562
8660
  }
8563
8661
  }
8564
8662
  if (s2 !== peg$FAILED) {
8565
8663
  s3 = [];
8566
- if (peg$c46.test(input.charAt(peg$currPos))) {
8664
+ if (peg$c47.test(input.charAt(peg$currPos))) {
8567
8665
  s4 = input.charAt(peg$currPos);
8568
8666
  peg$currPos++;
8569
8667
  }
8570
8668
  else {
8571
8669
  s4 = peg$FAILED;
8572
8670
  if (peg$silentFails === 0) {
8573
- peg$fail(peg$c47);
8671
+ peg$fail(peg$c48);
8574
8672
  }
8575
8673
  }
8576
8674
  while (s4 !== peg$FAILED) {
8577
8675
  s3.push(s4);
8578
- if (peg$c46.test(input.charAt(peg$currPos))) {
8676
+ if (peg$c47.test(input.charAt(peg$currPos))) {
8579
8677
  s4 = input.charAt(peg$currPos);
8580
8678
  peg$currPos++;
8581
8679
  }
8582
8680
  else {
8583
8681
  s4 = peg$FAILED;
8584
8682
  if (peg$silentFails === 0) {
8585
- peg$fail(peg$c47);
8683
+ peg$fail(peg$c48);
8586
8684
  }
8587
8685
  }
8588
8686
  }
@@ -8611,26 +8709,26 @@ function peg$parse(input, options) {
8611
8709
  var s0, s1;
8612
8710
  peg$silentFails++;
8613
8711
  s0 = [];
8614
- if (peg$c213.test(input.charAt(peg$currPos))) {
8712
+ if (peg$c214.test(input.charAt(peg$currPos))) {
8615
8713
  s1 = input.charAt(peg$currPos);
8616
8714
  peg$currPos++;
8617
8715
  }
8618
8716
  else {
8619
8717
  s1 = peg$FAILED;
8620
8718
  if (peg$silentFails === 0) {
8621
- peg$fail(peg$c214);
8719
+ peg$fail(peg$c215);
8622
8720
  }
8623
8721
  }
8624
8722
  while (s1 !== peg$FAILED) {
8625
8723
  s0.push(s1);
8626
- if (peg$c213.test(input.charAt(peg$currPos))) {
8724
+ if (peg$c214.test(input.charAt(peg$currPos))) {
8627
8725
  s1 = input.charAt(peg$currPos);
8628
8726
  peg$currPos++;
8629
8727
  }
8630
8728
  else {
8631
8729
  s1 = peg$FAILED;
8632
8730
  if (peg$silentFails === 0) {
8633
- peg$fail(peg$c214);
8731
+ peg$fail(peg$c215);
8634
8732
  }
8635
8733
  }
8636
8734
  }
@@ -8638,7 +8736,7 @@ function peg$parse(input, options) {
8638
8736
  if (s0 === peg$FAILED) {
8639
8737
  s1 = peg$FAILED;
8640
8738
  if (peg$silentFails === 0) {
8641
- peg$fail(peg$c212);
8739
+ peg$fail(peg$c213);
8642
8740
  }
8643
8741
  }
8644
8742
  return s0;
@@ -8647,26 +8745,26 @@ function peg$parse(input, options) {
8647
8745
  var s0, s1;
8648
8746
  peg$silentFails++;
8649
8747
  s0 = [];
8650
- if (peg$c213.test(input.charAt(peg$currPos))) {
8748
+ if (peg$c214.test(input.charAt(peg$currPos))) {
8651
8749
  s1 = input.charAt(peg$currPos);
8652
8750
  peg$currPos++;
8653
8751
  }
8654
8752
  else {
8655
8753
  s1 = peg$FAILED;
8656
8754
  if (peg$silentFails === 0) {
8657
- peg$fail(peg$c214);
8755
+ peg$fail(peg$c215);
8658
8756
  }
8659
8757
  }
8660
8758
  while (s1 !== peg$FAILED) {
8661
8759
  s0.push(s1);
8662
- if (peg$c213.test(input.charAt(peg$currPos))) {
8760
+ if (peg$c214.test(input.charAt(peg$currPos))) {
8663
8761
  s1 = input.charAt(peg$currPos);
8664
8762
  peg$currPos++;
8665
8763
  }
8666
8764
  else {
8667
8765
  s1 = peg$FAILED;
8668
8766
  if (peg$silentFails === 0) {
8669
- peg$fail(peg$c214);
8767
+ peg$fail(peg$c215);
8670
8768
  }
8671
8769
  }
8672
8770
  }
@@ -8674,7 +8772,7 @@ function peg$parse(input, options) {
8674
8772
  if (s0 === peg$FAILED) {
8675
8773
  s1 = peg$FAILED;
8676
8774
  if (peg$silentFails === 0) {
8677
- peg$fail(peg$c215);
8775
+ peg$fail(peg$c216);
8678
8776
  }
8679
8777
  }
8680
8778
  return s0;
@@ -8685,6 +8783,12 @@ function peg$parse(input, options) {
8685
8783
  &&
8686
8784
  name !== name.toUpperCase());
8687
8785
  }
8786
+ // the body of these blocks is kept as written
8787
+ function isRawBlock(name) {
8788
+ return (Boolean(name.match(/code|comment|formula|output|input|markdown|picture|toc|data|fixture|assert|resource/))
8789
+ ||
8790
+ isNamedBlock(name));
8791
+ }
8688
8792
  // the following names: =AUTHOR =DESCRIPTION are reserved
8689
8793
  function isSemanticBlock(name) {
8690
8794
  return name === name.toUpperCase();
@@ -8709,6 +8813,31 @@ function peg$parse(input, options) {
8709
8813
  options.diagnostics.push({ severity: 'warning', code: code || 'value-unreadable', message, location });
8710
8814
  }
8711
8815
  }
8816
+ // Opt-in and separate from the diagnostics: a line naming a block this
8817
+ // parser does not know is ordinary text for every other reader.
8818
+ function noteRecognition(options, event) {
8819
+ if (!options || !Array.isArray(options.recognition))
8820
+ return;
8821
+ const seen = options.recognition.some(e => e.kind === event.kind && e.location.start.offset === event.location.start.offset);
8822
+ if (!seen)
8823
+ options.recognition.push(event);
8824
+ }
8825
+ function noteUnknownDirective(options, line, location) {
8826
+ const marked = line.match(/^[ \t]*=(begin|for|end)[ \t]+([a-zA-Z][a-zA-Z0-9_-]*)/);
8827
+ // a marker with no name, or with one no block can have, opens nothing
8828
+ if (!marked && /^[ \t]*=(begin|for|end)([ \t\r\n]|$)/.test(line)) {
8829
+ noteRecognition(options, { kind: 'unreadable-directive', location });
8830
+ return;
8831
+ }
8832
+ const bare = marked ? null : line.match(/^[ \t]*=([a-zA-Z][a-zA-Z0-9_-]*)/);
8833
+ const marker = marked ? marked[1] : 'abbreviated';
8834
+ const name = marked ? marked[2] : bare && bare[1];
8835
+ if (!name || isSupportedBlockName(name))
8836
+ return;
8837
+ if (!marked && ['begin', 'for', 'end', 'config', 'alias'].includes(name))
8838
+ return;
8839
+ noteRecognition(options, { kind: 'unknown-directive', marker, name, location });
8840
+ }
8712
8841
  function keepReadable(attrs) {
8713
8842
  return attrs.filter(a => !a.dropped);
8714
8843
  }
@@ -8716,12 +8845,14 @@ function peg$parse(input, options) {
8716
8845
  // direct call and is kept equal to it by a test
8717
8846
  function knownBlockNames() {
8718
8847
  return (options && options.blockNames) || [
8848
+ 'assert',
8719
8849
  'boundary',
8720
8850
  'code',
8721
8851
  'comment',
8722
8852
  'data',
8723
8853
  'data-table',
8724
8854
  'defn',
8855
+ 'fixture',
8725
8856
  'formula',
8726
8857
  'head',
8727
8858
  'include',
@@ -8733,10 +8864,12 @@ function peg$parse(input, options) {
8733
8864
  'para',
8734
8865
  'picture',
8735
8866
  'pod',
8867
+ 'resource',
8736
8868
  'row',
8737
8869
  'cell',
8738
8870
  'set',
8739
8871
  'table',
8872
+ 'test',
8740
8873
  'toc',
8741
8874
  ];
8742
8875
  }
@@ -8756,7 +8889,8 @@ function peg$parse(input, options) {
8756
8889
  if (string.indexOf(vmargin) == 0) {
8757
8890
  return string.replace(vmargin, '');
8758
8891
  }
8759
- return string.replace(/^\s+/, '');
8892
+ // a line indented less than the margin loses its indent, not its line break
8893
+ return string.replace(/^[^\S\r\n]+/, '');
8760
8894
  }
8761
8895
  peg$result = peg$startRuleFunction();
8762
8896
  if (peg$result !== peg$FAILED && peg$currPos === input.length) {