podlite 0.0.90 → 0.0.92
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 +24 -0
- package/esm/assemble/index.d.ts +2 -0
- package/esm/assemble/index.js +404 -57
- package/esm/assemble/index.js.map +1 -1
- package/esm/cli.js +5 -1
- package/esm/cli.js.map +1 -1
- package/esm/lint/grammar/lint.js +1181 -183
- package/esm/lint/grammar/lint.js.map +1 -1
- package/esm/lint/rules/include-resolves.js +30 -17
- package/esm/lint/rules/include-resolves.js.map +1 -1
- package/esm/lint/rules/index.js +6 -0
- package/esm/lint/rules/index.js.map +1 -1
- package/esm/lint/rules/item-hierarchy.d.ts +3 -0
- package/esm/lint/rules/item-hierarchy.js +65 -0
- package/esm/lint/rules/item-hierarchy.js.map +1 -0
- package/esm/lint/rules/markup-code-too-deep.d.ts +3 -0
- package/esm/lint/rules/markup-code-too-deep.js +16 -0
- package/esm/lint/rules/markup-code-too-deep.js.map +1 -0
- package/esm/lint/rules/table-column-width.js +14 -6
- package/esm/lint/rules/table-column-width.js.map +1 -1
- package/esm/lint/rules/test-under-rule.d.ts +3 -0
- package/esm/lint/rules/test-under-rule.js +135 -0
- package/esm/lint/rules/test-under-rule.js.map +1 -0
- package/esm/version.d.ts +1 -1
- package/esm/version.js +1 -1
- package/lib/assemble/index.d.ts +2 -0
- package/lib/assemble/index.js +406 -58
- package/lib/assemble/index.js.map +1 -1
- package/lib/cli.js +5 -1
- package/lib/cli.js.map +1 -1
- package/lib/lint/grammar/lint.js +1181 -183
- package/lib/lint/grammar/lint.js.map +1 -1
- package/lib/lint/rules/include-resolves.js +29 -16
- package/lib/lint/rules/include-resolves.js.map +1 -1
- package/lib/lint/rules/index.js +6 -0
- package/lib/lint/rules/index.js.map +1 -1
- package/lib/lint/rules/item-hierarchy.d.ts +3 -0
- package/lib/lint/rules/item-hierarchy.js +68 -0
- package/lib/lint/rules/item-hierarchy.js.map +1 -0
- package/lib/lint/rules/markup-code-too-deep.d.ts +3 -0
- package/lib/lint/rules/markup-code-too-deep.js +19 -0
- package/lib/lint/rules/markup-code-too-deep.js.map +1 -0
- package/lib/lint/rules/table-column-width.js +14 -6
- package/lib/lint/rules/table-column-width.js.map +1 -1
- package/lib/lint/rules/test-under-rule.d.ts +3 -0
- package/lib/lint/rules/test-under-rule.js +138 -0
- package/lib/lint/rules/test-under-rule.js.map +1 -0
- package/lib/version.d.ts +1 -1
- package/lib/version.js +1 -1
- package/package.json +8 -8
package/lib/lint/grammar/lint.js
CHANGED
|
@@ -116,17 +116,36 @@ peg$SyntaxError.buildMessage = function (expected, found) {
|
|
|
116
116
|
};
|
|
117
117
|
function peg$parse(input, options) {
|
|
118
118
|
options = options !== void 0 ? options : {};
|
|
119
|
-
var peg$FAILED = {}, peg$startRuleFunctions = { start: peg$parsestart }, peg$startRuleFunction = peg$parsestart, peg$c0 = peg$anyExpectation(), peg$c1 =
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
119
|
+
var peg$FAILED = {}, peg$startRuleFunctions = { start: peg$parsestart }, peg$startRuleFunction = peg$parsestart, peg$c0 = peg$anyExpectation(), peg$c1 = function () {
|
|
120
|
+
if (!options._inDirective || options._blockStack.some(b => options.isVerbatim(b.name)))
|
|
121
|
+
return false;
|
|
122
|
+
return /[ \t\x7b,]/.test(input.charAt(location().start.offset - 1));
|
|
123
|
+
}, peg$c2 = ':', peg$c3 = peg$literalExpectation(':', false), peg$c4 = '<', peg$c5 = peg$literalExpectation('<', false), peg$c6 = '>', peg$c7 = peg$literalExpectation('>', false), peg$c8 = function (value) {
|
|
124
|
+
return value.quoted;
|
|
125
|
+
}, peg$c9 = function (value) {
|
|
126
|
+
if (options.closedEarly(input.slice(peg$savedPos + text().length).split(/\r?\n/)[0], options.inHash(location().start.offset))) {
|
|
127
|
+
options.diagnostics.push({
|
|
128
|
+
rule: 'attr-nested-angle',
|
|
129
|
+
severity: 'error',
|
|
130
|
+
message: 'attribute value contains a > that closes the attribute early; ' + options.nestedAngleAdvice,
|
|
131
|
+
location: location(),
|
|
132
|
+
});
|
|
133
|
+
}
|
|
134
|
+
return null;
|
|
135
|
+
}, peg$c10 = function (first, e) {
|
|
136
|
+
return e;
|
|
137
|
+
}, peg$c11 = function (first, rest) {
|
|
138
|
+
return { quoted: [first].concat(rest).some(e => e) };
|
|
139
|
+
}, peg$c12 = function () {
|
|
140
|
+
return true;
|
|
141
|
+
}, peg$c13 = 'True', peg$c14 = peg$literalExpectation('True', false), peg$c15 = 'False', peg$c16 = peg$literalExpectation('False', false), peg$c17 = function () {
|
|
142
|
+
return false;
|
|
143
|
+
}, peg$c18 = /^[^ \t\r\n,<>[\]{}()'"]/, peg$c19 = peg$classExpectation([' ', '\t', '\r', '\n', ',', '<', '>', '[', ']', '{', '}', '(', ')', "'", '"'], true, false), peg$c20 = "'", peg$c21 = peg$literalExpectation("'", false), peg$c22 = /^[^'\n\r]/, peg$c23 = peg$classExpectation(["'", '\n', '\r'], true, false), peg$c24 = '"', peg$c25 = peg$literalExpectation('"', false), peg$c26 = /^[^"\n\r]/, peg$c27 = peg$classExpectation(['"', '\n', '\r'], true, false), peg$c28 = function () {
|
|
144
|
+
return { quoted: true };
|
|
145
|
+
}, peg$c29 = /^[\-+]/, peg$c30 = peg$classExpectation(['-', '+'], false, false), peg$c31 = /^[0-9]/, peg$c32 = peg$classExpectation([['0', '9']], false, false), peg$c33 = '.', peg$c34 = peg$literalExpectation('.', false), peg$c35 = /^[eE]/, peg$c36 = peg$classExpectation(['e', 'E'], false, false), peg$c37 = /^[ \xA0\u2001\t\f\u2008]/, peg$c38 = peg$classExpectation([' ', '\xA0', '\u2001', '\t', '\f', '\u2008'], false, false), peg$c39 = /^[ \t\f]/, peg$c40 = peg$classExpectation([' ', '\t', '\f'], false, false), peg$c41 = /^[^>\r\n]/, peg$c42 = peg$classExpectation(['>', '\r', '\n'], true, false), peg$c43 = function (name, value) {
|
|
146
|
+
const advice = options.nestedAngleAdvice;
|
|
128
147
|
const rest = input.slice(peg$savedPos + text().length).split(/\r?\n/)[0];
|
|
129
|
-
const closedEarly =
|
|
148
|
+
const closedEarly = options.closedEarly(rest, options.inHash(location().start.offset));
|
|
130
149
|
if (value.indexOf('<') !== -1) {
|
|
131
150
|
options.diagnostics.push({
|
|
132
151
|
rule: 'attr-nested-angle',
|
|
@@ -144,7 +163,11 @@ function peg$parse(input, options) {
|
|
|
144
163
|
});
|
|
145
164
|
}
|
|
146
165
|
return null;
|
|
147
|
-
}, peg$
|
|
166
|
+
}, peg$c44 = function () {
|
|
167
|
+
return options._inDirective;
|
|
168
|
+
}, peg$c45 = /^[^'\r\n]/, peg$c46 = peg$classExpectation(["'", '\r', '\n'], true, false), peg$c47 = /^[^"\r\n]/, peg$c48 = peg$classExpectation(['"', '\r', '\n'], true, false), peg$c49 = '\uFF62', peg$c50 = peg$literalExpectation('\uFF62', false), peg$c51 = /^[^\uFF63\r\n]/, peg$c52 = peg$classExpectation(['\uFF63', '\r', '\n'], true, false), peg$c53 = '\uFF63', peg$c54 = peg$literalExpectation('\uFF63', false), peg$c55 = function () {
|
|
169
|
+
return null;
|
|
170
|
+
}, peg$c56 = '=begin', peg$c57 = peg$literalExpectation('=begin', false), peg$c58 = function (name) {
|
|
148
171
|
const top = options._blockStack[options._blockStack.length - 1];
|
|
149
172
|
const verbatim = top && options.isVerbatim(top.name);
|
|
150
173
|
if (verbatim) {
|
|
@@ -169,7 +192,7 @@ function peg$parse(input, options) {
|
|
|
169
192
|
options._blockStack.push({ name: name, location: location() });
|
|
170
193
|
options._inDirective = true;
|
|
171
194
|
return null;
|
|
172
|
-
}, peg$
|
|
195
|
+
}, peg$c59 = '=end', peg$c60 = peg$literalExpectation('=end', false), peg$c61 = function (name) {
|
|
173
196
|
const top = options._blockStack[options._blockStack.length - 1];
|
|
174
197
|
// a verbatim block runs to its own =end, so any other marker inside it is content
|
|
175
198
|
if (top && top.name !== name && options.isVerbatim(top.name)) {
|
|
@@ -228,10 +251,10 @@ function peg$parse(input, options) {
|
|
|
228
251
|
}
|
|
229
252
|
options._inDirective = false;
|
|
230
253
|
return null;
|
|
231
|
-
}, peg$
|
|
254
|
+
}, peg$c62 = '=for', peg$c63 = peg$literalExpectation('=for', false), peg$c64 = function () {
|
|
232
255
|
options._inDirective = true;
|
|
233
256
|
return null;
|
|
234
|
-
}, peg$
|
|
257
|
+
}, peg$c65 = '!', peg$c66 = peg$literalExpectation('!', false), peg$c67 = function (name) {
|
|
235
258
|
// any verbatim block on the stack makes this line content: markers written
|
|
236
259
|
// inside such a block are an example, not structure
|
|
237
260
|
const verbatim = options._blockStack.some(b => options.isVerbatim(b.name));
|
|
@@ -244,15 +267,15 @@ function peg$parse(input, options) {
|
|
|
244
267
|
});
|
|
245
268
|
}
|
|
246
269
|
return null;
|
|
247
|
-
}, peg$
|
|
270
|
+
}, peg$c68 = '(', peg$c69 = peg$literalExpectation('(', false), peg$c70 = '{', peg$c71 = peg$literalExpectation('{', false), peg$c72 = '[', peg$c73 = peg$literalExpectation('[', false), peg$c74 = '=', peg$c75 = peg$literalExpectation('=', false), peg$c76 = /^[ \t]/, peg$c77 = peg$classExpectation([' ', '\t'], false, false), peg$c78 = '\n', peg$c79 = peg$literalExpectation('\n', false), peg$c80 = function () {
|
|
248
271
|
options._inDirective = false;
|
|
249
272
|
return null;
|
|
250
|
-
}, peg$
|
|
273
|
+
}, peg$c81 = peg$otherExpectation('identifier'), peg$c82 = /^[a-zA-Z]/, peg$c83 = peg$classExpectation([
|
|
251
274
|
['a', 'z'],
|
|
252
275
|
['A', 'Z'],
|
|
253
|
-
], false, false), peg$
|
|
276
|
+
], false, false), peg$c84 = /^[a-zA-Z0-9_\-]/, peg$c85 = peg$classExpectation([['a', 'z'], ['A', 'Z'], ['0', '9'], '_', '-'], false, false), peg$c86 = peg$otherExpectation('start-of-line'), peg$c87 = function () {
|
|
254
277
|
return location().start.column === 1;
|
|
255
|
-
}, peg$
|
|
278
|
+
}, peg$c88 = peg$otherExpectation('whitespace'), peg$currPos = 0, peg$savedPos = 0, peg$posDetailsCache = [{ line: 1, column: 1 }], peg$maxFailPos = 0, peg$maxFailExpected = [], peg$silentFails = 0, peg$result;
|
|
256
279
|
if ('startRule' in options) {
|
|
257
280
|
if (!(options.startRule in peg$startRuleFunctions)) {
|
|
258
281
|
throw new Error('Can\'t start parsing from rule "' + options.startRule + '".');
|
|
@@ -332,192 +355,1147 @@ function peg$parse(input, options) {
|
|
|
332
355
|
},
|
|
333
356
|
};
|
|
334
357
|
}
|
|
335
|
-
function peg$fail(expected) {
|
|
336
|
-
if (peg$currPos < peg$maxFailPos) {
|
|
337
|
-
return;
|
|
358
|
+
function peg$fail(expected) {
|
|
359
|
+
if (peg$currPos < peg$maxFailPos) {
|
|
360
|
+
return;
|
|
361
|
+
}
|
|
362
|
+
if (peg$currPos > peg$maxFailPos) {
|
|
363
|
+
peg$maxFailPos = peg$currPos;
|
|
364
|
+
peg$maxFailExpected = [];
|
|
365
|
+
}
|
|
366
|
+
peg$maxFailExpected.push(expected);
|
|
367
|
+
}
|
|
368
|
+
function peg$buildSimpleError(message, location) {
|
|
369
|
+
return new peg$SyntaxError(message, null, null, location);
|
|
370
|
+
}
|
|
371
|
+
function peg$buildStructuredError(expected, found, location) {
|
|
372
|
+
return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
|
|
373
|
+
}
|
|
374
|
+
function peg$parsestart() {
|
|
375
|
+
var s0, s1;
|
|
376
|
+
s0 = [];
|
|
377
|
+
s1 = peg$parserule_match();
|
|
378
|
+
if (s1 === peg$FAILED) {
|
|
379
|
+
if (input.length > peg$currPos) {
|
|
380
|
+
s1 = input.charAt(peg$currPos);
|
|
381
|
+
peg$currPos++;
|
|
382
|
+
}
|
|
383
|
+
else {
|
|
384
|
+
s1 = peg$FAILED;
|
|
385
|
+
if (peg$silentFails === 0) {
|
|
386
|
+
peg$fail(peg$c0);
|
|
387
|
+
}
|
|
388
|
+
}
|
|
389
|
+
}
|
|
390
|
+
while (s1 !== peg$FAILED) {
|
|
391
|
+
s0.push(s1);
|
|
392
|
+
s1 = peg$parserule_match();
|
|
393
|
+
if (s1 === peg$FAILED) {
|
|
394
|
+
if (input.length > peg$currPos) {
|
|
395
|
+
s1 = input.charAt(peg$currPos);
|
|
396
|
+
peg$currPos++;
|
|
397
|
+
}
|
|
398
|
+
else {
|
|
399
|
+
s1 = peg$FAILED;
|
|
400
|
+
if (peg$silentFails === 0) {
|
|
401
|
+
peg$fail(peg$c0);
|
|
402
|
+
}
|
|
403
|
+
}
|
|
404
|
+
}
|
|
405
|
+
}
|
|
406
|
+
return s0;
|
|
407
|
+
}
|
|
408
|
+
function peg$parserule_match() {
|
|
409
|
+
var s0;
|
|
410
|
+
s0 = peg$parseattr_quoted_angle();
|
|
411
|
+
if (s0 === peg$FAILED) {
|
|
412
|
+
s0 = peg$parseattr_nested_angle();
|
|
413
|
+
if (s0 === peg$FAILED) {
|
|
414
|
+
s0 = peg$parsequoted_value();
|
|
415
|
+
if (s0 === peg$FAILED) {
|
|
416
|
+
s0 = peg$parsedelim_begin();
|
|
417
|
+
if (s0 === peg$FAILED) {
|
|
418
|
+
s0 = peg$parsedelim_end();
|
|
419
|
+
if (s0 === peg$FAILED) {
|
|
420
|
+
s0 = peg$parseparagraph_directive();
|
|
421
|
+
if (s0 === peg$FAILED) {
|
|
422
|
+
s0 = peg$parsecontinuation_attr();
|
|
423
|
+
if (s0 === peg$FAILED) {
|
|
424
|
+
s0 = peg$parsecontinuation_marker();
|
|
425
|
+
if (s0 === peg$FAILED) {
|
|
426
|
+
s0 = peg$parseblank_line_marker();
|
|
427
|
+
if (s0 === peg$FAILED) {
|
|
428
|
+
s0 = peg$parseline_marker();
|
|
429
|
+
}
|
|
430
|
+
}
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
}
|
|
434
|
+
}
|
|
435
|
+
}
|
|
436
|
+
}
|
|
437
|
+
}
|
|
438
|
+
return s0;
|
|
439
|
+
}
|
|
440
|
+
function peg$parseoption_start() {
|
|
441
|
+
var s0;
|
|
442
|
+
peg$savedPos = peg$currPos;
|
|
443
|
+
s0 = peg$c1();
|
|
444
|
+
if (s0) {
|
|
445
|
+
s0 = void 0;
|
|
446
|
+
}
|
|
447
|
+
else {
|
|
448
|
+
s0 = peg$FAILED;
|
|
449
|
+
}
|
|
450
|
+
return s0;
|
|
451
|
+
}
|
|
452
|
+
function peg$parseattr_quoted_angle() {
|
|
453
|
+
var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
454
|
+
s0 = peg$currPos;
|
|
455
|
+
s1 = peg$parseoption_start();
|
|
456
|
+
if (s1 !== peg$FAILED) {
|
|
457
|
+
if (input.charCodeAt(peg$currPos) === 58) {
|
|
458
|
+
s2 = peg$c2;
|
|
459
|
+
peg$currPos++;
|
|
460
|
+
}
|
|
461
|
+
else {
|
|
462
|
+
s2 = peg$FAILED;
|
|
463
|
+
if (peg$silentFails === 0) {
|
|
464
|
+
peg$fail(peg$c3);
|
|
465
|
+
}
|
|
466
|
+
}
|
|
467
|
+
if (s2 !== peg$FAILED) {
|
|
468
|
+
s3 = peg$parseidentifier();
|
|
469
|
+
if (s3 !== peg$FAILED) {
|
|
470
|
+
if (input.charCodeAt(peg$currPos) === 60) {
|
|
471
|
+
s4 = peg$c4;
|
|
472
|
+
peg$currPos++;
|
|
473
|
+
}
|
|
474
|
+
else {
|
|
475
|
+
s4 = peg$FAILED;
|
|
476
|
+
if (peg$silentFails === 0) {
|
|
477
|
+
peg$fail(peg$c5);
|
|
478
|
+
}
|
|
479
|
+
}
|
|
480
|
+
if (s4 !== peg$FAILED) {
|
|
481
|
+
s5 = peg$parseqa_ws();
|
|
482
|
+
if (s5 !== peg$FAILED) {
|
|
483
|
+
s6 = peg$parseqa_list();
|
|
484
|
+
if (s6 === peg$FAILED) {
|
|
485
|
+
s6 = peg$parseqa_quoted();
|
|
486
|
+
}
|
|
487
|
+
if (s6 !== peg$FAILED) {
|
|
488
|
+
s7 = peg$parseqa_ws();
|
|
489
|
+
if (s7 !== peg$FAILED) {
|
|
490
|
+
if (input.charCodeAt(peg$currPos) === 62) {
|
|
491
|
+
s8 = peg$c6;
|
|
492
|
+
peg$currPos++;
|
|
493
|
+
}
|
|
494
|
+
else {
|
|
495
|
+
s8 = peg$FAILED;
|
|
496
|
+
if (peg$silentFails === 0) {
|
|
497
|
+
peg$fail(peg$c7);
|
|
498
|
+
}
|
|
499
|
+
}
|
|
500
|
+
if (s8 !== peg$FAILED) {
|
|
501
|
+
peg$savedPos = peg$currPos;
|
|
502
|
+
s9 = peg$c8(s6);
|
|
503
|
+
if (s9) {
|
|
504
|
+
s9 = void 0;
|
|
505
|
+
}
|
|
506
|
+
else {
|
|
507
|
+
s9 = peg$FAILED;
|
|
508
|
+
}
|
|
509
|
+
if (s9 !== peg$FAILED) {
|
|
510
|
+
peg$savedPos = s0;
|
|
511
|
+
s1 = peg$c9(s6);
|
|
512
|
+
s0 = s1;
|
|
513
|
+
}
|
|
514
|
+
else {
|
|
515
|
+
peg$currPos = s0;
|
|
516
|
+
s0 = peg$FAILED;
|
|
517
|
+
}
|
|
518
|
+
}
|
|
519
|
+
else {
|
|
520
|
+
peg$currPos = s0;
|
|
521
|
+
s0 = peg$FAILED;
|
|
522
|
+
}
|
|
523
|
+
}
|
|
524
|
+
else {
|
|
525
|
+
peg$currPos = s0;
|
|
526
|
+
s0 = peg$FAILED;
|
|
527
|
+
}
|
|
528
|
+
}
|
|
529
|
+
else {
|
|
530
|
+
peg$currPos = s0;
|
|
531
|
+
s0 = peg$FAILED;
|
|
532
|
+
}
|
|
533
|
+
}
|
|
534
|
+
else {
|
|
535
|
+
peg$currPos = s0;
|
|
536
|
+
s0 = peg$FAILED;
|
|
537
|
+
}
|
|
538
|
+
}
|
|
539
|
+
else {
|
|
540
|
+
peg$currPos = s0;
|
|
541
|
+
s0 = peg$FAILED;
|
|
542
|
+
}
|
|
543
|
+
}
|
|
544
|
+
else {
|
|
545
|
+
peg$currPos = s0;
|
|
546
|
+
s0 = peg$FAILED;
|
|
547
|
+
}
|
|
548
|
+
}
|
|
549
|
+
else {
|
|
550
|
+
peg$currPos = s0;
|
|
551
|
+
s0 = peg$FAILED;
|
|
552
|
+
}
|
|
553
|
+
}
|
|
554
|
+
else {
|
|
555
|
+
peg$currPos = s0;
|
|
556
|
+
s0 = peg$FAILED;
|
|
557
|
+
}
|
|
558
|
+
return s0;
|
|
559
|
+
}
|
|
560
|
+
function peg$parseqa_list() {
|
|
561
|
+
var s0, s1, s2, s3, s4, s5;
|
|
562
|
+
s0 = peg$currPos;
|
|
563
|
+
s1 = peg$parseqa_element();
|
|
564
|
+
if (s1 !== peg$FAILED) {
|
|
565
|
+
s2 = [];
|
|
566
|
+
s3 = peg$currPos;
|
|
567
|
+
s4 = [];
|
|
568
|
+
s5 = peg$parseqa_hs();
|
|
569
|
+
if (s5 !== peg$FAILED) {
|
|
570
|
+
while (s5 !== peg$FAILED) {
|
|
571
|
+
s4.push(s5);
|
|
572
|
+
s5 = peg$parseqa_hs();
|
|
573
|
+
}
|
|
574
|
+
}
|
|
575
|
+
else {
|
|
576
|
+
s4 = peg$FAILED;
|
|
577
|
+
}
|
|
578
|
+
if (s4 !== peg$FAILED) {
|
|
579
|
+
s5 = peg$parseqa_element();
|
|
580
|
+
if (s5 !== peg$FAILED) {
|
|
581
|
+
peg$savedPos = s3;
|
|
582
|
+
s4 = peg$c10(s1, s5);
|
|
583
|
+
s3 = s4;
|
|
584
|
+
}
|
|
585
|
+
else {
|
|
586
|
+
peg$currPos = s3;
|
|
587
|
+
s3 = peg$FAILED;
|
|
588
|
+
}
|
|
589
|
+
}
|
|
590
|
+
else {
|
|
591
|
+
peg$currPos = s3;
|
|
592
|
+
s3 = peg$FAILED;
|
|
593
|
+
}
|
|
594
|
+
if (s3 !== peg$FAILED) {
|
|
595
|
+
while (s3 !== peg$FAILED) {
|
|
596
|
+
s2.push(s3);
|
|
597
|
+
s3 = peg$currPos;
|
|
598
|
+
s4 = [];
|
|
599
|
+
s5 = peg$parseqa_hs();
|
|
600
|
+
if (s5 !== peg$FAILED) {
|
|
601
|
+
while (s5 !== peg$FAILED) {
|
|
602
|
+
s4.push(s5);
|
|
603
|
+
s5 = peg$parseqa_hs();
|
|
604
|
+
}
|
|
605
|
+
}
|
|
606
|
+
else {
|
|
607
|
+
s4 = peg$FAILED;
|
|
608
|
+
}
|
|
609
|
+
if (s4 !== peg$FAILED) {
|
|
610
|
+
s5 = peg$parseqa_element();
|
|
611
|
+
if (s5 !== peg$FAILED) {
|
|
612
|
+
peg$savedPos = s3;
|
|
613
|
+
s4 = peg$c10(s1, s5);
|
|
614
|
+
s3 = s4;
|
|
615
|
+
}
|
|
616
|
+
else {
|
|
617
|
+
peg$currPos = s3;
|
|
618
|
+
s3 = peg$FAILED;
|
|
619
|
+
}
|
|
620
|
+
}
|
|
621
|
+
else {
|
|
622
|
+
peg$currPos = s3;
|
|
623
|
+
s3 = peg$FAILED;
|
|
624
|
+
}
|
|
625
|
+
}
|
|
626
|
+
}
|
|
627
|
+
else {
|
|
628
|
+
s2 = peg$FAILED;
|
|
629
|
+
}
|
|
630
|
+
if (s2 !== peg$FAILED) {
|
|
631
|
+
peg$savedPos = s0;
|
|
632
|
+
s1 = peg$c11(s1, s2);
|
|
633
|
+
s0 = s1;
|
|
634
|
+
}
|
|
635
|
+
else {
|
|
636
|
+
peg$currPos = s0;
|
|
637
|
+
s0 = peg$FAILED;
|
|
638
|
+
}
|
|
639
|
+
}
|
|
640
|
+
else {
|
|
641
|
+
peg$currPos = s0;
|
|
642
|
+
s0 = peg$FAILED;
|
|
643
|
+
}
|
|
644
|
+
return s0;
|
|
645
|
+
}
|
|
646
|
+
function peg$parseqa_element() {
|
|
647
|
+
var s0, s1, s2;
|
|
648
|
+
s0 = peg$currPos;
|
|
649
|
+
s1 = peg$parseqa_quoted();
|
|
650
|
+
if (s1 !== peg$FAILED) {
|
|
651
|
+
peg$savedPos = s0;
|
|
652
|
+
s1 = peg$c12();
|
|
653
|
+
}
|
|
654
|
+
s0 = s1;
|
|
655
|
+
if (s0 === peg$FAILED) {
|
|
656
|
+
s0 = peg$currPos;
|
|
657
|
+
if (input.substr(peg$currPos, 4) === peg$c13) {
|
|
658
|
+
s1 = peg$c13;
|
|
659
|
+
peg$currPos += 4;
|
|
660
|
+
}
|
|
661
|
+
else {
|
|
662
|
+
s1 = peg$FAILED;
|
|
663
|
+
if (peg$silentFails === 0) {
|
|
664
|
+
peg$fail(peg$c14);
|
|
665
|
+
}
|
|
666
|
+
}
|
|
667
|
+
if (s1 === peg$FAILED) {
|
|
668
|
+
if (input.substr(peg$currPos, 5) === peg$c15) {
|
|
669
|
+
s1 = peg$c15;
|
|
670
|
+
peg$currPos += 5;
|
|
671
|
+
}
|
|
672
|
+
else {
|
|
673
|
+
s1 = peg$FAILED;
|
|
674
|
+
if (peg$silentFails === 0) {
|
|
675
|
+
peg$fail(peg$c16);
|
|
676
|
+
}
|
|
677
|
+
}
|
|
678
|
+
if (s1 === peg$FAILED) {
|
|
679
|
+
s1 = peg$parseqa_float();
|
|
680
|
+
if (s1 === peg$FAILED) {
|
|
681
|
+
s1 = peg$parseqa_number();
|
|
682
|
+
}
|
|
683
|
+
}
|
|
684
|
+
}
|
|
685
|
+
if (s1 !== peg$FAILED) {
|
|
686
|
+
peg$savedPos = s0;
|
|
687
|
+
s1 = peg$c17();
|
|
688
|
+
}
|
|
689
|
+
s0 = s1;
|
|
690
|
+
if (s0 === peg$FAILED) {
|
|
691
|
+
s0 = peg$currPos;
|
|
692
|
+
s1 = [];
|
|
693
|
+
if (peg$c18.test(input.charAt(peg$currPos))) {
|
|
694
|
+
s2 = input.charAt(peg$currPos);
|
|
695
|
+
peg$currPos++;
|
|
696
|
+
}
|
|
697
|
+
else {
|
|
698
|
+
s2 = peg$FAILED;
|
|
699
|
+
if (peg$silentFails === 0) {
|
|
700
|
+
peg$fail(peg$c19);
|
|
701
|
+
}
|
|
702
|
+
}
|
|
703
|
+
if (s2 !== peg$FAILED) {
|
|
704
|
+
while (s2 !== peg$FAILED) {
|
|
705
|
+
s1.push(s2);
|
|
706
|
+
if (peg$c18.test(input.charAt(peg$currPos))) {
|
|
707
|
+
s2 = input.charAt(peg$currPos);
|
|
708
|
+
peg$currPos++;
|
|
709
|
+
}
|
|
710
|
+
else {
|
|
711
|
+
s2 = peg$FAILED;
|
|
712
|
+
if (peg$silentFails === 0) {
|
|
713
|
+
peg$fail(peg$c19);
|
|
714
|
+
}
|
|
715
|
+
}
|
|
716
|
+
}
|
|
717
|
+
}
|
|
718
|
+
else {
|
|
719
|
+
s1 = peg$FAILED;
|
|
720
|
+
}
|
|
721
|
+
if (s1 !== peg$FAILED) {
|
|
722
|
+
peg$savedPos = s0;
|
|
723
|
+
s1 = peg$c17();
|
|
724
|
+
}
|
|
725
|
+
s0 = s1;
|
|
726
|
+
}
|
|
727
|
+
}
|
|
728
|
+
return s0;
|
|
729
|
+
}
|
|
730
|
+
function peg$parseqa_quoted() {
|
|
731
|
+
var s0, s1, s2, s3, s4;
|
|
732
|
+
s0 = peg$currPos;
|
|
733
|
+
s1 = peg$currPos;
|
|
734
|
+
if (input.charCodeAt(peg$currPos) === 39) {
|
|
735
|
+
s2 = peg$c20;
|
|
736
|
+
peg$currPos++;
|
|
737
|
+
}
|
|
738
|
+
else {
|
|
739
|
+
s2 = peg$FAILED;
|
|
740
|
+
if (peg$silentFails === 0) {
|
|
741
|
+
peg$fail(peg$c21);
|
|
742
|
+
}
|
|
743
|
+
}
|
|
744
|
+
if (s2 !== peg$FAILED) {
|
|
745
|
+
s3 = [];
|
|
746
|
+
if (peg$c22.test(input.charAt(peg$currPos))) {
|
|
747
|
+
s4 = input.charAt(peg$currPos);
|
|
748
|
+
peg$currPos++;
|
|
749
|
+
}
|
|
750
|
+
else {
|
|
751
|
+
s4 = peg$FAILED;
|
|
752
|
+
if (peg$silentFails === 0) {
|
|
753
|
+
peg$fail(peg$c23);
|
|
754
|
+
}
|
|
755
|
+
}
|
|
756
|
+
while (s4 !== peg$FAILED) {
|
|
757
|
+
s3.push(s4);
|
|
758
|
+
if (peg$c22.test(input.charAt(peg$currPos))) {
|
|
759
|
+
s4 = input.charAt(peg$currPos);
|
|
760
|
+
peg$currPos++;
|
|
761
|
+
}
|
|
762
|
+
else {
|
|
763
|
+
s4 = peg$FAILED;
|
|
764
|
+
if (peg$silentFails === 0) {
|
|
765
|
+
peg$fail(peg$c23);
|
|
766
|
+
}
|
|
767
|
+
}
|
|
768
|
+
}
|
|
769
|
+
if (s3 !== peg$FAILED) {
|
|
770
|
+
if (input.charCodeAt(peg$currPos) === 39) {
|
|
771
|
+
s4 = peg$c20;
|
|
772
|
+
peg$currPos++;
|
|
773
|
+
}
|
|
774
|
+
else {
|
|
775
|
+
s4 = peg$FAILED;
|
|
776
|
+
if (peg$silentFails === 0) {
|
|
777
|
+
peg$fail(peg$c21);
|
|
778
|
+
}
|
|
779
|
+
}
|
|
780
|
+
if (s4 !== peg$FAILED) {
|
|
781
|
+
s2 = [s2, s3, s4];
|
|
782
|
+
s1 = s2;
|
|
783
|
+
}
|
|
784
|
+
else {
|
|
785
|
+
peg$currPos = s1;
|
|
786
|
+
s1 = peg$FAILED;
|
|
787
|
+
}
|
|
788
|
+
}
|
|
789
|
+
else {
|
|
790
|
+
peg$currPos = s1;
|
|
791
|
+
s1 = peg$FAILED;
|
|
792
|
+
}
|
|
793
|
+
}
|
|
794
|
+
else {
|
|
795
|
+
peg$currPos = s1;
|
|
796
|
+
s1 = peg$FAILED;
|
|
797
|
+
}
|
|
798
|
+
if (s1 === peg$FAILED) {
|
|
799
|
+
s1 = peg$currPos;
|
|
800
|
+
if (input.charCodeAt(peg$currPos) === 34) {
|
|
801
|
+
s2 = peg$c24;
|
|
802
|
+
peg$currPos++;
|
|
803
|
+
}
|
|
804
|
+
else {
|
|
805
|
+
s2 = peg$FAILED;
|
|
806
|
+
if (peg$silentFails === 0) {
|
|
807
|
+
peg$fail(peg$c25);
|
|
808
|
+
}
|
|
809
|
+
}
|
|
810
|
+
if (s2 !== peg$FAILED) {
|
|
811
|
+
s3 = [];
|
|
812
|
+
if (peg$c26.test(input.charAt(peg$currPos))) {
|
|
813
|
+
s4 = input.charAt(peg$currPos);
|
|
814
|
+
peg$currPos++;
|
|
815
|
+
}
|
|
816
|
+
else {
|
|
817
|
+
s4 = peg$FAILED;
|
|
818
|
+
if (peg$silentFails === 0) {
|
|
819
|
+
peg$fail(peg$c27);
|
|
820
|
+
}
|
|
821
|
+
}
|
|
822
|
+
while (s4 !== peg$FAILED) {
|
|
823
|
+
s3.push(s4);
|
|
824
|
+
if (peg$c26.test(input.charAt(peg$currPos))) {
|
|
825
|
+
s4 = input.charAt(peg$currPos);
|
|
826
|
+
peg$currPos++;
|
|
827
|
+
}
|
|
828
|
+
else {
|
|
829
|
+
s4 = peg$FAILED;
|
|
830
|
+
if (peg$silentFails === 0) {
|
|
831
|
+
peg$fail(peg$c27);
|
|
832
|
+
}
|
|
833
|
+
}
|
|
834
|
+
}
|
|
835
|
+
if (s3 !== peg$FAILED) {
|
|
836
|
+
if (input.charCodeAt(peg$currPos) === 34) {
|
|
837
|
+
s4 = peg$c24;
|
|
838
|
+
peg$currPos++;
|
|
839
|
+
}
|
|
840
|
+
else {
|
|
841
|
+
s4 = peg$FAILED;
|
|
842
|
+
if (peg$silentFails === 0) {
|
|
843
|
+
peg$fail(peg$c25);
|
|
844
|
+
}
|
|
845
|
+
}
|
|
846
|
+
if (s4 !== peg$FAILED) {
|
|
847
|
+
s2 = [s2, s3, s4];
|
|
848
|
+
s1 = s2;
|
|
849
|
+
}
|
|
850
|
+
else {
|
|
851
|
+
peg$currPos = s1;
|
|
852
|
+
s1 = peg$FAILED;
|
|
853
|
+
}
|
|
854
|
+
}
|
|
855
|
+
else {
|
|
856
|
+
peg$currPos = s1;
|
|
857
|
+
s1 = peg$FAILED;
|
|
858
|
+
}
|
|
859
|
+
}
|
|
860
|
+
else {
|
|
861
|
+
peg$currPos = s1;
|
|
862
|
+
s1 = peg$FAILED;
|
|
863
|
+
}
|
|
864
|
+
}
|
|
865
|
+
if (s1 !== peg$FAILED) {
|
|
866
|
+
peg$savedPos = s0;
|
|
867
|
+
s1 = peg$c28();
|
|
868
|
+
}
|
|
869
|
+
s0 = s1;
|
|
870
|
+
return s0;
|
|
871
|
+
}
|
|
872
|
+
function peg$parseqa_number() {
|
|
873
|
+
var s0, s1, s2, s3;
|
|
874
|
+
s0 = peg$currPos;
|
|
875
|
+
if (peg$c29.test(input.charAt(peg$currPos))) {
|
|
876
|
+
s1 = input.charAt(peg$currPos);
|
|
877
|
+
peg$currPos++;
|
|
878
|
+
}
|
|
879
|
+
else {
|
|
880
|
+
s1 = peg$FAILED;
|
|
881
|
+
if (peg$silentFails === 0) {
|
|
882
|
+
peg$fail(peg$c30);
|
|
883
|
+
}
|
|
884
|
+
}
|
|
885
|
+
if (s1 === peg$FAILED) {
|
|
886
|
+
s1 = null;
|
|
887
|
+
}
|
|
888
|
+
if (s1 !== peg$FAILED) {
|
|
889
|
+
s2 = [];
|
|
890
|
+
if (peg$c31.test(input.charAt(peg$currPos))) {
|
|
891
|
+
s3 = input.charAt(peg$currPos);
|
|
892
|
+
peg$currPos++;
|
|
893
|
+
}
|
|
894
|
+
else {
|
|
895
|
+
s3 = peg$FAILED;
|
|
896
|
+
if (peg$silentFails === 0) {
|
|
897
|
+
peg$fail(peg$c32);
|
|
898
|
+
}
|
|
899
|
+
}
|
|
900
|
+
if (s3 !== peg$FAILED) {
|
|
901
|
+
while (s3 !== peg$FAILED) {
|
|
902
|
+
s2.push(s3);
|
|
903
|
+
if (peg$c31.test(input.charAt(peg$currPos))) {
|
|
904
|
+
s3 = input.charAt(peg$currPos);
|
|
905
|
+
peg$currPos++;
|
|
906
|
+
}
|
|
907
|
+
else {
|
|
908
|
+
s3 = peg$FAILED;
|
|
909
|
+
if (peg$silentFails === 0) {
|
|
910
|
+
peg$fail(peg$c32);
|
|
911
|
+
}
|
|
912
|
+
}
|
|
913
|
+
}
|
|
914
|
+
}
|
|
915
|
+
else {
|
|
916
|
+
s2 = peg$FAILED;
|
|
917
|
+
}
|
|
918
|
+
if (s2 !== peg$FAILED) {
|
|
919
|
+
s1 = [s1, s2];
|
|
920
|
+
s0 = s1;
|
|
921
|
+
}
|
|
922
|
+
else {
|
|
923
|
+
peg$currPos = s0;
|
|
924
|
+
s0 = peg$FAILED;
|
|
925
|
+
}
|
|
926
|
+
}
|
|
927
|
+
else {
|
|
928
|
+
peg$currPos = s0;
|
|
929
|
+
s0 = peg$FAILED;
|
|
930
|
+
}
|
|
931
|
+
return s0;
|
|
932
|
+
}
|
|
933
|
+
function peg$parseqa_float() {
|
|
934
|
+
var s0, s1, s2, s3, s4, s5;
|
|
935
|
+
s0 = peg$currPos;
|
|
936
|
+
s1 = peg$parseqa_number();
|
|
937
|
+
if (s1 !== peg$FAILED) {
|
|
938
|
+
s2 = peg$currPos;
|
|
939
|
+
if (input.charCodeAt(peg$currPos) === 46) {
|
|
940
|
+
s3 = peg$c33;
|
|
941
|
+
peg$currPos++;
|
|
942
|
+
}
|
|
943
|
+
else {
|
|
944
|
+
s3 = peg$FAILED;
|
|
945
|
+
if (peg$silentFails === 0) {
|
|
946
|
+
peg$fail(peg$c34);
|
|
947
|
+
}
|
|
948
|
+
}
|
|
949
|
+
if (s3 !== peg$FAILED) {
|
|
950
|
+
s4 = [];
|
|
951
|
+
if (peg$c31.test(input.charAt(peg$currPos))) {
|
|
952
|
+
s5 = input.charAt(peg$currPos);
|
|
953
|
+
peg$currPos++;
|
|
954
|
+
}
|
|
955
|
+
else {
|
|
956
|
+
s5 = peg$FAILED;
|
|
957
|
+
if (peg$silentFails === 0) {
|
|
958
|
+
peg$fail(peg$c32);
|
|
959
|
+
}
|
|
960
|
+
}
|
|
961
|
+
if (s5 !== peg$FAILED) {
|
|
962
|
+
while (s5 !== peg$FAILED) {
|
|
963
|
+
s4.push(s5);
|
|
964
|
+
if (peg$c31.test(input.charAt(peg$currPos))) {
|
|
965
|
+
s5 = input.charAt(peg$currPos);
|
|
966
|
+
peg$currPos++;
|
|
967
|
+
}
|
|
968
|
+
else {
|
|
969
|
+
s5 = peg$FAILED;
|
|
970
|
+
if (peg$silentFails === 0) {
|
|
971
|
+
peg$fail(peg$c32);
|
|
972
|
+
}
|
|
973
|
+
}
|
|
974
|
+
}
|
|
975
|
+
}
|
|
976
|
+
else {
|
|
977
|
+
s4 = peg$FAILED;
|
|
978
|
+
}
|
|
979
|
+
if (s4 !== peg$FAILED) {
|
|
980
|
+
s3 = [s3, s4];
|
|
981
|
+
s2 = s3;
|
|
982
|
+
}
|
|
983
|
+
else {
|
|
984
|
+
peg$currPos = s2;
|
|
985
|
+
s2 = peg$FAILED;
|
|
986
|
+
}
|
|
987
|
+
}
|
|
988
|
+
else {
|
|
989
|
+
peg$currPos = s2;
|
|
990
|
+
s2 = peg$FAILED;
|
|
991
|
+
}
|
|
992
|
+
if (s2 === peg$FAILED) {
|
|
993
|
+
s2 = null;
|
|
994
|
+
}
|
|
995
|
+
if (s2 !== peg$FAILED) {
|
|
996
|
+
if (peg$c35.test(input.charAt(peg$currPos))) {
|
|
997
|
+
s3 = input.charAt(peg$currPos);
|
|
998
|
+
peg$currPos++;
|
|
999
|
+
}
|
|
1000
|
+
else {
|
|
1001
|
+
s3 = peg$FAILED;
|
|
1002
|
+
if (peg$silentFails === 0) {
|
|
1003
|
+
peg$fail(peg$c36);
|
|
1004
|
+
}
|
|
1005
|
+
}
|
|
1006
|
+
if (s3 !== peg$FAILED) {
|
|
1007
|
+
s4 = peg$parseqa_number();
|
|
1008
|
+
if (s4 !== peg$FAILED) {
|
|
1009
|
+
s1 = [s1, s2, s3, s4];
|
|
1010
|
+
s0 = s1;
|
|
1011
|
+
}
|
|
1012
|
+
else {
|
|
1013
|
+
peg$currPos = s0;
|
|
1014
|
+
s0 = peg$FAILED;
|
|
1015
|
+
}
|
|
1016
|
+
}
|
|
1017
|
+
else {
|
|
1018
|
+
peg$currPos = s0;
|
|
1019
|
+
s0 = peg$FAILED;
|
|
1020
|
+
}
|
|
1021
|
+
}
|
|
1022
|
+
else {
|
|
1023
|
+
peg$currPos = s0;
|
|
1024
|
+
s0 = peg$FAILED;
|
|
1025
|
+
}
|
|
1026
|
+
}
|
|
1027
|
+
else {
|
|
1028
|
+
peg$currPos = s0;
|
|
1029
|
+
s0 = peg$FAILED;
|
|
1030
|
+
}
|
|
1031
|
+
if (s0 === peg$FAILED) {
|
|
1032
|
+
s0 = peg$currPos;
|
|
1033
|
+
s1 = peg$parseqa_number();
|
|
1034
|
+
if (s1 !== peg$FAILED) {
|
|
1035
|
+
if (input.charCodeAt(peg$currPos) === 46) {
|
|
1036
|
+
s2 = peg$c33;
|
|
1037
|
+
peg$currPos++;
|
|
1038
|
+
}
|
|
1039
|
+
else {
|
|
1040
|
+
s2 = peg$FAILED;
|
|
1041
|
+
if (peg$silentFails === 0) {
|
|
1042
|
+
peg$fail(peg$c34);
|
|
1043
|
+
}
|
|
1044
|
+
}
|
|
1045
|
+
if (s2 !== peg$FAILED) {
|
|
1046
|
+
s3 = [];
|
|
1047
|
+
if (peg$c31.test(input.charAt(peg$currPos))) {
|
|
1048
|
+
s4 = input.charAt(peg$currPos);
|
|
1049
|
+
peg$currPos++;
|
|
1050
|
+
}
|
|
1051
|
+
else {
|
|
1052
|
+
s4 = peg$FAILED;
|
|
1053
|
+
if (peg$silentFails === 0) {
|
|
1054
|
+
peg$fail(peg$c32);
|
|
1055
|
+
}
|
|
1056
|
+
}
|
|
1057
|
+
if (s4 !== peg$FAILED) {
|
|
1058
|
+
while (s4 !== peg$FAILED) {
|
|
1059
|
+
s3.push(s4);
|
|
1060
|
+
if (peg$c31.test(input.charAt(peg$currPos))) {
|
|
1061
|
+
s4 = input.charAt(peg$currPos);
|
|
1062
|
+
peg$currPos++;
|
|
1063
|
+
}
|
|
1064
|
+
else {
|
|
1065
|
+
s4 = peg$FAILED;
|
|
1066
|
+
if (peg$silentFails === 0) {
|
|
1067
|
+
peg$fail(peg$c32);
|
|
1068
|
+
}
|
|
1069
|
+
}
|
|
1070
|
+
}
|
|
1071
|
+
}
|
|
1072
|
+
else {
|
|
1073
|
+
s3 = peg$FAILED;
|
|
1074
|
+
}
|
|
1075
|
+
if (s3 !== peg$FAILED) {
|
|
1076
|
+
s1 = [s1, s2, s3];
|
|
1077
|
+
s0 = s1;
|
|
1078
|
+
}
|
|
1079
|
+
else {
|
|
1080
|
+
peg$currPos = s0;
|
|
1081
|
+
s0 = peg$FAILED;
|
|
1082
|
+
}
|
|
1083
|
+
}
|
|
1084
|
+
else {
|
|
1085
|
+
peg$currPos = s0;
|
|
1086
|
+
s0 = peg$FAILED;
|
|
1087
|
+
}
|
|
1088
|
+
}
|
|
1089
|
+
else {
|
|
1090
|
+
peg$currPos = s0;
|
|
1091
|
+
s0 = peg$FAILED;
|
|
1092
|
+
}
|
|
1093
|
+
}
|
|
1094
|
+
return s0;
|
|
1095
|
+
}
|
|
1096
|
+
function peg$parseqa_hs() {
|
|
1097
|
+
var s0;
|
|
1098
|
+
if (peg$c37.test(input.charAt(peg$currPos))) {
|
|
1099
|
+
s0 = input.charAt(peg$currPos);
|
|
1100
|
+
peg$currPos++;
|
|
338
1101
|
}
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
peg$
|
|
1102
|
+
else {
|
|
1103
|
+
s0 = peg$FAILED;
|
|
1104
|
+
if (peg$silentFails === 0) {
|
|
1105
|
+
peg$fail(peg$c38);
|
|
1106
|
+
}
|
|
342
1107
|
}
|
|
343
|
-
|
|
344
|
-
}
|
|
345
|
-
function peg$buildSimpleError(message, location) {
|
|
346
|
-
return new peg$SyntaxError(message, null, null, location);
|
|
347
|
-
}
|
|
348
|
-
function peg$buildStructuredError(expected, found, location) {
|
|
349
|
-
return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
|
|
1108
|
+
return s0;
|
|
350
1109
|
}
|
|
351
|
-
function peg$
|
|
1110
|
+
function peg$parseqa_ws() {
|
|
352
1111
|
var s0, s1;
|
|
353
1112
|
s0 = [];
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
1113
|
+
if (peg$c39.test(input.charAt(peg$currPos))) {
|
|
1114
|
+
s1 = input.charAt(peg$currPos);
|
|
1115
|
+
peg$currPos++;
|
|
1116
|
+
}
|
|
1117
|
+
else {
|
|
1118
|
+
s1 = peg$FAILED;
|
|
1119
|
+
if (peg$silentFails === 0) {
|
|
1120
|
+
peg$fail(peg$c40);
|
|
1121
|
+
}
|
|
1122
|
+
}
|
|
1123
|
+
while (s1 !== peg$FAILED) {
|
|
1124
|
+
s0.push(s1);
|
|
1125
|
+
if (peg$c39.test(input.charAt(peg$currPos))) {
|
|
357
1126
|
s1 = input.charAt(peg$currPos);
|
|
358
1127
|
peg$currPos++;
|
|
359
1128
|
}
|
|
360
1129
|
else {
|
|
361
1130
|
s1 = peg$FAILED;
|
|
362
1131
|
if (peg$silentFails === 0) {
|
|
363
|
-
peg$fail(peg$
|
|
364
|
-
}
|
|
365
|
-
}
|
|
366
|
-
}
|
|
367
|
-
while (s1 !== peg$FAILED) {
|
|
368
|
-
s0.push(s1);
|
|
369
|
-
s1 = peg$parserule_match();
|
|
370
|
-
if (s1 === peg$FAILED) {
|
|
371
|
-
if (input.length > peg$currPos) {
|
|
372
|
-
s1 = input.charAt(peg$currPos);
|
|
373
|
-
peg$currPos++;
|
|
374
|
-
}
|
|
375
|
-
else {
|
|
376
|
-
s1 = peg$FAILED;
|
|
377
|
-
if (peg$silentFails === 0) {
|
|
378
|
-
peg$fail(peg$c0);
|
|
379
|
-
}
|
|
1132
|
+
peg$fail(peg$c40);
|
|
380
1133
|
}
|
|
381
1134
|
}
|
|
382
1135
|
}
|
|
383
1136
|
return s0;
|
|
384
1137
|
}
|
|
385
|
-
function peg$
|
|
386
|
-
var s0;
|
|
387
|
-
s0 = peg$
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
if (
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
1138
|
+
function peg$parseattr_nested_angle() {
|
|
1139
|
+
var s0, s1, s2, s3, s4, s5, s6, s7, s8;
|
|
1140
|
+
s0 = peg$currPos;
|
|
1141
|
+
s1 = peg$parseoption_start();
|
|
1142
|
+
if (s1 !== peg$FAILED) {
|
|
1143
|
+
if (input.charCodeAt(peg$currPos) === 58) {
|
|
1144
|
+
s2 = peg$c2;
|
|
1145
|
+
peg$currPos++;
|
|
1146
|
+
}
|
|
1147
|
+
else {
|
|
1148
|
+
s2 = peg$FAILED;
|
|
1149
|
+
if (peg$silentFails === 0) {
|
|
1150
|
+
peg$fail(peg$c3);
|
|
1151
|
+
}
|
|
1152
|
+
}
|
|
1153
|
+
if (s2 !== peg$FAILED) {
|
|
1154
|
+
s3 = peg$parseidentifier();
|
|
1155
|
+
if (s3 !== peg$FAILED) {
|
|
1156
|
+
if (input.charCodeAt(peg$currPos) === 60) {
|
|
1157
|
+
s4 = peg$c4;
|
|
1158
|
+
peg$currPos++;
|
|
1159
|
+
}
|
|
1160
|
+
else {
|
|
1161
|
+
s4 = peg$FAILED;
|
|
1162
|
+
if (peg$silentFails === 0) {
|
|
1163
|
+
peg$fail(peg$c5);
|
|
1164
|
+
}
|
|
1165
|
+
}
|
|
1166
|
+
if (s4 !== peg$FAILED) {
|
|
1167
|
+
s5 = peg$currPos;
|
|
1168
|
+
peg$silentFails++;
|
|
1169
|
+
if (input.charCodeAt(peg$currPos) === 60) {
|
|
1170
|
+
s6 = peg$c4;
|
|
1171
|
+
peg$currPos++;
|
|
1172
|
+
}
|
|
1173
|
+
else {
|
|
1174
|
+
s6 = peg$FAILED;
|
|
1175
|
+
if (peg$silentFails === 0) {
|
|
1176
|
+
peg$fail(peg$c5);
|
|
1177
|
+
}
|
|
1178
|
+
}
|
|
1179
|
+
peg$silentFails--;
|
|
1180
|
+
if (s6 === peg$FAILED) {
|
|
1181
|
+
s5 = void 0;
|
|
1182
|
+
}
|
|
1183
|
+
else {
|
|
1184
|
+
peg$currPos = s5;
|
|
1185
|
+
s5 = peg$FAILED;
|
|
1186
|
+
}
|
|
1187
|
+
if (s5 !== peg$FAILED) {
|
|
1188
|
+
s6 = peg$currPos;
|
|
1189
|
+
s7 = [];
|
|
1190
|
+
if (peg$c41.test(input.charAt(peg$currPos))) {
|
|
1191
|
+
s8 = input.charAt(peg$currPos);
|
|
1192
|
+
peg$currPos++;
|
|
1193
|
+
}
|
|
1194
|
+
else {
|
|
1195
|
+
s8 = peg$FAILED;
|
|
1196
|
+
if (peg$silentFails === 0) {
|
|
1197
|
+
peg$fail(peg$c42);
|
|
1198
|
+
}
|
|
1199
|
+
}
|
|
1200
|
+
while (s8 !== peg$FAILED) {
|
|
1201
|
+
s7.push(s8);
|
|
1202
|
+
if (peg$c41.test(input.charAt(peg$currPos))) {
|
|
1203
|
+
s8 = input.charAt(peg$currPos);
|
|
1204
|
+
peg$currPos++;
|
|
1205
|
+
}
|
|
1206
|
+
else {
|
|
1207
|
+
s8 = peg$FAILED;
|
|
1208
|
+
if (peg$silentFails === 0) {
|
|
1209
|
+
peg$fail(peg$c42);
|
|
1210
|
+
}
|
|
1211
|
+
}
|
|
1212
|
+
}
|
|
1213
|
+
if (s7 !== peg$FAILED) {
|
|
1214
|
+
s6 = input.substring(s6, peg$currPos);
|
|
1215
|
+
}
|
|
1216
|
+
else {
|
|
1217
|
+
s6 = s7;
|
|
1218
|
+
}
|
|
1219
|
+
if (s6 !== peg$FAILED) {
|
|
1220
|
+
if (input.charCodeAt(peg$currPos) === 62) {
|
|
1221
|
+
s7 = peg$c6;
|
|
1222
|
+
peg$currPos++;
|
|
1223
|
+
}
|
|
1224
|
+
else {
|
|
1225
|
+
s7 = peg$FAILED;
|
|
1226
|
+
if (peg$silentFails === 0) {
|
|
1227
|
+
peg$fail(peg$c7);
|
|
1228
|
+
}
|
|
402
1229
|
}
|
|
1230
|
+
if (s7 !== peg$FAILED) {
|
|
1231
|
+
peg$savedPos = s0;
|
|
1232
|
+
s1 = peg$c43(s3, s6);
|
|
1233
|
+
s0 = s1;
|
|
1234
|
+
}
|
|
1235
|
+
else {
|
|
1236
|
+
peg$currPos = s0;
|
|
1237
|
+
s0 = peg$FAILED;
|
|
1238
|
+
}
|
|
1239
|
+
}
|
|
1240
|
+
else {
|
|
1241
|
+
peg$currPos = s0;
|
|
1242
|
+
s0 = peg$FAILED;
|
|
403
1243
|
}
|
|
404
1244
|
}
|
|
1245
|
+
else {
|
|
1246
|
+
peg$currPos = s0;
|
|
1247
|
+
s0 = peg$FAILED;
|
|
1248
|
+
}
|
|
1249
|
+
}
|
|
1250
|
+
else {
|
|
1251
|
+
peg$currPos = s0;
|
|
1252
|
+
s0 = peg$FAILED;
|
|
405
1253
|
}
|
|
406
1254
|
}
|
|
1255
|
+
else {
|
|
1256
|
+
peg$currPos = s0;
|
|
1257
|
+
s0 = peg$FAILED;
|
|
1258
|
+
}
|
|
1259
|
+
}
|
|
1260
|
+
else {
|
|
1261
|
+
peg$currPos = s0;
|
|
1262
|
+
s0 = peg$FAILED;
|
|
407
1263
|
}
|
|
408
1264
|
}
|
|
1265
|
+
else {
|
|
1266
|
+
peg$currPos = s0;
|
|
1267
|
+
s0 = peg$FAILED;
|
|
1268
|
+
}
|
|
409
1269
|
return s0;
|
|
410
1270
|
}
|
|
411
|
-
function peg$
|
|
412
|
-
var s0, s1, s2, s3, s4, s5, s6
|
|
1271
|
+
function peg$parsequoted_value() {
|
|
1272
|
+
var s0, s1, s2, s3, s4, s5, s6;
|
|
413
1273
|
s0 = peg$currPos;
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
1274
|
+
s1 = peg$currPos;
|
|
1275
|
+
peg$silentFails++;
|
|
1276
|
+
s2 = peg$parsesol();
|
|
1277
|
+
peg$silentFails--;
|
|
1278
|
+
if (s2 === peg$FAILED) {
|
|
1279
|
+
s1 = void 0;
|
|
417
1280
|
}
|
|
418
1281
|
else {
|
|
1282
|
+
peg$currPos = s1;
|
|
419
1283
|
s1 = peg$FAILED;
|
|
420
|
-
if (peg$silentFails === 0) {
|
|
421
|
-
peg$fail(peg$c2);
|
|
422
|
-
}
|
|
423
1284
|
}
|
|
424
1285
|
if (s1 !== peg$FAILED) {
|
|
425
|
-
|
|
1286
|
+
peg$savedPos = peg$currPos;
|
|
1287
|
+
s2 = peg$c44();
|
|
1288
|
+
if (s2) {
|
|
1289
|
+
s2 = void 0;
|
|
1290
|
+
}
|
|
1291
|
+
else {
|
|
1292
|
+
s2 = peg$FAILED;
|
|
1293
|
+
}
|
|
426
1294
|
if (s2 !== peg$FAILED) {
|
|
427
|
-
|
|
428
|
-
|
|
1295
|
+
s3 = peg$currPos;
|
|
1296
|
+
if (input.charCodeAt(peg$currPos) === 39) {
|
|
1297
|
+
s4 = peg$c20;
|
|
429
1298
|
peg$currPos++;
|
|
430
1299
|
}
|
|
431
1300
|
else {
|
|
432
|
-
|
|
1301
|
+
s4 = peg$FAILED;
|
|
433
1302
|
if (peg$silentFails === 0) {
|
|
434
|
-
peg$fail(peg$
|
|
1303
|
+
peg$fail(peg$c21);
|
|
435
1304
|
}
|
|
436
1305
|
}
|
|
437
|
-
if (
|
|
438
|
-
|
|
439
|
-
peg$
|
|
440
|
-
|
|
441
|
-
s5 = peg$c3;
|
|
1306
|
+
if (s4 !== peg$FAILED) {
|
|
1307
|
+
s5 = [];
|
|
1308
|
+
if (peg$c45.test(input.charAt(peg$currPos))) {
|
|
1309
|
+
s6 = input.charAt(peg$currPos);
|
|
442
1310
|
peg$currPos++;
|
|
443
1311
|
}
|
|
444
1312
|
else {
|
|
445
|
-
|
|
1313
|
+
s6 = peg$FAILED;
|
|
446
1314
|
if (peg$silentFails === 0) {
|
|
447
|
-
peg$fail(peg$
|
|
1315
|
+
peg$fail(peg$c46);
|
|
1316
|
+
}
|
|
1317
|
+
}
|
|
1318
|
+
while (s6 !== peg$FAILED) {
|
|
1319
|
+
s5.push(s6);
|
|
1320
|
+
if (peg$c45.test(input.charAt(peg$currPos))) {
|
|
1321
|
+
s6 = input.charAt(peg$currPos);
|
|
1322
|
+
peg$currPos++;
|
|
1323
|
+
}
|
|
1324
|
+
else {
|
|
1325
|
+
s6 = peg$FAILED;
|
|
1326
|
+
if (peg$silentFails === 0) {
|
|
1327
|
+
peg$fail(peg$c46);
|
|
1328
|
+
}
|
|
1329
|
+
}
|
|
1330
|
+
}
|
|
1331
|
+
if (s5 !== peg$FAILED) {
|
|
1332
|
+
if (input.charCodeAt(peg$currPos) === 39) {
|
|
1333
|
+
s6 = peg$c20;
|
|
1334
|
+
peg$currPos++;
|
|
1335
|
+
}
|
|
1336
|
+
else {
|
|
1337
|
+
s6 = peg$FAILED;
|
|
1338
|
+
if (peg$silentFails === 0) {
|
|
1339
|
+
peg$fail(peg$c21);
|
|
1340
|
+
}
|
|
1341
|
+
}
|
|
1342
|
+
if (s6 !== peg$FAILED) {
|
|
1343
|
+
s4 = [s4, s5, s6];
|
|
1344
|
+
s3 = s4;
|
|
1345
|
+
}
|
|
1346
|
+
else {
|
|
1347
|
+
peg$currPos = s3;
|
|
1348
|
+
s3 = peg$FAILED;
|
|
448
1349
|
}
|
|
449
1350
|
}
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
1351
|
+
else {
|
|
1352
|
+
peg$currPos = s3;
|
|
1353
|
+
s3 = peg$FAILED;
|
|
1354
|
+
}
|
|
1355
|
+
}
|
|
1356
|
+
else {
|
|
1357
|
+
peg$currPos = s3;
|
|
1358
|
+
s3 = peg$FAILED;
|
|
1359
|
+
}
|
|
1360
|
+
if (s3 === peg$FAILED) {
|
|
1361
|
+
s3 = peg$currPos;
|
|
1362
|
+
if (input.charCodeAt(peg$currPos) === 34) {
|
|
1363
|
+
s4 = peg$c24;
|
|
1364
|
+
peg$currPos++;
|
|
453
1365
|
}
|
|
454
1366
|
else {
|
|
455
|
-
peg$currPos = s4;
|
|
456
1367
|
s4 = peg$FAILED;
|
|
1368
|
+
if (peg$silentFails === 0) {
|
|
1369
|
+
peg$fail(peg$c25);
|
|
1370
|
+
}
|
|
457
1371
|
}
|
|
458
1372
|
if (s4 !== peg$FAILED) {
|
|
459
|
-
s5 =
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
s7 = input.charAt(peg$currPos);
|
|
1373
|
+
s5 = [];
|
|
1374
|
+
if (peg$c47.test(input.charAt(peg$currPos))) {
|
|
1375
|
+
s6 = input.charAt(peg$currPos);
|
|
463
1376
|
peg$currPos++;
|
|
464
1377
|
}
|
|
465
1378
|
else {
|
|
466
|
-
|
|
1379
|
+
s6 = peg$FAILED;
|
|
467
1380
|
if (peg$silentFails === 0) {
|
|
468
|
-
peg$fail(peg$
|
|
1381
|
+
peg$fail(peg$c48);
|
|
469
1382
|
}
|
|
470
1383
|
}
|
|
471
|
-
while (
|
|
472
|
-
|
|
473
|
-
if (peg$
|
|
474
|
-
|
|
1384
|
+
while (s6 !== peg$FAILED) {
|
|
1385
|
+
s5.push(s6);
|
|
1386
|
+
if (peg$c47.test(input.charAt(peg$currPos))) {
|
|
1387
|
+
s6 = input.charAt(peg$currPos);
|
|
475
1388
|
peg$currPos++;
|
|
476
1389
|
}
|
|
477
1390
|
else {
|
|
478
|
-
|
|
1391
|
+
s6 = peg$FAILED;
|
|
479
1392
|
if (peg$silentFails === 0) {
|
|
480
|
-
peg$fail(peg$
|
|
1393
|
+
peg$fail(peg$c48);
|
|
481
1394
|
}
|
|
482
1395
|
}
|
|
483
1396
|
}
|
|
484
|
-
if (s6 !== peg$FAILED) {
|
|
485
|
-
s5 = input.substring(s5, peg$currPos);
|
|
486
|
-
}
|
|
487
|
-
else {
|
|
488
|
-
s5 = s6;
|
|
489
|
-
}
|
|
490
1397
|
if (s5 !== peg$FAILED) {
|
|
491
|
-
if (input.charCodeAt(peg$currPos) ===
|
|
492
|
-
s6 = peg$
|
|
1398
|
+
if (input.charCodeAt(peg$currPos) === 34) {
|
|
1399
|
+
s6 = peg$c24;
|
|
493
1400
|
peg$currPos++;
|
|
494
1401
|
}
|
|
495
1402
|
else {
|
|
496
1403
|
s6 = peg$FAILED;
|
|
497
1404
|
if (peg$silentFails === 0) {
|
|
498
|
-
peg$fail(peg$
|
|
1405
|
+
peg$fail(peg$c25);
|
|
499
1406
|
}
|
|
500
1407
|
}
|
|
501
1408
|
if (s6 !== peg$FAILED) {
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
s0 = s1;
|
|
1409
|
+
s4 = [s4, s5, s6];
|
|
1410
|
+
s3 = s4;
|
|
505
1411
|
}
|
|
506
1412
|
else {
|
|
507
|
-
peg$currPos =
|
|
508
|
-
|
|
1413
|
+
peg$currPos = s3;
|
|
1414
|
+
s3 = peg$FAILED;
|
|
509
1415
|
}
|
|
510
1416
|
}
|
|
511
1417
|
else {
|
|
512
|
-
peg$currPos =
|
|
513
|
-
|
|
1418
|
+
peg$currPos = s3;
|
|
1419
|
+
s3 = peg$FAILED;
|
|
514
1420
|
}
|
|
515
1421
|
}
|
|
516
1422
|
else {
|
|
517
|
-
peg$currPos =
|
|
518
|
-
|
|
1423
|
+
peg$currPos = s3;
|
|
1424
|
+
s3 = peg$FAILED;
|
|
1425
|
+
}
|
|
1426
|
+
if (s3 === peg$FAILED) {
|
|
1427
|
+
s3 = peg$currPos;
|
|
1428
|
+
if (input.charCodeAt(peg$currPos) === 65378) {
|
|
1429
|
+
s4 = peg$c49;
|
|
1430
|
+
peg$currPos++;
|
|
1431
|
+
}
|
|
1432
|
+
else {
|
|
1433
|
+
s4 = peg$FAILED;
|
|
1434
|
+
if (peg$silentFails === 0) {
|
|
1435
|
+
peg$fail(peg$c50);
|
|
1436
|
+
}
|
|
1437
|
+
}
|
|
1438
|
+
if (s4 !== peg$FAILED) {
|
|
1439
|
+
s5 = [];
|
|
1440
|
+
if (peg$c51.test(input.charAt(peg$currPos))) {
|
|
1441
|
+
s6 = input.charAt(peg$currPos);
|
|
1442
|
+
peg$currPos++;
|
|
1443
|
+
}
|
|
1444
|
+
else {
|
|
1445
|
+
s6 = peg$FAILED;
|
|
1446
|
+
if (peg$silentFails === 0) {
|
|
1447
|
+
peg$fail(peg$c52);
|
|
1448
|
+
}
|
|
1449
|
+
}
|
|
1450
|
+
while (s6 !== peg$FAILED) {
|
|
1451
|
+
s5.push(s6);
|
|
1452
|
+
if (peg$c51.test(input.charAt(peg$currPos))) {
|
|
1453
|
+
s6 = input.charAt(peg$currPos);
|
|
1454
|
+
peg$currPos++;
|
|
1455
|
+
}
|
|
1456
|
+
else {
|
|
1457
|
+
s6 = peg$FAILED;
|
|
1458
|
+
if (peg$silentFails === 0) {
|
|
1459
|
+
peg$fail(peg$c52);
|
|
1460
|
+
}
|
|
1461
|
+
}
|
|
1462
|
+
}
|
|
1463
|
+
if (s5 !== peg$FAILED) {
|
|
1464
|
+
if (input.charCodeAt(peg$currPos) === 65379) {
|
|
1465
|
+
s6 = peg$c53;
|
|
1466
|
+
peg$currPos++;
|
|
1467
|
+
}
|
|
1468
|
+
else {
|
|
1469
|
+
s6 = peg$FAILED;
|
|
1470
|
+
if (peg$silentFails === 0) {
|
|
1471
|
+
peg$fail(peg$c54);
|
|
1472
|
+
}
|
|
1473
|
+
}
|
|
1474
|
+
if (s6 !== peg$FAILED) {
|
|
1475
|
+
s4 = [s4, s5, s6];
|
|
1476
|
+
s3 = s4;
|
|
1477
|
+
}
|
|
1478
|
+
else {
|
|
1479
|
+
peg$currPos = s3;
|
|
1480
|
+
s3 = peg$FAILED;
|
|
1481
|
+
}
|
|
1482
|
+
}
|
|
1483
|
+
else {
|
|
1484
|
+
peg$currPos = s3;
|
|
1485
|
+
s3 = peg$FAILED;
|
|
1486
|
+
}
|
|
1487
|
+
}
|
|
1488
|
+
else {
|
|
1489
|
+
peg$currPos = s3;
|
|
1490
|
+
s3 = peg$FAILED;
|
|
1491
|
+
}
|
|
519
1492
|
}
|
|
520
1493
|
}
|
|
1494
|
+
if (s3 !== peg$FAILED) {
|
|
1495
|
+
peg$savedPos = s0;
|
|
1496
|
+
s1 = peg$c55();
|
|
1497
|
+
s0 = s1;
|
|
1498
|
+
}
|
|
521
1499
|
else {
|
|
522
1500
|
peg$currPos = s0;
|
|
523
1501
|
s0 = peg$FAILED;
|
|
@@ -539,14 +1517,14 @@ function peg$parse(input, options) {
|
|
|
539
1517
|
s0 = peg$currPos;
|
|
540
1518
|
s1 = peg$parsesol();
|
|
541
1519
|
if (s1 !== peg$FAILED) {
|
|
542
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
543
|
-
s2 = peg$
|
|
1520
|
+
if (input.substr(peg$currPos, 6) === peg$c56) {
|
|
1521
|
+
s2 = peg$c56;
|
|
544
1522
|
peg$currPos += 6;
|
|
545
1523
|
}
|
|
546
1524
|
else {
|
|
547
1525
|
s2 = peg$FAILED;
|
|
548
1526
|
if (peg$silentFails === 0) {
|
|
549
|
-
peg$fail(peg$
|
|
1527
|
+
peg$fail(peg$c57);
|
|
550
1528
|
}
|
|
551
1529
|
}
|
|
552
1530
|
if (s2 !== peg$FAILED) {
|
|
@@ -555,7 +1533,7 @@ function peg$parse(input, options) {
|
|
|
555
1533
|
s4 = peg$parseidentifier();
|
|
556
1534
|
if (s4 !== peg$FAILED) {
|
|
557
1535
|
peg$savedPos = s0;
|
|
558
|
-
s1 = peg$
|
|
1536
|
+
s1 = peg$c58(s4);
|
|
559
1537
|
s0 = s1;
|
|
560
1538
|
}
|
|
561
1539
|
else {
|
|
@@ -584,14 +1562,14 @@ function peg$parse(input, options) {
|
|
|
584
1562
|
s0 = peg$currPos;
|
|
585
1563
|
s1 = peg$parsesol();
|
|
586
1564
|
if (s1 !== peg$FAILED) {
|
|
587
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
588
|
-
s2 = peg$
|
|
1565
|
+
if (input.substr(peg$currPos, 4) === peg$c59) {
|
|
1566
|
+
s2 = peg$c59;
|
|
589
1567
|
peg$currPos += 4;
|
|
590
1568
|
}
|
|
591
1569
|
else {
|
|
592
1570
|
s2 = peg$FAILED;
|
|
593
1571
|
if (peg$silentFails === 0) {
|
|
594
|
-
peg$fail(peg$
|
|
1572
|
+
peg$fail(peg$c60);
|
|
595
1573
|
}
|
|
596
1574
|
}
|
|
597
1575
|
if (s2 !== peg$FAILED) {
|
|
@@ -600,7 +1578,7 @@ function peg$parse(input, options) {
|
|
|
600
1578
|
s4 = peg$parseidentifier();
|
|
601
1579
|
if (s4 !== peg$FAILED) {
|
|
602
1580
|
peg$savedPos = s0;
|
|
603
|
-
s1 = peg$
|
|
1581
|
+
s1 = peg$c61(s4);
|
|
604
1582
|
s0 = s1;
|
|
605
1583
|
}
|
|
606
1584
|
else {
|
|
@@ -629,14 +1607,14 @@ function peg$parse(input, options) {
|
|
|
629
1607
|
s0 = peg$currPos;
|
|
630
1608
|
s1 = peg$parsesol();
|
|
631
1609
|
if (s1 !== peg$FAILED) {
|
|
632
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
633
|
-
s2 = peg$
|
|
1610
|
+
if (input.substr(peg$currPos, 4) === peg$c62) {
|
|
1611
|
+
s2 = peg$c62;
|
|
634
1612
|
peg$currPos += 4;
|
|
635
1613
|
}
|
|
636
1614
|
else {
|
|
637
1615
|
s2 = peg$FAILED;
|
|
638
1616
|
if (peg$silentFails === 0) {
|
|
639
|
-
peg$fail(peg$
|
|
1617
|
+
peg$fail(peg$c63);
|
|
640
1618
|
}
|
|
641
1619
|
}
|
|
642
1620
|
if (s2 !== peg$FAILED) {
|
|
@@ -645,7 +1623,7 @@ function peg$parse(input, options) {
|
|
|
645
1623
|
s4 = peg$parseidentifier();
|
|
646
1624
|
if (s4 !== peg$FAILED) {
|
|
647
1625
|
peg$savedPos = s0;
|
|
648
|
-
s1 = peg$
|
|
1626
|
+
s1 = peg$c64();
|
|
649
1627
|
s0 = s1;
|
|
650
1628
|
}
|
|
651
1629
|
else {
|
|
@@ -677,24 +1655,24 @@ function peg$parse(input, options) {
|
|
|
677
1655
|
s2 = peg$parse__();
|
|
678
1656
|
if (s2 !== peg$FAILED) {
|
|
679
1657
|
if (input.charCodeAt(peg$currPos) === 58) {
|
|
680
|
-
s3 = peg$
|
|
1658
|
+
s3 = peg$c2;
|
|
681
1659
|
peg$currPos++;
|
|
682
1660
|
}
|
|
683
1661
|
else {
|
|
684
1662
|
s3 = peg$FAILED;
|
|
685
1663
|
if (peg$silentFails === 0) {
|
|
686
|
-
peg$fail(peg$
|
|
1664
|
+
peg$fail(peg$c3);
|
|
687
1665
|
}
|
|
688
1666
|
}
|
|
689
1667
|
if (s3 !== peg$FAILED) {
|
|
690
1668
|
if (input.charCodeAt(peg$currPos) === 33) {
|
|
691
|
-
s4 = peg$
|
|
1669
|
+
s4 = peg$c65;
|
|
692
1670
|
peg$currPos++;
|
|
693
1671
|
}
|
|
694
1672
|
else {
|
|
695
1673
|
s4 = peg$FAILED;
|
|
696
1674
|
if (peg$silentFails === 0) {
|
|
697
|
-
peg$fail(peg$
|
|
1675
|
+
peg$fail(peg$c66);
|
|
698
1676
|
}
|
|
699
1677
|
}
|
|
700
1678
|
if (s4 === peg$FAILED) {
|
|
@@ -706,7 +1684,7 @@ function peg$parse(input, options) {
|
|
|
706
1684
|
s6 = peg$parsevalue_delim();
|
|
707
1685
|
if (s6 !== peg$FAILED) {
|
|
708
1686
|
peg$savedPos = s0;
|
|
709
|
-
s1 = peg$
|
|
1687
|
+
s1 = peg$c67(s5);
|
|
710
1688
|
s0 = s1;
|
|
711
1689
|
}
|
|
712
1690
|
else {
|
|
@@ -743,79 +1721,79 @@ function peg$parse(input, options) {
|
|
|
743
1721
|
function peg$parsevalue_delim() {
|
|
744
1722
|
var s0;
|
|
745
1723
|
if (input.charCodeAt(peg$currPos) === 60) {
|
|
746
|
-
s0 = peg$
|
|
1724
|
+
s0 = peg$c4;
|
|
747
1725
|
peg$currPos++;
|
|
748
1726
|
}
|
|
749
1727
|
else {
|
|
750
1728
|
s0 = peg$FAILED;
|
|
751
1729
|
if (peg$silentFails === 0) {
|
|
752
|
-
peg$fail(peg$
|
|
1730
|
+
peg$fail(peg$c5);
|
|
753
1731
|
}
|
|
754
1732
|
}
|
|
755
1733
|
if (s0 === peg$FAILED) {
|
|
756
1734
|
if (input.charCodeAt(peg$currPos) === 40) {
|
|
757
|
-
s0 = peg$
|
|
1735
|
+
s0 = peg$c68;
|
|
758
1736
|
peg$currPos++;
|
|
759
1737
|
}
|
|
760
1738
|
else {
|
|
761
1739
|
s0 = peg$FAILED;
|
|
762
1740
|
if (peg$silentFails === 0) {
|
|
763
|
-
peg$fail(peg$
|
|
1741
|
+
peg$fail(peg$c69);
|
|
764
1742
|
}
|
|
765
1743
|
}
|
|
766
1744
|
if (s0 === peg$FAILED) {
|
|
767
1745
|
if (input.charCodeAt(peg$currPos) === 123) {
|
|
768
|
-
s0 = peg$
|
|
1746
|
+
s0 = peg$c70;
|
|
769
1747
|
peg$currPos++;
|
|
770
1748
|
}
|
|
771
1749
|
else {
|
|
772
1750
|
s0 = peg$FAILED;
|
|
773
1751
|
if (peg$silentFails === 0) {
|
|
774
|
-
peg$fail(peg$
|
|
1752
|
+
peg$fail(peg$c71);
|
|
775
1753
|
}
|
|
776
1754
|
}
|
|
777
1755
|
if (s0 === peg$FAILED) {
|
|
778
1756
|
if (input.charCodeAt(peg$currPos) === 91) {
|
|
779
|
-
s0 = peg$
|
|
1757
|
+
s0 = peg$c72;
|
|
780
1758
|
peg$currPos++;
|
|
781
1759
|
}
|
|
782
1760
|
else {
|
|
783
1761
|
s0 = peg$FAILED;
|
|
784
1762
|
if (peg$silentFails === 0) {
|
|
785
|
-
peg$fail(peg$
|
|
1763
|
+
peg$fail(peg$c73);
|
|
786
1764
|
}
|
|
787
1765
|
}
|
|
788
1766
|
if (s0 === peg$FAILED) {
|
|
789
1767
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
790
|
-
s0 = peg$
|
|
1768
|
+
s0 = peg$c20;
|
|
791
1769
|
peg$currPos++;
|
|
792
1770
|
}
|
|
793
1771
|
else {
|
|
794
1772
|
s0 = peg$FAILED;
|
|
795
1773
|
if (peg$silentFails === 0) {
|
|
796
|
-
peg$fail(peg$
|
|
1774
|
+
peg$fail(peg$c21);
|
|
797
1775
|
}
|
|
798
1776
|
}
|
|
799
1777
|
if (s0 === peg$FAILED) {
|
|
800
1778
|
if (input.charCodeAt(peg$currPos) === 34) {
|
|
801
|
-
s0 = peg$
|
|
1779
|
+
s0 = peg$c24;
|
|
802
1780
|
peg$currPos++;
|
|
803
1781
|
}
|
|
804
1782
|
else {
|
|
805
1783
|
s0 = peg$FAILED;
|
|
806
1784
|
if (peg$silentFails === 0) {
|
|
807
|
-
peg$fail(peg$
|
|
1785
|
+
peg$fail(peg$c25);
|
|
808
1786
|
}
|
|
809
1787
|
}
|
|
810
1788
|
if (s0 === peg$FAILED) {
|
|
811
1789
|
if (input.charCodeAt(peg$currPos) === 65378) {
|
|
812
|
-
s0 = peg$
|
|
1790
|
+
s0 = peg$c49;
|
|
813
1791
|
peg$currPos++;
|
|
814
1792
|
}
|
|
815
1793
|
else {
|
|
816
1794
|
s0 = peg$FAILED;
|
|
817
1795
|
if (peg$silentFails === 0) {
|
|
818
|
-
peg$fail(peg$
|
|
1796
|
+
peg$fail(peg$c50);
|
|
819
1797
|
}
|
|
820
1798
|
}
|
|
821
1799
|
}
|
|
@@ -832,38 +1810,38 @@ function peg$parse(input, options) {
|
|
|
832
1810
|
s1 = peg$parsesol();
|
|
833
1811
|
if (s1 !== peg$FAILED) {
|
|
834
1812
|
if (input.charCodeAt(peg$currPos) === 61) {
|
|
835
|
-
s2 = peg$
|
|
1813
|
+
s2 = peg$c74;
|
|
836
1814
|
peg$currPos++;
|
|
837
1815
|
}
|
|
838
1816
|
else {
|
|
839
1817
|
s2 = peg$FAILED;
|
|
840
1818
|
if (peg$silentFails === 0) {
|
|
841
|
-
peg$fail(peg$
|
|
1819
|
+
peg$fail(peg$c75);
|
|
842
1820
|
}
|
|
843
1821
|
}
|
|
844
1822
|
if (s2 !== peg$FAILED) {
|
|
845
1823
|
s3 = [];
|
|
846
|
-
if (peg$
|
|
1824
|
+
if (peg$c76.test(input.charAt(peg$currPos))) {
|
|
847
1825
|
s4 = input.charAt(peg$currPos);
|
|
848
1826
|
peg$currPos++;
|
|
849
1827
|
}
|
|
850
1828
|
else {
|
|
851
1829
|
s4 = peg$FAILED;
|
|
852
1830
|
if (peg$silentFails === 0) {
|
|
853
|
-
peg$fail(peg$
|
|
1831
|
+
peg$fail(peg$c77);
|
|
854
1832
|
}
|
|
855
1833
|
}
|
|
856
1834
|
if (s4 !== peg$FAILED) {
|
|
857
1835
|
while (s4 !== peg$FAILED) {
|
|
858
1836
|
s3.push(s4);
|
|
859
|
-
if (peg$
|
|
1837
|
+
if (peg$c76.test(input.charAt(peg$currPos))) {
|
|
860
1838
|
s4 = input.charAt(peg$currPos);
|
|
861
1839
|
peg$currPos++;
|
|
862
1840
|
}
|
|
863
1841
|
else {
|
|
864
1842
|
s4 = peg$FAILED;
|
|
865
1843
|
if (peg$silentFails === 0) {
|
|
866
|
-
peg$fail(peg$
|
|
1844
|
+
peg$fail(peg$c77);
|
|
867
1845
|
}
|
|
868
1846
|
}
|
|
869
1847
|
}
|
|
@@ -873,7 +1851,7 @@ function peg$parse(input, options) {
|
|
|
873
1851
|
}
|
|
874
1852
|
if (s3 !== peg$FAILED) {
|
|
875
1853
|
peg$savedPos = s0;
|
|
876
|
-
s1 = peg$
|
|
1854
|
+
s1 = peg$c64();
|
|
877
1855
|
s0 = s1;
|
|
878
1856
|
}
|
|
879
1857
|
else {
|
|
@@ -898,43 +1876,43 @@ function peg$parse(input, options) {
|
|
|
898
1876
|
s1 = peg$parsesol();
|
|
899
1877
|
if (s1 !== peg$FAILED) {
|
|
900
1878
|
s2 = [];
|
|
901
|
-
if (peg$
|
|
1879
|
+
if (peg$c76.test(input.charAt(peg$currPos))) {
|
|
902
1880
|
s3 = input.charAt(peg$currPos);
|
|
903
1881
|
peg$currPos++;
|
|
904
1882
|
}
|
|
905
1883
|
else {
|
|
906
1884
|
s3 = peg$FAILED;
|
|
907
1885
|
if (peg$silentFails === 0) {
|
|
908
|
-
peg$fail(peg$
|
|
1886
|
+
peg$fail(peg$c77);
|
|
909
1887
|
}
|
|
910
1888
|
}
|
|
911
1889
|
while (s3 !== peg$FAILED) {
|
|
912
1890
|
s2.push(s3);
|
|
913
|
-
if (peg$
|
|
1891
|
+
if (peg$c76.test(input.charAt(peg$currPos))) {
|
|
914
1892
|
s3 = input.charAt(peg$currPos);
|
|
915
1893
|
peg$currPos++;
|
|
916
1894
|
}
|
|
917
1895
|
else {
|
|
918
1896
|
s3 = peg$FAILED;
|
|
919
1897
|
if (peg$silentFails === 0) {
|
|
920
|
-
peg$fail(peg$
|
|
1898
|
+
peg$fail(peg$c77);
|
|
921
1899
|
}
|
|
922
1900
|
}
|
|
923
1901
|
}
|
|
924
1902
|
if (s2 !== peg$FAILED) {
|
|
925
1903
|
if (input.charCodeAt(peg$currPos) === 10) {
|
|
926
|
-
s3 = peg$
|
|
1904
|
+
s3 = peg$c78;
|
|
927
1905
|
peg$currPos++;
|
|
928
1906
|
}
|
|
929
1907
|
else {
|
|
930
1908
|
s3 = peg$FAILED;
|
|
931
1909
|
if (peg$silentFails === 0) {
|
|
932
|
-
peg$fail(peg$
|
|
1910
|
+
peg$fail(peg$c79);
|
|
933
1911
|
}
|
|
934
1912
|
}
|
|
935
1913
|
if (s3 !== peg$FAILED) {
|
|
936
1914
|
peg$savedPos = s0;
|
|
937
|
-
s1 = peg$
|
|
1915
|
+
s1 = peg$c80();
|
|
938
1916
|
s0 = s1;
|
|
939
1917
|
}
|
|
940
1918
|
else {
|
|
@@ -970,7 +1948,7 @@ function peg$parse(input, options) {
|
|
|
970
1948
|
}
|
|
971
1949
|
if (s2 !== peg$FAILED) {
|
|
972
1950
|
peg$savedPos = s0;
|
|
973
|
-
s1 = peg$
|
|
1951
|
+
s1 = peg$c80();
|
|
974
1952
|
s0 = s1;
|
|
975
1953
|
}
|
|
976
1954
|
else {
|
|
@@ -989,38 +1967,38 @@ function peg$parse(input, options) {
|
|
|
989
1967
|
peg$silentFails++;
|
|
990
1968
|
s0 = peg$currPos;
|
|
991
1969
|
s1 = peg$currPos;
|
|
992
|
-
if (peg$
|
|
1970
|
+
if (peg$c82.test(input.charAt(peg$currPos))) {
|
|
993
1971
|
s2 = input.charAt(peg$currPos);
|
|
994
1972
|
peg$currPos++;
|
|
995
1973
|
}
|
|
996
1974
|
else {
|
|
997
1975
|
s2 = peg$FAILED;
|
|
998
1976
|
if (peg$silentFails === 0) {
|
|
999
|
-
peg$fail(peg$
|
|
1977
|
+
peg$fail(peg$c83);
|
|
1000
1978
|
}
|
|
1001
1979
|
}
|
|
1002
1980
|
if (s2 !== peg$FAILED) {
|
|
1003
1981
|
s3 = [];
|
|
1004
|
-
if (peg$
|
|
1982
|
+
if (peg$c84.test(input.charAt(peg$currPos))) {
|
|
1005
1983
|
s4 = input.charAt(peg$currPos);
|
|
1006
1984
|
peg$currPos++;
|
|
1007
1985
|
}
|
|
1008
1986
|
else {
|
|
1009
1987
|
s4 = peg$FAILED;
|
|
1010
1988
|
if (peg$silentFails === 0) {
|
|
1011
|
-
peg$fail(peg$
|
|
1989
|
+
peg$fail(peg$c85);
|
|
1012
1990
|
}
|
|
1013
1991
|
}
|
|
1014
1992
|
while (s4 !== peg$FAILED) {
|
|
1015
1993
|
s3.push(s4);
|
|
1016
|
-
if (peg$
|
|
1994
|
+
if (peg$c84.test(input.charAt(peg$currPos))) {
|
|
1017
1995
|
s4 = input.charAt(peg$currPos);
|
|
1018
1996
|
peg$currPos++;
|
|
1019
1997
|
}
|
|
1020
1998
|
else {
|
|
1021
1999
|
s4 = peg$FAILED;
|
|
1022
2000
|
if (peg$silentFails === 0) {
|
|
1023
|
-
peg$fail(peg$
|
|
2001
|
+
peg$fail(peg$c85);
|
|
1024
2002
|
}
|
|
1025
2003
|
}
|
|
1026
2004
|
}
|
|
@@ -1047,7 +2025,7 @@ function peg$parse(input, options) {
|
|
|
1047
2025
|
if (s0 === peg$FAILED) {
|
|
1048
2026
|
s1 = peg$FAILED;
|
|
1049
2027
|
if (peg$silentFails === 0) {
|
|
1050
|
-
peg$fail(peg$
|
|
2028
|
+
peg$fail(peg$c81);
|
|
1051
2029
|
}
|
|
1052
2030
|
}
|
|
1053
2031
|
return s0;
|
|
@@ -1056,7 +2034,7 @@ function peg$parse(input, options) {
|
|
|
1056
2034
|
var s0, s1;
|
|
1057
2035
|
peg$silentFails++;
|
|
1058
2036
|
peg$savedPos = peg$currPos;
|
|
1059
|
-
s0 = peg$
|
|
2037
|
+
s0 = peg$c87();
|
|
1060
2038
|
if (s0) {
|
|
1061
2039
|
s0 = void 0;
|
|
1062
2040
|
}
|
|
@@ -1067,7 +2045,7 @@ function peg$parse(input, options) {
|
|
|
1067
2045
|
if (s0 === peg$FAILED) {
|
|
1068
2046
|
s1 = peg$FAILED;
|
|
1069
2047
|
if (peg$silentFails === 0) {
|
|
1070
|
-
peg$fail(peg$
|
|
2048
|
+
peg$fail(peg$c86);
|
|
1071
2049
|
}
|
|
1072
2050
|
}
|
|
1073
2051
|
return s0;
|
|
@@ -1076,27 +2054,27 @@ function peg$parse(input, options) {
|
|
|
1076
2054
|
var s0, s1;
|
|
1077
2055
|
peg$silentFails++;
|
|
1078
2056
|
s0 = [];
|
|
1079
|
-
if (peg$
|
|
2057
|
+
if (peg$c76.test(input.charAt(peg$currPos))) {
|
|
1080
2058
|
s1 = input.charAt(peg$currPos);
|
|
1081
2059
|
peg$currPos++;
|
|
1082
2060
|
}
|
|
1083
2061
|
else {
|
|
1084
2062
|
s1 = peg$FAILED;
|
|
1085
2063
|
if (peg$silentFails === 0) {
|
|
1086
|
-
peg$fail(peg$
|
|
2064
|
+
peg$fail(peg$c77);
|
|
1087
2065
|
}
|
|
1088
2066
|
}
|
|
1089
2067
|
if (s1 !== peg$FAILED) {
|
|
1090
2068
|
while (s1 !== peg$FAILED) {
|
|
1091
2069
|
s0.push(s1);
|
|
1092
|
-
if (peg$
|
|
2070
|
+
if (peg$c76.test(input.charAt(peg$currPos))) {
|
|
1093
2071
|
s1 = input.charAt(peg$currPos);
|
|
1094
2072
|
peg$currPos++;
|
|
1095
2073
|
}
|
|
1096
2074
|
else {
|
|
1097
2075
|
s1 = peg$FAILED;
|
|
1098
2076
|
if (peg$silentFails === 0) {
|
|
1099
|
-
peg$fail(peg$
|
|
2077
|
+
peg$fail(peg$c77);
|
|
1100
2078
|
}
|
|
1101
2079
|
}
|
|
1102
2080
|
}
|
|
@@ -1108,7 +2086,7 @@ function peg$parse(input, options) {
|
|
|
1108
2086
|
if (s0 === peg$FAILED) {
|
|
1109
2087
|
s1 = peg$FAILED;
|
|
1110
2088
|
if (peg$silentFails === 0) {
|
|
1111
|
-
peg$fail(peg$
|
|
2089
|
+
peg$fail(peg$c88);
|
|
1112
2090
|
}
|
|
1113
2091
|
}
|
|
1114
2092
|
return s0;
|
|
@@ -1121,6 +2099,26 @@ function peg$parse(input, options) {
|
|
|
1121
2099
|
options.isVerbatim = options.isVerbatim || (name => options.verbatimBlocks.indexOf(name) !== -1);
|
|
1122
2100
|
if (typeof options._inDirective !== 'boolean')
|
|
1123
2101
|
options._inDirective = false;
|
|
2102
|
+
// an option inside a hash follows its opening brace or a comma, across a continuation marker
|
|
2103
|
+
options.inHash =
|
|
2104
|
+
options.inHash ||
|
|
2105
|
+
(offset => {
|
|
2106
|
+
let at = offset - 1;
|
|
2107
|
+
for (;;) {
|
|
2108
|
+
while (at >= 0 && /[ \t\f\r]/.test(input.charAt(at)))
|
|
2109
|
+
at--;
|
|
2110
|
+
if (at > 0 && input.charAt(at) === '=' && input.charAt(at - 1) === '\n')
|
|
2111
|
+
at -= 2;
|
|
2112
|
+
else
|
|
2113
|
+
break;
|
|
2114
|
+
}
|
|
2115
|
+
return input.charAt(at) === '\x7b' || input.charAt(at) === ',';
|
|
2116
|
+
});
|
|
2117
|
+
// a `>` left on the line closed the value early, unless the options or the hash go on
|
|
2118
|
+
options.closedEarly =
|
|
2119
|
+
options.closedEarly ||
|
|
2120
|
+
((rest, inHash) => rest.indexOf('>') !== -1 && !(inHash ? /^[ \t\f]*[:,\x7d]/ : /^[ \t\f]*:/).test(rest));
|
|
2121
|
+
options.nestedAngleAdvice = 'use a non-conflicting delimiter ("...", (...), <<...>>) or plain text';
|
|
1124
2122
|
peg$result = peg$startRuleFunction();
|
|
1125
2123
|
if (peg$result !== peg$FAILED && peg$currPos === input.length) {
|
|
1126
2124
|
return peg$result;
|