@podlite/schema 0.0.83 → 0.0.85

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (70) hide show
  1. package/CHANGELOG.podlite +30 -0
  2. package/esm/ast-inerator.js +1 -3
  3. package/esm/ast-inerator.js.map +1 -1
  4. package/esm/codes/scan.js +26 -22
  5. package/esm/codes/scan.js.map +1 -1
  6. package/esm/grammar.js +531 -416
  7. package/esm/grammar.js.map +1 -1
  8. package/esm/helpers/flatten-deep.d.ts +2 -0
  9. package/esm/helpers/flatten-deep.js +32 -0
  10. package/esm/helpers/flatten-deep.js.map +1 -0
  11. package/esm/helpers/itemNumbering.d.ts +2 -1
  12. package/esm/helpers/itemNumbering.js +3 -2
  13. package/esm/helpers/itemNumbering.js.map +1 -1
  14. package/esm/helpers/makeInterator.js +3 -6
  15. package/esm/helpers/makeInterator.js.map +1 -1
  16. package/esm/helpers/makeTransformer.js +1 -3
  17. package/esm/helpers/makeTransformer.js.map +1 -1
  18. package/esm/helpers/numberedShorthand.d.ts +2 -1
  19. package/esm/helpers/numberedShorthand.js +24 -4
  20. package/esm/helpers/numberedShorthand.js.map +1 -1
  21. package/esm/index.d.ts +3 -0
  22. package/esm/index.js +3 -0
  23. package/esm/index.js.map +1 -1
  24. package/esm/markup-code-letters.d.ts +2 -0
  25. package/esm/markup-code-letters.js +65 -0
  26. package/esm/markup-code-letters.js.map +1 -0
  27. package/esm/pluggableParser.js +13 -5
  28. package/esm/pluggableParser.js.map +1 -1
  29. package/esm/plugin-defn-fill-term.js +7 -0
  30. package/esm/plugin-defn-fill-term.js.map +1 -1
  31. package/esm/plugin-group-defn.js +6 -8
  32. package/esm/plugin-group-defn.js.map +1 -1
  33. package/esm/plugin-group-items.d.ts +4 -1
  34. package/esm/plugin-group-items.js +43 -9
  35. package/esm/plugin-group-items.js.map +1 -1
  36. package/esm/plugin-items.js +6 -5
  37. package/esm/plugin-items.js.map +1 -1
  38. package/esm/plugin-tables.js +33 -10
  39. package/esm/plugin-tables.js.map +1 -1
  40. package/esm/types.d.ts +1 -1
  41. package/esm/version.d.ts +1 -1
  42. package/esm/version.js +1 -1
  43. package/lib/ast-inerator.js +2 -4
  44. package/lib/codes/scan.js +26 -22
  45. package/lib/grammar.js +531 -416
  46. package/lib/helpers/flatten-deep.d.ts +2 -0
  47. package/lib/helpers/flatten-deep.js +35 -0
  48. package/lib/helpers/itemNumbering.d.ts +2 -1
  49. package/lib/helpers/itemNumbering.js +5 -3
  50. package/lib/helpers/makeInterator.js +3 -6
  51. package/lib/helpers/makeTransformer.js +2 -4
  52. package/lib/helpers/numberedShorthand.d.ts +2 -1
  53. package/lib/helpers/numberedShorthand.js +26 -5
  54. package/lib/index.d.ts +3 -0
  55. package/lib/index.js +7 -2
  56. package/lib/markup-code-letters.d.ts +2 -0
  57. package/lib/markup-code-letters.js +69 -0
  58. package/lib/pluggableParser.js +13 -5
  59. package/lib/plugin-defn-fill-term.js +7 -0
  60. package/lib/plugin-group-defn.js +6 -8
  61. package/lib/plugin-group-items.d.ts +4 -1
  62. package/lib/plugin-group-items.js +44 -12
  63. package/lib/plugin-items.js +5 -4
  64. package/lib/plugin-tables.js +37 -14
  65. package/lib/types.d.ts +1 -1
  66. package/lib/version.d.ts +1 -1
  67. package/lib/version.js +1 -1
  68. package/package.json +1 -1
  69. package/schema/AstTree.json +1 -0
  70. package/schema/PodliteDocument.json +1 -0
package/esm/grammar.js CHANGED
@@ -120,42 +120,42 @@ function peg$parse(input, options) {
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$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) {
123
+ }, peg$c40 = function (first, c) { return c; }, peg$c41 = function (first, rest) { return flattenDeep([first, ...rest]); }, peg$c42 = /^[ \t]/, peg$c43 = peg$classExpectation([" ", "\t"], false, false), peg$c44 = ",", peg$c45 = peg$literalExpectation(",", false), peg$c46 = function (first, i) { return i; }, 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 (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) {
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$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) {
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) {
130
130
  return (array.length > 1)
131
131
  ? { type: 'array', value: array }
132
132
  : { type: valueKind(array[0]), value: array[0] };
133
- }, peg$c106 = ")", peg$c107 = peg$literalExpectation(")", false), peg$c108 = function (isFalse, key, res) { return res; }, peg$c109 = function (isFalse, key) {
133
+ }, peg$c104 = ")", peg$c105 = peg$literalExpectation(")", false), peg$c106 = function (isFalse, key, res) { return res; }, peg$c107 = 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$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) {
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) {
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$c117 = function (isFalse, key) {
145
+ }, peg$c115 = function (isFalse, key) {
146
146
  return {
147
147
  value: !isFalse,
148
148
  type: "boolean"
149
149
  };
150
- }, peg$c118 = function (isFalse, key, value) {
150
+ }, peg$c116 = 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$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) {
156
+ }, peg$c117 = function (first, rest) { return rest; }, peg$c118 = function (first, cont, unread) { return keepReadable(flattenDeep([...first, ...cont])); }, peg$c119 = function () { addDiagnostic(options, "Configuration continuation line could not be read", location()); }, peg$c120 = /^[^'"]/, peg$c121 = peg$classExpectation(["'", "\""], true, false), peg$c122 = function (text) { return text; }, peg$c123 = /^[0-9]/, peg$c124 = peg$classExpectation([["0", "9"]], false, false), peg$c125 = /^[\-+]/, peg$c126 = peg$classExpectation(["-", "+"], false, false), peg$c127 = "True", peg$c128 = peg$literalExpectation("True", false), peg$c129 = function () { return true; }, peg$c130 = "False", peg$c131 = peg$literalExpectation("False", false), peg$c132 = function () { return false; }, peg$c133 = ".", peg$c134 = peg$literalExpectation(".", false), peg$c135 = /^[eE]/, peg$c136 = peg$classExpectation(["e", "E"], false, false), peg$c137 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c138 = function (number) { return parseInt(number, 10); }, peg$c139 = function (vmargin, name, config) {
157
157
  return isRawBlock(name);
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) {
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) {
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$c146 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c147 = function (vmargin, name, config, content, vmargin2, res) {
166
+ }, peg$c144 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c145 = function (vmargin, name, config, content, vmargin2, res) {
167
167
  return {
168
168
  ...res,
169
169
  text: text(),
170
170
  config,
171
171
  location: location()
172
172
  };
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 () {
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 () {
174
174
  return {
175
175
  type: 'separator',
176
176
  text: text()
177
177
  };
178
- }, peg$c153 = function () { return !!options.isDelimited; }, peg$c154 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c155 = function () {
178
+ }, peg$c151 = function () { return !!options.isDelimited; }, peg$c152 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c153 = function () {
179
179
  // reset separator count and its accum
180
180
  options.separators = [];
181
181
  return true;
182
- }, peg$c156 = function (head, t) {
182
+ }, peg$c154 = function (head, t) {
183
183
  options.separators.push(t.text);
184
184
  return t;
185
- }, peg$c157 = function (head, separator, rowtext, t) {
185
+ }, peg$c155 = function (head, separator, rowtext, t) {
186
186
  options.separators.push(t.text);
187
187
  return t;
188
- }, peg$c158 = function (head, separator, rowtext, bseparator) {
188
+ }, peg$c156 = 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$c159 = function (head, separator, singleRow) { return [singleRow]; }, peg$c160 = function (head, separator, rest) {
197
+ }, peg$c157 = function (head, separator, singleRow) { return [singleRow]; }, peg$c158 = 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$c161 = function (head, separator, rest) {
204
+ }, peg$c159 = 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$c162 = function (rowtest, bseparator) {
214
+ }, peg$c160 = 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$c163 = function (rest) {
223
+ }, peg$c161 = function (rest) {
224
224
  return [...flattenDeep(rest)];
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) {
225
+ }, peg$c162 = function (vmargin, name, config) { return name === 'table'; }, peg$c163 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c164 = function (vmargin, name, config, nodes) { return nodes; }, peg$c165 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c166 = 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$c169 = function (vmargin, name, config, content, vmargin2, res) {
232
+ }, peg$c167 = 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$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) {
239
+ }, peg$c168 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c169 = function (vmargin, name, config, t) { return t; }, peg$c170 = 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$c173 = function (vmargin, name, config, content, vmargin2, res) {
246
+ }, peg$c171 = 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$c174 = function (vmargin, name, config, nodes) { return nodes; }, peg$c175 = function (vmargin, name, config, tvmargin, text) {
253
+ }, peg$c172 = function (vmargin, name, config, nodes) { return nodes; }, peg$c173 = 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$c176 = function (vmargin, name, config, content, vmargin2, ename) {
269
+ }, peg$c174 = 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$c177 = function (vmargin, name, config, content, vmargin2, res) {
276
+ }, peg$c175 = function (vmargin, name, config, content, vmargin2, res) {
277
277
  return {
278
278
  ...res,
279
279
  config,
280
280
  location: location(),
281
281
  };
282
- }, peg$c178 = function () {
282
+ }, peg$c176 = 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,9 +304,9 @@ function peg$parse(input, options) {
304
304
  ],
305
305
  location: location(),
306
306
  };
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) {
307
+ }, peg$c177 = function () { return { empty: 1 }; }, peg$c178 = /^[s]/, peg$c179 = peg$classExpectation(["s"], false, false), peg$c180 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c181 = function (vmargin, name) {
308
308
  return isRawBlock(name);
309
- }, peg$c184 = function (vmargin, name, text) { return exludeVMargin(vmargin, text); }, peg$c185 = function (vmargin, name, content) {
309
+ }, peg$c182 = function (vmargin, name, text) { return exludeVMargin(vmargin, text); }, peg$c183 = function (vmargin, name, content) {
310
310
  return {
311
311
  margin: vmargin,
312
312
  type: 'block',
@@ -315,7 +315,7 @@ function peg$parse(input, options) {
315
315
  config: [],
316
316
  location: location()
317
317
  };
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) {
318
+ }, peg$c184 = function (vmargin, name) { return name === 'table'; }, peg$c185 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c186 = function (vmargin, name, content) {
319
319
  return {
320
320
  margin: vmargin,
321
321
  type: 'block',
@@ -325,7 +325,7 @@ function peg$parse(input, options) {
325
325
  config: [],
326
326
  location: location()
327
327
  };
328
- }, peg$c189 = function (vmargin, name, first_line, text) { return exludeVMargin(vmargin, text); }, peg$c190 = function (vmargin, name, first_line, content_rest) {
328
+ }, peg$c187 = function (vmargin, name, first_line, text) { return exludeVMargin(vmargin, text); }, peg$c188 = function (vmargin, name, first_line, content_rest) {
329
329
  const content = (first_line === "\n" ? "" : first_line) + content_rest.join('');
330
330
  return {
331
331
  margin: vmargin,
@@ -348,7 +348,7 @@ function peg$parse(input, options) {
348
348
  name,
349
349
  location: location()
350
350
  };
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) {
351
+ }, peg$c189 = "= ", peg$c190 = peg$literalExpectation("= ", false), peg$c191 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c192 = function (attrs) { return { kind: 'attrs', attrs }; }, peg$c193 = function (name, value) { return { kind: 'alias', name, value }; }, peg$c194 = function (v) { return { kind: 'value', value: v }; }, peg$c195 = function (seg) { return seg; }, peg$c196 = "=set", peg$c197 = peg$literalExpectation("=set", false), peg$c198 = 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$c201 = function (vmargin, marker, name, replacement) {
381
+ }, peg$c199 = 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$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) {
388
+ }, peg$c200 = /^[A-Z]/, peg$c201 = peg$classExpectation([["A", "Z"]], false, false), peg$c202 = "<>", peg$c203 = peg$literalExpectation("<>", false), peg$c204 = 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$c207 = "=boundary", peg$c208 = peg$literalExpectation("=boundary", false), peg$c209 = function (vmargin, marker, config) {
395
+ }, peg$c205 = "=boundary", peg$c206 = peg$literalExpectation("=boundary", false), peg$c207 = function (vmargin, marker, config) {
396
396
  return {
397
397
  name: 'boundary',
398
398
  type: 'block',
@@ -401,9 +401,9 @@ function peg$parse(input, options) {
401
401
  margin: vmargin,
402
402
  location: location()
403
403
  };
404
- }, peg$c210 = function (vmargin, marker, name, config) {
404
+ }, peg$c208 = function (vmargin, marker, name, config) {
405
405
  return isRawBlock(name);
406
- }, peg$c211 = function (vmargin, marker, name, config, text) { return exludeVMargin(vmargin, text); }, peg$c212 = function (vmargin, marker, name, config, content) {
406
+ }, peg$c209 = function (vmargin, marker, name, config, text) { return exludeVMargin(vmargin, text); }, peg$c210 = function (vmargin, marker, name, config, content) {
407
407
  return {
408
408
  type: 'block',
409
409
  content: content.length === 0 ? [] : [{ type: 'verbatim', value: content.join('') }],
@@ -412,7 +412,7 @@ function peg$parse(input, options) {
412
412
  config,
413
413
  location: location()
414
414
  };
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) {
415
+ }, peg$c211 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c212 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c213 = function (vmargin, marker, name, config, content) {
416
416
  return {
417
417
  type: 'block',
418
418
  content: content === "" ? [] : content,
@@ -421,7 +421,7 @@ function peg$parse(input, options) {
421
421
  config,
422
422
  location: location()
423
423
  };
424
- }, peg$c216 = function (vmargin, marker, name, config, lines) {
424
+ }, peg$c214 = function (vmargin, marker, name, config, lines) {
425
425
  const content = lines.join('');
426
426
  return {
427
427
  type: 'block',
@@ -445,7 +445,7 @@ function peg$parse(input, options) {
445
445
  config,
446
446
  location: location()
447
447
  };
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
+ }, peg$c215 = /^[a-zA-Z]/, peg$c216 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c217 = peg$otherExpectation("whitespace"), peg$c218 = /^[\r\n \t\f]/, peg$c219 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c220 = 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;
449
449
  if ("startRule" in options) {
450
450
  if (!(options.startRule in peg$startRuleFunctions)) {
451
451
  throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -1839,33 +1839,75 @@ function peg$parse(input, options) {
1839
1839
  return s0;
1840
1840
  }
1841
1841
  function peg$parsearray_codes() {
1842
- var s0, s1, s2, s3;
1842
+ var s0, s1, s2, s3, s4, s5;
1843
1843
  s0 = peg$currPos;
1844
1844
  s1 = peg$parseFCode();
1845
1845
  if (s1 !== peg$FAILED) {
1846
1846
  s2 = [];
1847
- s3 = peg$parsehs();
1848
- if (s3 !== peg$FAILED) {
1849
- while (s3 !== peg$FAILED) {
1850
- s2.push(s3);
1851
- s3 = peg$parsehs();
1847
+ s3 = peg$currPos;
1848
+ s4 = [];
1849
+ s5 = peg$parsehs();
1850
+ if (s5 !== peg$FAILED) {
1851
+ while (s5 !== peg$FAILED) {
1852
+ s4.push(s5);
1853
+ s5 = peg$parsehs();
1852
1854
  }
1853
1855
  }
1854
1856
  else {
1855
- s2 = peg$FAILED;
1857
+ s4 = peg$FAILED;
1856
1858
  }
1857
- if (s2 !== peg$FAILED) {
1858
- s3 = peg$parsearray_codes();
1859
- if (s3 !== peg$FAILED) {
1860
- peg$savedPos = s0;
1861
- s1 = peg$c40(s1, s3);
1862
- s0 = s1;
1859
+ if (s4 !== peg$FAILED) {
1860
+ s5 = peg$parseFCode();
1861
+ if (s5 !== peg$FAILED) {
1862
+ peg$savedPos = s3;
1863
+ s4 = peg$c40(s1, s5);
1864
+ s3 = s4;
1863
1865
  }
1864
1866
  else {
1865
- peg$currPos = s0;
1866
- s0 = peg$FAILED;
1867
+ peg$currPos = s3;
1868
+ s3 = peg$FAILED;
1867
1869
  }
1868
1870
  }
1871
+ else {
1872
+ peg$currPos = s3;
1873
+ s3 = peg$FAILED;
1874
+ }
1875
+ while (s3 !== peg$FAILED) {
1876
+ s2.push(s3);
1877
+ s3 = peg$currPos;
1878
+ s4 = [];
1879
+ s5 = peg$parsehs();
1880
+ if (s5 !== peg$FAILED) {
1881
+ while (s5 !== peg$FAILED) {
1882
+ s4.push(s5);
1883
+ s5 = peg$parsehs();
1884
+ }
1885
+ }
1886
+ else {
1887
+ s4 = peg$FAILED;
1888
+ }
1889
+ if (s4 !== peg$FAILED) {
1890
+ s5 = peg$parseFCode();
1891
+ if (s5 !== peg$FAILED) {
1892
+ peg$savedPos = s3;
1893
+ s4 = peg$c40(s1, s5);
1894
+ s3 = s4;
1895
+ }
1896
+ else {
1897
+ peg$currPos = s3;
1898
+ s3 = peg$FAILED;
1899
+ }
1900
+ }
1901
+ else {
1902
+ peg$currPos = s3;
1903
+ s3 = peg$FAILED;
1904
+ }
1905
+ }
1906
+ if (s2 !== peg$FAILED) {
1907
+ peg$savedPos = s0;
1908
+ s1 = peg$c41(s1, s2);
1909
+ s0 = s1;
1910
+ }
1869
1911
  else {
1870
1912
  peg$currPos = s0;
1871
1913
  s0 = peg$FAILED;
@@ -1875,15 +1917,6 @@ function peg$parse(input, options) {
1875
1917
  peg$currPos = s0;
1876
1918
  s0 = peg$FAILED;
1877
1919
  }
1878
- if (s0 === peg$FAILED) {
1879
- s0 = peg$currPos;
1880
- s1 = peg$parseFCode();
1881
- if (s1 !== peg$FAILED) {
1882
- peg$savedPos = s0;
1883
- s1 = peg$c41(s1);
1884
- }
1885
- s0 = s1;
1886
- }
1887
1920
  return s0;
1888
1921
  }
1889
1922
  function peg$parseFCode() {
@@ -1998,68 +2031,145 @@ function peg$parse(input, options) {
1998
2031
  return s0;
1999
2032
  }
2000
2033
  function peg$parsearray_items() {
2001
- var s0, s1, s2, s3, s4, s5;
2034
+ var s0, s1, s2, s3, s4, s5, s6, s7;
2002
2035
  s0 = peg$currPos;
2003
2036
  s1 = peg$parseitem();
2004
2037
  if (s1 !== peg$FAILED) {
2005
2038
  s2 = [];
2006
- s3 = peg$parsehs();
2007
- if (s3 !== peg$FAILED) {
2008
- while (s3 !== peg$FAILED) {
2009
- s2.push(s3);
2010
- s3 = peg$parsehs();
2039
+ s3 = peg$currPos;
2040
+ s4 = [];
2041
+ s5 = peg$parsehs();
2042
+ if (s5 !== peg$FAILED) {
2043
+ while (s5 !== peg$FAILED) {
2044
+ s4.push(s5);
2045
+ s5 = peg$parsehs();
2011
2046
  }
2012
2047
  }
2013
2048
  else {
2014
- s2 = peg$FAILED;
2049
+ s4 = peg$FAILED;
2015
2050
  }
2016
- if (s2 === peg$FAILED) {
2017
- s2 = peg$currPos;
2018
- s3 = peg$parsegap();
2019
- if (s3 !== peg$FAILED) {
2051
+ if (s4 === peg$FAILED) {
2052
+ s4 = peg$currPos;
2053
+ s5 = peg$parsegap();
2054
+ if (s5 !== peg$FAILED) {
2020
2055
  if (input.charCodeAt(peg$currPos) === 44) {
2021
- s4 = peg$c44;
2056
+ s6 = peg$c44;
2022
2057
  peg$currPos++;
2023
2058
  }
2024
2059
  else {
2025
- s4 = peg$FAILED;
2060
+ s6 = peg$FAILED;
2026
2061
  if (peg$silentFails === 0) {
2027
2062
  peg$fail(peg$c45);
2028
2063
  }
2029
2064
  }
2030
- if (s4 !== peg$FAILED) {
2031
- s5 = peg$parsegap();
2032
- if (s5 !== peg$FAILED) {
2033
- s3 = [s3, s4, s5];
2034
- s2 = s3;
2065
+ if (s6 !== peg$FAILED) {
2066
+ s7 = peg$parsegap();
2067
+ if (s7 !== peg$FAILED) {
2068
+ s5 = [s5, s6, s7];
2069
+ s4 = s5;
2035
2070
  }
2036
2071
  else {
2037
- peg$currPos = s2;
2038
- s2 = peg$FAILED;
2072
+ peg$currPos = s4;
2073
+ s4 = peg$FAILED;
2039
2074
  }
2040
2075
  }
2041
2076
  else {
2042
- peg$currPos = s2;
2043
- s2 = peg$FAILED;
2077
+ peg$currPos = s4;
2078
+ s4 = peg$FAILED;
2044
2079
  }
2045
2080
  }
2046
2081
  else {
2047
- peg$currPos = s2;
2048
- s2 = peg$FAILED;
2082
+ peg$currPos = s4;
2083
+ s4 = peg$FAILED;
2049
2084
  }
2050
2085
  }
2051
- if (s2 !== peg$FAILED) {
2052
- s3 = peg$parsearray_items();
2053
- if (s3 !== peg$FAILED) {
2054
- peg$savedPos = s0;
2055
- s1 = peg$c46(s1, s3);
2056
- s0 = s1;
2086
+ if (s4 !== peg$FAILED) {
2087
+ s5 = peg$parseitem();
2088
+ if (s5 !== peg$FAILED) {
2089
+ peg$savedPos = s3;
2090
+ s4 = peg$c46(s1, s5);
2091
+ s3 = s4;
2057
2092
  }
2058
2093
  else {
2059
- peg$currPos = s0;
2060
- s0 = peg$FAILED;
2094
+ peg$currPos = s3;
2095
+ s3 = peg$FAILED;
2061
2096
  }
2062
2097
  }
2098
+ else {
2099
+ peg$currPos = s3;
2100
+ s3 = peg$FAILED;
2101
+ }
2102
+ while (s3 !== peg$FAILED) {
2103
+ s2.push(s3);
2104
+ s3 = peg$currPos;
2105
+ s4 = [];
2106
+ s5 = peg$parsehs();
2107
+ if (s5 !== peg$FAILED) {
2108
+ while (s5 !== peg$FAILED) {
2109
+ s4.push(s5);
2110
+ s5 = peg$parsehs();
2111
+ }
2112
+ }
2113
+ else {
2114
+ s4 = peg$FAILED;
2115
+ }
2116
+ if (s4 === peg$FAILED) {
2117
+ s4 = peg$currPos;
2118
+ s5 = peg$parsegap();
2119
+ if (s5 !== peg$FAILED) {
2120
+ if (input.charCodeAt(peg$currPos) === 44) {
2121
+ s6 = peg$c44;
2122
+ peg$currPos++;
2123
+ }
2124
+ else {
2125
+ s6 = peg$FAILED;
2126
+ if (peg$silentFails === 0) {
2127
+ peg$fail(peg$c45);
2128
+ }
2129
+ }
2130
+ if (s6 !== peg$FAILED) {
2131
+ s7 = peg$parsegap();
2132
+ if (s7 !== peg$FAILED) {
2133
+ s5 = [s5, s6, s7];
2134
+ s4 = s5;
2135
+ }
2136
+ else {
2137
+ peg$currPos = s4;
2138
+ s4 = peg$FAILED;
2139
+ }
2140
+ }
2141
+ else {
2142
+ peg$currPos = s4;
2143
+ s4 = peg$FAILED;
2144
+ }
2145
+ }
2146
+ else {
2147
+ peg$currPos = s4;
2148
+ s4 = peg$FAILED;
2149
+ }
2150
+ }
2151
+ if (s4 !== peg$FAILED) {
2152
+ s5 = peg$parseitem();
2153
+ if (s5 !== peg$FAILED) {
2154
+ peg$savedPos = s3;
2155
+ s4 = peg$c46(s1, s5);
2156
+ s3 = s4;
2157
+ }
2158
+ else {
2159
+ peg$currPos = s3;
2160
+ s3 = peg$FAILED;
2161
+ }
2162
+ }
2163
+ else {
2164
+ peg$currPos = s3;
2165
+ s3 = peg$FAILED;
2166
+ }
2167
+ }
2168
+ if (s2 !== peg$FAILED) {
2169
+ peg$savedPos = s0;
2170
+ s1 = peg$c41(s1, s2);
2171
+ s0 = s1;
2172
+ }
2063
2173
  else {
2064
2174
  peg$currPos = s0;
2065
2175
  s0 = peg$FAILED;
@@ -2069,15 +2179,6 @@ function peg$parse(input, options) {
2069
2179
  peg$currPos = s0;
2070
2180
  s0 = peg$FAILED;
2071
2181
  }
2072
- if (s0 === peg$FAILED) {
2073
- s0 = peg$currPos;
2074
- s1 = peg$parseitem();
2075
- if (s1 !== peg$FAILED) {
2076
- peg$savedPos = s0;
2077
- s1 = peg$c41(s1);
2078
- }
2079
- s0 = s1;
2080
- }
2081
2182
  return s0;
2082
2183
  }
2083
2184
  function peg$parseidentifierKey() {
@@ -2576,7 +2677,7 @@ function peg$parse(input, options) {
2576
2677
  s5 = peg$parselistItem();
2577
2678
  if (s5 !== peg$FAILED) {
2578
2679
  peg$savedPos = s3;
2579
- s4 = peg$c73(s1, s5);
2680
+ s4 = peg$c46(s1, s5);
2580
2681
  s3 = s4;
2581
2682
  }
2582
2683
  else {
@@ -2607,7 +2708,7 @@ function peg$parse(input, options) {
2607
2708
  s5 = peg$parselistItem();
2608
2709
  if (s5 !== peg$FAILED) {
2609
2710
  peg$savedPos = s3;
2610
- s4 = peg$c73(s1, s5);
2711
+ s4 = peg$c46(s1, s5);
2611
2712
  s3 = s4;
2612
2713
  }
2613
2714
  else {
@@ -2626,7 +2727,7 @@ function peg$parse(input, options) {
2626
2727
  }
2627
2728
  if (s2 !== peg$FAILED) {
2628
2729
  peg$savedPos = s0;
2629
- s1 = peg$c74(s1, s2);
2730
+ s1 = peg$c41(s1, s2);
2630
2731
  s0 = s1;
2631
2732
  }
2632
2733
  else {
@@ -2652,7 +2753,7 @@ function peg$parse(input, options) {
2652
2753
  s5 = peg$parse_();
2653
2754
  if (s5 !== peg$FAILED) {
2654
2755
  peg$savedPos = s2;
2655
- s3 = peg$c75(s4);
2756
+ s3 = peg$c73(s4);
2656
2757
  s2 = s3;
2657
2758
  }
2658
2759
  else {
@@ -2679,7 +2780,7 @@ function peg$parse(input, options) {
2679
2780
  s5 = peg$parse_();
2680
2781
  if (s5 !== peg$FAILED) {
2681
2782
  peg$savedPos = s2;
2682
- s3 = peg$c75(s4);
2783
+ s3 = peg$c73(s4);
2683
2784
  s2 = s3;
2684
2785
  }
2685
2786
  else {
@@ -2699,7 +2800,7 @@ function peg$parse(input, options) {
2699
2800
  }
2700
2801
  if (s1 !== peg$FAILED) {
2701
2802
  peg$savedPos = s0;
2702
- s1 = peg$c76(s1);
2803
+ s1 = peg$c74(s1);
2703
2804
  }
2704
2805
  s0 = s1;
2705
2806
  if (s0 === peg$FAILED) {
@@ -2707,7 +2808,7 @@ function peg$parse(input, options) {
2707
2808
  s1 = peg$parseitem();
2708
2809
  if (s1 !== peg$FAILED) {
2709
2810
  peg$savedPos = s0;
2710
- s1 = peg$c77(s1);
2811
+ s1 = peg$c75(s1);
2711
2812
  }
2712
2813
  s0 = s1;
2713
2814
  if (s0 === peg$FAILED) {
@@ -2715,7 +2816,7 @@ function peg$parse(input, options) {
2715
2816
  s1 = peg$parse_();
2716
2817
  if (s1 !== peg$FAILED) {
2717
2818
  peg$savedPos = s0;
2718
- s1 = peg$c78();
2819
+ s1 = peg$c76();
2719
2820
  }
2720
2821
  s0 = s1;
2721
2822
  }
@@ -2758,13 +2859,13 @@ function peg$parse(input, options) {
2758
2859
  if (s4 !== peg$FAILED) {
2759
2860
  s5 = peg$currPos;
2760
2861
  if (input.charCodeAt(peg$currPos) === 123) {
2761
- s6 = peg$c79;
2862
+ s6 = peg$c77;
2762
2863
  peg$currPos++;
2763
2864
  }
2764
2865
  else {
2765
2866
  s6 = peg$FAILED;
2766
2867
  if (peg$silentFails === 0) {
2767
- peg$fail(peg$c80);
2868
+ peg$fail(peg$c78);
2768
2869
  }
2769
2870
  }
2770
2871
  if (s6 !== peg$FAILED) {
@@ -2775,18 +2876,18 @@ function peg$parse(input, options) {
2775
2876
  s9 = peg$parsegap();
2776
2877
  if (s9 !== peg$FAILED) {
2777
2878
  if (input.charCodeAt(peg$currPos) === 125) {
2778
- s10 = peg$c81;
2879
+ s10 = peg$c79;
2779
2880
  peg$currPos++;
2780
2881
  }
2781
2882
  else {
2782
2883
  s10 = peg$FAILED;
2783
2884
  if (peg$silentFails === 0) {
2784
- peg$fail(peg$c82);
2885
+ peg$fail(peg$c80);
2785
2886
  }
2786
2887
  }
2787
2888
  if (s10 !== peg$FAILED) {
2788
2889
  peg$savedPos = s5;
2789
- s6 = peg$c83(s3, s4, s8);
2890
+ s6 = peg$c81(s3, s4, s8);
2790
2891
  s5 = s6;
2791
2892
  }
2792
2893
  else {
@@ -2816,31 +2917,31 @@ function peg$parse(input, options) {
2816
2917
  if (s5 === peg$FAILED) {
2817
2918
  s5 = peg$currPos;
2818
2919
  if (input.charCodeAt(peg$currPos) === 123) {
2819
- s6 = peg$c79;
2920
+ s6 = peg$c77;
2820
2921
  peg$currPos++;
2821
2922
  }
2822
2923
  else {
2823
2924
  s6 = peg$FAILED;
2824
2925
  if (peg$silentFails === 0) {
2825
- peg$fail(peg$c80);
2926
+ peg$fail(peg$c78);
2826
2927
  }
2827
2928
  }
2828
2929
  if (s6 !== peg$FAILED) {
2829
2930
  s7 = peg$parsegap();
2830
2931
  if (s7 !== peg$FAILED) {
2831
2932
  if (input.charCodeAt(peg$currPos) === 125) {
2832
- s8 = peg$c81;
2933
+ s8 = peg$c79;
2833
2934
  peg$currPos++;
2834
2935
  }
2835
2936
  else {
2836
2937
  s8 = peg$FAILED;
2837
2938
  if (peg$silentFails === 0) {
2838
- peg$fail(peg$c82);
2939
+ peg$fail(peg$c80);
2839
2940
  }
2840
2941
  }
2841
2942
  if (s8 !== peg$FAILED) {
2842
2943
  peg$savedPos = s5;
2843
- s6 = peg$c84(s3, s4);
2944
+ s6 = peg$c82(s3, s4);
2844
2945
  s5 = s6;
2845
2946
  }
2846
2947
  else {
@@ -2860,13 +2961,13 @@ function peg$parse(input, options) {
2860
2961
  if (s5 === peg$FAILED) {
2861
2962
  s5 = peg$currPos;
2862
2963
  if (input.charCodeAt(peg$currPos) === 123) {
2863
- s6 = peg$c79;
2964
+ s6 = peg$c77;
2864
2965
  peg$currPos++;
2865
2966
  }
2866
2967
  else {
2867
2968
  s6 = peg$FAILED;
2868
2969
  if (peg$silentFails === 0) {
2869
- peg$fail(peg$c80);
2970
+ peg$fail(peg$c78);
2870
2971
  }
2871
2972
  }
2872
2973
  if (s6 !== peg$FAILED) {
@@ -2876,13 +2977,13 @@ function peg$parse(input, options) {
2876
2977
  s10 = peg$currPos;
2877
2978
  peg$silentFails++;
2878
2979
  if (input.charCodeAt(peg$currPos) === 125) {
2879
- s11 = peg$c81;
2980
+ s11 = peg$c79;
2880
2981
  peg$currPos++;
2881
2982
  }
2882
2983
  else {
2883
2984
  s11 = peg$FAILED;
2884
2985
  if (peg$silentFails === 0) {
2885
- peg$fail(peg$c82);
2986
+ peg$fail(peg$c80);
2886
2987
  }
2887
2988
  }
2888
2989
  if (s11 === peg$FAILED) {
@@ -2926,13 +3027,13 @@ function peg$parse(input, options) {
2926
3027
  s10 = peg$currPos;
2927
3028
  peg$silentFails++;
2928
3029
  if (input.charCodeAt(peg$currPos) === 125) {
2929
- s11 = peg$c81;
3030
+ s11 = peg$c79;
2930
3031
  peg$currPos++;
2931
3032
  }
2932
3033
  else {
2933
3034
  s11 = peg$FAILED;
2934
3035
  if (peg$silentFails === 0) {
2935
- peg$fail(peg$c82);
3036
+ peg$fail(peg$c80);
2936
3037
  }
2937
3038
  }
2938
3039
  if (s11 === peg$FAILED) {
@@ -2979,18 +3080,18 @@ function peg$parse(input, options) {
2979
3080
  }
2980
3081
  if (s7 !== peg$FAILED) {
2981
3082
  if (input.charCodeAt(peg$currPos) === 125) {
2982
- s8 = peg$c81;
3083
+ s8 = peg$c79;
2983
3084
  peg$currPos++;
2984
3085
  }
2985
3086
  else {
2986
3087
  s8 = peg$FAILED;
2987
3088
  if (peg$silentFails === 0) {
2988
- peg$fail(peg$c82);
3089
+ peg$fail(peg$c80);
2989
3090
  }
2990
3091
  }
2991
3092
  if (s8 !== peg$FAILED) {
2992
3093
  peg$savedPos = s5;
2993
- s6 = peg$c85(s3, s4);
3094
+ s6 = peg$c83(s3, s4);
2994
3095
  s5 = s6;
2995
3096
  }
2996
3097
  else {
@@ -3010,13 +3111,13 @@ function peg$parse(input, options) {
3010
3111
  if (s5 === peg$FAILED) {
3011
3112
  s5 = peg$currPos;
3012
3113
  if (input.charCodeAt(peg$currPos) === 91) {
3013
- s6 = peg$c86;
3114
+ s6 = peg$c84;
3014
3115
  peg$currPos++;
3015
3116
  }
3016
3117
  else {
3017
3118
  s6 = peg$FAILED;
3018
3119
  if (peg$silentFails === 0) {
3019
- peg$fail(peg$c87);
3120
+ peg$fail(peg$c85);
3020
3121
  }
3021
3122
  }
3022
3123
  if (s6 !== peg$FAILED) {
@@ -3026,13 +3127,13 @@ function peg$parse(input, options) {
3026
3127
  s10 = peg$currPos;
3027
3128
  peg$silentFails++;
3028
3129
  if (input.charCodeAt(peg$currPos) === 93) {
3029
- s11 = peg$c88;
3130
+ s11 = peg$c86;
3030
3131
  peg$currPos++;
3031
3132
  }
3032
3133
  else {
3033
3134
  s11 = peg$FAILED;
3034
3135
  if (peg$silentFails === 0) {
3035
- peg$fail(peg$c89);
3136
+ peg$fail(peg$c87);
3036
3137
  }
3037
3138
  }
3038
3139
  if (s11 === peg$FAILED) {
@@ -3076,13 +3177,13 @@ function peg$parse(input, options) {
3076
3177
  s10 = peg$currPos;
3077
3178
  peg$silentFails++;
3078
3179
  if (input.charCodeAt(peg$currPos) === 93) {
3079
- s11 = peg$c88;
3180
+ s11 = peg$c86;
3080
3181
  peg$currPos++;
3081
3182
  }
3082
3183
  else {
3083
3184
  s11 = peg$FAILED;
3084
3185
  if (peg$silentFails === 0) {
3085
- peg$fail(peg$c89);
3186
+ peg$fail(peg$c87);
3086
3187
  }
3087
3188
  }
3088
3189
  if (s11 === peg$FAILED) {
@@ -3129,18 +3230,18 @@ function peg$parse(input, options) {
3129
3230
  }
3130
3231
  if (s7 !== peg$FAILED) {
3131
3232
  if (input.charCodeAt(peg$currPos) === 93) {
3132
- s8 = peg$c88;
3233
+ s8 = peg$c86;
3133
3234
  peg$currPos++;
3134
3235
  }
3135
3236
  else {
3136
3237
  s8 = peg$FAILED;
3137
3238
  if (peg$silentFails === 0) {
3138
- peg$fail(peg$c89);
3239
+ peg$fail(peg$c87);
3139
3240
  }
3140
3241
  }
3141
3242
  if (s8 !== peg$FAILED) {
3142
3243
  peg$savedPos = s5;
3143
- s6 = peg$c90(s3, s4);
3244
+ s6 = peg$c88(s3, s4);
3144
3245
  s5 = s6;
3145
3246
  }
3146
3247
  else {
@@ -3188,7 +3289,7 @@ function peg$parse(input, options) {
3188
3289
  }
3189
3290
  if (s10 !== peg$FAILED) {
3190
3291
  peg$savedPos = s5;
3191
- s6 = peg$c91(s3, s4, s8);
3292
+ s6 = peg$c89(s3, s4, s8);
3192
3293
  s5 = s6;
3193
3294
  }
3194
3295
  else {
@@ -3230,39 +3331,39 @@ function peg$parse(input, options) {
3230
3331
  if (s6 !== peg$FAILED) {
3231
3332
  s7 = peg$parse_();
3232
3333
  if (s7 !== peg$FAILED) {
3233
- if (peg$c92.test(input.charAt(peg$currPos))) {
3334
+ if (peg$c90.test(input.charAt(peg$currPos))) {
3234
3335
  s8 = input.charAt(peg$currPos);
3235
3336
  peg$currPos++;
3236
3337
  }
3237
3338
  else {
3238
3339
  s8 = peg$FAILED;
3239
3340
  if (peg$silentFails === 0) {
3240
- peg$fail(peg$c93);
3341
+ peg$fail(peg$c91);
3241
3342
  }
3242
3343
  }
3243
3344
  if (s8 !== peg$FAILED) {
3244
3345
  s9 = peg$currPos;
3245
3346
  s10 = [];
3246
- if (peg$c94.test(input.charAt(peg$currPos))) {
3347
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3247
3348
  s11 = input.charAt(peg$currPos);
3248
3349
  peg$currPos++;
3249
3350
  }
3250
3351
  else {
3251
3352
  s11 = peg$FAILED;
3252
3353
  if (peg$silentFails === 0) {
3253
- peg$fail(peg$c95);
3354
+ peg$fail(peg$c93);
3254
3355
  }
3255
3356
  }
3256
3357
  while (s11 !== peg$FAILED) {
3257
3358
  s10.push(s11);
3258
- if (peg$c94.test(input.charAt(peg$currPos))) {
3359
+ if (peg$c92.test(input.charAt(peg$currPos))) {
3259
3360
  s11 = input.charAt(peg$currPos);
3260
3361
  peg$currPos++;
3261
3362
  }
3262
3363
  else {
3263
3364
  s11 = peg$FAILED;
3264
3365
  if (peg$silentFails === 0) {
3265
- peg$fail(peg$c95);
3366
+ peg$fail(peg$c93);
3266
3367
  }
3267
3368
  }
3268
3369
  }
@@ -3273,14 +3374,14 @@ function peg$parse(input, options) {
3273
3374
  s9 = s10;
3274
3375
  }
3275
3376
  if (s9 !== peg$FAILED) {
3276
- if (peg$c92.test(input.charAt(peg$currPos))) {
3377
+ if (peg$c90.test(input.charAt(peg$currPos))) {
3277
3378
  s10 = input.charAt(peg$currPos);
3278
3379
  peg$currPos++;
3279
3380
  }
3280
3381
  else {
3281
3382
  s10 = peg$FAILED;
3282
3383
  if (peg$silentFails === 0) {
3283
- peg$fail(peg$c93);
3384
+ peg$fail(peg$c91);
3284
3385
  }
3285
3386
  }
3286
3387
  if (s10 !== peg$FAILED) {
@@ -3298,7 +3399,7 @@ function peg$parse(input, options) {
3298
3399
  }
3299
3400
  if (s12 !== peg$FAILED) {
3300
3401
  peg$savedPos = s5;
3301
- s6 = peg$c96(s3, s4, s9);
3402
+ s6 = peg$c94(s3, s4, s9);
3302
3403
  s5 = s6;
3303
3404
  }
3304
3405
  else {
@@ -3350,39 +3451,39 @@ function peg$parse(input, options) {
3350
3451
  if (s6 !== peg$FAILED) {
3351
3452
  s7 = peg$parse_();
3352
3453
  if (s7 !== peg$FAILED) {
3353
- if (peg$c97.test(input.charAt(peg$currPos))) {
3454
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3354
3455
  s8 = input.charAt(peg$currPos);
3355
3456
  peg$currPos++;
3356
3457
  }
3357
3458
  else {
3358
3459
  s8 = peg$FAILED;
3359
3460
  if (peg$silentFails === 0) {
3360
- peg$fail(peg$c98);
3461
+ peg$fail(peg$c96);
3361
3462
  }
3362
3463
  }
3363
3464
  if (s8 !== peg$FAILED) {
3364
3465
  s9 = peg$currPos;
3365
3466
  s10 = [];
3366
- if (peg$c99.test(input.charAt(peg$currPos))) {
3467
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3367
3468
  s11 = input.charAt(peg$currPos);
3368
3469
  peg$currPos++;
3369
3470
  }
3370
3471
  else {
3371
3472
  s11 = peg$FAILED;
3372
3473
  if (peg$silentFails === 0) {
3373
- peg$fail(peg$c100);
3474
+ peg$fail(peg$c98);
3374
3475
  }
3375
3476
  }
3376
3477
  while (s11 !== peg$FAILED) {
3377
3478
  s10.push(s11);
3378
- if (peg$c99.test(input.charAt(peg$currPos))) {
3479
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3379
3480
  s11 = input.charAt(peg$currPos);
3380
3481
  peg$currPos++;
3381
3482
  }
3382
3483
  else {
3383
3484
  s11 = peg$FAILED;
3384
3485
  if (peg$silentFails === 0) {
3385
- peg$fail(peg$c100);
3486
+ peg$fail(peg$c98);
3386
3487
  }
3387
3488
  }
3388
3489
  }
@@ -3393,14 +3494,14 @@ function peg$parse(input, options) {
3393
3494
  s9 = s10;
3394
3495
  }
3395
3496
  if (s9 !== peg$FAILED) {
3396
- if (peg$c97.test(input.charAt(peg$currPos))) {
3497
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3397
3498
  s10 = input.charAt(peg$currPos);
3398
3499
  peg$currPos++;
3399
3500
  }
3400
3501
  else {
3401
3502
  s10 = peg$FAILED;
3402
3503
  if (peg$silentFails === 0) {
3403
- peg$fail(peg$c98);
3504
+ peg$fail(peg$c96);
3404
3505
  }
3405
3506
  }
3406
3507
  if (s10 !== peg$FAILED) {
@@ -3418,7 +3519,7 @@ function peg$parse(input, options) {
3418
3519
  }
3419
3520
  if (s12 !== peg$FAILED) {
3420
3521
  peg$savedPos = s5;
3421
- s6 = peg$c96(s3, s4, s9);
3522
+ s6 = peg$c94(s3, s4, s9);
3422
3523
  s5 = s6;
3423
3524
  }
3424
3525
  else {
@@ -3619,7 +3720,7 @@ function peg$parse(input, options) {
3619
3720
  }
3620
3721
  if (s9 !== peg$FAILED) {
3621
3722
  peg$savedPos = s5;
3622
- s6 = peg$c101(s3, s4, s8);
3723
+ s6 = peg$c99(s3, s4, s8);
3623
3724
  s5 = s6;
3624
3725
  }
3625
3726
  else {
@@ -3668,7 +3769,7 @@ function peg$parse(input, options) {
3668
3769
  }
3669
3770
  if (s8 !== peg$FAILED) {
3670
3771
  peg$savedPos = s5;
3671
- s6 = peg$c102(s3, s4);
3772
+ s6 = peg$c100(s3, s4);
3672
3773
  s5 = s6;
3673
3774
  }
3674
3775
  else {
@@ -3688,13 +3789,13 @@ function peg$parse(input, options) {
3688
3789
  if (s5 === peg$FAILED) {
3689
3790
  s5 = peg$currPos;
3690
3791
  if (input.charCodeAt(peg$currPos) === 40) {
3691
- s6 = peg$c103;
3792
+ s6 = peg$c101;
3692
3793
  peg$currPos++;
3693
3794
  }
3694
3795
  else {
3695
3796
  s6 = peg$FAILED;
3696
3797
  if (peg$silentFails === 0) {
3697
- peg$fail(peg$c104);
3798
+ peg$fail(peg$c102);
3698
3799
  }
3699
3800
  }
3700
3801
  if (s6 !== peg$FAILED) {
@@ -3704,25 +3805,25 @@ function peg$parse(input, options) {
3704
3805
  s9 = peg$parsearray_items();
3705
3806
  if (s9 !== peg$FAILED) {
3706
3807
  peg$savedPos = s8;
3707
- s9 = peg$c105(s3, s4, s9);
3808
+ s9 = peg$c103(s3, s4, s9);
3708
3809
  }
3709
3810
  s8 = s9;
3710
3811
  if (s8 !== peg$FAILED) {
3711
3812
  s9 = peg$parsegap();
3712
3813
  if (s9 !== peg$FAILED) {
3713
3814
  if (input.charCodeAt(peg$currPos) === 41) {
3714
- s10 = peg$c106;
3815
+ s10 = peg$c104;
3715
3816
  peg$currPos++;
3716
3817
  }
3717
3818
  else {
3718
3819
  s10 = peg$FAILED;
3719
3820
  if (peg$silentFails === 0) {
3720
- peg$fail(peg$c107);
3821
+ peg$fail(peg$c105);
3721
3822
  }
3722
3823
  }
3723
3824
  if (s10 !== peg$FAILED) {
3724
3825
  peg$savedPos = s5;
3725
- s6 = peg$c108(s3, s4, s8);
3826
+ s6 = peg$c106(s3, s4, s8);
3726
3827
  s5 = s6;
3727
3828
  }
3728
3829
  else {
@@ -3752,31 +3853,31 @@ function peg$parse(input, options) {
3752
3853
  if (s5 === peg$FAILED) {
3753
3854
  s5 = peg$currPos;
3754
3855
  if (input.charCodeAt(peg$currPos) === 40) {
3755
- s6 = peg$c103;
3856
+ s6 = peg$c101;
3756
3857
  peg$currPos++;
3757
3858
  }
3758
3859
  else {
3759
3860
  s6 = peg$FAILED;
3760
3861
  if (peg$silentFails === 0) {
3761
- peg$fail(peg$c104);
3862
+ peg$fail(peg$c102);
3762
3863
  }
3763
3864
  }
3764
3865
  if (s6 !== peg$FAILED) {
3765
3866
  s7 = peg$parsegap();
3766
3867
  if (s7 !== peg$FAILED) {
3767
3868
  if (input.charCodeAt(peg$currPos) === 41) {
3768
- s8 = peg$c106;
3869
+ s8 = peg$c104;
3769
3870
  peg$currPos++;
3770
3871
  }
3771
3872
  else {
3772
3873
  s8 = peg$FAILED;
3773
3874
  if (peg$silentFails === 0) {
3774
- peg$fail(peg$c107);
3875
+ peg$fail(peg$c105);
3775
3876
  }
3776
3877
  }
3777
3878
  if (s8 !== peg$FAILED) {
3778
3879
  peg$savedPos = s5;
3779
- s6 = peg$c102(s3, s4);
3880
+ s6 = peg$c100(s3, s4);
3780
3881
  s5 = s6;
3781
3882
  }
3782
3883
  else {
@@ -3796,13 +3897,13 @@ function peg$parse(input, options) {
3796
3897
  if (s5 === peg$FAILED) {
3797
3898
  s5 = peg$currPos;
3798
3899
  if (input.charCodeAt(peg$currPos) === 40) {
3799
- s6 = peg$c103;
3900
+ s6 = peg$c101;
3800
3901
  peg$currPos++;
3801
3902
  }
3802
3903
  else {
3803
3904
  s6 = peg$FAILED;
3804
3905
  if (peg$silentFails === 0) {
3805
- peg$fail(peg$c104);
3906
+ peg$fail(peg$c102);
3806
3907
  }
3807
3908
  }
3808
3909
  if (s6 !== peg$FAILED) {
@@ -3826,24 +3927,24 @@ function peg$parse(input, options) {
3826
3927
  s13 = peg$currPos;
3827
3928
  peg$silentFails++;
3828
3929
  if (input.charCodeAt(peg$currPos) === 41) {
3829
- s14 = peg$c106;
3930
+ s14 = peg$c104;
3830
3931
  peg$currPos++;
3831
3932
  }
3832
3933
  else {
3833
3934
  s14 = peg$FAILED;
3834
3935
  if (peg$silentFails === 0) {
3835
- peg$fail(peg$c107);
3936
+ peg$fail(peg$c105);
3836
3937
  }
3837
3938
  }
3838
3939
  if (s14 === peg$FAILED) {
3839
3940
  if (input.charCodeAt(peg$currPos) === 40) {
3840
- s14 = peg$c103;
3941
+ s14 = peg$c101;
3841
3942
  peg$currPos++;
3842
3943
  }
3843
3944
  else {
3844
3945
  s14 = peg$FAILED;
3845
3946
  if (peg$silentFails === 0) {
3846
- peg$fail(peg$c104);
3947
+ peg$fail(peg$c102);
3847
3948
  }
3848
3949
  }
3849
3950
  }
@@ -3885,24 +3986,24 @@ function peg$parse(input, options) {
3885
3986
  s13 = peg$currPos;
3886
3987
  peg$silentFails++;
3887
3988
  if (input.charCodeAt(peg$currPos) === 41) {
3888
- s14 = peg$c106;
3989
+ s14 = peg$c104;
3889
3990
  peg$currPos++;
3890
3991
  }
3891
3992
  else {
3892
3993
  s14 = peg$FAILED;
3893
3994
  if (peg$silentFails === 0) {
3894
- peg$fail(peg$c107);
3995
+ peg$fail(peg$c105);
3895
3996
  }
3896
3997
  }
3897
3998
  if (s14 === peg$FAILED) {
3898
3999
  if (input.charCodeAt(peg$currPos) === 40) {
3899
- s14 = peg$c103;
4000
+ s14 = peg$c101;
3900
4001
  peg$currPos++;
3901
4002
  }
3902
4003
  else {
3903
4004
  s14 = peg$FAILED;
3904
4005
  if (peg$silentFails === 0) {
3905
- peg$fail(peg$c104);
4006
+ peg$fail(peg$c102);
3906
4007
  }
3907
4008
  }
3908
4009
  }
@@ -3960,18 +4061,18 @@ function peg$parse(input, options) {
3960
4061
  }
3961
4062
  if (s8 !== peg$FAILED) {
3962
4063
  if (input.charCodeAt(peg$currPos) === 41) {
3963
- s9 = peg$c106;
4064
+ s9 = peg$c104;
3964
4065
  peg$currPos++;
3965
4066
  }
3966
4067
  else {
3967
4068
  s9 = peg$FAILED;
3968
4069
  if (peg$silentFails === 0) {
3969
- peg$fail(peg$c107);
4070
+ peg$fail(peg$c105);
3970
4071
  }
3971
4072
  }
3972
4073
  if (s9 !== peg$FAILED) {
3973
4074
  peg$savedPos = s5;
3974
- s6 = peg$c96(s3, s4, s8);
4075
+ s6 = peg$c94(s3, s4, s8);
3975
4076
  s5 = s6;
3976
4077
  }
3977
4078
  else {
@@ -3996,13 +4097,13 @@ function peg$parse(input, options) {
3996
4097
  if (s5 === peg$FAILED) {
3997
4098
  s5 = peg$currPos;
3998
4099
  if (input.charCodeAt(peg$currPos) === 40) {
3999
- s6 = peg$c103;
4100
+ s6 = peg$c101;
4000
4101
  peg$currPos++;
4001
4102
  }
4002
4103
  else {
4003
4104
  s6 = peg$FAILED;
4004
4105
  if (peg$silentFails === 0) {
4005
- peg$fail(peg$c104);
4106
+ peg$fail(peg$c102);
4006
4107
  }
4007
4108
  }
4008
4109
  if (s6 !== peg$FAILED) {
@@ -4012,13 +4113,13 @@ function peg$parse(input, options) {
4012
4113
  s10 = peg$currPos;
4013
4114
  peg$silentFails++;
4014
4115
  if (input.charCodeAt(peg$currPos) === 41) {
4015
- s11 = peg$c106;
4116
+ s11 = peg$c104;
4016
4117
  peg$currPos++;
4017
4118
  }
4018
4119
  else {
4019
4120
  s11 = peg$FAILED;
4020
4121
  if (peg$silentFails === 0) {
4021
- peg$fail(peg$c107);
4122
+ peg$fail(peg$c105);
4022
4123
  }
4023
4124
  }
4024
4125
  if (s11 === peg$FAILED) {
@@ -4062,13 +4163,13 @@ function peg$parse(input, options) {
4062
4163
  s10 = peg$currPos;
4063
4164
  peg$silentFails++;
4064
4165
  if (input.charCodeAt(peg$currPos) === 41) {
4065
- s11 = peg$c106;
4166
+ s11 = peg$c104;
4066
4167
  peg$currPos++;
4067
4168
  }
4068
4169
  else {
4069
4170
  s11 = peg$FAILED;
4070
4171
  if (peg$silentFails === 0) {
4071
- peg$fail(peg$c107);
4172
+ peg$fail(peg$c105);
4072
4173
  }
4073
4174
  }
4074
4175
  if (s11 === peg$FAILED) {
@@ -4115,18 +4216,18 @@ function peg$parse(input, options) {
4115
4216
  }
4116
4217
  if (s7 !== peg$FAILED) {
4117
4218
  if (input.charCodeAt(peg$currPos) === 41) {
4118
- s8 = peg$c106;
4219
+ s8 = peg$c104;
4119
4220
  peg$currPos++;
4120
4221
  }
4121
4222
  else {
4122
4223
  s8 = peg$FAILED;
4123
4224
  if (peg$silentFails === 0) {
4124
- peg$fail(peg$c107);
4225
+ peg$fail(peg$c105);
4125
4226
  }
4126
4227
  }
4127
4228
  if (s8 !== peg$FAILED) {
4128
4229
  peg$savedPos = s5;
4129
- s6 = peg$c109(s3, s4);
4230
+ s6 = peg$c107(s3, s4);
4130
4231
  s5 = s6;
4131
4232
  }
4132
4233
  else {
@@ -4145,39 +4246,39 @@ function peg$parse(input, options) {
4145
4246
  }
4146
4247
  if (s5 === peg$FAILED) {
4147
4248
  s5 = peg$currPos;
4148
- if (peg$c92.test(input.charAt(peg$currPos))) {
4249
+ if (peg$c90.test(input.charAt(peg$currPos))) {
4149
4250
  s6 = input.charAt(peg$currPos);
4150
4251
  peg$currPos++;
4151
4252
  }
4152
4253
  else {
4153
4254
  s6 = peg$FAILED;
4154
4255
  if (peg$silentFails === 0) {
4155
- peg$fail(peg$c93);
4256
+ peg$fail(peg$c91);
4156
4257
  }
4157
4258
  }
4158
4259
  if (s6 !== peg$FAILED) {
4159
4260
  s7 = peg$currPos;
4160
4261
  s8 = [];
4161
- if (peg$c94.test(input.charAt(peg$currPos))) {
4262
+ if (peg$c92.test(input.charAt(peg$currPos))) {
4162
4263
  s9 = input.charAt(peg$currPos);
4163
4264
  peg$currPos++;
4164
4265
  }
4165
4266
  else {
4166
4267
  s9 = peg$FAILED;
4167
4268
  if (peg$silentFails === 0) {
4168
- peg$fail(peg$c95);
4269
+ peg$fail(peg$c93);
4169
4270
  }
4170
4271
  }
4171
4272
  while (s9 !== peg$FAILED) {
4172
4273
  s8.push(s9);
4173
- if (peg$c94.test(input.charAt(peg$currPos))) {
4274
+ if (peg$c92.test(input.charAt(peg$currPos))) {
4174
4275
  s9 = input.charAt(peg$currPos);
4175
4276
  peg$currPos++;
4176
4277
  }
4177
4278
  else {
4178
4279
  s9 = peg$FAILED;
4179
4280
  if (peg$silentFails === 0) {
4180
- peg$fail(peg$c95);
4281
+ peg$fail(peg$c93);
4181
4282
  }
4182
4283
  }
4183
4284
  }
@@ -4188,19 +4289,19 @@ function peg$parse(input, options) {
4188
4289
  s7 = s8;
4189
4290
  }
4190
4291
  if (s7 !== peg$FAILED) {
4191
- if (peg$c92.test(input.charAt(peg$currPos))) {
4292
+ if (peg$c90.test(input.charAt(peg$currPos))) {
4192
4293
  s8 = input.charAt(peg$currPos);
4193
4294
  peg$currPos++;
4194
4295
  }
4195
4296
  else {
4196
4297
  s8 = peg$FAILED;
4197
4298
  if (peg$silentFails === 0) {
4198
- peg$fail(peg$c93);
4299
+ peg$fail(peg$c91);
4199
4300
  }
4200
4301
  }
4201
4302
  if (s8 !== peg$FAILED) {
4202
4303
  peg$savedPos = s5;
4203
- s6 = peg$c96(s3, s4, s7);
4304
+ s6 = peg$c94(s3, s4, s7);
4204
4305
  s5 = s6;
4205
4306
  }
4206
4307
  else {
@@ -4219,39 +4320,39 @@ function peg$parse(input, options) {
4219
4320
  }
4220
4321
  if (s5 === peg$FAILED) {
4221
4322
  s5 = peg$currPos;
4222
- if (peg$c97.test(input.charAt(peg$currPos))) {
4323
+ if (peg$c95.test(input.charAt(peg$currPos))) {
4223
4324
  s6 = input.charAt(peg$currPos);
4224
4325
  peg$currPos++;
4225
4326
  }
4226
4327
  else {
4227
4328
  s6 = peg$FAILED;
4228
4329
  if (peg$silentFails === 0) {
4229
- peg$fail(peg$c98);
4330
+ peg$fail(peg$c96);
4230
4331
  }
4231
4332
  }
4232
4333
  if (s6 !== peg$FAILED) {
4233
4334
  s7 = peg$currPos;
4234
4335
  s8 = [];
4235
- if (peg$c99.test(input.charAt(peg$currPos))) {
4336
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4236
4337
  s9 = input.charAt(peg$currPos);
4237
4338
  peg$currPos++;
4238
4339
  }
4239
4340
  else {
4240
4341
  s9 = peg$FAILED;
4241
4342
  if (peg$silentFails === 0) {
4242
- peg$fail(peg$c100);
4343
+ peg$fail(peg$c98);
4243
4344
  }
4244
4345
  }
4245
4346
  while (s9 !== peg$FAILED) {
4246
4347
  s8.push(s9);
4247
- if (peg$c99.test(input.charAt(peg$currPos))) {
4348
+ if (peg$c97.test(input.charAt(peg$currPos))) {
4248
4349
  s9 = input.charAt(peg$currPos);
4249
4350
  peg$currPos++;
4250
4351
  }
4251
4352
  else {
4252
4353
  s9 = peg$FAILED;
4253
4354
  if (peg$silentFails === 0) {
4254
- peg$fail(peg$c100);
4355
+ peg$fail(peg$c98);
4255
4356
  }
4256
4357
  }
4257
4358
  }
@@ -4262,19 +4363,19 @@ function peg$parse(input, options) {
4262
4363
  s7 = s8;
4263
4364
  }
4264
4365
  if (s7 !== peg$FAILED) {
4265
- if (peg$c97.test(input.charAt(peg$currPos))) {
4366
+ if (peg$c95.test(input.charAt(peg$currPos))) {
4266
4367
  s8 = input.charAt(peg$currPos);
4267
4368
  peg$currPos++;
4268
4369
  }
4269
4370
  else {
4270
4371
  s8 = peg$FAILED;
4271
4372
  if (peg$silentFails === 0) {
4272
- peg$fail(peg$c98);
4373
+ peg$fail(peg$c96);
4273
4374
  }
4274
4375
  }
4275
4376
  if (s8 !== peg$FAILED) {
4276
4377
  peg$savedPos = s5;
4277
- s6 = peg$c96(s3, s4, s7);
4378
+ s6 = peg$c94(s3, s4, s7);
4278
4379
  s5 = s6;
4279
4380
  }
4280
4381
  else {
@@ -4294,38 +4395,38 @@ function peg$parse(input, options) {
4294
4395
  if (s5 === peg$FAILED) {
4295
4396
  s5 = peg$currPos;
4296
4397
  if (input.charCodeAt(peg$currPos) === 65378) {
4297
- s6 = peg$c110;
4398
+ s6 = peg$c108;
4298
4399
  peg$currPos++;
4299
4400
  }
4300
4401
  else {
4301
4402
  s6 = peg$FAILED;
4302
4403
  if (peg$silentFails === 0) {
4303
- peg$fail(peg$c111);
4404
+ peg$fail(peg$c109);
4304
4405
  }
4305
4406
  }
4306
4407
  if (s6 !== peg$FAILED) {
4307
4408
  s7 = peg$currPos;
4308
4409
  s8 = [];
4309
- if (peg$c112.test(input.charAt(peg$currPos))) {
4410
+ if (peg$c110.test(input.charAt(peg$currPos))) {
4310
4411
  s9 = input.charAt(peg$currPos);
4311
4412
  peg$currPos++;
4312
4413
  }
4313
4414
  else {
4314
4415
  s9 = peg$FAILED;
4315
4416
  if (peg$silentFails === 0) {
4316
- peg$fail(peg$c113);
4417
+ peg$fail(peg$c111);
4317
4418
  }
4318
4419
  }
4319
4420
  while (s9 !== peg$FAILED) {
4320
4421
  s8.push(s9);
4321
- if (peg$c112.test(input.charAt(peg$currPos))) {
4422
+ if (peg$c110.test(input.charAt(peg$currPos))) {
4322
4423
  s9 = input.charAt(peg$currPos);
4323
4424
  peg$currPos++;
4324
4425
  }
4325
4426
  else {
4326
4427
  s9 = peg$FAILED;
4327
4428
  if (peg$silentFails === 0) {
4328
- peg$fail(peg$c113);
4429
+ peg$fail(peg$c111);
4329
4430
  }
4330
4431
  }
4331
4432
  }
@@ -4337,18 +4438,18 @@ function peg$parse(input, options) {
4337
4438
  }
4338
4439
  if (s7 !== peg$FAILED) {
4339
4440
  if (input.charCodeAt(peg$currPos) === 65379) {
4340
- s8 = peg$c114;
4441
+ s8 = peg$c112;
4341
4442
  peg$currPos++;
4342
4443
  }
4343
4444
  else {
4344
4445
  s8 = peg$FAILED;
4345
4446
  if (peg$silentFails === 0) {
4346
- peg$fail(peg$c115);
4447
+ peg$fail(peg$c113);
4347
4448
  }
4348
4449
  }
4349
4450
  if (s8 !== peg$FAILED) {
4350
4451
  peg$savedPos = s5;
4351
- s6 = peg$c96(s3, s4, s7);
4452
+ s6 = peg$c94(s3, s4, s7);
4352
4453
  s5 = s6;
4353
4454
  }
4354
4455
  else {
@@ -4379,68 +4480,68 @@ function peg$parse(input, options) {
4379
4480
  }
4380
4481
  if (s6 === peg$FAILED) {
4381
4482
  if (input.charCodeAt(peg$currPos) === 40) {
4382
- s6 = peg$c103;
4483
+ s6 = peg$c101;
4383
4484
  peg$currPos++;
4384
4485
  }
4385
4486
  else {
4386
4487
  s6 = peg$FAILED;
4387
4488
  if (peg$silentFails === 0) {
4388
- peg$fail(peg$c104);
4489
+ peg$fail(peg$c102);
4389
4490
  }
4390
4491
  }
4391
4492
  if (s6 === peg$FAILED) {
4392
4493
  if (input.charCodeAt(peg$currPos) === 123) {
4393
- s6 = peg$c79;
4494
+ s6 = peg$c77;
4394
4495
  peg$currPos++;
4395
4496
  }
4396
4497
  else {
4397
4498
  s6 = peg$FAILED;
4398
4499
  if (peg$silentFails === 0) {
4399
- peg$fail(peg$c80);
4500
+ peg$fail(peg$c78);
4400
4501
  }
4401
4502
  }
4402
4503
  if (s6 === peg$FAILED) {
4403
4504
  if (input.charCodeAt(peg$currPos) === 91) {
4404
- s6 = peg$c86;
4505
+ s6 = peg$c84;
4405
4506
  peg$currPos++;
4406
4507
  }
4407
4508
  else {
4408
4509
  s6 = peg$FAILED;
4409
4510
  if (peg$silentFails === 0) {
4410
- peg$fail(peg$c87);
4511
+ peg$fail(peg$c85);
4411
4512
  }
4412
4513
  }
4413
4514
  if (s6 === peg$FAILED) {
4414
- if (peg$c92.test(input.charAt(peg$currPos))) {
4515
+ if (peg$c90.test(input.charAt(peg$currPos))) {
4415
4516
  s6 = input.charAt(peg$currPos);
4416
4517
  peg$currPos++;
4417
4518
  }
4418
4519
  else {
4419
4520
  s6 = peg$FAILED;
4420
4521
  if (peg$silentFails === 0) {
4421
- peg$fail(peg$c93);
4522
+ peg$fail(peg$c91);
4422
4523
  }
4423
4524
  }
4424
4525
  if (s6 === peg$FAILED) {
4425
- if (peg$c97.test(input.charAt(peg$currPos))) {
4526
+ if (peg$c95.test(input.charAt(peg$currPos))) {
4426
4527
  s6 = input.charAt(peg$currPos);
4427
4528
  peg$currPos++;
4428
4529
  }
4429
4530
  else {
4430
4531
  s6 = peg$FAILED;
4431
4532
  if (peg$silentFails === 0) {
4432
- peg$fail(peg$c98);
4533
+ peg$fail(peg$c96);
4433
4534
  }
4434
4535
  }
4435
4536
  if (s6 === peg$FAILED) {
4436
4537
  if (input.charCodeAt(peg$currPos) === 65378) {
4437
- s6 = peg$c110;
4538
+ s6 = peg$c108;
4438
4539
  peg$currPos++;
4439
4540
  }
4440
4541
  else {
4441
4542
  s6 = peg$FAILED;
4442
4543
  if (peg$silentFails === 0) {
4443
- peg$fail(peg$c111);
4544
+ peg$fail(peg$c109);
4444
4545
  }
4445
4546
  }
4446
4547
  }
@@ -4535,7 +4636,7 @@ function peg$parse(input, options) {
4535
4636
  }
4536
4637
  if (s7 !== peg$FAILED) {
4537
4638
  peg$savedPos = s5;
4538
- s6 = peg$c116(s3, s4);
4639
+ s6 = peg$c114(s3, s4);
4539
4640
  s5 = s6;
4540
4641
  }
4541
4642
  else {
@@ -4552,7 +4653,7 @@ function peg$parse(input, options) {
4552
4653
  s6 = peg$parse_();
4553
4654
  if (s6 !== peg$FAILED) {
4554
4655
  peg$savedPos = s5;
4555
- s6 = peg$c117(s3, s4);
4656
+ s6 = peg$c115(s3, s4);
4556
4657
  }
4557
4658
  s5 = s6;
4558
4659
  }
@@ -4576,7 +4677,7 @@ function peg$parse(input, options) {
4576
4677
  s6 = peg$parse_();
4577
4678
  if (s6 !== peg$FAILED) {
4578
4679
  peg$savedPos = s0;
4579
- s1 = peg$c118(s3, s4, s5);
4680
+ s1 = peg$c116(s3, s4, s5);
4580
4681
  s0 = s1;
4581
4682
  }
4582
4683
  else {
@@ -4655,7 +4756,7 @@ function peg$parse(input, options) {
4655
4756
  s9 = peg$parsenewline();
4656
4757
  if (s9 !== peg$FAILED) {
4657
4758
  peg$savedPos = s4;
4658
- s5 = peg$c119(s1, s7);
4759
+ s5 = peg$c117(s1, s7);
4659
4760
  s4 = s5;
4660
4761
  }
4661
4762
  else {
@@ -4715,7 +4816,7 @@ function peg$parse(input, options) {
4715
4816
  s9 = peg$parsenewline();
4716
4817
  if (s9 !== peg$FAILED) {
4717
4818
  peg$savedPos = s4;
4718
- s5 = peg$c119(s1, s7);
4819
+ s5 = peg$c117(s1, s7);
4719
4820
  s4 = s5;
4720
4821
  }
4721
4822
  else {
@@ -4750,7 +4851,7 @@ function peg$parse(input, options) {
4750
4851
  }
4751
4852
  if (s4 !== peg$FAILED) {
4752
4853
  peg$savedPos = s0;
4753
- s1 = peg$c120(s1, s3, s4);
4854
+ s1 = peg$c118(s1, s3, s4);
4754
4855
  s0 = s1;
4755
4856
  }
4756
4857
  else {
@@ -4824,7 +4925,7 @@ function peg$parse(input, options) {
4824
4925
  }
4825
4926
  if (s1 !== peg$FAILED) {
4826
4927
  peg$savedPos = s0;
4827
- s1 = peg$c121();
4928
+ s1 = peg$c119();
4828
4929
  }
4829
4930
  s0 = s1;
4830
4931
  return s0;
@@ -4834,27 +4935,27 @@ function peg$parse(input, options) {
4834
4935
  s0 = peg$currPos;
4835
4936
  s1 = peg$currPos;
4836
4937
  s2 = [];
4837
- if (peg$c122.test(input.charAt(peg$currPos))) {
4938
+ if (peg$c120.test(input.charAt(peg$currPos))) {
4838
4939
  s3 = input.charAt(peg$currPos);
4839
4940
  peg$currPos++;
4840
4941
  }
4841
4942
  else {
4842
4943
  s3 = peg$FAILED;
4843
4944
  if (peg$silentFails === 0) {
4844
- peg$fail(peg$c123);
4945
+ peg$fail(peg$c121);
4845
4946
  }
4846
4947
  }
4847
4948
  if (s3 !== peg$FAILED) {
4848
4949
  while (s3 !== peg$FAILED) {
4849
4950
  s2.push(s3);
4850
- if (peg$c122.test(input.charAt(peg$currPos))) {
4951
+ if (peg$c120.test(input.charAt(peg$currPos))) {
4851
4952
  s3 = input.charAt(peg$currPos);
4852
4953
  peg$currPos++;
4853
4954
  }
4854
4955
  else {
4855
4956
  s3 = peg$FAILED;
4856
4957
  if (peg$silentFails === 0) {
4857
- peg$fail(peg$c123);
4958
+ peg$fail(peg$c121);
4858
4959
  }
4859
4960
  }
4860
4961
  }
@@ -4870,7 +4971,7 @@ function peg$parse(input, options) {
4870
4971
  }
4871
4972
  if (s1 !== peg$FAILED) {
4872
4973
  peg$savedPos = s0;
4873
- s1 = peg$c124(s1);
4974
+ s1 = peg$c122(s1);
4874
4975
  }
4875
4976
  s0 = s1;
4876
4977
  return s0;
@@ -4879,27 +4980,27 @@ function peg$parse(input, options) {
4879
4980
  var s0, s1, s2;
4880
4981
  s0 = peg$currPos;
4881
4982
  s1 = [];
4882
- if (peg$c125.test(input.charAt(peg$currPos))) {
4983
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4883
4984
  s2 = input.charAt(peg$currPos);
4884
4985
  peg$currPos++;
4885
4986
  }
4886
4987
  else {
4887
4988
  s2 = peg$FAILED;
4888
4989
  if (peg$silentFails === 0) {
4889
- peg$fail(peg$c126);
4990
+ peg$fail(peg$c124);
4890
4991
  }
4891
4992
  }
4892
4993
  if (s2 !== peg$FAILED) {
4893
4994
  while (s2 !== peg$FAILED) {
4894
4995
  s1.push(s2);
4895
- if (peg$c125.test(input.charAt(peg$currPos))) {
4996
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4896
4997
  s2 = input.charAt(peg$currPos);
4897
4998
  peg$currPos++;
4898
4999
  }
4899
5000
  else {
4900
5001
  s2 = peg$FAILED;
4901
5002
  if (peg$silentFails === 0) {
4902
- peg$fail(peg$c126);
5003
+ peg$fail(peg$c124);
4903
5004
  }
4904
5005
  }
4905
5006
  }
@@ -4919,14 +5020,14 @@ function peg$parse(input, options) {
4919
5020
  var s0, s1, s2, s3, s4;
4920
5021
  s0 = peg$currPos;
4921
5022
  s1 = peg$currPos;
4922
- if (peg$c127.test(input.charAt(peg$currPos))) {
5023
+ if (peg$c125.test(input.charAt(peg$currPos))) {
4923
5024
  s2 = input.charAt(peg$currPos);
4924
5025
  peg$currPos++;
4925
5026
  }
4926
5027
  else {
4927
5028
  s2 = peg$FAILED;
4928
5029
  if (peg$silentFails === 0) {
4929
- peg$fail(peg$c128);
5030
+ peg$fail(peg$c126);
4930
5031
  }
4931
5032
  }
4932
5033
  if (s2 === peg$FAILED) {
@@ -4934,27 +5035,27 @@ function peg$parse(input, options) {
4934
5035
  }
4935
5036
  if (s2 !== peg$FAILED) {
4936
5037
  s3 = [];
4937
- if (peg$c125.test(input.charAt(peg$currPos))) {
5038
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4938
5039
  s4 = input.charAt(peg$currPos);
4939
5040
  peg$currPos++;
4940
5041
  }
4941
5042
  else {
4942
5043
  s4 = peg$FAILED;
4943
5044
  if (peg$silentFails === 0) {
4944
- peg$fail(peg$c126);
5045
+ peg$fail(peg$c124);
4945
5046
  }
4946
5047
  }
4947
5048
  if (s4 !== peg$FAILED) {
4948
5049
  while (s4 !== peg$FAILED) {
4949
5050
  s3.push(s4);
4950
- if (peg$c125.test(input.charAt(peg$currPos))) {
5051
+ if (peg$c123.test(input.charAt(peg$currPos))) {
4951
5052
  s4 = input.charAt(peg$currPos);
4952
5053
  peg$currPos++;
4953
5054
  }
4954
5055
  else {
4955
5056
  s4 = peg$FAILED;
4956
5057
  if (peg$silentFails === 0) {
4957
- peg$fail(peg$c126);
5058
+ peg$fail(peg$c124);
4958
5059
  }
4959
5060
  }
4960
5061
  }
@@ -4986,36 +5087,36 @@ function peg$parse(input, options) {
4986
5087
  function peg$parseBoolean() {
4987
5088
  var s0, s1;
4988
5089
  s0 = peg$currPos;
4989
- if (input.substr(peg$currPos, 4) === peg$c129) {
4990
- s1 = peg$c129;
5090
+ if (input.substr(peg$currPos, 4) === peg$c127) {
5091
+ s1 = peg$c127;
4991
5092
  peg$currPos += 4;
4992
5093
  }
4993
5094
  else {
4994
5095
  s1 = peg$FAILED;
4995
5096
  if (peg$silentFails === 0) {
4996
- peg$fail(peg$c130);
5097
+ peg$fail(peg$c128);
4997
5098
  }
4998
5099
  }
4999
5100
  if (s1 !== peg$FAILED) {
5000
5101
  peg$savedPos = s0;
5001
- s1 = peg$c131();
5102
+ s1 = peg$c129();
5002
5103
  }
5003
5104
  s0 = s1;
5004
5105
  if (s0 === peg$FAILED) {
5005
5106
  s0 = peg$currPos;
5006
- if (input.substr(peg$currPos, 5) === peg$c132) {
5007
- s1 = peg$c132;
5107
+ if (input.substr(peg$currPos, 5) === peg$c130) {
5108
+ s1 = peg$c130;
5008
5109
  peg$currPos += 5;
5009
5110
  }
5010
5111
  else {
5011
5112
  s1 = peg$FAILED;
5012
5113
  if (peg$silentFails === 0) {
5013
- peg$fail(peg$c133);
5114
+ peg$fail(peg$c131);
5014
5115
  }
5015
5116
  }
5016
5117
  if (s1 !== peg$FAILED) {
5017
5118
  peg$savedPos = s0;
5018
- s1 = peg$c134();
5119
+ s1 = peg$c132();
5019
5120
  }
5020
5121
  s0 = s1;
5021
5122
  }
@@ -5029,13 +5130,13 @@ function peg$parse(input, options) {
5029
5130
  if (s2 !== peg$FAILED) {
5030
5131
  s3 = peg$currPos;
5031
5132
  if (input.charCodeAt(peg$currPos) === 46) {
5032
- s4 = peg$c135;
5133
+ s4 = peg$c133;
5033
5134
  peg$currPos++;
5034
5135
  }
5035
5136
  else {
5036
5137
  s4 = peg$FAILED;
5037
5138
  if (peg$silentFails === 0) {
5038
- peg$fail(peg$c136);
5139
+ peg$fail(peg$c134);
5039
5140
  }
5040
5141
  }
5041
5142
  if (s4 !== peg$FAILED) {
@@ -5057,14 +5158,14 @@ function peg$parse(input, options) {
5057
5158
  s3 = null;
5058
5159
  }
5059
5160
  if (s3 !== peg$FAILED) {
5060
- if (peg$c137.test(input.charAt(peg$currPos))) {
5161
+ if (peg$c135.test(input.charAt(peg$currPos))) {
5061
5162
  s4 = input.charAt(peg$currPos);
5062
5163
  peg$currPos++;
5063
5164
  }
5064
5165
  else {
5065
5166
  s4 = peg$FAILED;
5066
5167
  if (peg$silentFails === 0) {
5067
- peg$fail(peg$c138);
5168
+ peg$fail(peg$c136);
5068
5169
  }
5069
5170
  }
5070
5171
  if (s4 !== peg$FAILED) {
@@ -5104,13 +5205,13 @@ function peg$parse(input, options) {
5104
5205
  s2 = peg$parsenumber();
5105
5206
  if (s2 !== peg$FAILED) {
5106
5207
  if (input.charCodeAt(peg$currPos) === 46) {
5107
- s3 = peg$c135;
5208
+ s3 = peg$c133;
5108
5209
  peg$currPos++;
5109
5210
  }
5110
5211
  else {
5111
5212
  s3 = peg$FAILED;
5112
5213
  if (peg$silentFails === 0) {
5113
- peg$fail(peg$c136);
5214
+ peg$fail(peg$c134);
5114
5215
  }
5115
5216
  }
5116
5217
  if (s3 !== peg$FAILED) {
@@ -5145,39 +5246,39 @@ function peg$parse(input, options) {
5145
5246
  function peg$parseitem() {
5146
5247
  var s0, s1, s2, s3, s4;
5147
5248
  s0 = peg$currPos;
5148
- if (peg$c97.test(input.charAt(peg$currPos))) {
5249
+ if (peg$c95.test(input.charAt(peg$currPos))) {
5149
5250
  s1 = input.charAt(peg$currPos);
5150
5251
  peg$currPos++;
5151
5252
  }
5152
5253
  else {
5153
5254
  s1 = peg$FAILED;
5154
5255
  if (peg$silentFails === 0) {
5155
- peg$fail(peg$c98);
5256
+ peg$fail(peg$c96);
5156
5257
  }
5157
5258
  }
5158
5259
  if (s1 !== peg$FAILED) {
5159
5260
  s2 = peg$currPos;
5160
5261
  s3 = [];
5161
- if (peg$c99.test(input.charAt(peg$currPos))) {
5262
+ if (peg$c97.test(input.charAt(peg$currPos))) {
5162
5263
  s4 = input.charAt(peg$currPos);
5163
5264
  peg$currPos++;
5164
5265
  }
5165
5266
  else {
5166
5267
  s4 = peg$FAILED;
5167
5268
  if (peg$silentFails === 0) {
5168
- peg$fail(peg$c100);
5269
+ peg$fail(peg$c98);
5169
5270
  }
5170
5271
  }
5171
5272
  while (s4 !== peg$FAILED) {
5172
5273
  s3.push(s4);
5173
- if (peg$c99.test(input.charAt(peg$currPos))) {
5274
+ if (peg$c97.test(input.charAt(peg$currPos))) {
5174
5275
  s4 = input.charAt(peg$currPos);
5175
5276
  peg$currPos++;
5176
5277
  }
5177
5278
  else {
5178
5279
  s4 = peg$FAILED;
5179
5280
  if (peg$silentFails === 0) {
5180
- peg$fail(peg$c100);
5281
+ peg$fail(peg$c98);
5181
5282
  }
5182
5283
  }
5183
5284
  }
@@ -5188,19 +5289,19 @@ function peg$parse(input, options) {
5188
5289
  s2 = s3;
5189
5290
  }
5190
5291
  if (s2 !== peg$FAILED) {
5191
- if (peg$c97.test(input.charAt(peg$currPos))) {
5292
+ if (peg$c95.test(input.charAt(peg$currPos))) {
5192
5293
  s3 = input.charAt(peg$currPos);
5193
5294
  peg$currPos++;
5194
5295
  }
5195
5296
  else {
5196
5297
  s3 = peg$FAILED;
5197
5298
  if (peg$silentFails === 0) {
5198
- peg$fail(peg$c98);
5299
+ peg$fail(peg$c96);
5199
5300
  }
5200
5301
  }
5201
5302
  if (s3 !== peg$FAILED) {
5202
5303
  peg$savedPos = s0;
5203
- s1 = peg$c124(s2);
5304
+ s1 = peg$c122(s2);
5204
5305
  s0 = s1;
5205
5306
  }
5206
5307
  else {
@@ -5219,39 +5320,39 @@ function peg$parse(input, options) {
5219
5320
  }
5220
5321
  if (s0 === peg$FAILED) {
5221
5322
  s0 = peg$currPos;
5222
- if (peg$c92.test(input.charAt(peg$currPos))) {
5323
+ if (peg$c90.test(input.charAt(peg$currPos))) {
5223
5324
  s1 = input.charAt(peg$currPos);
5224
5325
  peg$currPos++;
5225
5326
  }
5226
5327
  else {
5227
5328
  s1 = peg$FAILED;
5228
5329
  if (peg$silentFails === 0) {
5229
- peg$fail(peg$c93);
5330
+ peg$fail(peg$c91);
5230
5331
  }
5231
5332
  }
5232
5333
  if (s1 !== peg$FAILED) {
5233
5334
  s2 = peg$currPos;
5234
5335
  s3 = [];
5235
- if (peg$c94.test(input.charAt(peg$currPos))) {
5336
+ if (peg$c92.test(input.charAt(peg$currPos))) {
5236
5337
  s4 = input.charAt(peg$currPos);
5237
5338
  peg$currPos++;
5238
5339
  }
5239
5340
  else {
5240
5341
  s4 = peg$FAILED;
5241
5342
  if (peg$silentFails === 0) {
5242
- peg$fail(peg$c95);
5343
+ peg$fail(peg$c93);
5243
5344
  }
5244
5345
  }
5245
5346
  while (s4 !== peg$FAILED) {
5246
5347
  s3.push(s4);
5247
- if (peg$c94.test(input.charAt(peg$currPos))) {
5348
+ if (peg$c92.test(input.charAt(peg$currPos))) {
5248
5349
  s4 = input.charAt(peg$currPos);
5249
5350
  peg$currPos++;
5250
5351
  }
5251
5352
  else {
5252
5353
  s4 = peg$FAILED;
5253
5354
  if (peg$silentFails === 0) {
5254
- peg$fail(peg$c95);
5355
+ peg$fail(peg$c93);
5255
5356
  }
5256
5357
  }
5257
5358
  }
@@ -5262,19 +5363,19 @@ function peg$parse(input, options) {
5262
5363
  s2 = s3;
5263
5364
  }
5264
5365
  if (s2 !== peg$FAILED) {
5265
- if (peg$c92.test(input.charAt(peg$currPos))) {
5366
+ if (peg$c90.test(input.charAt(peg$currPos))) {
5266
5367
  s3 = input.charAt(peg$currPos);
5267
5368
  peg$currPos++;
5268
5369
  }
5269
5370
  else {
5270
5371
  s3 = peg$FAILED;
5271
5372
  if (peg$silentFails === 0) {
5272
- peg$fail(peg$c93);
5373
+ peg$fail(peg$c91);
5273
5374
  }
5274
5375
  }
5275
5376
  if (s3 !== peg$FAILED) {
5276
5377
  peg$savedPos = s0;
5277
- s1 = peg$c124(s2);
5378
+ s1 = peg$c122(s2);
5278
5379
  s0 = s1;
5279
5380
  }
5280
5381
  else {
@@ -5298,7 +5399,7 @@ function peg$parse(input, options) {
5298
5399
  s1 = peg$parsefloatNumber();
5299
5400
  if (s1 !== peg$FAILED) {
5300
5401
  peg$savedPos = s0;
5301
- s1 = peg$c139(s1);
5402
+ s1 = peg$c137(s1);
5302
5403
  }
5303
5404
  s0 = s1;
5304
5405
  if (s0 === peg$FAILED) {
@@ -5306,7 +5407,7 @@ function peg$parse(input, options) {
5306
5407
  s1 = peg$parsenumber();
5307
5408
  if (s1 !== peg$FAILED) {
5308
5409
  peg$savedPos = s0;
5309
- s1 = peg$c140(s1);
5410
+ s1 = peg$c138(s1);
5310
5411
  }
5311
5412
  s0 = s1;
5312
5413
  }
@@ -5336,7 +5437,7 @@ function peg$parse(input, options) {
5336
5437
  s5 = peg$parsepod_configuration();
5337
5438
  if (s5 !== peg$FAILED) {
5338
5439
  peg$savedPos = peg$currPos;
5339
- s6 = peg$c141(s1, s3, s5);
5440
+ s6 = peg$c139(s1, s3, s5);
5340
5441
  if (s6) {
5341
5442
  s6 = void 0;
5342
5443
  }
@@ -5379,7 +5480,7 @@ function peg$parse(input, options) {
5379
5480
  s15 = peg$parsestrictIdentifier();
5380
5481
  if (s15 !== peg$FAILED) {
5381
5482
  peg$savedPos = peg$currPos;
5382
- s16 = peg$c142(s1, s3, s5, s9, s15);
5483
+ s16 = peg$c140(s1, s3, s5, s9, s15);
5383
5484
  if (s16) {
5384
5485
  s16 = void 0;
5385
5486
  }
@@ -5447,7 +5548,7 @@ function peg$parse(input, options) {
5447
5548
  }
5448
5549
  if (s10 !== peg$FAILED) {
5449
5550
  peg$savedPos = s8;
5450
- s9 = peg$c143(s1, s3, s5, s9, s10);
5551
+ s9 = peg$c141(s1, s3, s5, s9, s10);
5451
5552
  s8 = s9;
5452
5553
  }
5453
5554
  else {
@@ -5496,7 +5597,7 @@ function peg$parse(input, options) {
5496
5597
  s15 = peg$parsestrictIdentifier();
5497
5598
  if (s15 !== peg$FAILED) {
5498
5599
  peg$savedPos = peg$currPos;
5499
- s16 = peg$c142(s1, s3, s5, s9, s15);
5600
+ s16 = peg$c140(s1, s3, s5, s9, s15);
5500
5601
  if (s16) {
5501
5602
  s16 = void 0;
5502
5603
  }
@@ -5564,7 +5665,7 @@ function peg$parse(input, options) {
5564
5665
  }
5565
5666
  if (s10 !== peg$FAILED) {
5566
5667
  peg$savedPos = s8;
5567
- s9 = peg$c143(s1, s3, s5, s9, s10);
5668
+ s9 = peg$c141(s1, s3, s5, s9, s10);
5568
5669
  s8 = s9;
5569
5670
  }
5570
5671
  else {
@@ -5597,7 +5698,7 @@ function peg$parse(input, options) {
5597
5698
  s11 = peg$parsestrictIdentifier();
5598
5699
  if (s11 !== peg$FAILED) {
5599
5700
  peg$savedPos = peg$currPos;
5600
- s12 = peg$c144(s1, s3, s5, s7, s8, s11);
5701
+ s12 = peg$c142(s1, s3, s5, s7, s8, s11);
5601
5702
  if (s12) {
5602
5703
  s12 = void 0;
5603
5704
  }
@@ -5611,7 +5712,7 @@ function peg$parse(input, options) {
5611
5712
  }
5612
5713
  if (s13 !== peg$FAILED) {
5613
5714
  peg$savedPos = s9;
5614
- s10 = peg$c145(s1, s3, s5, s7, s8, s11);
5715
+ s10 = peg$c143(s1, s3, s5, s7, s8, s11);
5615
5716
  s9 = s10;
5616
5717
  }
5617
5718
  else {
@@ -5635,7 +5736,7 @@ function peg$parse(input, options) {
5635
5736
  }
5636
5737
  if (s9 !== peg$FAILED) {
5637
5738
  peg$savedPos = peg$currPos;
5638
- s10 = peg$c146(s1, s3, s5, s7, s8, s9);
5739
+ s10 = peg$c144(s1, s3, s5, s7, s8, s9);
5639
5740
  if (s10) {
5640
5741
  s10 = void 0;
5641
5742
  }
@@ -5644,7 +5745,7 @@ function peg$parse(input, options) {
5644
5745
  }
5645
5746
  if (s10 !== peg$FAILED) {
5646
5747
  peg$savedPos = s0;
5647
- s1 = peg$c147(s1, s3, s5, s7, s8, s9);
5748
+ s1 = peg$c145(s1, s3, s5, s7, s8, s9);
5648
5749
  s0 = s1;
5649
5750
  }
5650
5751
  else {
@@ -5745,14 +5846,14 @@ function peg$parse(input, options) {
5745
5846
  s3 = peg$currPos;
5746
5847
  s4 = [];
5747
5848
  s5 = peg$currPos;
5748
- if (peg$c148.test(input.charAt(peg$currPos))) {
5849
+ if (peg$c146.test(input.charAt(peg$currPos))) {
5749
5850
  s6 = input.charAt(peg$currPos);
5750
5851
  peg$currPos++;
5751
5852
  }
5752
5853
  else {
5753
5854
  s6 = peg$FAILED;
5754
5855
  if (peg$silentFails === 0) {
5755
- peg$fail(peg$c149);
5856
+ peg$fail(peg$c147);
5756
5857
  }
5757
5858
  }
5758
5859
  if (s6 !== peg$FAILED) {
@@ -5779,14 +5880,14 @@ function peg$parse(input, options) {
5779
5880
  while (s5 !== peg$FAILED) {
5780
5881
  s4.push(s5);
5781
5882
  s5 = peg$currPos;
5782
- if (peg$c148.test(input.charAt(peg$currPos))) {
5883
+ if (peg$c146.test(input.charAt(peg$currPos))) {
5783
5884
  s6 = input.charAt(peg$currPos);
5784
5885
  peg$currPos++;
5785
5886
  }
5786
5887
  else {
5787
5888
  s6 = peg$FAILED;
5788
5889
  if (peg$silentFails === 0) {
5789
- peg$fail(peg$c149);
5890
+ peg$fail(peg$c147);
5790
5891
  }
5791
5892
  }
5792
5893
  if (s6 !== peg$FAILED) {
@@ -5824,7 +5925,7 @@ function peg$parse(input, options) {
5824
5925
  s4 = peg$parseEOL();
5825
5926
  if (s4 !== peg$FAILED) {
5826
5927
  peg$savedPos = s0;
5827
- s1 = peg$c150();
5928
+ s1 = peg$c148();
5828
5929
  s0 = s1;
5829
5930
  }
5830
5931
  else {
@@ -5856,7 +5957,7 @@ function peg$parse(input, options) {
5856
5957
  if (s2 === peg$FAILED) {
5857
5958
  s2 = peg$currPos;
5858
5959
  peg$savedPos = peg$currPos;
5859
- s3 = peg$c151();
5960
+ s3 = peg$c149();
5860
5961
  if (s3) {
5861
5962
  s3 = void 0;
5862
5963
  }
@@ -5887,7 +5988,7 @@ function peg$parse(input, options) {
5887
5988
  }
5888
5989
  if (s1 !== peg$FAILED) {
5889
5990
  peg$savedPos = s0;
5890
- s1 = peg$c152();
5991
+ s1 = peg$c150();
5891
5992
  }
5892
5993
  s0 = s1;
5893
5994
  return s0;
@@ -5896,7 +5997,7 @@ function peg$parse(input, options) {
5896
5997
  var s0, s1, s2;
5897
5998
  s0 = peg$currPos;
5898
5999
  peg$savedPos = peg$currPos;
5899
- s1 = peg$c153();
6000
+ s1 = peg$c151();
5900
6001
  if (s1) {
5901
6002
  s1 = void 0;
5902
6003
  }
@@ -5907,7 +6008,7 @@ function peg$parse(input, options) {
5907
6008
  s2 = peg$parseplain_line();
5908
6009
  if (s2 !== peg$FAILED) {
5909
6010
  peg$savedPos = s0;
5910
- s1 = peg$c154(s2);
6011
+ s1 = peg$c152(s2);
5911
6012
  s0 = s1;
5912
6013
  }
5913
6014
  else {
@@ -5936,7 +6037,7 @@ function peg$parse(input, options) {
5936
6037
  s2 = peg$parseplain_line();
5937
6038
  if (s2 !== peg$FAILED) {
5938
6039
  peg$savedPos = s0;
5939
- s1 = peg$c154(s2);
6040
+ s1 = peg$c152(s2);
5940
6041
  s0 = s1;
5941
6042
  }
5942
6043
  else {
@@ -5955,7 +6056,7 @@ function peg$parse(input, options) {
5955
6056
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
5956
6057
  s0 = peg$currPos;
5957
6058
  peg$savedPos = peg$currPos;
5958
- s1 = peg$c155();
6059
+ s1 = peg$c153();
5959
6060
  if (s1) {
5960
6061
  s1 = void 0;
5961
6062
  }
@@ -6038,7 +6139,7 @@ function peg$parse(input, options) {
6038
6139
  s4 = peg$parsetableHeadSeparator();
6039
6140
  if (s4 !== peg$FAILED) {
6040
6141
  peg$savedPos = s3;
6041
- s4 = peg$c156(s2, s4);
6142
+ s4 = peg$c154(s2, s4);
6042
6143
  }
6043
6144
  s3 = s4;
6044
6145
  if (s3 !== peg$FAILED) {
@@ -6119,12 +6220,12 @@ function peg$parse(input, options) {
6119
6220
  s8 = peg$parsetableBodyRowSeparator();
6120
6221
  if (s8 !== peg$FAILED) {
6121
6222
  peg$savedPos = s7;
6122
- s8 = peg$c157(s2, s3, s6, s8);
6223
+ s8 = peg$c155(s2, s3, s6, s8);
6123
6224
  }
6124
6225
  s7 = s8;
6125
6226
  if (s7 !== peg$FAILED) {
6126
6227
  peg$savedPos = s5;
6127
- s6 = peg$c158(s2, s3, s6, s7);
6228
+ s6 = peg$c156(s2, s3, s6, s7);
6128
6229
  s5 = s6;
6129
6230
  }
6130
6231
  else {
@@ -6165,7 +6266,7 @@ function peg$parse(input, options) {
6165
6266
  s8 = peg$parsetableRow();
6166
6267
  if (s8 !== peg$FAILED) {
6167
6268
  peg$savedPos = s5;
6168
- s6 = peg$c159(s2, s3, s8);
6269
+ s6 = peg$c157(s2, s3, s8);
6169
6270
  s5 = s6;
6170
6271
  }
6171
6272
  else {
@@ -6262,12 +6363,12 @@ function peg$parse(input, options) {
6262
6363
  s8 = peg$parsetableBodyRowSeparator();
6263
6364
  if (s8 !== peg$FAILED) {
6264
6365
  peg$savedPos = s7;
6265
- s8 = peg$c157(s2, s3, s6, s8);
6366
+ s8 = peg$c155(s2, s3, s6, s8);
6266
6367
  }
6267
6368
  s7 = s8;
6268
6369
  if (s7 !== peg$FAILED) {
6269
6370
  peg$savedPos = s5;
6270
- s6 = peg$c158(s2, s3, s6, s7);
6371
+ s6 = peg$c156(s2, s3, s6, s7);
6271
6372
  s5 = s6;
6272
6373
  }
6273
6374
  else {
@@ -6308,7 +6409,7 @@ function peg$parse(input, options) {
6308
6409
  s8 = peg$parsetableRow();
6309
6410
  if (s8 !== peg$FAILED) {
6310
6411
  peg$savedPos = s5;
6311
- s6 = peg$c159(s2, s3, s8);
6412
+ s6 = peg$c157(s2, s3, s8);
6312
6413
  s5 = s6;
6313
6414
  }
6314
6415
  else {
@@ -6333,7 +6434,7 @@ function peg$parse(input, options) {
6333
6434
  }
6334
6435
  if (s4 !== peg$FAILED) {
6335
6436
  peg$savedPos = peg$currPos;
6336
- s5 = peg$c160(s2, s3, s4);
6437
+ s5 = peg$c158(s2, s3, s4);
6337
6438
  if (s5) {
6338
6439
  s5 = void 0;
6339
6440
  }
@@ -6342,7 +6443,7 @@ function peg$parse(input, options) {
6342
6443
  }
6343
6444
  if (s5 !== peg$FAILED) {
6344
6445
  peg$savedPos = s0;
6345
- s1 = peg$c161(s2, s3, s4);
6446
+ s1 = peg$c159(s2, s3, s4);
6346
6447
  s0 = s1;
6347
6448
  }
6348
6449
  else {
@@ -6416,7 +6517,7 @@ function peg$parse(input, options) {
6416
6517
  }
6417
6518
  if (s4 !== peg$FAILED) {
6418
6519
  peg$savedPos = s2;
6419
- s3 = peg$c162(s3, s4);
6520
+ s3 = peg$c160(s3, s4);
6420
6521
  s2 = s3;
6421
6522
  }
6422
6523
  else {
@@ -6475,7 +6576,7 @@ function peg$parse(input, options) {
6475
6576
  }
6476
6577
  if (s4 !== peg$FAILED) {
6477
6578
  peg$savedPos = s2;
6478
- s3 = peg$c162(s3, s4);
6579
+ s3 = peg$c160(s3, s4);
6479
6580
  s2 = s3;
6480
6581
  }
6481
6582
  else {
@@ -6494,7 +6595,7 @@ function peg$parse(input, options) {
6494
6595
  }
6495
6596
  if (s1 !== peg$FAILED) {
6496
6597
  peg$savedPos = s0;
6497
- s1 = peg$c163(s1);
6598
+ s1 = peg$c161(s1);
6498
6599
  }
6499
6600
  s0 = s1;
6500
6601
  if (s0 === peg$FAILED) {
@@ -6534,7 +6635,7 @@ function peg$parse(input, options) {
6534
6635
  s5 = peg$parsepod_configuration();
6535
6636
  if (s5 !== peg$FAILED) {
6536
6637
  peg$savedPos = peg$currPos;
6537
- s6 = peg$c164(s1, s3, s5);
6638
+ s6 = peg$c162(s1, s3, s5);
6538
6639
  if (s6) {
6539
6640
  s6 = void 0;
6540
6641
  }
@@ -6543,7 +6644,7 @@ function peg$parse(input, options) {
6543
6644
  }
6544
6645
  if (s6 !== peg$FAILED) {
6545
6646
  peg$savedPos = peg$currPos;
6546
- s7 = peg$c165(s1, s3, s5);
6647
+ s7 = peg$c163(s1, s3, s5);
6547
6648
  if (s7) {
6548
6649
  s7 = void 0;
6549
6650
  }
@@ -6596,12 +6697,12 @@ function peg$parse(input, options) {
6596
6697
  }
6597
6698
  if (s9 !== peg$FAILED) {
6598
6699
  peg$savedPos = s8;
6599
- s9 = peg$c166(s1, s3, s5, s9);
6700
+ s9 = peg$c164(s1, s3, s5, s9);
6600
6701
  }
6601
6702
  s8 = s9;
6602
6703
  if (s8 !== peg$FAILED) {
6603
6704
  peg$savedPos = peg$currPos;
6604
- s9 = peg$c167(s1, s3, s5, s8);
6705
+ s9 = peg$c165(s1, s3, s5, s8);
6605
6706
  if (s9) {
6606
6707
  s9 = void 0;
6607
6708
  }
@@ -6624,7 +6725,7 @@ function peg$parse(input, options) {
6624
6725
  s13 = peg$parsestrictIdentifier();
6625
6726
  if (s13 !== peg$FAILED) {
6626
6727
  peg$savedPos = peg$currPos;
6627
- s14 = peg$c144(s1, s3, s5, s8, s10, s13);
6728
+ s14 = peg$c142(s1, s3, s5, s8, s10, s13);
6628
6729
  if (s14) {
6629
6730
  s14 = void 0;
6630
6731
  }
@@ -6638,7 +6739,7 @@ function peg$parse(input, options) {
6638
6739
  }
6639
6740
  if (s15 !== peg$FAILED) {
6640
6741
  peg$savedPos = s11;
6641
- s12 = peg$c168(s1, s3, s5, s8, s10, s13);
6742
+ s12 = peg$c166(s1, s3, s5, s8, s10, s13);
6642
6743
  s11 = s12;
6643
6744
  }
6644
6745
  else {
@@ -6662,7 +6763,7 @@ function peg$parse(input, options) {
6662
6763
  }
6663
6764
  if (s11 !== peg$FAILED) {
6664
6765
  peg$savedPos = s0;
6665
- s1 = peg$c169(s1, s3, s5, s8, s10, s11);
6766
+ s1 = peg$c167(s1, s3, s5, s8, s10, s11);
6666
6767
  s0 = s1;
6667
6768
  }
6668
6769
  else {
@@ -6742,7 +6843,7 @@ function peg$parse(input, options) {
6742
6843
  s5 = peg$parsepod_configuration();
6743
6844
  if (s5 !== peg$FAILED) {
6744
6845
  peg$savedPos = peg$currPos;
6745
- s6 = peg$c164(s1, s3, s5);
6846
+ s6 = peg$c162(s1, s3, s5);
6746
6847
  if (s6) {
6747
6848
  s6 = void 0;
6748
6849
  }
@@ -6751,7 +6852,7 @@ function peg$parse(input, options) {
6751
6852
  }
6752
6853
  if (s6 !== peg$FAILED) {
6753
6854
  peg$savedPos = peg$currPos;
6754
- s7 = peg$c170(s1, s3, s5);
6855
+ s7 = peg$c168(s1, s3, s5);
6755
6856
  if (s7) {
6756
6857
  s7 = void 0;
6757
6858
  }
@@ -6777,7 +6878,7 @@ function peg$parse(input, options) {
6777
6878
  }
6778
6879
  if (s11 !== peg$FAILED) {
6779
6880
  peg$savedPos = s8;
6780
- s9 = peg$c171(s1, s3, s5, s10);
6881
+ s9 = peg$c169(s1, s3, s5, s10);
6781
6882
  s8 = s9;
6782
6883
  }
6783
6884
  else {
@@ -6810,7 +6911,7 @@ function peg$parse(input, options) {
6810
6911
  s12 = peg$parsestrictIdentifier();
6811
6912
  if (s12 !== peg$FAILED) {
6812
6913
  peg$savedPos = peg$currPos;
6813
- s13 = peg$c144(s1, s3, s5, s8, s9, s12);
6914
+ s13 = peg$c142(s1, s3, s5, s8, s9, s12);
6814
6915
  if (s13) {
6815
6916
  s13 = void 0;
6816
6917
  }
@@ -6824,7 +6925,7 @@ function peg$parse(input, options) {
6824
6925
  }
6825
6926
  if (s14 !== peg$FAILED) {
6826
6927
  peg$savedPos = s10;
6827
- s11 = peg$c172(s1, s3, s5, s8, s9, s12);
6928
+ s11 = peg$c170(s1, s3, s5, s8, s9, s12);
6828
6929
  s10 = s11;
6829
6930
  }
6830
6931
  else {
@@ -6848,7 +6949,7 @@ function peg$parse(input, options) {
6848
6949
  }
6849
6950
  if (s10 !== peg$FAILED) {
6850
6951
  peg$savedPos = peg$currPos;
6851
- s11 = peg$c146(s1, s3, s5, s8, s9, s10);
6952
+ s11 = peg$c144(s1, s3, s5, s8, s9, s10);
6852
6953
  if (s11) {
6853
6954
  s11 = void 0;
6854
6955
  }
@@ -6857,7 +6958,7 @@ function peg$parse(input, options) {
6857
6958
  }
6858
6959
  if (s11 !== peg$FAILED) {
6859
6960
  peg$savedPos = s0;
6860
- s1 = peg$c173(s1, s3, s5, s8, s9, s10);
6961
+ s1 = peg$c171(s1, s3, s5, s8, s9, s10);
6861
6962
  s0 = s1;
6862
6963
  }
6863
6964
  else {
@@ -6980,7 +7081,7 @@ function peg$parse(input, options) {
6980
7081
  }
6981
7082
  if (s8 !== peg$FAILED) {
6982
7083
  peg$savedPos = s7;
6983
- s8 = peg$c174(s1, s3, s5, s8);
7084
+ s8 = peg$c172(s1, s3, s5, s8);
6984
7085
  }
6985
7086
  s7 = s8;
6986
7087
  if (s7 === peg$FAILED) {
@@ -7030,7 +7131,7 @@ function peg$parse(input, options) {
7030
7131
  }
7031
7132
  if (s9 !== peg$FAILED) {
7032
7133
  peg$savedPos = s7;
7033
- s8 = peg$c175(s1, s3, s5, s8, s9);
7134
+ s8 = peg$c173(s1, s3, s5, s8, s9);
7034
7135
  s7 = s8;
7035
7136
  }
7036
7137
  else {
@@ -7088,7 +7189,7 @@ function peg$parse(input, options) {
7088
7189
  }
7089
7190
  if (s8 !== peg$FAILED) {
7090
7191
  peg$savedPos = s7;
7091
- s8 = peg$c174(s1, s3, s5, s8);
7192
+ s8 = peg$c172(s1, s3, s5, s8);
7092
7193
  }
7093
7194
  s7 = s8;
7094
7195
  if (s7 === peg$FAILED) {
@@ -7138,7 +7239,7 @@ function peg$parse(input, options) {
7138
7239
  }
7139
7240
  if (s9 !== peg$FAILED) {
7140
7241
  peg$savedPos = s7;
7141
- s8 = peg$c175(s1, s3, s5, s8, s9);
7242
+ s8 = peg$c173(s1, s3, s5, s8, s9);
7142
7243
  s7 = s8;
7143
7244
  }
7144
7245
  else {
@@ -7168,7 +7269,7 @@ function peg$parse(input, options) {
7168
7269
  s10 = peg$parsestrictIdentifier();
7169
7270
  if (s10 !== peg$FAILED) {
7170
7271
  peg$savedPos = peg$currPos;
7171
- s11 = peg$c144(s1, s3, s5, s6, s7, s10);
7272
+ s11 = peg$c142(s1, s3, s5, s6, s7, s10);
7172
7273
  if (s11) {
7173
7274
  s11 = void 0;
7174
7275
  }
@@ -7182,7 +7283,7 @@ function peg$parse(input, options) {
7182
7283
  }
7183
7284
  if (s12 !== peg$FAILED) {
7184
7285
  peg$savedPos = s8;
7185
- s9 = peg$c176(s1, s3, s5, s6, s7, s10);
7286
+ s9 = peg$c174(s1, s3, s5, s6, s7, s10);
7186
7287
  s8 = s9;
7187
7288
  }
7188
7289
  else {
@@ -7206,7 +7307,7 @@ function peg$parse(input, options) {
7206
7307
  }
7207
7308
  if (s8 !== peg$FAILED) {
7208
7309
  peg$savedPos = peg$currPos;
7209
- s9 = peg$c146(s1, s3, s5, s6, s7, s8);
7310
+ s9 = peg$c144(s1, s3, s5, s6, s7, s8);
7210
7311
  if (s9) {
7211
7312
  s9 = void 0;
7212
7313
  }
@@ -7215,7 +7316,7 @@ function peg$parse(input, options) {
7215
7316
  }
7216
7317
  if (s9 !== peg$FAILED) {
7217
7318
  peg$savedPos = s0;
7218
- s1 = peg$c177(s1, s3, s5, s6, s7, s8);
7319
+ s1 = peg$c175(s1, s3, s5, s6, s7, s8);
7219
7320
  s0 = s1;
7220
7321
  }
7221
7322
  else {
@@ -7277,7 +7378,7 @@ function peg$parse(input, options) {
7277
7378
  }
7278
7379
  if (s2 !== peg$FAILED) {
7279
7380
  peg$savedPos = s0;
7280
- s1 = peg$c178();
7381
+ s1 = peg$c176();
7281
7382
  s0 = s1;
7282
7383
  }
7283
7384
  else {
@@ -7299,32 +7400,32 @@ function peg$parse(input, options) {
7299
7400
  s3 = peg$parseemptyline();
7300
7401
  if (s3 !== peg$FAILED) {
7301
7402
  peg$savedPos = s2;
7302
- s3 = peg$c179();
7403
+ s3 = peg$c177();
7303
7404
  }
7304
7405
  s2 = s3;
7305
7406
  if (s2 === peg$FAILED) {
7306
7407
  s2 = [];
7307
- if (peg$c180.test(input.charAt(peg$currPos))) {
7408
+ if (peg$c178.test(input.charAt(peg$currPos))) {
7308
7409
  s3 = input.charAt(peg$currPos);
7309
7410
  peg$currPos++;
7310
7411
  }
7311
7412
  else {
7312
7413
  s3 = peg$FAILED;
7313
7414
  if (peg$silentFails === 0) {
7314
- peg$fail(peg$c181);
7415
+ peg$fail(peg$c179);
7315
7416
  }
7316
7417
  }
7317
7418
  if (s3 !== peg$FAILED) {
7318
7419
  while (s3 !== peg$FAILED) {
7319
7420
  s2.push(s3);
7320
- if (peg$c180.test(input.charAt(peg$currPos))) {
7421
+ if (peg$c178.test(input.charAt(peg$currPos))) {
7321
7422
  s3 = input.charAt(peg$currPos);
7322
7423
  peg$currPos++;
7323
7424
  }
7324
7425
  else {
7325
7426
  s3 = peg$FAILED;
7326
7427
  if (peg$silentFails === 0) {
7327
- peg$fail(peg$c181);
7428
+ peg$fail(peg$c179);
7328
7429
  }
7329
7430
  }
7330
7431
  }
@@ -7343,32 +7444,32 @@ function peg$parse(input, options) {
7343
7444
  s3 = peg$parseemptyline();
7344
7445
  if (s3 !== peg$FAILED) {
7345
7446
  peg$savedPos = s2;
7346
- s3 = peg$c179();
7447
+ s3 = peg$c177();
7347
7448
  }
7348
7449
  s2 = s3;
7349
7450
  if (s2 === peg$FAILED) {
7350
7451
  s2 = [];
7351
- if (peg$c180.test(input.charAt(peg$currPos))) {
7452
+ if (peg$c178.test(input.charAt(peg$currPos))) {
7352
7453
  s3 = input.charAt(peg$currPos);
7353
7454
  peg$currPos++;
7354
7455
  }
7355
7456
  else {
7356
7457
  s3 = peg$FAILED;
7357
7458
  if (peg$silentFails === 0) {
7358
- peg$fail(peg$c181);
7459
+ peg$fail(peg$c179);
7359
7460
  }
7360
7461
  }
7361
7462
  if (s3 !== peg$FAILED) {
7362
7463
  while (s3 !== peg$FAILED) {
7363
7464
  s2.push(s3);
7364
- if (peg$c180.test(input.charAt(peg$currPos))) {
7465
+ if (peg$c178.test(input.charAt(peg$currPos))) {
7365
7466
  s3 = input.charAt(peg$currPos);
7366
7467
  peg$currPos++;
7367
7468
  }
7368
7469
  else {
7369
7470
  s3 = peg$FAILED;
7370
7471
  if (peg$silentFails === 0) {
7371
- peg$fail(peg$c181);
7472
+ peg$fail(peg$c179);
7372
7473
  }
7373
7474
  }
7374
7475
  }
@@ -7387,7 +7488,7 @@ function peg$parse(input, options) {
7387
7488
  }
7388
7489
  if (s1 !== peg$FAILED) {
7389
7490
  peg$savedPos = s0;
7390
- s1 = peg$c182(s1);
7491
+ s1 = peg$c180(s1);
7391
7492
  }
7392
7493
  s0 = s1;
7393
7494
  return s0;
@@ -7426,7 +7527,7 @@ function peg$parse(input, options) {
7426
7527
  }
7427
7528
  if (s5 !== peg$FAILED) {
7428
7529
  peg$savedPos = peg$currPos;
7429
- s6 = peg$c183(s1, s3);
7530
+ s6 = peg$c181(s1, s3);
7430
7531
  if (s6) {
7431
7532
  s6 = void 0;
7432
7533
  }
@@ -7451,7 +7552,7 @@ function peg$parse(input, options) {
7451
7552
  s10 = peg$parseraw_line();
7452
7553
  if (s10 !== peg$FAILED) {
7453
7554
  peg$savedPos = s8;
7454
- s9 = peg$c184(s1, s3, s10);
7555
+ s9 = peg$c182(s1, s3, s10);
7455
7556
  s8 = s9;
7456
7557
  }
7457
7558
  else {
@@ -7481,7 +7582,7 @@ function peg$parse(input, options) {
7481
7582
  s10 = peg$parseraw_line();
7482
7583
  if (s10 !== peg$FAILED) {
7483
7584
  peg$savedPos = s8;
7484
- s9 = peg$c184(s1, s3, s10);
7585
+ s9 = peg$c182(s1, s3, s10);
7485
7586
  s8 = s9;
7486
7587
  }
7487
7588
  else {
@@ -7496,7 +7597,7 @@ function peg$parse(input, options) {
7496
7597
  }
7497
7598
  if (s7 !== peg$FAILED) {
7498
7599
  peg$savedPos = s0;
7499
- s1 = peg$c185(s1, s3, s7);
7600
+ s1 = peg$c183(s1, s3, s7);
7500
7601
  s0 = s1;
7501
7602
  }
7502
7603
  else {
@@ -7569,7 +7670,7 @@ function peg$parse(input, options) {
7569
7670
  }
7570
7671
  if (s5 !== peg$FAILED) {
7571
7672
  peg$savedPos = peg$currPos;
7572
- s6 = peg$c186(s1, s3);
7673
+ s6 = peg$c184(s1, s3);
7573
7674
  if (s6) {
7574
7675
  s6 = void 0;
7575
7676
  }
@@ -7578,7 +7679,7 @@ function peg$parse(input, options) {
7578
7679
  }
7579
7680
  if (s6 !== peg$FAILED) {
7580
7681
  peg$savedPos = peg$currPos;
7581
- s7 = peg$c187(s1, s3);
7682
+ s7 = peg$c185(s1, s3);
7582
7683
  if (s7) {
7583
7684
  s7 = void 0;
7584
7685
  }
@@ -7589,7 +7690,7 @@ function peg$parse(input, options) {
7589
7690
  s8 = peg$parsetableContents();
7590
7691
  if (s8 !== peg$FAILED) {
7591
7692
  peg$savedPos = s0;
7592
- s1 = peg$c188(s1, s3, s8);
7693
+ s1 = peg$c186(s1, s3, s8);
7593
7694
  s0 = s1;
7594
7695
  }
7595
7696
  else {
@@ -7683,7 +7784,7 @@ function peg$parse(input, options) {
7683
7784
  s9 = peg$parsetext_content();
7684
7785
  if (s9 !== peg$FAILED) {
7685
7786
  peg$savedPos = s7;
7686
- s8 = peg$c189(s1, s3, s5, s9);
7787
+ s8 = peg$c187(s1, s3, s5, s9);
7687
7788
  s7 = s8;
7688
7789
  }
7689
7790
  else {
@@ -7713,7 +7814,7 @@ function peg$parse(input, options) {
7713
7814
  s9 = peg$parsetext_content();
7714
7815
  if (s9 !== peg$FAILED) {
7715
7816
  peg$savedPos = s7;
7716
- s8 = peg$c189(s1, s3, s5, s9);
7817
+ s8 = peg$c187(s1, s3, s5, s9);
7717
7818
  s7 = s8;
7718
7819
  }
7719
7820
  else {
@@ -7728,7 +7829,7 @@ function peg$parse(input, options) {
7728
7829
  }
7729
7830
  if (s6 !== peg$FAILED) {
7730
7831
  peg$savedPos = s0;
7731
- s1 = peg$c190(s1, s3, s5, s6);
7832
+ s1 = peg$c188(s1, s3, s5, s6);
7732
7833
  s0 = s1;
7733
7834
  }
7734
7835
  else {
@@ -7778,14 +7879,14 @@ function peg$parse(input, options) {
7778
7879
  s4 = peg$currPos;
7779
7880
  s5 = peg$parse_();
7780
7881
  if (s5 !== peg$FAILED) {
7781
- if (input.substr(peg$currPos, 2) === peg$c191) {
7782
- s6 = peg$c191;
7882
+ if (input.substr(peg$currPos, 2) === peg$c189) {
7883
+ s6 = peg$c189;
7783
7884
  peg$currPos += 2;
7784
7885
  }
7785
7886
  else {
7786
7887
  s6 = peg$FAILED;
7787
7888
  if (peg$silentFails === 0) {
7788
- peg$fail(peg$c192);
7889
+ peg$fail(peg$c190);
7789
7890
  }
7790
7891
  }
7791
7892
  if (s6 !== peg$FAILED) {
@@ -7808,7 +7909,7 @@ function peg$parse(input, options) {
7808
7909
  s10 = peg$parsenewline();
7809
7910
  if (s10 !== peg$FAILED) {
7810
7911
  peg$savedPos = s4;
7811
- s5 = peg$c119(s1, s8);
7912
+ s5 = peg$c117(s1, s8);
7812
7913
  s4 = s5;
7813
7914
  }
7814
7915
  else {
@@ -7845,14 +7946,14 @@ function peg$parse(input, options) {
7845
7946
  s4 = peg$currPos;
7846
7947
  s5 = peg$parse_();
7847
7948
  if (s5 !== peg$FAILED) {
7848
- if (input.substr(peg$currPos, 2) === peg$c191) {
7849
- s6 = peg$c191;
7949
+ if (input.substr(peg$currPos, 2) === peg$c189) {
7950
+ s6 = peg$c189;
7850
7951
  peg$currPos += 2;
7851
7952
  }
7852
7953
  else {
7853
7954
  s6 = peg$FAILED;
7854
7955
  if (peg$silentFails === 0) {
7855
- peg$fail(peg$c192);
7956
+ peg$fail(peg$c190);
7856
7957
  }
7857
7958
  }
7858
7959
  if (s6 !== peg$FAILED) {
@@ -7875,7 +7976,7 @@ function peg$parse(input, options) {
7875
7976
  s10 = peg$parsenewline();
7876
7977
  if (s10 !== peg$FAILED) {
7877
7978
  peg$savedPos = s4;
7878
- s5 = peg$c119(s1, s8);
7979
+ s5 = peg$c117(s1, s8);
7879
7980
  s4 = s5;
7880
7981
  }
7881
7982
  else {
@@ -7910,7 +8011,7 @@ function peg$parse(input, options) {
7910
8011
  }
7911
8012
  if (s3 !== peg$FAILED) {
7912
8013
  peg$savedPos = s0;
7913
- s1 = peg$c193(s1, s3);
8014
+ s1 = peg$c191(s1, s3);
7914
8015
  s0 = s1;
7915
8016
  }
7916
8017
  else {
@@ -7949,7 +8050,7 @@ function peg$parse(input, options) {
7949
8050
  s3 = peg$parseEOL();
7950
8051
  if (s3 !== peg$FAILED) {
7951
8052
  peg$savedPos = s0;
7952
- s1 = peg$c194(s1);
8053
+ s1 = peg$c192(s1);
7953
8054
  s0 = s1;
7954
8055
  }
7955
8056
  else {
@@ -8090,7 +8191,7 @@ function peg$parse(input, options) {
8090
8191
  s6 = peg$parseEOL();
8091
8192
  if (s6 !== peg$FAILED) {
8092
8193
  peg$savedPos = s0;
8093
- s1 = peg$c195(s3, s5);
8194
+ s1 = peg$c193(s3, s5);
8094
8195
  s0 = s1;
8095
8196
  }
8096
8197
  else {
@@ -8240,7 +8341,7 @@ function peg$parse(input, options) {
8240
8341
  s5 = peg$parseEOL();
8241
8342
  if (s5 !== peg$FAILED) {
8242
8343
  peg$savedPos = s3;
8243
- s4 = peg$c196(s4);
8344
+ s4 = peg$c194(s4);
8244
8345
  s3 = s4;
8245
8346
  }
8246
8347
  else {
@@ -8255,7 +8356,7 @@ function peg$parse(input, options) {
8255
8356
  }
8256
8357
  if (s3 !== peg$FAILED) {
8257
8358
  peg$savedPos = s0;
8258
- s1 = peg$c197(s3);
8359
+ s1 = peg$c195(s3);
8259
8360
  s0 = s1;
8260
8361
  }
8261
8362
  else {
@@ -8286,14 +8387,14 @@ function peg$parse(input, options) {
8286
8387
  s1 = s2;
8287
8388
  }
8288
8389
  if (s1 !== peg$FAILED) {
8289
- if (input.substr(peg$currPos, 4) === peg$c198) {
8290
- s2 = peg$c198;
8390
+ if (input.substr(peg$currPos, 4) === peg$c196) {
8391
+ s2 = peg$c196;
8291
8392
  peg$currPos += 4;
8292
8393
  }
8293
8394
  else {
8294
8395
  s2 = peg$FAILED;
8295
8396
  if (peg$silentFails === 0) {
8296
- peg$fail(peg$c199);
8397
+ peg$fail(peg$c197);
8297
8398
  }
8298
8399
  }
8299
8400
  if (s2 !== peg$FAILED) {
@@ -8322,7 +8423,7 @@ function peg$parse(input, options) {
8322
8423
  }
8323
8424
  if (s5 !== peg$FAILED) {
8324
8425
  peg$savedPos = s0;
8325
- s1 = peg$c200(s1, s4, s5);
8426
+ s1 = peg$c198(s1, s4, s5);
8326
8427
  s0 = s1;
8327
8428
  }
8328
8429
  else {
@@ -8390,7 +8491,7 @@ function peg$parse(input, options) {
8390
8491
  s6 = peg$parsealias_replacement_text();
8391
8492
  if (s6 !== peg$FAILED) {
8392
8493
  peg$savedPos = s0;
8393
- s1 = peg$c201(s1, s2, s4, s6);
8494
+ s1 = peg$c199(s1, s2, s4, s6);
8394
8495
  s0 = s1;
8395
8496
  }
8396
8497
  else {
@@ -8451,25 +8552,25 @@ function peg$parse(input, options) {
8451
8552
  if (s3 !== peg$FAILED) {
8452
8553
  s4 = peg$currPos;
8453
8554
  s5 = peg$currPos;
8454
- if (peg$c202.test(input.charAt(peg$currPos))) {
8555
+ if (peg$c200.test(input.charAt(peg$currPos))) {
8455
8556
  s6 = input.charAt(peg$currPos);
8456
8557
  peg$currPos++;
8457
8558
  }
8458
8559
  else {
8459
8560
  s6 = peg$FAILED;
8460
8561
  if (peg$silentFails === 0) {
8461
- peg$fail(peg$c203);
8562
+ peg$fail(peg$c201);
8462
8563
  }
8463
8564
  }
8464
8565
  if (s6 !== peg$FAILED) {
8465
- if (input.substr(peg$currPos, 2) === peg$c204) {
8466
- s7 = peg$c204;
8566
+ if (input.substr(peg$currPos, 2) === peg$c202) {
8567
+ s7 = peg$c202;
8467
8568
  peg$currPos += 2;
8468
8569
  }
8469
8570
  else {
8470
8571
  s7 = peg$FAILED;
8471
8572
  if (peg$silentFails === 0) {
8472
- peg$fail(peg$c205);
8573
+ peg$fail(peg$c203);
8473
8574
  }
8474
8575
  }
8475
8576
  if (s7 !== peg$FAILED) {
@@ -8500,7 +8601,7 @@ function peg$parse(input, options) {
8500
8601
  s6 = peg$parsepod_configuration();
8501
8602
  if (s6 !== peg$FAILED) {
8502
8603
  peg$savedPos = s0;
8503
- s1 = peg$c206(s1, s2, s4, s6);
8604
+ s1 = peg$c204(s1, s2, s4, s6);
8504
8605
  s0 = s1;
8505
8606
  }
8506
8607
  else {
@@ -8546,14 +8647,14 @@ function peg$parse(input, options) {
8546
8647
  s1 = s2;
8547
8648
  }
8548
8649
  if (s1 !== peg$FAILED) {
8549
- if (input.substr(peg$currPos, 9) === peg$c207) {
8550
- s2 = peg$c207;
8650
+ if (input.substr(peg$currPos, 9) === peg$c205) {
8651
+ s2 = peg$c205;
8551
8652
  peg$currPos += 9;
8552
8653
  }
8553
8654
  else {
8554
8655
  s2 = peg$FAILED;
8555
8656
  if (peg$silentFails === 0) {
8556
- peg$fail(peg$c208);
8657
+ peg$fail(peg$c206);
8557
8658
  }
8558
8659
  }
8559
8660
  if (s2 !== peg$FAILED) {
@@ -8562,7 +8663,7 @@ function peg$parse(input, options) {
8562
8663
  s4 = peg$parsepod_configuration();
8563
8664
  if (s4 !== peg$FAILED) {
8564
8665
  peg$savedPos = s0;
8565
- s1 = peg$c209(s1, s2, s4);
8666
+ s1 = peg$c207(s1, s2, s4);
8566
8667
  s0 = s1;
8567
8668
  }
8568
8669
  else {
@@ -8607,7 +8708,7 @@ function peg$parse(input, options) {
8607
8708
  s5 = peg$parsepod_configuration();
8608
8709
  if (s5 !== peg$FAILED) {
8609
8710
  peg$savedPos = peg$currPos;
8610
- s6 = peg$c210(s1, s2, s3, s5);
8711
+ s6 = peg$c208(s1, s2, s3, s5);
8611
8712
  if (s6) {
8612
8713
  s6 = void 0;
8613
8714
  }
@@ -8632,7 +8733,7 @@ function peg$parse(input, options) {
8632
8733
  s10 = peg$parseraw_line();
8633
8734
  if (s10 !== peg$FAILED) {
8634
8735
  peg$savedPos = s8;
8635
- s9 = peg$c211(s1, s2, s3, s5, s10);
8736
+ s9 = peg$c209(s1, s2, s3, s5, s10);
8636
8737
  s8 = s9;
8637
8738
  }
8638
8739
  else {
@@ -8662,7 +8763,7 @@ function peg$parse(input, options) {
8662
8763
  s10 = peg$parseraw_line();
8663
8764
  if (s10 !== peg$FAILED) {
8664
8765
  peg$savedPos = s8;
8665
- s9 = peg$c211(s1, s2, s3, s5, s10);
8766
+ s9 = peg$c209(s1, s2, s3, s5, s10);
8666
8767
  s8 = s9;
8667
8768
  }
8668
8769
  else {
@@ -8677,7 +8778,7 @@ function peg$parse(input, options) {
8677
8778
  }
8678
8779
  if (s7 !== peg$FAILED) {
8679
8780
  peg$savedPos = s0;
8680
- s1 = peg$c212(s1, s2, s3, s5, s7);
8781
+ s1 = peg$c210(s1, s2, s3, s5, s7);
8681
8782
  s0 = s1;
8682
8783
  }
8683
8784
  else {
@@ -8737,7 +8838,7 @@ function peg$parse(input, options) {
8737
8838
  s5 = peg$parsepod_configuration();
8738
8839
  if (s5 !== peg$FAILED) {
8739
8840
  peg$savedPos = peg$currPos;
8740
- s6 = peg$c213(s1, s2, s3, s5);
8841
+ s6 = peg$c211(s1, s2, s3, s5);
8741
8842
  if (s6) {
8742
8843
  s6 = void 0;
8743
8844
  }
@@ -8746,7 +8847,7 @@ function peg$parse(input, options) {
8746
8847
  }
8747
8848
  if (s6 !== peg$FAILED) {
8748
8849
  peg$savedPos = peg$currPos;
8749
- s7 = peg$c214(s1, s2, s3, s5);
8850
+ s7 = peg$c212(s1, s2, s3, s5);
8750
8851
  if (s7) {
8751
8852
  s7 = void 0;
8752
8853
  }
@@ -8757,7 +8858,7 @@ function peg$parse(input, options) {
8757
8858
  s8 = peg$parsetableContents();
8758
8859
  if (s8 !== peg$FAILED) {
8759
8860
  peg$savedPos = s0;
8760
- s1 = peg$c215(s1, s2, s3, s5, s8);
8861
+ s1 = peg$c213(s1, s2, s3, s5, s8);
8761
8862
  s0 = s1;
8762
8863
  }
8763
8864
  else {
@@ -8838,7 +8939,7 @@ function peg$parse(input, options) {
8838
8939
  s9 = peg$parsetext_content();
8839
8940
  if (s9 !== peg$FAILED) {
8840
8941
  peg$savedPos = s7;
8841
- s8 = peg$c211(s1, s2, s3, s5, s9);
8942
+ s8 = peg$c209(s1, s2, s3, s5, s9);
8842
8943
  s7 = s8;
8843
8944
  }
8844
8945
  else {
@@ -8868,7 +8969,7 @@ function peg$parse(input, options) {
8868
8969
  s9 = peg$parsetext_content();
8869
8970
  if (s9 !== peg$FAILED) {
8870
8971
  peg$savedPos = s7;
8871
- s8 = peg$c211(s1, s2, s3, s5, s9);
8972
+ s8 = peg$c209(s1, s2, s3, s5, s9);
8872
8973
  s7 = s8;
8873
8974
  }
8874
8975
  else {
@@ -8883,7 +8984,7 @@ function peg$parse(input, options) {
8883
8984
  }
8884
8985
  if (s6 !== peg$FAILED) {
8885
8986
  peg$savedPos = s0;
8886
- s1 = peg$c216(s1, s2, s3, s5, s6);
8987
+ s1 = peg$c214(s1, s2, s3, s5, s6);
8887
8988
  s0 = s1;
8888
8989
  }
8889
8990
  else {
@@ -8921,14 +9022,14 @@ function peg$parse(input, options) {
8921
9022
  var s0, s1, s2, s3, s4;
8922
9023
  s0 = peg$currPos;
8923
9024
  s1 = peg$currPos;
8924
- if (peg$c217.test(input.charAt(peg$currPos))) {
9025
+ if (peg$c215.test(input.charAt(peg$currPos))) {
8925
9026
  s2 = input.charAt(peg$currPos);
8926
9027
  peg$currPos++;
8927
9028
  }
8928
9029
  else {
8929
9030
  s2 = peg$FAILED;
8930
9031
  if (peg$silentFails === 0) {
8931
- peg$fail(peg$c218);
9032
+ peg$fail(peg$c216);
8932
9033
  }
8933
9034
  }
8934
9035
  if (s2 !== peg$FAILED) {
@@ -8981,26 +9082,26 @@ function peg$parse(input, options) {
8981
9082
  var s0, s1;
8982
9083
  peg$silentFails++;
8983
9084
  s0 = [];
8984
- if (peg$c220.test(input.charAt(peg$currPos))) {
9085
+ if (peg$c218.test(input.charAt(peg$currPos))) {
8985
9086
  s1 = input.charAt(peg$currPos);
8986
9087
  peg$currPos++;
8987
9088
  }
8988
9089
  else {
8989
9090
  s1 = peg$FAILED;
8990
9091
  if (peg$silentFails === 0) {
8991
- peg$fail(peg$c221);
9092
+ peg$fail(peg$c219);
8992
9093
  }
8993
9094
  }
8994
9095
  while (s1 !== peg$FAILED) {
8995
9096
  s0.push(s1);
8996
- if (peg$c220.test(input.charAt(peg$currPos))) {
9097
+ if (peg$c218.test(input.charAt(peg$currPos))) {
8997
9098
  s1 = input.charAt(peg$currPos);
8998
9099
  peg$currPos++;
8999
9100
  }
9000
9101
  else {
9001
9102
  s1 = peg$FAILED;
9002
9103
  if (peg$silentFails === 0) {
9003
- peg$fail(peg$c221);
9104
+ peg$fail(peg$c219);
9004
9105
  }
9005
9106
  }
9006
9107
  }
@@ -9008,7 +9109,7 @@ function peg$parse(input, options) {
9008
9109
  if (s0 === peg$FAILED) {
9009
9110
  s1 = peg$FAILED;
9010
9111
  if (peg$silentFails === 0) {
9011
- peg$fail(peg$c219);
9112
+ peg$fail(peg$c217);
9012
9113
  }
9013
9114
  }
9014
9115
  return s0;
@@ -9017,26 +9118,26 @@ function peg$parse(input, options) {
9017
9118
  var s0, s1;
9018
9119
  peg$silentFails++;
9019
9120
  s0 = [];
9020
- if (peg$c220.test(input.charAt(peg$currPos))) {
9121
+ if (peg$c218.test(input.charAt(peg$currPos))) {
9021
9122
  s1 = input.charAt(peg$currPos);
9022
9123
  peg$currPos++;
9023
9124
  }
9024
9125
  else {
9025
9126
  s1 = peg$FAILED;
9026
9127
  if (peg$silentFails === 0) {
9027
- peg$fail(peg$c221);
9128
+ peg$fail(peg$c219);
9028
9129
  }
9029
9130
  }
9030
9131
  while (s1 !== peg$FAILED) {
9031
9132
  s0.push(s1);
9032
- if (peg$c220.test(input.charAt(peg$currPos))) {
9133
+ if (peg$c218.test(input.charAt(peg$currPos))) {
9033
9134
  s1 = input.charAt(peg$currPos);
9034
9135
  peg$currPos++;
9035
9136
  }
9036
9137
  else {
9037
9138
  s1 = peg$FAILED;
9038
9139
  if (peg$silentFails === 0) {
9039
- peg$fail(peg$c221);
9140
+ peg$fail(peg$c219);
9040
9141
  }
9041
9142
  }
9042
9143
  }
@@ -9044,7 +9145,7 @@ function peg$parse(input, options) {
9044
9145
  if (s0 === peg$FAILED) {
9045
9146
  s1 = peg$FAILED;
9046
9147
  if (peg$silentFails === 0) {
9047
- peg$fail(peg$c222);
9148
+ peg$fail(peg$c220);
9048
9149
  }
9049
9150
  }
9050
9151
  return s0;
@@ -9065,8 +9166,22 @@ function peg$parse(input, options) {
9065
9166
  function isSemanticBlock(name) {
9066
9167
  return name === name.toUpperCase();
9067
9168
  }
9169
+ // nested lists in one list, in time that grows with the items; a value that is not a list is taken as concat takes it
9068
9170
  function flattenDeep(arr) {
9069
- return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
9171
+ const out = [];
9172
+ const walk = list => list.forEach(item => {
9173
+ if (Array.isArray(item))
9174
+ return walk(item);
9175
+ const parts = [].concat(item);
9176
+ for (let i = 0; i < parts.length; i++) {
9177
+ if (Object.prototype.hasOwnProperty.call(parts, i))
9178
+ out.push(parts[i]);
9179
+ else
9180
+ out.length++;
9181
+ }
9182
+ });
9183
+ walk(arr);
9184
+ return out;
9070
9185
  }
9071
9186
  function valueKind(v) {
9072
9187
  if (typeof v === 'number')