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