@podlite/schema 0.0.40 → 0.0.42

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 (60) hide show
  1. package/CHANGELOG.podlite +17 -0
  2. package/esm/blocks-helpers.d.ts +5 -0
  3. package/esm/blocks-helpers.js +3 -0
  4. package/esm/blocks-helpers.js.map +1 -1
  5. package/esm/exportAny.d.ts +1 -0
  6. package/esm/exportAny.js +1 -1
  7. package/esm/exportAny.js.map +1 -1
  8. package/esm/exportHtml.js +47 -5
  9. package/esm/exportHtml.js.map +1 -1
  10. package/esm/exportMarkdown.js +37 -10
  11. package/esm/exportMarkdown.js.map +1 -1
  12. package/esm/grammar.js +603 -497
  13. package/esm/grammar.js.map +1 -1
  14. package/esm/grammarfc.js +418 -406
  15. package/esm/grammarfc.js.map +1 -1
  16. package/esm/helpers/handlers.d.ts +11 -0
  17. package/esm/helpers/handlers.js +25 -0
  18. package/esm/helpers/handlers.js.map +1 -1
  19. package/esm/helpers/makeInterator.js +2 -4
  20. package/esm/helpers/makeInterator.js.map +1 -1
  21. package/esm/helpers/parseAttributes.d.ts +2 -0
  22. package/esm/helpers/parseAttributes.js +12 -0
  23. package/esm/helpers/parseAttributes.js.map +1 -0
  24. package/esm/index.d.ts +1 -0
  25. package/esm/index.js +3 -0
  26. package/esm/index.js.map +1 -1
  27. package/esm/plugin-data-table.d.ts +2 -0
  28. package/esm/plugin-data-table.js +152 -0
  29. package/esm/plugin-data-table.js.map +1 -0
  30. package/esm/plugin-formatting-codes.js +10 -23
  31. package/esm/plugin-formatting-codes.js.map +1 -1
  32. package/esm/plugin-tables.d.ts +10 -0
  33. package/esm/plugin-tables.js +7 -7
  34. package/esm/plugin-tables.js.map +1 -1
  35. package/esm/selectors.d.ts +17 -1
  36. package/esm/selectors.js +294 -18
  37. package/esm/selectors.js.map +1 -1
  38. package/lib/blocks-helpers.d.ts +5 -0
  39. package/lib/blocks-helpers.js +5 -1
  40. package/lib/exportAny.d.ts +1 -0
  41. package/lib/exportAny.js +1 -1
  42. package/lib/exportHtml.js +46 -4
  43. package/lib/exportMarkdown.js +36 -9
  44. package/lib/grammar.js +603 -497
  45. package/lib/grammarfc.js +418 -406
  46. package/lib/helpers/handlers.d.ts +11 -0
  47. package/lib/helpers/handlers.js +28 -1
  48. package/lib/helpers/makeInterator.js +2 -4
  49. package/lib/helpers/parseAttributes.d.ts +2 -0
  50. package/lib/helpers/parseAttributes.js +35 -0
  51. package/lib/index.d.ts +1 -0
  52. package/lib/index.js +5 -1
  53. package/lib/plugin-data-table.d.ts +2 -0
  54. package/lib/plugin-data-table.js +157 -0
  55. package/lib/plugin-formatting-codes.js +10 -23
  56. package/lib/plugin-tables.d.ts +10 -0
  57. package/lib/plugin-tables.js +8 -0
  58. package/lib/selectors.d.ts +17 -1
  59. package/lib/selectors.js +294 -18
  60. package/package.json +2 -2
package/lib/grammar.js CHANGED
@@ -107,37 +107,37 @@ peg$SyntaxError.buildMessage = function (expected, found) {
107
107
  };
108
108
  function peg$parse(input, options) {
109
109
  options = options !== void 0 ? options : {};
110
- var peg$FAILED = {}, peg$startRuleFunctions = { Document: peg$parseDocument }, peg$startRuleFunction = peg$parseDocument, peg$c0 = function (nodes) { return nodes; }, peg$c1 = function () { return !!options.podMode === true; }, peg$c2 = function (n) { return n; }, peg$c3 = peg$anyExpectation(), peg$c4 = function () {
110
+ var peg$FAILED = {}, peg$startRuleFunctions = { Document: peg$parseDocument, attributesOnly: peg$parseattributesOnly }, peg$startRuleFunction = peg$parseDocument, peg$c0 = function (nodes) { return nodes; }, peg$c1 = function (attrs) { return attrs; }, peg$c2 = function () { return !!options.podMode === true; }, peg$c3 = function (n) { return n; }, peg$c4 = peg$anyExpectation(), peg$c5 = function () {
111
111
  return {
112
112
  text: text(),
113
113
  type: 'ambient',
114
114
  location: location()
115
115
  };
116
- }, peg$c5 = /^[ \xA0\u2001\t\f\u2008]/, peg$c6 = peg$classExpectation([" ", "\xA0", "\u2001", "\t", "\f", "\u2008"], false, false), peg$c7 = /^[ \t\f]/, peg$c8 = peg$classExpectation([" ", "\t", "\f"], false, false), peg$c9 = /^[\n\r]/, peg$c10 = peg$classExpectation(["\n", "\r"], false, false), peg$c11 = function (text) { return text; }, peg$c12 = /^[^\n\r]/, peg$c13 = peg$classExpectation(["\n", "\r"], true, false), peg$c14 = "\n", peg$c15 = peg$literalExpectation("\n", false), peg$c16 = "\r", peg$c17 = peg$literalExpectation("\r", false), peg$c18 = function () { return { type: 'blankline' }; }, peg$c19 = "=begin ", peg$c20 = peg$literalExpectation("=begin ", false), peg$c21 = "=end ", peg$c22 = peg$literalExpectation("=end ", false), peg$c23 = "=for ", peg$c24 = peg$literalExpectation("=for ", false), peg$c25 = "=config", peg$c26 = peg$literalExpectation("=config", false), peg$c27 = "=alias", peg$c28 = peg$literalExpectation("=alias", false), peg$c29 = function (name) { return isSupportedBlockName(name); }, peg$c30 = function (name) { return name; }, peg$c31 = "=", peg$c32 = peg$literalExpectation("=", false), peg$c33 = peg$otherExpectation("text"), peg$c34 = function () { return text(); }, peg$c35 = function () { return { type: "para", value: text(), error: true, location: location() }; }, peg$c36 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c37 = function (code) { return [code]; }, peg$c38 = ",", peg$c39 = peg$literalExpectation(",", false), peg$c40 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c41 = /^[a-zA-Z0-9]/, peg$c42 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false), peg$c43 = /^[a-zA-Z0-9_\-]/, peg$c44 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false), peg$c45 = "=>", peg$c46 = peg$literalExpectation("=>", false), peg$c47 = function (name, value) { return { [name]: value }; }, peg$c48 = function (pair, pairs) { return { ...pair, ...pairs }; }, peg$c49 = function (code) { return code; }, peg$c50 = ":", peg$c51 = peg$literalExpectation(":", false), peg$c52 = "allow", peg$c53 = peg$literalExpectation("allow", false), peg$c54 = "<", peg$c55 = peg$literalExpectation("<", false), peg$c56 = ">", peg$c57 = peg$literalExpectation(">", false), peg$c58 = function (key, array) { return { value: array, type: "array" }; }, peg$c59 = function (key, value) { return { name: 'allow', ...value }; }, peg$c60 = function (i) { return i; }, peg$c61 = function (all) { return all; }, peg$c62 = function (res) { return [res]; }, peg$c63 = function () { return []; }, peg$c64 = /^[!]/, peg$c65 = peg$classExpectation(["!"], false, false), peg$c66 = "{", peg$c67 = peg$literalExpectation("{", false), peg$c68 = "}", peg$c69 = peg$literalExpectation("}", false), peg$c70 = function (isFalse, key, hash) { return { value: hash, type: "map" }; }, peg$c71 = "[", peg$c72 = peg$literalExpectation("[", false), peg$c73 = function (isFalse, key, array) { return array; }, peg$c74 = "]", peg$c75 = peg$literalExpectation("]", false), peg$c76 = function (isFalse, key) { return [text()]; }, peg$c77 = function (isFalse, key, array) {
116
+ }, peg$c6 = /^[ \xA0\u2001\t\f\u2008]/, peg$c7 = peg$classExpectation([" ", "\xA0", "\u2001", "\t", "\f", "\u2008"], false, false), peg$c8 = /^[ \t\f]/, peg$c9 = peg$classExpectation([" ", "\t", "\f"], false, false), peg$c10 = /^[\n\r]/, peg$c11 = peg$classExpectation(["\n", "\r"], false, false), peg$c12 = function (text) { return text; }, peg$c13 = /^[^\n\r]/, peg$c14 = peg$classExpectation(["\n", "\r"], true, false), peg$c15 = "\n", peg$c16 = peg$literalExpectation("\n", false), peg$c17 = "\r", peg$c18 = peg$literalExpectation("\r", false), peg$c19 = function () { return { type: 'blankline' }; }, peg$c20 = "=begin ", peg$c21 = peg$literalExpectation("=begin ", false), peg$c22 = "=end ", peg$c23 = peg$literalExpectation("=end ", false), peg$c24 = "=for ", peg$c25 = peg$literalExpectation("=for ", false), peg$c26 = "=config", peg$c27 = peg$literalExpectation("=config", false), peg$c28 = "=alias", peg$c29 = peg$literalExpectation("=alias", false), peg$c30 = function (name) { return isSupportedBlockName(name); }, peg$c31 = function (name) { return name; }, peg$c32 = "=", peg$c33 = peg$literalExpectation("=", false), peg$c34 = peg$otherExpectation("text"), peg$c35 = function () { return text(); }, peg$c36 = function () { return { type: "para", value: text(), error: true, location: location() }; }, peg$c37 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c38 = function (code) { return [code]; }, peg$c39 = ",", peg$c40 = peg$literalExpectation(",", false), peg$c41 = function (code, codes) { return flattenDeep([code, codes]); }, peg$c42 = /^[a-zA-Z0-9]/, peg$c43 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false), peg$c44 = /^[a-zA-Z0-9_\-]/, peg$c45 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false), peg$c46 = "=>", peg$c47 = peg$literalExpectation("=>", false), peg$c48 = function (name, value) { return { [name]: value }; }, peg$c49 = function (pair, pairs) { return { ...pair, ...pairs }; }, peg$c50 = function (code) { return code; }, peg$c51 = ":", peg$c52 = peg$literalExpectation(":", false), peg$c53 = "allow", peg$c54 = peg$literalExpectation("allow", false), peg$c55 = "<", peg$c56 = peg$literalExpectation("<", false), peg$c57 = ">", peg$c58 = peg$literalExpectation(">", false), peg$c59 = function (key, array) { return { value: array, type: "array" }; }, peg$c60 = function (key, value) { return { name: 'allow', ...value }; }, peg$c61 = function (i) { return i; }, peg$c62 = function (all) { return all; }, peg$c63 = function (res) { return [res]; }, peg$c64 = function () { return []; }, peg$c65 = /^[!]/, peg$c66 = peg$classExpectation(["!"], false, false), peg$c67 = "{", peg$c68 = peg$literalExpectation("{", false), peg$c69 = "}", peg$c70 = peg$literalExpectation("}", false), peg$c71 = function (isFalse, key, hash) { return { value: hash, type: "map" }; }, peg$c72 = "[", peg$c73 = peg$literalExpectation("[", false), peg$c74 = function (isFalse, key, array) { return array; }, peg$c75 = "]", peg$c76 = peg$literalExpectation("]", false), peg$c77 = function (isFalse, key) { return [text()]; }, peg$c78 = function (isFalse, key, array) {
117
117
  return {
118
118
  value: array,
119
119
  type: "array"
120
120
  };
121
- }, peg$c78 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c79 = function (isFalse, key, array) { return { value: array, type: "string" }; }, peg$c80 = "(", peg$c81 = peg$literalExpectation("(", false), peg$c82 = function (isFalse, key, array) {
121
+ }, peg$c79 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c80 = function (isFalse, key, array) { return { value: array, type: "string" }; }, peg$c81 = "(", peg$c82 = peg$literalExpectation("(", false), peg$c83 = function (isFalse, key, array) {
122
122
  // if one element (23) set type to 'value'
123
123
  return (array.length > 1)
124
124
  ? { type: 'array', value: array }
125
125
  : { type: 'value', value: array[0] };
126
- }, peg$c83 = ")", peg$c84 = peg$literalExpectation(")", false), peg$c85 = function (isFalse, key) { return { value: text() }; }, peg$c86 = function (isFalse, key, res) {
126
+ }, peg$c84 = ")", peg$c85 = peg$literalExpectation(")", false), peg$c86 = function (isFalse, key) { return { value: text() }; }, peg$c87 = function (isFalse, key, res) {
127
127
  return {
128
128
  type: "value",
129
129
  ...res
130
130
  };
131
- }, peg$c87 = function (isFalse, key) {
131
+ }, peg$c88 = function (isFalse, key) {
132
132
  return {
133
133
  value: !isFalse,
134
134
  type: "boolean"
135
135
  };
136
- }, peg$c88 = function (isFalse, key, value) { return { name: key, ...value }; }, peg$c89 = function (first, rest) { return rest; }, peg$c90 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c91 = /^[^'"]/, peg$c92 = peg$classExpectation(["'", "\""], true, false), peg$c93 = function (text) { return text; }, peg$c94 = /^[0-9]/, peg$c95 = peg$classExpectation([["0", "9"]], false, false), peg$c96 = /^[\-+]/, peg$c97 = peg$classExpectation(["-", "+"], false, false), peg$c98 = "True", peg$c99 = peg$literalExpectation("True", false), peg$c100 = function () { return true; }, peg$c101 = "False", peg$c102 = peg$literalExpectation("False", false), peg$c103 = function () { return false; }, peg$c104 = ".", peg$c105 = peg$literalExpectation(".", false), peg$c106 = /^[eE]/, peg$c107 = peg$classExpectation(["e", "E"], false, false), peg$c108 = /^["]/, peg$c109 = peg$classExpectation(["\""], false, false), peg$c110 = /^[^"]/, peg$c111 = peg$classExpectation(["\""], true, false), peg$c112 = /^[']/, peg$c113 = peg$classExpectation(["'"], false, false), peg$c114 = /^[^']/, peg$c115 = peg$classExpectation(["'"], true, false), peg$c116 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c117 = function (number) { return parseInt(number, 10); }, peg$c118 = function (vmargin, name, config) {
136
+ }, peg$c89 = function (isFalse, key, value) { return { name: key, ...value }; }, peg$c90 = function (first, rest) { return rest; }, peg$c91 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c92 = /^[^'"]/, peg$c93 = peg$classExpectation(["'", "\""], true, false), peg$c94 = function (text) { return text; }, peg$c95 = /^[0-9]/, peg$c96 = peg$classExpectation([["0", "9"]], false, false), peg$c97 = /^[\-+]/, peg$c98 = peg$classExpectation(["-", "+"], false, false), peg$c99 = "True", peg$c100 = peg$literalExpectation("True", false), peg$c101 = function () { return true; }, peg$c102 = "False", peg$c103 = peg$literalExpectation("False", false), peg$c104 = function () { return false; }, peg$c105 = ".", peg$c106 = peg$literalExpectation(".", false), peg$c107 = /^[eE]/, peg$c108 = peg$classExpectation(["e", "E"], false, false), peg$c109 = /^["]/, peg$c110 = peg$classExpectation(["\""], false, false), peg$c111 = /^[^"]/, peg$c112 = peg$classExpectation(["\""], true, false), peg$c113 = /^[']/, peg$c114 = peg$classExpectation(["'"], false, false), peg$c115 = /^[^']/, peg$c116 = peg$classExpectation(["'"], true, false), peg$c117 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c118 = function (number) { return parseInt(number, 10); }, peg$c119 = function (vmargin, name, config) {
137
137
  return ((name.match(/code|comment|formula|output|input|markdown|picture|toc|data/))
138
138
  ||
139
139
  isNamedBlock(name));
140
- }, peg$c119 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c120 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c121 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c122 = function (vmargin, name, config, content, vmargin2, ename) {
140
+ }, peg$c120 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c121 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c122 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c123 = function (vmargin, name, config, content, vmargin2, ename) {
141
141
  const type = 'block';
142
142
  return {
143
143
  type: type,
@@ -145,29 +145,29 @@ function peg$parse(input, options) {
145
145
  name,
146
146
  margin: vmargin
147
147
  };
148
- }, peg$c123 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c124 = function (vmargin, name, config, content, vmargin2, res) {
148
+ }, peg$c124 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c125 = function (vmargin, name, config, content, vmargin2, res) {
149
149
  return {
150
150
  ...res,
151
151
  text: text(),
152
152
  config,
153
153
  location: location()
154
154
  };
155
- }, peg$c125 = /^[\-+=_|]/, peg$c126 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c127 = function () { return { type: 'separator', text: text() }; }, peg$c128 = function () { return options.isDelimited; }, peg$c129 = function () {
155
+ }, peg$c126 = /^[\-+=_|]/, peg$c127 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c128 = function () { return { type: 'separator', text: text() }; }, peg$c129 = function () { return options.isDelimited; }, peg$c130 = function () {
156
156
  return {
157
157
  type: 'separator',
158
158
  text: text()
159
159
  };
160
- }, peg$c130 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c131 = function () {
160
+ }, peg$c131 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c132 = function () {
161
161
  // reset separator count and its accum
162
162
  options.separators = [];
163
163
  return true;
164
- }, peg$c132 = function (head, t) {
164
+ }, peg$c133 = function (head, t) {
165
165
  options.separators.push(t.text);
166
166
  return t;
167
- }, peg$c133 = function (head, separator, rowtext, t) {
167
+ }, peg$c134 = function (head, separator, rowtext, t) {
168
168
  options.separators.push(t.text);
169
169
  return t;
170
- }, peg$c134 = function (head, separator, rowtext, bseparator) {
170
+ }, peg$c135 = function (head, separator, rowtext, bseparator) {
171
171
  return [
172
172
  {
173
173
  name: 'row',
@@ -176,14 +176,14 @@ function peg$parse(input, options) {
176
176
  },
177
177
  bseparator
178
178
  ];
179
- }, peg$c135 = function (head, separator, singleRow) { return [singleRow]; }, peg$c136 = function (head, separator, rest) {
179
+ }, peg$c136 = function (head, separator, singleRow) { return [singleRow]; }, peg$c137 = function (head, separator, rest) {
180
180
  // if more then 1 separator and it equal - table doesn't have header
181
181
  if (options.separators.length > 1) {
182
182
  // check if separators equal (for table without header)
183
183
  return !options.separators.every(val => val === options.separators[0]);
184
184
  }
185
185
  return true;
186
- }, peg$c137 = function (head, separator, rest) {
186
+ }, peg$c138 = function (head, separator, rest) {
187
187
  return [
188
188
  {
189
189
  name: 'head',
@@ -193,7 +193,7 @@ function peg$parse(input, options) {
193
193
  separator,
194
194
  ...flattenDeep(rest)
195
195
  ];
196
- }, peg$c138 = function (rowtest, bseparator) {
196
+ }, peg$c139 = function (rowtest, bseparator) {
197
197
  return [
198
198
  {
199
199
  name: 'row',
@@ -202,37 +202,37 @@ function peg$parse(input, options) {
202
202
  },
203
203
  bseparator
204
204
  ];
205
- }, peg$c139 = function (rest) {
205
+ }, peg$c140 = function (rest) {
206
206
  return [...flattenDeep(rest)];
207
- }, peg$c140 = function (vmargin, name, config) { return name === 'table'; }, peg$c141 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c142 = function (vmargin, name, config, nodes) { return nodes; }, peg$c143 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c144 = function (vmargin, name, config, content, vmargin2, ename) {
207
+ }, peg$c141 = function (vmargin, name, config) { return name === 'table'; }, peg$c142 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c143 = function (vmargin, name, config, nodes) { return nodes; }, peg$c144 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c145 = function (vmargin, name, config, content, vmargin2, ename) {
208
208
  return {
209
209
  type: 'block',
210
210
  content,
211
211
  name,
212
212
  margin: vmargin
213
213
  };
214
- }, peg$c145 = function (vmargin, name, config, content, vmargin2, res) {
214
+ }, peg$c146 = function (vmargin, name, config, content, vmargin2, res) {
215
215
  return {
216
216
  ...res,
217
217
  text: text(),
218
218
  config,
219
219
  location: location()
220
220
  };
221
- }, peg$c146 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c147 = function (vmargin, name, config, t) { return t; }, peg$c148 = function (vmargin, name, config, content, vmargin2, ename) {
221
+ }, peg$c147 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c148 = function (vmargin, name, config, t) { return t; }, peg$c149 = function (vmargin, name, config, content, vmargin2, ename) {
222
222
  return {
223
223
  type: 'block',
224
224
  content: content,
225
225
  name,
226
226
  margin: vmargin
227
227
  };
228
- }, peg$c149 = function (vmargin, name, config, content, vmargin2, res) {
228
+ }, peg$c150 = function (vmargin, name, config, content, vmargin2, res) {
229
229
  return {
230
230
  ...res,
231
231
  text: text(),
232
232
  config,
233
233
  location: location()
234
234
  };
235
- }, peg$c150 = function (vmargin, name, config, nodes) { return nodes; }, peg$c151 = function (vmargin, name, config, tvmargin, text) {
235
+ }, peg$c151 = function (vmargin, name, config, nodes) { return nodes; }, peg$c152 = function (vmargin, name, config, tvmargin, text) {
236
236
  const type = name.match(/pod|nested|item|code|defn/)
237
237
  &&
238
238
  (tvmargin.length - vmargin.length) > 0 ? 'code' : 'para';
@@ -248,20 +248,20 @@ function peg$parse(input, options) {
248
248
  ],
249
249
  location: location(),
250
250
  };
251
- }, peg$c152 = function (vmargin, name, config, content, vmargin2, ename) {
251
+ }, peg$c153 = function (vmargin, name, config, content, vmargin2, ename) {
252
252
  return {
253
253
  type: 'block',
254
254
  content,
255
255
  name,
256
256
  margin: vmargin,
257
257
  };
258
- }, peg$c153 = function (vmargin, name, config, content, vmargin2, res) {
258
+ }, peg$c154 = function (vmargin, name, config, content, vmargin2, res) {
259
259
  return {
260
260
  ...res,
261
261
  config,
262
262
  location: location(),
263
263
  };
264
- }, peg$c154 = function () {
264
+ }, peg$c155 = function () {
265
265
  return {
266
266
  text: text(),
267
267
  type: 'para',
@@ -274,11 +274,11 @@ function peg$parse(input, options) {
274
274
  ],
275
275
  location: location(),
276
276
  };
277
- }, peg$c155 = function () { return { empty: 1 }; }, peg$c156 = /^[s]/, peg$c157 = peg$classExpectation(["s"], false, false), peg$c158 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c159 = function (vmargin, name) {
277
+ }, peg$c156 = function () { return { empty: 1 }; }, peg$c157 = /^[s]/, peg$c158 = peg$classExpectation(["s"], false, false), peg$c159 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c160 = function (vmargin, name) {
278
278
  return ((name.match(/code|comment|formula|output|input|markdown|picture|toc|data/))
279
279
  ||
280
280
  isNamedBlock(name));
281
- }, peg$c160 = function (vmargin, name, content) {
281
+ }, peg$c161 = function (vmargin, name, content) {
282
282
  return {
283
283
  margin: vmargin,
284
284
  type: 'block',
@@ -287,7 +287,7 @@ function peg$parse(input, options) {
287
287
  config: [],
288
288
  location: location()
289
289
  };
290
- }, peg$c161 = function (vmargin, name) { return name === 'table'; }, peg$c162 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c163 = function (vmargin, name, content) {
290
+ }, peg$c162 = function (vmargin, name) { return name === 'table'; }, peg$c163 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c164 = function (vmargin, name, content) {
291
291
  return {
292
292
  margin: vmargin,
293
293
  type: 'block',
@@ -297,7 +297,7 @@ function peg$parse(input, options) {
297
297
  config: [],
298
298
  location: location()
299
299
  };
300
- }, peg$c164 = function (vmargin, name, first_line, content_rest) {
300
+ }, peg$c165 = function (vmargin, name, first_line, content_rest) {
301
301
  const content = (first_line === "\n" ? "" : first_line) + content_rest;
302
302
  return {
303
303
  margin: vmargin,
@@ -320,25 +320,34 @@ function peg$parse(input, options) {
320
320
  name,
321
321
  location: location()
322
322
  };
323
- }, peg$c165 = "= ", peg$c166 = peg$literalExpectation("= ", false), peg$c167 = function (vmargin, marker, name, replacement) {
323
+ }, peg$c166 = "= ", peg$c167 = peg$literalExpectation("= ", false), peg$c168 = function (vmargin, marker, name, replacement) {
324
324
  return {
325
325
  name,
326
326
  type: 'alias',
327
327
  replacement,
328
328
  margin: vmargin
329
329
  };
330
- }, peg$c168 = /^[A-Z]/, peg$c169 = peg$classExpectation([["A", "Z"]], false, false), peg$c170 = "<>", peg$c171 = peg$literalExpectation("<>", false), peg$c172 = function (vmargin, marker, name, config) {
330
+ }, peg$c169 = /^[A-Z]/, peg$c170 = peg$classExpectation([["A", "Z"]], false, false), peg$c171 = "<>", peg$c172 = peg$literalExpectation("<>", false), peg$c173 = function (vmargin, marker, name, config) {
331
331
  return {
332
332
  name,
333
333
  type: 'config',
334
334
  config,
335
335
  margin: vmargin
336
336
  };
337
- }, peg$c173 = function (vmargin, marker, name, config) {
337
+ }, peg$c174 = "=boundary", peg$c175 = peg$literalExpectation("=boundary", false), peg$c176 = function (vmargin, marker, config) {
338
+ return {
339
+ name: 'boundary',
340
+ type: 'block',
341
+ content: [],
342
+ config,
343
+ margin: vmargin,
344
+ location: location()
345
+ };
346
+ }, peg$c177 = function (vmargin, marker, name, config) {
338
347
  return ((name.match(/code|comment|formula|output|input|markdown|picture|toc|data/))
339
348
  ||
340
349
  isNamedBlock(name));
341
- }, peg$c174 = function (vmargin, marker, name, config, content) {
350
+ }, peg$c178 = function (vmargin, marker, name, config, content) {
342
351
  return {
343
352
  type: 'block',
344
353
  content: content === "" ? [] : [{ type: 'verbatim', value: content }],
@@ -347,7 +356,7 @@ function peg$parse(input, options) {
347
356
  config,
348
357
  location: location()
349
358
  };
350
- }, peg$c175 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c176 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c177 = function (vmargin, marker, name, config, content) {
359
+ }, peg$c179 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c180 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c181 = function (vmargin, marker, name, config, content) {
351
360
  return {
352
361
  type: 'block',
353
362
  content: content === "" ? [] : content,
@@ -356,7 +365,7 @@ function peg$parse(input, options) {
356
365
  config,
357
366
  location: location()
358
367
  };
359
- }, peg$c178 = function (vmargin, marker, name, config, content) {
368
+ }, peg$c182 = function (vmargin, marker, name, config, content) {
360
369
  return {
361
370
  type: 'block',
362
371
  content: content === "" ? []
@@ -379,7 +388,7 @@ function peg$parse(input, options) {
379
388
  config,
380
389
  location: location()
381
390
  };
382
- }, peg$c179 = /^[a-zA-Z]/, peg$c180 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c181 = peg$otherExpectation("whitespace"), peg$c182 = /^[\r\n \t\f]/, peg$c183 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c184 = 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;
391
+ }, peg$c183 = /^[a-zA-Z]/, peg$c184 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c185 = peg$otherExpectation("whitespace"), peg$c186 = /^[\r\n \t\f]/, peg$c187 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c188 = 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;
383
392
  if ("startRule" in options) {
384
393
  if (!(options.startRule in peg$startRuleFunctions)) {
385
394
  throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -491,6 +500,40 @@ function peg$parse(input, options) {
491
500
  s0 = s1;
492
501
  return s0;
493
502
  }
503
+ function peg$parseattributesOnly() {
504
+ var s0, s1, s2, s3;
505
+ s0 = peg$currPos;
506
+ s1 = peg$parse_();
507
+ if (s1 !== peg$FAILED) {
508
+ s2 = [];
509
+ s3 = peg$parseattributes();
510
+ while (s3 !== peg$FAILED) {
511
+ s2.push(s3);
512
+ s3 = peg$parseattributes();
513
+ }
514
+ if (s2 !== peg$FAILED) {
515
+ s3 = peg$parse_();
516
+ if (s3 !== peg$FAILED) {
517
+ peg$savedPos = s0;
518
+ s1 = peg$c1(s2);
519
+ s0 = s1;
520
+ }
521
+ else {
522
+ peg$currPos = s0;
523
+ s0 = peg$FAILED;
524
+ }
525
+ }
526
+ else {
527
+ peg$currPos = s0;
528
+ s0 = peg$FAILED;
529
+ }
530
+ }
531
+ else {
532
+ peg$currPos = s0;
533
+ s0 = peg$FAILED;
534
+ }
535
+ return s0;
536
+ }
494
537
  function peg$parseElement() {
495
538
  var s0, s1, s2, s3, s4, s5, s6, s7;
496
539
  s0 = peg$parsedelimitedBlockRaw();
@@ -511,176 +554,179 @@ function peg$parse(input, options) {
511
554
  if (s0 === peg$FAILED) {
512
555
  s0 = peg$parseconfigDirective();
513
556
  if (s0 === peg$FAILED) {
514
- s0 = peg$parseabbreviatedBlockRaw();
557
+ s0 = peg$parseboundaryDirective();
515
558
  if (s0 === peg$FAILED) {
516
- s0 = peg$parseabbreviatedBlockTable();
559
+ s0 = peg$parseabbreviatedBlockRaw();
517
560
  if (s0 === peg$FAILED) {
518
- s0 = peg$parseabbreviatedBlock();
561
+ s0 = peg$parseabbreviatedBlockTable();
519
562
  if (s0 === peg$FAILED) {
520
- s0 = peg$currPos;
521
- peg$savedPos = peg$currPos;
522
- s1 = peg$c1();
523
- if (s1) {
524
- s1 = void 0;
525
- }
526
- else {
527
- s1 = peg$FAILED;
528
- }
529
- if (s1 !== peg$FAILED) {
530
- s2 = peg$parsetextBlock();
531
- if (s2 === peg$FAILED) {
532
- s2 = peg$parseblankline();
563
+ s0 = peg$parseabbreviatedBlock();
564
+ if (s0 === peg$FAILED) {
565
+ s0 = peg$currPos;
566
+ peg$savedPos = peg$currPos;
567
+ s1 = peg$c2();
568
+ if (s1) {
569
+ s1 = void 0;
570
+ }
571
+ else {
572
+ s1 = peg$FAILED;
573
+ }
574
+ if (s1 !== peg$FAILED) {
575
+ s2 = peg$parsetextBlock();
533
576
  if (s2 === peg$FAILED) {
534
- s2 = peg$parseerror_para();
577
+ s2 = peg$parseblankline();
578
+ if (s2 === peg$FAILED) {
579
+ s2 = peg$parseerror_para();
580
+ }
581
+ }
582
+ if (s2 !== peg$FAILED) {
583
+ peg$savedPos = s0;
584
+ s1 = peg$c3(s2);
585
+ s0 = s1;
586
+ }
587
+ else {
588
+ peg$currPos = s0;
589
+ s0 = peg$FAILED;
535
590
  }
536
- }
537
- if (s2 !== peg$FAILED) {
538
- peg$savedPos = s0;
539
- s1 = peg$c2(s2);
540
- s0 = s1;
541
591
  }
542
592
  else {
543
593
  peg$currPos = s0;
544
594
  s0 = peg$FAILED;
545
595
  }
546
- }
547
- else {
548
- peg$currPos = s0;
549
- s0 = peg$FAILED;
550
- }
551
- if (s0 === peg$FAILED) {
552
- s0 = peg$currPos;
553
- s1 = peg$currPos;
554
- s2 = [];
555
- s3 = peg$currPos;
556
- s4 = peg$currPos;
557
- peg$silentFails++;
558
- s5 = peg$currPos;
559
- s6 = peg$parsemarkers();
560
- if (s6 !== peg$FAILED) {
561
- s7 = peg$parsestrictIdentifier();
562
- if (s7 !== peg$FAILED) {
563
- s6 = [s6, s7];
564
- s5 = s6;
596
+ if (s0 === peg$FAILED) {
597
+ s0 = peg$currPos;
598
+ s1 = peg$currPos;
599
+ s2 = [];
600
+ s3 = peg$currPos;
601
+ s4 = peg$currPos;
602
+ peg$silentFails++;
603
+ s5 = peg$currPos;
604
+ s6 = peg$parsemarkers();
605
+ if (s6 !== peg$FAILED) {
606
+ s7 = peg$parsestrictIdentifier();
607
+ if (s7 !== peg$FAILED) {
608
+ s6 = [s6, s7];
609
+ s5 = s6;
610
+ }
611
+ else {
612
+ peg$currPos = s5;
613
+ s5 = peg$FAILED;
614
+ }
565
615
  }
566
616
  else {
567
617
  peg$currPos = s5;
568
618
  s5 = peg$FAILED;
569
619
  }
570
- }
571
- else {
572
- peg$currPos = s5;
573
- s5 = peg$FAILED;
574
- }
575
- if (s5 === peg$FAILED) {
576
- s5 = peg$parsemarkerAbbreviatedBlock();
577
- }
578
- peg$silentFails--;
579
- if (s5 === peg$FAILED) {
580
- s4 = void 0;
581
- }
582
- else {
583
- peg$currPos = s4;
584
- s4 = peg$FAILED;
585
- }
586
- if (s4 !== peg$FAILED) {
587
- if (input.length > peg$currPos) {
588
- s5 = input.charAt(peg$currPos);
589
- peg$currPos++;
620
+ if (s5 === peg$FAILED) {
621
+ s5 = peg$parsemarkerAbbreviatedBlock();
622
+ }
623
+ peg$silentFails--;
624
+ if (s5 === peg$FAILED) {
625
+ s4 = void 0;
590
626
  }
591
627
  else {
592
- s5 = peg$FAILED;
593
- if (peg$silentFails === 0) {
594
- peg$fail(peg$c3);
595
- }
628
+ peg$currPos = s4;
629
+ s4 = peg$FAILED;
596
630
  }
597
- if (s5 !== peg$FAILED) {
598
- s4 = [s4, s5];
599
- s3 = s4;
631
+ if (s4 !== peg$FAILED) {
632
+ if (input.length > peg$currPos) {
633
+ s5 = input.charAt(peg$currPos);
634
+ peg$currPos++;
635
+ }
636
+ else {
637
+ s5 = peg$FAILED;
638
+ if (peg$silentFails === 0) {
639
+ peg$fail(peg$c4);
640
+ }
641
+ }
642
+ if (s5 !== peg$FAILED) {
643
+ s4 = [s4, s5];
644
+ s3 = s4;
645
+ }
646
+ else {
647
+ peg$currPos = s3;
648
+ s3 = peg$FAILED;
649
+ }
600
650
  }
601
651
  else {
602
652
  peg$currPos = s3;
603
653
  s3 = peg$FAILED;
604
654
  }
605
- }
606
- else {
607
- peg$currPos = s3;
608
- s3 = peg$FAILED;
609
- }
610
- if (s3 !== peg$FAILED) {
611
- while (s3 !== peg$FAILED) {
612
- s2.push(s3);
613
- s3 = peg$currPos;
614
- s4 = peg$currPos;
615
- peg$silentFails++;
616
- s5 = peg$currPos;
617
- s6 = peg$parsemarkers();
618
- if (s6 !== peg$FAILED) {
619
- s7 = peg$parsestrictIdentifier();
620
- if (s7 !== peg$FAILED) {
621
- s6 = [s6, s7];
622
- s5 = s6;
655
+ if (s3 !== peg$FAILED) {
656
+ while (s3 !== peg$FAILED) {
657
+ s2.push(s3);
658
+ s3 = peg$currPos;
659
+ s4 = peg$currPos;
660
+ peg$silentFails++;
661
+ s5 = peg$currPos;
662
+ s6 = peg$parsemarkers();
663
+ if (s6 !== peg$FAILED) {
664
+ s7 = peg$parsestrictIdentifier();
665
+ if (s7 !== peg$FAILED) {
666
+ s6 = [s6, s7];
667
+ s5 = s6;
668
+ }
669
+ else {
670
+ peg$currPos = s5;
671
+ s5 = peg$FAILED;
672
+ }
623
673
  }
624
674
  else {
625
675
  peg$currPos = s5;
626
676
  s5 = peg$FAILED;
627
677
  }
628
- }
629
- else {
630
- peg$currPos = s5;
631
- s5 = peg$FAILED;
632
- }
633
- if (s5 === peg$FAILED) {
634
- s5 = peg$parsemarkerAbbreviatedBlock();
635
- }
636
- peg$silentFails--;
637
- if (s5 === peg$FAILED) {
638
- s4 = void 0;
639
- }
640
- else {
641
- peg$currPos = s4;
642
- s4 = peg$FAILED;
643
- }
644
- if (s4 !== peg$FAILED) {
645
- if (input.length > peg$currPos) {
646
- s5 = input.charAt(peg$currPos);
647
- peg$currPos++;
678
+ if (s5 === peg$FAILED) {
679
+ s5 = peg$parsemarkerAbbreviatedBlock();
680
+ }
681
+ peg$silentFails--;
682
+ if (s5 === peg$FAILED) {
683
+ s4 = void 0;
648
684
  }
649
685
  else {
650
- s5 = peg$FAILED;
651
- if (peg$silentFails === 0) {
652
- peg$fail(peg$c3);
653
- }
686
+ peg$currPos = s4;
687
+ s4 = peg$FAILED;
654
688
  }
655
- if (s5 !== peg$FAILED) {
656
- s4 = [s4, s5];
657
- s3 = s4;
689
+ if (s4 !== peg$FAILED) {
690
+ if (input.length > peg$currPos) {
691
+ s5 = input.charAt(peg$currPos);
692
+ peg$currPos++;
693
+ }
694
+ else {
695
+ s5 = peg$FAILED;
696
+ if (peg$silentFails === 0) {
697
+ peg$fail(peg$c4);
698
+ }
699
+ }
700
+ if (s5 !== peg$FAILED) {
701
+ s4 = [s4, s5];
702
+ s3 = s4;
703
+ }
704
+ else {
705
+ peg$currPos = s3;
706
+ s3 = peg$FAILED;
707
+ }
658
708
  }
659
709
  else {
660
710
  peg$currPos = s3;
661
711
  s3 = peg$FAILED;
662
712
  }
663
713
  }
664
- else {
665
- peg$currPos = s3;
666
- s3 = peg$FAILED;
667
- }
668
714
  }
715
+ else {
716
+ s2 = peg$FAILED;
717
+ }
718
+ if (s2 !== peg$FAILED) {
719
+ s1 = input.substring(s1, peg$currPos);
720
+ }
721
+ else {
722
+ s1 = s2;
723
+ }
724
+ if (s1 !== peg$FAILED) {
725
+ peg$savedPos = s0;
726
+ s1 = peg$c5();
727
+ }
728
+ s0 = s1;
669
729
  }
670
- else {
671
- s2 = peg$FAILED;
672
- }
673
- if (s2 !== peg$FAILED) {
674
- s1 = input.substring(s1, peg$currPos);
675
- }
676
- else {
677
- s1 = s2;
678
- }
679
- if (s1 !== peg$FAILED) {
680
- peg$savedPos = s0;
681
- s1 = peg$c4();
682
- }
683
- s0 = s1;
684
730
  }
685
731
  }
686
732
  }
@@ -698,14 +744,14 @@ function peg$parse(input, options) {
698
744
  }
699
745
  function peg$parsehs() {
700
746
  var s0;
701
- if (peg$c5.test(input.charAt(peg$currPos))) {
747
+ if (peg$c6.test(input.charAt(peg$currPos))) {
702
748
  s0 = input.charAt(peg$currPos);
703
749
  peg$currPos++;
704
750
  }
705
751
  else {
706
752
  s0 = peg$FAILED;
707
753
  if (peg$silentFails === 0) {
708
- peg$fail(peg$c6);
754
+ peg$fail(peg$c7);
709
755
  }
710
756
  }
711
757
  return s0;
@@ -713,26 +759,26 @@ function peg$parse(input, options) {
713
759
  function peg$parse_() {
714
760
  var s0, s1;
715
761
  s0 = [];
716
- if (peg$c7.test(input.charAt(peg$currPos))) {
762
+ if (peg$c8.test(input.charAt(peg$currPos))) {
717
763
  s1 = input.charAt(peg$currPos);
718
764
  peg$currPos++;
719
765
  }
720
766
  else {
721
767
  s1 = peg$FAILED;
722
768
  if (peg$silentFails === 0) {
723
- peg$fail(peg$c8);
769
+ peg$fail(peg$c9);
724
770
  }
725
771
  }
726
772
  while (s1 !== peg$FAILED) {
727
773
  s0.push(s1);
728
- if (peg$c7.test(input.charAt(peg$currPos))) {
774
+ if (peg$c8.test(input.charAt(peg$currPos))) {
729
775
  s1 = input.charAt(peg$currPos);
730
776
  peg$currPos++;
731
777
  }
732
778
  else {
733
779
  s1 = peg$FAILED;
734
780
  if (peg$silentFails === 0) {
735
- peg$fail(peg$c8);
781
+ peg$fail(peg$c9);
736
782
  }
737
783
  }
738
784
  }
@@ -749,14 +795,14 @@ function peg$parse(input, options) {
749
795
  s3 = peg$parsehs();
750
796
  }
751
797
  if (s2 !== peg$FAILED) {
752
- if (peg$c9.test(input.charAt(peg$currPos))) {
798
+ if (peg$c10.test(input.charAt(peg$currPos))) {
753
799
  s3 = input.charAt(peg$currPos);
754
800
  peg$currPos++;
755
801
  }
756
802
  else {
757
803
  s3 = peg$FAILED;
758
804
  if (peg$silentFails === 0) {
759
- peg$fail(peg$c10);
805
+ peg$fail(peg$c11);
760
806
  }
761
807
  }
762
808
  if (s3 !== peg$FAILED) {
@@ -805,7 +851,7 @@ function peg$parse(input, options) {
805
851
  s2 = peg$parseEOL();
806
852
  if (s2 !== peg$FAILED) {
807
853
  peg$savedPos = s0;
808
- s1 = peg$c11(s1);
854
+ s1 = peg$c12(s1);
809
855
  s0 = s1;
810
856
  }
811
857
  else {
@@ -821,14 +867,14 @@ function peg$parse(input, options) {
821
867
  }
822
868
  function peg$parsechar() {
823
869
  var s0;
824
- if (peg$c12.test(input.charAt(peg$currPos))) {
870
+ if (peg$c13.test(input.charAt(peg$currPos))) {
825
871
  s0 = input.charAt(peg$currPos);
826
872
  peg$currPos++;
827
873
  }
828
874
  else {
829
875
  s0 = peg$FAILED;
830
876
  if (peg$silentFails === 0) {
831
- peg$fail(peg$c13);
877
+ peg$fail(peg$c14);
832
878
  }
833
879
  }
834
880
  return s0;
@@ -836,36 +882,36 @@ function peg$parse(input, options) {
836
882
  function peg$parsenewline() {
837
883
  var s0, s1, s2;
838
884
  if (input.charCodeAt(peg$currPos) === 10) {
839
- s0 = peg$c14;
885
+ s0 = peg$c15;
840
886
  peg$currPos++;
841
887
  }
842
888
  else {
843
889
  s0 = peg$FAILED;
844
890
  if (peg$silentFails === 0) {
845
- peg$fail(peg$c15);
891
+ peg$fail(peg$c16);
846
892
  }
847
893
  }
848
894
  if (s0 === peg$FAILED) {
849
895
  s0 = peg$currPos;
850
896
  if (input.charCodeAt(peg$currPos) === 13) {
851
- s1 = peg$c16;
897
+ s1 = peg$c17;
852
898
  peg$currPos++;
853
899
  }
854
900
  else {
855
901
  s1 = peg$FAILED;
856
902
  if (peg$silentFails === 0) {
857
- peg$fail(peg$c17);
903
+ peg$fail(peg$c18);
858
904
  }
859
905
  }
860
906
  if (s1 !== peg$FAILED) {
861
907
  if (input.charCodeAt(peg$currPos) === 10) {
862
- s2 = peg$c14;
908
+ s2 = peg$c15;
863
909
  peg$currPos++;
864
910
  }
865
911
  else {
866
912
  s2 = peg$FAILED;
867
913
  if (peg$silentFails === 0) {
868
- peg$fail(peg$c15);
914
+ peg$fail(peg$c16);
869
915
  }
870
916
  }
871
917
  if (s2 === peg$FAILED) {
@@ -900,7 +946,7 @@ function peg$parse(input, options) {
900
946
  else {
901
947
  s1 = peg$FAILED;
902
948
  if (peg$silentFails === 0) {
903
- peg$fail(peg$c3);
949
+ peg$fail(peg$c4);
904
950
  }
905
951
  }
906
952
  peg$silentFails--;
@@ -925,14 +971,14 @@ function peg$parse(input, options) {
925
971
  s3 = peg$parsehs();
926
972
  }
927
973
  if (s2 !== peg$FAILED) {
928
- if (peg$c9.test(input.charAt(peg$currPos))) {
974
+ if (peg$c10.test(input.charAt(peg$currPos))) {
929
975
  s3 = input.charAt(peg$currPos);
930
976
  peg$currPos++;
931
977
  }
932
978
  else {
933
979
  s3 = peg$FAILED;
934
980
  if (peg$silentFails === 0) {
935
- peg$fail(peg$c10);
981
+ peg$fail(peg$c11);
936
982
  }
937
983
  }
938
984
  if (s3 !== peg$FAILED) {
@@ -968,14 +1014,14 @@ function peg$parse(input, options) {
968
1014
  s4 = peg$parsehs();
969
1015
  }
970
1016
  if (s3 !== peg$FAILED) {
971
- if (peg$c9.test(input.charAt(peg$currPos))) {
1017
+ if (peg$c10.test(input.charAt(peg$currPos))) {
972
1018
  s4 = input.charAt(peg$currPos);
973
1019
  peg$currPos++;
974
1020
  }
975
1021
  else {
976
1022
  s4 = peg$FAILED;
977
1023
  if (peg$silentFails === 0) {
978
- peg$fail(peg$c10);
1024
+ peg$fail(peg$c11);
979
1025
  }
980
1026
  }
981
1027
  if (s4 !== peg$FAILED) {
@@ -999,77 +1045,77 @@ function peg$parse(input, options) {
999
1045
  }
1000
1046
  if (s1 !== peg$FAILED) {
1001
1047
  peg$savedPos = s0;
1002
- s1 = peg$c18();
1048
+ s1 = peg$c19();
1003
1049
  }
1004
1050
  s0 = s1;
1005
1051
  return s0;
1006
1052
  }
1007
1053
  function peg$parsemarkerBegin() {
1008
1054
  var s0;
1009
- if (input.substr(peg$currPos, 7) === peg$c19) {
1010
- s0 = peg$c19;
1055
+ if (input.substr(peg$currPos, 7) === peg$c20) {
1056
+ s0 = peg$c20;
1011
1057
  peg$currPos += 7;
1012
1058
  }
1013
1059
  else {
1014
1060
  s0 = peg$FAILED;
1015
1061
  if (peg$silentFails === 0) {
1016
- peg$fail(peg$c20);
1062
+ peg$fail(peg$c21);
1017
1063
  }
1018
1064
  }
1019
1065
  return s0;
1020
1066
  }
1021
1067
  function peg$parsemarkerEnd() {
1022
1068
  var s0;
1023
- if (input.substr(peg$currPos, 5) === peg$c21) {
1024
- s0 = peg$c21;
1069
+ if (input.substr(peg$currPos, 5) === peg$c22) {
1070
+ s0 = peg$c22;
1025
1071
  peg$currPos += 5;
1026
1072
  }
1027
1073
  else {
1028
1074
  s0 = peg$FAILED;
1029
1075
  if (peg$silentFails === 0) {
1030
- peg$fail(peg$c22);
1076
+ peg$fail(peg$c23);
1031
1077
  }
1032
1078
  }
1033
1079
  return s0;
1034
1080
  }
1035
1081
  function peg$parsemarkerFor() {
1036
1082
  var s0;
1037
- if (input.substr(peg$currPos, 5) === peg$c23) {
1038
- s0 = peg$c23;
1083
+ if (input.substr(peg$currPos, 5) === peg$c24) {
1084
+ s0 = peg$c24;
1039
1085
  peg$currPos += 5;
1040
1086
  }
1041
1087
  else {
1042
1088
  s0 = peg$FAILED;
1043
1089
  if (peg$silentFails === 0) {
1044
- peg$fail(peg$c24);
1090
+ peg$fail(peg$c25);
1045
1091
  }
1046
1092
  }
1047
1093
  return s0;
1048
1094
  }
1049
1095
  function peg$parsemarkerConfig() {
1050
1096
  var s0;
1051
- if (input.substr(peg$currPos, 7) === peg$c25) {
1052
- s0 = peg$c25;
1097
+ if (input.substr(peg$currPos, 7) === peg$c26) {
1098
+ s0 = peg$c26;
1053
1099
  peg$currPos += 7;
1054
1100
  }
1055
1101
  else {
1056
1102
  s0 = peg$FAILED;
1057
1103
  if (peg$silentFails === 0) {
1058
- peg$fail(peg$c26);
1104
+ peg$fail(peg$c27);
1059
1105
  }
1060
1106
  }
1061
1107
  return s0;
1062
1108
  }
1063
1109
  function peg$parsemarkerAlias() {
1064
1110
  var s0;
1065
- if (input.substr(peg$currPos, 6) === peg$c27) {
1066
- s0 = peg$c27;
1111
+ if (input.substr(peg$currPos, 6) === peg$c28) {
1112
+ s0 = peg$c28;
1067
1113
  peg$currPos += 6;
1068
1114
  }
1069
1115
  else {
1070
1116
  s0 = peg$FAILED;
1071
1117
  if (peg$silentFails === 0) {
1072
- peg$fail(peg$c28);
1118
+ peg$fail(peg$c29);
1073
1119
  }
1074
1120
  }
1075
1121
  return s0;
@@ -1080,7 +1126,7 @@ function peg$parse(input, options) {
1080
1126
  s1 = peg$parseidentifier();
1081
1127
  if (s1 !== peg$FAILED) {
1082
1128
  peg$savedPos = peg$currPos;
1083
- s2 = peg$c29(s1);
1129
+ s2 = peg$c30(s1);
1084
1130
  if (s2) {
1085
1131
  s2 = void 0;
1086
1132
  }
@@ -1089,7 +1135,7 @@ function peg$parse(input, options) {
1089
1135
  }
1090
1136
  if (s2 !== peg$FAILED) {
1091
1137
  peg$savedPos = s0;
1092
- s1 = peg$c30(s1);
1138
+ s1 = peg$c31(s1);
1093
1139
  s0 = s1;
1094
1140
  }
1095
1141
  else {
@@ -1107,20 +1153,20 @@ function peg$parse(input, options) {
1107
1153
  var s0, s1, s2;
1108
1154
  s0 = peg$currPos;
1109
1155
  if (input.charCodeAt(peg$currPos) === 61) {
1110
- s1 = peg$c31;
1156
+ s1 = peg$c32;
1111
1157
  peg$currPos++;
1112
1158
  }
1113
1159
  else {
1114
1160
  s1 = peg$FAILED;
1115
1161
  if (peg$silentFails === 0) {
1116
- peg$fail(peg$c32);
1162
+ peg$fail(peg$c33);
1117
1163
  }
1118
1164
  }
1119
1165
  if (s1 !== peg$FAILED) {
1120
1166
  s2 = peg$parsestrictIdentifier();
1121
1167
  if (s2 !== peg$FAILED) {
1122
1168
  peg$savedPos = s0;
1123
- s1 = peg$c30(s2);
1169
+ s1 = peg$c31(s2);
1124
1170
  s0 = s1;
1125
1171
  }
1126
1172
  else {
@@ -1176,7 +1222,7 @@ function peg$parse(input, options) {
1176
1222
  if (s0 === peg$FAILED) {
1177
1223
  s1 = peg$FAILED;
1178
1224
  if (peg$silentFails === 0) {
1179
- peg$fail(peg$c33);
1225
+ peg$fail(peg$c34);
1180
1226
  }
1181
1227
  }
1182
1228
  return s0;
@@ -1262,7 +1308,7 @@ function peg$parse(input, options) {
1262
1308
  s3 = peg$parseEOL();
1263
1309
  if (s3 !== peg$FAILED) {
1264
1310
  peg$savedPos = s0;
1265
- s1 = peg$c34();
1311
+ s1 = peg$c35();
1266
1312
  s0 = s1;
1267
1313
  }
1268
1314
  else {
@@ -1306,7 +1352,7 @@ function peg$parse(input, options) {
1306
1352
  s2 = peg$parseEOL();
1307
1353
  if (s2 !== peg$FAILED) {
1308
1354
  peg$savedPos = s0;
1309
- s1 = peg$c34();
1355
+ s1 = peg$c35();
1310
1356
  s0 = s1;
1311
1357
  }
1312
1358
  else {
@@ -1345,7 +1391,7 @@ function peg$parse(input, options) {
1345
1391
  else {
1346
1392
  s5 = peg$FAILED;
1347
1393
  if (peg$silentFails === 0) {
1348
- peg$fail(peg$c3);
1394
+ peg$fail(peg$c4);
1349
1395
  }
1350
1396
  }
1351
1397
  if (s5 !== peg$FAILED) {
@@ -1384,7 +1430,7 @@ function peg$parse(input, options) {
1384
1430
  else {
1385
1431
  s5 = peg$FAILED;
1386
1432
  if (peg$silentFails === 0) {
1387
- peg$fail(peg$c3);
1433
+ peg$fail(peg$c4);
1388
1434
  }
1389
1435
  }
1390
1436
  if (s5 !== peg$FAILED) {
@@ -1415,7 +1461,7 @@ function peg$parse(input, options) {
1415
1461
  s2 = peg$parseEOL();
1416
1462
  if (s2 !== peg$FAILED) {
1417
1463
  peg$savedPos = s0;
1418
- s1 = peg$c35();
1464
+ s1 = peg$c36();
1419
1465
  s0 = s1;
1420
1466
  }
1421
1467
  else {
@@ -1449,7 +1495,7 @@ function peg$parse(input, options) {
1449
1495
  s3 = peg$parsearray_codes();
1450
1496
  if (s3 !== peg$FAILED) {
1451
1497
  peg$savedPos = s0;
1452
- s1 = peg$c36(s1, s3);
1498
+ s1 = peg$c37(s1, s3);
1453
1499
  s0 = s1;
1454
1500
  }
1455
1501
  else {
@@ -1471,7 +1517,7 @@ function peg$parse(input, options) {
1471
1517
  s1 = peg$parseFCode();
1472
1518
  if (s1 !== peg$FAILED) {
1473
1519
  peg$savedPos = s0;
1474
- s1 = peg$c37(s1);
1520
+ s1 = peg$c38(s1);
1475
1521
  }
1476
1522
  s0 = s1;
1477
1523
  }
@@ -1510,13 +1556,13 @@ function peg$parse(input, options) {
1510
1556
  s3 = peg$parse_();
1511
1557
  if (s3 !== peg$FAILED) {
1512
1558
  if (input.charCodeAt(peg$currPos) === 44) {
1513
- s4 = peg$c38;
1559
+ s4 = peg$c39;
1514
1560
  peg$currPos++;
1515
1561
  }
1516
1562
  else {
1517
1563
  s4 = peg$FAILED;
1518
1564
  if (peg$silentFails === 0) {
1519
- peg$fail(peg$c39);
1565
+ peg$fail(peg$c40);
1520
1566
  }
1521
1567
  }
1522
1568
  if (s4 !== peg$FAILED) {
@@ -1544,7 +1590,7 @@ function peg$parse(input, options) {
1544
1590
  s3 = peg$parsearray_items();
1545
1591
  if (s3 !== peg$FAILED) {
1546
1592
  peg$savedPos = s0;
1547
- s1 = peg$c40(s1, s3);
1593
+ s1 = peg$c41(s1, s3);
1548
1594
  s0 = s1;
1549
1595
  }
1550
1596
  else {
@@ -1566,7 +1612,7 @@ function peg$parse(input, options) {
1566
1612
  s1 = peg$parseitem();
1567
1613
  if (s1 !== peg$FAILED) {
1568
1614
  peg$savedPos = s0;
1569
- s1 = peg$c37(s1);
1615
+ s1 = peg$c38(s1);
1570
1616
  }
1571
1617
  s0 = s1;
1572
1618
  }
@@ -1577,27 +1623,27 @@ function peg$parse(input, options) {
1577
1623
  s0 = peg$currPos;
1578
1624
  s1 = peg$currPos;
1579
1625
  s2 = [];
1580
- if (peg$c41.test(input.charAt(peg$currPos))) {
1626
+ if (peg$c42.test(input.charAt(peg$currPos))) {
1581
1627
  s3 = input.charAt(peg$currPos);
1582
1628
  peg$currPos++;
1583
1629
  }
1584
1630
  else {
1585
1631
  s3 = peg$FAILED;
1586
1632
  if (peg$silentFails === 0) {
1587
- peg$fail(peg$c42);
1633
+ peg$fail(peg$c43);
1588
1634
  }
1589
1635
  }
1590
1636
  if (s3 !== peg$FAILED) {
1591
1637
  while (s3 !== peg$FAILED) {
1592
1638
  s2.push(s3);
1593
- if (peg$c41.test(input.charAt(peg$currPos))) {
1639
+ if (peg$c42.test(input.charAt(peg$currPos))) {
1594
1640
  s3 = input.charAt(peg$currPos);
1595
1641
  peg$currPos++;
1596
1642
  }
1597
1643
  else {
1598
1644
  s3 = peg$FAILED;
1599
1645
  if (peg$silentFails === 0) {
1600
- peg$fail(peg$c42);
1646
+ peg$fail(peg$c43);
1601
1647
  }
1602
1648
  }
1603
1649
  }
@@ -1607,26 +1653,26 @@ function peg$parse(input, options) {
1607
1653
  }
1608
1654
  if (s2 !== peg$FAILED) {
1609
1655
  s3 = [];
1610
- if (peg$c43.test(input.charAt(peg$currPos))) {
1656
+ if (peg$c44.test(input.charAt(peg$currPos))) {
1611
1657
  s4 = input.charAt(peg$currPos);
1612
1658
  peg$currPos++;
1613
1659
  }
1614
1660
  else {
1615
1661
  s4 = peg$FAILED;
1616
1662
  if (peg$silentFails === 0) {
1617
- peg$fail(peg$c44);
1663
+ peg$fail(peg$c45);
1618
1664
  }
1619
1665
  }
1620
1666
  while (s4 !== peg$FAILED) {
1621
1667
  s3.push(s4);
1622
- if (peg$c43.test(input.charAt(peg$currPos))) {
1668
+ if (peg$c44.test(input.charAt(peg$currPos))) {
1623
1669
  s4 = input.charAt(peg$currPos);
1624
1670
  peg$currPos++;
1625
1671
  }
1626
1672
  else {
1627
1673
  s4 = peg$FAILED;
1628
1674
  if (peg$silentFails === 0) {
1629
- peg$fail(peg$c44);
1675
+ peg$fail(peg$c45);
1630
1676
  }
1631
1677
  }
1632
1678
  }
@@ -1659,24 +1705,24 @@ function peg$parse(input, options) {
1659
1705
  s2 = peg$parse_();
1660
1706
  if (s2 !== peg$FAILED) {
1661
1707
  if (input.charCodeAt(peg$currPos) === 44) {
1662
- s3 = peg$c38;
1708
+ s3 = peg$c39;
1663
1709
  peg$currPos++;
1664
1710
  }
1665
1711
  else {
1666
1712
  s3 = peg$FAILED;
1667
1713
  if (peg$silentFails === 0) {
1668
- peg$fail(peg$c39);
1714
+ peg$fail(peg$c40);
1669
1715
  }
1670
1716
  }
1671
1717
  if (s3 === peg$FAILED) {
1672
- if (input.substr(peg$currPos, 2) === peg$c45) {
1673
- s3 = peg$c45;
1718
+ if (input.substr(peg$currPos, 2) === peg$c46) {
1719
+ s3 = peg$c46;
1674
1720
  peg$currPos += 2;
1675
1721
  }
1676
1722
  else {
1677
1723
  s3 = peg$FAILED;
1678
1724
  if (peg$silentFails === 0) {
1679
- peg$fail(peg$c46);
1725
+ peg$fail(peg$c47);
1680
1726
  }
1681
1727
  }
1682
1728
  }
@@ -1686,7 +1732,7 @@ function peg$parse(input, options) {
1686
1732
  s5 = peg$parseitem();
1687
1733
  if (s5 !== peg$FAILED) {
1688
1734
  peg$savedPos = s0;
1689
- s1 = peg$c47(s1, s5);
1735
+ s1 = peg$c48(s1, s5);
1690
1736
  s0 = s1;
1691
1737
  }
1692
1738
  else {
@@ -1723,13 +1769,13 @@ function peg$parse(input, options) {
1723
1769
  s2 = peg$parse_();
1724
1770
  if (s2 !== peg$FAILED) {
1725
1771
  if (input.charCodeAt(peg$currPos) === 44) {
1726
- s3 = peg$c38;
1772
+ s3 = peg$c39;
1727
1773
  peg$currPos++;
1728
1774
  }
1729
1775
  else {
1730
1776
  s3 = peg$FAILED;
1731
1777
  if (peg$silentFails === 0) {
1732
- peg$fail(peg$c39);
1778
+ peg$fail(peg$c40);
1733
1779
  }
1734
1780
  }
1735
1781
  if (s3 !== peg$FAILED) {
@@ -1738,7 +1784,7 @@ function peg$parse(input, options) {
1738
1784
  s5 = peg$parsearray_pairs();
1739
1785
  if (s5 !== peg$FAILED) {
1740
1786
  peg$savedPos = s0;
1741
- s1 = peg$c48(s1, s5);
1787
+ s1 = peg$c49(s1, s5);
1742
1788
  s0 = s1;
1743
1789
  }
1744
1790
  else {
@@ -1770,7 +1816,7 @@ function peg$parse(input, options) {
1770
1816
  s1 = peg$parsepair_item();
1771
1817
  if (s1 !== peg$FAILED) {
1772
1818
  peg$savedPos = s0;
1773
- s1 = peg$c49(s1);
1819
+ s1 = peg$c50(s1);
1774
1820
  }
1775
1821
  s0 = s1;
1776
1822
  }
@@ -1782,36 +1828,36 @@ function peg$parse(input, options) {
1782
1828
  s1 = peg$parse_();
1783
1829
  if (s1 !== peg$FAILED) {
1784
1830
  if (input.charCodeAt(peg$currPos) === 58) {
1785
- s2 = peg$c50;
1831
+ s2 = peg$c51;
1786
1832
  peg$currPos++;
1787
1833
  }
1788
1834
  else {
1789
1835
  s2 = peg$FAILED;
1790
1836
  if (peg$silentFails === 0) {
1791
- peg$fail(peg$c51);
1837
+ peg$fail(peg$c52);
1792
1838
  }
1793
1839
  }
1794
1840
  if (s2 !== peg$FAILED) {
1795
- if (input.substr(peg$currPos, 5) === peg$c52) {
1796
- s3 = peg$c52;
1841
+ if (input.substr(peg$currPos, 5) === peg$c53) {
1842
+ s3 = peg$c53;
1797
1843
  peg$currPos += 5;
1798
1844
  }
1799
1845
  else {
1800
1846
  s3 = peg$FAILED;
1801
1847
  if (peg$silentFails === 0) {
1802
- peg$fail(peg$c53);
1848
+ peg$fail(peg$c54);
1803
1849
  }
1804
1850
  }
1805
1851
  if (s3 !== peg$FAILED) {
1806
1852
  s4 = peg$currPos;
1807
1853
  if (input.charCodeAt(peg$currPos) === 60) {
1808
- s5 = peg$c54;
1854
+ s5 = peg$c55;
1809
1855
  peg$currPos++;
1810
1856
  }
1811
1857
  else {
1812
1858
  s5 = peg$FAILED;
1813
1859
  if (peg$silentFails === 0) {
1814
- peg$fail(peg$c55);
1860
+ peg$fail(peg$c56);
1815
1861
  }
1816
1862
  }
1817
1863
  if (s5 !== peg$FAILED) {
@@ -1822,18 +1868,18 @@ function peg$parse(input, options) {
1822
1868
  s8 = peg$parse_();
1823
1869
  if (s8 !== peg$FAILED) {
1824
1870
  if (input.charCodeAt(peg$currPos) === 62) {
1825
- s9 = peg$c56;
1871
+ s9 = peg$c57;
1826
1872
  peg$currPos++;
1827
1873
  }
1828
1874
  else {
1829
1875
  s9 = peg$FAILED;
1830
1876
  if (peg$silentFails === 0) {
1831
- peg$fail(peg$c57);
1877
+ peg$fail(peg$c58);
1832
1878
  }
1833
1879
  }
1834
1880
  if (s9 !== peg$FAILED) {
1835
1881
  peg$savedPos = s4;
1836
- s5 = peg$c58(s3, s7);
1882
+ s5 = peg$c59(s3, s7);
1837
1883
  s4 = s5;
1838
1884
  }
1839
1885
  else {
@@ -1864,7 +1910,7 @@ function peg$parse(input, options) {
1864
1910
  s5 = peg$parse_();
1865
1911
  if (s5 !== peg$FAILED) {
1866
1912
  peg$savedPos = s0;
1867
- s1 = peg$c59(s3, s4);
1913
+ s1 = peg$c60(s3, s4);
1868
1914
  s0 = s1;
1869
1915
  }
1870
1916
  else {
@@ -1905,7 +1951,7 @@ function peg$parse(input, options) {
1905
1951
  s5 = peg$parse_();
1906
1952
  if (s5 !== peg$FAILED) {
1907
1953
  peg$savedPos = s2;
1908
- s3 = peg$c60(s4);
1954
+ s3 = peg$c61(s4);
1909
1955
  s2 = s3;
1910
1956
  }
1911
1957
  else {
@@ -1932,7 +1978,7 @@ function peg$parse(input, options) {
1932
1978
  s5 = peg$parse_();
1933
1979
  if (s5 !== peg$FAILED) {
1934
1980
  peg$savedPos = s2;
1935
- s3 = peg$c60(s4);
1981
+ s3 = peg$c61(s4);
1936
1982
  s2 = s3;
1937
1983
  }
1938
1984
  else {
@@ -1952,7 +1998,7 @@ function peg$parse(input, options) {
1952
1998
  }
1953
1999
  if (s1 !== peg$FAILED) {
1954
2000
  peg$savedPos = s0;
1955
- s1 = peg$c61(s1);
2001
+ s1 = peg$c62(s1);
1956
2002
  }
1957
2003
  s0 = s1;
1958
2004
  if (s0 === peg$FAILED) {
@@ -1960,7 +2006,7 @@ function peg$parse(input, options) {
1960
2006
  s1 = peg$parseitem();
1961
2007
  if (s1 !== peg$FAILED) {
1962
2008
  peg$savedPos = s0;
1963
- s1 = peg$c62(s1);
2009
+ s1 = peg$c63(s1);
1964
2010
  }
1965
2011
  s0 = s1;
1966
2012
  if (s0 === peg$FAILED) {
@@ -1968,7 +2014,7 @@ function peg$parse(input, options) {
1968
2014
  s1 = peg$parse_();
1969
2015
  if (s1 !== peg$FAILED) {
1970
2016
  peg$savedPos = s0;
1971
- s1 = peg$c63();
2017
+ s1 = peg$c64();
1972
2018
  }
1973
2019
  s0 = s1;
1974
2020
  }
@@ -1983,24 +2029,24 @@ function peg$parse(input, options) {
1983
2029
  s1 = peg$parse_();
1984
2030
  if (s1 !== peg$FAILED) {
1985
2031
  if (input.charCodeAt(peg$currPos) === 58) {
1986
- s2 = peg$c50;
2032
+ s2 = peg$c51;
1987
2033
  peg$currPos++;
1988
2034
  }
1989
2035
  else {
1990
2036
  s2 = peg$FAILED;
1991
2037
  if (peg$silentFails === 0) {
1992
- peg$fail(peg$c51);
2038
+ peg$fail(peg$c52);
1993
2039
  }
1994
2040
  }
1995
2041
  if (s2 !== peg$FAILED) {
1996
- if (peg$c64.test(input.charAt(peg$currPos))) {
2042
+ if (peg$c65.test(input.charAt(peg$currPos))) {
1997
2043
  s3 = input.charAt(peg$currPos);
1998
2044
  peg$currPos++;
1999
2045
  }
2000
2046
  else {
2001
2047
  s3 = peg$FAILED;
2002
2048
  if (peg$silentFails === 0) {
2003
- peg$fail(peg$c65);
2049
+ peg$fail(peg$c66);
2004
2050
  }
2005
2051
  }
2006
2052
  if (s3 === peg$FAILED) {
@@ -2011,13 +2057,13 @@ function peg$parse(input, options) {
2011
2057
  if (s4 !== peg$FAILED) {
2012
2058
  s5 = peg$currPos;
2013
2059
  if (input.charCodeAt(peg$currPos) === 123) {
2014
- s6 = peg$c66;
2060
+ s6 = peg$c67;
2015
2061
  peg$currPos++;
2016
2062
  }
2017
2063
  else {
2018
2064
  s6 = peg$FAILED;
2019
2065
  if (peg$silentFails === 0) {
2020
- peg$fail(peg$c67);
2066
+ peg$fail(peg$c68);
2021
2067
  }
2022
2068
  }
2023
2069
  if (s6 !== peg$FAILED) {
@@ -2028,18 +2074,18 @@ function peg$parse(input, options) {
2028
2074
  s9 = peg$parse_();
2029
2075
  if (s9 !== peg$FAILED) {
2030
2076
  if (input.charCodeAt(peg$currPos) === 125) {
2031
- s10 = peg$c68;
2077
+ s10 = peg$c69;
2032
2078
  peg$currPos++;
2033
2079
  }
2034
2080
  else {
2035
2081
  s10 = peg$FAILED;
2036
2082
  if (peg$silentFails === 0) {
2037
- peg$fail(peg$c69);
2083
+ peg$fail(peg$c70);
2038
2084
  }
2039
2085
  }
2040
2086
  if (s10 !== peg$FAILED) {
2041
2087
  peg$savedPos = s5;
2042
- s6 = peg$c70(s3, s4, s8);
2088
+ s6 = peg$c71(s3, s4, s8);
2043
2089
  s5 = s6;
2044
2090
  }
2045
2091
  else {
@@ -2069,13 +2115,13 @@ function peg$parse(input, options) {
2069
2115
  if (s5 === peg$FAILED) {
2070
2116
  s5 = peg$currPos;
2071
2117
  if (input.charCodeAt(peg$currPos) === 91) {
2072
- s6 = peg$c71;
2118
+ s6 = peg$c72;
2073
2119
  peg$currPos++;
2074
2120
  }
2075
2121
  else {
2076
2122
  s6 = peg$FAILED;
2077
2123
  if (peg$silentFails === 0) {
2078
- peg$fail(peg$c72);
2124
+ peg$fail(peg$c73);
2079
2125
  }
2080
2126
  }
2081
2127
  if (s6 !== peg$FAILED) {
@@ -2085,7 +2131,7 @@ function peg$parse(input, options) {
2085
2131
  s9 = peg$parsearray_items();
2086
2132
  if (s9 !== peg$FAILED) {
2087
2133
  peg$savedPos = s8;
2088
- s9 = peg$c73(s3, s4, s9);
2134
+ s9 = peg$c74(s3, s4, s9);
2089
2135
  }
2090
2136
  s8 = s9;
2091
2137
  if (s8 === peg$FAILED) {
@@ -2096,24 +2142,24 @@ function peg$parse(input, options) {
2096
2142
  s12 = peg$currPos;
2097
2143
  peg$silentFails++;
2098
2144
  if (input.charCodeAt(peg$currPos) === 93) {
2099
- s13 = peg$c74;
2145
+ s13 = peg$c75;
2100
2146
  peg$currPos++;
2101
2147
  }
2102
2148
  else {
2103
2149
  s13 = peg$FAILED;
2104
2150
  if (peg$silentFails === 0) {
2105
- peg$fail(peg$c75);
2151
+ peg$fail(peg$c76);
2106
2152
  }
2107
2153
  }
2108
2154
  if (s13 === peg$FAILED) {
2109
2155
  if (input.charCodeAt(peg$currPos) === 91) {
2110
- s13 = peg$c71;
2156
+ s13 = peg$c72;
2111
2157
  peg$currPos++;
2112
2158
  }
2113
2159
  else {
2114
2160
  s13 = peg$FAILED;
2115
2161
  if (peg$silentFails === 0) {
2116
- peg$fail(peg$c72);
2162
+ peg$fail(peg$c73);
2117
2163
  }
2118
2164
  }
2119
2165
  }
@@ -2133,7 +2179,7 @@ function peg$parse(input, options) {
2133
2179
  else {
2134
2180
  s13 = peg$FAILED;
2135
2181
  if (peg$silentFails === 0) {
2136
- peg$fail(peg$c3);
2182
+ peg$fail(peg$c4);
2137
2183
  }
2138
2184
  }
2139
2185
  if (s13 !== peg$FAILED) {
@@ -2156,24 +2202,24 @@ function peg$parse(input, options) {
2156
2202
  s12 = peg$currPos;
2157
2203
  peg$silentFails++;
2158
2204
  if (input.charCodeAt(peg$currPos) === 93) {
2159
- s13 = peg$c74;
2205
+ s13 = peg$c75;
2160
2206
  peg$currPos++;
2161
2207
  }
2162
2208
  else {
2163
2209
  s13 = peg$FAILED;
2164
2210
  if (peg$silentFails === 0) {
2165
- peg$fail(peg$c75);
2211
+ peg$fail(peg$c76);
2166
2212
  }
2167
2213
  }
2168
2214
  if (s13 === peg$FAILED) {
2169
2215
  if (input.charCodeAt(peg$currPos) === 91) {
2170
- s13 = peg$c71;
2216
+ s13 = peg$c72;
2171
2217
  peg$currPos++;
2172
2218
  }
2173
2219
  else {
2174
2220
  s13 = peg$FAILED;
2175
2221
  if (peg$silentFails === 0) {
2176
- peg$fail(peg$c72);
2222
+ peg$fail(peg$c73);
2177
2223
  }
2178
2224
  }
2179
2225
  }
@@ -2193,7 +2239,7 @@ function peg$parse(input, options) {
2193
2239
  else {
2194
2240
  s13 = peg$FAILED;
2195
2241
  if (peg$silentFails === 0) {
2196
- peg$fail(peg$c3);
2242
+ peg$fail(peg$c4);
2197
2243
  }
2198
2244
  }
2199
2245
  if (s13 !== peg$FAILED) {
@@ -2222,7 +2268,7 @@ function peg$parse(input, options) {
2222
2268
  }
2223
2269
  if (s9 !== peg$FAILED) {
2224
2270
  peg$savedPos = s8;
2225
- s9 = peg$c76(s3, s4);
2271
+ s9 = peg$c77(s3, s4);
2226
2272
  }
2227
2273
  s8 = s9;
2228
2274
  }
@@ -2230,18 +2276,18 @@ function peg$parse(input, options) {
2230
2276
  s9 = peg$parse_();
2231
2277
  if (s9 !== peg$FAILED) {
2232
2278
  if (input.charCodeAt(peg$currPos) === 93) {
2233
- s10 = peg$c74;
2279
+ s10 = peg$c75;
2234
2280
  peg$currPos++;
2235
2281
  }
2236
2282
  else {
2237
2283
  s10 = peg$FAILED;
2238
2284
  if (peg$silentFails === 0) {
2239
- peg$fail(peg$c75);
2285
+ peg$fail(peg$c76);
2240
2286
  }
2241
2287
  }
2242
2288
  if (s10 !== peg$FAILED) {
2243
2289
  peg$savedPos = s5;
2244
- s6 = peg$c77(s3, s4, s8);
2290
+ s6 = peg$c78(s3, s4, s8);
2245
2291
  s5 = s6;
2246
2292
  }
2247
2293
  else {
@@ -2271,13 +2317,13 @@ function peg$parse(input, options) {
2271
2317
  if (s5 === peg$FAILED) {
2272
2318
  s5 = peg$currPos;
2273
2319
  if (input.charCodeAt(peg$currPos) === 60) {
2274
- s6 = peg$c54;
2320
+ s6 = peg$c55;
2275
2321
  peg$currPos++;
2276
2322
  }
2277
2323
  else {
2278
2324
  s6 = peg$FAILED;
2279
2325
  if (peg$silentFails === 0) {
2280
- peg$fail(peg$c55);
2326
+ peg$fail(peg$c56);
2281
2327
  }
2282
2328
  }
2283
2329
  if (s6 !== peg$FAILED) {
@@ -2288,18 +2334,18 @@ function peg$parse(input, options) {
2288
2334
  s9 = peg$parse_();
2289
2335
  if (s9 !== peg$FAILED) {
2290
2336
  if (input.charCodeAt(peg$currPos) === 62) {
2291
- s10 = peg$c56;
2337
+ s10 = peg$c57;
2292
2338
  peg$currPos++;
2293
2339
  }
2294
2340
  else {
2295
2341
  s10 = peg$FAILED;
2296
2342
  if (peg$silentFails === 0) {
2297
- peg$fail(peg$c57);
2343
+ peg$fail(peg$c58);
2298
2344
  }
2299
2345
  }
2300
2346
  if (s10 !== peg$FAILED) {
2301
2347
  peg$savedPos = s5;
2302
- s6 = peg$c78(s3, s4, s8);
2348
+ s6 = peg$c79(s3, s4, s8);
2303
2349
  s5 = s6;
2304
2350
  }
2305
2351
  else {
@@ -2329,13 +2375,13 @@ function peg$parse(input, options) {
2329
2375
  if (s5 === peg$FAILED) {
2330
2376
  s5 = peg$currPos;
2331
2377
  if (input.charCodeAt(peg$currPos) === 60) {
2332
- s6 = peg$c54;
2378
+ s6 = peg$c55;
2333
2379
  peg$currPos++;
2334
2380
  }
2335
2381
  else {
2336
2382
  s6 = peg$FAILED;
2337
2383
  if (peg$silentFails === 0) {
2338
- peg$fail(peg$c55);
2384
+ peg$fail(peg$c56);
2339
2385
  }
2340
2386
  }
2341
2387
  if (s6 !== peg$FAILED) {
@@ -2347,24 +2393,24 @@ function peg$parse(input, options) {
2347
2393
  s11 = peg$currPos;
2348
2394
  peg$silentFails++;
2349
2395
  if (input.charCodeAt(peg$currPos) === 60) {
2350
- s12 = peg$c54;
2396
+ s12 = peg$c55;
2351
2397
  peg$currPos++;
2352
2398
  }
2353
2399
  else {
2354
2400
  s12 = peg$FAILED;
2355
2401
  if (peg$silentFails === 0) {
2356
- peg$fail(peg$c55);
2402
+ peg$fail(peg$c56);
2357
2403
  }
2358
2404
  }
2359
2405
  if (s12 === peg$FAILED) {
2360
2406
  if (input.charCodeAt(peg$currPos) === 62) {
2361
- s12 = peg$c56;
2407
+ s12 = peg$c57;
2362
2408
  peg$currPos++;
2363
2409
  }
2364
2410
  else {
2365
2411
  s12 = peg$FAILED;
2366
2412
  if (peg$silentFails === 0) {
2367
- peg$fail(peg$c57);
2413
+ peg$fail(peg$c58);
2368
2414
  }
2369
2415
  }
2370
2416
  }
@@ -2384,7 +2430,7 @@ function peg$parse(input, options) {
2384
2430
  else {
2385
2431
  s12 = peg$FAILED;
2386
2432
  if (peg$silentFails === 0) {
2387
- peg$fail(peg$c3);
2433
+ peg$fail(peg$c4);
2388
2434
  }
2389
2435
  }
2390
2436
  if (s12 !== peg$FAILED) {
@@ -2407,24 +2453,24 @@ function peg$parse(input, options) {
2407
2453
  s11 = peg$currPos;
2408
2454
  peg$silentFails++;
2409
2455
  if (input.charCodeAt(peg$currPos) === 60) {
2410
- s12 = peg$c54;
2456
+ s12 = peg$c55;
2411
2457
  peg$currPos++;
2412
2458
  }
2413
2459
  else {
2414
2460
  s12 = peg$FAILED;
2415
2461
  if (peg$silentFails === 0) {
2416
- peg$fail(peg$c55);
2462
+ peg$fail(peg$c56);
2417
2463
  }
2418
2464
  }
2419
2465
  if (s12 === peg$FAILED) {
2420
2466
  if (input.charCodeAt(peg$currPos) === 62) {
2421
- s12 = peg$c56;
2467
+ s12 = peg$c57;
2422
2468
  peg$currPos++;
2423
2469
  }
2424
2470
  else {
2425
2471
  s12 = peg$FAILED;
2426
2472
  if (peg$silentFails === 0) {
2427
- peg$fail(peg$c57);
2473
+ peg$fail(peg$c58);
2428
2474
  }
2429
2475
  }
2430
2476
  }
@@ -2444,7 +2490,7 @@ function peg$parse(input, options) {
2444
2490
  else {
2445
2491
  s12 = peg$FAILED;
2446
2492
  if (peg$silentFails === 0) {
2447
- peg$fail(peg$c3);
2493
+ peg$fail(peg$c4);
2448
2494
  }
2449
2495
  }
2450
2496
  if (s12 !== peg$FAILED) {
@@ -2475,18 +2521,18 @@ function peg$parse(input, options) {
2475
2521
  s9 = peg$parse_();
2476
2522
  if (s9 !== peg$FAILED) {
2477
2523
  if (input.charCodeAt(peg$currPos) === 62) {
2478
- s10 = peg$c56;
2524
+ s10 = peg$c57;
2479
2525
  peg$currPos++;
2480
2526
  }
2481
2527
  else {
2482
2528
  s10 = peg$FAILED;
2483
2529
  if (peg$silentFails === 0) {
2484
- peg$fail(peg$c57);
2530
+ peg$fail(peg$c58);
2485
2531
  }
2486
2532
  }
2487
2533
  if (s10 !== peg$FAILED) {
2488
2534
  peg$savedPos = s5;
2489
- s6 = peg$c79(s3, s4, s8);
2535
+ s6 = peg$c80(s3, s4, s8);
2490
2536
  s5 = s6;
2491
2537
  }
2492
2538
  else {
@@ -2516,13 +2562,13 @@ function peg$parse(input, options) {
2516
2562
  if (s5 === peg$FAILED) {
2517
2563
  s5 = peg$currPos;
2518
2564
  if (input.charCodeAt(peg$currPos) === 40) {
2519
- s6 = peg$c80;
2565
+ s6 = peg$c81;
2520
2566
  peg$currPos++;
2521
2567
  }
2522
2568
  else {
2523
2569
  s6 = peg$FAILED;
2524
2570
  if (peg$silentFails === 0) {
2525
- peg$fail(peg$c81);
2571
+ peg$fail(peg$c82);
2526
2572
  }
2527
2573
  }
2528
2574
  if (s6 !== peg$FAILED) {
@@ -2532,7 +2578,7 @@ function peg$parse(input, options) {
2532
2578
  s9 = peg$parsearray_items();
2533
2579
  if (s9 !== peg$FAILED) {
2534
2580
  peg$savedPos = s8;
2535
- s9 = peg$c82(s3, s4, s9);
2581
+ s9 = peg$c83(s3, s4, s9);
2536
2582
  }
2537
2583
  s8 = s9;
2538
2584
  if (s8 === peg$FAILED) {
@@ -2543,24 +2589,24 @@ function peg$parse(input, options) {
2543
2589
  s12 = peg$currPos;
2544
2590
  peg$silentFails++;
2545
2591
  if (input.charCodeAt(peg$currPos) === 41) {
2546
- s13 = peg$c83;
2592
+ s13 = peg$c84;
2547
2593
  peg$currPos++;
2548
2594
  }
2549
2595
  else {
2550
2596
  s13 = peg$FAILED;
2551
2597
  if (peg$silentFails === 0) {
2552
- peg$fail(peg$c84);
2598
+ peg$fail(peg$c85);
2553
2599
  }
2554
2600
  }
2555
2601
  if (s13 === peg$FAILED) {
2556
2602
  if (input.charCodeAt(peg$currPos) === 40) {
2557
- s13 = peg$c80;
2603
+ s13 = peg$c81;
2558
2604
  peg$currPos++;
2559
2605
  }
2560
2606
  else {
2561
2607
  s13 = peg$FAILED;
2562
2608
  if (peg$silentFails === 0) {
2563
- peg$fail(peg$c81);
2609
+ peg$fail(peg$c82);
2564
2610
  }
2565
2611
  }
2566
2612
  }
@@ -2580,7 +2626,7 @@ function peg$parse(input, options) {
2580
2626
  else {
2581
2627
  s13 = peg$FAILED;
2582
2628
  if (peg$silentFails === 0) {
2583
- peg$fail(peg$c3);
2629
+ peg$fail(peg$c4);
2584
2630
  }
2585
2631
  }
2586
2632
  if (s13 !== peg$FAILED) {
@@ -2603,24 +2649,24 @@ function peg$parse(input, options) {
2603
2649
  s12 = peg$currPos;
2604
2650
  peg$silentFails++;
2605
2651
  if (input.charCodeAt(peg$currPos) === 41) {
2606
- s13 = peg$c83;
2652
+ s13 = peg$c84;
2607
2653
  peg$currPos++;
2608
2654
  }
2609
2655
  else {
2610
2656
  s13 = peg$FAILED;
2611
2657
  if (peg$silentFails === 0) {
2612
- peg$fail(peg$c84);
2658
+ peg$fail(peg$c85);
2613
2659
  }
2614
2660
  }
2615
2661
  if (s13 === peg$FAILED) {
2616
2662
  if (input.charCodeAt(peg$currPos) === 40) {
2617
- s13 = peg$c80;
2663
+ s13 = peg$c81;
2618
2664
  peg$currPos++;
2619
2665
  }
2620
2666
  else {
2621
2667
  s13 = peg$FAILED;
2622
2668
  if (peg$silentFails === 0) {
2623
- peg$fail(peg$c81);
2669
+ peg$fail(peg$c82);
2624
2670
  }
2625
2671
  }
2626
2672
  }
@@ -2640,7 +2686,7 @@ function peg$parse(input, options) {
2640
2686
  else {
2641
2687
  s13 = peg$FAILED;
2642
2688
  if (peg$silentFails === 0) {
2643
- peg$fail(peg$c3);
2689
+ peg$fail(peg$c4);
2644
2690
  }
2645
2691
  }
2646
2692
  if (s13 !== peg$FAILED) {
@@ -2669,7 +2715,7 @@ function peg$parse(input, options) {
2669
2715
  }
2670
2716
  if (s9 !== peg$FAILED) {
2671
2717
  peg$savedPos = s8;
2672
- s9 = peg$c85(s3, s4);
2718
+ s9 = peg$c86(s3, s4);
2673
2719
  }
2674
2720
  s8 = s9;
2675
2721
  }
@@ -2677,18 +2723,18 @@ function peg$parse(input, options) {
2677
2723
  s9 = peg$parse_();
2678
2724
  if (s9 !== peg$FAILED) {
2679
2725
  if (input.charCodeAt(peg$currPos) === 41) {
2680
- s10 = peg$c83;
2726
+ s10 = peg$c84;
2681
2727
  peg$currPos++;
2682
2728
  }
2683
2729
  else {
2684
2730
  s10 = peg$FAILED;
2685
2731
  if (peg$silentFails === 0) {
2686
- peg$fail(peg$c84);
2732
+ peg$fail(peg$c85);
2687
2733
  }
2688
2734
  }
2689
2735
  if (s10 !== peg$FAILED) {
2690
2736
  peg$savedPos = s5;
2691
- s6 = peg$c86(s3, s4, s8);
2737
+ s6 = peg$c87(s3, s4, s8);
2692
2738
  s5 = s6;
2693
2739
  }
2694
2740
  else {
@@ -2720,7 +2766,7 @@ function peg$parse(input, options) {
2720
2766
  s6 = peg$parse_();
2721
2767
  if (s6 !== peg$FAILED) {
2722
2768
  peg$savedPos = s5;
2723
- s6 = peg$c87(s3, s4);
2769
+ s6 = peg$c88(s3, s4);
2724
2770
  }
2725
2771
  s5 = s6;
2726
2772
  }
@@ -2732,7 +2778,7 @@ function peg$parse(input, options) {
2732
2778
  s6 = peg$parse_();
2733
2779
  if (s6 !== peg$FAILED) {
2734
2780
  peg$savedPos = s0;
2735
- s1 = peg$c88(s3, s4, s5);
2781
+ s1 = peg$c89(s3, s4, s5);
2736
2782
  s0 = s1;
2737
2783
  }
2738
2784
  else {
@@ -2782,13 +2828,13 @@ function peg$parse(input, options) {
2782
2828
  s3 = [];
2783
2829
  s4 = peg$currPos;
2784
2830
  if (input.charCodeAt(peg$currPos) === 61) {
2785
- s5 = peg$c31;
2831
+ s5 = peg$c32;
2786
2832
  peg$currPos++;
2787
2833
  }
2788
2834
  else {
2789
2835
  s5 = peg$FAILED;
2790
2836
  if (peg$silentFails === 0) {
2791
- peg$fail(peg$c32);
2837
+ peg$fail(peg$c33);
2792
2838
  }
2793
2839
  }
2794
2840
  if (s5 !== peg$FAILED) {
@@ -2811,7 +2857,7 @@ function peg$parse(input, options) {
2811
2857
  s9 = peg$parsenewline();
2812
2858
  if (s9 !== peg$FAILED) {
2813
2859
  peg$savedPos = s4;
2814
- s5 = peg$c89(s1, s7);
2860
+ s5 = peg$c90(s1, s7);
2815
2861
  s4 = s5;
2816
2862
  }
2817
2863
  else {
@@ -2842,13 +2888,13 @@ function peg$parse(input, options) {
2842
2888
  s3.push(s4);
2843
2889
  s4 = peg$currPos;
2844
2890
  if (input.charCodeAt(peg$currPos) === 61) {
2845
- s5 = peg$c31;
2891
+ s5 = peg$c32;
2846
2892
  peg$currPos++;
2847
2893
  }
2848
2894
  else {
2849
2895
  s5 = peg$FAILED;
2850
2896
  if (peg$silentFails === 0) {
2851
- peg$fail(peg$c32);
2897
+ peg$fail(peg$c33);
2852
2898
  }
2853
2899
  }
2854
2900
  if (s5 !== peg$FAILED) {
@@ -2871,7 +2917,7 @@ function peg$parse(input, options) {
2871
2917
  s9 = peg$parsenewline();
2872
2918
  if (s9 !== peg$FAILED) {
2873
2919
  peg$savedPos = s4;
2874
- s5 = peg$c89(s1, s7);
2920
+ s5 = peg$c90(s1, s7);
2875
2921
  s4 = s5;
2876
2922
  }
2877
2923
  else {
@@ -2901,7 +2947,7 @@ function peg$parse(input, options) {
2901
2947
  }
2902
2948
  if (s3 !== peg$FAILED) {
2903
2949
  peg$savedPos = s0;
2904
- s1 = peg$c90(s1, s3);
2950
+ s1 = peg$c91(s1, s3);
2905
2951
  s0 = s1;
2906
2952
  }
2907
2953
  else {
@@ -2925,27 +2971,27 @@ function peg$parse(input, options) {
2925
2971
  s0 = peg$currPos;
2926
2972
  s1 = peg$currPos;
2927
2973
  s2 = [];
2928
- if (peg$c91.test(input.charAt(peg$currPos))) {
2974
+ if (peg$c92.test(input.charAt(peg$currPos))) {
2929
2975
  s3 = input.charAt(peg$currPos);
2930
2976
  peg$currPos++;
2931
2977
  }
2932
2978
  else {
2933
2979
  s3 = peg$FAILED;
2934
2980
  if (peg$silentFails === 0) {
2935
- peg$fail(peg$c92);
2981
+ peg$fail(peg$c93);
2936
2982
  }
2937
2983
  }
2938
2984
  if (s3 !== peg$FAILED) {
2939
2985
  while (s3 !== peg$FAILED) {
2940
2986
  s2.push(s3);
2941
- if (peg$c91.test(input.charAt(peg$currPos))) {
2987
+ if (peg$c92.test(input.charAt(peg$currPos))) {
2942
2988
  s3 = input.charAt(peg$currPos);
2943
2989
  peg$currPos++;
2944
2990
  }
2945
2991
  else {
2946
2992
  s3 = peg$FAILED;
2947
2993
  if (peg$silentFails === 0) {
2948
- peg$fail(peg$c92);
2994
+ peg$fail(peg$c93);
2949
2995
  }
2950
2996
  }
2951
2997
  }
@@ -2961,7 +3007,7 @@ function peg$parse(input, options) {
2961
3007
  }
2962
3008
  if (s1 !== peg$FAILED) {
2963
3009
  peg$savedPos = s0;
2964
- s1 = peg$c93(s1);
3010
+ s1 = peg$c94(s1);
2965
3011
  }
2966
3012
  s0 = s1;
2967
3013
  return s0;
@@ -2970,27 +3016,27 @@ function peg$parse(input, options) {
2970
3016
  var s0, s1, s2;
2971
3017
  s0 = peg$currPos;
2972
3018
  s1 = [];
2973
- if (peg$c94.test(input.charAt(peg$currPos))) {
3019
+ if (peg$c95.test(input.charAt(peg$currPos))) {
2974
3020
  s2 = input.charAt(peg$currPos);
2975
3021
  peg$currPos++;
2976
3022
  }
2977
3023
  else {
2978
3024
  s2 = peg$FAILED;
2979
3025
  if (peg$silentFails === 0) {
2980
- peg$fail(peg$c95);
3026
+ peg$fail(peg$c96);
2981
3027
  }
2982
3028
  }
2983
3029
  if (s2 !== peg$FAILED) {
2984
3030
  while (s2 !== peg$FAILED) {
2985
3031
  s1.push(s2);
2986
- if (peg$c94.test(input.charAt(peg$currPos))) {
3032
+ if (peg$c95.test(input.charAt(peg$currPos))) {
2987
3033
  s2 = input.charAt(peg$currPos);
2988
3034
  peg$currPos++;
2989
3035
  }
2990
3036
  else {
2991
3037
  s2 = peg$FAILED;
2992
3038
  if (peg$silentFails === 0) {
2993
- peg$fail(peg$c95);
3039
+ peg$fail(peg$c96);
2994
3040
  }
2995
3041
  }
2996
3042
  }
@@ -3010,14 +3056,14 @@ function peg$parse(input, options) {
3010
3056
  var s0, s1, s2, s3, s4;
3011
3057
  s0 = peg$currPos;
3012
3058
  s1 = peg$currPos;
3013
- if (peg$c96.test(input.charAt(peg$currPos))) {
3059
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3014
3060
  s2 = input.charAt(peg$currPos);
3015
3061
  peg$currPos++;
3016
3062
  }
3017
3063
  else {
3018
3064
  s2 = peg$FAILED;
3019
3065
  if (peg$silentFails === 0) {
3020
- peg$fail(peg$c97);
3066
+ peg$fail(peg$c98);
3021
3067
  }
3022
3068
  }
3023
3069
  if (s2 === peg$FAILED) {
@@ -3025,27 +3071,27 @@ function peg$parse(input, options) {
3025
3071
  }
3026
3072
  if (s2 !== peg$FAILED) {
3027
3073
  s3 = [];
3028
- if (peg$c94.test(input.charAt(peg$currPos))) {
3074
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3029
3075
  s4 = input.charAt(peg$currPos);
3030
3076
  peg$currPos++;
3031
3077
  }
3032
3078
  else {
3033
3079
  s4 = peg$FAILED;
3034
3080
  if (peg$silentFails === 0) {
3035
- peg$fail(peg$c95);
3081
+ peg$fail(peg$c96);
3036
3082
  }
3037
3083
  }
3038
3084
  if (s4 !== peg$FAILED) {
3039
3085
  while (s4 !== peg$FAILED) {
3040
3086
  s3.push(s4);
3041
- if (peg$c94.test(input.charAt(peg$currPos))) {
3087
+ if (peg$c95.test(input.charAt(peg$currPos))) {
3042
3088
  s4 = input.charAt(peg$currPos);
3043
3089
  peg$currPos++;
3044
3090
  }
3045
3091
  else {
3046
3092
  s4 = peg$FAILED;
3047
3093
  if (peg$silentFails === 0) {
3048
- peg$fail(peg$c95);
3094
+ peg$fail(peg$c96);
3049
3095
  }
3050
3096
  }
3051
3097
  }
@@ -3077,36 +3123,36 @@ function peg$parse(input, options) {
3077
3123
  function peg$parseBoolean() {
3078
3124
  var s0, s1;
3079
3125
  s0 = peg$currPos;
3080
- if (input.substr(peg$currPos, 4) === peg$c98) {
3081
- s1 = peg$c98;
3126
+ if (input.substr(peg$currPos, 4) === peg$c99) {
3127
+ s1 = peg$c99;
3082
3128
  peg$currPos += 4;
3083
3129
  }
3084
3130
  else {
3085
3131
  s1 = peg$FAILED;
3086
3132
  if (peg$silentFails === 0) {
3087
- peg$fail(peg$c99);
3133
+ peg$fail(peg$c100);
3088
3134
  }
3089
3135
  }
3090
3136
  if (s1 !== peg$FAILED) {
3091
3137
  peg$savedPos = s0;
3092
- s1 = peg$c100();
3138
+ s1 = peg$c101();
3093
3139
  }
3094
3140
  s0 = s1;
3095
3141
  if (s0 === peg$FAILED) {
3096
3142
  s0 = peg$currPos;
3097
- if (input.substr(peg$currPos, 5) === peg$c101) {
3098
- s1 = peg$c101;
3143
+ if (input.substr(peg$currPos, 5) === peg$c102) {
3144
+ s1 = peg$c102;
3099
3145
  peg$currPos += 5;
3100
3146
  }
3101
3147
  else {
3102
3148
  s1 = peg$FAILED;
3103
3149
  if (peg$silentFails === 0) {
3104
- peg$fail(peg$c102);
3150
+ peg$fail(peg$c103);
3105
3151
  }
3106
3152
  }
3107
3153
  if (s1 !== peg$FAILED) {
3108
3154
  peg$savedPos = s0;
3109
- s1 = peg$c103();
3155
+ s1 = peg$c104();
3110
3156
  }
3111
3157
  s0 = s1;
3112
3158
  }
@@ -3120,13 +3166,13 @@ function peg$parse(input, options) {
3120
3166
  if (s2 !== peg$FAILED) {
3121
3167
  s3 = peg$currPos;
3122
3168
  if (input.charCodeAt(peg$currPos) === 46) {
3123
- s4 = peg$c104;
3169
+ s4 = peg$c105;
3124
3170
  peg$currPos++;
3125
3171
  }
3126
3172
  else {
3127
3173
  s4 = peg$FAILED;
3128
3174
  if (peg$silentFails === 0) {
3129
- peg$fail(peg$c105);
3175
+ peg$fail(peg$c106);
3130
3176
  }
3131
3177
  }
3132
3178
  if (s4 !== peg$FAILED) {
@@ -3148,14 +3194,14 @@ function peg$parse(input, options) {
3148
3194
  s3 = null;
3149
3195
  }
3150
3196
  if (s3 !== peg$FAILED) {
3151
- if (peg$c106.test(input.charAt(peg$currPos))) {
3197
+ if (peg$c107.test(input.charAt(peg$currPos))) {
3152
3198
  s4 = input.charAt(peg$currPos);
3153
3199
  peg$currPos++;
3154
3200
  }
3155
3201
  else {
3156
3202
  s4 = peg$FAILED;
3157
3203
  if (peg$silentFails === 0) {
3158
- peg$fail(peg$c107);
3204
+ peg$fail(peg$c108);
3159
3205
  }
3160
3206
  }
3161
3207
  if (s4 !== peg$FAILED) {
@@ -3195,13 +3241,13 @@ function peg$parse(input, options) {
3195
3241
  s2 = peg$parsenumber();
3196
3242
  if (s2 !== peg$FAILED) {
3197
3243
  if (input.charCodeAt(peg$currPos) === 46) {
3198
- s3 = peg$c104;
3244
+ s3 = peg$c105;
3199
3245
  peg$currPos++;
3200
3246
  }
3201
3247
  else {
3202
3248
  s3 = peg$FAILED;
3203
3249
  if (peg$silentFails === 0) {
3204
- peg$fail(peg$c105);
3250
+ peg$fail(peg$c106);
3205
3251
  }
3206
3252
  }
3207
3253
  if (s3 !== peg$FAILED) {
@@ -3236,39 +3282,39 @@ function peg$parse(input, options) {
3236
3282
  function peg$parseitem() {
3237
3283
  var s0, s1, s2, s3, s4;
3238
3284
  s0 = peg$currPos;
3239
- if (peg$c108.test(input.charAt(peg$currPos))) {
3285
+ if (peg$c109.test(input.charAt(peg$currPos))) {
3240
3286
  s1 = input.charAt(peg$currPos);
3241
3287
  peg$currPos++;
3242
3288
  }
3243
3289
  else {
3244
3290
  s1 = peg$FAILED;
3245
3291
  if (peg$silentFails === 0) {
3246
- peg$fail(peg$c109);
3292
+ peg$fail(peg$c110);
3247
3293
  }
3248
3294
  }
3249
3295
  if (s1 !== peg$FAILED) {
3250
3296
  s2 = peg$currPos;
3251
3297
  s3 = [];
3252
- if (peg$c110.test(input.charAt(peg$currPos))) {
3298
+ if (peg$c111.test(input.charAt(peg$currPos))) {
3253
3299
  s4 = input.charAt(peg$currPos);
3254
3300
  peg$currPos++;
3255
3301
  }
3256
3302
  else {
3257
3303
  s4 = peg$FAILED;
3258
3304
  if (peg$silentFails === 0) {
3259
- peg$fail(peg$c111);
3305
+ peg$fail(peg$c112);
3260
3306
  }
3261
3307
  }
3262
3308
  while (s4 !== peg$FAILED) {
3263
3309
  s3.push(s4);
3264
- if (peg$c110.test(input.charAt(peg$currPos))) {
3310
+ if (peg$c111.test(input.charAt(peg$currPos))) {
3265
3311
  s4 = input.charAt(peg$currPos);
3266
3312
  peg$currPos++;
3267
3313
  }
3268
3314
  else {
3269
3315
  s4 = peg$FAILED;
3270
3316
  if (peg$silentFails === 0) {
3271
- peg$fail(peg$c111);
3317
+ peg$fail(peg$c112);
3272
3318
  }
3273
3319
  }
3274
3320
  }
@@ -3279,19 +3325,19 @@ function peg$parse(input, options) {
3279
3325
  s2 = s3;
3280
3326
  }
3281
3327
  if (s2 !== peg$FAILED) {
3282
- if (peg$c108.test(input.charAt(peg$currPos))) {
3328
+ if (peg$c109.test(input.charAt(peg$currPos))) {
3283
3329
  s3 = input.charAt(peg$currPos);
3284
3330
  peg$currPos++;
3285
3331
  }
3286
3332
  else {
3287
3333
  s3 = peg$FAILED;
3288
3334
  if (peg$silentFails === 0) {
3289
- peg$fail(peg$c109);
3335
+ peg$fail(peg$c110);
3290
3336
  }
3291
3337
  }
3292
3338
  if (s3 !== peg$FAILED) {
3293
3339
  peg$savedPos = s0;
3294
- s1 = peg$c93(s2);
3340
+ s1 = peg$c94(s2);
3295
3341
  s0 = s1;
3296
3342
  }
3297
3343
  else {
@@ -3310,39 +3356,39 @@ function peg$parse(input, options) {
3310
3356
  }
3311
3357
  if (s0 === peg$FAILED) {
3312
3358
  s0 = peg$currPos;
3313
- if (peg$c112.test(input.charAt(peg$currPos))) {
3359
+ if (peg$c113.test(input.charAt(peg$currPos))) {
3314
3360
  s1 = input.charAt(peg$currPos);
3315
3361
  peg$currPos++;
3316
3362
  }
3317
3363
  else {
3318
3364
  s1 = peg$FAILED;
3319
3365
  if (peg$silentFails === 0) {
3320
- peg$fail(peg$c113);
3366
+ peg$fail(peg$c114);
3321
3367
  }
3322
3368
  }
3323
3369
  if (s1 !== peg$FAILED) {
3324
3370
  s2 = peg$currPos;
3325
3371
  s3 = [];
3326
- if (peg$c114.test(input.charAt(peg$currPos))) {
3372
+ if (peg$c115.test(input.charAt(peg$currPos))) {
3327
3373
  s4 = input.charAt(peg$currPos);
3328
3374
  peg$currPos++;
3329
3375
  }
3330
3376
  else {
3331
3377
  s4 = peg$FAILED;
3332
3378
  if (peg$silentFails === 0) {
3333
- peg$fail(peg$c115);
3379
+ peg$fail(peg$c116);
3334
3380
  }
3335
3381
  }
3336
3382
  while (s4 !== peg$FAILED) {
3337
3383
  s3.push(s4);
3338
- if (peg$c114.test(input.charAt(peg$currPos))) {
3384
+ if (peg$c115.test(input.charAt(peg$currPos))) {
3339
3385
  s4 = input.charAt(peg$currPos);
3340
3386
  peg$currPos++;
3341
3387
  }
3342
3388
  else {
3343
3389
  s4 = peg$FAILED;
3344
3390
  if (peg$silentFails === 0) {
3345
- peg$fail(peg$c115);
3391
+ peg$fail(peg$c116);
3346
3392
  }
3347
3393
  }
3348
3394
  }
@@ -3353,19 +3399,19 @@ function peg$parse(input, options) {
3353
3399
  s2 = s3;
3354
3400
  }
3355
3401
  if (s2 !== peg$FAILED) {
3356
- if (peg$c112.test(input.charAt(peg$currPos))) {
3402
+ if (peg$c113.test(input.charAt(peg$currPos))) {
3357
3403
  s3 = input.charAt(peg$currPos);
3358
3404
  peg$currPos++;
3359
3405
  }
3360
3406
  else {
3361
3407
  s3 = peg$FAILED;
3362
3408
  if (peg$silentFails === 0) {
3363
- peg$fail(peg$c113);
3409
+ peg$fail(peg$c114);
3364
3410
  }
3365
3411
  }
3366
3412
  if (s3 !== peg$FAILED) {
3367
3413
  peg$savedPos = s0;
3368
- s1 = peg$c93(s2);
3414
+ s1 = peg$c94(s2);
3369
3415
  s0 = s1;
3370
3416
  }
3371
3417
  else {
@@ -3389,7 +3435,7 @@ function peg$parse(input, options) {
3389
3435
  s1 = peg$parsefloatNumber();
3390
3436
  if (s1 !== peg$FAILED) {
3391
3437
  peg$savedPos = s0;
3392
- s1 = peg$c116(s1);
3438
+ s1 = peg$c117(s1);
3393
3439
  }
3394
3440
  s0 = s1;
3395
3441
  if (s0 === peg$FAILED) {
@@ -3397,7 +3443,7 @@ function peg$parse(input, options) {
3397
3443
  s1 = peg$parsenumber();
3398
3444
  if (s1 !== peg$FAILED) {
3399
3445
  peg$savedPos = s0;
3400
- s1 = peg$c117(s1);
3446
+ s1 = peg$c118(s1);
3401
3447
  }
3402
3448
  s0 = s1;
3403
3449
  }
@@ -3427,7 +3473,7 @@ function peg$parse(input, options) {
3427
3473
  s5 = peg$parsepod_configuration();
3428
3474
  if (s5 !== peg$FAILED) {
3429
3475
  peg$savedPos = peg$currPos;
3430
- s6 = peg$c118(s1, s3, s5);
3476
+ s6 = peg$c119(s1, s3, s5);
3431
3477
  if (s6) {
3432
3478
  s6 = void 0;
3433
3479
  }
@@ -3470,7 +3516,7 @@ function peg$parse(input, options) {
3470
3516
  s15 = peg$parsestrictIdentifier();
3471
3517
  if (s15 !== peg$FAILED) {
3472
3518
  peg$savedPos = peg$currPos;
3473
- s16 = peg$c119(s1, s3, s5, s9, s15);
3519
+ s16 = peg$c120(s1, s3, s5, s9, s15);
3474
3520
  if (s16) {
3475
3521
  s16 = void 0;
3476
3522
  }
@@ -3538,7 +3584,7 @@ function peg$parse(input, options) {
3538
3584
  }
3539
3585
  if (s10 !== peg$FAILED) {
3540
3586
  peg$savedPos = s8;
3541
- s9 = peg$c120(s1, s3, s5, s9, s10);
3587
+ s9 = peg$c121(s1, s3, s5, s9, s10);
3542
3588
  s8 = s9;
3543
3589
  }
3544
3590
  else {
@@ -3587,7 +3633,7 @@ function peg$parse(input, options) {
3587
3633
  s15 = peg$parsestrictIdentifier();
3588
3634
  if (s15 !== peg$FAILED) {
3589
3635
  peg$savedPos = peg$currPos;
3590
- s16 = peg$c119(s1, s3, s5, s9, s15);
3636
+ s16 = peg$c120(s1, s3, s5, s9, s15);
3591
3637
  if (s16) {
3592
3638
  s16 = void 0;
3593
3639
  }
@@ -3655,7 +3701,7 @@ function peg$parse(input, options) {
3655
3701
  }
3656
3702
  if (s10 !== peg$FAILED) {
3657
3703
  peg$savedPos = s8;
3658
- s9 = peg$c120(s1, s3, s5, s9, s10);
3704
+ s9 = peg$c121(s1, s3, s5, s9, s10);
3659
3705
  s8 = s9;
3660
3706
  }
3661
3707
  else {
@@ -3688,7 +3734,7 @@ function peg$parse(input, options) {
3688
3734
  s11 = peg$parsestrictIdentifier();
3689
3735
  if (s11 !== peg$FAILED) {
3690
3736
  peg$savedPos = peg$currPos;
3691
- s12 = peg$c121(s1, s3, s5, s7, s8, s11);
3737
+ s12 = peg$c122(s1, s3, s5, s7, s8, s11);
3692
3738
  if (s12) {
3693
3739
  s12 = void 0;
3694
3740
  }
@@ -3702,7 +3748,7 @@ function peg$parse(input, options) {
3702
3748
  }
3703
3749
  if (s13 !== peg$FAILED) {
3704
3750
  peg$savedPos = s9;
3705
- s10 = peg$c122(s1, s3, s5, s7, s8, s11);
3751
+ s10 = peg$c123(s1, s3, s5, s7, s8, s11);
3706
3752
  s9 = s10;
3707
3753
  }
3708
3754
  else {
@@ -3726,7 +3772,7 @@ function peg$parse(input, options) {
3726
3772
  }
3727
3773
  if (s9 !== peg$FAILED) {
3728
3774
  peg$savedPos = peg$currPos;
3729
- s10 = peg$c123(s1, s3, s5, s7, s8, s9);
3775
+ s10 = peg$c124(s1, s3, s5, s7, s8, s9);
3730
3776
  if (s10) {
3731
3777
  s10 = void 0;
3732
3778
  }
@@ -3735,7 +3781,7 @@ function peg$parse(input, options) {
3735
3781
  }
3736
3782
  if (s10 !== peg$FAILED) {
3737
3783
  peg$savedPos = s0;
3738
- s1 = peg$c124(s1, s3, s5, s7, s8, s9);
3784
+ s1 = peg$c125(s1, s3, s5, s7, s8, s9);
3739
3785
  s0 = s1;
3740
3786
  }
3741
3787
  else {
@@ -3836,14 +3882,14 @@ function peg$parse(input, options) {
3836
3882
  s3 = peg$currPos;
3837
3883
  s4 = [];
3838
3884
  s5 = peg$currPos;
3839
- if (peg$c125.test(input.charAt(peg$currPos))) {
3885
+ if (peg$c126.test(input.charAt(peg$currPos))) {
3840
3886
  s6 = input.charAt(peg$currPos);
3841
3887
  peg$currPos++;
3842
3888
  }
3843
3889
  else {
3844
3890
  s6 = peg$FAILED;
3845
3891
  if (peg$silentFails === 0) {
3846
- peg$fail(peg$c126);
3892
+ peg$fail(peg$c127);
3847
3893
  }
3848
3894
  }
3849
3895
  if (s6 !== peg$FAILED) {
@@ -3870,14 +3916,14 @@ function peg$parse(input, options) {
3870
3916
  while (s5 !== peg$FAILED) {
3871
3917
  s4.push(s5);
3872
3918
  s5 = peg$currPos;
3873
- if (peg$c125.test(input.charAt(peg$currPos))) {
3919
+ if (peg$c126.test(input.charAt(peg$currPos))) {
3874
3920
  s6 = input.charAt(peg$currPos);
3875
3921
  peg$currPos++;
3876
3922
  }
3877
3923
  else {
3878
3924
  s6 = peg$FAILED;
3879
3925
  if (peg$silentFails === 0) {
3880
- peg$fail(peg$c126);
3926
+ peg$fail(peg$c127);
3881
3927
  }
3882
3928
  }
3883
3929
  if (s6 !== peg$FAILED) {
@@ -3915,7 +3961,7 @@ function peg$parse(input, options) {
3915
3961
  s4 = peg$parseEOL();
3916
3962
  if (s4 !== peg$FAILED) {
3917
3963
  peg$savedPos = s0;
3918
- s1 = peg$c127();
3964
+ s1 = peg$c128();
3919
3965
  s0 = s1;
3920
3966
  }
3921
3967
  else {
@@ -3947,7 +3993,7 @@ function peg$parse(input, options) {
3947
3993
  if (s2 === peg$FAILED) {
3948
3994
  s2 = peg$currPos;
3949
3995
  peg$savedPos = peg$currPos;
3950
- s3 = peg$c128();
3996
+ s3 = peg$c129();
3951
3997
  if (s3) {
3952
3998
  s3 = void 0;
3953
3999
  }
@@ -3978,7 +4024,7 @@ function peg$parse(input, options) {
3978
4024
  }
3979
4025
  if (s1 !== peg$FAILED) {
3980
4026
  peg$savedPos = s0;
3981
- s1 = peg$c129();
4027
+ s1 = peg$c130();
3982
4028
  }
3983
4029
  s0 = s1;
3984
4030
  return s0;
@@ -3989,7 +4035,7 @@ function peg$parse(input, options) {
3989
4035
  s1 = peg$parsetext_content();
3990
4036
  if (s1 !== peg$FAILED) {
3991
4037
  peg$savedPos = s0;
3992
- s1 = peg$c130(s1);
4038
+ s1 = peg$c131(s1);
3993
4039
  }
3994
4040
  s0 = s1;
3995
4041
  return s0;
@@ -3998,7 +4044,7 @@ function peg$parse(input, options) {
3998
4044
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
3999
4045
  s0 = peg$currPos;
4000
4046
  peg$savedPos = peg$currPos;
4001
- s1 = peg$c131();
4047
+ s1 = peg$c132();
4002
4048
  if (s1) {
4003
4049
  s1 = void 0;
4004
4050
  }
@@ -4081,7 +4127,7 @@ function peg$parse(input, options) {
4081
4127
  s4 = peg$parsetableHeadSeparator();
4082
4128
  if (s4 !== peg$FAILED) {
4083
4129
  peg$savedPos = s3;
4084
- s4 = peg$c132(s2, s4);
4130
+ s4 = peg$c133(s2, s4);
4085
4131
  }
4086
4132
  s3 = s4;
4087
4133
  if (s3 !== peg$FAILED) {
@@ -4162,12 +4208,12 @@ function peg$parse(input, options) {
4162
4208
  s8 = peg$parsetableBodyRowSeparator();
4163
4209
  if (s8 !== peg$FAILED) {
4164
4210
  peg$savedPos = s7;
4165
- s8 = peg$c133(s2, s3, s6, s8);
4211
+ s8 = peg$c134(s2, s3, s6, s8);
4166
4212
  }
4167
4213
  s7 = s8;
4168
4214
  if (s7 !== peg$FAILED) {
4169
4215
  peg$savedPos = s5;
4170
- s6 = peg$c134(s2, s3, s6, s7);
4216
+ s6 = peg$c135(s2, s3, s6, s7);
4171
4217
  s5 = s6;
4172
4218
  }
4173
4219
  else {
@@ -4208,7 +4254,7 @@ function peg$parse(input, options) {
4208
4254
  s8 = peg$parsetableRow();
4209
4255
  if (s8 !== peg$FAILED) {
4210
4256
  peg$savedPos = s5;
4211
- s6 = peg$c135(s2, s3, s8);
4257
+ s6 = peg$c136(s2, s3, s8);
4212
4258
  s5 = s6;
4213
4259
  }
4214
4260
  else {
@@ -4305,12 +4351,12 @@ function peg$parse(input, options) {
4305
4351
  s8 = peg$parsetableBodyRowSeparator();
4306
4352
  if (s8 !== peg$FAILED) {
4307
4353
  peg$savedPos = s7;
4308
- s8 = peg$c133(s2, s3, s6, s8);
4354
+ s8 = peg$c134(s2, s3, s6, s8);
4309
4355
  }
4310
4356
  s7 = s8;
4311
4357
  if (s7 !== peg$FAILED) {
4312
4358
  peg$savedPos = s5;
4313
- s6 = peg$c134(s2, s3, s6, s7);
4359
+ s6 = peg$c135(s2, s3, s6, s7);
4314
4360
  s5 = s6;
4315
4361
  }
4316
4362
  else {
@@ -4351,7 +4397,7 @@ function peg$parse(input, options) {
4351
4397
  s8 = peg$parsetableRow();
4352
4398
  if (s8 !== peg$FAILED) {
4353
4399
  peg$savedPos = s5;
4354
- s6 = peg$c135(s2, s3, s8);
4400
+ s6 = peg$c136(s2, s3, s8);
4355
4401
  s5 = s6;
4356
4402
  }
4357
4403
  else {
@@ -4376,7 +4422,7 @@ function peg$parse(input, options) {
4376
4422
  }
4377
4423
  if (s4 !== peg$FAILED) {
4378
4424
  peg$savedPos = peg$currPos;
4379
- s5 = peg$c136(s2, s3, s4);
4425
+ s5 = peg$c137(s2, s3, s4);
4380
4426
  if (s5) {
4381
4427
  s5 = void 0;
4382
4428
  }
@@ -4385,7 +4431,7 @@ function peg$parse(input, options) {
4385
4431
  }
4386
4432
  if (s5 !== peg$FAILED) {
4387
4433
  peg$savedPos = s0;
4388
- s1 = peg$c137(s2, s3, s4);
4434
+ s1 = peg$c138(s2, s3, s4);
4389
4435
  s0 = s1;
4390
4436
  }
4391
4437
  else {
@@ -4459,7 +4505,7 @@ function peg$parse(input, options) {
4459
4505
  }
4460
4506
  if (s4 !== peg$FAILED) {
4461
4507
  peg$savedPos = s2;
4462
- s3 = peg$c138(s3, s4);
4508
+ s3 = peg$c139(s3, s4);
4463
4509
  s2 = s3;
4464
4510
  }
4465
4511
  else {
@@ -4518,7 +4564,7 @@ function peg$parse(input, options) {
4518
4564
  }
4519
4565
  if (s4 !== peg$FAILED) {
4520
4566
  peg$savedPos = s2;
4521
- s3 = peg$c138(s3, s4);
4567
+ s3 = peg$c139(s3, s4);
4522
4568
  s2 = s3;
4523
4569
  }
4524
4570
  else {
@@ -4537,7 +4583,7 @@ function peg$parse(input, options) {
4537
4583
  }
4538
4584
  if (s1 !== peg$FAILED) {
4539
4585
  peg$savedPos = s0;
4540
- s1 = peg$c139(s1);
4586
+ s1 = peg$c140(s1);
4541
4587
  }
4542
4588
  s0 = s1;
4543
4589
  if (s0 === peg$FAILED) {
@@ -4577,7 +4623,7 @@ function peg$parse(input, options) {
4577
4623
  s5 = peg$parsepod_configuration();
4578
4624
  if (s5 !== peg$FAILED) {
4579
4625
  peg$savedPos = peg$currPos;
4580
- s6 = peg$c140(s1, s3, s5);
4626
+ s6 = peg$c141(s1, s3, s5);
4581
4627
  if (s6) {
4582
4628
  s6 = void 0;
4583
4629
  }
@@ -4586,7 +4632,7 @@ function peg$parse(input, options) {
4586
4632
  }
4587
4633
  if (s6 !== peg$FAILED) {
4588
4634
  peg$savedPos = peg$currPos;
4589
- s7 = peg$c141(s1, s3, s5);
4635
+ s7 = peg$c142(s1, s3, s5);
4590
4636
  if (s7) {
4591
4637
  s7 = void 0;
4592
4638
  }
@@ -4639,12 +4685,12 @@ function peg$parse(input, options) {
4639
4685
  }
4640
4686
  if (s9 !== peg$FAILED) {
4641
4687
  peg$savedPos = s8;
4642
- s9 = peg$c142(s1, s3, s5, s9);
4688
+ s9 = peg$c143(s1, s3, s5, s9);
4643
4689
  }
4644
4690
  s8 = s9;
4645
4691
  if (s8 !== peg$FAILED) {
4646
4692
  peg$savedPos = peg$currPos;
4647
- s9 = peg$c143(s1, s3, s5, s8);
4693
+ s9 = peg$c144(s1, s3, s5, s8);
4648
4694
  if (s9) {
4649
4695
  s9 = void 0;
4650
4696
  }
@@ -4667,7 +4713,7 @@ function peg$parse(input, options) {
4667
4713
  s13 = peg$parsestrictIdentifier();
4668
4714
  if (s13 !== peg$FAILED) {
4669
4715
  peg$savedPos = peg$currPos;
4670
- s14 = peg$c121(s1, s3, s5, s8, s10, s13);
4716
+ s14 = peg$c122(s1, s3, s5, s8, s10, s13);
4671
4717
  if (s14) {
4672
4718
  s14 = void 0;
4673
4719
  }
@@ -4681,7 +4727,7 @@ function peg$parse(input, options) {
4681
4727
  }
4682
4728
  if (s15 !== peg$FAILED) {
4683
4729
  peg$savedPos = s11;
4684
- s12 = peg$c144(s1, s3, s5, s8, s10, s13);
4730
+ s12 = peg$c145(s1, s3, s5, s8, s10, s13);
4685
4731
  s11 = s12;
4686
4732
  }
4687
4733
  else {
@@ -4705,7 +4751,7 @@ function peg$parse(input, options) {
4705
4751
  }
4706
4752
  if (s11 !== peg$FAILED) {
4707
4753
  peg$savedPos = s0;
4708
- s1 = peg$c145(s1, s3, s5, s8, s10, s11);
4754
+ s1 = peg$c146(s1, s3, s5, s8, s10, s11);
4709
4755
  s0 = s1;
4710
4756
  }
4711
4757
  else {
@@ -4785,7 +4831,7 @@ function peg$parse(input, options) {
4785
4831
  s5 = peg$parsepod_configuration();
4786
4832
  if (s5 !== peg$FAILED) {
4787
4833
  peg$savedPos = peg$currPos;
4788
- s6 = peg$c140(s1, s3, s5);
4834
+ s6 = peg$c141(s1, s3, s5);
4789
4835
  if (s6) {
4790
4836
  s6 = void 0;
4791
4837
  }
@@ -4794,7 +4840,7 @@ function peg$parse(input, options) {
4794
4840
  }
4795
4841
  if (s6 !== peg$FAILED) {
4796
4842
  peg$savedPos = peg$currPos;
4797
- s7 = peg$c146(s1, s3, s5);
4843
+ s7 = peg$c147(s1, s3, s5);
4798
4844
  if (s7) {
4799
4845
  s7 = void 0;
4800
4846
  }
@@ -4820,7 +4866,7 @@ function peg$parse(input, options) {
4820
4866
  }
4821
4867
  if (s11 !== peg$FAILED) {
4822
4868
  peg$savedPos = s8;
4823
- s9 = peg$c147(s1, s3, s5, s10);
4869
+ s9 = peg$c148(s1, s3, s5, s10);
4824
4870
  s8 = s9;
4825
4871
  }
4826
4872
  else {
@@ -4853,7 +4899,7 @@ function peg$parse(input, options) {
4853
4899
  s12 = peg$parsestrictIdentifier();
4854
4900
  if (s12 !== peg$FAILED) {
4855
4901
  peg$savedPos = peg$currPos;
4856
- s13 = peg$c121(s1, s3, s5, s8, s9, s12);
4902
+ s13 = peg$c122(s1, s3, s5, s8, s9, s12);
4857
4903
  if (s13) {
4858
4904
  s13 = void 0;
4859
4905
  }
@@ -4867,7 +4913,7 @@ function peg$parse(input, options) {
4867
4913
  }
4868
4914
  if (s14 !== peg$FAILED) {
4869
4915
  peg$savedPos = s10;
4870
- s11 = peg$c148(s1, s3, s5, s8, s9, s12);
4916
+ s11 = peg$c149(s1, s3, s5, s8, s9, s12);
4871
4917
  s10 = s11;
4872
4918
  }
4873
4919
  else {
@@ -4891,7 +4937,7 @@ function peg$parse(input, options) {
4891
4937
  }
4892
4938
  if (s10 !== peg$FAILED) {
4893
4939
  peg$savedPos = peg$currPos;
4894
- s11 = peg$c123(s1, s3, s5, s8, s9, s10);
4940
+ s11 = peg$c124(s1, s3, s5, s8, s9, s10);
4895
4941
  if (s11) {
4896
4942
  s11 = void 0;
4897
4943
  }
@@ -4900,7 +4946,7 @@ function peg$parse(input, options) {
4900
4946
  }
4901
4947
  if (s11 !== peg$FAILED) {
4902
4948
  peg$savedPos = s0;
4903
- s1 = peg$c149(s1, s3, s5, s8, s9, s10);
4949
+ s1 = peg$c150(s1, s3, s5, s8, s9, s10);
4904
4950
  s0 = s1;
4905
4951
  }
4906
4952
  else {
@@ -4999,11 +5045,14 @@ function peg$parse(input, options) {
4999
5045
  if (s8 === peg$FAILED) {
5000
5046
  s8 = peg$parseconfigDirective();
5001
5047
  if (s8 === peg$FAILED) {
5002
- s8 = peg$parseabbreviatedBlockRaw();
5048
+ s8 = peg$parseboundaryDirective();
5003
5049
  if (s8 === peg$FAILED) {
5004
- s8 = peg$parseabbreviatedBlockTable();
5050
+ s8 = peg$parseabbreviatedBlockRaw();
5005
5051
  if (s8 === peg$FAILED) {
5006
- s8 = peg$parseabbreviatedBlock();
5052
+ s8 = peg$parseabbreviatedBlockTable();
5053
+ if (s8 === peg$FAILED) {
5054
+ s8 = peg$parseabbreviatedBlock();
5055
+ }
5007
5056
  }
5008
5057
  }
5009
5058
  }
@@ -5017,7 +5066,7 @@ function peg$parse(input, options) {
5017
5066
  }
5018
5067
  if (s8 !== peg$FAILED) {
5019
5068
  peg$savedPos = s7;
5020
- s8 = peg$c150(s1, s3, s5, s8);
5069
+ s8 = peg$c151(s1, s3, s5, s8);
5021
5070
  }
5022
5071
  s7 = s8;
5023
5072
  if (s7 === peg$FAILED) {
@@ -5056,7 +5105,7 @@ function peg$parse(input, options) {
5056
5105
  }
5057
5106
  if (s9 !== peg$FAILED) {
5058
5107
  peg$savedPos = s7;
5059
- s8 = peg$c151(s1, s3, s5, s8, s9);
5108
+ s8 = peg$c152(s1, s3, s5, s8, s9);
5060
5109
  s7 = s8;
5061
5110
  }
5062
5111
  else {
@@ -5090,11 +5139,14 @@ function peg$parse(input, options) {
5090
5139
  if (s8 === peg$FAILED) {
5091
5140
  s8 = peg$parseconfigDirective();
5092
5141
  if (s8 === peg$FAILED) {
5093
- s8 = peg$parseabbreviatedBlockRaw();
5142
+ s8 = peg$parseboundaryDirective();
5094
5143
  if (s8 === peg$FAILED) {
5095
- s8 = peg$parseabbreviatedBlockTable();
5144
+ s8 = peg$parseabbreviatedBlockRaw();
5096
5145
  if (s8 === peg$FAILED) {
5097
- s8 = peg$parseabbreviatedBlock();
5146
+ s8 = peg$parseabbreviatedBlockTable();
5147
+ if (s8 === peg$FAILED) {
5148
+ s8 = peg$parseabbreviatedBlock();
5149
+ }
5098
5150
  }
5099
5151
  }
5100
5152
  }
@@ -5108,7 +5160,7 @@ function peg$parse(input, options) {
5108
5160
  }
5109
5161
  if (s8 !== peg$FAILED) {
5110
5162
  peg$savedPos = s7;
5111
- s8 = peg$c150(s1, s3, s5, s8);
5163
+ s8 = peg$c151(s1, s3, s5, s8);
5112
5164
  }
5113
5165
  s7 = s8;
5114
5166
  if (s7 === peg$FAILED) {
@@ -5147,7 +5199,7 @@ function peg$parse(input, options) {
5147
5199
  }
5148
5200
  if (s9 !== peg$FAILED) {
5149
5201
  peg$savedPos = s7;
5150
- s8 = peg$c151(s1, s3, s5, s8, s9);
5202
+ s8 = peg$c152(s1, s3, s5, s8, s9);
5151
5203
  s7 = s8;
5152
5204
  }
5153
5205
  else {
@@ -5177,7 +5229,7 @@ function peg$parse(input, options) {
5177
5229
  s10 = peg$parsestrictIdentifier();
5178
5230
  if (s10 !== peg$FAILED) {
5179
5231
  peg$savedPos = peg$currPos;
5180
- s11 = peg$c121(s1, s3, s5, s6, s7, s10);
5232
+ s11 = peg$c122(s1, s3, s5, s6, s7, s10);
5181
5233
  if (s11) {
5182
5234
  s11 = void 0;
5183
5235
  }
@@ -5191,7 +5243,7 @@ function peg$parse(input, options) {
5191
5243
  }
5192
5244
  if (s12 !== peg$FAILED) {
5193
5245
  peg$savedPos = s8;
5194
- s9 = peg$c152(s1, s3, s5, s6, s7, s10);
5246
+ s9 = peg$c153(s1, s3, s5, s6, s7, s10);
5195
5247
  s8 = s9;
5196
5248
  }
5197
5249
  else {
@@ -5215,7 +5267,7 @@ function peg$parse(input, options) {
5215
5267
  }
5216
5268
  if (s8 !== peg$FAILED) {
5217
5269
  peg$savedPos = peg$currPos;
5218
- s9 = peg$c123(s1, s3, s5, s6, s7, s8);
5270
+ s9 = peg$c124(s1, s3, s5, s6, s7, s8);
5219
5271
  if (s9) {
5220
5272
  s9 = void 0;
5221
5273
  }
@@ -5224,7 +5276,7 @@ function peg$parse(input, options) {
5224
5276
  }
5225
5277
  if (s9 !== peg$FAILED) {
5226
5278
  peg$savedPos = s0;
5227
- s1 = peg$c153(s1, s3, s5, s6, s7, s8);
5279
+ s1 = peg$c154(s1, s3, s5, s6, s7, s8);
5228
5280
  s0 = s1;
5229
5281
  }
5230
5282
  else {
@@ -5289,7 +5341,7 @@ function peg$parse(input, options) {
5289
5341
  }
5290
5342
  if (s1 !== peg$FAILED) {
5291
5343
  peg$savedPos = s0;
5292
- s1 = peg$c154();
5344
+ s1 = peg$c155();
5293
5345
  }
5294
5346
  s0 = s1;
5295
5347
  return s0;
@@ -5302,32 +5354,32 @@ function peg$parse(input, options) {
5302
5354
  s3 = peg$parseemptyline();
5303
5355
  if (s3 !== peg$FAILED) {
5304
5356
  peg$savedPos = s2;
5305
- s3 = peg$c155();
5357
+ s3 = peg$c156();
5306
5358
  }
5307
5359
  s2 = s3;
5308
5360
  if (s2 === peg$FAILED) {
5309
5361
  s2 = [];
5310
- if (peg$c156.test(input.charAt(peg$currPos))) {
5362
+ if (peg$c157.test(input.charAt(peg$currPos))) {
5311
5363
  s3 = input.charAt(peg$currPos);
5312
5364
  peg$currPos++;
5313
5365
  }
5314
5366
  else {
5315
5367
  s3 = peg$FAILED;
5316
5368
  if (peg$silentFails === 0) {
5317
- peg$fail(peg$c157);
5369
+ peg$fail(peg$c158);
5318
5370
  }
5319
5371
  }
5320
5372
  if (s3 !== peg$FAILED) {
5321
5373
  while (s3 !== peg$FAILED) {
5322
5374
  s2.push(s3);
5323
- if (peg$c156.test(input.charAt(peg$currPos))) {
5375
+ if (peg$c157.test(input.charAt(peg$currPos))) {
5324
5376
  s3 = input.charAt(peg$currPos);
5325
5377
  peg$currPos++;
5326
5378
  }
5327
5379
  else {
5328
5380
  s3 = peg$FAILED;
5329
5381
  if (peg$silentFails === 0) {
5330
- peg$fail(peg$c157);
5382
+ peg$fail(peg$c158);
5331
5383
  }
5332
5384
  }
5333
5385
  }
@@ -5346,32 +5398,32 @@ function peg$parse(input, options) {
5346
5398
  s3 = peg$parseemptyline();
5347
5399
  if (s3 !== peg$FAILED) {
5348
5400
  peg$savedPos = s2;
5349
- s3 = peg$c155();
5401
+ s3 = peg$c156();
5350
5402
  }
5351
5403
  s2 = s3;
5352
5404
  if (s2 === peg$FAILED) {
5353
5405
  s2 = [];
5354
- if (peg$c156.test(input.charAt(peg$currPos))) {
5406
+ if (peg$c157.test(input.charAt(peg$currPos))) {
5355
5407
  s3 = input.charAt(peg$currPos);
5356
5408
  peg$currPos++;
5357
5409
  }
5358
5410
  else {
5359
5411
  s3 = peg$FAILED;
5360
5412
  if (peg$silentFails === 0) {
5361
- peg$fail(peg$c157);
5413
+ peg$fail(peg$c158);
5362
5414
  }
5363
5415
  }
5364
5416
  if (s3 !== peg$FAILED) {
5365
5417
  while (s3 !== peg$FAILED) {
5366
5418
  s2.push(s3);
5367
- if (peg$c156.test(input.charAt(peg$currPos))) {
5419
+ if (peg$c157.test(input.charAt(peg$currPos))) {
5368
5420
  s3 = input.charAt(peg$currPos);
5369
5421
  peg$currPos++;
5370
5422
  }
5371
5423
  else {
5372
5424
  s3 = peg$FAILED;
5373
5425
  if (peg$silentFails === 0) {
5374
- peg$fail(peg$c157);
5426
+ peg$fail(peg$c158);
5375
5427
  }
5376
5428
  }
5377
5429
  }
@@ -5390,7 +5442,7 @@ function peg$parse(input, options) {
5390
5442
  }
5391
5443
  if (s1 !== peg$FAILED) {
5392
5444
  peg$savedPos = s0;
5393
- s1 = peg$c158(s1);
5445
+ s1 = peg$c159(s1);
5394
5446
  }
5395
5447
  s0 = s1;
5396
5448
  return s0;
@@ -5429,7 +5481,7 @@ function peg$parse(input, options) {
5429
5481
  }
5430
5482
  if (s5 !== peg$FAILED) {
5431
5483
  peg$savedPos = peg$currPos;
5432
- s6 = peg$c159(s1, s3);
5484
+ s6 = peg$c160(s1, s3);
5433
5485
  if (s6) {
5434
5486
  s6 = void 0;
5435
5487
  }
@@ -5504,7 +5556,7 @@ function peg$parse(input, options) {
5504
5556
  }
5505
5557
  if (s7 !== peg$FAILED) {
5506
5558
  peg$savedPos = s0;
5507
- s1 = peg$c160(s1, s3, s7);
5559
+ s1 = peg$c161(s1, s3, s7);
5508
5560
  s0 = s1;
5509
5561
  }
5510
5562
  else {
@@ -5577,7 +5629,7 @@ function peg$parse(input, options) {
5577
5629
  }
5578
5630
  if (s5 !== peg$FAILED) {
5579
5631
  peg$savedPos = peg$currPos;
5580
- s6 = peg$c161(s1, s3);
5632
+ s6 = peg$c162(s1, s3);
5581
5633
  if (s6) {
5582
5634
  s6 = void 0;
5583
5635
  }
@@ -5586,7 +5638,7 @@ function peg$parse(input, options) {
5586
5638
  }
5587
5639
  if (s6 !== peg$FAILED) {
5588
5640
  peg$savedPos = peg$currPos;
5589
- s7 = peg$c162(s1, s3);
5641
+ s7 = peg$c163(s1, s3);
5590
5642
  if (s7) {
5591
5643
  s7 = void 0;
5592
5644
  }
@@ -5597,7 +5649,7 @@ function peg$parse(input, options) {
5597
5649
  s8 = peg$parsetableContents();
5598
5650
  if (s8 !== peg$FAILED) {
5599
5651
  peg$savedPos = s0;
5600
- s1 = peg$c163(s1, s3, s8);
5652
+ s1 = peg$c164(s1, s3, s8);
5601
5653
  s0 = s1;
5602
5654
  }
5603
5655
  else {
@@ -5741,7 +5793,7 @@ function peg$parse(input, options) {
5741
5793
  }
5742
5794
  if (s6 !== peg$FAILED) {
5743
5795
  peg$savedPos = s0;
5744
- s1 = peg$c164(s1, s3, s5, s6);
5796
+ s1 = peg$c165(s1, s3, s5, s6);
5745
5797
  s0 = s1;
5746
5798
  }
5747
5799
  else {
@@ -5791,14 +5843,14 @@ function peg$parse(input, options) {
5791
5843
  s4 = peg$currPos;
5792
5844
  s5 = peg$parse_();
5793
5845
  if (s5 !== peg$FAILED) {
5794
- if (input.substr(peg$currPos, 2) === peg$c165) {
5795
- s6 = peg$c165;
5846
+ if (input.substr(peg$currPos, 2) === peg$c166) {
5847
+ s6 = peg$c166;
5796
5848
  peg$currPos += 2;
5797
5849
  }
5798
5850
  else {
5799
5851
  s6 = peg$FAILED;
5800
5852
  if (peg$silentFails === 0) {
5801
- peg$fail(peg$c166);
5853
+ peg$fail(peg$c167);
5802
5854
  }
5803
5855
  }
5804
5856
  if (s6 !== peg$FAILED) {
@@ -5821,7 +5873,7 @@ function peg$parse(input, options) {
5821
5873
  s10 = peg$parsenewline();
5822
5874
  if (s10 !== peg$FAILED) {
5823
5875
  peg$savedPos = s4;
5824
- s5 = peg$c89(s1, s8);
5876
+ s5 = peg$c90(s1, s8);
5825
5877
  s4 = s5;
5826
5878
  }
5827
5879
  else {
@@ -5858,14 +5910,14 @@ function peg$parse(input, options) {
5858
5910
  s4 = peg$currPos;
5859
5911
  s5 = peg$parse_();
5860
5912
  if (s5 !== peg$FAILED) {
5861
- if (input.substr(peg$currPos, 2) === peg$c165) {
5862
- s6 = peg$c165;
5913
+ if (input.substr(peg$currPos, 2) === peg$c166) {
5914
+ s6 = peg$c166;
5863
5915
  peg$currPos += 2;
5864
5916
  }
5865
5917
  else {
5866
5918
  s6 = peg$FAILED;
5867
5919
  if (peg$silentFails === 0) {
5868
- peg$fail(peg$c166);
5920
+ peg$fail(peg$c167);
5869
5921
  }
5870
5922
  }
5871
5923
  if (s6 !== peg$FAILED) {
@@ -5888,7 +5940,7 @@ function peg$parse(input, options) {
5888
5940
  s10 = peg$parsenewline();
5889
5941
  if (s10 !== peg$FAILED) {
5890
5942
  peg$savedPos = s4;
5891
- s5 = peg$c89(s1, s8);
5943
+ s5 = peg$c90(s1, s8);
5892
5944
  s4 = s5;
5893
5945
  }
5894
5946
  else {
@@ -5923,7 +5975,7 @@ function peg$parse(input, options) {
5923
5975
  }
5924
5976
  if (s3 !== peg$FAILED) {
5925
5977
  peg$savedPos = s0;
5926
- s1 = peg$c90(s1, s3);
5978
+ s1 = peg$c91(s1, s3);
5927
5979
  s0 = s1;
5928
5980
  }
5929
5981
  else {
@@ -5954,14 +6006,14 @@ function peg$parse(input, options) {
5954
6006
  s1 = s2;
5955
6007
  }
5956
6008
  if (s1 !== peg$FAILED) {
5957
- if (input.substr(peg$currPos, 6) === peg$c27) {
5958
- s2 = peg$c27;
6009
+ if (input.substr(peg$currPos, 6) === peg$c28) {
6010
+ s2 = peg$c28;
5959
6011
  peg$currPos += 6;
5960
6012
  }
5961
6013
  else {
5962
6014
  s2 = peg$FAILED;
5963
6015
  if (peg$silentFails === 0) {
5964
- peg$fail(peg$c28);
6016
+ peg$fail(peg$c29);
5965
6017
  }
5966
6018
  }
5967
6019
  if (s2 !== peg$FAILED) {
@@ -5981,7 +6033,7 @@ function peg$parse(input, options) {
5981
6033
  s6 = peg$parsealias_replacement_text();
5982
6034
  if (s6 !== peg$FAILED) {
5983
6035
  peg$savedPos = s0;
5984
- s1 = peg$c167(s1, s2, s4, s6);
6036
+ s1 = peg$c168(s1, s2, s4, s6);
5985
6037
  s0 = s1;
5986
6038
  }
5987
6039
  else {
@@ -6027,14 +6079,14 @@ function peg$parse(input, options) {
6027
6079
  s1 = s2;
6028
6080
  }
6029
6081
  if (s1 !== peg$FAILED) {
6030
- if (input.substr(peg$currPos, 7) === peg$c25) {
6031
- s2 = peg$c25;
6082
+ if (input.substr(peg$currPos, 7) === peg$c26) {
6083
+ s2 = peg$c26;
6032
6084
  peg$currPos += 7;
6033
6085
  }
6034
6086
  else {
6035
6087
  s2 = peg$FAILED;
6036
6088
  if (peg$silentFails === 0) {
6037
- peg$fail(peg$c26);
6089
+ peg$fail(peg$c27);
6038
6090
  }
6039
6091
  }
6040
6092
  if (s2 !== peg$FAILED) {
@@ -6044,25 +6096,25 @@ function peg$parse(input, options) {
6044
6096
  s5 = peg$parsestrictIdentifier();
6045
6097
  if (s5 === peg$FAILED) {
6046
6098
  s5 = peg$currPos;
6047
- if (peg$c168.test(input.charAt(peg$currPos))) {
6099
+ if (peg$c169.test(input.charAt(peg$currPos))) {
6048
6100
  s6 = input.charAt(peg$currPos);
6049
6101
  peg$currPos++;
6050
6102
  }
6051
6103
  else {
6052
6104
  s6 = peg$FAILED;
6053
6105
  if (peg$silentFails === 0) {
6054
- peg$fail(peg$c169);
6106
+ peg$fail(peg$c170);
6055
6107
  }
6056
6108
  }
6057
6109
  if (s6 !== peg$FAILED) {
6058
- if (input.substr(peg$currPos, 2) === peg$c170) {
6059
- s7 = peg$c170;
6110
+ if (input.substr(peg$currPos, 2) === peg$c171) {
6111
+ s7 = peg$c171;
6060
6112
  peg$currPos += 2;
6061
6113
  }
6062
6114
  else {
6063
6115
  s7 = peg$FAILED;
6064
6116
  if (peg$silentFails === 0) {
6065
- peg$fail(peg$c171);
6117
+ peg$fail(peg$c172);
6066
6118
  }
6067
6119
  }
6068
6120
  if (s7 !== peg$FAILED) {
@@ -6091,7 +6143,7 @@ function peg$parse(input, options) {
6091
6143
  s6 = peg$parsepod_configuration();
6092
6144
  if (s6 !== peg$FAILED) {
6093
6145
  peg$savedPos = s0;
6094
- s1 = peg$c172(s1, s2, s4, s6);
6146
+ s1 = peg$c173(s1, s2, s4, s6);
6095
6147
  s0 = s1;
6096
6148
  }
6097
6149
  else {
@@ -6125,6 +6177,58 @@ function peg$parse(input, options) {
6125
6177
  }
6126
6178
  return s0;
6127
6179
  }
6180
+ function peg$parseboundaryDirective() {
6181
+ var s0, s1, s2, s3, s4;
6182
+ s0 = peg$currPos;
6183
+ s1 = peg$currPos;
6184
+ s2 = peg$parse_();
6185
+ if (s2 !== peg$FAILED) {
6186
+ s1 = input.substring(s1, peg$currPos);
6187
+ }
6188
+ else {
6189
+ s1 = s2;
6190
+ }
6191
+ if (s1 !== peg$FAILED) {
6192
+ if (input.substr(peg$currPos, 9) === peg$c174) {
6193
+ s2 = peg$c174;
6194
+ peg$currPos += 9;
6195
+ }
6196
+ else {
6197
+ s2 = peg$FAILED;
6198
+ if (peg$silentFails === 0) {
6199
+ peg$fail(peg$c175);
6200
+ }
6201
+ }
6202
+ if (s2 !== peg$FAILED) {
6203
+ s3 = peg$parse_();
6204
+ if (s3 !== peg$FAILED) {
6205
+ s4 = peg$parsepod_configuration();
6206
+ if (s4 !== peg$FAILED) {
6207
+ peg$savedPos = s0;
6208
+ s1 = peg$c176(s1, s2, s4);
6209
+ s0 = s1;
6210
+ }
6211
+ else {
6212
+ peg$currPos = s0;
6213
+ s0 = peg$FAILED;
6214
+ }
6215
+ }
6216
+ else {
6217
+ peg$currPos = s0;
6218
+ s0 = peg$FAILED;
6219
+ }
6220
+ }
6221
+ else {
6222
+ peg$currPos = s0;
6223
+ s0 = peg$FAILED;
6224
+ }
6225
+ }
6226
+ else {
6227
+ peg$currPos = s0;
6228
+ s0 = peg$FAILED;
6229
+ }
6230
+ return s0;
6231
+ }
6128
6232
  function peg$parseparagraphBlockRaw() {
6129
6233
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
6130
6234
  s0 = peg$currPos;
@@ -6146,7 +6250,7 @@ function peg$parse(input, options) {
6146
6250
  s5 = peg$parsepod_configuration();
6147
6251
  if (s5 !== peg$FAILED) {
6148
6252
  peg$savedPos = peg$currPos;
6149
- s6 = peg$c173(s1, s2, s3, s5);
6253
+ s6 = peg$c177(s1, s2, s3, s5);
6150
6254
  if (s6) {
6151
6255
  s6 = void 0;
6152
6256
  }
@@ -6221,7 +6325,7 @@ function peg$parse(input, options) {
6221
6325
  }
6222
6326
  if (s7 !== peg$FAILED) {
6223
6327
  peg$savedPos = s0;
6224
- s1 = peg$c174(s1, s2, s3, s5, s7);
6328
+ s1 = peg$c178(s1, s2, s3, s5, s7);
6225
6329
  s0 = s1;
6226
6330
  }
6227
6331
  else {
@@ -6281,7 +6385,7 @@ function peg$parse(input, options) {
6281
6385
  s5 = peg$parsepod_configuration();
6282
6386
  if (s5 !== peg$FAILED) {
6283
6387
  peg$savedPos = peg$currPos;
6284
- s6 = peg$c175(s1, s2, s3, s5);
6388
+ s6 = peg$c179(s1, s2, s3, s5);
6285
6389
  if (s6) {
6286
6390
  s6 = void 0;
6287
6391
  }
@@ -6290,7 +6394,7 @@ function peg$parse(input, options) {
6290
6394
  }
6291
6395
  if (s6 !== peg$FAILED) {
6292
6396
  peg$savedPos = peg$currPos;
6293
- s7 = peg$c176(s1, s2, s3, s5);
6397
+ s7 = peg$c180(s1, s2, s3, s5);
6294
6398
  if (s7) {
6295
6399
  s7 = void 0;
6296
6400
  }
@@ -6301,7 +6405,7 @@ function peg$parse(input, options) {
6301
6405
  s8 = peg$parsetableContents();
6302
6406
  if (s8 !== peg$FAILED) {
6303
6407
  peg$savedPos = s0;
6304
- s1 = peg$c177(s1, s2, s3, s5, s8);
6408
+ s1 = peg$c181(s1, s2, s3, s5, s8);
6305
6409
  s0 = s1;
6306
6410
  }
6307
6411
  else {
@@ -6432,7 +6536,7 @@ function peg$parse(input, options) {
6432
6536
  }
6433
6537
  if (s6 !== peg$FAILED) {
6434
6538
  peg$savedPos = s0;
6435
- s1 = peg$c178(s1, s2, s3, s5, s6);
6539
+ s1 = peg$c182(s1, s2, s3, s5, s6);
6436
6540
  s0 = s1;
6437
6541
  }
6438
6542
  else {
@@ -6470,39 +6574,39 @@ function peg$parse(input, options) {
6470
6574
  var s0, s1, s2, s3, s4;
6471
6575
  s0 = peg$currPos;
6472
6576
  s1 = peg$currPos;
6473
- if (peg$c179.test(input.charAt(peg$currPos))) {
6577
+ if (peg$c183.test(input.charAt(peg$currPos))) {
6474
6578
  s2 = input.charAt(peg$currPos);
6475
6579
  peg$currPos++;
6476
6580
  }
6477
6581
  else {
6478
6582
  s2 = peg$FAILED;
6479
6583
  if (peg$silentFails === 0) {
6480
- peg$fail(peg$c180);
6584
+ peg$fail(peg$c184);
6481
6585
  }
6482
6586
  }
6483
6587
  if (s2 !== peg$FAILED) {
6484
6588
  s3 = [];
6485
- if (peg$c43.test(input.charAt(peg$currPos))) {
6589
+ if (peg$c44.test(input.charAt(peg$currPos))) {
6486
6590
  s4 = input.charAt(peg$currPos);
6487
6591
  peg$currPos++;
6488
6592
  }
6489
6593
  else {
6490
6594
  s4 = peg$FAILED;
6491
6595
  if (peg$silentFails === 0) {
6492
- peg$fail(peg$c44);
6596
+ peg$fail(peg$c45);
6493
6597
  }
6494
6598
  }
6495
6599
  if (s4 !== peg$FAILED) {
6496
6600
  while (s4 !== peg$FAILED) {
6497
6601
  s3.push(s4);
6498
- if (peg$c43.test(input.charAt(peg$currPos))) {
6602
+ if (peg$c44.test(input.charAt(peg$currPos))) {
6499
6603
  s4 = input.charAt(peg$currPos);
6500
6604
  peg$currPos++;
6501
6605
  }
6502
6606
  else {
6503
6607
  s4 = peg$FAILED;
6504
6608
  if (peg$silentFails === 0) {
6505
- peg$fail(peg$c44);
6609
+ peg$fail(peg$c45);
6506
6610
  }
6507
6611
  }
6508
6612
  }
@@ -6535,26 +6639,26 @@ function peg$parse(input, options) {
6535
6639
  var s0, s1;
6536
6640
  peg$silentFails++;
6537
6641
  s0 = [];
6538
- if (peg$c182.test(input.charAt(peg$currPos))) {
6642
+ if (peg$c186.test(input.charAt(peg$currPos))) {
6539
6643
  s1 = input.charAt(peg$currPos);
6540
6644
  peg$currPos++;
6541
6645
  }
6542
6646
  else {
6543
6647
  s1 = peg$FAILED;
6544
6648
  if (peg$silentFails === 0) {
6545
- peg$fail(peg$c183);
6649
+ peg$fail(peg$c187);
6546
6650
  }
6547
6651
  }
6548
6652
  while (s1 !== peg$FAILED) {
6549
6653
  s0.push(s1);
6550
- if (peg$c182.test(input.charAt(peg$currPos))) {
6654
+ if (peg$c186.test(input.charAt(peg$currPos))) {
6551
6655
  s1 = input.charAt(peg$currPos);
6552
6656
  peg$currPos++;
6553
6657
  }
6554
6658
  else {
6555
6659
  s1 = peg$FAILED;
6556
6660
  if (peg$silentFails === 0) {
6557
- peg$fail(peg$c183);
6661
+ peg$fail(peg$c187);
6558
6662
  }
6559
6663
  }
6560
6664
  }
@@ -6562,7 +6666,7 @@ function peg$parse(input, options) {
6562
6666
  if (s0 === peg$FAILED) {
6563
6667
  s1 = peg$FAILED;
6564
6668
  if (peg$silentFails === 0) {
6565
- peg$fail(peg$c181);
6669
+ peg$fail(peg$c185);
6566
6670
  }
6567
6671
  }
6568
6672
  return s0;
@@ -6571,26 +6675,26 @@ function peg$parse(input, options) {
6571
6675
  var s0, s1;
6572
6676
  peg$silentFails++;
6573
6677
  s0 = [];
6574
- if (peg$c182.test(input.charAt(peg$currPos))) {
6678
+ if (peg$c186.test(input.charAt(peg$currPos))) {
6575
6679
  s1 = input.charAt(peg$currPos);
6576
6680
  peg$currPos++;
6577
6681
  }
6578
6682
  else {
6579
6683
  s1 = peg$FAILED;
6580
6684
  if (peg$silentFails === 0) {
6581
- peg$fail(peg$c183);
6685
+ peg$fail(peg$c187);
6582
6686
  }
6583
6687
  }
6584
6688
  while (s1 !== peg$FAILED) {
6585
6689
  s0.push(s1);
6586
- if (peg$c182.test(input.charAt(peg$currPos))) {
6690
+ if (peg$c186.test(input.charAt(peg$currPos))) {
6587
6691
  s1 = input.charAt(peg$currPos);
6588
6692
  peg$currPos++;
6589
6693
  }
6590
6694
  else {
6591
6695
  s1 = peg$FAILED;
6592
6696
  if (peg$silentFails === 0) {
6593
- peg$fail(peg$c183);
6697
+ peg$fail(peg$c187);
6594
6698
  }
6595
6699
  }
6596
6700
  }
@@ -6598,7 +6702,7 @@ function peg$parse(input, options) {
6598
6702
  if (s0 === peg$FAILED) {
6599
6703
  s1 = peg$FAILED;
6600
6704
  if (peg$silentFails === 0) {
6601
- peg$fail(peg$c184);
6705
+ peg$fail(peg$c188);
6602
6706
  }
6603
6707
  }
6604
6708
  return s0;
@@ -6618,9 +6722,11 @@ function peg$parse(input, options) {
6618
6722
  }
6619
6723
  function isSupportedBlockName(name) {
6620
6724
  return [
6725
+ 'boundary',
6621
6726
  'code',
6622
6727
  'comment',
6623
6728
  'data',
6729
+ 'data-table',
6624
6730
  'defn',
6625
6731
  'formula',
6626
6732
  'head',