@podlite/schema 0.0.78 → 0.0.79

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.
package/lib/grammar.js CHANGED
@@ -113,49 +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 () {
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 = function () { const at = location().start.offset; return at === 0 || input[at - 1] === '\n' || input[at - 1] === '\r'; }, peg$c35 = peg$otherExpectation("text"), peg$c36 = function () {
117
117
  noteUnknownDirective(options, text(), location());
118
118
  return text();
119
- }, peg$c36 = function () { return text(); }, peg$c37 = function () {
119
+ }, peg$c37 = function () { return text(); }, peg$c38 = function () { return text(); }, peg$c39 = function () {
120
120
  addDiagnostic(options, "Line looks like a directive but could not be read; it stays as text", location(), 'directive-unreadable');
121
121
  noteRecognition(options, { kind: 'unreadable-directive', location: location() });
122
122
  return { type: "para", value: text(), error: true, location: location() };
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) {
123
+ }, peg$c40 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c41 = function (code) { return [code]; }, peg$c42 = /^[ \t]/, peg$c43 = peg$classExpectation([" ", "\t"], false, false), peg$c44 = ",", peg$c45 = peg$literalExpectation(",", false), peg$c46 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c47 = /^[a-zA-Z0-9]/, peg$c48 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false), peg$c49 = /^[a-zA-Z0-9_\-]/, peg$c50 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false), peg$c51 = function (attr) { return !attr.dropped; }, peg$c52 = function (attr) { return { [attr.name]: attr.value }; }, peg$c53 = "=>", peg$c54 = peg$literalExpectation("=>", false), peg$c55 = function (name, value) { return { [name]: value }; }, peg$c56 = function (pair, pairs) { return { ...pair, ...pairs }; }, peg$c57 = function (code) { return code; }, peg$c58 = ":", peg$c59 = peg$literalExpectation(":", false), peg$c60 = /^[!]/, peg$c61 = peg$classExpectation(["!"], false, false), peg$c62 = "allow", peg$c63 = peg$literalExpectation("allow", false), peg$c64 = "<", peg$c65 = peg$literalExpectation("<", false), peg$c66 = ">", peg$c67 = peg$literalExpectation(">", false), peg$c68 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c69 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c70 = function (isFalse, key, value) { return { name: 'allow', ...value, ...(isFalse ? { isFalse: true } : {}) }; }, peg$c71 = /^[^ \t\r\n,<>[\]{}()'"]/, peg$c72 = peg$classExpectation([" ", "\t", "\r", "\n", ",", "<", ">", "[", "]", "{", "}", "(", ")", "'", "\""], true, false), peg$c73 = function (first, i) { return i; }, peg$c74 = function (first, rest) { return flattenDeep([first, ...rest]); }, peg$c75 = function (i) { return i; }, peg$c76 = function (all) { return all; }, peg$c77 = function (res) { return [res]; }, peg$c78 = function () { return []; }, peg$c79 = "{", peg$c80 = peg$literalExpectation("{", false), peg$c81 = "}", peg$c82 = peg$literalExpectation("}", false), peg$c83 = function (isFalse, key, hash) { return { value: hash, type: "map" }; }, peg$c84 = function (isFalse, key) { return { value: {}, type: "map" }; }, peg$c85 = function (isFalse, key) { return { unreadable: true, location: location() }; }, peg$c86 = "[", peg$c87 = peg$literalExpectation("[", false), peg$c88 = "]", peg$c89 = peg$literalExpectation("]", false), peg$c90 = function (isFalse, key) {
124
124
  return {
125
125
  unreadable: true,
126
126
  location: location(),
127
127
  message: "Square brackets are not an attribute value form; write a list with angle brackets or parentheses"
128
128
  };
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) {
129
+ }, peg$c91 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c92 = /^[']/, peg$c93 = peg$classExpectation(["'"], false, false), peg$c94 = /^[^'\n\r]/, peg$c95 = peg$classExpectation(["'", "\n", "\r"], true, false), peg$c96 = function (isFalse, key, text) { return { value: text, type: "string" }; }, peg$c97 = /^["]/, peg$c98 = peg$classExpectation(["\""], false, false), peg$c99 = /^[^"\n\r]/, peg$c100 = peg$classExpectation(["\"", "\n", "\r"], true, false), peg$c101 = function (isFalse, key, text) { return { value: text.trim(), type: "string" }; }, peg$c102 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c103 = "(", peg$c104 = peg$literalExpectation("(", false), peg$c105 = function (isFalse, key, array) {
130
130
  return (array.length > 1)
131
131
  ? { type: 'array', value: array }
132
132
  : { type: valueKind(array[0]), value: array[0] };
133
- }, peg$c104 = ")", peg$c105 = peg$literalExpectation(")", false), peg$c106 = function (isFalse, key, res) { return res; }, peg$c107 = function (isFalse, key) {
133
+ }, peg$c106 = ")", peg$c107 = peg$literalExpectation(")", false), peg$c108 = function (isFalse, key, res) { return res; }, peg$c109 = function (isFalse, key) {
134
134
  return {
135
135
  unreadable: true,
136
136
  location: location(),
137
137
  message: "Bare text in parentheses; quote it or use a number"
138
138
  };
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) {
139
+ }, peg$c110 = "\uFF62", peg$c111 = peg$literalExpectation("\uFF62", false), peg$c112 = /^[^\uFF63\n\r]/, peg$c113 = peg$classExpectation(["\uFF63", "\n", "\r"], true, false), peg$c114 = "\uFF63", peg$c115 = peg$literalExpectation("\uFF63", false), peg$c116 = function (isFalse, key) {
140
140
  return {
141
141
  unreadable: true,
142
142
  location: location(),
143
143
  message: "Value is not closed; only a bracketed value may continue on the next configuration line"
144
144
  };
145
- }, peg$c115 = function (isFalse, key) {
145
+ }, peg$c117 = function (isFalse, key) {
146
146
  return {
147
147
  value: !isFalse,
148
148
  type: "boolean"
149
149
  };
150
- }, peg$c116 = function (isFalse, key, value) {
150
+ }, peg$c118 = function (isFalse, key, value) {
151
151
  if (value.unreadable) {
152
152
  addDiagnostic(options, value.message || `cannot read the value of :${key}`, value.location);
153
153
  return { name: key, dropped: true };
154
154
  }
155
155
  return { name: key, ...value, ...(isFalse && value.type !== 'boolean' ? { isFalse: true } : {}) };
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) {
156
+ }, peg$c119 = function (first, rest) { return rest; }, peg$c120 = function (first, cont, unread) { return keepReadable(flattenDeep([...first, ...cont])); }, peg$c121 = function () { addDiagnostic(options, "Configuration continuation line could not be read", location()); }, peg$c122 = /^[^'"]/, peg$c123 = peg$classExpectation(["'", "\""], true, false), peg$c124 = function (text) { return text; }, peg$c125 = /^[0-9]/, peg$c126 = peg$classExpectation([["0", "9"]], false, false), peg$c127 = /^[\-+]/, peg$c128 = peg$classExpectation(["-", "+"], false, false), peg$c129 = "True", peg$c130 = peg$literalExpectation("True", false), peg$c131 = function () { return true; }, peg$c132 = "False", peg$c133 = peg$literalExpectation("False", false), peg$c134 = function () { return false; }, peg$c135 = ".", peg$c136 = peg$literalExpectation(".", false), peg$c137 = /^[eE]/, peg$c138 = peg$classExpectation(["e", "E"], false, false), peg$c139 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c140 = function (number) { return parseInt(number, 10); }, peg$c141 = function (vmargin, name, config) {
157
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) {
158
+ }, peg$c142 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c143 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c144 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c145 = function (vmargin, name, config, content, vmargin2, ename) {
159
159
  const type = 'block';
160
160
  return {
161
161
  type: type,
@@ -163,29 +163,29 @@ function peg$parse(input, options) {
163
163
  name,
164
164
  margin: vmargin
165
165
  };
166
- }, peg$c144 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c145 = function (vmargin, name, config, content, vmargin2, res) {
166
+ }, peg$c146 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c147 = function (vmargin, name, config, content, vmargin2, res) {
167
167
  return {
168
168
  ...res,
169
169
  text: text(),
170
170
  config,
171
171
  location: location()
172
172
  };
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 () {
173
+ }, peg$c148 = /^[\-+=_|]/, peg$c149 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c150 = function () { return { type: 'separator', text: text() }; }, peg$c151 = function () { return options.isDelimited; }, peg$c152 = function () {
174
174
  return {
175
175
  type: 'separator',
176
176
  text: text()
177
177
  };
178
- }, peg$c151 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c152 = function () {
178
+ }, peg$c153 = function () { return !!options.isDelimited; }, peg$c154 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c155 = function () {
179
179
  // reset separator count and its accum
180
180
  options.separators = [];
181
181
  return true;
182
- }, peg$c153 = function (head, t) {
182
+ }, peg$c156 = function (head, t) {
183
183
  options.separators.push(t.text);
184
184
  return t;
185
- }, peg$c154 = function (head, separator, rowtext, t) {
185
+ }, peg$c157 = function (head, separator, rowtext, t) {
186
186
  options.separators.push(t.text);
187
187
  return t;
188
- }, peg$c155 = function (head, separator, rowtext, bseparator) {
188
+ }, peg$c158 = function (head, separator, rowtext, bseparator) {
189
189
  return [
190
190
  {
191
191
  name: 'row',
@@ -194,14 +194,14 @@ function peg$parse(input, options) {
194
194
  },
195
195
  bseparator
196
196
  ];
197
- }, peg$c156 = function (head, separator, singleRow) { return [singleRow]; }, peg$c157 = function (head, separator, rest) {
197
+ }, peg$c159 = function (head, separator, singleRow) { return [singleRow]; }, peg$c160 = function (head, separator, rest) {
198
198
  // if more then 1 separator and it equal - table doesn't have header
199
199
  if (options.separators.length > 1) {
200
200
  // check if separators equal (for table without header)
201
201
  return !options.separators.every(val => val === options.separators[0]);
202
202
  }
203
203
  return true;
204
- }, peg$c158 = function (head, separator, rest) {
204
+ }, peg$c161 = function (head, separator, rest) {
205
205
  return [
206
206
  {
207
207
  name: 'head',
@@ -211,7 +211,7 @@ function peg$parse(input, options) {
211
211
  separator,
212
212
  ...flattenDeep(rest)
213
213
  ];
214
- }, peg$c159 = function (rowtest, bseparator) {
214
+ }, peg$c162 = function (rowtest, bseparator) {
215
215
  return [
216
216
  {
217
217
  name: 'row',
@@ -220,37 +220,37 @@ function peg$parse(input, options) {
220
220
  },
221
221
  bseparator
222
222
  ];
223
- }, peg$c160 = function (rest) {
223
+ }, peg$c163 = function (rest) {
224
224
  return [...flattenDeep(rest)];
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) {
225
+ }, peg$c164 = function (vmargin, name, config) { return name === 'table'; }, peg$c165 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c166 = function (vmargin, name, config, nodes) { return nodes; }, peg$c167 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c168 = function (vmargin, name, config, content, vmargin2, ename) {
226
226
  return {
227
227
  type: 'block',
228
228
  content,
229
229
  name,
230
230
  margin: vmargin
231
231
  };
232
- }, peg$c166 = function (vmargin, name, config, content, vmargin2, res) {
232
+ }, peg$c169 = function (vmargin, name, config, content, vmargin2, res) {
233
233
  return {
234
234
  ...res,
235
235
  text: text(),
236
236
  config,
237
237
  location: location()
238
238
  };
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) {
239
+ }, peg$c170 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c171 = function (vmargin, name, config, t) { return t; }, peg$c172 = function (vmargin, name, config, content, vmargin2, ename) {
240
240
  return {
241
241
  type: 'block',
242
242
  content: content,
243
243
  name,
244
244
  margin: vmargin
245
245
  };
246
- }, peg$c170 = function (vmargin, name, config, content, vmargin2, res) {
246
+ }, peg$c173 = function (vmargin, name, config, content, vmargin2, res) {
247
247
  return {
248
248
  ...res,
249
249
  text: text(),
250
250
  config,
251
251
  location: location()
252
252
  };
253
- }, peg$c171 = function (vmargin, name, config, nodes) { return nodes; }, peg$c172 = function (vmargin, name, config, tvmargin, text) {
253
+ }, peg$c174 = function (vmargin, name, config, nodes) { return nodes; }, peg$c175 = function (vmargin, name, config, tvmargin, text) {
254
254
  const type = name.match(/pod|nested|item|code|defn/)
255
255
  &&
256
256
  (tvmargin.length - vmargin.length) > 0 ? 'code' : 'para';
@@ -266,20 +266,20 @@ function peg$parse(input, options) {
266
266
  ],
267
267
  location: location(),
268
268
  };
269
- }, peg$c173 = function (vmargin, name, config, content, vmargin2, ename) {
269
+ }, peg$c176 = function (vmargin, name, config, content, vmargin2, ename) {
270
270
  return {
271
271
  type: 'block',
272
272
  content,
273
273
  name,
274
274
  margin: vmargin,
275
275
  };
276
- }, peg$c174 = function (vmargin, name, config, content, vmargin2, res) {
276
+ }, peg$c177 = function (vmargin, name, config, content, vmargin2, res) {
277
277
  return {
278
278
  ...res,
279
279
  config,
280
280
  location: location(),
281
281
  };
282
- }, peg$c175 = function () {
282
+ }, peg$c178 = function () {
283
283
  // the document is a pod: a chunk whose first line is set in from the margin is code
284
284
  const indent = text().match(/^[ \u00a0\u2001\t\u000C\u2008]*/)[0];
285
285
  if (indent.length > 0 && text().trim() !== '') {
@@ -304,18 +304,18 @@ function peg$parse(input, options) {
304
304
  ],
305
305
  location: location(),
306
306
  };
307
- }, 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) {
307
+ }, peg$c179 = function () { return { empty: 1 }; }, peg$c180 = /^[s]/, peg$c181 = peg$classExpectation(["s"], false, false), peg$c182 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c183 = function (vmargin, name) {
308
308
  return isRawBlock(name);
309
- }, peg$c181 = function (vmargin, name, content) {
309
+ }, peg$c184 = function (vmargin, name, text) { return exludeVMargin(vmargin, text); }, peg$c185 = function (vmargin, name, content) {
310
310
  return {
311
311
  margin: vmargin,
312
312
  type: 'block',
313
- content: content === "" ? [] : [{ type: 'verbatim', value: content }],
313
+ content: content.length === 0 ? [] : [{ type: 'verbatim', value: content.join('') }],
314
314
  name,
315
315
  config: [],
316
316
  location: location()
317
317
  };
318
- }, peg$c182 = function (vmargin, name) { return name === 'table'; }, peg$c183 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c184 = function (vmargin, name, content) {
318
+ }, peg$c186 = function (vmargin, name) { return name === 'table'; }, peg$c187 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c188 = function (vmargin, name, content) {
319
319
  return {
320
320
  margin: vmargin,
321
321
  type: 'block',
@@ -325,8 +325,8 @@ function peg$parse(input, options) {
325
325
  config: [],
326
326
  location: location()
327
327
  };
328
- }, peg$c185 = function (vmargin, name, first_line, content_rest) {
329
- const content = (first_line === "\n" ? "" : first_line) + content_rest;
328
+ }, peg$c189 = function (vmargin, name, first_line, text) { return exludeVMargin(vmargin, text); }, peg$c190 = function (vmargin, name, first_line, content_rest) {
329
+ const content = (first_line === "\n" ? "" : first_line) + content_rest.join('');
330
330
  return {
331
331
  margin: vmargin,
332
332
  type: 'block',
@@ -348,7 +348,7 @@ function peg$parse(input, options) {
348
348
  name,
349
349
  location: location()
350
350
  };
351
- }, 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) {
351
+ }, peg$c191 = "= ", peg$c192 = peg$literalExpectation("= ", false), peg$c193 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c194 = function (attrs) { return { kind: 'attrs', attrs }; }, peg$c195 = function (name, value) { return { kind: 'alias', name, value }; }, peg$c196 = function (v) { return { kind: 'value', value: v }; }, peg$c197 = function (seg) { return seg; }, peg$c198 = "=set", peg$c199 = peg$literalExpectation("=set", false), peg$c200 = function (vmargin, first, cont) {
352
352
  const items = [];
353
353
  let pending = null;
354
354
  const flush = () => {
@@ -378,21 +378,21 @@ function peg$parse(input, options) {
378
378
  margin: vmargin,
379
379
  location: location()
380
380
  };
381
- }, peg$c196 = function (vmargin, marker, name, replacement) {
381
+ }, peg$c201 = function (vmargin, marker, name, replacement) {
382
382
  return {
383
383
  name,
384
384
  type: 'alias',
385
385
  replacement,
386
386
  margin: vmargin
387
387
  };
388
- }, 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) {
388
+ }, peg$c202 = /^[A-Z]/, peg$c203 = peg$classExpectation([["A", "Z"]], false, false), peg$c204 = "<>", peg$c205 = peg$literalExpectation("<>", false), peg$c206 = function (vmargin, marker, name, config) {
389
389
  return {
390
390
  name,
391
391
  type: 'config',
392
392
  config,
393
393
  margin: vmargin
394
394
  };
395
- }, peg$c202 = "=boundary", peg$c203 = peg$literalExpectation("=boundary", false), peg$c204 = function (vmargin, marker, config) {
395
+ }, peg$c207 = "=boundary", peg$c208 = peg$literalExpectation("=boundary", false), peg$c209 = function (vmargin, marker, config) {
396
396
  return {
397
397
  name: 'boundary',
398
398
  type: 'block',
@@ -401,18 +401,18 @@ function peg$parse(input, options) {
401
401
  margin: vmargin,
402
402
  location: location()
403
403
  };
404
- }, peg$c205 = function (vmargin, marker, name, config) {
404
+ }, peg$c210 = function (vmargin, marker, name, config) {
405
405
  return isRawBlock(name);
406
- }, peg$c206 = function (vmargin, marker, name, config, content) {
406
+ }, peg$c211 = function (vmargin, marker, name, config, text) { return exludeVMargin(vmargin, text); }, peg$c212 = function (vmargin, marker, name, config, content) {
407
407
  return {
408
408
  type: 'block',
409
- content: content === "" ? [] : [{ type: 'verbatim', value: content }],
409
+ content: content.length === 0 ? [] : [{ type: 'verbatim', value: content.join('') }],
410
410
  name,
411
411
  margin: vmargin,
412
412
  config,
413
413
  location: location()
414
414
  };
415
- }, 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) {
415
+ }, peg$c213 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c214 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c215 = function (vmargin, marker, name, config, content) {
416
416
  return {
417
417
  type: 'block',
418
418
  content: content === "" ? [] : content,
@@ -421,7 +421,8 @@ function peg$parse(input, options) {
421
421
  config,
422
422
  location: location()
423
423
  };
424
- }, peg$c210 = function (vmargin, marker, name, config, content) {
424
+ }, peg$c216 = function (vmargin, marker, name, config, lines) {
425
+ const content = lines.join('');
425
426
  return {
426
427
  type: 'block',
427
428
  content: content === "" ? []
@@ -444,7 +445,7 @@ function peg$parse(input, options) {
444
445
  config,
445
446
  location: location()
446
447
  };
447
- }, 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;
448
+ }, peg$c217 = /^[a-zA-Z]/, peg$c218 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c219 = peg$otherExpectation("whitespace"), peg$c220 = /^[\r\n \t\f]/, peg$c221 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c222 = 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;
448
449
  if ("startRule" in options) {
449
450
  if (!(options.startRule in peg$startRuleFunctions)) {
450
451
  throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -1256,6 +1257,91 @@ function peg$parse(input, options) {
1256
1257
  }
1257
1258
  return s0;
1258
1259
  }
1260
+ function peg$parseanyDirective() {
1261
+ var s0, s1, s2, s3, s4, s5;
1262
+ s0 = peg$currPos;
1263
+ peg$savedPos = peg$currPos;
1264
+ s1 = peg$c34();
1265
+ if (s1) {
1266
+ s1 = void 0;
1267
+ }
1268
+ else {
1269
+ s1 = peg$FAILED;
1270
+ }
1271
+ if (s1 !== peg$FAILED) {
1272
+ s2 = peg$parse_();
1273
+ if (s2 !== peg$FAILED) {
1274
+ s3 = peg$parsemarkerConfig();
1275
+ if (s3 === peg$FAILED) {
1276
+ s3 = peg$parsemarkerAlias();
1277
+ if (s3 === peg$FAILED) {
1278
+ s3 = peg$currPos;
1279
+ s4 = peg$parsemarkers();
1280
+ if (s4 !== peg$FAILED) {
1281
+ s5 = peg$parseidentifier();
1282
+ if (s5 !== peg$FAILED) {
1283
+ s4 = [s4, s5];
1284
+ s3 = s4;
1285
+ }
1286
+ else {
1287
+ peg$currPos = s3;
1288
+ s3 = peg$FAILED;
1289
+ }
1290
+ }
1291
+ else {
1292
+ peg$currPos = s3;
1293
+ s3 = peg$FAILED;
1294
+ }
1295
+ if (s3 === peg$FAILED) {
1296
+ s3 = peg$currPos;
1297
+ if (input.charCodeAt(peg$currPos) === 61) {
1298
+ s4 = peg$c32;
1299
+ peg$currPos++;
1300
+ }
1301
+ else {
1302
+ s4 = peg$FAILED;
1303
+ if (peg$silentFails === 0) {
1304
+ peg$fail(peg$c33);
1305
+ }
1306
+ }
1307
+ if (s4 !== peg$FAILED) {
1308
+ s5 = peg$parseidentifier();
1309
+ if (s5 !== peg$FAILED) {
1310
+ s4 = [s4, s5];
1311
+ s3 = s4;
1312
+ }
1313
+ else {
1314
+ peg$currPos = s3;
1315
+ s3 = peg$FAILED;
1316
+ }
1317
+ }
1318
+ else {
1319
+ peg$currPos = s3;
1320
+ s3 = peg$FAILED;
1321
+ }
1322
+ }
1323
+ }
1324
+ }
1325
+ if (s3 !== peg$FAILED) {
1326
+ s1 = [s1, s2, s3];
1327
+ s0 = s1;
1328
+ }
1329
+ else {
1330
+ peg$currPos = s0;
1331
+ s0 = peg$FAILED;
1332
+ }
1333
+ }
1334
+ else {
1335
+ peg$currPos = s0;
1336
+ s0 = peg$FAILED;
1337
+ }
1338
+ }
1339
+ else {
1340
+ peg$currPos = s0;
1341
+ s0 = peg$FAILED;
1342
+ }
1343
+ return s0;
1344
+ }
1259
1345
  function peg$parseText() {
1260
1346
  var s0, s1, s2;
1261
1347
  peg$silentFails++;
@@ -1281,12 +1367,12 @@ function peg$parse(input, options) {
1281
1367
  if (s0 === peg$FAILED) {
1282
1368
  s1 = peg$FAILED;
1283
1369
  if (peg$silentFails === 0) {
1284
- peg$fail(peg$c34);
1370
+ peg$fail(peg$c35);
1285
1371
  }
1286
1372
  }
1287
1373
  return s0;
1288
1374
  }
1289
- function peg$parsetext_content() {
1375
+ function peg$parsetext_line_first() {
1290
1376
  var s0, s1, s2, s3, s4, s5, s6;
1291
1377
  s0 = peg$currPos;
1292
1378
  s1 = peg$currPos;
@@ -1367,7 +1453,66 @@ function peg$parse(input, options) {
1367
1453
  s3 = peg$parseEOL();
1368
1454
  if (s3 !== peg$FAILED) {
1369
1455
  peg$savedPos = s0;
1370
- s1 = peg$c35();
1456
+ s1 = peg$c36();
1457
+ s0 = s1;
1458
+ }
1459
+ else {
1460
+ peg$currPos = s0;
1461
+ s0 = peg$FAILED;
1462
+ }
1463
+ }
1464
+ else {
1465
+ peg$currPos = s0;
1466
+ s0 = peg$FAILED;
1467
+ }
1468
+ }
1469
+ else {
1470
+ peg$currPos = s0;
1471
+ s0 = peg$FAILED;
1472
+ }
1473
+ return s0;
1474
+ }
1475
+ function peg$parsetext_content() {
1476
+ var s0, s1, s2, s3, s4;
1477
+ s0 = peg$currPos;
1478
+ s1 = peg$currPos;
1479
+ peg$silentFails++;
1480
+ s2 = peg$parseanyDirective();
1481
+ if (s2 === peg$FAILED) {
1482
+ s2 = peg$parseblankline();
1483
+ }
1484
+ peg$silentFails--;
1485
+ if (s2 === peg$FAILED) {
1486
+ s1 = void 0;
1487
+ }
1488
+ else {
1489
+ peg$currPos = s1;
1490
+ s1 = peg$FAILED;
1491
+ }
1492
+ if (s1 !== peg$FAILED) {
1493
+ s2 = peg$currPos;
1494
+ s3 = [];
1495
+ s4 = peg$parseText();
1496
+ if (s4 !== peg$FAILED) {
1497
+ while (s4 !== peg$FAILED) {
1498
+ s3.push(s4);
1499
+ s4 = peg$parseText();
1500
+ }
1501
+ }
1502
+ else {
1503
+ s3 = peg$FAILED;
1504
+ }
1505
+ if (s3 !== peg$FAILED) {
1506
+ s2 = input.substring(s2, peg$currPos);
1507
+ }
1508
+ else {
1509
+ s2 = s3;
1510
+ }
1511
+ if (s2 !== peg$FAILED) {
1512
+ s3 = peg$parseEOL();
1513
+ if (s3 !== peg$FAILED) {
1514
+ peg$savedPos = s0;
1515
+ s1 = peg$c37();
1371
1516
  s0 = s1;
1372
1517
  }
1373
1518
  else {
@@ -1411,7 +1556,7 @@ function peg$parse(input, options) {
1411
1556
  s2 = peg$parseEOL();
1412
1557
  if (s2 !== peg$FAILED) {
1413
1558
  peg$savedPos = s0;
1414
- s1 = peg$c36();
1559
+ s1 = peg$c38();
1415
1560
  s0 = s1;
1416
1561
  }
1417
1562
  else {
@@ -1506,7 +1651,66 @@ function peg$parse(input, options) {
1506
1651
  s3 = peg$parseEOL();
1507
1652
  if (s3 !== peg$FAILED) {
1508
1653
  peg$savedPos = s0;
1509
- s1 = peg$c36();
1654
+ s1 = peg$c38();
1655
+ s0 = s1;
1656
+ }
1657
+ else {
1658
+ peg$currPos = s0;
1659
+ s0 = peg$FAILED;
1660
+ }
1661
+ }
1662
+ else {
1663
+ peg$currPos = s0;
1664
+ s0 = peg$FAILED;
1665
+ }
1666
+ }
1667
+ else {
1668
+ peg$currPos = s0;
1669
+ s0 = peg$FAILED;
1670
+ }
1671
+ return s0;
1672
+ }
1673
+ function peg$parseraw_line() {
1674
+ var s0, s1, s2, s3, s4;
1675
+ s0 = peg$currPos;
1676
+ s1 = peg$currPos;
1677
+ peg$silentFails++;
1678
+ s2 = peg$parseanyDirective();
1679
+ if (s2 === peg$FAILED) {
1680
+ s2 = peg$parseblankline();
1681
+ }
1682
+ peg$silentFails--;
1683
+ if (s2 === peg$FAILED) {
1684
+ s1 = void 0;
1685
+ }
1686
+ else {
1687
+ peg$currPos = s1;
1688
+ s1 = peg$FAILED;
1689
+ }
1690
+ if (s1 !== peg$FAILED) {
1691
+ s2 = peg$currPos;
1692
+ s3 = [];
1693
+ s4 = peg$parseText();
1694
+ if (s4 !== peg$FAILED) {
1695
+ while (s4 !== peg$FAILED) {
1696
+ s3.push(s4);
1697
+ s4 = peg$parseText();
1698
+ }
1699
+ }
1700
+ else {
1701
+ s3 = peg$FAILED;
1702
+ }
1703
+ if (s3 !== peg$FAILED) {
1704
+ s2 = input.substring(s2, peg$currPos);
1705
+ }
1706
+ else {
1707
+ s2 = s3;
1708
+ }
1709
+ if (s2 !== peg$FAILED) {
1710
+ s3 = peg$parseEOL();
1711
+ if (s3 !== peg$FAILED) {
1712
+ peg$savedPos = s0;
1713
+ s1 = peg$c38();
1510
1714
  s0 = s1;
1511
1715
  }
1512
1716
  else {
@@ -1620,7 +1824,7 @@ function peg$parse(input, options) {
1620
1824
  s2 = peg$parseEOL();
1621
1825
  if (s2 !== peg$FAILED) {
1622
1826
  peg$savedPos = s0;
1623
- s1 = peg$c37();
1827
+ s1 = peg$c39();
1624
1828
  s0 = s1;
1625
1829
  }
1626
1830
  else {
@@ -1654,7 +1858,7 @@ function peg$parse(input, options) {
1654
1858
  s3 = peg$parsearray_codes();
1655
1859
  if (s3 !== peg$FAILED) {
1656
1860
  peg$savedPos = s0;
1657
- s1 = peg$c38(s1, s3);
1861
+ s1 = peg$c40(s1, s3);
1658
1862
  s0 = s1;
1659
1863
  }
1660
1864
  else {
@@ -1676,7 +1880,7 @@ function peg$parse(input, options) {
1676
1880
  s1 = peg$parseFCode();
1677
1881
  if (s1 !== peg$FAILED) {
1678
1882
  peg$savedPos = s0;
1679
- s1 = peg$c39(s1);
1883
+ s1 = peg$c41(s1);
1680
1884
  }
1681
1885
  s0 = s1;
1682
1886
  }
@@ -1711,27 +1915,27 @@ function peg$parse(input, options) {
1711
1915
  }
1712
1916
  if (s2 !== peg$FAILED) {
1713
1917
  s3 = [];
1714
- if (peg$c40.test(input.charAt(peg$currPos))) {
1918
+ if (peg$c42.test(input.charAt(peg$currPos))) {
1715
1919
  s4 = input.charAt(peg$currPos);
1716
1920
  peg$currPos++;
1717
1921
  }
1718
1922
  else {
1719
1923
  s4 = peg$FAILED;
1720
1924
  if (peg$silentFails === 0) {
1721
- peg$fail(peg$c41);
1925
+ peg$fail(peg$c43);
1722
1926
  }
1723
1927
  }
1724
1928
  if (s4 !== peg$FAILED) {
1725
1929
  while (s4 !== peg$FAILED) {
1726
1930
  s3.push(s4);
1727
- if (peg$c40.test(input.charAt(peg$currPos))) {
1931
+ if (peg$c42.test(input.charAt(peg$currPos))) {
1728
1932
  s4 = input.charAt(peg$currPos);
1729
1933
  peg$currPos++;
1730
1934
  }
1731
1935
  else {
1732
1936
  s4 = peg$FAILED;
1733
1937
  if (peg$silentFails === 0) {
1734
- peg$fail(peg$c41);
1938
+ peg$fail(peg$c43);
1735
1939
  }
1736
1940
  }
1737
1941
  }
@@ -1814,13 +2018,13 @@ function peg$parse(input, options) {
1814
2018
  s3 = peg$parsegap();
1815
2019
  if (s3 !== peg$FAILED) {
1816
2020
  if (input.charCodeAt(peg$currPos) === 44) {
1817
- s4 = peg$c42;
2021
+ s4 = peg$c44;
1818
2022
  peg$currPos++;
1819
2023
  }
1820
2024
  else {
1821
2025
  s4 = peg$FAILED;
1822
2026
  if (peg$silentFails === 0) {
1823
- peg$fail(peg$c43);
2027
+ peg$fail(peg$c45);
1824
2028
  }
1825
2029
  }
1826
2030
  if (s4 !== peg$FAILED) {
@@ -1848,7 +2052,7 @@ function peg$parse(input, options) {
1848
2052
  s3 = peg$parsearray_items();
1849
2053
  if (s3 !== peg$FAILED) {
1850
2054
  peg$savedPos = s0;
1851
- s1 = peg$c44(s1, s3);
2055
+ s1 = peg$c46(s1, s3);
1852
2056
  s0 = s1;
1853
2057
  }
1854
2058
  else {
@@ -1870,7 +2074,7 @@ function peg$parse(input, options) {
1870
2074
  s1 = peg$parseitem();
1871
2075
  if (s1 !== peg$FAILED) {
1872
2076
  peg$savedPos = s0;
1873
- s1 = peg$c39(s1);
2077
+ s1 = peg$c41(s1);
1874
2078
  }
1875
2079
  s0 = s1;
1876
2080
  }
@@ -1881,27 +2085,27 @@ function peg$parse(input, options) {
1881
2085
  s0 = peg$currPos;
1882
2086
  s1 = peg$currPos;
1883
2087
  s2 = [];
1884
- if (peg$c45.test(input.charAt(peg$currPos))) {
2088
+ if (peg$c47.test(input.charAt(peg$currPos))) {
1885
2089
  s3 = input.charAt(peg$currPos);
1886
2090
  peg$currPos++;
1887
2091
  }
1888
2092
  else {
1889
2093
  s3 = peg$FAILED;
1890
2094
  if (peg$silentFails === 0) {
1891
- peg$fail(peg$c46);
2095
+ peg$fail(peg$c48);
1892
2096
  }
1893
2097
  }
1894
2098
  if (s3 !== peg$FAILED) {
1895
2099
  while (s3 !== peg$FAILED) {
1896
2100
  s2.push(s3);
1897
- if (peg$c45.test(input.charAt(peg$currPos))) {
2101
+ if (peg$c47.test(input.charAt(peg$currPos))) {
1898
2102
  s3 = input.charAt(peg$currPos);
1899
2103
  peg$currPos++;
1900
2104
  }
1901
2105
  else {
1902
2106
  s3 = peg$FAILED;
1903
2107
  if (peg$silentFails === 0) {
1904
- peg$fail(peg$c46);
2108
+ peg$fail(peg$c48);
1905
2109
  }
1906
2110
  }
1907
2111
  }
@@ -1911,26 +2115,26 @@ function peg$parse(input, options) {
1911
2115
  }
1912
2116
  if (s2 !== peg$FAILED) {
1913
2117
  s3 = [];
1914
- if (peg$c47.test(input.charAt(peg$currPos))) {
2118
+ if (peg$c49.test(input.charAt(peg$currPos))) {
1915
2119
  s4 = input.charAt(peg$currPos);
1916
2120
  peg$currPos++;
1917
2121
  }
1918
2122
  else {
1919
2123
  s4 = peg$FAILED;
1920
2124
  if (peg$silentFails === 0) {
1921
- peg$fail(peg$c48);
2125
+ peg$fail(peg$c50);
1922
2126
  }
1923
2127
  }
1924
2128
  while (s4 !== peg$FAILED) {
1925
2129
  s3.push(s4);
1926
- if (peg$c47.test(input.charAt(peg$currPos))) {
2130
+ if (peg$c49.test(input.charAt(peg$currPos))) {
1927
2131
  s4 = input.charAt(peg$currPos);
1928
2132
  peg$currPos++;
1929
2133
  }
1930
2134
  else {
1931
2135
  s4 = peg$FAILED;
1932
2136
  if (peg$silentFails === 0) {
1933
- peg$fail(peg$c48);
2137
+ peg$fail(peg$c50);
1934
2138
  }
1935
2139
  }
1936
2140
  }
@@ -1963,7 +2167,7 @@ function peg$parse(input, options) {
1963
2167
  s2 = peg$parseattributes();
1964
2168
  if (s2 !== peg$FAILED) {
1965
2169
  peg$savedPos = peg$currPos;
1966
- s3 = peg$c49(s2);
2170
+ s3 = peg$c51(s2);
1967
2171
  if (s3) {
1968
2172
  s3 = void 0;
1969
2173
  }
@@ -1972,7 +2176,7 @@ function peg$parse(input, options) {
1972
2176
  }
1973
2177
  if (s3 !== peg$FAILED) {
1974
2178
  peg$savedPos = s0;
1975
- s1 = peg$c50(s2);
2179
+ s1 = peg$c52(s2);
1976
2180
  s0 = s1;
1977
2181
  }
1978
2182
  else {
@@ -1998,24 +2202,24 @@ function peg$parse(input, options) {
1998
2202
  s3 = peg$parsegap();
1999
2203
  if (s3 !== peg$FAILED) {
2000
2204
  if (input.charCodeAt(peg$currPos) === 44) {
2001
- s4 = peg$c42;
2205
+ s4 = peg$c44;
2002
2206
  peg$currPos++;
2003
2207
  }
2004
2208
  else {
2005
2209
  s4 = peg$FAILED;
2006
2210
  if (peg$silentFails === 0) {
2007
- peg$fail(peg$c43);
2211
+ peg$fail(peg$c45);
2008
2212
  }
2009
2213
  }
2010
2214
  if (s4 === peg$FAILED) {
2011
- if (input.substr(peg$currPos, 2) === peg$c51) {
2012
- s4 = peg$c51;
2215
+ if (input.substr(peg$currPos, 2) === peg$c53) {
2216
+ s4 = peg$c53;
2013
2217
  peg$currPos += 2;
2014
2218
  }
2015
2219
  else {
2016
2220
  s4 = peg$FAILED;
2017
2221
  if (peg$silentFails === 0) {
2018
- peg$fail(peg$c52);
2222
+ peg$fail(peg$c54);
2019
2223
  }
2020
2224
  }
2021
2225
  }
@@ -2025,7 +2229,7 @@ function peg$parse(input, options) {
2025
2229
  s6 = peg$parseitem();
2026
2230
  if (s6 !== peg$FAILED) {
2027
2231
  peg$savedPos = s0;
2028
- s1 = peg$c53(s2, s6);
2232
+ s1 = peg$c55(s2, s6);
2029
2233
  s0 = s1;
2030
2234
  }
2031
2235
  else {
@@ -2068,13 +2272,13 @@ function peg$parse(input, options) {
2068
2272
  s2 = peg$parsegap();
2069
2273
  if (s2 !== peg$FAILED) {
2070
2274
  if (input.charCodeAt(peg$currPos) === 44) {
2071
- s3 = peg$c42;
2275
+ s3 = peg$c44;
2072
2276
  peg$currPos++;
2073
2277
  }
2074
2278
  else {
2075
2279
  s3 = peg$FAILED;
2076
2280
  if (peg$silentFails === 0) {
2077
- peg$fail(peg$c43);
2281
+ peg$fail(peg$c45);
2078
2282
  }
2079
2283
  }
2080
2284
  if (s3 !== peg$FAILED) {
@@ -2083,7 +2287,7 @@ function peg$parse(input, options) {
2083
2287
  s5 = peg$parsearray_pairs();
2084
2288
  if (s5 !== peg$FAILED) {
2085
2289
  peg$savedPos = s0;
2086
- s1 = peg$c54(s1, s5);
2290
+ s1 = peg$c56(s1, s5);
2087
2291
  s0 = s1;
2088
2292
  }
2089
2293
  else {
@@ -2115,7 +2319,7 @@ function peg$parse(input, options) {
2115
2319
  s1 = peg$parsepair_item();
2116
2320
  if (s1 !== peg$FAILED) {
2117
2321
  peg$savedPos = s0;
2118
- s1 = peg$c55(s1);
2322
+ s1 = peg$c57(s1);
2119
2323
  }
2120
2324
  s0 = s1;
2121
2325
  }
@@ -2127,50 +2331,50 @@ function peg$parse(input, options) {
2127
2331
  s1 = peg$parse_();
2128
2332
  if (s1 !== peg$FAILED) {
2129
2333
  if (input.charCodeAt(peg$currPos) === 58) {
2130
- s2 = peg$c56;
2334
+ s2 = peg$c58;
2131
2335
  peg$currPos++;
2132
2336
  }
2133
2337
  else {
2134
2338
  s2 = peg$FAILED;
2135
2339
  if (peg$silentFails === 0) {
2136
- peg$fail(peg$c57);
2340
+ peg$fail(peg$c59);
2137
2341
  }
2138
2342
  }
2139
2343
  if (s2 !== peg$FAILED) {
2140
- if (peg$c58.test(input.charAt(peg$currPos))) {
2344
+ if (peg$c60.test(input.charAt(peg$currPos))) {
2141
2345
  s3 = input.charAt(peg$currPos);
2142
2346
  peg$currPos++;
2143
2347
  }
2144
2348
  else {
2145
2349
  s3 = peg$FAILED;
2146
2350
  if (peg$silentFails === 0) {
2147
- peg$fail(peg$c59);
2351
+ peg$fail(peg$c61);
2148
2352
  }
2149
2353
  }
2150
2354
  if (s3 === peg$FAILED) {
2151
2355
  s3 = null;
2152
2356
  }
2153
2357
  if (s3 !== peg$FAILED) {
2154
- if (input.substr(peg$currPos, 5) === peg$c60) {
2155
- s4 = peg$c60;
2358
+ if (input.substr(peg$currPos, 5) === peg$c62) {
2359
+ s4 = peg$c62;
2156
2360
  peg$currPos += 5;
2157
2361
  }
2158
2362
  else {
2159
2363
  s4 = peg$FAILED;
2160
2364
  if (peg$silentFails === 0) {
2161
- peg$fail(peg$c61);
2365
+ peg$fail(peg$c63);
2162
2366
  }
2163
2367
  }
2164
2368
  if (s4 !== peg$FAILED) {
2165
2369
  s5 = peg$currPos;
2166
2370
  if (input.charCodeAt(peg$currPos) === 60) {
2167
- s6 = peg$c62;
2371
+ s6 = peg$c64;
2168
2372
  peg$currPos++;
2169
2373
  }
2170
2374
  else {
2171
2375
  s6 = peg$FAILED;
2172
2376
  if (peg$silentFails === 0) {
2173
- peg$fail(peg$c63);
2377
+ peg$fail(peg$c65);
2174
2378
  }
2175
2379
  }
2176
2380
  if (s6 !== peg$FAILED) {
@@ -2181,18 +2385,18 @@ function peg$parse(input, options) {
2181
2385
  s9 = peg$parse_();
2182
2386
  if (s9 !== peg$FAILED) {
2183
2387
  if (input.charCodeAt(peg$currPos) === 62) {
2184
- s10 = peg$c64;
2388
+ s10 = peg$c66;
2185
2389
  peg$currPos++;
2186
2390
  }
2187
2391
  else {
2188
2392
  s10 = peg$FAILED;
2189
2393
  if (peg$silentFails === 0) {
2190
- peg$fail(peg$c65);
2394
+ peg$fail(peg$c67);
2191
2395
  }
2192
2396
  }
2193
2397
  if (s10 !== peg$FAILED) {
2194
2398
  peg$savedPos = s5;
2195
- s6 = peg$c66(s3, s4, s8);
2399
+ s6 = peg$c68(s3, s4, s8);
2196
2400
  s5 = s6;
2197
2401
  }
2198
2402
  else {
@@ -2222,31 +2426,31 @@ function peg$parse(input, options) {
2222
2426
  if (s5 === peg$FAILED) {
2223
2427
  s5 = peg$currPos;
2224
2428
  if (input.charCodeAt(peg$currPos) === 60) {
2225
- s6 = peg$c62;
2429
+ s6 = peg$c64;
2226
2430
  peg$currPos++;
2227
2431
  }
2228
2432
  else {
2229
2433
  s6 = peg$FAILED;
2230
2434
  if (peg$silentFails === 0) {
2231
- peg$fail(peg$c63);
2435
+ peg$fail(peg$c65);
2232
2436
  }
2233
2437
  }
2234
2438
  if (s6 !== peg$FAILED) {
2235
2439
  s7 = peg$parse_();
2236
2440
  if (s7 !== peg$FAILED) {
2237
2441
  if (input.charCodeAt(peg$currPos) === 62) {
2238
- s8 = peg$c64;
2442
+ s8 = peg$c66;
2239
2443
  peg$currPos++;
2240
2444
  }
2241
2445
  else {
2242
2446
  s8 = peg$FAILED;
2243
2447
  if (peg$silentFails === 0) {
2244
- peg$fail(peg$c65);
2448
+ peg$fail(peg$c67);
2245
2449
  }
2246
2450
  }
2247
2451
  if (s8 !== peg$FAILED) {
2248
2452
  peg$savedPos = s5;
2249
- s6 = peg$c67(s3, s4);
2453
+ s6 = peg$c69(s3, s4);
2250
2454
  s5 = s6;
2251
2455
  }
2252
2456
  else {
@@ -2268,7 +2472,7 @@ function peg$parse(input, options) {
2268
2472
  s6 = peg$parse_();
2269
2473
  if (s6 !== peg$FAILED) {
2270
2474
  peg$savedPos = s0;
2271
- s1 = peg$c68(s3, s4, s5);
2475
+ s1 = peg$c70(s3, s4, s5);
2272
2476
  s0 = s1;
2273
2477
  }
2274
2478
  else {
@@ -2306,27 +2510,27 @@ function peg$parse(input, options) {
2306
2510
  var s0, s1, s2;
2307
2511
  s0 = peg$currPos;
2308
2512
  s1 = [];
2309
- if (peg$c69.test(input.charAt(peg$currPos))) {
2513
+ if (peg$c71.test(input.charAt(peg$currPos))) {
2310
2514
  s2 = input.charAt(peg$currPos);
2311
2515
  peg$currPos++;
2312
2516
  }
2313
2517
  else {
2314
2518
  s2 = peg$FAILED;
2315
2519
  if (peg$silentFails === 0) {
2316
- peg$fail(peg$c70);
2520
+ peg$fail(peg$c72);
2317
2521
  }
2318
2522
  }
2319
2523
  if (s2 !== peg$FAILED) {
2320
2524
  while (s2 !== peg$FAILED) {
2321
2525
  s1.push(s2);
2322
- if (peg$c69.test(input.charAt(peg$currPos))) {
2526
+ if (peg$c71.test(input.charAt(peg$currPos))) {
2323
2527
  s2 = input.charAt(peg$currPos);
2324
2528
  peg$currPos++;
2325
2529
  }
2326
2530
  else {
2327
2531
  s2 = peg$FAILED;
2328
2532
  if (peg$silentFails === 0) {
2329
- peg$fail(peg$c70);
2533
+ peg$fail(peg$c72);
2330
2534
  }
2331
2535
  }
2332
2536
  }
@@ -2372,7 +2576,7 @@ function peg$parse(input, options) {
2372
2576
  s5 = peg$parselistItem();
2373
2577
  if (s5 !== peg$FAILED) {
2374
2578
  peg$savedPos = s3;
2375
- s4 = peg$c71(s1, s5);
2579
+ s4 = peg$c73(s1, s5);
2376
2580
  s3 = s4;
2377
2581
  }
2378
2582
  else {
@@ -2403,7 +2607,7 @@ function peg$parse(input, options) {
2403
2607
  s5 = peg$parselistItem();
2404
2608
  if (s5 !== peg$FAILED) {
2405
2609
  peg$savedPos = s3;
2406
- s4 = peg$c71(s1, s5);
2610
+ s4 = peg$c73(s1, s5);
2407
2611
  s3 = s4;
2408
2612
  }
2409
2613
  else {
@@ -2422,7 +2626,7 @@ function peg$parse(input, options) {
2422
2626
  }
2423
2627
  if (s2 !== peg$FAILED) {
2424
2628
  peg$savedPos = s0;
2425
- s1 = peg$c72(s1, s2);
2629
+ s1 = peg$c74(s1, s2);
2426
2630
  s0 = s1;
2427
2631
  }
2428
2632
  else {
@@ -2448,7 +2652,7 @@ function peg$parse(input, options) {
2448
2652
  s5 = peg$parse_();
2449
2653
  if (s5 !== peg$FAILED) {
2450
2654
  peg$savedPos = s2;
2451
- s3 = peg$c73(s4);
2655
+ s3 = peg$c75(s4);
2452
2656
  s2 = s3;
2453
2657
  }
2454
2658
  else {
@@ -2475,7 +2679,7 @@ function peg$parse(input, options) {
2475
2679
  s5 = peg$parse_();
2476
2680
  if (s5 !== peg$FAILED) {
2477
2681
  peg$savedPos = s2;
2478
- s3 = peg$c73(s4);
2682
+ s3 = peg$c75(s4);
2479
2683
  s2 = s3;
2480
2684
  }
2481
2685
  else {
@@ -2495,7 +2699,7 @@ function peg$parse(input, options) {
2495
2699
  }
2496
2700
  if (s1 !== peg$FAILED) {
2497
2701
  peg$savedPos = s0;
2498
- s1 = peg$c74(s1);
2702
+ s1 = peg$c76(s1);
2499
2703
  }
2500
2704
  s0 = s1;
2501
2705
  if (s0 === peg$FAILED) {
@@ -2503,7 +2707,7 @@ function peg$parse(input, options) {
2503
2707
  s1 = peg$parseitem();
2504
2708
  if (s1 !== peg$FAILED) {
2505
2709
  peg$savedPos = s0;
2506
- s1 = peg$c75(s1);
2710
+ s1 = peg$c77(s1);
2507
2711
  }
2508
2712
  s0 = s1;
2509
2713
  if (s0 === peg$FAILED) {
@@ -2511,7 +2715,7 @@ function peg$parse(input, options) {
2511
2715
  s1 = peg$parse_();
2512
2716
  if (s1 !== peg$FAILED) {
2513
2717
  peg$savedPos = s0;
2514
- s1 = peg$c76();
2718
+ s1 = peg$c78();
2515
2719
  }
2516
2720
  s0 = s1;
2517
2721
  }
@@ -2526,24 +2730,24 @@ function peg$parse(input, options) {
2526
2730
  s1 = peg$parse_();
2527
2731
  if (s1 !== peg$FAILED) {
2528
2732
  if (input.charCodeAt(peg$currPos) === 58) {
2529
- s2 = peg$c56;
2733
+ s2 = peg$c58;
2530
2734
  peg$currPos++;
2531
2735
  }
2532
2736
  else {
2533
2737
  s2 = peg$FAILED;
2534
2738
  if (peg$silentFails === 0) {
2535
- peg$fail(peg$c57);
2739
+ peg$fail(peg$c59);
2536
2740
  }
2537
2741
  }
2538
2742
  if (s2 !== peg$FAILED) {
2539
- if (peg$c58.test(input.charAt(peg$currPos))) {
2743
+ if (peg$c60.test(input.charAt(peg$currPos))) {
2540
2744
  s3 = input.charAt(peg$currPos);
2541
2745
  peg$currPos++;
2542
2746
  }
2543
2747
  else {
2544
2748
  s3 = peg$FAILED;
2545
2749
  if (peg$silentFails === 0) {
2546
- peg$fail(peg$c59);
2750
+ peg$fail(peg$c61);
2547
2751
  }
2548
2752
  }
2549
2753
  if (s3 === peg$FAILED) {
@@ -2554,13 +2758,13 @@ function peg$parse(input, options) {
2554
2758
  if (s4 !== peg$FAILED) {
2555
2759
  s5 = peg$currPos;
2556
2760
  if (input.charCodeAt(peg$currPos) === 123) {
2557
- s6 = peg$c77;
2761
+ s6 = peg$c79;
2558
2762
  peg$currPos++;
2559
2763
  }
2560
2764
  else {
2561
2765
  s6 = peg$FAILED;
2562
2766
  if (peg$silentFails === 0) {
2563
- peg$fail(peg$c78);
2767
+ peg$fail(peg$c80);
2564
2768
  }
2565
2769
  }
2566
2770
  if (s6 !== peg$FAILED) {
@@ -2571,18 +2775,18 @@ function peg$parse(input, options) {
2571
2775
  s9 = peg$parsegap();
2572
2776
  if (s9 !== peg$FAILED) {
2573
2777
  if (input.charCodeAt(peg$currPos) === 125) {
2574
- s10 = peg$c79;
2778
+ s10 = peg$c81;
2575
2779
  peg$currPos++;
2576
2780
  }
2577
2781
  else {
2578
2782
  s10 = peg$FAILED;
2579
2783
  if (peg$silentFails === 0) {
2580
- peg$fail(peg$c80);
2784
+ peg$fail(peg$c82);
2581
2785
  }
2582
2786
  }
2583
2787
  if (s10 !== peg$FAILED) {
2584
2788
  peg$savedPos = s5;
2585
- s6 = peg$c81(s3, s4, s8);
2789
+ s6 = peg$c83(s3, s4, s8);
2586
2790
  s5 = s6;
2587
2791
  }
2588
2792
  else {
@@ -2612,31 +2816,31 @@ function peg$parse(input, options) {
2612
2816
  if (s5 === peg$FAILED) {
2613
2817
  s5 = peg$currPos;
2614
2818
  if (input.charCodeAt(peg$currPos) === 123) {
2615
- s6 = peg$c77;
2819
+ s6 = peg$c79;
2616
2820
  peg$currPos++;
2617
2821
  }
2618
2822
  else {
2619
2823
  s6 = peg$FAILED;
2620
2824
  if (peg$silentFails === 0) {
2621
- peg$fail(peg$c78);
2825
+ peg$fail(peg$c80);
2622
2826
  }
2623
2827
  }
2624
2828
  if (s6 !== peg$FAILED) {
2625
2829
  s7 = peg$parsegap();
2626
2830
  if (s7 !== peg$FAILED) {
2627
2831
  if (input.charCodeAt(peg$currPos) === 125) {
2628
- s8 = peg$c79;
2832
+ s8 = peg$c81;
2629
2833
  peg$currPos++;
2630
2834
  }
2631
2835
  else {
2632
2836
  s8 = peg$FAILED;
2633
2837
  if (peg$silentFails === 0) {
2634
- peg$fail(peg$c80);
2838
+ peg$fail(peg$c82);
2635
2839
  }
2636
2840
  }
2637
2841
  if (s8 !== peg$FAILED) {
2638
2842
  peg$savedPos = s5;
2639
- s6 = peg$c82(s3, s4);
2843
+ s6 = peg$c84(s3, s4);
2640
2844
  s5 = s6;
2641
2845
  }
2642
2846
  else {
@@ -2656,13 +2860,13 @@ function peg$parse(input, options) {
2656
2860
  if (s5 === peg$FAILED) {
2657
2861
  s5 = peg$currPos;
2658
2862
  if (input.charCodeAt(peg$currPos) === 123) {
2659
- s6 = peg$c77;
2863
+ s6 = peg$c79;
2660
2864
  peg$currPos++;
2661
2865
  }
2662
2866
  else {
2663
2867
  s6 = peg$FAILED;
2664
2868
  if (peg$silentFails === 0) {
2665
- peg$fail(peg$c78);
2869
+ peg$fail(peg$c80);
2666
2870
  }
2667
2871
  }
2668
2872
  if (s6 !== peg$FAILED) {
@@ -2672,13 +2876,13 @@ function peg$parse(input, options) {
2672
2876
  s10 = peg$currPos;
2673
2877
  peg$silentFails++;
2674
2878
  if (input.charCodeAt(peg$currPos) === 125) {
2675
- s11 = peg$c79;
2879
+ s11 = peg$c81;
2676
2880
  peg$currPos++;
2677
2881
  }
2678
2882
  else {
2679
2883
  s11 = peg$FAILED;
2680
2884
  if (peg$silentFails === 0) {
2681
- peg$fail(peg$c80);
2885
+ peg$fail(peg$c82);
2682
2886
  }
2683
2887
  }
2684
2888
  if (s11 === peg$FAILED) {
@@ -2722,13 +2926,13 @@ function peg$parse(input, options) {
2722
2926
  s10 = peg$currPos;
2723
2927
  peg$silentFails++;
2724
2928
  if (input.charCodeAt(peg$currPos) === 125) {
2725
- s11 = peg$c79;
2929
+ s11 = peg$c81;
2726
2930
  peg$currPos++;
2727
2931
  }
2728
2932
  else {
2729
2933
  s11 = peg$FAILED;
2730
2934
  if (peg$silentFails === 0) {
2731
- peg$fail(peg$c80);
2935
+ peg$fail(peg$c82);
2732
2936
  }
2733
2937
  }
2734
2938
  if (s11 === peg$FAILED) {
@@ -2775,18 +2979,18 @@ function peg$parse(input, options) {
2775
2979
  }
2776
2980
  if (s7 !== peg$FAILED) {
2777
2981
  if (input.charCodeAt(peg$currPos) === 125) {
2778
- s8 = peg$c79;
2982
+ s8 = peg$c81;
2779
2983
  peg$currPos++;
2780
2984
  }
2781
2985
  else {
2782
2986
  s8 = peg$FAILED;
2783
2987
  if (peg$silentFails === 0) {
2784
- peg$fail(peg$c80);
2988
+ peg$fail(peg$c82);
2785
2989
  }
2786
2990
  }
2787
2991
  if (s8 !== peg$FAILED) {
2788
2992
  peg$savedPos = s5;
2789
- s6 = peg$c83(s3, s4);
2993
+ s6 = peg$c85(s3, s4);
2790
2994
  s5 = s6;
2791
2995
  }
2792
2996
  else {
@@ -2806,13 +3010,13 @@ function peg$parse(input, options) {
2806
3010
  if (s5 === peg$FAILED) {
2807
3011
  s5 = peg$currPos;
2808
3012
  if (input.charCodeAt(peg$currPos) === 91) {
2809
- s6 = peg$c84;
3013
+ s6 = peg$c86;
2810
3014
  peg$currPos++;
2811
3015
  }
2812
3016
  else {
2813
3017
  s6 = peg$FAILED;
2814
3018
  if (peg$silentFails === 0) {
2815
- peg$fail(peg$c85);
3019
+ peg$fail(peg$c87);
2816
3020
  }
2817
3021
  }
2818
3022
  if (s6 !== peg$FAILED) {
@@ -2822,13 +3026,13 @@ function peg$parse(input, options) {
2822
3026
  s10 = peg$currPos;
2823
3027
  peg$silentFails++;
2824
3028
  if (input.charCodeAt(peg$currPos) === 93) {
2825
- s11 = peg$c86;
3029
+ s11 = peg$c88;
2826
3030
  peg$currPos++;
2827
3031
  }
2828
3032
  else {
2829
3033
  s11 = peg$FAILED;
2830
3034
  if (peg$silentFails === 0) {
2831
- peg$fail(peg$c87);
3035
+ peg$fail(peg$c89);
2832
3036
  }
2833
3037
  }
2834
3038
  if (s11 === peg$FAILED) {
@@ -2872,13 +3076,13 @@ function peg$parse(input, options) {
2872
3076
  s10 = peg$currPos;
2873
3077
  peg$silentFails++;
2874
3078
  if (input.charCodeAt(peg$currPos) === 93) {
2875
- s11 = peg$c86;
3079
+ s11 = peg$c88;
2876
3080
  peg$currPos++;
2877
3081
  }
2878
3082
  else {
2879
3083
  s11 = peg$FAILED;
2880
3084
  if (peg$silentFails === 0) {
2881
- peg$fail(peg$c87);
3085
+ peg$fail(peg$c89);
2882
3086
  }
2883
3087
  }
2884
3088
  if (s11 === peg$FAILED) {
@@ -2925,18 +3129,18 @@ function peg$parse(input, options) {
2925
3129
  }
2926
3130
  if (s7 !== peg$FAILED) {
2927
3131
  if (input.charCodeAt(peg$currPos) === 93) {
2928
- s8 = peg$c86;
3132
+ s8 = peg$c88;
2929
3133
  peg$currPos++;
2930
3134
  }
2931
3135
  else {
2932
3136
  s8 = peg$FAILED;
2933
3137
  if (peg$silentFails === 0) {
2934
- peg$fail(peg$c87);
3138
+ peg$fail(peg$c89);
2935
3139
  }
2936
3140
  }
2937
3141
  if (s8 !== peg$FAILED) {
2938
3142
  peg$savedPos = s5;
2939
- s6 = peg$c88(s3, s4);
3143
+ s6 = peg$c90(s3, s4);
2940
3144
  s5 = s6;
2941
3145
  }
2942
3146
  else {
@@ -2956,13 +3160,13 @@ function peg$parse(input, options) {
2956
3160
  if (s5 === peg$FAILED) {
2957
3161
  s5 = peg$currPos;
2958
3162
  if (input.charCodeAt(peg$currPos) === 60) {
2959
- s6 = peg$c62;
3163
+ s6 = peg$c64;
2960
3164
  peg$currPos++;
2961
3165
  }
2962
3166
  else {
2963
3167
  s6 = peg$FAILED;
2964
3168
  if (peg$silentFails === 0) {
2965
- peg$fail(peg$c63);
3169
+ peg$fail(peg$c65);
2966
3170
  }
2967
3171
  }
2968
3172
  if (s6 !== peg$FAILED) {
@@ -2973,18 +3177,18 @@ function peg$parse(input, options) {
2973
3177
  s9 = peg$parse_();
2974
3178
  if (s9 !== peg$FAILED) {
2975
3179
  if (input.charCodeAt(peg$currPos) === 62) {
2976
- s10 = peg$c64;
3180
+ s10 = peg$c66;
2977
3181
  peg$currPos++;
2978
3182
  }
2979
3183
  else {
2980
3184
  s10 = peg$FAILED;
2981
3185
  if (peg$silentFails === 0) {
2982
- peg$fail(peg$c65);
3186
+ peg$fail(peg$c67);
2983
3187
  }
2984
3188
  }
2985
3189
  if (s10 !== peg$FAILED) {
2986
3190
  peg$savedPos = s5;
2987
- s6 = peg$c89(s3, s4, s8);
3191
+ s6 = peg$c91(s3, s4, s8);
2988
3192
  s5 = s6;
2989
3193
  }
2990
3194
  else {
@@ -3014,51 +3218,51 @@ function peg$parse(input, options) {
3014
3218
  if (s5 === peg$FAILED) {
3015
3219
  s5 = peg$currPos;
3016
3220
  if (input.charCodeAt(peg$currPos) === 60) {
3017
- s6 = peg$c62;
3221
+ s6 = peg$c64;
3018
3222
  peg$currPos++;
3019
3223
  }
3020
3224
  else {
3021
3225
  s6 = peg$FAILED;
3022
3226
  if (peg$silentFails === 0) {
3023
- peg$fail(peg$c63);
3227
+ peg$fail(peg$c65);
3024
3228
  }
3025
3229
  }
3026
3230
  if (s6 !== peg$FAILED) {
3027
3231
  s7 = peg$parse_();
3028
3232
  if (s7 !== peg$FAILED) {
3029
- if (peg$c90.test(input.charAt(peg$currPos))) {
3233
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3030
3234
  s8 = input.charAt(peg$currPos);
3031
3235
  peg$currPos++;
3032
3236
  }
3033
3237
  else {
3034
3238
  s8 = peg$FAILED;
3035
3239
  if (peg$silentFails === 0) {
3036
- peg$fail(peg$c91);
3240
+ peg$fail(peg$c93);
3037
3241
  }
3038
3242
  }
3039
3243
  if (s8 !== peg$FAILED) {
3040
3244
  s9 = peg$currPos;
3041
3245
  s10 = [];
3042
- if (peg$c92.test(input.charAt(peg$currPos))) {
3246
+ if (peg$c94.test(input.charAt(peg$currPos))) {
3043
3247
  s11 = input.charAt(peg$currPos);
3044
3248
  peg$currPos++;
3045
3249
  }
3046
3250
  else {
3047
3251
  s11 = peg$FAILED;
3048
3252
  if (peg$silentFails === 0) {
3049
- peg$fail(peg$c93);
3253
+ peg$fail(peg$c95);
3050
3254
  }
3051
3255
  }
3052
3256
  while (s11 !== peg$FAILED) {
3053
3257
  s10.push(s11);
3054
- if (peg$c92.test(input.charAt(peg$currPos))) {
3258
+ if (peg$c94.test(input.charAt(peg$currPos))) {
3055
3259
  s11 = input.charAt(peg$currPos);
3056
3260
  peg$currPos++;
3057
3261
  }
3058
3262
  else {
3059
3263
  s11 = peg$FAILED;
3060
3264
  if (peg$silentFails === 0) {
3061
- peg$fail(peg$c93);
3265
+ peg$fail(peg$c95);
3062
3266
  }
3063
3267
  }
3064
3268
  }
@@ -3069,32 +3273,32 @@ function peg$parse(input, options) {
3069
3273
  s9 = s10;
3070
3274
  }
3071
3275
  if (s9 !== peg$FAILED) {
3072
- if (peg$c90.test(input.charAt(peg$currPos))) {
3276
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3073
3277
  s10 = input.charAt(peg$currPos);
3074
3278
  peg$currPos++;
3075
3279
  }
3076
3280
  else {
3077
3281
  s10 = peg$FAILED;
3078
3282
  if (peg$silentFails === 0) {
3079
- peg$fail(peg$c91);
3283
+ peg$fail(peg$c93);
3080
3284
  }
3081
3285
  }
3082
3286
  if (s10 !== peg$FAILED) {
3083
3287
  s11 = peg$parse_();
3084
3288
  if (s11 !== peg$FAILED) {
3085
3289
  if (input.charCodeAt(peg$currPos) === 62) {
3086
- s12 = peg$c64;
3290
+ s12 = peg$c66;
3087
3291
  peg$currPos++;
3088
3292
  }
3089
3293
  else {
3090
3294
  s12 = peg$FAILED;
3091
3295
  if (peg$silentFails === 0) {
3092
- peg$fail(peg$c65);
3296
+ peg$fail(peg$c67);
3093
3297
  }
3094
3298
  }
3095
3299
  if (s12 !== peg$FAILED) {
3096
3300
  peg$savedPos = s5;
3097
- s6 = peg$c94(s3, s4, s9);
3301
+ s6 = peg$c96(s3, s4, s9);
3098
3302
  s5 = s6;
3099
3303
  }
3100
3304
  else {
@@ -3134,51 +3338,51 @@ function peg$parse(input, options) {
3134
3338
  if (s5 === peg$FAILED) {
3135
3339
  s5 = peg$currPos;
3136
3340
  if (input.charCodeAt(peg$currPos) === 60) {
3137
- s6 = peg$c62;
3341
+ s6 = peg$c64;
3138
3342
  peg$currPos++;
3139
3343
  }
3140
3344
  else {
3141
3345
  s6 = peg$FAILED;
3142
3346
  if (peg$silentFails === 0) {
3143
- peg$fail(peg$c63);
3347
+ peg$fail(peg$c65);
3144
3348
  }
3145
3349
  }
3146
3350
  if (s6 !== peg$FAILED) {
3147
3351
  s7 = peg$parse_();
3148
3352
  if (s7 !== peg$FAILED) {
3149
- if (peg$c95.test(input.charAt(peg$currPos))) {
3353
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3150
3354
  s8 = input.charAt(peg$currPos);
3151
3355
  peg$currPos++;
3152
3356
  }
3153
3357
  else {
3154
3358
  s8 = peg$FAILED;
3155
3359
  if (peg$silentFails === 0) {
3156
- peg$fail(peg$c96);
3360
+ peg$fail(peg$c98);
3157
3361
  }
3158
3362
  }
3159
3363
  if (s8 !== peg$FAILED) {
3160
3364
  s9 = peg$currPos;
3161
3365
  s10 = [];
3162
- if (peg$c97.test(input.charAt(peg$currPos))) {
3366
+ if (peg$c99.test(input.charAt(peg$currPos))) {
3163
3367
  s11 = input.charAt(peg$currPos);
3164
3368
  peg$currPos++;
3165
3369
  }
3166
3370
  else {
3167
3371
  s11 = peg$FAILED;
3168
3372
  if (peg$silentFails === 0) {
3169
- peg$fail(peg$c98);
3373
+ peg$fail(peg$c100);
3170
3374
  }
3171
3375
  }
3172
3376
  while (s11 !== peg$FAILED) {
3173
3377
  s10.push(s11);
3174
- if (peg$c97.test(input.charAt(peg$currPos))) {
3378
+ if (peg$c99.test(input.charAt(peg$currPos))) {
3175
3379
  s11 = input.charAt(peg$currPos);
3176
3380
  peg$currPos++;
3177
3381
  }
3178
3382
  else {
3179
3383
  s11 = peg$FAILED;
3180
3384
  if (peg$silentFails === 0) {
3181
- peg$fail(peg$c98);
3385
+ peg$fail(peg$c100);
3182
3386
  }
3183
3387
  }
3184
3388
  }
@@ -3189,32 +3393,32 @@ function peg$parse(input, options) {
3189
3393
  s9 = s10;
3190
3394
  }
3191
3395
  if (s9 !== peg$FAILED) {
3192
- if (peg$c95.test(input.charAt(peg$currPos))) {
3396
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3193
3397
  s10 = input.charAt(peg$currPos);
3194
3398
  peg$currPos++;
3195
3399
  }
3196
3400
  else {
3197
3401
  s10 = peg$FAILED;
3198
3402
  if (peg$silentFails === 0) {
3199
- peg$fail(peg$c96);
3403
+ peg$fail(peg$c98);
3200
3404
  }
3201
3405
  }
3202
3406
  if (s10 !== peg$FAILED) {
3203
3407
  s11 = peg$parse_();
3204
3408
  if (s11 !== peg$FAILED) {
3205
3409
  if (input.charCodeAt(peg$currPos) === 62) {
3206
- s12 = peg$c64;
3410
+ s12 = peg$c66;
3207
3411
  peg$currPos++;
3208
3412
  }
3209
3413
  else {
3210
3414
  s12 = peg$FAILED;
3211
3415
  if (peg$silentFails === 0) {
3212
- peg$fail(peg$c65);
3416
+ peg$fail(peg$c67);
3213
3417
  }
3214
3418
  }
3215
3419
  if (s12 !== peg$FAILED) {
3216
3420
  peg$savedPos = s5;
3217
- s6 = peg$c94(s3, s4, s9);
3421
+ s6 = peg$c96(s3, s4, s9);
3218
3422
  s5 = s6;
3219
3423
  }
3220
3424
  else {
@@ -3254,13 +3458,13 @@ function peg$parse(input, options) {
3254
3458
  if (s5 === peg$FAILED) {
3255
3459
  s5 = peg$currPos;
3256
3460
  if (input.charCodeAt(peg$currPos) === 60) {
3257
- s6 = peg$c62;
3461
+ s6 = peg$c64;
3258
3462
  peg$currPos++;
3259
3463
  }
3260
3464
  else {
3261
3465
  s6 = peg$FAILED;
3262
3466
  if (peg$silentFails === 0) {
3263
- peg$fail(peg$c63);
3467
+ peg$fail(peg$c65);
3264
3468
  }
3265
3469
  }
3266
3470
  if (s6 !== peg$FAILED) {
@@ -3272,24 +3476,24 @@ function peg$parse(input, options) {
3272
3476
  s11 = peg$currPos;
3273
3477
  peg$silentFails++;
3274
3478
  if (input.charCodeAt(peg$currPos) === 60) {
3275
- s12 = peg$c62;
3479
+ s12 = peg$c64;
3276
3480
  peg$currPos++;
3277
3481
  }
3278
3482
  else {
3279
3483
  s12 = peg$FAILED;
3280
3484
  if (peg$silentFails === 0) {
3281
- peg$fail(peg$c63);
3485
+ peg$fail(peg$c65);
3282
3486
  }
3283
3487
  }
3284
3488
  if (s12 === peg$FAILED) {
3285
3489
  if (input.charCodeAt(peg$currPos) === 62) {
3286
- s12 = peg$c64;
3490
+ s12 = peg$c66;
3287
3491
  peg$currPos++;
3288
3492
  }
3289
3493
  else {
3290
3494
  s12 = peg$FAILED;
3291
3495
  if (peg$silentFails === 0) {
3292
- peg$fail(peg$c65);
3496
+ peg$fail(peg$c67);
3293
3497
  }
3294
3498
  }
3295
3499
  if (s12 === peg$FAILED) {
@@ -3335,24 +3539,24 @@ function peg$parse(input, options) {
3335
3539
  s11 = peg$currPos;
3336
3540
  peg$silentFails++;
3337
3541
  if (input.charCodeAt(peg$currPos) === 60) {
3338
- s12 = peg$c62;
3542
+ s12 = peg$c64;
3339
3543
  peg$currPos++;
3340
3544
  }
3341
3545
  else {
3342
3546
  s12 = peg$FAILED;
3343
3547
  if (peg$silentFails === 0) {
3344
- peg$fail(peg$c63);
3548
+ peg$fail(peg$c65);
3345
3549
  }
3346
3550
  }
3347
3551
  if (s12 === peg$FAILED) {
3348
3552
  if (input.charCodeAt(peg$currPos) === 62) {
3349
- s12 = peg$c64;
3553
+ s12 = peg$c66;
3350
3554
  peg$currPos++;
3351
3555
  }
3352
3556
  else {
3353
3557
  s12 = peg$FAILED;
3354
3558
  if (peg$silentFails === 0) {
3355
- peg$fail(peg$c65);
3559
+ peg$fail(peg$c67);
3356
3560
  }
3357
3561
  }
3358
3562
  if (s12 === peg$FAILED) {
@@ -3404,18 +3608,18 @@ function peg$parse(input, options) {
3404
3608
  }
3405
3609
  if (s8 !== peg$FAILED) {
3406
3610
  if (input.charCodeAt(peg$currPos) === 62) {
3407
- s9 = peg$c64;
3611
+ s9 = peg$c66;
3408
3612
  peg$currPos++;
3409
3613
  }
3410
3614
  else {
3411
3615
  s9 = peg$FAILED;
3412
3616
  if (peg$silentFails === 0) {
3413
- peg$fail(peg$c65);
3617
+ peg$fail(peg$c67);
3414
3618
  }
3415
3619
  }
3416
3620
  if (s9 !== peg$FAILED) {
3417
3621
  peg$savedPos = s5;
3418
- s6 = peg$c99(s3, s4, s8);
3622
+ s6 = peg$c101(s3, s4, s8);
3419
3623
  s5 = s6;
3420
3624
  }
3421
3625
  else {
@@ -3440,31 +3644,31 @@ function peg$parse(input, options) {
3440
3644
  if (s5 === peg$FAILED) {
3441
3645
  s5 = peg$currPos;
3442
3646
  if (input.charCodeAt(peg$currPos) === 60) {
3443
- s6 = peg$c62;
3647
+ s6 = peg$c64;
3444
3648
  peg$currPos++;
3445
3649
  }
3446
3650
  else {
3447
3651
  s6 = peg$FAILED;
3448
3652
  if (peg$silentFails === 0) {
3449
- peg$fail(peg$c63);
3653
+ peg$fail(peg$c65);
3450
3654
  }
3451
3655
  }
3452
3656
  if (s6 !== peg$FAILED) {
3453
3657
  s7 = peg$parse_();
3454
3658
  if (s7 !== peg$FAILED) {
3455
3659
  if (input.charCodeAt(peg$currPos) === 62) {
3456
- s8 = peg$c64;
3660
+ s8 = peg$c66;
3457
3661
  peg$currPos++;
3458
3662
  }
3459
3663
  else {
3460
3664
  s8 = peg$FAILED;
3461
3665
  if (peg$silentFails === 0) {
3462
- peg$fail(peg$c65);
3666
+ peg$fail(peg$c67);
3463
3667
  }
3464
3668
  }
3465
3669
  if (s8 !== peg$FAILED) {
3466
3670
  peg$savedPos = s5;
3467
- s6 = peg$c100(s3, s4);
3671
+ s6 = peg$c102(s3, s4);
3468
3672
  s5 = s6;
3469
3673
  }
3470
3674
  else {
@@ -3484,13 +3688,13 @@ function peg$parse(input, options) {
3484
3688
  if (s5 === peg$FAILED) {
3485
3689
  s5 = peg$currPos;
3486
3690
  if (input.charCodeAt(peg$currPos) === 40) {
3487
- s6 = peg$c101;
3691
+ s6 = peg$c103;
3488
3692
  peg$currPos++;
3489
3693
  }
3490
3694
  else {
3491
3695
  s6 = peg$FAILED;
3492
3696
  if (peg$silentFails === 0) {
3493
- peg$fail(peg$c102);
3697
+ peg$fail(peg$c104);
3494
3698
  }
3495
3699
  }
3496
3700
  if (s6 !== peg$FAILED) {
@@ -3500,25 +3704,25 @@ function peg$parse(input, options) {
3500
3704
  s9 = peg$parsearray_items();
3501
3705
  if (s9 !== peg$FAILED) {
3502
3706
  peg$savedPos = s8;
3503
- s9 = peg$c103(s3, s4, s9);
3707
+ s9 = peg$c105(s3, s4, s9);
3504
3708
  }
3505
3709
  s8 = s9;
3506
3710
  if (s8 !== peg$FAILED) {
3507
3711
  s9 = peg$parsegap();
3508
3712
  if (s9 !== peg$FAILED) {
3509
3713
  if (input.charCodeAt(peg$currPos) === 41) {
3510
- s10 = peg$c104;
3714
+ s10 = peg$c106;
3511
3715
  peg$currPos++;
3512
3716
  }
3513
3717
  else {
3514
3718
  s10 = peg$FAILED;
3515
3719
  if (peg$silentFails === 0) {
3516
- peg$fail(peg$c105);
3720
+ peg$fail(peg$c107);
3517
3721
  }
3518
3722
  }
3519
3723
  if (s10 !== peg$FAILED) {
3520
3724
  peg$savedPos = s5;
3521
- s6 = peg$c106(s3, s4, s8);
3725
+ s6 = peg$c108(s3, s4, s8);
3522
3726
  s5 = s6;
3523
3727
  }
3524
3728
  else {
@@ -3548,31 +3752,31 @@ function peg$parse(input, options) {
3548
3752
  if (s5 === peg$FAILED) {
3549
3753
  s5 = peg$currPos;
3550
3754
  if (input.charCodeAt(peg$currPos) === 40) {
3551
- s6 = peg$c101;
3755
+ s6 = peg$c103;
3552
3756
  peg$currPos++;
3553
3757
  }
3554
3758
  else {
3555
3759
  s6 = peg$FAILED;
3556
3760
  if (peg$silentFails === 0) {
3557
- peg$fail(peg$c102);
3761
+ peg$fail(peg$c104);
3558
3762
  }
3559
3763
  }
3560
3764
  if (s6 !== peg$FAILED) {
3561
3765
  s7 = peg$parsegap();
3562
3766
  if (s7 !== peg$FAILED) {
3563
3767
  if (input.charCodeAt(peg$currPos) === 41) {
3564
- s8 = peg$c104;
3768
+ s8 = peg$c106;
3565
3769
  peg$currPos++;
3566
3770
  }
3567
3771
  else {
3568
3772
  s8 = peg$FAILED;
3569
3773
  if (peg$silentFails === 0) {
3570
- peg$fail(peg$c105);
3774
+ peg$fail(peg$c107);
3571
3775
  }
3572
3776
  }
3573
3777
  if (s8 !== peg$FAILED) {
3574
3778
  peg$savedPos = s5;
3575
- s6 = peg$c100(s3, s4);
3779
+ s6 = peg$c102(s3, s4);
3576
3780
  s5 = s6;
3577
3781
  }
3578
3782
  else {
@@ -3592,13 +3796,13 @@ function peg$parse(input, options) {
3592
3796
  if (s5 === peg$FAILED) {
3593
3797
  s5 = peg$currPos;
3594
3798
  if (input.charCodeAt(peg$currPos) === 40) {
3595
- s6 = peg$c101;
3799
+ s6 = peg$c103;
3596
3800
  peg$currPos++;
3597
3801
  }
3598
3802
  else {
3599
3803
  s6 = peg$FAILED;
3600
3804
  if (peg$silentFails === 0) {
3601
- peg$fail(peg$c102);
3805
+ peg$fail(peg$c104);
3602
3806
  }
3603
3807
  }
3604
3808
  if (s6 !== peg$FAILED) {
@@ -3607,13 +3811,13 @@ function peg$parse(input, options) {
3607
3811
  s8 = peg$currPos;
3608
3812
  s9 = peg$currPos;
3609
3813
  if (input.charCodeAt(peg$currPos) === 58) {
3610
- s10 = peg$c56;
3814
+ s10 = peg$c58;
3611
3815
  peg$currPos++;
3612
3816
  }
3613
3817
  else {
3614
3818
  s10 = peg$FAILED;
3615
3819
  if (peg$silentFails === 0) {
3616
- peg$fail(peg$c57);
3820
+ peg$fail(peg$c59);
3617
3821
  }
3618
3822
  }
3619
3823
  if (s10 !== peg$FAILED) {
@@ -3622,24 +3826,24 @@ function peg$parse(input, options) {
3622
3826
  s13 = peg$currPos;
3623
3827
  peg$silentFails++;
3624
3828
  if (input.charCodeAt(peg$currPos) === 41) {
3625
- s14 = peg$c104;
3829
+ s14 = peg$c106;
3626
3830
  peg$currPos++;
3627
3831
  }
3628
3832
  else {
3629
3833
  s14 = peg$FAILED;
3630
3834
  if (peg$silentFails === 0) {
3631
- peg$fail(peg$c105);
3835
+ peg$fail(peg$c107);
3632
3836
  }
3633
3837
  }
3634
3838
  if (s14 === peg$FAILED) {
3635
3839
  if (input.charCodeAt(peg$currPos) === 40) {
3636
- s14 = peg$c101;
3840
+ s14 = peg$c103;
3637
3841
  peg$currPos++;
3638
3842
  }
3639
3843
  else {
3640
3844
  s14 = peg$FAILED;
3641
3845
  if (peg$silentFails === 0) {
3642
- peg$fail(peg$c102);
3846
+ peg$fail(peg$c104);
3643
3847
  }
3644
3848
  }
3645
3849
  }
@@ -3681,24 +3885,24 @@ function peg$parse(input, options) {
3681
3885
  s13 = peg$currPos;
3682
3886
  peg$silentFails++;
3683
3887
  if (input.charCodeAt(peg$currPos) === 41) {
3684
- s14 = peg$c104;
3888
+ s14 = peg$c106;
3685
3889
  peg$currPos++;
3686
3890
  }
3687
3891
  else {
3688
3892
  s14 = peg$FAILED;
3689
3893
  if (peg$silentFails === 0) {
3690
- peg$fail(peg$c105);
3894
+ peg$fail(peg$c107);
3691
3895
  }
3692
3896
  }
3693
3897
  if (s14 === peg$FAILED) {
3694
3898
  if (input.charCodeAt(peg$currPos) === 40) {
3695
- s14 = peg$c101;
3899
+ s14 = peg$c103;
3696
3900
  peg$currPos++;
3697
3901
  }
3698
3902
  else {
3699
3903
  s14 = peg$FAILED;
3700
3904
  if (peg$silentFails === 0) {
3701
- peg$fail(peg$c102);
3905
+ peg$fail(peg$c104);
3702
3906
  }
3703
3907
  }
3704
3908
  }
@@ -3756,18 +3960,18 @@ function peg$parse(input, options) {
3756
3960
  }
3757
3961
  if (s8 !== peg$FAILED) {
3758
3962
  if (input.charCodeAt(peg$currPos) === 41) {
3759
- s9 = peg$c104;
3963
+ s9 = peg$c106;
3760
3964
  peg$currPos++;
3761
3965
  }
3762
3966
  else {
3763
3967
  s9 = peg$FAILED;
3764
3968
  if (peg$silentFails === 0) {
3765
- peg$fail(peg$c105);
3969
+ peg$fail(peg$c107);
3766
3970
  }
3767
3971
  }
3768
3972
  if (s9 !== peg$FAILED) {
3769
3973
  peg$savedPos = s5;
3770
- s6 = peg$c94(s3, s4, s8);
3974
+ s6 = peg$c96(s3, s4, s8);
3771
3975
  s5 = s6;
3772
3976
  }
3773
3977
  else {
@@ -3792,13 +3996,13 @@ function peg$parse(input, options) {
3792
3996
  if (s5 === peg$FAILED) {
3793
3997
  s5 = peg$currPos;
3794
3998
  if (input.charCodeAt(peg$currPos) === 40) {
3795
- s6 = peg$c101;
3999
+ s6 = peg$c103;
3796
4000
  peg$currPos++;
3797
4001
  }
3798
4002
  else {
3799
4003
  s6 = peg$FAILED;
3800
4004
  if (peg$silentFails === 0) {
3801
- peg$fail(peg$c102);
4005
+ peg$fail(peg$c104);
3802
4006
  }
3803
4007
  }
3804
4008
  if (s6 !== peg$FAILED) {
@@ -3808,13 +4012,13 @@ function peg$parse(input, options) {
3808
4012
  s10 = peg$currPos;
3809
4013
  peg$silentFails++;
3810
4014
  if (input.charCodeAt(peg$currPos) === 41) {
3811
- s11 = peg$c104;
4015
+ s11 = peg$c106;
3812
4016
  peg$currPos++;
3813
4017
  }
3814
4018
  else {
3815
4019
  s11 = peg$FAILED;
3816
4020
  if (peg$silentFails === 0) {
3817
- peg$fail(peg$c105);
4021
+ peg$fail(peg$c107);
3818
4022
  }
3819
4023
  }
3820
4024
  if (s11 === peg$FAILED) {
@@ -3858,13 +4062,13 @@ function peg$parse(input, options) {
3858
4062
  s10 = peg$currPos;
3859
4063
  peg$silentFails++;
3860
4064
  if (input.charCodeAt(peg$currPos) === 41) {
3861
- s11 = peg$c104;
4065
+ s11 = peg$c106;
3862
4066
  peg$currPos++;
3863
4067
  }
3864
4068
  else {
3865
4069
  s11 = peg$FAILED;
3866
4070
  if (peg$silentFails === 0) {
3867
- peg$fail(peg$c105);
4071
+ peg$fail(peg$c107);
3868
4072
  }
3869
4073
  }
3870
4074
  if (s11 === peg$FAILED) {
@@ -3911,18 +4115,18 @@ function peg$parse(input, options) {
3911
4115
  }
3912
4116
  if (s7 !== peg$FAILED) {
3913
4117
  if (input.charCodeAt(peg$currPos) === 41) {
3914
- s8 = peg$c104;
4118
+ s8 = peg$c106;
3915
4119
  peg$currPos++;
3916
4120
  }
3917
4121
  else {
3918
4122
  s8 = peg$FAILED;
3919
4123
  if (peg$silentFails === 0) {
3920
- peg$fail(peg$c105);
4124
+ peg$fail(peg$c107);
3921
4125
  }
3922
4126
  }
3923
4127
  if (s8 !== peg$FAILED) {
3924
4128
  peg$savedPos = s5;
3925
- s6 = peg$c107(s3, s4);
4129
+ s6 = peg$c109(s3, s4);
3926
4130
  s5 = s6;
3927
4131
  }
3928
4132
  else {
@@ -3941,39 +4145,39 @@ function peg$parse(input, options) {
3941
4145
  }
3942
4146
  if (s5 === peg$FAILED) {
3943
4147
  s5 = peg$currPos;
3944
- if (peg$c90.test(input.charAt(peg$currPos))) {
4148
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3945
4149
  s6 = input.charAt(peg$currPos);
3946
4150
  peg$currPos++;
3947
4151
  }
3948
4152
  else {
3949
4153
  s6 = peg$FAILED;
3950
4154
  if (peg$silentFails === 0) {
3951
- peg$fail(peg$c91);
4155
+ peg$fail(peg$c93);
3952
4156
  }
3953
4157
  }
3954
4158
  if (s6 !== peg$FAILED) {
3955
4159
  s7 = peg$currPos;
3956
4160
  s8 = [];
3957
- if (peg$c92.test(input.charAt(peg$currPos))) {
4161
+ if (peg$c94.test(input.charAt(peg$currPos))) {
3958
4162
  s9 = input.charAt(peg$currPos);
3959
4163
  peg$currPos++;
3960
4164
  }
3961
4165
  else {
3962
4166
  s9 = peg$FAILED;
3963
4167
  if (peg$silentFails === 0) {
3964
- peg$fail(peg$c93);
4168
+ peg$fail(peg$c95);
3965
4169
  }
3966
4170
  }
3967
4171
  while (s9 !== peg$FAILED) {
3968
4172
  s8.push(s9);
3969
- if (peg$c92.test(input.charAt(peg$currPos))) {
4173
+ if (peg$c94.test(input.charAt(peg$currPos))) {
3970
4174
  s9 = input.charAt(peg$currPos);
3971
4175
  peg$currPos++;
3972
4176
  }
3973
4177
  else {
3974
4178
  s9 = peg$FAILED;
3975
4179
  if (peg$silentFails === 0) {
3976
- peg$fail(peg$c93);
4180
+ peg$fail(peg$c95);
3977
4181
  }
3978
4182
  }
3979
4183
  }
@@ -3984,19 +4188,19 @@ function peg$parse(input, options) {
3984
4188
  s7 = s8;
3985
4189
  }
3986
4190
  if (s7 !== peg$FAILED) {
3987
- if (peg$c90.test(input.charAt(peg$currPos))) {
4191
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3988
4192
  s8 = input.charAt(peg$currPos);
3989
4193
  peg$currPos++;
3990
4194
  }
3991
4195
  else {
3992
4196
  s8 = peg$FAILED;
3993
4197
  if (peg$silentFails === 0) {
3994
- peg$fail(peg$c91);
4198
+ peg$fail(peg$c93);
3995
4199
  }
3996
4200
  }
3997
4201
  if (s8 !== peg$FAILED) {
3998
4202
  peg$savedPos = s5;
3999
- s6 = peg$c94(s3, s4, s7);
4203
+ s6 = peg$c96(s3, s4, s7);
4000
4204
  s5 = s6;
4001
4205
  }
4002
4206
  else {
@@ -4015,39 +4219,39 @@ function peg$parse(input, options) {
4015
4219
  }
4016
4220
  if (s5 === peg$FAILED) {
4017
4221
  s5 = peg$currPos;
4018
- if (peg$c95.test(input.charAt(peg$currPos))) {
4222
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4019
4223
  s6 = input.charAt(peg$currPos);
4020
4224
  peg$currPos++;
4021
4225
  }
4022
4226
  else {
4023
4227
  s6 = peg$FAILED;
4024
4228
  if (peg$silentFails === 0) {
4025
- peg$fail(peg$c96);
4229
+ peg$fail(peg$c98);
4026
4230
  }
4027
4231
  }
4028
4232
  if (s6 !== peg$FAILED) {
4029
4233
  s7 = peg$currPos;
4030
4234
  s8 = [];
4031
- if (peg$c97.test(input.charAt(peg$currPos))) {
4235
+ if (peg$c99.test(input.charAt(peg$currPos))) {
4032
4236
  s9 = input.charAt(peg$currPos);
4033
4237
  peg$currPos++;
4034
4238
  }
4035
4239
  else {
4036
4240
  s9 = peg$FAILED;
4037
4241
  if (peg$silentFails === 0) {
4038
- peg$fail(peg$c98);
4242
+ peg$fail(peg$c100);
4039
4243
  }
4040
4244
  }
4041
4245
  while (s9 !== peg$FAILED) {
4042
4246
  s8.push(s9);
4043
- if (peg$c97.test(input.charAt(peg$currPos))) {
4247
+ if (peg$c99.test(input.charAt(peg$currPos))) {
4044
4248
  s9 = input.charAt(peg$currPos);
4045
4249
  peg$currPos++;
4046
4250
  }
4047
4251
  else {
4048
4252
  s9 = peg$FAILED;
4049
4253
  if (peg$silentFails === 0) {
4050
- peg$fail(peg$c98);
4254
+ peg$fail(peg$c100);
4051
4255
  }
4052
4256
  }
4053
4257
  }
@@ -4058,19 +4262,19 @@ function peg$parse(input, options) {
4058
4262
  s7 = s8;
4059
4263
  }
4060
4264
  if (s7 !== peg$FAILED) {
4061
- if (peg$c95.test(input.charAt(peg$currPos))) {
4265
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4062
4266
  s8 = input.charAt(peg$currPos);
4063
4267
  peg$currPos++;
4064
4268
  }
4065
4269
  else {
4066
4270
  s8 = peg$FAILED;
4067
4271
  if (peg$silentFails === 0) {
4068
- peg$fail(peg$c96);
4272
+ peg$fail(peg$c98);
4069
4273
  }
4070
4274
  }
4071
4275
  if (s8 !== peg$FAILED) {
4072
4276
  peg$savedPos = s5;
4073
- s6 = peg$c94(s3, s4, s7);
4277
+ s6 = peg$c96(s3, s4, s7);
4074
4278
  s5 = s6;
4075
4279
  }
4076
4280
  else {
@@ -4090,38 +4294,38 @@ function peg$parse(input, options) {
4090
4294
  if (s5 === peg$FAILED) {
4091
4295
  s5 = peg$currPos;
4092
4296
  if (input.charCodeAt(peg$currPos) === 65378) {
4093
- s6 = peg$c108;
4297
+ s6 = peg$c110;
4094
4298
  peg$currPos++;
4095
4299
  }
4096
4300
  else {
4097
4301
  s6 = peg$FAILED;
4098
4302
  if (peg$silentFails === 0) {
4099
- peg$fail(peg$c109);
4303
+ peg$fail(peg$c111);
4100
4304
  }
4101
4305
  }
4102
4306
  if (s6 !== peg$FAILED) {
4103
4307
  s7 = peg$currPos;
4104
4308
  s8 = [];
4105
- if (peg$c110.test(input.charAt(peg$currPos))) {
4309
+ if (peg$c112.test(input.charAt(peg$currPos))) {
4106
4310
  s9 = input.charAt(peg$currPos);
4107
4311
  peg$currPos++;
4108
4312
  }
4109
4313
  else {
4110
4314
  s9 = peg$FAILED;
4111
4315
  if (peg$silentFails === 0) {
4112
- peg$fail(peg$c111);
4316
+ peg$fail(peg$c113);
4113
4317
  }
4114
4318
  }
4115
4319
  while (s9 !== peg$FAILED) {
4116
4320
  s8.push(s9);
4117
- if (peg$c110.test(input.charAt(peg$currPos))) {
4321
+ if (peg$c112.test(input.charAt(peg$currPos))) {
4118
4322
  s9 = input.charAt(peg$currPos);
4119
4323
  peg$currPos++;
4120
4324
  }
4121
4325
  else {
4122
4326
  s9 = peg$FAILED;
4123
4327
  if (peg$silentFails === 0) {
4124
- peg$fail(peg$c111);
4328
+ peg$fail(peg$c113);
4125
4329
  }
4126
4330
  }
4127
4331
  }
@@ -4133,18 +4337,18 @@ function peg$parse(input, options) {
4133
4337
  }
4134
4338
  if (s7 !== peg$FAILED) {
4135
4339
  if (input.charCodeAt(peg$currPos) === 65379) {
4136
- s8 = peg$c112;
4340
+ s8 = peg$c114;
4137
4341
  peg$currPos++;
4138
4342
  }
4139
4343
  else {
4140
4344
  s8 = peg$FAILED;
4141
4345
  if (peg$silentFails === 0) {
4142
- peg$fail(peg$c113);
4346
+ peg$fail(peg$c115);
4143
4347
  }
4144
4348
  }
4145
4349
  if (s8 !== peg$FAILED) {
4146
4350
  peg$savedPos = s5;
4147
- s6 = peg$c94(s3, s4, s7);
4351
+ s6 = peg$c96(s3, s4, s7);
4148
4352
  s5 = s6;
4149
4353
  }
4150
4354
  else {
@@ -4164,79 +4368,79 @@ function peg$parse(input, options) {
4164
4368
  if (s5 === peg$FAILED) {
4165
4369
  s5 = peg$currPos;
4166
4370
  if (input.charCodeAt(peg$currPos) === 60) {
4167
- s6 = peg$c62;
4371
+ s6 = peg$c64;
4168
4372
  peg$currPos++;
4169
4373
  }
4170
4374
  else {
4171
4375
  s6 = peg$FAILED;
4172
4376
  if (peg$silentFails === 0) {
4173
- peg$fail(peg$c63);
4377
+ peg$fail(peg$c65);
4174
4378
  }
4175
4379
  }
4176
4380
  if (s6 === peg$FAILED) {
4177
4381
  if (input.charCodeAt(peg$currPos) === 40) {
4178
- s6 = peg$c101;
4382
+ s6 = peg$c103;
4179
4383
  peg$currPos++;
4180
4384
  }
4181
4385
  else {
4182
4386
  s6 = peg$FAILED;
4183
4387
  if (peg$silentFails === 0) {
4184
- peg$fail(peg$c102);
4388
+ peg$fail(peg$c104);
4185
4389
  }
4186
4390
  }
4187
4391
  if (s6 === peg$FAILED) {
4188
4392
  if (input.charCodeAt(peg$currPos) === 123) {
4189
- s6 = peg$c77;
4393
+ s6 = peg$c79;
4190
4394
  peg$currPos++;
4191
4395
  }
4192
4396
  else {
4193
4397
  s6 = peg$FAILED;
4194
4398
  if (peg$silentFails === 0) {
4195
- peg$fail(peg$c78);
4399
+ peg$fail(peg$c80);
4196
4400
  }
4197
4401
  }
4198
4402
  if (s6 === peg$FAILED) {
4199
4403
  if (input.charCodeAt(peg$currPos) === 91) {
4200
- s6 = peg$c84;
4404
+ s6 = peg$c86;
4201
4405
  peg$currPos++;
4202
4406
  }
4203
4407
  else {
4204
4408
  s6 = peg$FAILED;
4205
4409
  if (peg$silentFails === 0) {
4206
- peg$fail(peg$c85);
4410
+ peg$fail(peg$c87);
4207
4411
  }
4208
4412
  }
4209
4413
  if (s6 === peg$FAILED) {
4210
- if (peg$c90.test(input.charAt(peg$currPos))) {
4414
+ if (peg$c92.test(input.charAt(peg$currPos))) {
4211
4415
  s6 = input.charAt(peg$currPos);
4212
4416
  peg$currPos++;
4213
4417
  }
4214
4418
  else {
4215
4419
  s6 = peg$FAILED;
4216
4420
  if (peg$silentFails === 0) {
4217
- peg$fail(peg$c91);
4421
+ peg$fail(peg$c93);
4218
4422
  }
4219
4423
  }
4220
4424
  if (s6 === peg$FAILED) {
4221
- if (peg$c95.test(input.charAt(peg$currPos))) {
4425
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4222
4426
  s6 = input.charAt(peg$currPos);
4223
4427
  peg$currPos++;
4224
4428
  }
4225
4429
  else {
4226
4430
  s6 = peg$FAILED;
4227
4431
  if (peg$silentFails === 0) {
4228
- peg$fail(peg$c96);
4432
+ peg$fail(peg$c98);
4229
4433
  }
4230
4434
  }
4231
4435
  if (s6 === peg$FAILED) {
4232
4436
  if (input.charCodeAt(peg$currPos) === 65378) {
4233
- s6 = peg$c108;
4437
+ s6 = peg$c110;
4234
4438
  peg$currPos++;
4235
4439
  }
4236
4440
  else {
4237
4441
  s6 = peg$FAILED;
4238
4442
  if (peg$silentFails === 0) {
4239
- peg$fail(peg$c109);
4443
+ peg$fail(peg$c111);
4240
4444
  }
4241
4445
  }
4242
4446
  }
@@ -4331,7 +4535,7 @@ function peg$parse(input, options) {
4331
4535
  }
4332
4536
  if (s7 !== peg$FAILED) {
4333
4537
  peg$savedPos = s5;
4334
- s6 = peg$c114(s3, s4);
4538
+ s6 = peg$c116(s3, s4);
4335
4539
  s5 = s6;
4336
4540
  }
4337
4541
  else {
@@ -4348,7 +4552,7 @@ function peg$parse(input, options) {
4348
4552
  s6 = peg$parse_();
4349
4553
  if (s6 !== peg$FAILED) {
4350
4554
  peg$savedPos = s5;
4351
- s6 = peg$c115(s3, s4);
4555
+ s6 = peg$c117(s3, s4);
4352
4556
  }
4353
4557
  s5 = s6;
4354
4558
  }
@@ -4372,7 +4576,7 @@ function peg$parse(input, options) {
4372
4576
  s6 = peg$parse_();
4373
4577
  if (s6 !== peg$FAILED) {
4374
4578
  peg$savedPos = s0;
4375
- s1 = peg$c116(s3, s4, s5);
4579
+ s1 = peg$c118(s3, s4, s5);
4376
4580
  s0 = s1;
4377
4581
  }
4378
4582
  else {
@@ -4451,7 +4655,7 @@ function peg$parse(input, options) {
4451
4655
  s9 = peg$parsenewline();
4452
4656
  if (s9 !== peg$FAILED) {
4453
4657
  peg$savedPos = s4;
4454
- s5 = peg$c117(s1, s7);
4658
+ s5 = peg$c119(s1, s7);
4455
4659
  s4 = s5;
4456
4660
  }
4457
4661
  else {
@@ -4511,7 +4715,7 @@ function peg$parse(input, options) {
4511
4715
  s9 = peg$parsenewline();
4512
4716
  if (s9 !== peg$FAILED) {
4513
4717
  peg$savedPos = s4;
4514
- s5 = peg$c117(s1, s7);
4718
+ s5 = peg$c119(s1, s7);
4515
4719
  s4 = s5;
4516
4720
  }
4517
4721
  else {
@@ -4546,7 +4750,7 @@ function peg$parse(input, options) {
4546
4750
  }
4547
4751
  if (s4 !== peg$FAILED) {
4548
4752
  peg$savedPos = s0;
4549
- s1 = peg$c118(s1, s3, s4);
4753
+ s1 = peg$c120(s1, s3, s4);
4550
4754
  s0 = s1;
4551
4755
  }
4552
4756
  else {
@@ -4587,14 +4791,14 @@ function peg$parse(input, options) {
4587
4791
  }
4588
4792
  }
4589
4793
  if (s3 !== peg$FAILED) {
4590
- if (peg$c40.test(input.charAt(peg$currPos))) {
4794
+ if (peg$c42.test(input.charAt(peg$currPos))) {
4591
4795
  s4 = input.charAt(peg$currPos);
4592
4796
  peg$currPos++;
4593
4797
  }
4594
4798
  else {
4595
4799
  s4 = peg$FAILED;
4596
4800
  if (peg$silentFails === 0) {
4597
- peg$fail(peg$c41);
4801
+ peg$fail(peg$c43);
4598
4802
  }
4599
4803
  }
4600
4804
  if (s4 !== peg$FAILED) {
@@ -4620,7 +4824,7 @@ function peg$parse(input, options) {
4620
4824
  }
4621
4825
  if (s1 !== peg$FAILED) {
4622
4826
  peg$savedPos = s0;
4623
- s1 = peg$c119();
4827
+ s1 = peg$c121();
4624
4828
  }
4625
4829
  s0 = s1;
4626
4830
  return s0;
@@ -4630,27 +4834,27 @@ function peg$parse(input, options) {
4630
4834
  s0 = peg$currPos;
4631
4835
  s1 = peg$currPos;
4632
4836
  s2 = [];
4633
- if (peg$c120.test(input.charAt(peg$currPos))) {
4837
+ if (peg$c122.test(input.charAt(peg$currPos))) {
4634
4838
  s3 = input.charAt(peg$currPos);
4635
4839
  peg$currPos++;
4636
4840
  }
4637
4841
  else {
4638
4842
  s3 = peg$FAILED;
4639
4843
  if (peg$silentFails === 0) {
4640
- peg$fail(peg$c121);
4844
+ peg$fail(peg$c123);
4641
4845
  }
4642
4846
  }
4643
4847
  if (s3 !== peg$FAILED) {
4644
4848
  while (s3 !== peg$FAILED) {
4645
4849
  s2.push(s3);
4646
- if (peg$c120.test(input.charAt(peg$currPos))) {
4850
+ if (peg$c122.test(input.charAt(peg$currPos))) {
4647
4851
  s3 = input.charAt(peg$currPos);
4648
4852
  peg$currPos++;
4649
4853
  }
4650
4854
  else {
4651
4855
  s3 = peg$FAILED;
4652
4856
  if (peg$silentFails === 0) {
4653
- peg$fail(peg$c121);
4857
+ peg$fail(peg$c123);
4654
4858
  }
4655
4859
  }
4656
4860
  }
@@ -4666,7 +4870,7 @@ function peg$parse(input, options) {
4666
4870
  }
4667
4871
  if (s1 !== peg$FAILED) {
4668
4872
  peg$savedPos = s0;
4669
- s1 = peg$c122(s1);
4873
+ s1 = peg$c124(s1);
4670
4874
  }
4671
4875
  s0 = s1;
4672
4876
  return s0;
@@ -4675,27 +4879,27 @@ function peg$parse(input, options) {
4675
4879
  var s0, s1, s2;
4676
4880
  s0 = peg$currPos;
4677
4881
  s1 = [];
4678
- if (peg$c123.test(input.charAt(peg$currPos))) {
4882
+ if (peg$c125.test(input.charAt(peg$currPos))) {
4679
4883
  s2 = input.charAt(peg$currPos);
4680
4884
  peg$currPos++;
4681
4885
  }
4682
4886
  else {
4683
4887
  s2 = peg$FAILED;
4684
4888
  if (peg$silentFails === 0) {
4685
- peg$fail(peg$c124);
4889
+ peg$fail(peg$c126);
4686
4890
  }
4687
4891
  }
4688
4892
  if (s2 !== peg$FAILED) {
4689
4893
  while (s2 !== peg$FAILED) {
4690
4894
  s1.push(s2);
4691
- if (peg$c123.test(input.charAt(peg$currPos))) {
4895
+ if (peg$c125.test(input.charAt(peg$currPos))) {
4692
4896
  s2 = input.charAt(peg$currPos);
4693
4897
  peg$currPos++;
4694
4898
  }
4695
4899
  else {
4696
4900
  s2 = peg$FAILED;
4697
4901
  if (peg$silentFails === 0) {
4698
- peg$fail(peg$c124);
4902
+ peg$fail(peg$c126);
4699
4903
  }
4700
4904
  }
4701
4905
  }
@@ -4715,14 +4919,14 @@ function peg$parse(input, options) {
4715
4919
  var s0, s1, s2, s3, s4;
4716
4920
  s0 = peg$currPos;
4717
4921
  s1 = peg$currPos;
4718
- if (peg$c125.test(input.charAt(peg$currPos))) {
4922
+ if (peg$c127.test(input.charAt(peg$currPos))) {
4719
4923
  s2 = input.charAt(peg$currPos);
4720
4924
  peg$currPos++;
4721
4925
  }
4722
4926
  else {
4723
4927
  s2 = peg$FAILED;
4724
4928
  if (peg$silentFails === 0) {
4725
- peg$fail(peg$c126);
4929
+ peg$fail(peg$c128);
4726
4930
  }
4727
4931
  }
4728
4932
  if (s2 === peg$FAILED) {
@@ -4730,27 +4934,27 @@ function peg$parse(input, options) {
4730
4934
  }
4731
4935
  if (s2 !== peg$FAILED) {
4732
4936
  s3 = [];
4733
- if (peg$c123.test(input.charAt(peg$currPos))) {
4937
+ if (peg$c125.test(input.charAt(peg$currPos))) {
4734
4938
  s4 = input.charAt(peg$currPos);
4735
4939
  peg$currPos++;
4736
4940
  }
4737
4941
  else {
4738
4942
  s4 = peg$FAILED;
4739
4943
  if (peg$silentFails === 0) {
4740
- peg$fail(peg$c124);
4944
+ peg$fail(peg$c126);
4741
4945
  }
4742
4946
  }
4743
4947
  if (s4 !== peg$FAILED) {
4744
4948
  while (s4 !== peg$FAILED) {
4745
4949
  s3.push(s4);
4746
- if (peg$c123.test(input.charAt(peg$currPos))) {
4950
+ if (peg$c125.test(input.charAt(peg$currPos))) {
4747
4951
  s4 = input.charAt(peg$currPos);
4748
4952
  peg$currPos++;
4749
4953
  }
4750
4954
  else {
4751
4955
  s4 = peg$FAILED;
4752
4956
  if (peg$silentFails === 0) {
4753
- peg$fail(peg$c124);
4957
+ peg$fail(peg$c126);
4754
4958
  }
4755
4959
  }
4756
4960
  }
@@ -4782,36 +4986,36 @@ function peg$parse(input, options) {
4782
4986
  function peg$parseBoolean() {
4783
4987
  var s0, s1;
4784
4988
  s0 = peg$currPos;
4785
- if (input.substr(peg$currPos, 4) === peg$c127) {
4786
- s1 = peg$c127;
4989
+ if (input.substr(peg$currPos, 4) === peg$c129) {
4990
+ s1 = peg$c129;
4787
4991
  peg$currPos += 4;
4788
4992
  }
4789
4993
  else {
4790
4994
  s1 = peg$FAILED;
4791
4995
  if (peg$silentFails === 0) {
4792
- peg$fail(peg$c128);
4996
+ peg$fail(peg$c130);
4793
4997
  }
4794
4998
  }
4795
4999
  if (s1 !== peg$FAILED) {
4796
5000
  peg$savedPos = s0;
4797
- s1 = peg$c129();
5001
+ s1 = peg$c131();
4798
5002
  }
4799
5003
  s0 = s1;
4800
5004
  if (s0 === peg$FAILED) {
4801
5005
  s0 = peg$currPos;
4802
- if (input.substr(peg$currPos, 5) === peg$c130) {
4803
- s1 = peg$c130;
5006
+ if (input.substr(peg$currPos, 5) === peg$c132) {
5007
+ s1 = peg$c132;
4804
5008
  peg$currPos += 5;
4805
5009
  }
4806
5010
  else {
4807
5011
  s1 = peg$FAILED;
4808
5012
  if (peg$silentFails === 0) {
4809
- peg$fail(peg$c131);
5013
+ peg$fail(peg$c133);
4810
5014
  }
4811
5015
  }
4812
5016
  if (s1 !== peg$FAILED) {
4813
5017
  peg$savedPos = s0;
4814
- s1 = peg$c132();
5018
+ s1 = peg$c134();
4815
5019
  }
4816
5020
  s0 = s1;
4817
5021
  }
@@ -4825,13 +5029,13 @@ function peg$parse(input, options) {
4825
5029
  if (s2 !== peg$FAILED) {
4826
5030
  s3 = peg$currPos;
4827
5031
  if (input.charCodeAt(peg$currPos) === 46) {
4828
- s4 = peg$c133;
5032
+ s4 = peg$c135;
4829
5033
  peg$currPos++;
4830
5034
  }
4831
5035
  else {
4832
5036
  s4 = peg$FAILED;
4833
5037
  if (peg$silentFails === 0) {
4834
- peg$fail(peg$c134);
5038
+ peg$fail(peg$c136);
4835
5039
  }
4836
5040
  }
4837
5041
  if (s4 !== peg$FAILED) {
@@ -4853,14 +5057,14 @@ function peg$parse(input, options) {
4853
5057
  s3 = null;
4854
5058
  }
4855
5059
  if (s3 !== peg$FAILED) {
4856
- if (peg$c135.test(input.charAt(peg$currPos))) {
5060
+ if (peg$c137.test(input.charAt(peg$currPos))) {
4857
5061
  s4 = input.charAt(peg$currPos);
4858
5062
  peg$currPos++;
4859
5063
  }
4860
5064
  else {
4861
5065
  s4 = peg$FAILED;
4862
5066
  if (peg$silentFails === 0) {
4863
- peg$fail(peg$c136);
5067
+ peg$fail(peg$c138);
4864
5068
  }
4865
5069
  }
4866
5070
  if (s4 !== peg$FAILED) {
@@ -4900,13 +5104,13 @@ function peg$parse(input, options) {
4900
5104
  s2 = peg$parsenumber();
4901
5105
  if (s2 !== peg$FAILED) {
4902
5106
  if (input.charCodeAt(peg$currPos) === 46) {
4903
- s3 = peg$c133;
5107
+ s3 = peg$c135;
4904
5108
  peg$currPos++;
4905
5109
  }
4906
5110
  else {
4907
5111
  s3 = peg$FAILED;
4908
5112
  if (peg$silentFails === 0) {
4909
- peg$fail(peg$c134);
5113
+ peg$fail(peg$c136);
4910
5114
  }
4911
5115
  }
4912
5116
  if (s3 !== peg$FAILED) {
@@ -4941,39 +5145,39 @@ function peg$parse(input, options) {
4941
5145
  function peg$parseitem() {
4942
5146
  var s0, s1, s2, s3, s4;
4943
5147
  s0 = peg$currPos;
4944
- if (peg$c95.test(input.charAt(peg$currPos))) {
5148
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4945
5149
  s1 = input.charAt(peg$currPos);
4946
5150
  peg$currPos++;
4947
5151
  }
4948
5152
  else {
4949
5153
  s1 = peg$FAILED;
4950
5154
  if (peg$silentFails === 0) {
4951
- peg$fail(peg$c96);
5155
+ peg$fail(peg$c98);
4952
5156
  }
4953
5157
  }
4954
5158
  if (s1 !== peg$FAILED) {
4955
5159
  s2 = peg$currPos;
4956
5160
  s3 = [];
4957
- if (peg$c97.test(input.charAt(peg$currPos))) {
5161
+ if (peg$c99.test(input.charAt(peg$currPos))) {
4958
5162
  s4 = input.charAt(peg$currPos);
4959
5163
  peg$currPos++;
4960
5164
  }
4961
5165
  else {
4962
5166
  s4 = peg$FAILED;
4963
5167
  if (peg$silentFails === 0) {
4964
- peg$fail(peg$c98);
5168
+ peg$fail(peg$c100);
4965
5169
  }
4966
5170
  }
4967
5171
  while (s4 !== peg$FAILED) {
4968
5172
  s3.push(s4);
4969
- if (peg$c97.test(input.charAt(peg$currPos))) {
5173
+ if (peg$c99.test(input.charAt(peg$currPos))) {
4970
5174
  s4 = input.charAt(peg$currPos);
4971
5175
  peg$currPos++;
4972
5176
  }
4973
5177
  else {
4974
5178
  s4 = peg$FAILED;
4975
5179
  if (peg$silentFails === 0) {
4976
- peg$fail(peg$c98);
5180
+ peg$fail(peg$c100);
4977
5181
  }
4978
5182
  }
4979
5183
  }
@@ -4984,19 +5188,19 @@ function peg$parse(input, options) {
4984
5188
  s2 = s3;
4985
5189
  }
4986
5190
  if (s2 !== peg$FAILED) {
4987
- if (peg$c95.test(input.charAt(peg$currPos))) {
5191
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4988
5192
  s3 = input.charAt(peg$currPos);
4989
5193
  peg$currPos++;
4990
5194
  }
4991
5195
  else {
4992
5196
  s3 = peg$FAILED;
4993
5197
  if (peg$silentFails === 0) {
4994
- peg$fail(peg$c96);
5198
+ peg$fail(peg$c98);
4995
5199
  }
4996
5200
  }
4997
5201
  if (s3 !== peg$FAILED) {
4998
5202
  peg$savedPos = s0;
4999
- s1 = peg$c122(s2);
5203
+ s1 = peg$c124(s2);
5000
5204
  s0 = s1;
5001
5205
  }
5002
5206
  else {
@@ -5015,39 +5219,39 @@ function peg$parse(input, options) {
5015
5219
  }
5016
5220
  if (s0 === peg$FAILED) {
5017
5221
  s0 = peg$currPos;
5018
- if (peg$c90.test(input.charAt(peg$currPos))) {
5222
+ if (peg$c92.test(input.charAt(peg$currPos))) {
5019
5223
  s1 = input.charAt(peg$currPos);
5020
5224
  peg$currPos++;
5021
5225
  }
5022
5226
  else {
5023
5227
  s1 = peg$FAILED;
5024
5228
  if (peg$silentFails === 0) {
5025
- peg$fail(peg$c91);
5229
+ peg$fail(peg$c93);
5026
5230
  }
5027
5231
  }
5028
5232
  if (s1 !== peg$FAILED) {
5029
5233
  s2 = peg$currPos;
5030
5234
  s3 = [];
5031
- if (peg$c92.test(input.charAt(peg$currPos))) {
5235
+ if (peg$c94.test(input.charAt(peg$currPos))) {
5032
5236
  s4 = input.charAt(peg$currPos);
5033
5237
  peg$currPos++;
5034
5238
  }
5035
5239
  else {
5036
5240
  s4 = peg$FAILED;
5037
5241
  if (peg$silentFails === 0) {
5038
- peg$fail(peg$c93);
5242
+ peg$fail(peg$c95);
5039
5243
  }
5040
5244
  }
5041
5245
  while (s4 !== peg$FAILED) {
5042
5246
  s3.push(s4);
5043
- if (peg$c92.test(input.charAt(peg$currPos))) {
5247
+ if (peg$c94.test(input.charAt(peg$currPos))) {
5044
5248
  s4 = input.charAt(peg$currPos);
5045
5249
  peg$currPos++;
5046
5250
  }
5047
5251
  else {
5048
5252
  s4 = peg$FAILED;
5049
5253
  if (peg$silentFails === 0) {
5050
- peg$fail(peg$c93);
5254
+ peg$fail(peg$c95);
5051
5255
  }
5052
5256
  }
5053
5257
  }
@@ -5058,19 +5262,19 @@ function peg$parse(input, options) {
5058
5262
  s2 = s3;
5059
5263
  }
5060
5264
  if (s2 !== peg$FAILED) {
5061
- if (peg$c90.test(input.charAt(peg$currPos))) {
5265
+ if (peg$c92.test(input.charAt(peg$currPos))) {
5062
5266
  s3 = input.charAt(peg$currPos);
5063
5267
  peg$currPos++;
5064
5268
  }
5065
5269
  else {
5066
5270
  s3 = peg$FAILED;
5067
5271
  if (peg$silentFails === 0) {
5068
- peg$fail(peg$c91);
5272
+ peg$fail(peg$c93);
5069
5273
  }
5070
5274
  }
5071
5275
  if (s3 !== peg$FAILED) {
5072
5276
  peg$savedPos = s0;
5073
- s1 = peg$c122(s2);
5277
+ s1 = peg$c124(s2);
5074
5278
  s0 = s1;
5075
5279
  }
5076
5280
  else {
@@ -5094,7 +5298,7 @@ function peg$parse(input, options) {
5094
5298
  s1 = peg$parsefloatNumber();
5095
5299
  if (s1 !== peg$FAILED) {
5096
5300
  peg$savedPos = s0;
5097
- s1 = peg$c137(s1);
5301
+ s1 = peg$c139(s1);
5098
5302
  }
5099
5303
  s0 = s1;
5100
5304
  if (s0 === peg$FAILED) {
@@ -5102,7 +5306,7 @@ function peg$parse(input, options) {
5102
5306
  s1 = peg$parsenumber();
5103
5307
  if (s1 !== peg$FAILED) {
5104
5308
  peg$savedPos = s0;
5105
- s1 = peg$c138(s1);
5309
+ s1 = peg$c140(s1);
5106
5310
  }
5107
5311
  s0 = s1;
5108
5312
  }
@@ -5132,7 +5336,7 @@ function peg$parse(input, options) {
5132
5336
  s5 = peg$parsepod_configuration();
5133
5337
  if (s5 !== peg$FAILED) {
5134
5338
  peg$savedPos = peg$currPos;
5135
- s6 = peg$c139(s1, s3, s5);
5339
+ s6 = peg$c141(s1, s3, s5);
5136
5340
  if (s6) {
5137
5341
  s6 = void 0;
5138
5342
  }
@@ -5175,7 +5379,7 @@ function peg$parse(input, options) {
5175
5379
  s15 = peg$parsestrictIdentifier();
5176
5380
  if (s15 !== peg$FAILED) {
5177
5381
  peg$savedPos = peg$currPos;
5178
- s16 = peg$c140(s1, s3, s5, s9, s15);
5382
+ s16 = peg$c142(s1, s3, s5, s9, s15);
5179
5383
  if (s16) {
5180
5384
  s16 = void 0;
5181
5385
  }
@@ -5243,7 +5447,7 @@ function peg$parse(input, options) {
5243
5447
  }
5244
5448
  if (s10 !== peg$FAILED) {
5245
5449
  peg$savedPos = s8;
5246
- s9 = peg$c141(s1, s3, s5, s9, s10);
5450
+ s9 = peg$c143(s1, s3, s5, s9, s10);
5247
5451
  s8 = s9;
5248
5452
  }
5249
5453
  else {
@@ -5292,7 +5496,7 @@ function peg$parse(input, options) {
5292
5496
  s15 = peg$parsestrictIdentifier();
5293
5497
  if (s15 !== peg$FAILED) {
5294
5498
  peg$savedPos = peg$currPos;
5295
- s16 = peg$c140(s1, s3, s5, s9, s15);
5499
+ s16 = peg$c142(s1, s3, s5, s9, s15);
5296
5500
  if (s16) {
5297
5501
  s16 = void 0;
5298
5502
  }
@@ -5360,7 +5564,7 @@ function peg$parse(input, options) {
5360
5564
  }
5361
5565
  if (s10 !== peg$FAILED) {
5362
5566
  peg$savedPos = s8;
5363
- s9 = peg$c141(s1, s3, s5, s9, s10);
5567
+ s9 = peg$c143(s1, s3, s5, s9, s10);
5364
5568
  s8 = s9;
5365
5569
  }
5366
5570
  else {
@@ -5393,7 +5597,7 @@ function peg$parse(input, options) {
5393
5597
  s11 = peg$parsestrictIdentifier();
5394
5598
  if (s11 !== peg$FAILED) {
5395
5599
  peg$savedPos = peg$currPos;
5396
- s12 = peg$c142(s1, s3, s5, s7, s8, s11);
5600
+ s12 = peg$c144(s1, s3, s5, s7, s8, s11);
5397
5601
  if (s12) {
5398
5602
  s12 = void 0;
5399
5603
  }
@@ -5407,7 +5611,7 @@ function peg$parse(input, options) {
5407
5611
  }
5408
5612
  if (s13 !== peg$FAILED) {
5409
5613
  peg$savedPos = s9;
5410
- s10 = peg$c143(s1, s3, s5, s7, s8, s11);
5614
+ s10 = peg$c145(s1, s3, s5, s7, s8, s11);
5411
5615
  s9 = s10;
5412
5616
  }
5413
5617
  else {
@@ -5431,7 +5635,7 @@ function peg$parse(input, options) {
5431
5635
  }
5432
5636
  if (s9 !== peg$FAILED) {
5433
5637
  peg$savedPos = peg$currPos;
5434
- s10 = peg$c144(s1, s3, s5, s7, s8, s9);
5638
+ s10 = peg$c146(s1, s3, s5, s7, s8, s9);
5435
5639
  if (s10) {
5436
5640
  s10 = void 0;
5437
5641
  }
@@ -5440,7 +5644,7 @@ function peg$parse(input, options) {
5440
5644
  }
5441
5645
  if (s10 !== peg$FAILED) {
5442
5646
  peg$savedPos = s0;
5443
- s1 = peg$c145(s1, s3, s5, s7, s8, s9);
5647
+ s1 = peg$c147(s1, s3, s5, s7, s8, s9);
5444
5648
  s0 = s1;
5445
5649
  }
5446
5650
  else {
@@ -5541,14 +5745,14 @@ function peg$parse(input, options) {
5541
5745
  s3 = peg$currPos;
5542
5746
  s4 = [];
5543
5747
  s5 = peg$currPos;
5544
- if (peg$c146.test(input.charAt(peg$currPos))) {
5748
+ if (peg$c148.test(input.charAt(peg$currPos))) {
5545
5749
  s6 = input.charAt(peg$currPos);
5546
5750
  peg$currPos++;
5547
5751
  }
5548
5752
  else {
5549
5753
  s6 = peg$FAILED;
5550
5754
  if (peg$silentFails === 0) {
5551
- peg$fail(peg$c147);
5755
+ peg$fail(peg$c149);
5552
5756
  }
5553
5757
  }
5554
5758
  if (s6 !== peg$FAILED) {
@@ -5575,14 +5779,14 @@ function peg$parse(input, options) {
5575
5779
  while (s5 !== peg$FAILED) {
5576
5780
  s4.push(s5);
5577
5781
  s5 = peg$currPos;
5578
- if (peg$c146.test(input.charAt(peg$currPos))) {
5782
+ if (peg$c148.test(input.charAt(peg$currPos))) {
5579
5783
  s6 = input.charAt(peg$currPos);
5580
5784
  peg$currPos++;
5581
5785
  }
5582
5786
  else {
5583
5787
  s6 = peg$FAILED;
5584
5788
  if (peg$silentFails === 0) {
5585
- peg$fail(peg$c147);
5789
+ peg$fail(peg$c149);
5586
5790
  }
5587
5791
  }
5588
5792
  if (s6 !== peg$FAILED) {
@@ -5620,7 +5824,7 @@ function peg$parse(input, options) {
5620
5824
  s4 = peg$parseEOL();
5621
5825
  if (s4 !== peg$FAILED) {
5622
5826
  peg$savedPos = s0;
5623
- s1 = peg$c148();
5827
+ s1 = peg$c150();
5624
5828
  s0 = s1;
5625
5829
  }
5626
5830
  else {
@@ -5652,7 +5856,7 @@ function peg$parse(input, options) {
5652
5856
  if (s2 === peg$FAILED) {
5653
5857
  s2 = peg$currPos;
5654
5858
  peg$savedPos = peg$currPos;
5655
- s3 = peg$c149();
5859
+ s3 = peg$c151();
5656
5860
  if (s3) {
5657
5861
  s3 = void 0;
5658
5862
  }
@@ -5683,27 +5887,16 @@ function peg$parse(input, options) {
5683
5887
  }
5684
5888
  if (s1 !== peg$FAILED) {
5685
5889
  peg$savedPos = s0;
5686
- s1 = peg$c150();
5890
+ s1 = peg$c152();
5687
5891
  }
5688
5892
  s0 = s1;
5689
5893
  return s0;
5690
5894
  }
5691
5895
  function peg$parsetableRow() {
5692
- var s0, s1;
5693
- s0 = peg$currPos;
5694
- s1 = peg$parseplain_line();
5695
- if (s1 !== peg$FAILED) {
5696
- peg$savedPos = s0;
5697
- s1 = peg$c151(s1);
5698
- }
5699
- s0 = s1;
5700
- return s0;
5701
- }
5702
- function peg$parsetableContents() {
5703
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
5896
+ var s0, s1, s2;
5704
5897
  s0 = peg$currPos;
5705
5898
  peg$savedPos = peg$currPos;
5706
- s1 = peg$c152();
5899
+ s1 = peg$c153();
5707
5900
  if (s1) {
5708
5901
  s1 = void 0;
5709
5902
  }
@@ -5711,20 +5904,79 @@ function peg$parse(input, options) {
5711
5904
  s1 = peg$FAILED;
5712
5905
  }
5713
5906
  if (s1 !== peg$FAILED) {
5714
- s2 = peg$currPos;
5715
- s3 = [];
5716
- s4 = peg$currPos;
5717
- s5 = peg$currPos;
5718
- peg$silentFails++;
5719
- s6 = peg$parsetableHeadSeparator();
5720
- peg$silentFails--;
5721
- if (s6 === peg$FAILED) {
5722
- s5 = void 0;
5907
+ s2 = peg$parseplain_line();
5908
+ if (s2 !== peg$FAILED) {
5909
+ peg$savedPos = s0;
5910
+ s1 = peg$c154(s2);
5911
+ s0 = s1;
5723
5912
  }
5724
5913
  else {
5725
- peg$currPos = s5;
5726
- s5 = peg$FAILED;
5727
- }
5914
+ peg$currPos = s0;
5915
+ s0 = peg$FAILED;
5916
+ }
5917
+ }
5918
+ else {
5919
+ peg$currPos = s0;
5920
+ s0 = peg$FAILED;
5921
+ }
5922
+ if (s0 === peg$FAILED) {
5923
+ s0 = peg$currPos;
5924
+ s1 = peg$currPos;
5925
+ peg$silentFails++;
5926
+ s2 = peg$parseanyDirective();
5927
+ peg$silentFails--;
5928
+ if (s2 === peg$FAILED) {
5929
+ s1 = void 0;
5930
+ }
5931
+ else {
5932
+ peg$currPos = s1;
5933
+ s1 = peg$FAILED;
5934
+ }
5935
+ if (s1 !== peg$FAILED) {
5936
+ s2 = peg$parseplain_line();
5937
+ if (s2 !== peg$FAILED) {
5938
+ peg$savedPos = s0;
5939
+ s1 = peg$c154(s2);
5940
+ s0 = s1;
5941
+ }
5942
+ else {
5943
+ peg$currPos = s0;
5944
+ s0 = peg$FAILED;
5945
+ }
5946
+ }
5947
+ else {
5948
+ peg$currPos = s0;
5949
+ s0 = peg$FAILED;
5950
+ }
5951
+ }
5952
+ return s0;
5953
+ }
5954
+ function peg$parsetableContents() {
5955
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
5956
+ s0 = peg$currPos;
5957
+ peg$savedPos = peg$currPos;
5958
+ s1 = peg$c155();
5959
+ if (s1) {
5960
+ s1 = void 0;
5961
+ }
5962
+ else {
5963
+ s1 = peg$FAILED;
5964
+ }
5965
+ if (s1 !== peg$FAILED) {
5966
+ s2 = peg$currPos;
5967
+ s3 = [];
5968
+ s4 = peg$currPos;
5969
+ s5 = peg$currPos;
5970
+ peg$silentFails++;
5971
+ s6 = peg$parsetableHeadSeparator();
5972
+ peg$silentFails--;
5973
+ if (s6 === peg$FAILED) {
5974
+ s5 = void 0;
5975
+ }
5976
+ else {
5977
+ peg$currPos = s5;
5978
+ s5 = peg$FAILED;
5979
+ }
5728
5980
  if (s5 !== peg$FAILED) {
5729
5981
  s6 = peg$parsetableRow();
5730
5982
  if (s6 !== peg$FAILED) {
@@ -5786,7 +6038,7 @@ function peg$parse(input, options) {
5786
6038
  s4 = peg$parsetableHeadSeparator();
5787
6039
  if (s4 !== peg$FAILED) {
5788
6040
  peg$savedPos = s3;
5789
- s4 = peg$c153(s2, s4);
6041
+ s4 = peg$c156(s2, s4);
5790
6042
  }
5791
6043
  s3 = s4;
5792
6044
  if (s3 !== peg$FAILED) {
@@ -5867,12 +6119,12 @@ function peg$parse(input, options) {
5867
6119
  s8 = peg$parsetableBodyRowSeparator();
5868
6120
  if (s8 !== peg$FAILED) {
5869
6121
  peg$savedPos = s7;
5870
- s8 = peg$c154(s2, s3, s6, s8);
6122
+ s8 = peg$c157(s2, s3, s6, s8);
5871
6123
  }
5872
6124
  s7 = s8;
5873
6125
  if (s7 !== peg$FAILED) {
5874
6126
  peg$savedPos = s5;
5875
- s6 = peg$c155(s2, s3, s6, s7);
6127
+ s6 = peg$c158(s2, s3, s6, s7);
5876
6128
  s5 = s6;
5877
6129
  }
5878
6130
  else {
@@ -5913,7 +6165,7 @@ function peg$parse(input, options) {
5913
6165
  s8 = peg$parsetableRow();
5914
6166
  if (s8 !== peg$FAILED) {
5915
6167
  peg$savedPos = s5;
5916
- s6 = peg$c156(s2, s3, s8);
6168
+ s6 = peg$c159(s2, s3, s8);
5917
6169
  s5 = s6;
5918
6170
  }
5919
6171
  else {
@@ -6010,12 +6262,12 @@ function peg$parse(input, options) {
6010
6262
  s8 = peg$parsetableBodyRowSeparator();
6011
6263
  if (s8 !== peg$FAILED) {
6012
6264
  peg$savedPos = s7;
6013
- s8 = peg$c154(s2, s3, s6, s8);
6265
+ s8 = peg$c157(s2, s3, s6, s8);
6014
6266
  }
6015
6267
  s7 = s8;
6016
6268
  if (s7 !== peg$FAILED) {
6017
6269
  peg$savedPos = s5;
6018
- s6 = peg$c155(s2, s3, s6, s7);
6270
+ s6 = peg$c158(s2, s3, s6, s7);
6019
6271
  s5 = s6;
6020
6272
  }
6021
6273
  else {
@@ -6056,7 +6308,7 @@ function peg$parse(input, options) {
6056
6308
  s8 = peg$parsetableRow();
6057
6309
  if (s8 !== peg$FAILED) {
6058
6310
  peg$savedPos = s5;
6059
- s6 = peg$c156(s2, s3, s8);
6311
+ s6 = peg$c159(s2, s3, s8);
6060
6312
  s5 = s6;
6061
6313
  }
6062
6314
  else {
@@ -6081,7 +6333,7 @@ function peg$parse(input, options) {
6081
6333
  }
6082
6334
  if (s4 !== peg$FAILED) {
6083
6335
  peg$savedPos = peg$currPos;
6084
- s5 = peg$c157(s2, s3, s4);
6336
+ s5 = peg$c160(s2, s3, s4);
6085
6337
  if (s5) {
6086
6338
  s5 = void 0;
6087
6339
  }
@@ -6090,7 +6342,7 @@ function peg$parse(input, options) {
6090
6342
  }
6091
6343
  if (s5 !== peg$FAILED) {
6092
6344
  peg$savedPos = s0;
6093
- s1 = peg$c158(s2, s3, s4);
6345
+ s1 = peg$c161(s2, s3, s4);
6094
6346
  s0 = s1;
6095
6347
  }
6096
6348
  else {
@@ -6164,7 +6416,7 @@ function peg$parse(input, options) {
6164
6416
  }
6165
6417
  if (s4 !== peg$FAILED) {
6166
6418
  peg$savedPos = s2;
6167
- s3 = peg$c159(s3, s4);
6419
+ s3 = peg$c162(s3, s4);
6168
6420
  s2 = s3;
6169
6421
  }
6170
6422
  else {
@@ -6223,7 +6475,7 @@ function peg$parse(input, options) {
6223
6475
  }
6224
6476
  if (s4 !== peg$FAILED) {
6225
6477
  peg$savedPos = s2;
6226
- s3 = peg$c159(s3, s4);
6478
+ s3 = peg$c162(s3, s4);
6227
6479
  s2 = s3;
6228
6480
  }
6229
6481
  else {
@@ -6242,7 +6494,7 @@ function peg$parse(input, options) {
6242
6494
  }
6243
6495
  if (s1 !== peg$FAILED) {
6244
6496
  peg$savedPos = s0;
6245
- s1 = peg$c160(s1);
6497
+ s1 = peg$c163(s1);
6246
6498
  }
6247
6499
  s0 = s1;
6248
6500
  if (s0 === peg$FAILED) {
@@ -6282,7 +6534,7 @@ function peg$parse(input, options) {
6282
6534
  s5 = peg$parsepod_configuration();
6283
6535
  if (s5 !== peg$FAILED) {
6284
6536
  peg$savedPos = peg$currPos;
6285
- s6 = peg$c161(s1, s3, s5);
6537
+ s6 = peg$c164(s1, s3, s5);
6286
6538
  if (s6) {
6287
6539
  s6 = void 0;
6288
6540
  }
@@ -6291,7 +6543,7 @@ function peg$parse(input, options) {
6291
6543
  }
6292
6544
  if (s6 !== peg$FAILED) {
6293
6545
  peg$savedPos = peg$currPos;
6294
- s7 = peg$c162(s1, s3, s5);
6546
+ s7 = peg$c165(s1, s3, s5);
6295
6547
  if (s7) {
6296
6548
  s7 = void 0;
6297
6549
  }
@@ -6344,12 +6596,12 @@ function peg$parse(input, options) {
6344
6596
  }
6345
6597
  if (s9 !== peg$FAILED) {
6346
6598
  peg$savedPos = s8;
6347
- s9 = peg$c163(s1, s3, s5, s9);
6599
+ s9 = peg$c166(s1, s3, s5, s9);
6348
6600
  }
6349
6601
  s8 = s9;
6350
6602
  if (s8 !== peg$FAILED) {
6351
6603
  peg$savedPos = peg$currPos;
6352
- s9 = peg$c164(s1, s3, s5, s8);
6604
+ s9 = peg$c167(s1, s3, s5, s8);
6353
6605
  if (s9) {
6354
6606
  s9 = void 0;
6355
6607
  }
@@ -6372,7 +6624,7 @@ function peg$parse(input, options) {
6372
6624
  s13 = peg$parsestrictIdentifier();
6373
6625
  if (s13 !== peg$FAILED) {
6374
6626
  peg$savedPos = peg$currPos;
6375
- s14 = peg$c142(s1, s3, s5, s8, s10, s13);
6627
+ s14 = peg$c144(s1, s3, s5, s8, s10, s13);
6376
6628
  if (s14) {
6377
6629
  s14 = void 0;
6378
6630
  }
@@ -6386,7 +6638,7 @@ function peg$parse(input, options) {
6386
6638
  }
6387
6639
  if (s15 !== peg$FAILED) {
6388
6640
  peg$savedPos = s11;
6389
- s12 = peg$c165(s1, s3, s5, s8, s10, s13);
6641
+ s12 = peg$c168(s1, s3, s5, s8, s10, s13);
6390
6642
  s11 = s12;
6391
6643
  }
6392
6644
  else {
@@ -6410,7 +6662,7 @@ function peg$parse(input, options) {
6410
6662
  }
6411
6663
  if (s11 !== peg$FAILED) {
6412
6664
  peg$savedPos = s0;
6413
- s1 = peg$c166(s1, s3, s5, s8, s10, s11);
6665
+ s1 = peg$c169(s1, s3, s5, s8, s10, s11);
6414
6666
  s0 = s1;
6415
6667
  }
6416
6668
  else {
@@ -6490,7 +6742,7 @@ function peg$parse(input, options) {
6490
6742
  s5 = peg$parsepod_configuration();
6491
6743
  if (s5 !== peg$FAILED) {
6492
6744
  peg$savedPos = peg$currPos;
6493
- s6 = peg$c161(s1, s3, s5);
6745
+ s6 = peg$c164(s1, s3, s5);
6494
6746
  if (s6) {
6495
6747
  s6 = void 0;
6496
6748
  }
@@ -6499,7 +6751,7 @@ function peg$parse(input, options) {
6499
6751
  }
6500
6752
  if (s6 !== peg$FAILED) {
6501
6753
  peg$savedPos = peg$currPos;
6502
- s7 = peg$c167(s1, s3, s5);
6754
+ s7 = peg$c170(s1, s3, s5);
6503
6755
  if (s7) {
6504
6756
  s7 = void 0;
6505
6757
  }
@@ -6525,7 +6777,7 @@ function peg$parse(input, options) {
6525
6777
  }
6526
6778
  if (s11 !== peg$FAILED) {
6527
6779
  peg$savedPos = s8;
6528
- s9 = peg$c168(s1, s3, s5, s10);
6780
+ s9 = peg$c171(s1, s3, s5, s10);
6529
6781
  s8 = s9;
6530
6782
  }
6531
6783
  else {
@@ -6558,7 +6810,7 @@ function peg$parse(input, options) {
6558
6810
  s12 = peg$parsestrictIdentifier();
6559
6811
  if (s12 !== peg$FAILED) {
6560
6812
  peg$savedPos = peg$currPos;
6561
- s13 = peg$c142(s1, s3, s5, s8, s9, s12);
6813
+ s13 = peg$c144(s1, s3, s5, s8, s9, s12);
6562
6814
  if (s13) {
6563
6815
  s13 = void 0;
6564
6816
  }
@@ -6572,7 +6824,7 @@ function peg$parse(input, options) {
6572
6824
  }
6573
6825
  if (s14 !== peg$FAILED) {
6574
6826
  peg$savedPos = s10;
6575
- s11 = peg$c169(s1, s3, s5, s8, s9, s12);
6827
+ s11 = peg$c172(s1, s3, s5, s8, s9, s12);
6576
6828
  s10 = s11;
6577
6829
  }
6578
6830
  else {
@@ -6596,7 +6848,7 @@ function peg$parse(input, options) {
6596
6848
  }
6597
6849
  if (s10 !== peg$FAILED) {
6598
6850
  peg$savedPos = peg$currPos;
6599
- s11 = peg$c144(s1, s3, s5, s8, s9, s10);
6851
+ s11 = peg$c146(s1, s3, s5, s8, s9, s10);
6600
6852
  if (s11) {
6601
6853
  s11 = void 0;
6602
6854
  }
@@ -6605,7 +6857,7 @@ function peg$parse(input, options) {
6605
6857
  }
6606
6858
  if (s11 !== peg$FAILED) {
6607
6859
  peg$savedPos = s0;
6608
- s1 = peg$c170(s1, s3, s5, s8, s9, s10);
6860
+ s1 = peg$c173(s1, s3, s5, s8, s9, s10);
6609
6861
  s0 = s1;
6610
6862
  }
6611
6863
  else {
@@ -6665,7 +6917,7 @@ function peg$parse(input, options) {
6665
6917
  return s0;
6666
6918
  }
6667
6919
  function peg$parsedelimitedBlock() {
6668
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
6920
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
6669
6921
  s0 = peg$currPos;
6670
6922
  s1 = peg$currPos;
6671
6923
  s2 = peg$parse_();
@@ -6728,7 +6980,7 @@ function peg$parse(input, options) {
6728
6980
  }
6729
6981
  if (s8 !== peg$FAILED) {
6730
6982
  peg$savedPos = s7;
6731
- s8 = peg$c171(s1, s3, s5, s8);
6983
+ s8 = peg$c174(s1, s3, s5, s8);
6732
6984
  }
6733
6985
  s7 = s8;
6734
6986
  if (s7 === peg$FAILED) {
@@ -6748,15 +7000,26 @@ function peg$parse(input, options) {
6748
7000
  }
6749
7001
  if (s8 !== peg$FAILED) {
6750
7002
  s9 = peg$currPos;
6751
- s10 = [];
6752
- s11 = peg$parsetext_content();
7003
+ s10 = peg$currPos;
7004
+ s11 = peg$parsetext_line_first();
6753
7005
  if (s11 !== peg$FAILED) {
6754
- while (s11 !== peg$FAILED) {
6755
- s10.push(s11);
6756
- s11 = peg$parsetext_content();
7006
+ s12 = [];
7007
+ s13 = peg$parsetext_content();
7008
+ while (s13 !== peg$FAILED) {
7009
+ s12.push(s13);
7010
+ s13 = peg$parsetext_content();
7011
+ }
7012
+ if (s12 !== peg$FAILED) {
7013
+ s11 = [s11, s12];
7014
+ s10 = s11;
7015
+ }
7016
+ else {
7017
+ peg$currPos = s10;
7018
+ s10 = peg$FAILED;
6757
7019
  }
6758
7020
  }
6759
7021
  else {
7022
+ peg$currPos = s10;
6760
7023
  s10 = peg$FAILED;
6761
7024
  }
6762
7025
  if (s10 !== peg$FAILED) {
@@ -6767,7 +7030,7 @@ function peg$parse(input, options) {
6767
7030
  }
6768
7031
  if (s9 !== peg$FAILED) {
6769
7032
  peg$savedPos = s7;
6770
- s8 = peg$c172(s1, s3, s5, s8, s9);
7033
+ s8 = peg$c175(s1, s3, s5, s8, s9);
6771
7034
  s7 = s8;
6772
7035
  }
6773
7036
  else {
@@ -6825,7 +7088,7 @@ function peg$parse(input, options) {
6825
7088
  }
6826
7089
  if (s8 !== peg$FAILED) {
6827
7090
  peg$savedPos = s7;
6828
- s8 = peg$c171(s1, s3, s5, s8);
7091
+ s8 = peg$c174(s1, s3, s5, s8);
6829
7092
  }
6830
7093
  s7 = s8;
6831
7094
  if (s7 === peg$FAILED) {
@@ -6845,15 +7108,26 @@ function peg$parse(input, options) {
6845
7108
  }
6846
7109
  if (s8 !== peg$FAILED) {
6847
7110
  s9 = peg$currPos;
6848
- s10 = [];
6849
- s11 = peg$parsetext_content();
7111
+ s10 = peg$currPos;
7112
+ s11 = peg$parsetext_line_first();
6850
7113
  if (s11 !== peg$FAILED) {
6851
- while (s11 !== peg$FAILED) {
6852
- s10.push(s11);
6853
- s11 = peg$parsetext_content();
7114
+ s12 = [];
7115
+ s13 = peg$parsetext_content();
7116
+ while (s13 !== peg$FAILED) {
7117
+ s12.push(s13);
7118
+ s13 = peg$parsetext_content();
7119
+ }
7120
+ if (s12 !== peg$FAILED) {
7121
+ s11 = [s11, s12];
7122
+ s10 = s11;
7123
+ }
7124
+ else {
7125
+ peg$currPos = s10;
7126
+ s10 = peg$FAILED;
6854
7127
  }
6855
7128
  }
6856
7129
  else {
7130
+ peg$currPos = s10;
6857
7131
  s10 = peg$FAILED;
6858
7132
  }
6859
7133
  if (s10 !== peg$FAILED) {
@@ -6864,7 +7138,7 @@ function peg$parse(input, options) {
6864
7138
  }
6865
7139
  if (s9 !== peg$FAILED) {
6866
7140
  peg$savedPos = s7;
6867
- s8 = peg$c172(s1, s3, s5, s8, s9);
7141
+ s8 = peg$c175(s1, s3, s5, s8, s9);
6868
7142
  s7 = s8;
6869
7143
  }
6870
7144
  else {
@@ -6894,7 +7168,7 @@ function peg$parse(input, options) {
6894
7168
  s10 = peg$parsestrictIdentifier();
6895
7169
  if (s10 !== peg$FAILED) {
6896
7170
  peg$savedPos = peg$currPos;
6897
- s11 = peg$c142(s1, s3, s5, s6, s7, s10);
7171
+ s11 = peg$c144(s1, s3, s5, s6, s7, s10);
6898
7172
  if (s11) {
6899
7173
  s11 = void 0;
6900
7174
  }
@@ -6908,7 +7182,7 @@ function peg$parse(input, options) {
6908
7182
  }
6909
7183
  if (s12 !== peg$FAILED) {
6910
7184
  peg$savedPos = s8;
6911
- s9 = peg$c173(s1, s3, s5, s6, s7, s10);
7185
+ s9 = peg$c176(s1, s3, s5, s6, s7, s10);
6912
7186
  s8 = s9;
6913
7187
  }
6914
7188
  else {
@@ -6932,7 +7206,7 @@ function peg$parse(input, options) {
6932
7206
  }
6933
7207
  if (s8 !== peg$FAILED) {
6934
7208
  peg$savedPos = peg$currPos;
6935
- s9 = peg$c144(s1, s3, s5, s6, s7, s8);
7209
+ s9 = peg$c146(s1, s3, s5, s6, s7, s8);
6936
7210
  if (s9) {
6937
7211
  s9 = void 0;
6938
7212
  }
@@ -6941,7 +7215,7 @@ function peg$parse(input, options) {
6941
7215
  }
6942
7216
  if (s9 !== peg$FAILED) {
6943
7217
  peg$savedPos = s0;
6944
- s1 = peg$c174(s1, s3, s5, s6, s7, s8);
7218
+ s1 = peg$c177(s1, s3, s5, s6, s7, s8);
6945
7219
  s0 = s1;
6946
7220
  }
6947
7221
  else {
@@ -6991,24 +7265,30 @@ function peg$parse(input, options) {
6991
7265
  return s0;
6992
7266
  }
6993
7267
  function peg$parsetextBlock() {
6994
- var s0, s1, s2;
7268
+ var s0, s1, s2, s3;
6995
7269
  s0 = peg$currPos;
6996
- s1 = [];
6997
- s2 = peg$parsetext_content();
6998
- if (s2 !== peg$FAILED) {
6999
- while (s2 !== peg$FAILED) {
7000
- s1.push(s2);
7001
- s2 = peg$parsetext_content();
7270
+ s1 = peg$parsetext_line_first();
7271
+ if (s1 !== peg$FAILED) {
7272
+ s2 = [];
7273
+ s3 = peg$parsetext_content();
7274
+ while (s3 !== peg$FAILED) {
7275
+ s2.push(s3);
7276
+ s3 = peg$parsetext_content();
7277
+ }
7278
+ if (s2 !== peg$FAILED) {
7279
+ peg$savedPos = s0;
7280
+ s1 = peg$c178();
7281
+ s0 = s1;
7282
+ }
7283
+ else {
7284
+ peg$currPos = s0;
7285
+ s0 = peg$FAILED;
7002
7286
  }
7003
7287
  }
7004
7288
  else {
7005
- s1 = peg$FAILED;
7006
- }
7007
- if (s1 !== peg$FAILED) {
7008
- peg$savedPos = s0;
7009
- s1 = peg$c175();
7289
+ peg$currPos = s0;
7290
+ s0 = peg$FAILED;
7010
7291
  }
7011
- s0 = s1;
7012
7292
  return s0;
7013
7293
  }
7014
7294
  function peg$parseambientBlock() {
@@ -7019,32 +7299,32 @@ function peg$parse(input, options) {
7019
7299
  s3 = peg$parseemptyline();
7020
7300
  if (s3 !== peg$FAILED) {
7021
7301
  peg$savedPos = s2;
7022
- s3 = peg$c176();
7302
+ s3 = peg$c179();
7023
7303
  }
7024
7304
  s2 = s3;
7025
7305
  if (s2 === peg$FAILED) {
7026
7306
  s2 = [];
7027
- if (peg$c177.test(input.charAt(peg$currPos))) {
7307
+ if (peg$c180.test(input.charAt(peg$currPos))) {
7028
7308
  s3 = input.charAt(peg$currPos);
7029
7309
  peg$currPos++;
7030
7310
  }
7031
7311
  else {
7032
7312
  s3 = peg$FAILED;
7033
7313
  if (peg$silentFails === 0) {
7034
- peg$fail(peg$c178);
7314
+ peg$fail(peg$c181);
7035
7315
  }
7036
7316
  }
7037
7317
  if (s3 !== peg$FAILED) {
7038
7318
  while (s3 !== peg$FAILED) {
7039
7319
  s2.push(s3);
7040
- if (peg$c177.test(input.charAt(peg$currPos))) {
7320
+ if (peg$c180.test(input.charAt(peg$currPos))) {
7041
7321
  s3 = input.charAt(peg$currPos);
7042
7322
  peg$currPos++;
7043
7323
  }
7044
7324
  else {
7045
7325
  s3 = peg$FAILED;
7046
7326
  if (peg$silentFails === 0) {
7047
- peg$fail(peg$c178);
7327
+ peg$fail(peg$c181);
7048
7328
  }
7049
7329
  }
7050
7330
  }
@@ -7053,7 +7333,7 @@ function peg$parse(input, options) {
7053
7333
  s2 = peg$FAILED;
7054
7334
  }
7055
7335
  if (s2 === peg$FAILED) {
7056
- s2 = peg$parsetext_content();
7336
+ s2 = peg$parsetext_line_first();
7057
7337
  }
7058
7338
  }
7059
7339
  if (s2 !== peg$FAILED) {
@@ -7063,32 +7343,32 @@ function peg$parse(input, options) {
7063
7343
  s3 = peg$parseemptyline();
7064
7344
  if (s3 !== peg$FAILED) {
7065
7345
  peg$savedPos = s2;
7066
- s3 = peg$c176();
7346
+ s3 = peg$c179();
7067
7347
  }
7068
7348
  s2 = s3;
7069
7349
  if (s2 === peg$FAILED) {
7070
7350
  s2 = [];
7071
- if (peg$c177.test(input.charAt(peg$currPos))) {
7351
+ if (peg$c180.test(input.charAt(peg$currPos))) {
7072
7352
  s3 = input.charAt(peg$currPos);
7073
7353
  peg$currPos++;
7074
7354
  }
7075
7355
  else {
7076
7356
  s3 = peg$FAILED;
7077
7357
  if (peg$silentFails === 0) {
7078
- peg$fail(peg$c178);
7358
+ peg$fail(peg$c181);
7079
7359
  }
7080
7360
  }
7081
7361
  if (s3 !== peg$FAILED) {
7082
7362
  while (s3 !== peg$FAILED) {
7083
7363
  s2.push(s3);
7084
- if (peg$c177.test(input.charAt(peg$currPos))) {
7364
+ if (peg$c180.test(input.charAt(peg$currPos))) {
7085
7365
  s3 = input.charAt(peg$currPos);
7086
7366
  peg$currPos++;
7087
7367
  }
7088
7368
  else {
7089
7369
  s3 = peg$FAILED;
7090
7370
  if (peg$silentFails === 0) {
7091
- peg$fail(peg$c178);
7371
+ peg$fail(peg$c181);
7092
7372
  }
7093
7373
  }
7094
7374
  }
@@ -7097,7 +7377,7 @@ function peg$parse(input, options) {
7097
7377
  s2 = peg$FAILED;
7098
7378
  }
7099
7379
  if (s2 === peg$FAILED) {
7100
- s2 = peg$parsetext_content();
7380
+ s2 = peg$parsetext_line_first();
7101
7381
  }
7102
7382
  }
7103
7383
  }
@@ -7107,13 +7387,13 @@ function peg$parse(input, options) {
7107
7387
  }
7108
7388
  if (s1 !== peg$FAILED) {
7109
7389
  peg$savedPos = s0;
7110
- s1 = peg$c179(s1);
7390
+ s1 = peg$c182(s1);
7111
7391
  }
7112
7392
  s0 = s1;
7113
7393
  return s0;
7114
7394
  }
7115
7395
  function peg$parseabbreviatedBlockRaw() {
7116
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
7396
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
7117
7397
  s0 = peg$currPos;
7118
7398
  s1 = peg$currPos;
7119
7399
  s2 = peg$parse_();
@@ -7146,7 +7426,7 @@ function peg$parse(input, options) {
7146
7426
  }
7147
7427
  if (s5 !== peg$FAILED) {
7148
7428
  peg$savedPos = peg$currPos;
7149
- s6 = peg$c180(s1, s3);
7429
+ s6 = peg$c183(s1, s3);
7150
7430
  if (s6) {
7151
7431
  s6 = void 0;
7152
7432
  }
@@ -7154,74 +7434,69 @@ function peg$parse(input, options) {
7154
7434
  s6 = peg$FAILED;
7155
7435
  }
7156
7436
  if (s6 !== peg$FAILED) {
7157
- s7 = peg$currPos;
7158
- s8 = [];
7437
+ s7 = [];
7438
+ s8 = peg$currPos;
7159
7439
  s9 = peg$currPos;
7160
- s10 = peg$currPos;
7161
7440
  peg$silentFails++;
7162
- s11 = peg$parseemptyline();
7441
+ s10 = peg$parseemptyline();
7163
7442
  peg$silentFails--;
7164
- if (s11 === peg$FAILED) {
7165
- s10 = void 0;
7443
+ if (s10 === peg$FAILED) {
7444
+ s9 = void 0;
7166
7445
  }
7167
7446
  else {
7168
- peg$currPos = s10;
7169
- s10 = peg$FAILED;
7447
+ peg$currPos = s9;
7448
+ s9 = peg$FAILED;
7170
7449
  }
7171
- if (s10 !== peg$FAILED) {
7172
- s11 = peg$parseplain_line();
7173
- if (s11 !== peg$FAILED) {
7174
- s10 = [s10, s11];
7175
- s9 = s10;
7450
+ if (s9 !== peg$FAILED) {
7451
+ s10 = peg$parseraw_line();
7452
+ if (s10 !== peg$FAILED) {
7453
+ peg$savedPos = s8;
7454
+ s9 = peg$c184(s1, s3, s10);
7455
+ s8 = s9;
7176
7456
  }
7177
7457
  else {
7178
- peg$currPos = s9;
7179
- s9 = peg$FAILED;
7458
+ peg$currPos = s8;
7459
+ s8 = peg$FAILED;
7180
7460
  }
7181
7461
  }
7182
7462
  else {
7183
- peg$currPos = s9;
7184
- s9 = peg$FAILED;
7463
+ peg$currPos = s8;
7464
+ s8 = peg$FAILED;
7185
7465
  }
7186
- while (s9 !== peg$FAILED) {
7187
- s8.push(s9);
7466
+ while (s8 !== peg$FAILED) {
7467
+ s7.push(s8);
7468
+ s8 = peg$currPos;
7188
7469
  s9 = peg$currPos;
7189
- s10 = peg$currPos;
7190
7470
  peg$silentFails++;
7191
- s11 = peg$parseemptyline();
7471
+ s10 = peg$parseemptyline();
7192
7472
  peg$silentFails--;
7193
- if (s11 === peg$FAILED) {
7194
- s10 = void 0;
7473
+ if (s10 === peg$FAILED) {
7474
+ s9 = void 0;
7195
7475
  }
7196
7476
  else {
7197
- peg$currPos = s10;
7198
- s10 = peg$FAILED;
7477
+ peg$currPos = s9;
7478
+ s9 = peg$FAILED;
7199
7479
  }
7200
- if (s10 !== peg$FAILED) {
7201
- s11 = peg$parseplain_line();
7202
- if (s11 !== peg$FAILED) {
7203
- s10 = [s10, s11];
7204
- s9 = s10;
7480
+ if (s9 !== peg$FAILED) {
7481
+ s10 = peg$parseraw_line();
7482
+ if (s10 !== peg$FAILED) {
7483
+ peg$savedPos = s8;
7484
+ s9 = peg$c184(s1, s3, s10);
7485
+ s8 = s9;
7205
7486
  }
7206
7487
  else {
7207
- peg$currPos = s9;
7208
- s9 = peg$FAILED;
7488
+ peg$currPos = s8;
7489
+ s8 = peg$FAILED;
7209
7490
  }
7210
7491
  }
7211
7492
  else {
7212
- peg$currPos = s9;
7213
- s9 = peg$FAILED;
7493
+ peg$currPos = s8;
7494
+ s8 = peg$FAILED;
7214
7495
  }
7215
7496
  }
7216
- if (s8 !== peg$FAILED) {
7217
- s7 = input.substring(s7, peg$currPos);
7218
- }
7219
- else {
7220
- s7 = s8;
7221
- }
7222
7497
  if (s7 !== peg$FAILED) {
7223
7498
  peg$savedPos = s0;
7224
- s1 = peg$c181(s1, s3, s7);
7499
+ s1 = peg$c185(s1, s3, s7);
7225
7500
  s0 = s1;
7226
7501
  }
7227
7502
  else {
@@ -7294,7 +7569,7 @@ function peg$parse(input, options) {
7294
7569
  }
7295
7570
  if (s5 !== peg$FAILED) {
7296
7571
  peg$savedPos = peg$currPos;
7297
- s6 = peg$c182(s1, s3);
7572
+ s6 = peg$c186(s1, s3);
7298
7573
  if (s6) {
7299
7574
  s6 = void 0;
7300
7575
  }
@@ -7303,7 +7578,7 @@ function peg$parse(input, options) {
7303
7578
  }
7304
7579
  if (s6 !== peg$FAILED) {
7305
7580
  peg$savedPos = peg$currPos;
7306
- s7 = peg$c183(s1, s3);
7581
+ s7 = peg$c187(s1, s3);
7307
7582
  if (s7) {
7308
7583
  s7 = void 0;
7309
7584
  }
@@ -7314,7 +7589,7 @@ function peg$parse(input, options) {
7314
7589
  s8 = peg$parsetableContents();
7315
7590
  if (s8 !== peg$FAILED) {
7316
7591
  peg$savedPos = s0;
7317
- s1 = peg$c184(s1, s3, s8);
7592
+ s1 = peg$c188(s1, s3, s8);
7318
7593
  s0 = s1;
7319
7594
  }
7320
7595
  else {
@@ -7359,7 +7634,7 @@ function peg$parse(input, options) {
7359
7634
  return s0;
7360
7635
  }
7361
7636
  function peg$parseabbreviatedBlock() {
7362
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
7637
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
7363
7638
  s0 = peg$currPos;
7364
7639
  s1 = peg$currPos;
7365
7640
  s2 = peg$parse_();
@@ -7391,74 +7666,69 @@ function peg$parse(input, options) {
7391
7666
  s5 = peg$parseraw_text_until_eol();
7392
7667
  }
7393
7668
  if (s5 !== peg$FAILED) {
7394
- s6 = peg$currPos;
7395
- s7 = [];
7669
+ s6 = [];
7670
+ s7 = peg$currPos;
7396
7671
  s8 = peg$currPos;
7397
- s9 = peg$currPos;
7398
7672
  peg$silentFails++;
7399
- s10 = peg$parseemptyline();
7673
+ s9 = peg$parseemptyline();
7400
7674
  peg$silentFails--;
7401
- if (s10 === peg$FAILED) {
7402
- s9 = void 0;
7675
+ if (s9 === peg$FAILED) {
7676
+ s8 = void 0;
7403
7677
  }
7404
7678
  else {
7405
- peg$currPos = s9;
7406
- s9 = peg$FAILED;
7679
+ peg$currPos = s8;
7680
+ s8 = peg$FAILED;
7407
7681
  }
7408
- if (s9 !== peg$FAILED) {
7409
- s10 = peg$parsetext_content();
7410
- if (s10 !== peg$FAILED) {
7411
- s9 = [s9, s10];
7412
- s8 = s9;
7682
+ if (s8 !== peg$FAILED) {
7683
+ s9 = peg$parsetext_content();
7684
+ if (s9 !== peg$FAILED) {
7685
+ peg$savedPos = s7;
7686
+ s8 = peg$c189(s1, s3, s5, s9);
7687
+ s7 = s8;
7413
7688
  }
7414
7689
  else {
7415
- peg$currPos = s8;
7416
- s8 = peg$FAILED;
7690
+ peg$currPos = s7;
7691
+ s7 = peg$FAILED;
7417
7692
  }
7418
7693
  }
7419
7694
  else {
7420
- peg$currPos = s8;
7421
- s8 = peg$FAILED;
7695
+ peg$currPos = s7;
7696
+ s7 = peg$FAILED;
7422
7697
  }
7423
- while (s8 !== peg$FAILED) {
7424
- s7.push(s8);
7698
+ while (s7 !== peg$FAILED) {
7699
+ s6.push(s7);
7700
+ s7 = peg$currPos;
7425
7701
  s8 = peg$currPos;
7426
- s9 = peg$currPos;
7427
7702
  peg$silentFails++;
7428
- s10 = peg$parseemptyline();
7703
+ s9 = peg$parseemptyline();
7429
7704
  peg$silentFails--;
7430
- if (s10 === peg$FAILED) {
7431
- s9 = void 0;
7705
+ if (s9 === peg$FAILED) {
7706
+ s8 = void 0;
7432
7707
  }
7433
7708
  else {
7434
- peg$currPos = s9;
7435
- s9 = peg$FAILED;
7709
+ peg$currPos = s8;
7710
+ s8 = peg$FAILED;
7436
7711
  }
7437
- if (s9 !== peg$FAILED) {
7438
- s10 = peg$parsetext_content();
7439
- if (s10 !== peg$FAILED) {
7440
- s9 = [s9, s10];
7441
- s8 = s9;
7712
+ if (s8 !== peg$FAILED) {
7713
+ s9 = peg$parsetext_content();
7714
+ if (s9 !== peg$FAILED) {
7715
+ peg$savedPos = s7;
7716
+ s8 = peg$c189(s1, s3, s5, s9);
7717
+ s7 = s8;
7442
7718
  }
7443
7719
  else {
7444
- peg$currPos = s8;
7445
- s8 = peg$FAILED;
7720
+ peg$currPos = s7;
7721
+ s7 = peg$FAILED;
7446
7722
  }
7447
7723
  }
7448
7724
  else {
7449
- peg$currPos = s8;
7450
- s8 = peg$FAILED;
7725
+ peg$currPos = s7;
7726
+ s7 = peg$FAILED;
7451
7727
  }
7452
7728
  }
7453
- if (s7 !== peg$FAILED) {
7454
- s6 = input.substring(s6, peg$currPos);
7455
- }
7456
- else {
7457
- s6 = s7;
7458
- }
7459
7729
  if (s6 !== peg$FAILED) {
7460
7730
  peg$savedPos = s0;
7461
- s1 = peg$c185(s1, s3, s5, s6);
7731
+ s1 = peg$c190(s1, s3, s5, s6);
7462
7732
  s0 = s1;
7463
7733
  }
7464
7734
  else {
@@ -7508,14 +7778,14 @@ function peg$parse(input, options) {
7508
7778
  s4 = peg$currPos;
7509
7779
  s5 = peg$parse_();
7510
7780
  if (s5 !== peg$FAILED) {
7511
- if (input.substr(peg$currPos, 2) === peg$c186) {
7512
- s6 = peg$c186;
7781
+ if (input.substr(peg$currPos, 2) === peg$c191) {
7782
+ s6 = peg$c191;
7513
7783
  peg$currPos += 2;
7514
7784
  }
7515
7785
  else {
7516
7786
  s6 = peg$FAILED;
7517
7787
  if (peg$silentFails === 0) {
7518
- peg$fail(peg$c187);
7788
+ peg$fail(peg$c192);
7519
7789
  }
7520
7790
  }
7521
7791
  if (s6 !== peg$FAILED) {
@@ -7538,7 +7808,7 @@ function peg$parse(input, options) {
7538
7808
  s10 = peg$parsenewline();
7539
7809
  if (s10 !== peg$FAILED) {
7540
7810
  peg$savedPos = s4;
7541
- s5 = peg$c117(s1, s8);
7811
+ s5 = peg$c119(s1, s8);
7542
7812
  s4 = s5;
7543
7813
  }
7544
7814
  else {
@@ -7575,14 +7845,14 @@ function peg$parse(input, options) {
7575
7845
  s4 = peg$currPos;
7576
7846
  s5 = peg$parse_();
7577
7847
  if (s5 !== peg$FAILED) {
7578
- if (input.substr(peg$currPos, 2) === peg$c186) {
7579
- s6 = peg$c186;
7848
+ if (input.substr(peg$currPos, 2) === peg$c191) {
7849
+ s6 = peg$c191;
7580
7850
  peg$currPos += 2;
7581
7851
  }
7582
7852
  else {
7583
7853
  s6 = peg$FAILED;
7584
7854
  if (peg$silentFails === 0) {
7585
- peg$fail(peg$c187);
7855
+ peg$fail(peg$c192);
7586
7856
  }
7587
7857
  }
7588
7858
  if (s6 !== peg$FAILED) {
@@ -7605,7 +7875,7 @@ function peg$parse(input, options) {
7605
7875
  s10 = peg$parsenewline();
7606
7876
  if (s10 !== peg$FAILED) {
7607
7877
  peg$savedPos = s4;
7608
- s5 = peg$c117(s1, s8);
7878
+ s5 = peg$c119(s1, s8);
7609
7879
  s4 = s5;
7610
7880
  }
7611
7881
  else {
@@ -7640,7 +7910,7 @@ function peg$parse(input, options) {
7640
7910
  }
7641
7911
  if (s3 !== peg$FAILED) {
7642
7912
  peg$savedPos = s0;
7643
- s1 = peg$c188(s1, s3);
7913
+ s1 = peg$c193(s1, s3);
7644
7914
  s0 = s1;
7645
7915
  }
7646
7916
  else {
@@ -7679,7 +7949,7 @@ function peg$parse(input, options) {
7679
7949
  s3 = peg$parseEOL();
7680
7950
  if (s3 !== peg$FAILED) {
7681
7951
  peg$savedPos = s0;
7682
- s1 = peg$c189(s1);
7952
+ s1 = peg$c194(s1);
7683
7953
  s0 = s1;
7684
7954
  }
7685
7955
  else {
@@ -7704,13 +7974,13 @@ function peg$parse(input, options) {
7704
7974
  s1 = peg$parse_();
7705
7975
  if (s1 !== peg$FAILED) {
7706
7976
  if (input.charCodeAt(peg$currPos) === 58) {
7707
- s2 = peg$c56;
7977
+ s2 = peg$c58;
7708
7978
  peg$currPos++;
7709
7979
  }
7710
7980
  else {
7711
7981
  s2 = peg$FAILED;
7712
7982
  if (peg$silentFails === 0) {
7713
- peg$fail(peg$c57);
7983
+ peg$fail(peg$c59);
7714
7984
  }
7715
7985
  }
7716
7986
  if (s2 !== peg$FAILED) {
@@ -7820,7 +8090,7 @@ function peg$parse(input, options) {
7820
8090
  s6 = peg$parseEOL();
7821
8091
  if (s6 !== peg$FAILED) {
7822
8092
  peg$savedPos = s0;
7823
- s1 = peg$c190(s3, s5);
8093
+ s1 = peg$c195(s3, s5);
7824
8094
  s0 = s1;
7825
8095
  }
7826
8096
  else {
@@ -7970,7 +8240,7 @@ function peg$parse(input, options) {
7970
8240
  s5 = peg$parseEOL();
7971
8241
  if (s5 !== peg$FAILED) {
7972
8242
  peg$savedPos = s3;
7973
- s4 = peg$c191(s4);
8243
+ s4 = peg$c196(s4);
7974
8244
  s3 = s4;
7975
8245
  }
7976
8246
  else {
@@ -7985,7 +8255,7 @@ function peg$parse(input, options) {
7985
8255
  }
7986
8256
  if (s3 !== peg$FAILED) {
7987
8257
  peg$savedPos = s0;
7988
- s1 = peg$c192(s3);
8258
+ s1 = peg$c197(s3);
7989
8259
  s0 = s1;
7990
8260
  }
7991
8261
  else {
@@ -8016,14 +8286,14 @@ function peg$parse(input, options) {
8016
8286
  s1 = s2;
8017
8287
  }
8018
8288
  if (s1 !== peg$FAILED) {
8019
- if (input.substr(peg$currPos, 4) === peg$c193) {
8020
- s2 = peg$c193;
8289
+ if (input.substr(peg$currPos, 4) === peg$c198) {
8290
+ s2 = peg$c198;
8021
8291
  peg$currPos += 4;
8022
8292
  }
8023
8293
  else {
8024
8294
  s2 = peg$FAILED;
8025
8295
  if (peg$silentFails === 0) {
8026
- peg$fail(peg$c194);
8296
+ peg$fail(peg$c199);
8027
8297
  }
8028
8298
  }
8029
8299
  if (s2 !== peg$FAILED) {
@@ -8052,7 +8322,7 @@ function peg$parse(input, options) {
8052
8322
  }
8053
8323
  if (s5 !== peg$FAILED) {
8054
8324
  peg$savedPos = s0;
8055
- s1 = peg$c195(s1, s4, s5);
8325
+ s1 = peg$c200(s1, s4, s5);
8056
8326
  s0 = s1;
8057
8327
  }
8058
8328
  else {
@@ -8120,7 +8390,7 @@ function peg$parse(input, options) {
8120
8390
  s6 = peg$parsealias_replacement_text();
8121
8391
  if (s6 !== peg$FAILED) {
8122
8392
  peg$savedPos = s0;
8123
- s1 = peg$c196(s1, s2, s4, s6);
8393
+ s1 = peg$c201(s1, s2, s4, s6);
8124
8394
  s0 = s1;
8125
8395
  }
8126
8396
  else {
@@ -8181,25 +8451,25 @@ function peg$parse(input, options) {
8181
8451
  if (s3 !== peg$FAILED) {
8182
8452
  s4 = peg$currPos;
8183
8453
  s5 = peg$currPos;
8184
- if (peg$c197.test(input.charAt(peg$currPos))) {
8454
+ if (peg$c202.test(input.charAt(peg$currPos))) {
8185
8455
  s6 = input.charAt(peg$currPos);
8186
8456
  peg$currPos++;
8187
8457
  }
8188
8458
  else {
8189
8459
  s6 = peg$FAILED;
8190
8460
  if (peg$silentFails === 0) {
8191
- peg$fail(peg$c198);
8461
+ peg$fail(peg$c203);
8192
8462
  }
8193
8463
  }
8194
8464
  if (s6 !== peg$FAILED) {
8195
- if (input.substr(peg$currPos, 2) === peg$c199) {
8196
- s7 = peg$c199;
8465
+ if (input.substr(peg$currPos, 2) === peg$c204) {
8466
+ s7 = peg$c204;
8197
8467
  peg$currPos += 2;
8198
8468
  }
8199
8469
  else {
8200
8470
  s7 = peg$FAILED;
8201
8471
  if (peg$silentFails === 0) {
8202
- peg$fail(peg$c200);
8472
+ peg$fail(peg$c205);
8203
8473
  }
8204
8474
  }
8205
8475
  if (s7 !== peg$FAILED) {
@@ -8230,7 +8500,7 @@ function peg$parse(input, options) {
8230
8500
  s6 = peg$parsepod_configuration();
8231
8501
  if (s6 !== peg$FAILED) {
8232
8502
  peg$savedPos = s0;
8233
- s1 = peg$c201(s1, s2, s4, s6);
8503
+ s1 = peg$c206(s1, s2, s4, s6);
8234
8504
  s0 = s1;
8235
8505
  }
8236
8506
  else {
@@ -8276,14 +8546,14 @@ function peg$parse(input, options) {
8276
8546
  s1 = s2;
8277
8547
  }
8278
8548
  if (s1 !== peg$FAILED) {
8279
- if (input.substr(peg$currPos, 9) === peg$c202) {
8280
- s2 = peg$c202;
8549
+ if (input.substr(peg$currPos, 9) === peg$c207) {
8550
+ s2 = peg$c207;
8281
8551
  peg$currPos += 9;
8282
8552
  }
8283
8553
  else {
8284
8554
  s2 = peg$FAILED;
8285
8555
  if (peg$silentFails === 0) {
8286
- peg$fail(peg$c203);
8556
+ peg$fail(peg$c208);
8287
8557
  }
8288
8558
  }
8289
8559
  if (s2 !== peg$FAILED) {
@@ -8292,7 +8562,7 @@ function peg$parse(input, options) {
8292
8562
  s4 = peg$parsepod_configuration();
8293
8563
  if (s4 !== peg$FAILED) {
8294
8564
  peg$savedPos = s0;
8295
- s1 = peg$c204(s1, s2, s4);
8565
+ s1 = peg$c209(s1, s2, s4);
8296
8566
  s0 = s1;
8297
8567
  }
8298
8568
  else {
@@ -8317,7 +8587,7 @@ function peg$parse(input, options) {
8317
8587
  return s0;
8318
8588
  }
8319
8589
  function peg$parseparagraphBlockRaw() {
8320
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
8590
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
8321
8591
  s0 = peg$currPos;
8322
8592
  s1 = peg$currPos;
8323
8593
  s2 = peg$parse_();
@@ -8337,7 +8607,7 @@ function peg$parse(input, options) {
8337
8607
  s5 = peg$parsepod_configuration();
8338
8608
  if (s5 !== peg$FAILED) {
8339
8609
  peg$savedPos = peg$currPos;
8340
- s6 = peg$c205(s1, s2, s3, s5);
8610
+ s6 = peg$c210(s1, s2, s3, s5);
8341
8611
  if (s6) {
8342
8612
  s6 = void 0;
8343
8613
  }
@@ -8345,74 +8615,69 @@ function peg$parse(input, options) {
8345
8615
  s6 = peg$FAILED;
8346
8616
  }
8347
8617
  if (s6 !== peg$FAILED) {
8348
- s7 = peg$currPos;
8349
- s8 = [];
8618
+ s7 = [];
8619
+ s8 = peg$currPos;
8350
8620
  s9 = peg$currPos;
8351
- s10 = peg$currPos;
8352
8621
  peg$silentFails++;
8353
- s11 = peg$parseemptyline();
8622
+ s10 = peg$parseemptyline();
8354
8623
  peg$silentFails--;
8355
- if (s11 === peg$FAILED) {
8356
- s10 = void 0;
8624
+ if (s10 === peg$FAILED) {
8625
+ s9 = void 0;
8357
8626
  }
8358
8627
  else {
8359
- peg$currPos = s10;
8360
- s10 = peg$FAILED;
8628
+ peg$currPos = s9;
8629
+ s9 = peg$FAILED;
8361
8630
  }
8362
- if (s10 !== peg$FAILED) {
8363
- s11 = peg$parseplain_line();
8364
- if (s11 !== peg$FAILED) {
8365
- s10 = [s10, s11];
8366
- s9 = s10;
8631
+ if (s9 !== peg$FAILED) {
8632
+ s10 = peg$parseraw_line();
8633
+ if (s10 !== peg$FAILED) {
8634
+ peg$savedPos = s8;
8635
+ s9 = peg$c211(s1, s2, s3, s5, s10);
8636
+ s8 = s9;
8367
8637
  }
8368
8638
  else {
8369
- peg$currPos = s9;
8370
- s9 = peg$FAILED;
8639
+ peg$currPos = s8;
8640
+ s8 = peg$FAILED;
8371
8641
  }
8372
8642
  }
8373
8643
  else {
8374
- peg$currPos = s9;
8375
- s9 = peg$FAILED;
8644
+ peg$currPos = s8;
8645
+ s8 = peg$FAILED;
8376
8646
  }
8377
- while (s9 !== peg$FAILED) {
8378
- s8.push(s9);
8647
+ while (s8 !== peg$FAILED) {
8648
+ s7.push(s8);
8649
+ s8 = peg$currPos;
8379
8650
  s9 = peg$currPos;
8380
- s10 = peg$currPos;
8381
8651
  peg$silentFails++;
8382
- s11 = peg$parseemptyline();
8652
+ s10 = peg$parseemptyline();
8383
8653
  peg$silentFails--;
8384
- if (s11 === peg$FAILED) {
8385
- s10 = void 0;
8654
+ if (s10 === peg$FAILED) {
8655
+ s9 = void 0;
8386
8656
  }
8387
8657
  else {
8388
- peg$currPos = s10;
8389
- s10 = peg$FAILED;
8658
+ peg$currPos = s9;
8659
+ s9 = peg$FAILED;
8390
8660
  }
8391
- if (s10 !== peg$FAILED) {
8392
- s11 = peg$parseplain_line();
8393
- if (s11 !== peg$FAILED) {
8394
- s10 = [s10, s11];
8395
- s9 = s10;
8661
+ if (s9 !== peg$FAILED) {
8662
+ s10 = peg$parseraw_line();
8663
+ if (s10 !== peg$FAILED) {
8664
+ peg$savedPos = s8;
8665
+ s9 = peg$c211(s1, s2, s3, s5, s10);
8666
+ s8 = s9;
8396
8667
  }
8397
8668
  else {
8398
- peg$currPos = s9;
8399
- s9 = peg$FAILED;
8669
+ peg$currPos = s8;
8670
+ s8 = peg$FAILED;
8400
8671
  }
8401
8672
  }
8402
8673
  else {
8403
- peg$currPos = s9;
8404
- s9 = peg$FAILED;
8674
+ peg$currPos = s8;
8675
+ s8 = peg$FAILED;
8405
8676
  }
8406
8677
  }
8407
- if (s8 !== peg$FAILED) {
8408
- s7 = input.substring(s7, peg$currPos);
8409
- }
8410
- else {
8411
- s7 = s8;
8412
- }
8413
8678
  if (s7 !== peg$FAILED) {
8414
8679
  peg$savedPos = s0;
8415
- s1 = peg$c206(s1, s2, s3, s5, s7);
8680
+ s1 = peg$c212(s1, s2, s3, s5, s7);
8416
8681
  s0 = s1;
8417
8682
  }
8418
8683
  else {
@@ -8472,7 +8737,7 @@ function peg$parse(input, options) {
8472
8737
  s5 = peg$parsepod_configuration();
8473
8738
  if (s5 !== peg$FAILED) {
8474
8739
  peg$savedPos = peg$currPos;
8475
- s6 = peg$c207(s1, s2, s3, s5);
8740
+ s6 = peg$c213(s1, s2, s3, s5);
8476
8741
  if (s6) {
8477
8742
  s6 = void 0;
8478
8743
  }
@@ -8481,7 +8746,7 @@ function peg$parse(input, options) {
8481
8746
  }
8482
8747
  if (s6 !== peg$FAILED) {
8483
8748
  peg$savedPos = peg$currPos;
8484
- s7 = peg$c208(s1, s2, s3, s5);
8749
+ s7 = peg$c214(s1, s2, s3, s5);
8485
8750
  if (s7) {
8486
8751
  s7 = void 0;
8487
8752
  }
@@ -8492,7 +8757,7 @@ function peg$parse(input, options) {
8492
8757
  s8 = peg$parsetableContents();
8493
8758
  if (s8 !== peg$FAILED) {
8494
8759
  peg$savedPos = s0;
8495
- s1 = peg$c209(s1, s2, s3, s5, s8);
8760
+ s1 = peg$c215(s1, s2, s3, s5, s8);
8496
8761
  s0 = s1;
8497
8762
  }
8498
8763
  else {
@@ -8537,7 +8802,7 @@ function peg$parse(input, options) {
8537
8802
  return s0;
8538
8803
  }
8539
8804
  function peg$parseparagraphBlock() {
8540
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
8805
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
8541
8806
  s0 = peg$currPos;
8542
8807
  s1 = peg$currPos;
8543
8808
  s2 = peg$parse_();
@@ -8556,74 +8821,69 @@ function peg$parse(input, options) {
8556
8821
  if (s4 !== peg$FAILED) {
8557
8822
  s5 = peg$parsepod_configuration();
8558
8823
  if (s5 !== peg$FAILED) {
8559
- s6 = peg$currPos;
8560
- s7 = [];
8824
+ s6 = [];
8825
+ s7 = peg$currPos;
8561
8826
  s8 = peg$currPos;
8562
- s9 = peg$currPos;
8563
8827
  peg$silentFails++;
8564
- s10 = peg$parseemptyline();
8828
+ s9 = peg$parseemptyline();
8565
8829
  peg$silentFails--;
8566
- if (s10 === peg$FAILED) {
8567
- s9 = void 0;
8830
+ if (s9 === peg$FAILED) {
8831
+ s8 = void 0;
8568
8832
  }
8569
8833
  else {
8570
- peg$currPos = s9;
8571
- s9 = peg$FAILED;
8834
+ peg$currPos = s8;
8835
+ s8 = peg$FAILED;
8572
8836
  }
8573
- if (s9 !== peg$FAILED) {
8574
- s10 = peg$parsetext_content();
8575
- if (s10 !== peg$FAILED) {
8576
- s9 = [s9, s10];
8577
- s8 = s9;
8837
+ if (s8 !== peg$FAILED) {
8838
+ s9 = peg$parsetext_content();
8839
+ if (s9 !== peg$FAILED) {
8840
+ peg$savedPos = s7;
8841
+ s8 = peg$c211(s1, s2, s3, s5, s9);
8842
+ s7 = s8;
8578
8843
  }
8579
8844
  else {
8580
- peg$currPos = s8;
8581
- s8 = peg$FAILED;
8845
+ peg$currPos = s7;
8846
+ s7 = peg$FAILED;
8582
8847
  }
8583
8848
  }
8584
8849
  else {
8585
- peg$currPos = s8;
8586
- s8 = peg$FAILED;
8850
+ peg$currPos = s7;
8851
+ s7 = peg$FAILED;
8587
8852
  }
8588
- while (s8 !== peg$FAILED) {
8589
- s7.push(s8);
8853
+ while (s7 !== peg$FAILED) {
8854
+ s6.push(s7);
8855
+ s7 = peg$currPos;
8590
8856
  s8 = peg$currPos;
8591
- s9 = peg$currPos;
8592
8857
  peg$silentFails++;
8593
- s10 = peg$parseemptyline();
8858
+ s9 = peg$parseemptyline();
8594
8859
  peg$silentFails--;
8595
- if (s10 === peg$FAILED) {
8596
- s9 = void 0;
8860
+ if (s9 === peg$FAILED) {
8861
+ s8 = void 0;
8597
8862
  }
8598
8863
  else {
8599
- peg$currPos = s9;
8600
- s9 = peg$FAILED;
8864
+ peg$currPos = s8;
8865
+ s8 = peg$FAILED;
8601
8866
  }
8602
- if (s9 !== peg$FAILED) {
8603
- s10 = peg$parsetext_content();
8604
- if (s10 !== peg$FAILED) {
8605
- s9 = [s9, s10];
8606
- s8 = s9;
8867
+ if (s8 !== peg$FAILED) {
8868
+ s9 = peg$parsetext_content();
8869
+ if (s9 !== peg$FAILED) {
8870
+ peg$savedPos = s7;
8871
+ s8 = peg$c211(s1, s2, s3, s5, s9);
8872
+ s7 = s8;
8607
8873
  }
8608
8874
  else {
8609
- peg$currPos = s8;
8610
- s8 = peg$FAILED;
8875
+ peg$currPos = s7;
8876
+ s7 = peg$FAILED;
8611
8877
  }
8612
8878
  }
8613
8879
  else {
8614
- peg$currPos = s8;
8615
- s8 = peg$FAILED;
8880
+ peg$currPos = s7;
8881
+ s7 = peg$FAILED;
8616
8882
  }
8617
8883
  }
8618
- if (s7 !== peg$FAILED) {
8619
- s6 = input.substring(s6, peg$currPos);
8620
- }
8621
- else {
8622
- s6 = s7;
8623
- }
8624
8884
  if (s6 !== peg$FAILED) {
8625
8885
  peg$savedPos = s0;
8626
- s1 = peg$c210(s1, s2, s3, s5, s6);
8886
+ s1 = peg$c216(s1, s2, s3, s5, s6);
8627
8887
  s0 = s1;
8628
8888
  }
8629
8889
  else {
@@ -8661,38 +8921,38 @@ function peg$parse(input, options) {
8661
8921
  var s0, s1, s2, s3, s4;
8662
8922
  s0 = peg$currPos;
8663
8923
  s1 = peg$currPos;
8664
- if (peg$c211.test(input.charAt(peg$currPos))) {
8924
+ if (peg$c217.test(input.charAt(peg$currPos))) {
8665
8925
  s2 = input.charAt(peg$currPos);
8666
8926
  peg$currPos++;
8667
8927
  }
8668
8928
  else {
8669
8929
  s2 = peg$FAILED;
8670
8930
  if (peg$silentFails === 0) {
8671
- peg$fail(peg$c212);
8931
+ peg$fail(peg$c218);
8672
8932
  }
8673
8933
  }
8674
8934
  if (s2 !== peg$FAILED) {
8675
8935
  s3 = [];
8676
- if (peg$c47.test(input.charAt(peg$currPos))) {
8936
+ if (peg$c49.test(input.charAt(peg$currPos))) {
8677
8937
  s4 = input.charAt(peg$currPos);
8678
8938
  peg$currPos++;
8679
8939
  }
8680
8940
  else {
8681
8941
  s4 = peg$FAILED;
8682
8942
  if (peg$silentFails === 0) {
8683
- peg$fail(peg$c48);
8943
+ peg$fail(peg$c50);
8684
8944
  }
8685
8945
  }
8686
8946
  while (s4 !== peg$FAILED) {
8687
8947
  s3.push(s4);
8688
- if (peg$c47.test(input.charAt(peg$currPos))) {
8948
+ if (peg$c49.test(input.charAt(peg$currPos))) {
8689
8949
  s4 = input.charAt(peg$currPos);
8690
8950
  peg$currPos++;
8691
8951
  }
8692
8952
  else {
8693
8953
  s4 = peg$FAILED;
8694
8954
  if (peg$silentFails === 0) {
8695
- peg$fail(peg$c48);
8955
+ peg$fail(peg$c50);
8696
8956
  }
8697
8957
  }
8698
8958
  }
@@ -8721,26 +8981,26 @@ function peg$parse(input, options) {
8721
8981
  var s0, s1;
8722
8982
  peg$silentFails++;
8723
8983
  s0 = [];
8724
- if (peg$c214.test(input.charAt(peg$currPos))) {
8984
+ if (peg$c220.test(input.charAt(peg$currPos))) {
8725
8985
  s1 = input.charAt(peg$currPos);
8726
8986
  peg$currPos++;
8727
8987
  }
8728
8988
  else {
8729
8989
  s1 = peg$FAILED;
8730
8990
  if (peg$silentFails === 0) {
8731
- peg$fail(peg$c215);
8991
+ peg$fail(peg$c221);
8732
8992
  }
8733
8993
  }
8734
8994
  while (s1 !== peg$FAILED) {
8735
8995
  s0.push(s1);
8736
- if (peg$c214.test(input.charAt(peg$currPos))) {
8996
+ if (peg$c220.test(input.charAt(peg$currPos))) {
8737
8997
  s1 = input.charAt(peg$currPos);
8738
8998
  peg$currPos++;
8739
8999
  }
8740
9000
  else {
8741
9001
  s1 = peg$FAILED;
8742
9002
  if (peg$silentFails === 0) {
8743
- peg$fail(peg$c215);
9003
+ peg$fail(peg$c221);
8744
9004
  }
8745
9005
  }
8746
9006
  }
@@ -8748,7 +9008,7 @@ function peg$parse(input, options) {
8748
9008
  if (s0 === peg$FAILED) {
8749
9009
  s1 = peg$FAILED;
8750
9010
  if (peg$silentFails === 0) {
8751
- peg$fail(peg$c213);
9011
+ peg$fail(peg$c219);
8752
9012
  }
8753
9013
  }
8754
9014
  return s0;
@@ -8757,26 +9017,26 @@ function peg$parse(input, options) {
8757
9017
  var s0, s1;
8758
9018
  peg$silentFails++;
8759
9019
  s0 = [];
8760
- if (peg$c214.test(input.charAt(peg$currPos))) {
9020
+ if (peg$c220.test(input.charAt(peg$currPos))) {
8761
9021
  s1 = input.charAt(peg$currPos);
8762
9022
  peg$currPos++;
8763
9023
  }
8764
9024
  else {
8765
9025
  s1 = peg$FAILED;
8766
9026
  if (peg$silentFails === 0) {
8767
- peg$fail(peg$c215);
9027
+ peg$fail(peg$c221);
8768
9028
  }
8769
9029
  }
8770
9030
  while (s1 !== peg$FAILED) {
8771
9031
  s0.push(s1);
8772
- if (peg$c214.test(input.charAt(peg$currPos))) {
9032
+ if (peg$c220.test(input.charAt(peg$currPos))) {
8773
9033
  s1 = input.charAt(peg$currPos);
8774
9034
  peg$currPos++;
8775
9035
  }
8776
9036
  else {
8777
9037
  s1 = peg$FAILED;
8778
9038
  if (peg$silentFails === 0) {
8779
- peg$fail(peg$c215);
9039
+ peg$fail(peg$c221);
8780
9040
  }
8781
9041
  }
8782
9042
  }
@@ -8784,7 +9044,7 @@ function peg$parse(input, options) {
8784
9044
  if (s0 === peg$FAILED) {
8785
9045
  s1 = peg$FAILED;
8786
9046
  if (peg$silentFails === 0) {
8787
- peg$fail(peg$c216);
9047
+ peg$fail(peg$c222);
8788
9048
  }
8789
9049
  }
8790
9050
  return s0;