@podlite/schema 0.0.51 → 0.0.52

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 (95) hide show
  1. package/CHANGELOG.podlite +18 -0
  2. package/LICENSE +1 -1
  3. package/esm/ast-helpers.js.map +1 -1
  4. package/esm/ast-inerator.js.map +1 -1
  5. package/esm/blocks-helpers.js.map +1 -1
  6. package/esm/exportAny.d.ts +2 -2
  7. package/esm/exportAny.js.map +1 -1
  8. package/esm/exportHtml.d.ts +1 -1
  9. package/esm/exportHtml.js +16 -0
  10. package/esm/exportHtml.js.map +1 -1
  11. package/esm/exportMarkdown.d.ts +1 -1
  12. package/esm/exportMarkdown.js +2 -2
  13. package/esm/exportMarkdown.js.map +1 -1
  14. package/esm/grammar.js +1133 -562
  15. package/esm/grammar.js.map +1 -1
  16. package/esm/grammarfc.js +1300 -1065
  17. package/esm/grammarfc.js.map +1 -1
  18. package/esm/helpers/config.d.ts +1 -1
  19. package/esm/helpers/config.js.map +1 -1
  20. package/esm/helpers/configPropagation.d.ts +2 -2
  21. package/esm/helpers/configPropagation.js.map +1 -1
  22. package/esm/helpers/corePlugins.js.map +1 -1
  23. package/esm/helpers/handlers.js.map +1 -1
  24. package/esm/helpers/headingNumbering.d.ts +2 -2
  25. package/esm/helpers/headingNumbering.js.map +1 -1
  26. package/esm/helpers/ids.js.map +1 -1
  27. package/esm/helpers/itemNumbering.d.ts +2 -2
  28. package/esm/helpers/itemNumbering.js.map +1 -1
  29. package/esm/helpers/makeInterator.js.map +1 -1
  30. package/esm/helpers/makeQuery.d.ts +2 -2
  31. package/esm/helpers/makeQuery.js.map +1 -1
  32. package/esm/helpers/makeTransformer.js.map +1 -1
  33. package/esm/helpers/parseAttributes.js.map +1 -1
  34. package/esm/helpers/plugins.js.map +1 -1
  35. package/esm/image-base.js.map +1 -1
  36. package/esm/index.d.ts +7 -6
  37. package/esm/index.js +3 -0
  38. package/esm/index.js.map +1 -1
  39. package/esm/pluggableParser.js.map +1 -1
  40. package/esm/plugin-clean-location.js.map +1 -1
  41. package/esm/plugin-data-table.js.map +1 -1
  42. package/esm/plugin-defn-fill-term.js.map +1 -1
  43. package/esm/plugin-group-defn.js +1 -1
  44. package/esm/plugin-group-defn.js.map +1 -1
  45. package/esm/plugin-group-items.js.map +1 -1
  46. package/esm/plugin-heading.js.map +1 -1
  47. package/esm/plugin-items.js.map +1 -1
  48. package/esm/plugin-set.d.ts +2 -0
  49. package/esm/plugin-set.js +54 -0
  50. package/esm/plugin-set.js.map +1 -0
  51. package/esm/plugin-tables.js +5 -2
  52. package/esm/plugin-tables.js.map +1 -1
  53. package/esm/plugin-vmargin.js.map +1 -1
  54. package/esm/query-helpers.d.ts +2 -2
  55. package/esm/query-helpers.js.map +1 -1
  56. package/esm/selectors.d.ts +6 -6
  57. package/esm/selectors.js.map +1 -1
  58. package/esm/types.d.ts +9 -8
  59. package/esm/version.d.ts +1 -1
  60. package/esm/version.js +1 -1
  61. package/esm/writer.d.ts +0 -1
  62. package/esm/writer.js.map +1 -1
  63. package/lib/ast-inerator.js +2 -2
  64. package/lib/exportAny.d.ts +2 -2
  65. package/lib/exportHtml.d.ts +1 -1
  66. package/lib/exportHtml.js +16 -0
  67. package/lib/exportMarkdown.d.ts +1 -1
  68. package/lib/exportMarkdown.js +2 -2
  69. package/lib/grammar.js +1133 -562
  70. package/lib/grammarfc.js +1300 -1065
  71. package/lib/helpers/config.d.ts +1 -1
  72. package/lib/helpers/configPropagation.d.ts +2 -2
  73. package/lib/helpers/headingNumbering.d.ts +2 -2
  74. package/lib/helpers/itemNumbering.d.ts +2 -2
  75. package/lib/helpers/makeQuery.d.ts +2 -2
  76. package/lib/helpers/makeQuery.js +2 -2
  77. package/lib/helpers/makeTransformer.js +3 -3
  78. package/lib/helpers/parseAttributes.js +23 -10
  79. package/lib/index.d.ts +7 -6
  80. package/lib/index.js +35 -17
  81. package/lib/plugin-formatting-codes.js +22 -8
  82. package/lib/plugin-group-defn.js +1 -1
  83. package/lib/plugin-set.d.ts +2 -0
  84. package/lib/plugin-set.js +56 -0
  85. package/lib/plugin-tables.js +12 -10
  86. package/lib/query-helpers.d.ts +2 -2
  87. package/lib/selectors.d.ts +6 -6
  88. package/lib/types.d.ts +9 -8
  89. package/lib/version.d.ts +1 -1
  90. package/lib/version.js +1 -1
  91. package/lib/writer.d.ts +0 -1
  92. package/lib/writer.js +22 -8
  93. package/package.json +7 -3
  94. package/schema/AstTree.json +200 -382
  95. package/schema/PodliteDocument.json +200 -382
package/esm/grammar.js CHANGED
@@ -113,31 +113,31 @@ function peg$parse(input, options) {
113
113
  type: 'ambient',
114
114
  location: location()
115
115
  };
116
- }, peg$c6 = /^[ \xA0\u2001\t\f\u2008]/, peg$c7 = peg$classExpectation([" ", "\xA0", "\u2001", "\t", "\f", "\u2008"], false, false), peg$c8 = /^[ \t\f]/, peg$c9 = peg$classExpectation([" ", "\t", "\f"], false, false), peg$c10 = /^[\n\r]/, peg$c11 = peg$classExpectation(["\n", "\r"], false, false), peg$c12 = function (text) { return text; }, peg$c13 = /^[^\n\r]/, peg$c14 = peg$classExpectation(["\n", "\r"], true, false), peg$c15 = "\n", peg$c16 = peg$literalExpectation("\n", false), peg$c17 = "\r", peg$c18 = peg$literalExpectation("\r", false), peg$c19 = function () { return { type: 'blankline' }; }, peg$c20 = "=begin ", peg$c21 = peg$literalExpectation("=begin ", false), peg$c22 = "=end ", peg$c23 = peg$literalExpectation("=end ", false), peg$c24 = "=for ", peg$c25 = peg$literalExpectation("=for ", false), peg$c26 = "=config", peg$c27 = peg$literalExpectation("=config", false), peg$c28 = "=alias", peg$c29 = peg$literalExpectation("=alias", false), peg$c30 = function (name) { return isSupportedBlockName(name); }, peg$c31 = function (name) { return name; }, peg$c32 = "=", peg$c33 = peg$literalExpectation("=", false), peg$c34 = peg$otherExpectation("text"), peg$c35 = function () { return text(); }, peg$c36 = function () { 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) {
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 = /^[!]/, peg$c54 = peg$classExpectation(["!"], false, false), peg$c55 = "allow", peg$c56 = peg$literalExpectation("allow", false), peg$c57 = "<", peg$c58 = peg$literalExpectation("<", false), peg$c59 = ">", peg$c60 = peg$literalExpectation(">", false), peg$c61 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c62 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c63 = function (isFalse, key, value) { return { name: 'allow', ...value, ...(isFalse ? { isFalse: true } : {}) }; }, peg$c64 = function (i) { return i; }, peg$c65 = function (all) { return all; }, peg$c66 = function (res) { return [res]; }, peg$c67 = function () { return []; }, peg$c68 = "{", peg$c69 = peg$literalExpectation("{", false), peg$c70 = "}", peg$c71 = peg$literalExpectation("}", false), peg$c72 = function (isFalse, key, hash) { return { value: hash, type: "map" }; }, peg$c73 = "[", peg$c74 = peg$literalExpectation("[", false), peg$c75 = function (isFalse, key, array) { return array; }, peg$c76 = "]", peg$c77 = peg$literalExpectation("]", false), peg$c78 = function (isFalse, key) { return [text()]; }, peg$c79 = function (isFalse, key, array) {
117
117
  return {
118
118
  value: array,
119
119
  type: "array"
120
120
  };
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) {
121
+ }, peg$c80 = function (isFalse, key, array) { return { value: array, type: "array" }; }, peg$c81 = function (isFalse, key, array) { return { value: array, type: "string" }; }, peg$c82 = function (isFalse, key) { return { value: [], type: "array" }; }, peg$c83 = "(", peg$c84 = peg$literalExpectation("(", false), peg$c85 = 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$c84 = ")", peg$c85 = peg$literalExpectation(")", false), peg$c86 = function (isFalse, key) { return { value: text() }; }, peg$c87 = function (isFalse, key, res) {
126
+ }, peg$c86 = ")", peg$c87 = peg$literalExpectation(")", false), peg$c88 = function (isFalse, key) { return { value: text() }; }, peg$c89 = function (isFalse, key, res) {
127
127
  return {
128
128
  type: "value",
129
129
  ...res
130
130
  };
131
- }, peg$c88 = function (isFalse, key) {
131
+ }, peg$c90 = function (isFalse, key) {
132
132
  return {
133
133
  value: !isFalse,
134
134
  type: "boolean"
135
135
  };
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) {
136
+ }, peg$c91 = function (isFalse, key, value) { return { name: key, ...value, ...(isFalse && value.type !== 'boolean' ? { isFalse: true } : {}) }; }, peg$c92 = function (first, rest) { return rest; }, peg$c93 = function (first, cont) { return flattenDeep([...first, ...cont]); }, peg$c94 = /^[^'"]/, peg$c95 = peg$classExpectation(["'", "\""], true, false), peg$c96 = function (text) { return text; }, peg$c97 = /^[0-9]/, peg$c98 = peg$classExpectation([["0", "9"]], false, false), peg$c99 = /^[\-+]/, peg$c100 = peg$classExpectation(["-", "+"], false, false), peg$c101 = "True", peg$c102 = peg$literalExpectation("True", false), peg$c103 = function () { return true; }, peg$c104 = "False", peg$c105 = peg$literalExpectation("False", false), peg$c106 = function () { return false; }, peg$c107 = ".", peg$c108 = peg$literalExpectation(".", false), peg$c109 = /^[eE]/, peg$c110 = peg$classExpectation(["e", "E"], false, false), peg$c111 = /^["]/, peg$c112 = peg$classExpectation(["\""], false, false), peg$c113 = /^[^"]/, peg$c114 = peg$classExpectation(["\""], true, false), peg$c115 = /^[']/, peg$c116 = peg$classExpectation(["'"], false, false), peg$c117 = /^[^']/, peg$c118 = peg$classExpectation(["'"], true, false), peg$c119 = function (numberFloat) { return parseFloat(numberFloat); }, peg$c120 = function (number) { return parseInt(number, 10); }, peg$c121 = 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$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) {
140
+ }, peg$c122 = function (vmargin, name, config, margins, ename) { return vmargin.length === margins.length && name === ename; }, peg$c123 = function (vmargin, name, config, margins, line) { return exludeVMargin(vmargin, `${margins}${line}`); }, peg$c124 = function (vmargin, name, config, content, vmargin2, ename) { return name === ename; }, peg$c125 = 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$c124 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c125 = function (vmargin, name, config, content, vmargin2, res) {
148
+ }, peg$c126 = function (vmargin, name, config, content, vmargin2, res) { return true || vmargin === vmargin2; }, peg$c127 = 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$c126 = /^[\-+=_|]/, peg$c127 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c128 = function () { return { type: 'separator', text: text() }; }, peg$c129 = function () { return options.isDelimited; }, peg$c130 = function () {
155
+ }, peg$c128 = /^[\-+=_|]/, peg$c129 = peg$classExpectation(["-", "+", "=", "_", "|"], false, false), peg$c130 = function () { return { type: 'separator', text: text() }; }, peg$c131 = function () { return options.isDelimited; }, peg$c132 = function () {
156
156
  return {
157
157
  type: 'separator',
158
158
  text: text()
159
159
  };
160
- }, peg$c131 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c132 = function () {
160
+ }, peg$c133 = function (t) { return { name: 'row', type: 'text', value: t }; }, peg$c134 = function () {
161
161
  // reset separator count and its accum
162
162
  options.separators = [];
163
163
  return true;
164
- }, peg$c133 = function (head, t) {
164
+ }, peg$c135 = function (head, t) {
165
165
  options.separators.push(t.text);
166
166
  return t;
167
- }, peg$c134 = function (head, separator, rowtext, t) {
167
+ }, peg$c136 = function (head, separator, rowtext, t) {
168
168
  options.separators.push(t.text);
169
169
  return t;
170
- }, peg$c135 = function (head, separator, rowtext, bseparator) {
170
+ }, peg$c137 = 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$c136 = function (head, separator, singleRow) { return [singleRow]; }, peg$c137 = function (head, separator, rest) {
179
+ }, peg$c138 = function (head, separator, singleRow) { return [singleRow]; }, peg$c139 = 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$c138 = function (head, separator, rest) {
186
+ }, peg$c140 = 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$c139 = function (rowtest, bseparator) {
196
+ }, peg$c141 = 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$c140 = function (rest) {
205
+ }, peg$c142 = function (rest) {
206
206
  return [...flattenDeep(rest)];
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) {
207
+ }, peg$c143 = function (vmargin, name, config) { return name === 'table'; }, peg$c144 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c145 = function (vmargin, name, config, nodes) { return nodes; }, peg$c146 = function (vmargin, name, config, content) { return content.some(n => n && (n.name === 'row' || n.name === 'cell')); }, peg$c147 = 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$c146 = function (vmargin, name, config, content, vmargin2, res) {
214
+ }, peg$c148 = 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$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) {
221
+ }, peg$c149 = function (vmargin, name, config) { options.isDelimited = true; return true; }, peg$c150 = function (vmargin, name, config, t) { return t; }, peg$c151 = 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$c150 = function (vmargin, name, config, content, vmargin2, res) {
228
+ }, peg$c152 = 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$c151 = function (vmargin, name, config, nodes) { return nodes; }, peg$c152 = function (vmargin, name, config, tvmargin, text) {
235
+ }, peg$c153 = function (vmargin, name, config, nodes) { return nodes; }, peg$c154 = 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$c153 = function (vmargin, name, config, content, vmargin2, ename) {
251
+ }, peg$c155 = 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$c154 = function (vmargin, name, config, content, vmargin2, res) {
258
+ }, peg$c156 = function (vmargin, name, config, content, vmargin2, res) {
259
259
  return {
260
260
  ...res,
261
261
  config,
262
262
  location: location(),
263
263
  };
264
- }, peg$c155 = function () {
264
+ }, peg$c157 = 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$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) {
277
+ }, peg$c158 = function () { return { empty: 1 }; }, peg$c159 = /^[s]/, peg$c160 = peg$classExpectation(["s"], false, false), peg$c161 = function (line) { return { text: text(), type: "ambient1" }; }, peg$c162 = 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$c161 = function (vmargin, name, content) {
281
+ }, peg$c163 = 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$c162 = function (vmargin, name) { return name === 'table'; }, peg$c163 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c164 = function (vmargin, name, content) {
290
+ }, peg$c164 = function (vmargin, name) { return name === 'table'; }, peg$c165 = function (vmargin, name) { options.isDelimited = false; return true; }, peg$c166 = 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$c165 = function (vmargin, name, first_line, content_rest) {
300
+ }, peg$c167 = 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,21 +320,51 @@ function peg$parse(input, options) {
320
320
  name,
321
321
  location: location()
322
322
  };
323
- }, peg$c166 = "= ", peg$c167 = peg$literalExpectation("= ", false), peg$c168 = function (vmargin, marker, name, replacement) {
323
+ }, peg$c168 = "= ", peg$c169 = peg$literalExpectation("= ", false), peg$c170 = function (attrs) { return { kind: 'attrs', attrs }; }, peg$c171 = function (name, value) { return { kind: 'alias', name, value }; }, peg$c172 = function (v) { return { kind: 'value', value: v }; }, peg$c173 = function (seg) { return seg; }, peg$c174 = "=set", peg$c175 = peg$literalExpectation("=set", false), peg$c176 = function (vmargin, first, cont) {
324
+ const items = [];
325
+ let pending = null;
326
+ const flush = () => {
327
+ if (!pending)
328
+ return;
329
+ const value = pending.parts.map(s => s.trim()).filter(s => s.length).join(' ');
330
+ items.push({ name: pending.name, value, type: 'string' });
331
+ pending = null;
332
+ };
333
+ for (const seg of [first, ...cont]) {
334
+ if (seg.kind === 'attrs') {
335
+ flush();
336
+ items.push(...seg.attrs);
337
+ }
338
+ else if (seg.kind === 'alias') {
339
+ flush();
340
+ pending = { name: seg.name, parts: [seg.value] };
341
+ }
342
+ else if (seg.kind === 'value' && pending) {
343
+ pending.parts.push(seg.value);
344
+ }
345
+ }
346
+ flush();
347
+ return {
348
+ type: 'set',
349
+ config: items,
350
+ margin: vmargin,
351
+ location: location()
352
+ };
353
+ }, peg$c177 = function (vmargin, marker, name, replacement) {
324
354
  return {
325
355
  name,
326
356
  type: 'alias',
327
357
  replacement,
328
358
  margin: vmargin
329
359
  };
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) {
360
+ }, peg$c178 = /^[A-Z]/, peg$c179 = peg$classExpectation([["A", "Z"]], false, false), peg$c180 = "<>", peg$c181 = peg$literalExpectation("<>", false), peg$c182 = function (vmargin, marker, name, config) {
331
361
  return {
332
362
  name,
333
363
  type: 'config',
334
364
  config,
335
365
  margin: vmargin
336
366
  };
337
- }, peg$c174 = "=boundary", peg$c175 = peg$literalExpectation("=boundary", false), peg$c176 = function (vmargin, marker, config) {
367
+ }, peg$c183 = "=boundary", peg$c184 = peg$literalExpectation("=boundary", false), peg$c185 = function (vmargin, marker, config) {
338
368
  return {
339
369
  name: 'boundary',
340
370
  type: 'block',
@@ -343,11 +373,11 @@ function peg$parse(input, options) {
343
373
  margin: vmargin,
344
374
  location: location()
345
375
  };
346
- }, peg$c177 = function (vmargin, marker, name, config) {
376
+ }, peg$c186 = function (vmargin, marker, name, config) {
347
377
  return ((name.match(/code|comment|formula|output|input|markdown|picture|toc|data/))
348
378
  ||
349
379
  isNamedBlock(name));
350
- }, peg$c178 = function (vmargin, marker, name, config, content) {
380
+ }, peg$c187 = function (vmargin, marker, name, config, content) {
351
381
  return {
352
382
  type: 'block',
353
383
  content: content === "" ? [] : [{ type: 'verbatim', value: content }],
@@ -356,7 +386,7 @@ function peg$parse(input, options) {
356
386
  config,
357
387
  location: location()
358
388
  };
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) {
389
+ }, peg$c188 = function (vmargin, marker, name, config) { return name === 'table'; }, peg$c189 = function (vmargin, marker, name, config) { options.isDelimited = false; return true; }, peg$c190 = function (vmargin, marker, name, config, content) {
360
390
  return {
361
391
  type: 'block',
362
392
  content: content === "" ? [] : content,
@@ -365,7 +395,7 @@ function peg$parse(input, options) {
365
395
  config,
366
396
  location: location()
367
397
  };
368
- }, peg$c182 = function (vmargin, marker, name, config, content) {
398
+ }, peg$c191 = function (vmargin, marker, name, config, content) {
369
399
  return {
370
400
  type: 'block',
371
401
  content: content === "" ? []
@@ -388,7 +418,7 @@ function peg$parse(input, options) {
388
418
  config,
389
419
  location: location()
390
420
  };
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;
421
+ }, peg$c192 = /^[a-zA-Z]/, peg$c193 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false), peg$c194 = peg$otherExpectation("whitespace"), peg$c195 = /^[\r\n \t\f]/, peg$c196 = peg$classExpectation(["\r", "\n", " ", "\t", "\f"], false, false), peg$c197 = 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;
392
422
  if ("startRule" in options) {
393
423
  if (!(options.startRule in peg$startRuleFunctions)) {
394
424
  throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
@@ -550,182 +580,185 @@ function peg$parse(input, options) {
550
580
  if (s0 === peg$FAILED) {
551
581
  s0 = peg$parseparagraphBlock();
552
582
  if (s0 === peg$FAILED) {
553
- s0 = peg$parsealiasDirective();
583
+ s0 = peg$parsesetDirective();
554
584
  if (s0 === peg$FAILED) {
555
- s0 = peg$parseconfigDirective();
585
+ s0 = peg$parsealiasDirective();
556
586
  if (s0 === peg$FAILED) {
557
- s0 = peg$parseboundaryDirective();
587
+ s0 = peg$parseconfigDirective();
558
588
  if (s0 === peg$FAILED) {
559
- s0 = peg$parseabbreviatedBlockRaw();
589
+ s0 = peg$parseboundaryDirective();
560
590
  if (s0 === peg$FAILED) {
561
- s0 = peg$parseabbreviatedBlockTable();
591
+ s0 = peg$parseabbreviatedBlockRaw();
562
592
  if (s0 === peg$FAILED) {
563
- s0 = peg$parseabbreviatedBlock();
593
+ s0 = peg$parseabbreviatedBlockTable();
564
594
  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();
576
- if (s2 === peg$FAILED) {
577
- s2 = peg$parseblankline();
595
+ s0 = peg$parseabbreviatedBlock();
596
+ if (s0 === peg$FAILED) {
597
+ s0 = peg$currPos;
598
+ peg$savedPos = peg$currPos;
599
+ s1 = peg$c2();
600
+ if (s1) {
601
+ s1 = void 0;
602
+ }
603
+ else {
604
+ s1 = peg$FAILED;
605
+ }
606
+ if (s1 !== peg$FAILED) {
607
+ s2 = peg$parsetextBlock();
578
608
  if (s2 === peg$FAILED) {
579
- s2 = peg$parseerror_para();
609
+ s2 = peg$parseblankline();
610
+ if (s2 === peg$FAILED) {
611
+ s2 = peg$parseerror_para();
612
+ }
613
+ }
614
+ if (s2 !== peg$FAILED) {
615
+ peg$savedPos = s0;
616
+ s1 = peg$c3(s2);
617
+ s0 = s1;
618
+ }
619
+ else {
620
+ peg$currPos = s0;
621
+ s0 = peg$FAILED;
580
622
  }
581
- }
582
- if (s2 !== peg$FAILED) {
583
- peg$savedPos = s0;
584
- s1 = peg$c3(s2);
585
- s0 = s1;
586
623
  }
587
624
  else {
588
625
  peg$currPos = s0;
589
626
  s0 = peg$FAILED;
590
627
  }
591
- }
592
- else {
593
- peg$currPos = s0;
594
- s0 = peg$FAILED;
595
- }
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;
628
+ if (s0 === peg$FAILED) {
629
+ s0 = peg$currPos;
630
+ s1 = peg$currPos;
631
+ s2 = [];
632
+ s3 = peg$currPos;
633
+ s4 = peg$currPos;
634
+ peg$silentFails++;
635
+ s5 = peg$currPos;
636
+ s6 = peg$parsemarkers();
637
+ if (s6 !== peg$FAILED) {
638
+ s7 = peg$parsestrictIdentifier();
639
+ if (s7 !== peg$FAILED) {
640
+ s6 = [s6, s7];
641
+ s5 = s6;
642
+ }
643
+ else {
644
+ peg$currPos = s5;
645
+ s5 = peg$FAILED;
646
+ }
610
647
  }
611
648
  else {
612
649
  peg$currPos = s5;
613
650
  s5 = peg$FAILED;
614
651
  }
615
- }
616
- else {
617
- peg$currPos = s5;
618
- s5 = peg$FAILED;
619
- }
620
- if (s5 === peg$FAILED) {
621
- s5 = peg$parsemarkerAbbreviatedBlock();
622
- }
623
- peg$silentFails--;
624
- if (s5 === peg$FAILED) {
625
- s4 = void 0;
626
- }
627
- else {
628
- peg$currPos = s4;
629
- s4 = peg$FAILED;
630
- }
631
- if (s4 !== peg$FAILED) {
632
- if (input.length > peg$currPos) {
633
- s5 = input.charAt(peg$currPos);
634
- peg$currPos++;
652
+ if (s5 === peg$FAILED) {
653
+ s5 = peg$parsemarkerAbbreviatedBlock();
654
+ }
655
+ peg$silentFails--;
656
+ if (s5 === peg$FAILED) {
657
+ s4 = void 0;
635
658
  }
636
659
  else {
637
- s5 = peg$FAILED;
638
- if (peg$silentFails === 0) {
639
- peg$fail(peg$c4);
640
- }
660
+ peg$currPos = s4;
661
+ s4 = peg$FAILED;
641
662
  }
642
- if (s5 !== peg$FAILED) {
643
- s4 = [s4, s5];
644
- s3 = s4;
663
+ if (s4 !== peg$FAILED) {
664
+ if (input.length > peg$currPos) {
665
+ s5 = input.charAt(peg$currPos);
666
+ peg$currPos++;
667
+ }
668
+ else {
669
+ s5 = peg$FAILED;
670
+ if (peg$silentFails === 0) {
671
+ peg$fail(peg$c4);
672
+ }
673
+ }
674
+ if (s5 !== peg$FAILED) {
675
+ s4 = [s4, s5];
676
+ s3 = s4;
677
+ }
678
+ else {
679
+ peg$currPos = s3;
680
+ s3 = peg$FAILED;
681
+ }
645
682
  }
646
683
  else {
647
684
  peg$currPos = s3;
648
685
  s3 = peg$FAILED;
649
686
  }
650
- }
651
- else {
652
- peg$currPos = s3;
653
- s3 = peg$FAILED;
654
- }
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;
687
+ if (s3 !== peg$FAILED) {
688
+ while (s3 !== peg$FAILED) {
689
+ s2.push(s3);
690
+ s3 = peg$currPos;
691
+ s4 = peg$currPos;
692
+ peg$silentFails++;
693
+ s5 = peg$currPos;
694
+ s6 = peg$parsemarkers();
695
+ if (s6 !== peg$FAILED) {
696
+ s7 = peg$parsestrictIdentifier();
697
+ if (s7 !== peg$FAILED) {
698
+ s6 = [s6, s7];
699
+ s5 = s6;
700
+ }
701
+ else {
702
+ peg$currPos = s5;
703
+ s5 = peg$FAILED;
704
+ }
668
705
  }
669
706
  else {
670
707
  peg$currPos = s5;
671
708
  s5 = peg$FAILED;
672
709
  }
673
- }
674
- else {
675
- peg$currPos = s5;
676
- s5 = peg$FAILED;
677
- }
678
- if (s5 === peg$FAILED) {
679
- s5 = peg$parsemarkerAbbreviatedBlock();
680
- }
681
- peg$silentFails--;
682
- if (s5 === peg$FAILED) {
683
- s4 = void 0;
684
- }
685
- else {
686
- peg$currPos = s4;
687
- s4 = peg$FAILED;
688
- }
689
- if (s4 !== peg$FAILED) {
690
- if (input.length > peg$currPos) {
691
- s5 = input.charAt(peg$currPos);
692
- peg$currPos++;
710
+ if (s5 === peg$FAILED) {
711
+ s5 = peg$parsemarkerAbbreviatedBlock();
712
+ }
713
+ peg$silentFails--;
714
+ if (s5 === peg$FAILED) {
715
+ s4 = void 0;
693
716
  }
694
717
  else {
695
- s5 = peg$FAILED;
696
- if (peg$silentFails === 0) {
697
- peg$fail(peg$c4);
698
- }
718
+ peg$currPos = s4;
719
+ s4 = peg$FAILED;
699
720
  }
700
- if (s5 !== peg$FAILED) {
701
- s4 = [s4, s5];
702
- s3 = s4;
721
+ if (s4 !== peg$FAILED) {
722
+ if (input.length > peg$currPos) {
723
+ s5 = input.charAt(peg$currPos);
724
+ peg$currPos++;
725
+ }
726
+ else {
727
+ s5 = peg$FAILED;
728
+ if (peg$silentFails === 0) {
729
+ peg$fail(peg$c4);
730
+ }
731
+ }
732
+ if (s5 !== peg$FAILED) {
733
+ s4 = [s4, s5];
734
+ s3 = s4;
735
+ }
736
+ else {
737
+ peg$currPos = s3;
738
+ s3 = peg$FAILED;
739
+ }
703
740
  }
704
741
  else {
705
742
  peg$currPos = s3;
706
743
  s3 = peg$FAILED;
707
744
  }
708
745
  }
709
- else {
710
- peg$currPos = s3;
711
- s3 = peg$FAILED;
712
- }
713
746
  }
747
+ else {
748
+ s2 = peg$FAILED;
749
+ }
750
+ if (s2 !== peg$FAILED) {
751
+ s1 = input.substring(s1, peg$currPos);
752
+ }
753
+ else {
754
+ s1 = s2;
755
+ }
756
+ if (s1 !== peg$FAILED) {
757
+ peg$savedPos = s0;
758
+ s1 = peg$c5();
759
+ }
760
+ s0 = s1;
714
761
  }
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;
729
762
  }
730
763
  }
731
764
  }
@@ -1823,7 +1856,7 @@ function peg$parse(input, options) {
1823
1856
  return s0;
1824
1857
  }
1825
1858
  function peg$parseallow_attribute() {
1826
- var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
1859
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
1827
1860
  s0 = peg$currPos;
1828
1861
  s1 = peg$parse_();
1829
1862
  if (s1 !== peg$FAILED) {
@@ -1838,9 +1871,9 @@ function peg$parse(input, options) {
1838
1871
  }
1839
1872
  }
1840
1873
  if (s2 !== peg$FAILED) {
1841
- if (input.substr(peg$currPos, 5) === peg$c53) {
1842
- s3 = peg$c53;
1843
- peg$currPos += 5;
1874
+ if (peg$c53.test(input.charAt(peg$currPos))) {
1875
+ s3 = input.charAt(peg$currPos);
1876
+ peg$currPos++;
1844
1877
  }
1845
1878
  else {
1846
1879
  s3 = peg$FAILED;
@@ -1848,70 +1881,134 @@ function peg$parse(input, options) {
1848
1881
  peg$fail(peg$c54);
1849
1882
  }
1850
1883
  }
1884
+ if (s3 === peg$FAILED) {
1885
+ s3 = null;
1886
+ }
1851
1887
  if (s3 !== peg$FAILED) {
1852
- s4 = peg$currPos;
1853
- if (input.charCodeAt(peg$currPos) === 60) {
1854
- s5 = peg$c55;
1855
- peg$currPos++;
1888
+ if (input.substr(peg$currPos, 5) === peg$c55) {
1889
+ s4 = peg$c55;
1890
+ peg$currPos += 5;
1856
1891
  }
1857
1892
  else {
1858
- s5 = peg$FAILED;
1893
+ s4 = peg$FAILED;
1859
1894
  if (peg$silentFails === 0) {
1860
1895
  peg$fail(peg$c56);
1861
1896
  }
1862
1897
  }
1863
- if (s5 !== peg$FAILED) {
1864
- s6 = peg$parse_();
1898
+ if (s4 !== peg$FAILED) {
1899
+ s5 = peg$currPos;
1900
+ if (input.charCodeAt(peg$currPos) === 60) {
1901
+ s6 = peg$c57;
1902
+ peg$currPos++;
1903
+ }
1904
+ else {
1905
+ s6 = peg$FAILED;
1906
+ if (peg$silentFails === 0) {
1907
+ peg$fail(peg$c58);
1908
+ }
1909
+ }
1865
1910
  if (s6 !== peg$FAILED) {
1866
- s7 = peg$parsearray_codes();
1911
+ s7 = peg$parse_();
1867
1912
  if (s7 !== peg$FAILED) {
1868
- s8 = peg$parse_();
1913
+ s8 = peg$parsearray_codes();
1869
1914
  if (s8 !== peg$FAILED) {
1915
+ s9 = peg$parse_();
1916
+ if (s9 !== peg$FAILED) {
1917
+ if (input.charCodeAt(peg$currPos) === 62) {
1918
+ s10 = peg$c59;
1919
+ peg$currPos++;
1920
+ }
1921
+ else {
1922
+ s10 = peg$FAILED;
1923
+ if (peg$silentFails === 0) {
1924
+ peg$fail(peg$c60);
1925
+ }
1926
+ }
1927
+ if (s10 !== peg$FAILED) {
1928
+ peg$savedPos = s5;
1929
+ s6 = peg$c61(s3, s4, s8);
1930
+ s5 = s6;
1931
+ }
1932
+ else {
1933
+ peg$currPos = s5;
1934
+ s5 = peg$FAILED;
1935
+ }
1936
+ }
1937
+ else {
1938
+ peg$currPos = s5;
1939
+ s5 = peg$FAILED;
1940
+ }
1941
+ }
1942
+ else {
1943
+ peg$currPos = s5;
1944
+ s5 = peg$FAILED;
1945
+ }
1946
+ }
1947
+ else {
1948
+ peg$currPos = s5;
1949
+ s5 = peg$FAILED;
1950
+ }
1951
+ }
1952
+ else {
1953
+ peg$currPos = s5;
1954
+ s5 = peg$FAILED;
1955
+ }
1956
+ if (s5 === peg$FAILED) {
1957
+ s5 = peg$currPos;
1958
+ if (input.charCodeAt(peg$currPos) === 60) {
1959
+ s6 = peg$c57;
1960
+ peg$currPos++;
1961
+ }
1962
+ else {
1963
+ s6 = peg$FAILED;
1964
+ if (peg$silentFails === 0) {
1965
+ peg$fail(peg$c58);
1966
+ }
1967
+ }
1968
+ if (s6 !== peg$FAILED) {
1969
+ s7 = peg$parse_();
1970
+ if (s7 !== peg$FAILED) {
1870
1971
  if (input.charCodeAt(peg$currPos) === 62) {
1871
- s9 = peg$c57;
1972
+ s8 = peg$c59;
1872
1973
  peg$currPos++;
1873
1974
  }
1874
1975
  else {
1875
- s9 = peg$FAILED;
1976
+ s8 = peg$FAILED;
1876
1977
  if (peg$silentFails === 0) {
1877
- peg$fail(peg$c58);
1978
+ peg$fail(peg$c60);
1878
1979
  }
1879
1980
  }
1880
- if (s9 !== peg$FAILED) {
1881
- peg$savedPos = s4;
1882
- s5 = peg$c59(s3, s7);
1883
- s4 = s5;
1981
+ if (s8 !== peg$FAILED) {
1982
+ peg$savedPos = s5;
1983
+ s6 = peg$c62(s3, s4);
1984
+ s5 = s6;
1884
1985
  }
1885
1986
  else {
1886
- peg$currPos = s4;
1887
- s4 = peg$FAILED;
1987
+ peg$currPos = s5;
1988
+ s5 = peg$FAILED;
1888
1989
  }
1889
1990
  }
1890
1991
  else {
1891
- peg$currPos = s4;
1892
- s4 = peg$FAILED;
1992
+ peg$currPos = s5;
1993
+ s5 = peg$FAILED;
1893
1994
  }
1894
1995
  }
1895
1996
  else {
1896
- peg$currPos = s4;
1897
- s4 = peg$FAILED;
1997
+ peg$currPos = s5;
1998
+ s5 = peg$FAILED;
1898
1999
  }
1899
2000
  }
1900
- else {
1901
- peg$currPos = s4;
1902
- s4 = peg$FAILED;
1903
- }
1904
- }
1905
- else {
1906
- peg$currPos = s4;
1907
- s4 = peg$FAILED;
1908
- }
1909
- if (s4 !== peg$FAILED) {
1910
- s5 = peg$parse_();
1911
2001
  if (s5 !== peg$FAILED) {
1912
- peg$savedPos = s0;
1913
- s1 = peg$c60(s3, s4);
1914
- s0 = s1;
2002
+ s6 = peg$parse_();
2003
+ if (s6 !== peg$FAILED) {
2004
+ peg$savedPos = s0;
2005
+ s1 = peg$c63(s3, s4, s5);
2006
+ s0 = s1;
2007
+ }
2008
+ else {
2009
+ peg$currPos = s0;
2010
+ s0 = peg$FAILED;
2011
+ }
1915
2012
  }
1916
2013
  else {
1917
2014
  peg$currPos = s0;
@@ -1951,7 +2048,7 @@ function peg$parse(input, options) {
1951
2048
  s5 = peg$parse_();
1952
2049
  if (s5 !== peg$FAILED) {
1953
2050
  peg$savedPos = s2;
1954
- s3 = peg$c61(s4);
2051
+ s3 = peg$c64(s4);
1955
2052
  s2 = s3;
1956
2053
  }
1957
2054
  else {
@@ -1978,7 +2075,7 @@ function peg$parse(input, options) {
1978
2075
  s5 = peg$parse_();
1979
2076
  if (s5 !== peg$FAILED) {
1980
2077
  peg$savedPos = s2;
1981
- s3 = peg$c61(s4);
2078
+ s3 = peg$c64(s4);
1982
2079
  s2 = s3;
1983
2080
  }
1984
2081
  else {
@@ -1998,7 +2095,7 @@ function peg$parse(input, options) {
1998
2095
  }
1999
2096
  if (s1 !== peg$FAILED) {
2000
2097
  peg$savedPos = s0;
2001
- s1 = peg$c62(s1);
2098
+ s1 = peg$c65(s1);
2002
2099
  }
2003
2100
  s0 = s1;
2004
2101
  if (s0 === peg$FAILED) {
@@ -2006,7 +2103,7 @@ function peg$parse(input, options) {
2006
2103
  s1 = peg$parseitem();
2007
2104
  if (s1 !== peg$FAILED) {
2008
2105
  peg$savedPos = s0;
2009
- s1 = peg$c63(s1);
2106
+ s1 = peg$c66(s1);
2010
2107
  }
2011
2108
  s0 = s1;
2012
2109
  if (s0 === peg$FAILED) {
@@ -2014,7 +2111,7 @@ function peg$parse(input, options) {
2014
2111
  s1 = peg$parse_();
2015
2112
  if (s1 !== peg$FAILED) {
2016
2113
  peg$savedPos = s0;
2017
- s1 = peg$c64();
2114
+ s1 = peg$c67();
2018
2115
  }
2019
2116
  s0 = s1;
2020
2117
  }
@@ -2039,14 +2136,14 @@ function peg$parse(input, options) {
2039
2136
  }
2040
2137
  }
2041
2138
  if (s2 !== peg$FAILED) {
2042
- if (peg$c65.test(input.charAt(peg$currPos))) {
2139
+ if (peg$c53.test(input.charAt(peg$currPos))) {
2043
2140
  s3 = input.charAt(peg$currPos);
2044
2141
  peg$currPos++;
2045
2142
  }
2046
2143
  else {
2047
2144
  s3 = peg$FAILED;
2048
2145
  if (peg$silentFails === 0) {
2049
- peg$fail(peg$c66);
2146
+ peg$fail(peg$c54);
2050
2147
  }
2051
2148
  }
2052
2149
  if (s3 === peg$FAILED) {
@@ -2057,13 +2154,13 @@ function peg$parse(input, options) {
2057
2154
  if (s4 !== peg$FAILED) {
2058
2155
  s5 = peg$currPos;
2059
2156
  if (input.charCodeAt(peg$currPos) === 123) {
2060
- s6 = peg$c67;
2157
+ s6 = peg$c68;
2061
2158
  peg$currPos++;
2062
2159
  }
2063
2160
  else {
2064
2161
  s6 = peg$FAILED;
2065
2162
  if (peg$silentFails === 0) {
2066
- peg$fail(peg$c68);
2163
+ peg$fail(peg$c69);
2067
2164
  }
2068
2165
  }
2069
2166
  if (s6 !== peg$FAILED) {
@@ -2074,18 +2171,18 @@ function peg$parse(input, options) {
2074
2171
  s9 = peg$parse_();
2075
2172
  if (s9 !== peg$FAILED) {
2076
2173
  if (input.charCodeAt(peg$currPos) === 125) {
2077
- s10 = peg$c69;
2174
+ s10 = peg$c70;
2078
2175
  peg$currPos++;
2079
2176
  }
2080
2177
  else {
2081
2178
  s10 = peg$FAILED;
2082
2179
  if (peg$silentFails === 0) {
2083
- peg$fail(peg$c70);
2180
+ peg$fail(peg$c71);
2084
2181
  }
2085
2182
  }
2086
2183
  if (s10 !== peg$FAILED) {
2087
2184
  peg$savedPos = s5;
2088
- s6 = peg$c71(s3, s4, s8);
2185
+ s6 = peg$c72(s3, s4, s8);
2089
2186
  s5 = s6;
2090
2187
  }
2091
2188
  else {
@@ -2115,13 +2212,13 @@ function peg$parse(input, options) {
2115
2212
  if (s5 === peg$FAILED) {
2116
2213
  s5 = peg$currPos;
2117
2214
  if (input.charCodeAt(peg$currPos) === 91) {
2118
- s6 = peg$c72;
2215
+ s6 = peg$c73;
2119
2216
  peg$currPos++;
2120
2217
  }
2121
2218
  else {
2122
2219
  s6 = peg$FAILED;
2123
2220
  if (peg$silentFails === 0) {
2124
- peg$fail(peg$c73);
2221
+ peg$fail(peg$c74);
2125
2222
  }
2126
2223
  }
2127
2224
  if (s6 !== peg$FAILED) {
@@ -2131,7 +2228,7 @@ function peg$parse(input, options) {
2131
2228
  s9 = peg$parsearray_items();
2132
2229
  if (s9 !== peg$FAILED) {
2133
2230
  peg$savedPos = s8;
2134
- s9 = peg$c74(s3, s4, s9);
2231
+ s9 = peg$c75(s3, s4, s9);
2135
2232
  }
2136
2233
  s8 = s9;
2137
2234
  if (s8 === peg$FAILED) {
@@ -2142,24 +2239,24 @@ function peg$parse(input, options) {
2142
2239
  s12 = peg$currPos;
2143
2240
  peg$silentFails++;
2144
2241
  if (input.charCodeAt(peg$currPos) === 93) {
2145
- s13 = peg$c75;
2242
+ s13 = peg$c76;
2146
2243
  peg$currPos++;
2147
2244
  }
2148
2245
  else {
2149
2246
  s13 = peg$FAILED;
2150
2247
  if (peg$silentFails === 0) {
2151
- peg$fail(peg$c76);
2248
+ peg$fail(peg$c77);
2152
2249
  }
2153
2250
  }
2154
2251
  if (s13 === peg$FAILED) {
2155
2252
  if (input.charCodeAt(peg$currPos) === 91) {
2156
- s13 = peg$c72;
2253
+ s13 = peg$c73;
2157
2254
  peg$currPos++;
2158
2255
  }
2159
2256
  else {
2160
2257
  s13 = peg$FAILED;
2161
2258
  if (peg$silentFails === 0) {
2162
- peg$fail(peg$c73);
2259
+ peg$fail(peg$c74);
2163
2260
  }
2164
2261
  }
2165
2262
  }
@@ -2202,24 +2299,24 @@ function peg$parse(input, options) {
2202
2299
  s12 = peg$currPos;
2203
2300
  peg$silentFails++;
2204
2301
  if (input.charCodeAt(peg$currPos) === 93) {
2205
- s13 = peg$c75;
2302
+ s13 = peg$c76;
2206
2303
  peg$currPos++;
2207
2304
  }
2208
2305
  else {
2209
2306
  s13 = peg$FAILED;
2210
2307
  if (peg$silentFails === 0) {
2211
- peg$fail(peg$c76);
2308
+ peg$fail(peg$c77);
2212
2309
  }
2213
2310
  }
2214
2311
  if (s13 === peg$FAILED) {
2215
2312
  if (input.charCodeAt(peg$currPos) === 91) {
2216
- s13 = peg$c72;
2313
+ s13 = peg$c73;
2217
2314
  peg$currPos++;
2218
2315
  }
2219
2316
  else {
2220
2317
  s13 = peg$FAILED;
2221
2318
  if (peg$silentFails === 0) {
2222
- peg$fail(peg$c73);
2319
+ peg$fail(peg$c74);
2223
2320
  }
2224
2321
  }
2225
2322
  }
@@ -2268,7 +2365,7 @@ function peg$parse(input, options) {
2268
2365
  }
2269
2366
  if (s9 !== peg$FAILED) {
2270
2367
  peg$savedPos = s8;
2271
- s9 = peg$c77(s3, s4);
2368
+ s9 = peg$c78(s3, s4);
2272
2369
  }
2273
2370
  s8 = s9;
2274
2371
  }
@@ -2276,18 +2373,18 @@ function peg$parse(input, options) {
2276
2373
  s9 = peg$parse_();
2277
2374
  if (s9 !== peg$FAILED) {
2278
2375
  if (input.charCodeAt(peg$currPos) === 93) {
2279
- s10 = peg$c75;
2376
+ s10 = peg$c76;
2280
2377
  peg$currPos++;
2281
2378
  }
2282
2379
  else {
2283
2380
  s10 = peg$FAILED;
2284
2381
  if (peg$silentFails === 0) {
2285
- peg$fail(peg$c76);
2382
+ peg$fail(peg$c77);
2286
2383
  }
2287
2384
  }
2288
2385
  if (s10 !== peg$FAILED) {
2289
2386
  peg$savedPos = s5;
2290
- s6 = peg$c78(s3, s4, s8);
2387
+ s6 = peg$c79(s3, s4, s8);
2291
2388
  s5 = s6;
2292
2389
  }
2293
2390
  else {
@@ -2317,13 +2414,13 @@ function peg$parse(input, options) {
2317
2414
  if (s5 === peg$FAILED) {
2318
2415
  s5 = peg$currPos;
2319
2416
  if (input.charCodeAt(peg$currPos) === 60) {
2320
- s6 = peg$c55;
2417
+ s6 = peg$c57;
2321
2418
  peg$currPos++;
2322
2419
  }
2323
2420
  else {
2324
2421
  s6 = peg$FAILED;
2325
2422
  if (peg$silentFails === 0) {
2326
- peg$fail(peg$c56);
2423
+ peg$fail(peg$c58);
2327
2424
  }
2328
2425
  }
2329
2426
  if (s6 !== peg$FAILED) {
@@ -2334,18 +2431,18 @@ function peg$parse(input, options) {
2334
2431
  s9 = peg$parse_();
2335
2432
  if (s9 !== peg$FAILED) {
2336
2433
  if (input.charCodeAt(peg$currPos) === 62) {
2337
- s10 = peg$c57;
2434
+ s10 = peg$c59;
2338
2435
  peg$currPos++;
2339
2436
  }
2340
2437
  else {
2341
2438
  s10 = peg$FAILED;
2342
2439
  if (peg$silentFails === 0) {
2343
- peg$fail(peg$c58);
2440
+ peg$fail(peg$c60);
2344
2441
  }
2345
2442
  }
2346
2443
  if (s10 !== peg$FAILED) {
2347
2444
  peg$savedPos = s5;
2348
- s6 = peg$c79(s3, s4, s8);
2445
+ s6 = peg$c80(s3, s4, s8);
2349
2446
  s5 = s6;
2350
2447
  }
2351
2448
  else {
@@ -2375,13 +2472,13 @@ function peg$parse(input, options) {
2375
2472
  if (s5 === peg$FAILED) {
2376
2473
  s5 = peg$currPos;
2377
2474
  if (input.charCodeAt(peg$currPos) === 60) {
2378
- s6 = peg$c55;
2475
+ s6 = peg$c57;
2379
2476
  peg$currPos++;
2380
2477
  }
2381
2478
  else {
2382
2479
  s6 = peg$FAILED;
2383
2480
  if (peg$silentFails === 0) {
2384
- peg$fail(peg$c56);
2481
+ peg$fail(peg$c58);
2385
2482
  }
2386
2483
  }
2387
2484
  if (s6 !== peg$FAILED) {
@@ -2393,24 +2490,24 @@ function peg$parse(input, options) {
2393
2490
  s11 = peg$currPos;
2394
2491
  peg$silentFails++;
2395
2492
  if (input.charCodeAt(peg$currPos) === 60) {
2396
- s12 = peg$c55;
2493
+ s12 = peg$c57;
2397
2494
  peg$currPos++;
2398
2495
  }
2399
2496
  else {
2400
2497
  s12 = peg$FAILED;
2401
2498
  if (peg$silentFails === 0) {
2402
- peg$fail(peg$c56);
2499
+ peg$fail(peg$c58);
2403
2500
  }
2404
2501
  }
2405
2502
  if (s12 === peg$FAILED) {
2406
2503
  if (input.charCodeAt(peg$currPos) === 62) {
2407
- s12 = peg$c57;
2504
+ s12 = peg$c59;
2408
2505
  peg$currPos++;
2409
2506
  }
2410
2507
  else {
2411
2508
  s12 = peg$FAILED;
2412
2509
  if (peg$silentFails === 0) {
2413
- peg$fail(peg$c58);
2510
+ peg$fail(peg$c60);
2414
2511
  }
2415
2512
  }
2416
2513
  }
@@ -2453,24 +2550,24 @@ function peg$parse(input, options) {
2453
2550
  s11 = peg$currPos;
2454
2551
  peg$silentFails++;
2455
2552
  if (input.charCodeAt(peg$currPos) === 60) {
2456
- s12 = peg$c55;
2553
+ s12 = peg$c57;
2457
2554
  peg$currPos++;
2458
2555
  }
2459
2556
  else {
2460
2557
  s12 = peg$FAILED;
2461
2558
  if (peg$silentFails === 0) {
2462
- peg$fail(peg$c56);
2559
+ peg$fail(peg$c58);
2463
2560
  }
2464
2561
  }
2465
2562
  if (s12 === peg$FAILED) {
2466
2563
  if (input.charCodeAt(peg$currPos) === 62) {
2467
- s12 = peg$c57;
2564
+ s12 = peg$c59;
2468
2565
  peg$currPos++;
2469
2566
  }
2470
2567
  else {
2471
2568
  s12 = peg$FAILED;
2472
2569
  if (peg$silentFails === 0) {
2473
- peg$fail(peg$c58);
2570
+ peg$fail(peg$c60);
2474
2571
  }
2475
2572
  }
2476
2573
  }
@@ -2521,18 +2618,18 @@ function peg$parse(input, options) {
2521
2618
  s9 = peg$parse_();
2522
2619
  if (s9 !== peg$FAILED) {
2523
2620
  if (input.charCodeAt(peg$currPos) === 62) {
2524
- s10 = peg$c57;
2621
+ s10 = peg$c59;
2525
2622
  peg$currPos++;
2526
2623
  }
2527
2624
  else {
2528
2625
  s10 = peg$FAILED;
2529
2626
  if (peg$silentFails === 0) {
2530
- peg$fail(peg$c58);
2627
+ peg$fail(peg$c60);
2531
2628
  }
2532
2629
  }
2533
2630
  if (s10 !== peg$FAILED) {
2534
2631
  peg$savedPos = s5;
2535
- s6 = peg$c80(s3, s4, s8);
2632
+ s6 = peg$c81(s3, s4, s8);
2536
2633
  s5 = s6;
2537
2634
  }
2538
2635
  else {
@@ -2561,181 +2658,230 @@ function peg$parse(input, options) {
2561
2658
  }
2562
2659
  if (s5 === peg$FAILED) {
2563
2660
  s5 = peg$currPos;
2564
- if (input.charCodeAt(peg$currPos) === 40) {
2565
- s6 = peg$c81;
2661
+ if (input.charCodeAt(peg$currPos) === 60) {
2662
+ s6 = peg$c57;
2566
2663
  peg$currPos++;
2567
2664
  }
2568
2665
  else {
2569
2666
  s6 = peg$FAILED;
2570
2667
  if (peg$silentFails === 0) {
2571
- peg$fail(peg$c82);
2668
+ peg$fail(peg$c58);
2572
2669
  }
2573
2670
  }
2574
2671
  if (s6 !== peg$FAILED) {
2575
2672
  s7 = peg$parse_();
2576
2673
  if (s7 !== peg$FAILED) {
2577
- s8 = peg$currPos;
2578
- s9 = peg$parsearray_items();
2579
- if (s9 !== peg$FAILED) {
2580
- peg$savedPos = s8;
2581
- s9 = peg$c83(s3, s4, s9);
2674
+ if (input.charCodeAt(peg$currPos) === 62) {
2675
+ s8 = peg$c59;
2676
+ peg$currPos++;
2582
2677
  }
2583
- s8 = s9;
2584
- if (s8 === peg$FAILED) {
2678
+ else {
2679
+ s8 = peg$FAILED;
2680
+ if (peg$silentFails === 0) {
2681
+ peg$fail(peg$c60);
2682
+ }
2683
+ }
2684
+ if (s8 !== peg$FAILED) {
2685
+ peg$savedPos = s5;
2686
+ s6 = peg$c82(s3, s4);
2687
+ s5 = s6;
2688
+ }
2689
+ else {
2690
+ peg$currPos = s5;
2691
+ s5 = peg$FAILED;
2692
+ }
2693
+ }
2694
+ else {
2695
+ peg$currPos = s5;
2696
+ s5 = peg$FAILED;
2697
+ }
2698
+ }
2699
+ else {
2700
+ peg$currPos = s5;
2701
+ s5 = peg$FAILED;
2702
+ }
2703
+ if (s5 === peg$FAILED) {
2704
+ s5 = peg$currPos;
2705
+ if (input.charCodeAt(peg$currPos) === 40) {
2706
+ s6 = peg$c83;
2707
+ peg$currPos++;
2708
+ }
2709
+ else {
2710
+ s6 = peg$FAILED;
2711
+ if (peg$silentFails === 0) {
2712
+ peg$fail(peg$c84);
2713
+ }
2714
+ }
2715
+ if (s6 !== peg$FAILED) {
2716
+ s7 = peg$parse_();
2717
+ if (s7 !== peg$FAILED) {
2585
2718
  s8 = peg$currPos;
2586
- s9 = peg$currPos;
2587
- s10 = [];
2588
- s11 = peg$currPos;
2589
- s12 = peg$currPos;
2590
- peg$silentFails++;
2591
- if (input.charCodeAt(peg$currPos) === 41) {
2592
- s13 = peg$c84;
2593
- peg$currPos++;
2719
+ s9 = peg$parsearray_items();
2720
+ if (s9 !== peg$FAILED) {
2721
+ peg$savedPos = s8;
2722
+ s9 = peg$c85(s3, s4, s9);
2594
2723
  }
2595
- else {
2596
- s13 = peg$FAILED;
2597
- if (peg$silentFails === 0) {
2598
- peg$fail(peg$c85);
2599
- }
2600
- }
2601
- if (s13 === peg$FAILED) {
2602
- if (input.charCodeAt(peg$currPos) === 40) {
2603
- s13 = peg$c81;
2724
+ s8 = s9;
2725
+ if (s8 === peg$FAILED) {
2726
+ s8 = peg$currPos;
2727
+ s9 = peg$currPos;
2728
+ s10 = [];
2729
+ s11 = peg$currPos;
2730
+ s12 = peg$currPos;
2731
+ peg$silentFails++;
2732
+ if (input.charCodeAt(peg$currPos) === 41) {
2733
+ s13 = peg$c86;
2604
2734
  peg$currPos++;
2605
2735
  }
2606
2736
  else {
2607
2737
  s13 = peg$FAILED;
2608
2738
  if (peg$silentFails === 0) {
2609
- peg$fail(peg$c82);
2739
+ peg$fail(peg$c87);
2610
2740
  }
2611
2741
  }
2612
- }
2613
- peg$silentFails--;
2614
- if (s13 === peg$FAILED) {
2615
- s12 = void 0;
2616
- }
2617
- else {
2618
- peg$currPos = s12;
2619
- s12 = peg$FAILED;
2620
- }
2621
- if (s12 !== peg$FAILED) {
2622
- if (input.length > peg$currPos) {
2623
- s13 = input.charAt(peg$currPos);
2624
- peg$currPos++;
2625
- }
2626
- else {
2627
- s13 = peg$FAILED;
2628
- if (peg$silentFails === 0) {
2629
- peg$fail(peg$c4);
2742
+ if (s13 === peg$FAILED) {
2743
+ if (input.charCodeAt(peg$currPos) === 40) {
2744
+ s13 = peg$c83;
2745
+ peg$currPos++;
2746
+ }
2747
+ else {
2748
+ s13 = peg$FAILED;
2749
+ if (peg$silentFails === 0) {
2750
+ peg$fail(peg$c84);
2751
+ }
2630
2752
  }
2631
2753
  }
2632
- if (s13 !== peg$FAILED) {
2633
- s12 = [s12, s13];
2634
- s11 = s12;
2754
+ peg$silentFails--;
2755
+ if (s13 === peg$FAILED) {
2756
+ s12 = void 0;
2635
2757
  }
2636
2758
  else {
2637
- peg$currPos = s11;
2638
- s11 = peg$FAILED;
2759
+ peg$currPos = s12;
2760
+ s12 = peg$FAILED;
2639
2761
  }
2640
- }
2641
- else {
2642
- peg$currPos = s11;
2643
- s11 = peg$FAILED;
2644
- }
2645
- if (s11 !== peg$FAILED) {
2646
- while (s11 !== peg$FAILED) {
2647
- s10.push(s11);
2648
- s11 = peg$currPos;
2649
- s12 = peg$currPos;
2650
- peg$silentFails++;
2651
- if (input.charCodeAt(peg$currPos) === 41) {
2652
- s13 = peg$c84;
2762
+ if (s12 !== peg$FAILED) {
2763
+ if (input.length > peg$currPos) {
2764
+ s13 = input.charAt(peg$currPos);
2653
2765
  peg$currPos++;
2654
2766
  }
2655
2767
  else {
2656
2768
  s13 = peg$FAILED;
2657
2769
  if (peg$silentFails === 0) {
2658
- peg$fail(peg$c85);
2659
- }
2660
- }
2661
- if (s13 === peg$FAILED) {
2662
- if (input.charCodeAt(peg$currPos) === 40) {
2663
- s13 = peg$c81;
2664
- peg$currPos++;
2665
- }
2666
- else {
2667
- s13 = peg$FAILED;
2668
- if (peg$silentFails === 0) {
2669
- peg$fail(peg$c82);
2670
- }
2770
+ peg$fail(peg$c4);
2671
2771
  }
2672
2772
  }
2673
- peg$silentFails--;
2674
- if (s13 === peg$FAILED) {
2675
- s12 = void 0;
2773
+ if (s13 !== peg$FAILED) {
2774
+ s12 = [s12, s13];
2775
+ s11 = s12;
2676
2776
  }
2677
2777
  else {
2678
- peg$currPos = s12;
2679
- s12 = peg$FAILED;
2778
+ peg$currPos = s11;
2779
+ s11 = peg$FAILED;
2680
2780
  }
2681
- if (s12 !== peg$FAILED) {
2682
- if (input.length > peg$currPos) {
2683
- s13 = input.charAt(peg$currPos);
2781
+ }
2782
+ else {
2783
+ peg$currPos = s11;
2784
+ s11 = peg$FAILED;
2785
+ }
2786
+ if (s11 !== peg$FAILED) {
2787
+ while (s11 !== peg$FAILED) {
2788
+ s10.push(s11);
2789
+ s11 = peg$currPos;
2790
+ s12 = peg$currPos;
2791
+ peg$silentFails++;
2792
+ if (input.charCodeAt(peg$currPos) === 41) {
2793
+ s13 = peg$c86;
2684
2794
  peg$currPos++;
2685
2795
  }
2686
2796
  else {
2687
2797
  s13 = peg$FAILED;
2688
2798
  if (peg$silentFails === 0) {
2689
- peg$fail(peg$c4);
2799
+ peg$fail(peg$c87);
2800
+ }
2801
+ }
2802
+ if (s13 === peg$FAILED) {
2803
+ if (input.charCodeAt(peg$currPos) === 40) {
2804
+ s13 = peg$c83;
2805
+ peg$currPos++;
2806
+ }
2807
+ else {
2808
+ s13 = peg$FAILED;
2809
+ if (peg$silentFails === 0) {
2810
+ peg$fail(peg$c84);
2811
+ }
2690
2812
  }
2691
2813
  }
2692
- if (s13 !== peg$FAILED) {
2693
- s12 = [s12, s13];
2694
- s11 = s12;
2814
+ peg$silentFails--;
2815
+ if (s13 === peg$FAILED) {
2816
+ s12 = void 0;
2817
+ }
2818
+ else {
2819
+ peg$currPos = s12;
2820
+ s12 = peg$FAILED;
2821
+ }
2822
+ if (s12 !== peg$FAILED) {
2823
+ if (input.length > peg$currPos) {
2824
+ s13 = input.charAt(peg$currPos);
2825
+ peg$currPos++;
2826
+ }
2827
+ else {
2828
+ s13 = peg$FAILED;
2829
+ if (peg$silentFails === 0) {
2830
+ peg$fail(peg$c4);
2831
+ }
2832
+ }
2833
+ if (s13 !== peg$FAILED) {
2834
+ s12 = [s12, s13];
2835
+ s11 = s12;
2836
+ }
2837
+ else {
2838
+ peg$currPos = s11;
2839
+ s11 = peg$FAILED;
2840
+ }
2695
2841
  }
2696
2842
  else {
2697
2843
  peg$currPos = s11;
2698
2844
  s11 = peg$FAILED;
2699
2845
  }
2700
2846
  }
2701
- else {
2702
- peg$currPos = s11;
2703
- s11 = peg$FAILED;
2704
- }
2705
- }
2706
- }
2707
- else {
2708
- s10 = peg$FAILED;
2709
- }
2710
- if (s10 !== peg$FAILED) {
2711
- s9 = input.substring(s9, peg$currPos);
2712
- }
2713
- else {
2714
- s9 = s10;
2715
- }
2716
- if (s9 !== peg$FAILED) {
2717
- peg$savedPos = s8;
2718
- s9 = peg$c86(s3, s4);
2719
- }
2720
- s8 = s9;
2721
- }
2722
- if (s8 !== peg$FAILED) {
2723
- s9 = peg$parse_();
2724
- if (s9 !== peg$FAILED) {
2725
- if (input.charCodeAt(peg$currPos) === 41) {
2726
- s10 = peg$c84;
2727
- peg$currPos++;
2728
2847
  }
2729
2848
  else {
2730
2849
  s10 = peg$FAILED;
2731
- if (peg$silentFails === 0) {
2732
- peg$fail(peg$c85);
2733
- }
2734
2850
  }
2735
2851
  if (s10 !== peg$FAILED) {
2736
- peg$savedPos = s5;
2737
- s6 = peg$c87(s3, s4, s8);
2738
- s5 = s6;
2852
+ s9 = input.substring(s9, peg$currPos);
2853
+ }
2854
+ else {
2855
+ s9 = s10;
2856
+ }
2857
+ if (s9 !== peg$FAILED) {
2858
+ peg$savedPos = s8;
2859
+ s9 = peg$c88(s3, s4);
2860
+ }
2861
+ s8 = s9;
2862
+ }
2863
+ if (s8 !== peg$FAILED) {
2864
+ s9 = peg$parse_();
2865
+ if (s9 !== peg$FAILED) {
2866
+ if (input.charCodeAt(peg$currPos) === 41) {
2867
+ s10 = peg$c86;
2868
+ peg$currPos++;
2869
+ }
2870
+ else {
2871
+ s10 = peg$FAILED;
2872
+ if (peg$silentFails === 0) {
2873
+ peg$fail(peg$c87);
2874
+ }
2875
+ }
2876
+ if (s10 !== peg$FAILED) {
2877
+ peg$savedPos = s5;
2878
+ s6 = peg$c89(s3, s4, s8);
2879
+ s5 = s6;
2880
+ }
2881
+ else {
2882
+ peg$currPos = s5;
2883
+ s5 = peg$FAILED;
2884
+ }
2739
2885
  }
2740
2886
  else {
2741
2887
  peg$currPos = s5;
@@ -2756,19 +2902,15 @@ function peg$parse(input, options) {
2756
2902
  peg$currPos = s5;
2757
2903
  s5 = peg$FAILED;
2758
2904
  }
2759
- }
2760
- else {
2761
- peg$currPos = s5;
2762
- s5 = peg$FAILED;
2763
- }
2764
- if (s5 === peg$FAILED) {
2765
- s5 = peg$currPos;
2766
- s6 = peg$parse_();
2767
- if (s6 !== peg$FAILED) {
2768
- peg$savedPos = s5;
2769
- s6 = peg$c88(s3, s4);
2905
+ if (s5 === peg$FAILED) {
2906
+ s5 = peg$currPos;
2907
+ s6 = peg$parse_();
2908
+ if (s6 !== peg$FAILED) {
2909
+ peg$savedPos = s5;
2910
+ s6 = peg$c90(s3, s4);
2911
+ }
2912
+ s5 = s6;
2770
2913
  }
2771
- s5 = s6;
2772
2914
  }
2773
2915
  }
2774
2916
  }
@@ -2778,7 +2920,7 @@ function peg$parse(input, options) {
2778
2920
  s6 = peg$parse_();
2779
2921
  if (s6 !== peg$FAILED) {
2780
2922
  peg$savedPos = s0;
2781
- s1 = peg$c89(s3, s4, s5);
2923
+ s1 = peg$c91(s3, s4, s5);
2782
2924
  s0 = s1;
2783
2925
  }
2784
2926
  else {
@@ -2857,7 +2999,7 @@ function peg$parse(input, options) {
2857
2999
  s9 = peg$parsenewline();
2858
3000
  if (s9 !== peg$FAILED) {
2859
3001
  peg$savedPos = s4;
2860
- s5 = peg$c90(s1, s7);
3002
+ s5 = peg$c92(s1, s7);
2861
3003
  s4 = s5;
2862
3004
  }
2863
3005
  else {
@@ -2917,7 +3059,7 @@ function peg$parse(input, options) {
2917
3059
  s9 = peg$parsenewline();
2918
3060
  if (s9 !== peg$FAILED) {
2919
3061
  peg$savedPos = s4;
2920
- s5 = peg$c90(s1, s7);
3062
+ s5 = peg$c92(s1, s7);
2921
3063
  s4 = s5;
2922
3064
  }
2923
3065
  else {
@@ -2947,7 +3089,7 @@ function peg$parse(input, options) {
2947
3089
  }
2948
3090
  if (s3 !== peg$FAILED) {
2949
3091
  peg$savedPos = s0;
2950
- s1 = peg$c91(s1, s3);
3092
+ s1 = peg$c93(s1, s3);
2951
3093
  s0 = s1;
2952
3094
  }
2953
3095
  else {
@@ -2971,27 +3113,27 @@ function peg$parse(input, options) {
2971
3113
  s0 = peg$currPos;
2972
3114
  s1 = peg$currPos;
2973
3115
  s2 = [];
2974
- if (peg$c92.test(input.charAt(peg$currPos))) {
3116
+ if (peg$c94.test(input.charAt(peg$currPos))) {
2975
3117
  s3 = input.charAt(peg$currPos);
2976
3118
  peg$currPos++;
2977
3119
  }
2978
3120
  else {
2979
3121
  s3 = peg$FAILED;
2980
3122
  if (peg$silentFails === 0) {
2981
- peg$fail(peg$c93);
3123
+ peg$fail(peg$c95);
2982
3124
  }
2983
3125
  }
2984
3126
  if (s3 !== peg$FAILED) {
2985
3127
  while (s3 !== peg$FAILED) {
2986
3128
  s2.push(s3);
2987
- if (peg$c92.test(input.charAt(peg$currPos))) {
3129
+ if (peg$c94.test(input.charAt(peg$currPos))) {
2988
3130
  s3 = input.charAt(peg$currPos);
2989
3131
  peg$currPos++;
2990
3132
  }
2991
3133
  else {
2992
3134
  s3 = peg$FAILED;
2993
3135
  if (peg$silentFails === 0) {
2994
- peg$fail(peg$c93);
3136
+ peg$fail(peg$c95);
2995
3137
  }
2996
3138
  }
2997
3139
  }
@@ -3007,7 +3149,7 @@ function peg$parse(input, options) {
3007
3149
  }
3008
3150
  if (s1 !== peg$FAILED) {
3009
3151
  peg$savedPos = s0;
3010
- s1 = peg$c94(s1);
3152
+ s1 = peg$c96(s1);
3011
3153
  }
3012
3154
  s0 = s1;
3013
3155
  return s0;
@@ -3016,27 +3158,27 @@ function peg$parse(input, options) {
3016
3158
  var s0, s1, s2;
3017
3159
  s0 = peg$currPos;
3018
3160
  s1 = [];
3019
- if (peg$c95.test(input.charAt(peg$currPos))) {
3161
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3020
3162
  s2 = input.charAt(peg$currPos);
3021
3163
  peg$currPos++;
3022
3164
  }
3023
3165
  else {
3024
3166
  s2 = peg$FAILED;
3025
3167
  if (peg$silentFails === 0) {
3026
- peg$fail(peg$c96);
3168
+ peg$fail(peg$c98);
3027
3169
  }
3028
3170
  }
3029
3171
  if (s2 !== peg$FAILED) {
3030
3172
  while (s2 !== peg$FAILED) {
3031
3173
  s1.push(s2);
3032
- if (peg$c95.test(input.charAt(peg$currPos))) {
3174
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3033
3175
  s2 = input.charAt(peg$currPos);
3034
3176
  peg$currPos++;
3035
3177
  }
3036
3178
  else {
3037
3179
  s2 = peg$FAILED;
3038
3180
  if (peg$silentFails === 0) {
3039
- peg$fail(peg$c96);
3181
+ peg$fail(peg$c98);
3040
3182
  }
3041
3183
  }
3042
3184
  }
@@ -3056,14 +3198,14 @@ function peg$parse(input, options) {
3056
3198
  var s0, s1, s2, s3, s4;
3057
3199
  s0 = peg$currPos;
3058
3200
  s1 = peg$currPos;
3059
- if (peg$c97.test(input.charAt(peg$currPos))) {
3201
+ if (peg$c99.test(input.charAt(peg$currPos))) {
3060
3202
  s2 = input.charAt(peg$currPos);
3061
3203
  peg$currPos++;
3062
3204
  }
3063
3205
  else {
3064
3206
  s2 = peg$FAILED;
3065
3207
  if (peg$silentFails === 0) {
3066
- peg$fail(peg$c98);
3208
+ peg$fail(peg$c100);
3067
3209
  }
3068
3210
  }
3069
3211
  if (s2 === peg$FAILED) {
@@ -3071,27 +3213,27 @@ function peg$parse(input, options) {
3071
3213
  }
3072
3214
  if (s2 !== peg$FAILED) {
3073
3215
  s3 = [];
3074
- if (peg$c95.test(input.charAt(peg$currPos))) {
3216
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3075
3217
  s4 = input.charAt(peg$currPos);
3076
3218
  peg$currPos++;
3077
3219
  }
3078
3220
  else {
3079
3221
  s4 = peg$FAILED;
3080
3222
  if (peg$silentFails === 0) {
3081
- peg$fail(peg$c96);
3223
+ peg$fail(peg$c98);
3082
3224
  }
3083
3225
  }
3084
3226
  if (s4 !== peg$FAILED) {
3085
3227
  while (s4 !== peg$FAILED) {
3086
3228
  s3.push(s4);
3087
- if (peg$c95.test(input.charAt(peg$currPos))) {
3229
+ if (peg$c97.test(input.charAt(peg$currPos))) {
3088
3230
  s4 = input.charAt(peg$currPos);
3089
3231
  peg$currPos++;
3090
3232
  }
3091
3233
  else {
3092
3234
  s4 = peg$FAILED;
3093
3235
  if (peg$silentFails === 0) {
3094
- peg$fail(peg$c96);
3236
+ peg$fail(peg$c98);
3095
3237
  }
3096
3238
  }
3097
3239
  }
@@ -3123,36 +3265,36 @@ function peg$parse(input, options) {
3123
3265
  function peg$parseBoolean() {
3124
3266
  var s0, s1;
3125
3267
  s0 = peg$currPos;
3126
- if (input.substr(peg$currPos, 4) === peg$c99) {
3127
- s1 = peg$c99;
3268
+ if (input.substr(peg$currPos, 4) === peg$c101) {
3269
+ s1 = peg$c101;
3128
3270
  peg$currPos += 4;
3129
3271
  }
3130
3272
  else {
3131
3273
  s1 = peg$FAILED;
3132
3274
  if (peg$silentFails === 0) {
3133
- peg$fail(peg$c100);
3275
+ peg$fail(peg$c102);
3134
3276
  }
3135
3277
  }
3136
3278
  if (s1 !== peg$FAILED) {
3137
3279
  peg$savedPos = s0;
3138
- s1 = peg$c101();
3280
+ s1 = peg$c103();
3139
3281
  }
3140
3282
  s0 = s1;
3141
3283
  if (s0 === peg$FAILED) {
3142
3284
  s0 = peg$currPos;
3143
- if (input.substr(peg$currPos, 5) === peg$c102) {
3144
- s1 = peg$c102;
3285
+ if (input.substr(peg$currPos, 5) === peg$c104) {
3286
+ s1 = peg$c104;
3145
3287
  peg$currPos += 5;
3146
3288
  }
3147
3289
  else {
3148
3290
  s1 = peg$FAILED;
3149
3291
  if (peg$silentFails === 0) {
3150
- peg$fail(peg$c103);
3292
+ peg$fail(peg$c105);
3151
3293
  }
3152
3294
  }
3153
3295
  if (s1 !== peg$FAILED) {
3154
3296
  peg$savedPos = s0;
3155
- s1 = peg$c104();
3297
+ s1 = peg$c106();
3156
3298
  }
3157
3299
  s0 = s1;
3158
3300
  }
@@ -3166,13 +3308,13 @@ function peg$parse(input, options) {
3166
3308
  if (s2 !== peg$FAILED) {
3167
3309
  s3 = peg$currPos;
3168
3310
  if (input.charCodeAt(peg$currPos) === 46) {
3169
- s4 = peg$c105;
3311
+ s4 = peg$c107;
3170
3312
  peg$currPos++;
3171
3313
  }
3172
3314
  else {
3173
3315
  s4 = peg$FAILED;
3174
3316
  if (peg$silentFails === 0) {
3175
- peg$fail(peg$c106);
3317
+ peg$fail(peg$c108);
3176
3318
  }
3177
3319
  }
3178
3320
  if (s4 !== peg$FAILED) {
@@ -3194,14 +3336,14 @@ function peg$parse(input, options) {
3194
3336
  s3 = null;
3195
3337
  }
3196
3338
  if (s3 !== peg$FAILED) {
3197
- if (peg$c107.test(input.charAt(peg$currPos))) {
3339
+ if (peg$c109.test(input.charAt(peg$currPos))) {
3198
3340
  s4 = input.charAt(peg$currPos);
3199
3341
  peg$currPos++;
3200
3342
  }
3201
3343
  else {
3202
3344
  s4 = peg$FAILED;
3203
3345
  if (peg$silentFails === 0) {
3204
- peg$fail(peg$c108);
3346
+ peg$fail(peg$c110);
3205
3347
  }
3206
3348
  }
3207
3349
  if (s4 !== peg$FAILED) {
@@ -3241,13 +3383,13 @@ function peg$parse(input, options) {
3241
3383
  s2 = peg$parsenumber();
3242
3384
  if (s2 !== peg$FAILED) {
3243
3385
  if (input.charCodeAt(peg$currPos) === 46) {
3244
- s3 = peg$c105;
3386
+ s3 = peg$c107;
3245
3387
  peg$currPos++;
3246
3388
  }
3247
3389
  else {
3248
3390
  s3 = peg$FAILED;
3249
3391
  if (peg$silentFails === 0) {
3250
- peg$fail(peg$c106);
3392
+ peg$fail(peg$c108);
3251
3393
  }
3252
3394
  }
3253
3395
  if (s3 !== peg$FAILED) {
@@ -3282,39 +3424,39 @@ function peg$parse(input, options) {
3282
3424
  function peg$parseitem() {
3283
3425
  var s0, s1, s2, s3, s4;
3284
3426
  s0 = peg$currPos;
3285
- if (peg$c109.test(input.charAt(peg$currPos))) {
3427
+ if (peg$c111.test(input.charAt(peg$currPos))) {
3286
3428
  s1 = input.charAt(peg$currPos);
3287
3429
  peg$currPos++;
3288
3430
  }
3289
3431
  else {
3290
3432
  s1 = peg$FAILED;
3291
3433
  if (peg$silentFails === 0) {
3292
- peg$fail(peg$c110);
3434
+ peg$fail(peg$c112);
3293
3435
  }
3294
3436
  }
3295
3437
  if (s1 !== peg$FAILED) {
3296
3438
  s2 = peg$currPos;
3297
3439
  s3 = [];
3298
- if (peg$c111.test(input.charAt(peg$currPos))) {
3440
+ if (peg$c113.test(input.charAt(peg$currPos))) {
3299
3441
  s4 = input.charAt(peg$currPos);
3300
3442
  peg$currPos++;
3301
3443
  }
3302
3444
  else {
3303
3445
  s4 = peg$FAILED;
3304
3446
  if (peg$silentFails === 0) {
3305
- peg$fail(peg$c112);
3447
+ peg$fail(peg$c114);
3306
3448
  }
3307
3449
  }
3308
3450
  while (s4 !== peg$FAILED) {
3309
3451
  s3.push(s4);
3310
- if (peg$c111.test(input.charAt(peg$currPos))) {
3452
+ if (peg$c113.test(input.charAt(peg$currPos))) {
3311
3453
  s4 = input.charAt(peg$currPos);
3312
3454
  peg$currPos++;
3313
3455
  }
3314
3456
  else {
3315
3457
  s4 = peg$FAILED;
3316
3458
  if (peg$silentFails === 0) {
3317
- peg$fail(peg$c112);
3459
+ peg$fail(peg$c114);
3318
3460
  }
3319
3461
  }
3320
3462
  }
@@ -3325,19 +3467,19 @@ function peg$parse(input, options) {
3325
3467
  s2 = s3;
3326
3468
  }
3327
3469
  if (s2 !== peg$FAILED) {
3328
- if (peg$c109.test(input.charAt(peg$currPos))) {
3470
+ if (peg$c111.test(input.charAt(peg$currPos))) {
3329
3471
  s3 = input.charAt(peg$currPos);
3330
3472
  peg$currPos++;
3331
3473
  }
3332
3474
  else {
3333
3475
  s3 = peg$FAILED;
3334
3476
  if (peg$silentFails === 0) {
3335
- peg$fail(peg$c110);
3477
+ peg$fail(peg$c112);
3336
3478
  }
3337
3479
  }
3338
3480
  if (s3 !== peg$FAILED) {
3339
3481
  peg$savedPos = s0;
3340
- s1 = peg$c94(s2);
3482
+ s1 = peg$c96(s2);
3341
3483
  s0 = s1;
3342
3484
  }
3343
3485
  else {
@@ -3356,39 +3498,39 @@ function peg$parse(input, options) {
3356
3498
  }
3357
3499
  if (s0 === peg$FAILED) {
3358
3500
  s0 = peg$currPos;
3359
- if (peg$c113.test(input.charAt(peg$currPos))) {
3501
+ if (peg$c115.test(input.charAt(peg$currPos))) {
3360
3502
  s1 = input.charAt(peg$currPos);
3361
3503
  peg$currPos++;
3362
3504
  }
3363
3505
  else {
3364
3506
  s1 = peg$FAILED;
3365
3507
  if (peg$silentFails === 0) {
3366
- peg$fail(peg$c114);
3508
+ peg$fail(peg$c116);
3367
3509
  }
3368
3510
  }
3369
3511
  if (s1 !== peg$FAILED) {
3370
3512
  s2 = peg$currPos;
3371
3513
  s3 = [];
3372
- if (peg$c115.test(input.charAt(peg$currPos))) {
3514
+ if (peg$c117.test(input.charAt(peg$currPos))) {
3373
3515
  s4 = input.charAt(peg$currPos);
3374
3516
  peg$currPos++;
3375
3517
  }
3376
3518
  else {
3377
3519
  s4 = peg$FAILED;
3378
3520
  if (peg$silentFails === 0) {
3379
- peg$fail(peg$c116);
3521
+ peg$fail(peg$c118);
3380
3522
  }
3381
3523
  }
3382
3524
  while (s4 !== peg$FAILED) {
3383
3525
  s3.push(s4);
3384
- if (peg$c115.test(input.charAt(peg$currPos))) {
3526
+ if (peg$c117.test(input.charAt(peg$currPos))) {
3385
3527
  s4 = input.charAt(peg$currPos);
3386
3528
  peg$currPos++;
3387
3529
  }
3388
3530
  else {
3389
3531
  s4 = peg$FAILED;
3390
3532
  if (peg$silentFails === 0) {
3391
- peg$fail(peg$c116);
3533
+ peg$fail(peg$c118);
3392
3534
  }
3393
3535
  }
3394
3536
  }
@@ -3399,19 +3541,19 @@ function peg$parse(input, options) {
3399
3541
  s2 = s3;
3400
3542
  }
3401
3543
  if (s2 !== peg$FAILED) {
3402
- if (peg$c113.test(input.charAt(peg$currPos))) {
3544
+ if (peg$c115.test(input.charAt(peg$currPos))) {
3403
3545
  s3 = input.charAt(peg$currPos);
3404
3546
  peg$currPos++;
3405
3547
  }
3406
3548
  else {
3407
3549
  s3 = peg$FAILED;
3408
3550
  if (peg$silentFails === 0) {
3409
- peg$fail(peg$c114);
3551
+ peg$fail(peg$c116);
3410
3552
  }
3411
3553
  }
3412
3554
  if (s3 !== peg$FAILED) {
3413
3555
  peg$savedPos = s0;
3414
- s1 = peg$c94(s2);
3556
+ s1 = peg$c96(s2);
3415
3557
  s0 = s1;
3416
3558
  }
3417
3559
  else {
@@ -3435,7 +3577,7 @@ function peg$parse(input, options) {
3435
3577
  s1 = peg$parsefloatNumber();
3436
3578
  if (s1 !== peg$FAILED) {
3437
3579
  peg$savedPos = s0;
3438
- s1 = peg$c117(s1);
3580
+ s1 = peg$c119(s1);
3439
3581
  }
3440
3582
  s0 = s1;
3441
3583
  if (s0 === peg$FAILED) {
@@ -3443,7 +3585,7 @@ function peg$parse(input, options) {
3443
3585
  s1 = peg$parsenumber();
3444
3586
  if (s1 !== peg$FAILED) {
3445
3587
  peg$savedPos = s0;
3446
- s1 = peg$c118(s1);
3588
+ s1 = peg$c120(s1);
3447
3589
  }
3448
3590
  s0 = s1;
3449
3591
  }
@@ -3473,7 +3615,7 @@ function peg$parse(input, options) {
3473
3615
  s5 = peg$parsepod_configuration();
3474
3616
  if (s5 !== peg$FAILED) {
3475
3617
  peg$savedPos = peg$currPos;
3476
- s6 = peg$c119(s1, s3, s5);
3618
+ s6 = peg$c121(s1, s3, s5);
3477
3619
  if (s6) {
3478
3620
  s6 = void 0;
3479
3621
  }
@@ -3516,7 +3658,7 @@ function peg$parse(input, options) {
3516
3658
  s15 = peg$parsestrictIdentifier();
3517
3659
  if (s15 !== peg$FAILED) {
3518
3660
  peg$savedPos = peg$currPos;
3519
- s16 = peg$c120(s1, s3, s5, s9, s15);
3661
+ s16 = peg$c122(s1, s3, s5, s9, s15);
3520
3662
  if (s16) {
3521
3663
  s16 = void 0;
3522
3664
  }
@@ -3584,7 +3726,7 @@ function peg$parse(input, options) {
3584
3726
  }
3585
3727
  if (s10 !== peg$FAILED) {
3586
3728
  peg$savedPos = s8;
3587
- s9 = peg$c121(s1, s3, s5, s9, s10);
3729
+ s9 = peg$c123(s1, s3, s5, s9, s10);
3588
3730
  s8 = s9;
3589
3731
  }
3590
3732
  else {
@@ -3633,7 +3775,7 @@ function peg$parse(input, options) {
3633
3775
  s15 = peg$parsestrictIdentifier();
3634
3776
  if (s15 !== peg$FAILED) {
3635
3777
  peg$savedPos = peg$currPos;
3636
- s16 = peg$c120(s1, s3, s5, s9, s15);
3778
+ s16 = peg$c122(s1, s3, s5, s9, s15);
3637
3779
  if (s16) {
3638
3780
  s16 = void 0;
3639
3781
  }
@@ -3701,7 +3843,7 @@ function peg$parse(input, options) {
3701
3843
  }
3702
3844
  if (s10 !== peg$FAILED) {
3703
3845
  peg$savedPos = s8;
3704
- s9 = peg$c121(s1, s3, s5, s9, s10);
3846
+ s9 = peg$c123(s1, s3, s5, s9, s10);
3705
3847
  s8 = s9;
3706
3848
  }
3707
3849
  else {
@@ -3734,7 +3876,7 @@ function peg$parse(input, options) {
3734
3876
  s11 = peg$parsestrictIdentifier();
3735
3877
  if (s11 !== peg$FAILED) {
3736
3878
  peg$savedPos = peg$currPos;
3737
- s12 = peg$c122(s1, s3, s5, s7, s8, s11);
3879
+ s12 = peg$c124(s1, s3, s5, s7, s8, s11);
3738
3880
  if (s12) {
3739
3881
  s12 = void 0;
3740
3882
  }
@@ -3748,7 +3890,7 @@ function peg$parse(input, options) {
3748
3890
  }
3749
3891
  if (s13 !== peg$FAILED) {
3750
3892
  peg$savedPos = s9;
3751
- s10 = peg$c123(s1, s3, s5, s7, s8, s11);
3893
+ s10 = peg$c125(s1, s3, s5, s7, s8, s11);
3752
3894
  s9 = s10;
3753
3895
  }
3754
3896
  else {
@@ -3772,7 +3914,7 @@ function peg$parse(input, options) {
3772
3914
  }
3773
3915
  if (s9 !== peg$FAILED) {
3774
3916
  peg$savedPos = peg$currPos;
3775
- s10 = peg$c124(s1, s3, s5, s7, s8, s9);
3917
+ s10 = peg$c126(s1, s3, s5, s7, s8, s9);
3776
3918
  if (s10) {
3777
3919
  s10 = void 0;
3778
3920
  }
@@ -3781,7 +3923,7 @@ function peg$parse(input, options) {
3781
3923
  }
3782
3924
  if (s10 !== peg$FAILED) {
3783
3925
  peg$savedPos = s0;
3784
- s1 = peg$c125(s1, s3, s5, s7, s8, s9);
3926
+ s1 = peg$c127(s1, s3, s5, s7, s8, s9);
3785
3927
  s0 = s1;
3786
3928
  }
3787
3929
  else {
@@ -3882,14 +4024,14 @@ function peg$parse(input, options) {
3882
4024
  s3 = peg$currPos;
3883
4025
  s4 = [];
3884
4026
  s5 = peg$currPos;
3885
- if (peg$c126.test(input.charAt(peg$currPos))) {
4027
+ if (peg$c128.test(input.charAt(peg$currPos))) {
3886
4028
  s6 = input.charAt(peg$currPos);
3887
4029
  peg$currPos++;
3888
4030
  }
3889
4031
  else {
3890
4032
  s6 = peg$FAILED;
3891
4033
  if (peg$silentFails === 0) {
3892
- peg$fail(peg$c127);
4034
+ peg$fail(peg$c129);
3893
4035
  }
3894
4036
  }
3895
4037
  if (s6 !== peg$FAILED) {
@@ -3916,14 +4058,14 @@ function peg$parse(input, options) {
3916
4058
  while (s5 !== peg$FAILED) {
3917
4059
  s4.push(s5);
3918
4060
  s5 = peg$currPos;
3919
- if (peg$c126.test(input.charAt(peg$currPos))) {
4061
+ if (peg$c128.test(input.charAt(peg$currPos))) {
3920
4062
  s6 = input.charAt(peg$currPos);
3921
4063
  peg$currPos++;
3922
4064
  }
3923
4065
  else {
3924
4066
  s6 = peg$FAILED;
3925
4067
  if (peg$silentFails === 0) {
3926
- peg$fail(peg$c127);
4068
+ peg$fail(peg$c129);
3927
4069
  }
3928
4070
  }
3929
4071
  if (s6 !== peg$FAILED) {
@@ -3961,7 +4103,7 @@ function peg$parse(input, options) {
3961
4103
  s4 = peg$parseEOL();
3962
4104
  if (s4 !== peg$FAILED) {
3963
4105
  peg$savedPos = s0;
3964
- s1 = peg$c128();
4106
+ s1 = peg$c130();
3965
4107
  s0 = s1;
3966
4108
  }
3967
4109
  else {
@@ -3993,7 +4135,7 @@ function peg$parse(input, options) {
3993
4135
  if (s2 === peg$FAILED) {
3994
4136
  s2 = peg$currPos;
3995
4137
  peg$savedPos = peg$currPos;
3996
- s3 = peg$c129();
4138
+ s3 = peg$c131();
3997
4139
  if (s3) {
3998
4140
  s3 = void 0;
3999
4141
  }
@@ -4024,7 +4166,7 @@ function peg$parse(input, options) {
4024
4166
  }
4025
4167
  if (s1 !== peg$FAILED) {
4026
4168
  peg$savedPos = s0;
4027
- s1 = peg$c130();
4169
+ s1 = peg$c132();
4028
4170
  }
4029
4171
  s0 = s1;
4030
4172
  return s0;
@@ -4035,7 +4177,7 @@ function peg$parse(input, options) {
4035
4177
  s1 = peg$parsetext_content();
4036
4178
  if (s1 !== peg$FAILED) {
4037
4179
  peg$savedPos = s0;
4038
- s1 = peg$c131(s1);
4180
+ s1 = peg$c133(s1);
4039
4181
  }
4040
4182
  s0 = s1;
4041
4183
  return s0;
@@ -4044,7 +4186,7 @@ function peg$parse(input, options) {
4044
4186
  var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
4045
4187
  s0 = peg$currPos;
4046
4188
  peg$savedPos = peg$currPos;
4047
- s1 = peg$c132();
4189
+ s1 = peg$c134();
4048
4190
  if (s1) {
4049
4191
  s1 = void 0;
4050
4192
  }
@@ -4127,7 +4269,7 @@ function peg$parse(input, options) {
4127
4269
  s4 = peg$parsetableHeadSeparator();
4128
4270
  if (s4 !== peg$FAILED) {
4129
4271
  peg$savedPos = s3;
4130
- s4 = peg$c133(s2, s4);
4272
+ s4 = peg$c135(s2, s4);
4131
4273
  }
4132
4274
  s3 = s4;
4133
4275
  if (s3 !== peg$FAILED) {
@@ -4208,12 +4350,12 @@ function peg$parse(input, options) {
4208
4350
  s8 = peg$parsetableBodyRowSeparator();
4209
4351
  if (s8 !== peg$FAILED) {
4210
4352
  peg$savedPos = s7;
4211
- s8 = peg$c134(s2, s3, s6, s8);
4353
+ s8 = peg$c136(s2, s3, s6, s8);
4212
4354
  }
4213
4355
  s7 = s8;
4214
4356
  if (s7 !== peg$FAILED) {
4215
4357
  peg$savedPos = s5;
4216
- s6 = peg$c135(s2, s3, s6, s7);
4358
+ s6 = peg$c137(s2, s3, s6, s7);
4217
4359
  s5 = s6;
4218
4360
  }
4219
4361
  else {
@@ -4254,7 +4396,7 @@ function peg$parse(input, options) {
4254
4396
  s8 = peg$parsetableRow();
4255
4397
  if (s8 !== peg$FAILED) {
4256
4398
  peg$savedPos = s5;
4257
- s6 = peg$c136(s2, s3, s8);
4399
+ s6 = peg$c138(s2, s3, s8);
4258
4400
  s5 = s6;
4259
4401
  }
4260
4402
  else {
@@ -4351,12 +4493,12 @@ function peg$parse(input, options) {
4351
4493
  s8 = peg$parsetableBodyRowSeparator();
4352
4494
  if (s8 !== peg$FAILED) {
4353
4495
  peg$savedPos = s7;
4354
- s8 = peg$c134(s2, s3, s6, s8);
4496
+ s8 = peg$c136(s2, s3, s6, s8);
4355
4497
  }
4356
4498
  s7 = s8;
4357
4499
  if (s7 !== peg$FAILED) {
4358
4500
  peg$savedPos = s5;
4359
- s6 = peg$c135(s2, s3, s6, s7);
4501
+ s6 = peg$c137(s2, s3, s6, s7);
4360
4502
  s5 = s6;
4361
4503
  }
4362
4504
  else {
@@ -4397,7 +4539,7 @@ function peg$parse(input, options) {
4397
4539
  s8 = peg$parsetableRow();
4398
4540
  if (s8 !== peg$FAILED) {
4399
4541
  peg$savedPos = s5;
4400
- s6 = peg$c136(s2, s3, s8);
4542
+ s6 = peg$c138(s2, s3, s8);
4401
4543
  s5 = s6;
4402
4544
  }
4403
4545
  else {
@@ -4422,7 +4564,7 @@ function peg$parse(input, options) {
4422
4564
  }
4423
4565
  if (s4 !== peg$FAILED) {
4424
4566
  peg$savedPos = peg$currPos;
4425
- s5 = peg$c137(s2, s3, s4);
4567
+ s5 = peg$c139(s2, s3, s4);
4426
4568
  if (s5) {
4427
4569
  s5 = void 0;
4428
4570
  }
@@ -4431,7 +4573,7 @@ function peg$parse(input, options) {
4431
4573
  }
4432
4574
  if (s5 !== peg$FAILED) {
4433
4575
  peg$savedPos = s0;
4434
- s1 = peg$c138(s2, s3, s4);
4576
+ s1 = peg$c140(s2, s3, s4);
4435
4577
  s0 = s1;
4436
4578
  }
4437
4579
  else {
@@ -4505,7 +4647,7 @@ function peg$parse(input, options) {
4505
4647
  }
4506
4648
  if (s4 !== peg$FAILED) {
4507
4649
  peg$savedPos = s2;
4508
- s3 = peg$c139(s3, s4);
4650
+ s3 = peg$c141(s3, s4);
4509
4651
  s2 = s3;
4510
4652
  }
4511
4653
  else {
@@ -4564,7 +4706,7 @@ function peg$parse(input, options) {
4564
4706
  }
4565
4707
  if (s4 !== peg$FAILED) {
4566
4708
  peg$savedPos = s2;
4567
- s3 = peg$c139(s3, s4);
4709
+ s3 = peg$c141(s3, s4);
4568
4710
  s2 = s3;
4569
4711
  }
4570
4712
  else {
@@ -4583,7 +4725,7 @@ function peg$parse(input, options) {
4583
4725
  }
4584
4726
  if (s1 !== peg$FAILED) {
4585
4727
  peg$savedPos = s0;
4586
- s1 = peg$c140(s1);
4728
+ s1 = peg$c142(s1);
4587
4729
  }
4588
4730
  s0 = s1;
4589
4731
  if (s0 === peg$FAILED) {
@@ -4623,7 +4765,7 @@ function peg$parse(input, options) {
4623
4765
  s5 = peg$parsepod_configuration();
4624
4766
  if (s5 !== peg$FAILED) {
4625
4767
  peg$savedPos = peg$currPos;
4626
- s6 = peg$c141(s1, s3, s5);
4768
+ s6 = peg$c143(s1, s3, s5);
4627
4769
  if (s6) {
4628
4770
  s6 = void 0;
4629
4771
  }
@@ -4632,7 +4774,7 @@ function peg$parse(input, options) {
4632
4774
  }
4633
4775
  if (s6 !== peg$FAILED) {
4634
4776
  peg$savedPos = peg$currPos;
4635
- s7 = peg$c142(s1, s3, s5);
4777
+ s7 = peg$c144(s1, s3, s5);
4636
4778
  if (s7) {
4637
4779
  s7 = void 0;
4638
4780
  }
@@ -4685,12 +4827,12 @@ function peg$parse(input, options) {
4685
4827
  }
4686
4828
  if (s9 !== peg$FAILED) {
4687
4829
  peg$savedPos = s8;
4688
- s9 = peg$c143(s1, s3, s5, s9);
4830
+ s9 = peg$c145(s1, s3, s5, s9);
4689
4831
  }
4690
4832
  s8 = s9;
4691
4833
  if (s8 !== peg$FAILED) {
4692
4834
  peg$savedPos = peg$currPos;
4693
- s9 = peg$c144(s1, s3, s5, s8);
4835
+ s9 = peg$c146(s1, s3, s5, s8);
4694
4836
  if (s9) {
4695
4837
  s9 = void 0;
4696
4838
  }
@@ -4713,7 +4855,7 @@ function peg$parse(input, options) {
4713
4855
  s13 = peg$parsestrictIdentifier();
4714
4856
  if (s13 !== peg$FAILED) {
4715
4857
  peg$savedPos = peg$currPos;
4716
- s14 = peg$c122(s1, s3, s5, s8, s10, s13);
4858
+ s14 = peg$c124(s1, s3, s5, s8, s10, s13);
4717
4859
  if (s14) {
4718
4860
  s14 = void 0;
4719
4861
  }
@@ -4727,7 +4869,7 @@ function peg$parse(input, options) {
4727
4869
  }
4728
4870
  if (s15 !== peg$FAILED) {
4729
4871
  peg$savedPos = s11;
4730
- s12 = peg$c145(s1, s3, s5, s8, s10, s13);
4872
+ s12 = peg$c147(s1, s3, s5, s8, s10, s13);
4731
4873
  s11 = s12;
4732
4874
  }
4733
4875
  else {
@@ -4751,7 +4893,7 @@ function peg$parse(input, options) {
4751
4893
  }
4752
4894
  if (s11 !== peg$FAILED) {
4753
4895
  peg$savedPos = s0;
4754
- s1 = peg$c146(s1, s3, s5, s8, s10, s11);
4896
+ s1 = peg$c148(s1, s3, s5, s8, s10, s11);
4755
4897
  s0 = s1;
4756
4898
  }
4757
4899
  else {
@@ -4831,7 +4973,7 @@ function peg$parse(input, options) {
4831
4973
  s5 = peg$parsepod_configuration();
4832
4974
  if (s5 !== peg$FAILED) {
4833
4975
  peg$savedPos = peg$currPos;
4834
- s6 = peg$c141(s1, s3, s5);
4976
+ s6 = peg$c143(s1, s3, s5);
4835
4977
  if (s6) {
4836
4978
  s6 = void 0;
4837
4979
  }
@@ -4840,7 +4982,7 @@ function peg$parse(input, options) {
4840
4982
  }
4841
4983
  if (s6 !== peg$FAILED) {
4842
4984
  peg$savedPos = peg$currPos;
4843
- s7 = peg$c147(s1, s3, s5);
4985
+ s7 = peg$c149(s1, s3, s5);
4844
4986
  if (s7) {
4845
4987
  s7 = void 0;
4846
4988
  }
@@ -4866,7 +5008,7 @@ function peg$parse(input, options) {
4866
5008
  }
4867
5009
  if (s11 !== peg$FAILED) {
4868
5010
  peg$savedPos = s8;
4869
- s9 = peg$c148(s1, s3, s5, s10);
5011
+ s9 = peg$c150(s1, s3, s5, s10);
4870
5012
  s8 = s9;
4871
5013
  }
4872
5014
  else {
@@ -4899,7 +5041,7 @@ function peg$parse(input, options) {
4899
5041
  s12 = peg$parsestrictIdentifier();
4900
5042
  if (s12 !== peg$FAILED) {
4901
5043
  peg$savedPos = peg$currPos;
4902
- s13 = peg$c122(s1, s3, s5, s8, s9, s12);
5044
+ s13 = peg$c124(s1, s3, s5, s8, s9, s12);
4903
5045
  if (s13) {
4904
5046
  s13 = void 0;
4905
5047
  }
@@ -4913,7 +5055,7 @@ function peg$parse(input, options) {
4913
5055
  }
4914
5056
  if (s14 !== peg$FAILED) {
4915
5057
  peg$savedPos = s10;
4916
- s11 = peg$c149(s1, s3, s5, s8, s9, s12);
5058
+ s11 = peg$c151(s1, s3, s5, s8, s9, s12);
4917
5059
  s10 = s11;
4918
5060
  }
4919
5061
  else {
@@ -4937,7 +5079,7 @@ function peg$parse(input, options) {
4937
5079
  }
4938
5080
  if (s10 !== peg$FAILED) {
4939
5081
  peg$savedPos = peg$currPos;
4940
- s11 = peg$c124(s1, s3, s5, s8, s9, s10);
5082
+ s11 = peg$c126(s1, s3, s5, s8, s9, s10);
4941
5083
  if (s11) {
4942
5084
  s11 = void 0;
4943
5085
  }
@@ -4946,7 +5088,7 @@ function peg$parse(input, options) {
4946
5088
  }
4947
5089
  if (s11 !== peg$FAILED) {
4948
5090
  peg$savedPos = s0;
4949
- s1 = peg$c150(s1, s3, s5, s8, s9, s10);
5091
+ s1 = peg$c152(s1, s3, s5, s8, s9, s10);
4950
5092
  s0 = s1;
4951
5093
  }
4952
5094
  else {
@@ -5041,17 +5183,20 @@ function peg$parse(input, options) {
5041
5183
  if (s8 === peg$FAILED) {
5042
5184
  s8 = peg$parseparagraphBlock();
5043
5185
  if (s8 === peg$FAILED) {
5044
- s8 = peg$parsealiasDirective();
5186
+ s8 = peg$parsesetDirective();
5045
5187
  if (s8 === peg$FAILED) {
5046
- s8 = peg$parseconfigDirective();
5188
+ s8 = peg$parsealiasDirective();
5047
5189
  if (s8 === peg$FAILED) {
5048
- s8 = peg$parseboundaryDirective();
5190
+ s8 = peg$parseconfigDirective();
5049
5191
  if (s8 === peg$FAILED) {
5050
- s8 = peg$parseabbreviatedBlockRaw();
5192
+ s8 = peg$parseboundaryDirective();
5051
5193
  if (s8 === peg$FAILED) {
5052
- s8 = peg$parseabbreviatedBlockTable();
5194
+ s8 = peg$parseabbreviatedBlockRaw();
5053
5195
  if (s8 === peg$FAILED) {
5054
- s8 = peg$parseabbreviatedBlock();
5196
+ s8 = peg$parseabbreviatedBlockTable();
5197
+ if (s8 === peg$FAILED) {
5198
+ s8 = peg$parseabbreviatedBlock();
5199
+ }
5055
5200
  }
5056
5201
  }
5057
5202
  }
@@ -5066,7 +5211,7 @@ function peg$parse(input, options) {
5066
5211
  }
5067
5212
  if (s8 !== peg$FAILED) {
5068
5213
  peg$savedPos = s7;
5069
- s8 = peg$c151(s1, s3, s5, s8);
5214
+ s8 = peg$c153(s1, s3, s5, s8);
5070
5215
  }
5071
5216
  s7 = s8;
5072
5217
  if (s7 === peg$FAILED) {
@@ -5105,7 +5250,7 @@ function peg$parse(input, options) {
5105
5250
  }
5106
5251
  if (s9 !== peg$FAILED) {
5107
5252
  peg$savedPos = s7;
5108
- s8 = peg$c152(s1, s3, s5, s8, s9);
5253
+ s8 = peg$c154(s1, s3, s5, s8, s9);
5109
5254
  s7 = s8;
5110
5255
  }
5111
5256
  else {
@@ -5135,17 +5280,20 @@ function peg$parse(input, options) {
5135
5280
  if (s8 === peg$FAILED) {
5136
5281
  s8 = peg$parseparagraphBlock();
5137
5282
  if (s8 === peg$FAILED) {
5138
- s8 = peg$parsealiasDirective();
5283
+ s8 = peg$parsesetDirective();
5139
5284
  if (s8 === peg$FAILED) {
5140
- s8 = peg$parseconfigDirective();
5285
+ s8 = peg$parsealiasDirective();
5141
5286
  if (s8 === peg$FAILED) {
5142
- s8 = peg$parseboundaryDirective();
5287
+ s8 = peg$parseconfigDirective();
5143
5288
  if (s8 === peg$FAILED) {
5144
- s8 = peg$parseabbreviatedBlockRaw();
5289
+ s8 = peg$parseboundaryDirective();
5145
5290
  if (s8 === peg$FAILED) {
5146
- s8 = peg$parseabbreviatedBlockTable();
5291
+ s8 = peg$parseabbreviatedBlockRaw();
5147
5292
  if (s8 === peg$FAILED) {
5148
- s8 = peg$parseabbreviatedBlock();
5293
+ s8 = peg$parseabbreviatedBlockTable();
5294
+ if (s8 === peg$FAILED) {
5295
+ s8 = peg$parseabbreviatedBlock();
5296
+ }
5149
5297
  }
5150
5298
  }
5151
5299
  }
@@ -5160,7 +5308,7 @@ function peg$parse(input, options) {
5160
5308
  }
5161
5309
  if (s8 !== peg$FAILED) {
5162
5310
  peg$savedPos = s7;
5163
- s8 = peg$c151(s1, s3, s5, s8);
5311
+ s8 = peg$c153(s1, s3, s5, s8);
5164
5312
  }
5165
5313
  s7 = s8;
5166
5314
  if (s7 === peg$FAILED) {
@@ -5199,7 +5347,7 @@ function peg$parse(input, options) {
5199
5347
  }
5200
5348
  if (s9 !== peg$FAILED) {
5201
5349
  peg$savedPos = s7;
5202
- s8 = peg$c152(s1, s3, s5, s8, s9);
5350
+ s8 = peg$c154(s1, s3, s5, s8, s9);
5203
5351
  s7 = s8;
5204
5352
  }
5205
5353
  else {
@@ -5229,7 +5377,7 @@ function peg$parse(input, options) {
5229
5377
  s10 = peg$parsestrictIdentifier();
5230
5378
  if (s10 !== peg$FAILED) {
5231
5379
  peg$savedPos = peg$currPos;
5232
- s11 = peg$c122(s1, s3, s5, s6, s7, s10);
5380
+ s11 = peg$c124(s1, s3, s5, s6, s7, s10);
5233
5381
  if (s11) {
5234
5382
  s11 = void 0;
5235
5383
  }
@@ -5243,7 +5391,7 @@ function peg$parse(input, options) {
5243
5391
  }
5244
5392
  if (s12 !== peg$FAILED) {
5245
5393
  peg$savedPos = s8;
5246
- s9 = peg$c153(s1, s3, s5, s6, s7, s10);
5394
+ s9 = peg$c155(s1, s3, s5, s6, s7, s10);
5247
5395
  s8 = s9;
5248
5396
  }
5249
5397
  else {
@@ -5267,7 +5415,7 @@ function peg$parse(input, options) {
5267
5415
  }
5268
5416
  if (s8 !== peg$FAILED) {
5269
5417
  peg$savedPos = peg$currPos;
5270
- s9 = peg$c124(s1, s3, s5, s6, s7, s8);
5418
+ s9 = peg$c126(s1, s3, s5, s6, s7, s8);
5271
5419
  if (s9) {
5272
5420
  s9 = void 0;
5273
5421
  }
@@ -5276,7 +5424,7 @@ function peg$parse(input, options) {
5276
5424
  }
5277
5425
  if (s9 !== peg$FAILED) {
5278
5426
  peg$savedPos = s0;
5279
- s1 = peg$c154(s1, s3, s5, s6, s7, s8);
5427
+ s1 = peg$c156(s1, s3, s5, s6, s7, s8);
5280
5428
  s0 = s1;
5281
5429
  }
5282
5430
  else {
@@ -5341,7 +5489,7 @@ function peg$parse(input, options) {
5341
5489
  }
5342
5490
  if (s1 !== peg$FAILED) {
5343
5491
  peg$savedPos = s0;
5344
- s1 = peg$c155();
5492
+ s1 = peg$c157();
5345
5493
  }
5346
5494
  s0 = s1;
5347
5495
  return s0;
@@ -5354,32 +5502,32 @@ function peg$parse(input, options) {
5354
5502
  s3 = peg$parseemptyline();
5355
5503
  if (s3 !== peg$FAILED) {
5356
5504
  peg$savedPos = s2;
5357
- s3 = peg$c156();
5505
+ s3 = peg$c158();
5358
5506
  }
5359
5507
  s2 = s3;
5360
5508
  if (s2 === peg$FAILED) {
5361
5509
  s2 = [];
5362
- if (peg$c157.test(input.charAt(peg$currPos))) {
5510
+ if (peg$c159.test(input.charAt(peg$currPos))) {
5363
5511
  s3 = input.charAt(peg$currPos);
5364
5512
  peg$currPos++;
5365
5513
  }
5366
5514
  else {
5367
5515
  s3 = peg$FAILED;
5368
5516
  if (peg$silentFails === 0) {
5369
- peg$fail(peg$c158);
5517
+ peg$fail(peg$c160);
5370
5518
  }
5371
5519
  }
5372
5520
  if (s3 !== peg$FAILED) {
5373
5521
  while (s3 !== peg$FAILED) {
5374
5522
  s2.push(s3);
5375
- if (peg$c157.test(input.charAt(peg$currPos))) {
5523
+ if (peg$c159.test(input.charAt(peg$currPos))) {
5376
5524
  s3 = input.charAt(peg$currPos);
5377
5525
  peg$currPos++;
5378
5526
  }
5379
5527
  else {
5380
5528
  s3 = peg$FAILED;
5381
5529
  if (peg$silentFails === 0) {
5382
- peg$fail(peg$c158);
5530
+ peg$fail(peg$c160);
5383
5531
  }
5384
5532
  }
5385
5533
  }
@@ -5398,32 +5546,32 @@ function peg$parse(input, options) {
5398
5546
  s3 = peg$parseemptyline();
5399
5547
  if (s3 !== peg$FAILED) {
5400
5548
  peg$savedPos = s2;
5401
- s3 = peg$c156();
5549
+ s3 = peg$c158();
5402
5550
  }
5403
5551
  s2 = s3;
5404
5552
  if (s2 === peg$FAILED) {
5405
5553
  s2 = [];
5406
- if (peg$c157.test(input.charAt(peg$currPos))) {
5554
+ if (peg$c159.test(input.charAt(peg$currPos))) {
5407
5555
  s3 = input.charAt(peg$currPos);
5408
5556
  peg$currPos++;
5409
5557
  }
5410
5558
  else {
5411
5559
  s3 = peg$FAILED;
5412
5560
  if (peg$silentFails === 0) {
5413
- peg$fail(peg$c158);
5561
+ peg$fail(peg$c160);
5414
5562
  }
5415
5563
  }
5416
5564
  if (s3 !== peg$FAILED) {
5417
5565
  while (s3 !== peg$FAILED) {
5418
5566
  s2.push(s3);
5419
- if (peg$c157.test(input.charAt(peg$currPos))) {
5567
+ if (peg$c159.test(input.charAt(peg$currPos))) {
5420
5568
  s3 = input.charAt(peg$currPos);
5421
5569
  peg$currPos++;
5422
5570
  }
5423
5571
  else {
5424
5572
  s3 = peg$FAILED;
5425
5573
  if (peg$silentFails === 0) {
5426
- peg$fail(peg$c158);
5574
+ peg$fail(peg$c160);
5427
5575
  }
5428
5576
  }
5429
5577
  }
@@ -5442,7 +5590,7 @@ function peg$parse(input, options) {
5442
5590
  }
5443
5591
  if (s1 !== peg$FAILED) {
5444
5592
  peg$savedPos = s0;
5445
- s1 = peg$c159(s1);
5593
+ s1 = peg$c161(s1);
5446
5594
  }
5447
5595
  s0 = s1;
5448
5596
  return s0;
@@ -5481,7 +5629,7 @@ function peg$parse(input, options) {
5481
5629
  }
5482
5630
  if (s5 !== peg$FAILED) {
5483
5631
  peg$savedPos = peg$currPos;
5484
- s6 = peg$c160(s1, s3);
5632
+ s6 = peg$c162(s1, s3);
5485
5633
  if (s6) {
5486
5634
  s6 = void 0;
5487
5635
  }
@@ -5556,7 +5704,7 @@ function peg$parse(input, options) {
5556
5704
  }
5557
5705
  if (s7 !== peg$FAILED) {
5558
5706
  peg$savedPos = s0;
5559
- s1 = peg$c161(s1, s3, s7);
5707
+ s1 = peg$c163(s1, s3, s7);
5560
5708
  s0 = s1;
5561
5709
  }
5562
5710
  else {
@@ -5629,7 +5777,7 @@ function peg$parse(input, options) {
5629
5777
  }
5630
5778
  if (s5 !== peg$FAILED) {
5631
5779
  peg$savedPos = peg$currPos;
5632
- s6 = peg$c162(s1, s3);
5780
+ s6 = peg$c164(s1, s3);
5633
5781
  if (s6) {
5634
5782
  s6 = void 0;
5635
5783
  }
@@ -5638,7 +5786,7 @@ function peg$parse(input, options) {
5638
5786
  }
5639
5787
  if (s6 !== peg$FAILED) {
5640
5788
  peg$savedPos = peg$currPos;
5641
- s7 = peg$c163(s1, s3);
5789
+ s7 = peg$c165(s1, s3);
5642
5790
  if (s7) {
5643
5791
  s7 = void 0;
5644
5792
  }
@@ -5649,7 +5797,7 @@ function peg$parse(input, options) {
5649
5797
  s8 = peg$parsetableContents();
5650
5798
  if (s8 !== peg$FAILED) {
5651
5799
  peg$savedPos = s0;
5652
- s1 = peg$c164(s1, s3, s8);
5800
+ s1 = peg$c166(s1, s3, s8);
5653
5801
  s0 = s1;
5654
5802
  }
5655
5803
  else {
@@ -5793,7 +5941,7 @@ function peg$parse(input, options) {
5793
5941
  }
5794
5942
  if (s6 !== peg$FAILED) {
5795
5943
  peg$savedPos = s0;
5796
- s1 = peg$c165(s1, s3, s5, s6);
5944
+ s1 = peg$c167(s1, s3, s5, s6);
5797
5945
  s0 = s1;
5798
5946
  }
5799
5947
  else {
@@ -5843,14 +5991,14 @@ function peg$parse(input, options) {
5843
5991
  s4 = peg$currPos;
5844
5992
  s5 = peg$parse_();
5845
5993
  if (s5 !== peg$FAILED) {
5846
- if (input.substr(peg$currPos, 2) === peg$c166) {
5847
- s6 = peg$c166;
5994
+ if (input.substr(peg$currPos, 2) === peg$c168) {
5995
+ s6 = peg$c168;
5848
5996
  peg$currPos += 2;
5849
5997
  }
5850
5998
  else {
5851
5999
  s6 = peg$FAILED;
5852
6000
  if (peg$silentFails === 0) {
5853
- peg$fail(peg$c167);
6001
+ peg$fail(peg$c169);
5854
6002
  }
5855
6003
  }
5856
6004
  if (s6 !== peg$FAILED) {
@@ -5873,7 +6021,7 @@ function peg$parse(input, options) {
5873
6021
  s10 = peg$parsenewline();
5874
6022
  if (s10 !== peg$FAILED) {
5875
6023
  peg$savedPos = s4;
5876
- s5 = peg$c90(s1, s8);
6024
+ s5 = peg$c92(s1, s8);
5877
6025
  s4 = s5;
5878
6026
  }
5879
6027
  else {
@@ -5910,14 +6058,14 @@ function peg$parse(input, options) {
5910
6058
  s4 = peg$currPos;
5911
6059
  s5 = peg$parse_();
5912
6060
  if (s5 !== peg$FAILED) {
5913
- if (input.substr(peg$currPos, 2) === peg$c166) {
5914
- s6 = peg$c166;
6061
+ if (input.substr(peg$currPos, 2) === peg$c168) {
6062
+ s6 = peg$c168;
5915
6063
  peg$currPos += 2;
5916
6064
  }
5917
6065
  else {
5918
6066
  s6 = peg$FAILED;
5919
6067
  if (peg$silentFails === 0) {
5920
- peg$fail(peg$c167);
6068
+ peg$fail(peg$c169);
5921
6069
  }
5922
6070
  }
5923
6071
  if (s6 !== peg$FAILED) {
@@ -5940,7 +6088,7 @@ function peg$parse(input, options) {
5940
6088
  s10 = peg$parsenewline();
5941
6089
  if (s10 !== peg$FAILED) {
5942
6090
  peg$savedPos = s4;
5943
- s5 = peg$c90(s1, s8);
6091
+ s5 = peg$c92(s1, s8);
5944
6092
  s4 = s5;
5945
6093
  }
5946
6094
  else {
@@ -5975,7 +6123,352 @@ function peg$parse(input, options) {
5975
6123
  }
5976
6124
  if (s3 !== peg$FAILED) {
5977
6125
  peg$savedPos = s0;
5978
- s1 = peg$c91(s1, s3);
6126
+ s1 = peg$c93(s1, s3);
6127
+ s0 = s1;
6128
+ }
6129
+ else {
6130
+ peg$currPos = s0;
6131
+ s0 = peg$FAILED;
6132
+ }
6133
+ }
6134
+ else {
6135
+ peg$currPos = s0;
6136
+ s0 = peg$FAILED;
6137
+ }
6138
+ }
6139
+ else {
6140
+ peg$currPos = s0;
6141
+ s0 = peg$FAILED;
6142
+ }
6143
+ return s0;
6144
+ }
6145
+ function peg$parsesetLineAttrs() {
6146
+ var s0, s1, s2, s3;
6147
+ s0 = peg$currPos;
6148
+ s1 = [];
6149
+ s2 = peg$parseattributes();
6150
+ if (s2 !== peg$FAILED) {
6151
+ while (s2 !== peg$FAILED) {
6152
+ s1.push(s2);
6153
+ s2 = peg$parseattributes();
6154
+ }
6155
+ }
6156
+ else {
6157
+ s1 = peg$FAILED;
6158
+ }
6159
+ if (s1 !== peg$FAILED) {
6160
+ s2 = peg$parse_();
6161
+ if (s2 !== peg$FAILED) {
6162
+ s3 = peg$parseEOL();
6163
+ if (s3 !== peg$FAILED) {
6164
+ peg$savedPos = s0;
6165
+ s1 = peg$c170(s1);
6166
+ s0 = s1;
6167
+ }
6168
+ else {
6169
+ peg$currPos = s0;
6170
+ s0 = peg$FAILED;
6171
+ }
6172
+ }
6173
+ else {
6174
+ peg$currPos = s0;
6175
+ s0 = peg$FAILED;
6176
+ }
6177
+ }
6178
+ else {
6179
+ peg$currPos = s0;
6180
+ s0 = peg$FAILED;
6181
+ }
6182
+ return s0;
6183
+ }
6184
+ function peg$parsesetLineAlias() {
6185
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
6186
+ s0 = peg$currPos;
6187
+ s1 = peg$parse_();
6188
+ if (s1 !== peg$FAILED) {
6189
+ if (input.charCodeAt(peg$currPos) === 58) {
6190
+ s2 = peg$c51;
6191
+ peg$currPos++;
6192
+ }
6193
+ else {
6194
+ s2 = peg$FAILED;
6195
+ if (peg$silentFails === 0) {
6196
+ peg$fail(peg$c52);
6197
+ }
6198
+ }
6199
+ if (s2 !== peg$FAILED) {
6200
+ s3 = peg$parseidentifier();
6201
+ if (s3 !== peg$FAILED) {
6202
+ s4 = [];
6203
+ s5 = peg$parsehs();
6204
+ if (s5 !== peg$FAILED) {
6205
+ while (s5 !== peg$FAILED) {
6206
+ s4.push(s5);
6207
+ s5 = peg$parsehs();
6208
+ }
6209
+ }
6210
+ else {
6211
+ s4 = peg$FAILED;
6212
+ }
6213
+ if (s4 !== peg$FAILED) {
6214
+ s5 = peg$currPos;
6215
+ s6 = [];
6216
+ s7 = peg$currPos;
6217
+ s8 = peg$currPos;
6218
+ peg$silentFails++;
6219
+ s9 = peg$parseEOL();
6220
+ peg$silentFails--;
6221
+ if (s9 === peg$FAILED) {
6222
+ s8 = void 0;
6223
+ }
6224
+ else {
6225
+ peg$currPos = s8;
6226
+ s8 = peg$FAILED;
6227
+ }
6228
+ if (s8 !== peg$FAILED) {
6229
+ if (input.length > peg$currPos) {
6230
+ s9 = input.charAt(peg$currPos);
6231
+ peg$currPos++;
6232
+ }
6233
+ else {
6234
+ s9 = peg$FAILED;
6235
+ if (peg$silentFails === 0) {
6236
+ peg$fail(peg$c4);
6237
+ }
6238
+ }
6239
+ if (s9 !== peg$FAILED) {
6240
+ s8 = [s8, s9];
6241
+ s7 = s8;
6242
+ }
6243
+ else {
6244
+ peg$currPos = s7;
6245
+ s7 = peg$FAILED;
6246
+ }
6247
+ }
6248
+ else {
6249
+ peg$currPos = s7;
6250
+ s7 = peg$FAILED;
6251
+ }
6252
+ if (s7 !== peg$FAILED) {
6253
+ while (s7 !== peg$FAILED) {
6254
+ s6.push(s7);
6255
+ s7 = peg$currPos;
6256
+ s8 = peg$currPos;
6257
+ peg$silentFails++;
6258
+ s9 = peg$parseEOL();
6259
+ peg$silentFails--;
6260
+ if (s9 === peg$FAILED) {
6261
+ s8 = void 0;
6262
+ }
6263
+ else {
6264
+ peg$currPos = s8;
6265
+ s8 = peg$FAILED;
6266
+ }
6267
+ if (s8 !== peg$FAILED) {
6268
+ if (input.length > peg$currPos) {
6269
+ s9 = input.charAt(peg$currPos);
6270
+ peg$currPos++;
6271
+ }
6272
+ else {
6273
+ s9 = peg$FAILED;
6274
+ if (peg$silentFails === 0) {
6275
+ peg$fail(peg$c4);
6276
+ }
6277
+ }
6278
+ if (s9 !== peg$FAILED) {
6279
+ s8 = [s8, s9];
6280
+ s7 = s8;
6281
+ }
6282
+ else {
6283
+ peg$currPos = s7;
6284
+ s7 = peg$FAILED;
6285
+ }
6286
+ }
6287
+ else {
6288
+ peg$currPos = s7;
6289
+ s7 = peg$FAILED;
6290
+ }
6291
+ }
6292
+ }
6293
+ else {
6294
+ s6 = peg$FAILED;
6295
+ }
6296
+ if (s6 !== peg$FAILED) {
6297
+ s5 = input.substring(s5, peg$currPos);
6298
+ }
6299
+ else {
6300
+ s5 = s6;
6301
+ }
6302
+ if (s5 !== peg$FAILED) {
6303
+ s6 = peg$parseEOL();
6304
+ if (s6 !== peg$FAILED) {
6305
+ peg$savedPos = s0;
6306
+ s1 = peg$c171(s3, s5);
6307
+ s0 = s1;
6308
+ }
6309
+ else {
6310
+ peg$currPos = s0;
6311
+ s0 = peg$FAILED;
6312
+ }
6313
+ }
6314
+ else {
6315
+ peg$currPos = s0;
6316
+ s0 = peg$FAILED;
6317
+ }
6318
+ }
6319
+ else {
6320
+ peg$currPos = s0;
6321
+ s0 = peg$FAILED;
6322
+ }
6323
+ }
6324
+ else {
6325
+ peg$currPos = s0;
6326
+ s0 = peg$FAILED;
6327
+ }
6328
+ }
6329
+ else {
6330
+ peg$currPos = s0;
6331
+ s0 = peg$FAILED;
6332
+ }
6333
+ }
6334
+ else {
6335
+ peg$currPos = s0;
6336
+ s0 = peg$FAILED;
6337
+ }
6338
+ return s0;
6339
+ }
6340
+ function peg$parsesetContLine() {
6341
+ var s0, s1, s2, s3, s4, s5, s6, s7, s8;
6342
+ s0 = peg$currPos;
6343
+ if (input.charCodeAt(peg$currPos) === 61) {
6344
+ s1 = peg$c32;
6345
+ peg$currPos++;
6346
+ }
6347
+ else {
6348
+ s1 = peg$FAILED;
6349
+ if (peg$silentFails === 0) {
6350
+ peg$fail(peg$c33);
6351
+ }
6352
+ }
6353
+ if (s1 !== peg$FAILED) {
6354
+ s2 = [];
6355
+ s3 = peg$parsehs();
6356
+ if (s3 !== peg$FAILED) {
6357
+ while (s3 !== peg$FAILED) {
6358
+ s2.push(s3);
6359
+ s3 = peg$parsehs();
6360
+ }
6361
+ }
6362
+ else {
6363
+ s2 = peg$FAILED;
6364
+ }
6365
+ if (s2 !== peg$FAILED) {
6366
+ s3 = peg$parsesetLineAttrs();
6367
+ if (s3 === peg$FAILED) {
6368
+ s3 = peg$currPos;
6369
+ s4 = peg$currPos;
6370
+ s5 = [];
6371
+ s6 = peg$currPos;
6372
+ s7 = peg$currPos;
6373
+ peg$silentFails++;
6374
+ s8 = peg$parseEOL();
6375
+ peg$silentFails--;
6376
+ if (s8 === peg$FAILED) {
6377
+ s7 = void 0;
6378
+ }
6379
+ else {
6380
+ peg$currPos = s7;
6381
+ s7 = peg$FAILED;
6382
+ }
6383
+ if (s7 !== peg$FAILED) {
6384
+ if (input.length > peg$currPos) {
6385
+ s8 = input.charAt(peg$currPos);
6386
+ peg$currPos++;
6387
+ }
6388
+ else {
6389
+ s8 = peg$FAILED;
6390
+ if (peg$silentFails === 0) {
6391
+ peg$fail(peg$c4);
6392
+ }
6393
+ }
6394
+ if (s8 !== peg$FAILED) {
6395
+ s7 = [s7, s8];
6396
+ s6 = s7;
6397
+ }
6398
+ else {
6399
+ peg$currPos = s6;
6400
+ s6 = peg$FAILED;
6401
+ }
6402
+ }
6403
+ else {
6404
+ peg$currPos = s6;
6405
+ s6 = peg$FAILED;
6406
+ }
6407
+ while (s6 !== peg$FAILED) {
6408
+ s5.push(s6);
6409
+ s6 = peg$currPos;
6410
+ s7 = peg$currPos;
6411
+ peg$silentFails++;
6412
+ s8 = peg$parseEOL();
6413
+ peg$silentFails--;
6414
+ if (s8 === peg$FAILED) {
6415
+ s7 = void 0;
6416
+ }
6417
+ else {
6418
+ peg$currPos = s7;
6419
+ s7 = peg$FAILED;
6420
+ }
6421
+ if (s7 !== peg$FAILED) {
6422
+ if (input.length > peg$currPos) {
6423
+ s8 = input.charAt(peg$currPos);
6424
+ peg$currPos++;
6425
+ }
6426
+ else {
6427
+ s8 = peg$FAILED;
6428
+ if (peg$silentFails === 0) {
6429
+ peg$fail(peg$c4);
6430
+ }
6431
+ }
6432
+ if (s8 !== peg$FAILED) {
6433
+ s7 = [s7, s8];
6434
+ s6 = s7;
6435
+ }
6436
+ else {
6437
+ peg$currPos = s6;
6438
+ s6 = peg$FAILED;
6439
+ }
6440
+ }
6441
+ else {
6442
+ peg$currPos = s6;
6443
+ s6 = peg$FAILED;
6444
+ }
6445
+ }
6446
+ if (s5 !== peg$FAILED) {
6447
+ s4 = input.substring(s4, peg$currPos);
6448
+ }
6449
+ else {
6450
+ s4 = s5;
6451
+ }
6452
+ if (s4 !== peg$FAILED) {
6453
+ s5 = peg$parseEOL();
6454
+ if (s5 !== peg$FAILED) {
6455
+ peg$savedPos = s3;
6456
+ s4 = peg$c172(s4);
6457
+ s3 = s4;
6458
+ }
6459
+ else {
6460
+ peg$currPos = s3;
6461
+ s3 = peg$FAILED;
6462
+ }
6463
+ }
6464
+ else {
6465
+ peg$currPos = s3;
6466
+ s3 = peg$FAILED;
6467
+ }
6468
+ }
6469
+ if (s3 !== peg$FAILED) {
6470
+ peg$savedPos = s0;
6471
+ s1 = peg$c173(s3);
5979
6472
  s0 = s1;
5980
6473
  }
5981
6474
  else {
@@ -5994,6 +6487,83 @@ function peg$parse(input, options) {
5994
6487
  }
5995
6488
  return s0;
5996
6489
  }
6490
+ function peg$parsesetDirective() {
6491
+ var s0, s1, s2, s3, s4, s5, s6;
6492
+ s0 = peg$currPos;
6493
+ s1 = peg$currPos;
6494
+ s2 = peg$parse_();
6495
+ if (s2 !== peg$FAILED) {
6496
+ s1 = input.substring(s1, peg$currPos);
6497
+ }
6498
+ else {
6499
+ s1 = s2;
6500
+ }
6501
+ if (s1 !== peg$FAILED) {
6502
+ if (input.substr(peg$currPos, 4) === peg$c174) {
6503
+ s2 = peg$c174;
6504
+ peg$currPos += 4;
6505
+ }
6506
+ else {
6507
+ s2 = peg$FAILED;
6508
+ if (peg$silentFails === 0) {
6509
+ peg$fail(peg$c175);
6510
+ }
6511
+ }
6512
+ if (s2 !== peg$FAILED) {
6513
+ s3 = [];
6514
+ s4 = peg$parsehs();
6515
+ if (s4 !== peg$FAILED) {
6516
+ while (s4 !== peg$FAILED) {
6517
+ s3.push(s4);
6518
+ s4 = peg$parsehs();
6519
+ }
6520
+ }
6521
+ else {
6522
+ s3 = peg$FAILED;
6523
+ }
6524
+ if (s3 !== peg$FAILED) {
6525
+ s4 = peg$parsesetLineAttrs();
6526
+ if (s4 === peg$FAILED) {
6527
+ s4 = peg$parsesetLineAlias();
6528
+ }
6529
+ if (s4 !== peg$FAILED) {
6530
+ s5 = [];
6531
+ s6 = peg$parsesetContLine();
6532
+ while (s6 !== peg$FAILED) {
6533
+ s5.push(s6);
6534
+ s6 = peg$parsesetContLine();
6535
+ }
6536
+ if (s5 !== peg$FAILED) {
6537
+ peg$savedPos = s0;
6538
+ s1 = peg$c176(s1, s4, s5);
6539
+ s0 = s1;
6540
+ }
6541
+ else {
6542
+ peg$currPos = s0;
6543
+ s0 = peg$FAILED;
6544
+ }
6545
+ }
6546
+ else {
6547
+ peg$currPos = s0;
6548
+ s0 = peg$FAILED;
6549
+ }
6550
+ }
6551
+ else {
6552
+ peg$currPos = s0;
6553
+ s0 = peg$FAILED;
6554
+ }
6555
+ }
6556
+ else {
6557
+ peg$currPos = s0;
6558
+ s0 = peg$FAILED;
6559
+ }
6560
+ }
6561
+ else {
6562
+ peg$currPos = s0;
6563
+ s0 = peg$FAILED;
6564
+ }
6565
+ return s0;
6566
+ }
5997
6567
  function peg$parsealiasDirective() {
5998
6568
  var s0, s1, s2, s3, s4, s5, s6;
5999
6569
  s0 = peg$currPos;
@@ -6033,7 +6603,7 @@ function peg$parse(input, options) {
6033
6603
  s6 = peg$parsealias_replacement_text();
6034
6604
  if (s6 !== peg$FAILED) {
6035
6605
  peg$savedPos = s0;
6036
- s1 = peg$c168(s1, s2, s4, s6);
6606
+ s1 = peg$c177(s1, s2, s4, s6);
6037
6607
  s0 = s1;
6038
6608
  }
6039
6609
  else {
@@ -6094,25 +6664,25 @@ function peg$parse(input, options) {
6094
6664
  if (s3 !== peg$FAILED) {
6095
6665
  s4 = peg$currPos;
6096
6666
  s5 = peg$currPos;
6097
- if (peg$c169.test(input.charAt(peg$currPos))) {
6667
+ if (peg$c178.test(input.charAt(peg$currPos))) {
6098
6668
  s6 = input.charAt(peg$currPos);
6099
6669
  peg$currPos++;
6100
6670
  }
6101
6671
  else {
6102
6672
  s6 = peg$FAILED;
6103
6673
  if (peg$silentFails === 0) {
6104
- peg$fail(peg$c170);
6674
+ peg$fail(peg$c179);
6105
6675
  }
6106
6676
  }
6107
6677
  if (s6 !== peg$FAILED) {
6108
- if (input.substr(peg$currPos, 2) === peg$c171) {
6109
- s7 = peg$c171;
6678
+ if (input.substr(peg$currPos, 2) === peg$c180) {
6679
+ s7 = peg$c180;
6110
6680
  peg$currPos += 2;
6111
6681
  }
6112
6682
  else {
6113
6683
  s7 = peg$FAILED;
6114
6684
  if (peg$silentFails === 0) {
6115
- peg$fail(peg$c172);
6685
+ peg$fail(peg$c181);
6116
6686
  }
6117
6687
  }
6118
6688
  if (s7 !== peg$FAILED) {
@@ -6143,7 +6713,7 @@ function peg$parse(input, options) {
6143
6713
  s6 = peg$parsepod_configuration();
6144
6714
  if (s6 !== peg$FAILED) {
6145
6715
  peg$savedPos = s0;
6146
- s1 = peg$c173(s1, s2, s4, s6);
6716
+ s1 = peg$c182(s1, s2, s4, s6);
6147
6717
  s0 = s1;
6148
6718
  }
6149
6719
  else {
@@ -6189,14 +6759,14 @@ function peg$parse(input, options) {
6189
6759
  s1 = s2;
6190
6760
  }
6191
6761
  if (s1 !== peg$FAILED) {
6192
- if (input.substr(peg$currPos, 9) === peg$c174) {
6193
- s2 = peg$c174;
6762
+ if (input.substr(peg$currPos, 9) === peg$c183) {
6763
+ s2 = peg$c183;
6194
6764
  peg$currPos += 9;
6195
6765
  }
6196
6766
  else {
6197
6767
  s2 = peg$FAILED;
6198
6768
  if (peg$silentFails === 0) {
6199
- peg$fail(peg$c175);
6769
+ peg$fail(peg$c184);
6200
6770
  }
6201
6771
  }
6202
6772
  if (s2 !== peg$FAILED) {
@@ -6205,7 +6775,7 @@ function peg$parse(input, options) {
6205
6775
  s4 = peg$parsepod_configuration();
6206
6776
  if (s4 !== peg$FAILED) {
6207
6777
  peg$savedPos = s0;
6208
- s1 = peg$c176(s1, s2, s4);
6778
+ s1 = peg$c185(s1, s2, s4);
6209
6779
  s0 = s1;
6210
6780
  }
6211
6781
  else {
@@ -6250,7 +6820,7 @@ function peg$parse(input, options) {
6250
6820
  s5 = peg$parsepod_configuration();
6251
6821
  if (s5 !== peg$FAILED) {
6252
6822
  peg$savedPos = peg$currPos;
6253
- s6 = peg$c177(s1, s2, s3, s5);
6823
+ s6 = peg$c186(s1, s2, s3, s5);
6254
6824
  if (s6) {
6255
6825
  s6 = void 0;
6256
6826
  }
@@ -6325,7 +6895,7 @@ function peg$parse(input, options) {
6325
6895
  }
6326
6896
  if (s7 !== peg$FAILED) {
6327
6897
  peg$savedPos = s0;
6328
- s1 = peg$c178(s1, s2, s3, s5, s7);
6898
+ s1 = peg$c187(s1, s2, s3, s5, s7);
6329
6899
  s0 = s1;
6330
6900
  }
6331
6901
  else {
@@ -6385,7 +6955,7 @@ function peg$parse(input, options) {
6385
6955
  s5 = peg$parsepod_configuration();
6386
6956
  if (s5 !== peg$FAILED) {
6387
6957
  peg$savedPos = peg$currPos;
6388
- s6 = peg$c179(s1, s2, s3, s5);
6958
+ s6 = peg$c188(s1, s2, s3, s5);
6389
6959
  if (s6) {
6390
6960
  s6 = void 0;
6391
6961
  }
@@ -6394,7 +6964,7 @@ function peg$parse(input, options) {
6394
6964
  }
6395
6965
  if (s6 !== peg$FAILED) {
6396
6966
  peg$savedPos = peg$currPos;
6397
- s7 = peg$c180(s1, s2, s3, s5);
6967
+ s7 = peg$c189(s1, s2, s3, s5);
6398
6968
  if (s7) {
6399
6969
  s7 = void 0;
6400
6970
  }
@@ -6405,7 +6975,7 @@ function peg$parse(input, options) {
6405
6975
  s8 = peg$parsetableContents();
6406
6976
  if (s8 !== peg$FAILED) {
6407
6977
  peg$savedPos = s0;
6408
- s1 = peg$c181(s1, s2, s3, s5, s8);
6978
+ s1 = peg$c190(s1, s2, s3, s5, s8);
6409
6979
  s0 = s1;
6410
6980
  }
6411
6981
  else {
@@ -6536,7 +7106,7 @@ function peg$parse(input, options) {
6536
7106
  }
6537
7107
  if (s6 !== peg$FAILED) {
6538
7108
  peg$savedPos = s0;
6539
- s1 = peg$c182(s1, s2, s3, s5, s6);
7109
+ s1 = peg$c191(s1, s2, s3, s5, s6);
6540
7110
  s0 = s1;
6541
7111
  }
6542
7112
  else {
@@ -6574,14 +7144,14 @@ function peg$parse(input, options) {
6574
7144
  var s0, s1, s2, s3, s4;
6575
7145
  s0 = peg$currPos;
6576
7146
  s1 = peg$currPos;
6577
- if (peg$c183.test(input.charAt(peg$currPos))) {
7147
+ if (peg$c192.test(input.charAt(peg$currPos))) {
6578
7148
  s2 = input.charAt(peg$currPos);
6579
7149
  peg$currPos++;
6580
7150
  }
6581
7151
  else {
6582
7152
  s2 = peg$FAILED;
6583
7153
  if (peg$silentFails === 0) {
6584
- peg$fail(peg$c184);
7154
+ peg$fail(peg$c193);
6585
7155
  }
6586
7156
  }
6587
7157
  if (s2 !== peg$FAILED) {
@@ -6634,26 +7204,26 @@ function peg$parse(input, options) {
6634
7204
  var s0, s1;
6635
7205
  peg$silentFails++;
6636
7206
  s0 = [];
6637
- if (peg$c186.test(input.charAt(peg$currPos))) {
7207
+ if (peg$c195.test(input.charAt(peg$currPos))) {
6638
7208
  s1 = input.charAt(peg$currPos);
6639
7209
  peg$currPos++;
6640
7210
  }
6641
7211
  else {
6642
7212
  s1 = peg$FAILED;
6643
7213
  if (peg$silentFails === 0) {
6644
- peg$fail(peg$c187);
7214
+ peg$fail(peg$c196);
6645
7215
  }
6646
7216
  }
6647
7217
  while (s1 !== peg$FAILED) {
6648
7218
  s0.push(s1);
6649
- if (peg$c186.test(input.charAt(peg$currPos))) {
7219
+ if (peg$c195.test(input.charAt(peg$currPos))) {
6650
7220
  s1 = input.charAt(peg$currPos);
6651
7221
  peg$currPos++;
6652
7222
  }
6653
7223
  else {
6654
7224
  s1 = peg$FAILED;
6655
7225
  if (peg$silentFails === 0) {
6656
- peg$fail(peg$c187);
7226
+ peg$fail(peg$c196);
6657
7227
  }
6658
7228
  }
6659
7229
  }
@@ -6661,7 +7231,7 @@ function peg$parse(input, options) {
6661
7231
  if (s0 === peg$FAILED) {
6662
7232
  s1 = peg$FAILED;
6663
7233
  if (peg$silentFails === 0) {
6664
- peg$fail(peg$c185);
7234
+ peg$fail(peg$c194);
6665
7235
  }
6666
7236
  }
6667
7237
  return s0;
@@ -6670,26 +7240,26 @@ function peg$parse(input, options) {
6670
7240
  var s0, s1;
6671
7241
  peg$silentFails++;
6672
7242
  s0 = [];
6673
- if (peg$c186.test(input.charAt(peg$currPos))) {
7243
+ if (peg$c195.test(input.charAt(peg$currPos))) {
6674
7244
  s1 = input.charAt(peg$currPos);
6675
7245
  peg$currPos++;
6676
7246
  }
6677
7247
  else {
6678
7248
  s1 = peg$FAILED;
6679
7249
  if (peg$silentFails === 0) {
6680
- peg$fail(peg$c187);
7250
+ peg$fail(peg$c196);
6681
7251
  }
6682
7252
  }
6683
7253
  while (s1 !== peg$FAILED) {
6684
7254
  s0.push(s1);
6685
- if (peg$c186.test(input.charAt(peg$currPos))) {
7255
+ if (peg$c195.test(input.charAt(peg$currPos))) {
6686
7256
  s1 = input.charAt(peg$currPos);
6687
7257
  peg$currPos++;
6688
7258
  }
6689
7259
  else {
6690
7260
  s1 = peg$FAILED;
6691
7261
  if (peg$silentFails === 0) {
6692
- peg$fail(peg$c187);
7262
+ peg$fail(peg$c196);
6693
7263
  }
6694
7264
  }
6695
7265
  }
@@ -6697,7 +7267,7 @@ function peg$parse(input, options) {
6697
7267
  if (s0 === peg$FAILED) {
6698
7268
  s1 = peg$FAILED;
6699
7269
  if (peg$silentFails === 0) {
6700
- peg$fail(peg$c188);
7270
+ peg$fail(peg$c197);
6701
7271
  }
6702
7272
  }
6703
7273
  return s0;
@@ -6736,6 +7306,7 @@ function peg$parse(input, options) {
6736
7306
  'pod',
6737
7307
  'row',
6738
7308
  'cell',
7309
+ 'set',
6739
7310
  'table',
6740
7311
  'toc',
6741
7312
  ].includes(name)