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.
Files changed (50) hide show
  1. package/CHANGELOG.podlite +24 -0
  2. package/esm/assemble/index.d.ts +2 -0
  3. package/esm/assemble/index.js +404 -57
  4. package/esm/assemble/index.js.map +1 -1
  5. package/esm/cli.js +5 -1
  6. package/esm/cli.js.map +1 -1
  7. package/esm/lint/grammar/lint.js +1181 -183
  8. package/esm/lint/grammar/lint.js.map +1 -1
  9. package/esm/lint/rules/include-resolves.js +30 -17
  10. package/esm/lint/rules/include-resolves.js.map +1 -1
  11. package/esm/lint/rules/index.js +6 -0
  12. package/esm/lint/rules/index.js.map +1 -1
  13. package/esm/lint/rules/item-hierarchy.d.ts +3 -0
  14. package/esm/lint/rules/item-hierarchy.js +65 -0
  15. package/esm/lint/rules/item-hierarchy.js.map +1 -0
  16. package/esm/lint/rules/markup-code-too-deep.d.ts +3 -0
  17. package/esm/lint/rules/markup-code-too-deep.js +16 -0
  18. package/esm/lint/rules/markup-code-too-deep.js.map +1 -0
  19. package/esm/lint/rules/table-column-width.js +14 -6
  20. package/esm/lint/rules/table-column-width.js.map +1 -1
  21. package/esm/lint/rules/test-under-rule.d.ts +3 -0
  22. package/esm/lint/rules/test-under-rule.js +135 -0
  23. package/esm/lint/rules/test-under-rule.js.map +1 -0
  24. package/esm/version.d.ts +1 -1
  25. package/esm/version.js +1 -1
  26. package/lib/assemble/index.d.ts +2 -0
  27. package/lib/assemble/index.js +406 -58
  28. package/lib/assemble/index.js.map +1 -1
  29. package/lib/cli.js +5 -1
  30. package/lib/cli.js.map +1 -1
  31. package/lib/lint/grammar/lint.js +1181 -183
  32. package/lib/lint/grammar/lint.js.map +1 -1
  33. package/lib/lint/rules/include-resolves.js +29 -16
  34. package/lib/lint/rules/include-resolves.js.map +1 -1
  35. package/lib/lint/rules/index.js +6 -0
  36. package/lib/lint/rules/index.js.map +1 -1
  37. package/lib/lint/rules/item-hierarchy.d.ts +3 -0
  38. package/lib/lint/rules/item-hierarchy.js +68 -0
  39. package/lib/lint/rules/item-hierarchy.js.map +1 -0
  40. package/lib/lint/rules/markup-code-too-deep.d.ts +3 -0
  41. package/lib/lint/rules/markup-code-too-deep.js +19 -0
  42. package/lib/lint/rules/markup-code-too-deep.js.map +1 -0
  43. package/lib/lint/rules/table-column-width.js +14 -6
  44. package/lib/lint/rules/table-column-width.js.map +1 -1
  45. package/lib/lint/rules/test-under-rule.d.ts +3 -0
  46. package/lib/lint/rules/test-under-rule.js +138 -0
  47. package/lib/lint/rules/test-under-rule.js.map +1 -0
  48. package/lib/version.d.ts +1 -1
  49. package/lib/version.js +1 -1
  50. package/package.json +8 -8
@@ -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 = ':', peg$c2 = peg$literalExpectation(':', false), peg$c3 = '<', peg$c4 = peg$literalExpectation('<', false), peg$c5 = /^[^>]/, peg$c6 = peg$classExpectation(['>'], true, false), peg$c7 = '>', peg$c8 = peg$literalExpectation('>', false), peg$c9 = function (name, value) {
120
- // only a real attribute list is checked: `<` and `>` in running text or in
121
- // a verbatim block are not markup
122
- const verbatim = options._blockStack.some(b => options.isVerbatim(b.name));
123
- if (!options._inDirective || verbatim)
124
- return null;
125
- const advice = 'use a non-conflicting delimiter ("...", (...), <<...>>) or plain text';
126
- // the mirror case: the value ended at a `>` written inside it, and the one
127
- // the author meant as the closing bracket is still ahead on the line
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 = rest.indexOf('>') !== -1 && !/^[ \t]*:/.test(rest);
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$c10 = '=begin', peg$c11 = peg$literalExpectation('=begin', false), peg$c12 = function (name) {
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$c13 = '=end', peg$c14 = peg$literalExpectation('=end', false), peg$c15 = function (name) {
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$c16 = '=for', peg$c17 = peg$literalExpectation('=for', false), peg$c18 = function () {
254
+ }, peg$c62 = '=for', peg$c63 = peg$literalExpectation('=for', false), peg$c64 = function () {
232
255
  options._inDirective = true;
233
256
  return null;
234
- }, peg$c19 = '!', peg$c20 = peg$literalExpectation('!', false), peg$c21 = function (name) {
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$c22 = '(', peg$c23 = peg$literalExpectation('(', false), peg$c24 = '{', peg$c25 = peg$literalExpectation('{', false), peg$c26 = '[', peg$c27 = peg$literalExpectation('[', false), peg$c28 = "'", peg$c29 = peg$literalExpectation("'", false), peg$c30 = '"', peg$c31 = peg$literalExpectation('"', false), peg$c32 = '\uFF62', peg$c33 = peg$literalExpectation('\uFF62', false), peg$c34 = '=', peg$c35 = peg$literalExpectation('=', false), peg$c36 = /^[ \t]/, peg$c37 = peg$classExpectation([' ', '\t'], false, false), peg$c38 = '\n', peg$c39 = peg$literalExpectation('\n', false), peg$c40 = function () {
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$c41 = peg$otherExpectation('identifier'), peg$c42 = /^[a-zA-Z]/, peg$c43 = peg$classExpectation([
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$c44 = /^[a-zA-Z0-9_\-]/, peg$c45 = peg$classExpectation([['a', 'z'], ['A', 'Z'], ['0', '9'], '_', '-'], false, false), peg$c46 = peg$otherExpectation('start-of-line'), peg$c47 = function () {
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$c48 = 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;
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
- if (peg$currPos > peg$maxFailPos) {
340
- peg$maxFailPos = peg$currPos;
341
- peg$maxFailExpected = [];
1102
+ else {
1103
+ s0 = peg$FAILED;
1104
+ if (peg$silentFails === 0) {
1105
+ peg$fail(peg$c38);
1106
+ }
342
1107
  }
343
- peg$maxFailExpected.push(expected);
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$parsestart() {
1110
+ function peg$parseqa_ws() {
352
1111
  var s0, s1;
353
1112
  s0 = [];
354
- s1 = peg$parserule_match();
355
- if (s1 === peg$FAILED) {
356
- if (input.length > peg$currPos) {
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$c0);
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$parserule_match() {
386
- var s0;
387
- s0 = peg$parseattr_nested_angle();
388
- if (s0 === peg$FAILED) {
389
- s0 = peg$parsedelim_begin();
390
- if (s0 === peg$FAILED) {
391
- s0 = peg$parsedelim_end();
392
- if (s0 === peg$FAILED) {
393
- s0 = peg$parseparagraph_directive();
394
- if (s0 === peg$FAILED) {
395
- s0 = peg$parsecontinuation_attr();
396
- if (s0 === peg$FAILED) {
397
- s0 = peg$parsecontinuation_marker();
398
- if (s0 === peg$FAILED) {
399
- s0 = peg$parseblank_line_marker();
400
- if (s0 === peg$FAILED) {
401
- s0 = peg$parseline_marker();
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$parseattr_nested_angle() {
412
- var s0, s1, s2, s3, s4, s5, s6, s7;
1271
+ function peg$parsequoted_value() {
1272
+ var s0, s1, s2, s3, s4, s5, s6;
413
1273
  s0 = peg$currPos;
414
- if (input.charCodeAt(peg$currPos) === 58) {
415
- s1 = peg$c1;
416
- peg$currPos++;
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
- s2 = peg$parseidentifier();
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
- if (input.charCodeAt(peg$currPos) === 60) {
428
- s3 = peg$c3;
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
- s3 = peg$FAILED;
1301
+ s4 = peg$FAILED;
433
1302
  if (peg$silentFails === 0) {
434
- peg$fail(peg$c4);
1303
+ peg$fail(peg$c21);
435
1304
  }
436
1305
  }
437
- if (s3 !== peg$FAILED) {
438
- s4 = peg$currPos;
439
- peg$silentFails++;
440
- if (input.charCodeAt(peg$currPos) === 60) {
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
- s5 = peg$FAILED;
1313
+ s6 = peg$FAILED;
446
1314
  if (peg$silentFails === 0) {
447
- peg$fail(peg$c4);
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
- peg$silentFails--;
451
- if (s5 === peg$FAILED) {
452
- s4 = void 0;
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 = peg$currPos;
460
- s6 = [];
461
- if (peg$c5.test(input.charAt(peg$currPos))) {
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
- s7 = peg$FAILED;
1379
+ s6 = peg$FAILED;
467
1380
  if (peg$silentFails === 0) {
468
- peg$fail(peg$c6);
1381
+ peg$fail(peg$c48);
469
1382
  }
470
1383
  }
471
- while (s7 !== peg$FAILED) {
472
- s6.push(s7);
473
- if (peg$c5.test(input.charAt(peg$currPos))) {
474
- s7 = input.charAt(peg$currPos);
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
- s7 = peg$FAILED;
1391
+ s6 = peg$FAILED;
479
1392
  if (peg$silentFails === 0) {
480
- peg$fail(peg$c6);
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) === 62) {
492
- s6 = peg$c7;
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$c8);
1405
+ peg$fail(peg$c25);
499
1406
  }
500
1407
  }
501
1408
  if (s6 !== peg$FAILED) {
502
- peg$savedPos = s0;
503
- s1 = peg$c9(s2, s5);
504
- s0 = s1;
1409
+ s4 = [s4, s5, s6];
1410
+ s3 = s4;
505
1411
  }
506
1412
  else {
507
- peg$currPos = s0;
508
- s0 = peg$FAILED;
1413
+ peg$currPos = s3;
1414
+ s3 = peg$FAILED;
509
1415
  }
510
1416
  }
511
1417
  else {
512
- peg$currPos = s0;
513
- s0 = peg$FAILED;
1418
+ peg$currPos = s3;
1419
+ s3 = peg$FAILED;
514
1420
  }
515
1421
  }
516
1422
  else {
517
- peg$currPos = s0;
518
- s0 = peg$FAILED;
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$c10) {
543
- s2 = peg$c10;
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$c11);
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$c12(s4);
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$c13) {
588
- s2 = peg$c13;
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$c14);
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$c15(s4);
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$c16) {
633
- s2 = peg$c16;
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$c17);
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$c18();
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$c1;
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$c2);
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$c19;
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$c20);
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$c21(s5);
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$c3;
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$c4);
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$c22;
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$c23);
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$c24;
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$c25);
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$c26;
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$c27);
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$c28;
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$c29);
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$c30;
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$c31);
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$c32;
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$c33);
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$c34;
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$c35);
1819
+ peg$fail(peg$c75);
842
1820
  }
843
1821
  }
844
1822
  if (s2 !== peg$FAILED) {
845
1823
  s3 = [];
846
- if (peg$c36.test(input.charAt(peg$currPos))) {
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$c37);
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$c36.test(input.charAt(peg$currPos))) {
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$c37);
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$c18();
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$c36.test(input.charAt(peg$currPos))) {
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$c37);
1886
+ peg$fail(peg$c77);
909
1887
  }
910
1888
  }
911
1889
  while (s3 !== peg$FAILED) {
912
1890
  s2.push(s3);
913
- if (peg$c36.test(input.charAt(peg$currPos))) {
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$c37);
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$c38;
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$c39);
1910
+ peg$fail(peg$c79);
933
1911
  }
934
1912
  }
935
1913
  if (s3 !== peg$FAILED) {
936
1914
  peg$savedPos = s0;
937
- s1 = peg$c40();
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$c40();
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$c42.test(input.charAt(peg$currPos))) {
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$c43);
1977
+ peg$fail(peg$c83);
1000
1978
  }
1001
1979
  }
1002
1980
  if (s2 !== peg$FAILED) {
1003
1981
  s3 = [];
1004
- if (peg$c44.test(input.charAt(peg$currPos))) {
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$c45);
1989
+ peg$fail(peg$c85);
1012
1990
  }
1013
1991
  }
1014
1992
  while (s4 !== peg$FAILED) {
1015
1993
  s3.push(s4);
1016
- if (peg$c44.test(input.charAt(peg$currPos))) {
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$c45);
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$c41);
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$c47();
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$c46);
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$c36.test(input.charAt(peg$currPos))) {
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$c37);
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$c36.test(input.charAt(peg$currPos))) {
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$c37);
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$c48);
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;