@wireweave/core 3.1.0-beta.6 → 3.1.0-beta.8
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/dist/index.cjs +1082 -806
- package/dist/index.d.cts +132 -3
- package/dist/index.d.ts +132 -3
- package/dist/index.js +1078 -806
- package/dist/parser.cjs +888 -801
- package/dist/parser.d.cts +1 -1
- package/dist/parser.d.ts +1 -1
- package/dist/parser.js +888 -801
- package/dist/renderer.cjs +172 -4
- package/dist/renderer.d.cts +10 -1
- package/dist/renderer.d.ts +10 -1
- package/dist/renderer.js +172 -4
- package/dist/spec.cjs +15 -1
- package/dist/spec.d.cts +2 -1
- package/dist/spec.d.ts +2 -1
- package/dist/spec.js +15 -1
- package/dist/{types-BiDAgo6f.d.cts → types-DfiCKOPE.d.cts} +52 -3
- package/dist/{types-BiDAgo6f.d.ts → types-DfiCKOPE.d.ts} +52 -3
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -4,6 +4,7 @@ var CONTAINER_TYPES = [
|
|
|
4
4
|
"Layout",
|
|
5
5
|
"Component",
|
|
6
6
|
"ComponentUse",
|
|
7
|
+
"Repeat",
|
|
7
8
|
"Header",
|
|
8
9
|
"Main",
|
|
9
10
|
"Footer",
|
|
@@ -355,6 +356,129 @@ function collectParameterReferences(children) {
|
|
|
355
356
|
return found;
|
|
356
357
|
}
|
|
357
358
|
|
|
359
|
+
// src/ast/expand-repeats.ts
|
|
360
|
+
var REPEAT_EXPANSION_BUDGET = 500;
|
|
361
|
+
var RepeatBudgetError = class extends Error {
|
|
362
|
+
constructor(budget) {
|
|
363
|
+
super(
|
|
364
|
+
`repeat expansion exceeds ${budget} nodes \u2014 nesting multiplies, so check the nested counts rather than the outermost one`
|
|
365
|
+
);
|
|
366
|
+
this.name = "RepeatBudgetError";
|
|
367
|
+
}
|
|
368
|
+
};
|
|
369
|
+
function cloneNode2(value) {
|
|
370
|
+
if (Array.isArray(value)) return value.map(cloneNode2);
|
|
371
|
+
if (value === null || typeof value !== "object") return value;
|
|
372
|
+
const source = value;
|
|
373
|
+
const result = {};
|
|
374
|
+
for (const [key, item] of Object.entries(source)) {
|
|
375
|
+
result[key] = key === "loc" ? item : cloneNode2(item);
|
|
376
|
+
}
|
|
377
|
+
return result;
|
|
378
|
+
}
|
|
379
|
+
function containsRepeat(node) {
|
|
380
|
+
if (node.type === "Repeat") return true;
|
|
381
|
+
const children = node.children;
|
|
382
|
+
if (Array.isArray(children)) {
|
|
383
|
+
for (const child of children) if (containsRepeat(child)) return true;
|
|
384
|
+
}
|
|
385
|
+
const fills = node.fills;
|
|
386
|
+
if (Array.isArray(fills)) {
|
|
387
|
+
for (const fill of fills) {
|
|
388
|
+
for (const child of fill.children ?? []) if (containsRepeat(child)) return true;
|
|
389
|
+
}
|
|
390
|
+
}
|
|
391
|
+
return false;
|
|
392
|
+
}
|
|
393
|
+
function expandOne(node, budget) {
|
|
394
|
+
if (node.type === "Repeat") {
|
|
395
|
+
const repeat = node;
|
|
396
|
+
const count = Number.isInteger(repeat.count) && repeat.count > 0 ? repeat.count : 0;
|
|
397
|
+
const result = [];
|
|
398
|
+
for (let i = 0; i < count; i++) {
|
|
399
|
+
for (const child of repeat.children) {
|
|
400
|
+
for (const expanded of expandOne(child, budget)) {
|
|
401
|
+
budget.remaining -= 1;
|
|
402
|
+
if (budget.remaining < 0) throw new RepeatBudgetError(REPEAT_EXPANSION_BUDGET);
|
|
403
|
+
result.push(cloneNode2(expanded));
|
|
404
|
+
}
|
|
405
|
+
}
|
|
406
|
+
}
|
|
407
|
+
return result;
|
|
408
|
+
}
|
|
409
|
+
if (!containsRepeat(node)) return [node];
|
|
410
|
+
const clone = { ...node };
|
|
411
|
+
const children = clone.children;
|
|
412
|
+
if (Array.isArray(children)) {
|
|
413
|
+
clone.children = children.flatMap((child) => expandOne(child, budget));
|
|
414
|
+
}
|
|
415
|
+
const fills = clone.fills;
|
|
416
|
+
if (Array.isArray(fills)) {
|
|
417
|
+
clone.fills = fills.map((fill) => ({
|
|
418
|
+
...fill,
|
|
419
|
+
children: (fill.children ?? []).flatMap((child) => expandOne(child, budget))
|
|
420
|
+
}));
|
|
421
|
+
}
|
|
422
|
+
return [clone];
|
|
423
|
+
}
|
|
424
|
+
function expandRepeats(document) {
|
|
425
|
+
if (!document.children.some((child) => containsRepeat(child))) return document;
|
|
426
|
+
const budget = { remaining: REPEAT_EXPANSION_BUDGET };
|
|
427
|
+
return {
|
|
428
|
+
...document,
|
|
429
|
+
children: document.children.flatMap(
|
|
430
|
+
(child) => expandOne(child, budget)
|
|
431
|
+
)
|
|
432
|
+
};
|
|
433
|
+
}
|
|
434
|
+
|
|
435
|
+
// src/ast/expand-variants.ts
|
|
436
|
+
function cloneNode3(value) {
|
|
437
|
+
if (Array.isArray(value)) return value.map(cloneNode3);
|
|
438
|
+
if (value === null || typeof value !== "object") return value;
|
|
439
|
+
const source = value;
|
|
440
|
+
const result = {};
|
|
441
|
+
for (const [key, item] of Object.entries(source)) {
|
|
442
|
+
result[key] = key === "loc" ? item : cloneNode3(item);
|
|
443
|
+
}
|
|
444
|
+
return result;
|
|
445
|
+
}
|
|
446
|
+
function variantNames(page) {
|
|
447
|
+
const declared = page.variants;
|
|
448
|
+
if (!Array.isArray(declared)) return [];
|
|
449
|
+
const seen = /* @__PURE__ */ new Set();
|
|
450
|
+
const names = [];
|
|
451
|
+
for (const raw of declared) {
|
|
452
|
+
if (typeof raw !== "string") continue;
|
|
453
|
+
const name = raw.trim();
|
|
454
|
+
if (name.length === 0 || seen.has(name)) continue;
|
|
455
|
+
seen.add(name);
|
|
456
|
+
names.push(name);
|
|
457
|
+
}
|
|
458
|
+
return names;
|
|
459
|
+
}
|
|
460
|
+
function hasVariants(document) {
|
|
461
|
+
return document.children.some((child) => child.type === "Page" && variantNames(child).length > 0);
|
|
462
|
+
}
|
|
463
|
+
function expandVariants(document) {
|
|
464
|
+
if (!hasVariants(document)) return document;
|
|
465
|
+
return {
|
|
466
|
+
...document,
|
|
467
|
+
children: document.children.flatMap((child) => {
|
|
468
|
+
if (child.type !== "Page") return [child];
|
|
469
|
+
const names = variantNames(child);
|
|
470
|
+
if (names.length === 0) return [child];
|
|
471
|
+
return names.map((variant, position) => {
|
|
472
|
+
const clone = cloneNode3(child);
|
|
473
|
+
delete clone.variants;
|
|
474
|
+
clone.variant = variant;
|
|
475
|
+
if (position > 0) delete clone.states;
|
|
476
|
+
return clone;
|
|
477
|
+
});
|
|
478
|
+
})
|
|
479
|
+
};
|
|
480
|
+
}
|
|
481
|
+
|
|
358
482
|
// src/parser/generated-parser.js
|
|
359
483
|
var peg$SyntaxError = class extends SyntaxError {
|
|
360
484
|
constructor(message, expected, found, location) {
|
|
@@ -484,75 +608,76 @@ function peg$parse(input, options) {
|
|
|
484
608
|
const peg$c17 = "\r\n";
|
|
485
609
|
const peg$c18 = "//";
|
|
486
610
|
const peg$c19 = "/*";
|
|
487
|
-
const peg$c20 = "
|
|
488
|
-
const peg$c21 = "
|
|
489
|
-
const peg$c22 = "
|
|
490
|
-
const peg$c23 = "
|
|
491
|
-
const peg$c24 = "
|
|
492
|
-
const peg$c25 = "
|
|
493
|
-
const peg$c26 = "
|
|
494
|
-
const peg$c27 = "
|
|
495
|
-
const peg$c28 = "
|
|
496
|
-
const peg$c29 = "
|
|
497
|
-
const peg$c30 = "
|
|
498
|
-
const peg$c31 = "
|
|
499
|
-
const peg$c32 = "
|
|
500
|
-
const peg$c33 = "
|
|
501
|
-
const peg$c34 = "
|
|
502
|
-
const peg$c35 = "
|
|
503
|
-
const peg$c36 = "
|
|
504
|
-
const peg$c37 = "
|
|
505
|
-
const peg$c38 = "
|
|
506
|
-
const peg$c39 = "
|
|
507
|
-
const peg$c40 = "
|
|
508
|
-
const peg$c41 = "
|
|
509
|
-
const peg$c42 = "
|
|
510
|
-
const peg$c43 = "
|
|
511
|
-
const peg$c44 = "
|
|
512
|
-
const peg$c45 = "
|
|
513
|
-
const peg$c46 = "
|
|
514
|
-
const peg$c47 = "
|
|
515
|
-
const peg$c48 = "
|
|
516
|
-
const peg$c49 = "
|
|
517
|
-
const peg$c50 = "
|
|
518
|
-
const peg$c51 = "
|
|
519
|
-
const peg$c52 = "
|
|
520
|
-
const peg$c53 = "
|
|
521
|
-
const peg$c54 = "
|
|
522
|
-
const peg$c55 = "
|
|
523
|
-
const peg$c56 = "
|
|
524
|
-
const peg$c57 = "
|
|
525
|
-
const peg$c58 = "
|
|
526
|
-
const peg$c59 = "
|
|
527
|
-
const peg$c60 = "
|
|
528
|
-
const peg$c61 = "
|
|
529
|
-
const peg$c62 = "
|
|
530
|
-
const peg$c63 = "
|
|
531
|
-
const peg$c64 = "
|
|
532
|
-
const peg$c65 = "
|
|
533
|
-
const peg$c66 = "
|
|
534
|
-
const peg$c67 = "
|
|
535
|
-
const peg$c68 = "
|
|
536
|
-
const peg$c69 = "
|
|
537
|
-
const peg$c70 = "
|
|
538
|
-
const peg$c71 =
|
|
539
|
-
const peg$c72 = "'
|
|
540
|
-
const peg$c73 = "
|
|
541
|
-
const peg$c74 = "
|
|
542
|
-
const peg$c75 = "
|
|
543
|
-
const peg$c76 = "
|
|
544
|
-
const peg$c77 = "
|
|
545
|
-
const peg$c78 = "
|
|
546
|
-
const peg$c79 = "
|
|
547
|
-
const peg$c80 = "
|
|
548
|
-
const peg$c81 = "
|
|
549
|
-
const peg$c82 = "
|
|
550
|
-
const peg$c83 = "
|
|
551
|
-
const peg$c84 = "
|
|
552
|
-
const peg$c85 = "
|
|
553
|
-
const peg$c86 = "
|
|
554
|
-
const peg$c87 = "
|
|
555
|
-
const peg$c88 = "
|
|
611
|
+
const peg$c20 = "repeat";
|
|
612
|
+
const peg$c21 = "header";
|
|
613
|
+
const peg$c22 = "main";
|
|
614
|
+
const peg$c23 = "footer";
|
|
615
|
+
const peg$c24 = "sidebar";
|
|
616
|
+
const peg$c25 = "row";
|
|
617
|
+
const peg$c26 = "col";
|
|
618
|
+
const peg$c27 = "stack";
|
|
619
|
+
const peg$c28 = "relative";
|
|
620
|
+
const peg$c29 = "card";
|
|
621
|
+
const peg$c30 = "modal";
|
|
622
|
+
const peg$c31 = "drawer";
|
|
623
|
+
const peg$c32 = "accordion";
|
|
624
|
+
const peg$c33 = "section";
|
|
625
|
+
const peg$c34 = "text";
|
|
626
|
+
const peg$c35 = "title";
|
|
627
|
+
const peg$c36 = "link";
|
|
628
|
+
const peg$c37 = "button";
|
|
629
|
+
const peg$c38 = "input";
|
|
630
|
+
const peg$c39 = "textarea";
|
|
631
|
+
const peg$c40 = "select";
|
|
632
|
+
const peg$c41 = "checkbox";
|
|
633
|
+
const peg$c42 = "radio";
|
|
634
|
+
const peg$c43 = "switch";
|
|
635
|
+
const peg$c44 = "slider";
|
|
636
|
+
const peg$c45 = "image";
|
|
637
|
+
const peg$c46 = "placeholder";
|
|
638
|
+
const peg$c47 = "avatar";
|
|
639
|
+
const peg$c48 = "badge";
|
|
640
|
+
const peg$c49 = "icon";
|
|
641
|
+
const peg$c50 = "table";
|
|
642
|
+
const peg$c51 = "[";
|
|
643
|
+
const peg$c52 = "]";
|
|
644
|
+
const peg$c53 = "columns";
|
|
645
|
+
const peg$c54 = "list";
|
|
646
|
+
const peg$c55 = "item";
|
|
647
|
+
const peg$c56 = "alert";
|
|
648
|
+
const peg$c57 = "toast";
|
|
649
|
+
const peg$c58 = "progress";
|
|
650
|
+
const peg$c59 = "spinner";
|
|
651
|
+
const peg$c60 = "tooltip";
|
|
652
|
+
const peg$c61 = "popover";
|
|
653
|
+
const peg$c62 = "dropdown";
|
|
654
|
+
const peg$c63 = "divider";
|
|
655
|
+
const peg$c64 = "nav";
|
|
656
|
+
const peg$c65 = "group";
|
|
657
|
+
const peg$c66 = "tabs";
|
|
658
|
+
const peg$c67 = "tab";
|
|
659
|
+
const peg$c68 = "breadcrumb";
|
|
660
|
+
const peg$c69 = "marker";
|
|
661
|
+
const peg$c70 = "annotations";
|
|
662
|
+
const peg$c71 = "at";
|
|
663
|
+
const peg$c72 = '"';
|
|
664
|
+
const peg$c73 = "'";
|
|
665
|
+
const peg$c74 = "\\";
|
|
666
|
+
const peg$c75 = "n";
|
|
667
|
+
const peg$c76 = "r";
|
|
668
|
+
const peg$c77 = "t";
|
|
669
|
+
const peg$c78 = "-";
|
|
670
|
+
const peg$c79 = ".";
|
|
671
|
+
const peg$c80 = "px";
|
|
672
|
+
const peg$c81 = "%";
|
|
673
|
+
const peg$c82 = "em";
|
|
674
|
+
const peg$c83 = "rem";
|
|
675
|
+
const peg$c84 = "vh";
|
|
676
|
+
const peg$c85 = "vw";
|
|
677
|
+
const peg$c86 = "true";
|
|
678
|
+
const peg$c87 = "false";
|
|
679
|
+
const peg$c88 = "\n";
|
|
680
|
+
const peg$c89 = "*/";
|
|
556
681
|
const peg$r0 = /^[ \t]/;
|
|
557
682
|
const peg$r1 = /^[\n\r}]/;
|
|
558
683
|
const peg$r2 = /^[0-9]/;
|
|
@@ -584,88 +709,89 @@ function peg$parse(input, options) {
|
|
|
584
709
|
const peg$e20 = peg$literalExpectation("//", false);
|
|
585
710
|
const peg$e21 = peg$literalExpectation("/*", false);
|
|
586
711
|
const peg$e22 = peg$anyExpectation();
|
|
587
|
-
const peg$e23 = peg$literalExpectation("
|
|
588
|
-
const peg$e24 = peg$literalExpectation("
|
|
589
|
-
const peg$e25 = peg$literalExpectation("
|
|
590
|
-
const peg$e26 = peg$literalExpectation("
|
|
591
|
-
const peg$e27 = peg$literalExpectation("
|
|
592
|
-
const peg$e28 = peg$literalExpectation("
|
|
593
|
-
const peg$e29 = peg$literalExpectation("
|
|
594
|
-
const peg$e30 = peg$literalExpectation("
|
|
595
|
-
const peg$e31 = peg$literalExpectation("
|
|
596
|
-
const peg$e32 = peg$literalExpectation("
|
|
597
|
-
const peg$e33 = peg$literalExpectation("
|
|
598
|
-
const peg$e34 = peg$literalExpectation("
|
|
599
|
-
const peg$e35 = peg$literalExpectation("
|
|
600
|
-
const peg$e36 = peg$literalExpectation("
|
|
601
|
-
const peg$e37 = peg$literalExpectation("
|
|
602
|
-
const peg$e38 = peg$literalExpectation("
|
|
603
|
-
const peg$e39 = peg$literalExpectation("
|
|
604
|
-
const peg$e40 = peg$literalExpectation("
|
|
605
|
-
const peg$e41 = peg$literalExpectation("
|
|
606
|
-
const peg$e42 = peg$literalExpectation("
|
|
607
|
-
const peg$e43 = peg$literalExpectation("
|
|
608
|
-
const peg$e44 = peg$literalExpectation("
|
|
609
|
-
const peg$e45 = peg$literalExpectation("
|
|
610
|
-
const peg$e46 = peg$literalExpectation("
|
|
611
|
-
const peg$e47 = peg$literalExpectation("
|
|
612
|
-
const peg$e48 = peg$literalExpectation("
|
|
613
|
-
const peg$e49 = peg$literalExpectation("
|
|
614
|
-
const peg$e50 = peg$literalExpectation("
|
|
615
|
-
const peg$e51 = peg$literalExpectation("
|
|
616
|
-
const peg$e52 = peg$literalExpectation("
|
|
617
|
-
const peg$e53 = peg$literalExpectation("
|
|
618
|
-
const peg$e54 = peg$literalExpectation("
|
|
619
|
-
const peg$e55 = peg$literalExpectation("
|
|
620
|
-
const peg$e56 = peg$literalExpectation("
|
|
621
|
-
const peg$e57 = peg$literalExpectation("
|
|
622
|
-
const peg$e58 = peg$literalExpectation("
|
|
623
|
-
const peg$e59 = peg$literalExpectation("
|
|
624
|
-
const peg$e60 = peg$literalExpectation("
|
|
625
|
-
const peg$e61 = peg$literalExpectation("
|
|
626
|
-
const peg$e62 = peg$literalExpectation("
|
|
627
|
-
const peg$e63 = peg$literalExpectation("
|
|
628
|
-
const peg$e64 = peg$literalExpectation("
|
|
629
|
-
const peg$e65 = peg$literalExpectation("
|
|
630
|
-
const peg$e66 = peg$literalExpectation("
|
|
631
|
-
const peg$e67 = peg$literalExpectation("
|
|
632
|
-
const peg$e68 = peg$literalExpectation("
|
|
633
|
-
const peg$e69 = peg$literalExpectation("
|
|
634
|
-
const peg$e70 = peg$literalExpectation("
|
|
635
|
-
const peg$e71 = peg$literalExpectation("
|
|
636
|
-
const peg$e72 = peg$literalExpectation("
|
|
637
|
-
const peg$e73 = peg$
|
|
638
|
-
const peg$e74 = peg$
|
|
639
|
-
const peg$e75 = peg$
|
|
640
|
-
const peg$e76 = peg$
|
|
641
|
-
const peg$e77 = peg$classExpectation([
|
|
642
|
-
const peg$e78 = peg$
|
|
643
|
-
const peg$e79 = peg$
|
|
644
|
-
const peg$e80 = peg$literalExpectation("'
|
|
645
|
-
const peg$e81 = peg$literalExpectation("
|
|
646
|
-
const peg$e82 = peg$literalExpectation("
|
|
647
|
-
const peg$e83 = peg$literalExpectation("
|
|
648
|
-
const peg$e84 = peg$literalExpectation("
|
|
649
|
-
const peg$e85 = peg$
|
|
650
|
-
const peg$e86 = peg$
|
|
651
|
-
const peg$e87 = peg$literalExpectation("
|
|
652
|
-
const peg$e88 = peg$
|
|
653
|
-
const peg$e89 = peg$
|
|
654
|
-
const peg$e90 = peg$literalExpectation("
|
|
655
|
-
const peg$e91 = peg$literalExpectation("
|
|
656
|
-
const peg$e92 = peg$literalExpectation("
|
|
657
|
-
const peg$e93 = peg$literalExpectation("
|
|
658
|
-
const peg$e94 = peg$literalExpectation("
|
|
659
|
-
const peg$e95 = peg$
|
|
660
|
-
const peg$e96 = peg$
|
|
661
|
-
const peg$e97 = peg$literalExpectation("
|
|
662
|
-
const peg$e98 = peg$
|
|
663
|
-
const peg$e99 = peg$
|
|
664
|
-
const peg$e100 = peg$classExpectation([" ", "
|
|
665
|
-
const peg$e101 = peg$
|
|
666
|
-
const peg$e102 = peg$
|
|
667
|
-
const peg$e103 = peg$
|
|
668
|
-
const peg$e104 = peg$literalExpectation("
|
|
712
|
+
const peg$e23 = peg$literalExpectation("repeat", false);
|
|
713
|
+
const peg$e24 = peg$literalExpectation("header", false);
|
|
714
|
+
const peg$e25 = peg$literalExpectation("main", false);
|
|
715
|
+
const peg$e26 = peg$literalExpectation("footer", false);
|
|
716
|
+
const peg$e27 = peg$literalExpectation("sidebar", false);
|
|
717
|
+
const peg$e28 = peg$literalExpectation("row", false);
|
|
718
|
+
const peg$e29 = peg$literalExpectation("col", false);
|
|
719
|
+
const peg$e30 = peg$literalExpectation("stack", false);
|
|
720
|
+
const peg$e31 = peg$literalExpectation("relative", false);
|
|
721
|
+
const peg$e32 = peg$literalExpectation("card", false);
|
|
722
|
+
const peg$e33 = peg$literalExpectation("modal", false);
|
|
723
|
+
const peg$e34 = peg$literalExpectation("drawer", false);
|
|
724
|
+
const peg$e35 = peg$literalExpectation("accordion", false);
|
|
725
|
+
const peg$e36 = peg$literalExpectation("section", false);
|
|
726
|
+
const peg$e37 = peg$literalExpectation("text", false);
|
|
727
|
+
const peg$e38 = peg$literalExpectation("title", false);
|
|
728
|
+
const peg$e39 = peg$literalExpectation("link", false);
|
|
729
|
+
const peg$e40 = peg$literalExpectation("button", false);
|
|
730
|
+
const peg$e41 = peg$literalExpectation("input", false);
|
|
731
|
+
const peg$e42 = peg$literalExpectation("textarea", false);
|
|
732
|
+
const peg$e43 = peg$literalExpectation("select", false);
|
|
733
|
+
const peg$e44 = peg$literalExpectation("checkbox", false);
|
|
734
|
+
const peg$e45 = peg$literalExpectation("radio", false);
|
|
735
|
+
const peg$e46 = peg$literalExpectation("switch", false);
|
|
736
|
+
const peg$e47 = peg$literalExpectation("slider", false);
|
|
737
|
+
const peg$e48 = peg$literalExpectation("image", false);
|
|
738
|
+
const peg$e49 = peg$literalExpectation("placeholder", false);
|
|
739
|
+
const peg$e50 = peg$literalExpectation("avatar", false);
|
|
740
|
+
const peg$e51 = peg$literalExpectation("badge", false);
|
|
741
|
+
const peg$e52 = peg$literalExpectation("icon", false);
|
|
742
|
+
const peg$e53 = peg$literalExpectation("table", false);
|
|
743
|
+
const peg$e54 = peg$literalExpectation("[", false);
|
|
744
|
+
const peg$e55 = peg$literalExpectation("]", false);
|
|
745
|
+
const peg$e56 = peg$literalExpectation("columns", false);
|
|
746
|
+
const peg$e57 = peg$literalExpectation("list", false);
|
|
747
|
+
const peg$e58 = peg$literalExpectation("item", false);
|
|
748
|
+
const peg$e59 = peg$literalExpectation("alert", false);
|
|
749
|
+
const peg$e60 = peg$literalExpectation("toast", false);
|
|
750
|
+
const peg$e61 = peg$literalExpectation("progress", false);
|
|
751
|
+
const peg$e62 = peg$literalExpectation("spinner", false);
|
|
752
|
+
const peg$e63 = peg$literalExpectation("tooltip", false);
|
|
753
|
+
const peg$e64 = peg$literalExpectation("popover", false);
|
|
754
|
+
const peg$e65 = peg$literalExpectation("dropdown", false);
|
|
755
|
+
const peg$e66 = peg$literalExpectation("divider", false);
|
|
756
|
+
const peg$e67 = peg$literalExpectation("nav", false);
|
|
757
|
+
const peg$e68 = peg$literalExpectation("group", false);
|
|
758
|
+
const peg$e69 = peg$literalExpectation("tabs", false);
|
|
759
|
+
const peg$e70 = peg$literalExpectation("tab", false);
|
|
760
|
+
const peg$e71 = peg$literalExpectation("breadcrumb", false);
|
|
761
|
+
const peg$e72 = peg$literalExpectation("marker", false);
|
|
762
|
+
const peg$e73 = peg$literalExpectation("annotations", false);
|
|
763
|
+
const peg$e74 = peg$otherExpectation("integer");
|
|
764
|
+
const peg$e75 = peg$classExpectation([["0", "9"]], false, false, false);
|
|
765
|
+
const peg$e76 = peg$literalExpectation("at", false);
|
|
766
|
+
const peg$e77 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
|
|
767
|
+
const peg$e78 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
|
|
768
|
+
const peg$e79 = peg$otherExpectation("string");
|
|
769
|
+
const peg$e80 = peg$literalExpectation('"', false);
|
|
770
|
+
const peg$e81 = peg$literalExpectation("'", false);
|
|
771
|
+
const peg$e82 = peg$literalExpectation("\\", false);
|
|
772
|
+
const peg$e83 = peg$literalExpectation("n", false);
|
|
773
|
+
const peg$e84 = peg$literalExpectation("r", false);
|
|
774
|
+
const peg$e85 = peg$literalExpectation("t", false);
|
|
775
|
+
const peg$e86 = peg$otherExpectation("number");
|
|
776
|
+
const peg$e87 = peg$literalExpectation("-", false);
|
|
777
|
+
const peg$e88 = peg$literalExpectation(".", false);
|
|
778
|
+
const peg$e89 = peg$otherExpectation("value with unit");
|
|
779
|
+
const peg$e90 = peg$literalExpectation("px", false);
|
|
780
|
+
const peg$e91 = peg$literalExpectation("%", false);
|
|
781
|
+
const peg$e92 = peg$literalExpectation("em", false);
|
|
782
|
+
const peg$e93 = peg$literalExpectation("rem", false);
|
|
783
|
+
const peg$e94 = peg$literalExpectation("vh", false);
|
|
784
|
+
const peg$e95 = peg$literalExpectation("vw", false);
|
|
785
|
+
const peg$e96 = peg$otherExpectation("boolean");
|
|
786
|
+
const peg$e97 = peg$literalExpectation("true", false);
|
|
787
|
+
const peg$e98 = peg$literalExpectation("false", false);
|
|
788
|
+
const peg$e99 = peg$otherExpectation("identifier");
|
|
789
|
+
const peg$e100 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
|
|
790
|
+
const peg$e101 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
|
|
791
|
+
const peg$e102 = peg$otherExpectation("comment");
|
|
792
|
+
const peg$e103 = peg$classExpectation(["\n"], true, false, false);
|
|
793
|
+
const peg$e104 = peg$literalExpectation("\n", false);
|
|
794
|
+
const peg$e105 = peg$literalExpectation("*/", false);
|
|
669
795
|
function peg$f0(children) {
|
|
670
796
|
return createNode("Document", {
|
|
671
797
|
children: children.map((c) => c[0]).filter((c) => c !== null)
|
|
@@ -746,114 +872,120 @@ function peg$parse(input, options) {
|
|
|
746
872
|
function peg$f18() {
|
|
747
873
|
return null;
|
|
748
874
|
}
|
|
749
|
-
function peg$f19(
|
|
875
|
+
function peg$f19(count, children) {
|
|
876
|
+
return createNode("Repeat", {
|
|
877
|
+
count,
|
|
878
|
+
children
|
|
879
|
+
});
|
|
880
|
+
}
|
|
881
|
+
function peg$f20(attrs2, children) {
|
|
750
882
|
return createNode("Header", {
|
|
751
883
|
...attrsToObject(attrs2),
|
|
752
884
|
children
|
|
753
885
|
});
|
|
754
886
|
}
|
|
755
|
-
function peg$
|
|
887
|
+
function peg$f21(attrs2, children) {
|
|
756
888
|
return createNode("Main", {
|
|
757
889
|
...attrsToObject(attrs2),
|
|
758
890
|
children
|
|
759
891
|
});
|
|
760
892
|
}
|
|
761
|
-
function peg$
|
|
893
|
+
function peg$f22(attrs2, children) {
|
|
762
894
|
return createNode("Footer", {
|
|
763
895
|
...attrsToObject(attrs2),
|
|
764
896
|
children
|
|
765
897
|
});
|
|
766
898
|
}
|
|
767
|
-
function peg$
|
|
899
|
+
function peg$f23(attrs2, children) {
|
|
768
900
|
return createNode("Sidebar", {
|
|
769
901
|
...attrsToObject(attrs2),
|
|
770
902
|
children
|
|
771
903
|
});
|
|
772
904
|
}
|
|
773
|
-
function peg$
|
|
905
|
+
function peg$f24(attrs2, children) {
|
|
774
906
|
return createNode("Row", {
|
|
775
907
|
...attrsToObject(attrs2),
|
|
776
908
|
children
|
|
777
909
|
});
|
|
778
910
|
}
|
|
779
|
-
function peg$
|
|
911
|
+
function peg$f25(attrs2, children) {
|
|
780
912
|
return createNode("Col", {
|
|
781
913
|
...attrsToObject(attrs2),
|
|
782
914
|
children
|
|
783
915
|
});
|
|
784
916
|
}
|
|
785
|
-
function peg$
|
|
917
|
+
function peg$f26(attrs2, children) {
|
|
786
918
|
return createNode("Stack", {
|
|
787
919
|
...attrsToObject(attrs2),
|
|
788
920
|
children
|
|
789
921
|
});
|
|
790
922
|
}
|
|
791
|
-
function peg$
|
|
923
|
+
function peg$f27(attrs2, children) {
|
|
792
924
|
return createNode("Relative", {
|
|
793
925
|
...attrsToObject(attrs2),
|
|
794
926
|
children
|
|
795
927
|
});
|
|
796
928
|
}
|
|
797
|
-
function peg$
|
|
929
|
+
function peg$f28(label, attrs2, children) {
|
|
798
930
|
return createNode("Card", {
|
|
799
931
|
title: label || null,
|
|
800
932
|
...attrsToObject(attrs2),
|
|
801
933
|
children
|
|
802
934
|
});
|
|
803
935
|
}
|
|
804
|
-
function peg$
|
|
936
|
+
function peg$f29(label, attrs2, children) {
|
|
805
937
|
return createNode("Modal", {
|
|
806
938
|
title: label || null,
|
|
807
939
|
...attrsToObject(attrs2),
|
|
808
940
|
children
|
|
809
941
|
});
|
|
810
942
|
}
|
|
811
|
-
function peg$
|
|
943
|
+
function peg$f30(label, attrs2, children) {
|
|
812
944
|
return createNode("Drawer", {
|
|
813
945
|
title: label || null,
|
|
814
946
|
...attrsToObject(attrs2),
|
|
815
947
|
children
|
|
816
948
|
});
|
|
817
949
|
}
|
|
818
|
-
function peg$
|
|
950
|
+
function peg$f31(label, attrs2, children) {
|
|
819
951
|
return createNode("Accordion", {
|
|
820
952
|
title: label || null,
|
|
821
953
|
...attrsToObject(attrs2),
|
|
822
954
|
children
|
|
823
955
|
});
|
|
824
956
|
}
|
|
825
|
-
function peg$
|
|
957
|
+
function peg$f32(label, attrs2, children) {
|
|
826
958
|
return createNode("Section", {
|
|
827
959
|
title: label || null,
|
|
828
960
|
...attrsToObject(attrs2),
|
|
829
961
|
children
|
|
830
962
|
});
|
|
831
963
|
}
|
|
832
|
-
function peg$
|
|
964
|
+
function peg$f33(label, attrs2) {
|
|
833
965
|
return createNode("Text", {
|
|
834
966
|
content: label,
|
|
835
967
|
...attrsToObject(attrs2)
|
|
836
968
|
});
|
|
837
969
|
}
|
|
838
|
-
function peg$
|
|
970
|
+
function peg$f34(label, attrs2) {
|
|
839
971
|
return createNode("Title", {
|
|
840
972
|
content: label,
|
|
841
973
|
...attrsToObject(attrs2)
|
|
842
974
|
});
|
|
843
975
|
}
|
|
844
|
-
function peg$
|
|
976
|
+
function peg$f35(label, attrs2) {
|
|
845
977
|
return createNode("Link", {
|
|
846
978
|
content: label,
|
|
847
979
|
...attrsToObject(attrs2)
|
|
848
980
|
});
|
|
849
981
|
}
|
|
850
|
-
function peg$
|
|
982
|
+
function peg$f36(label, attrs2) {
|
|
851
983
|
return createNode("Button", {
|
|
852
984
|
content: label,
|
|
853
985
|
...attrsToObject(attrs2)
|
|
854
986
|
});
|
|
855
987
|
}
|
|
856
|
-
function peg$
|
|
988
|
+
function peg$f37(label, attrs2) {
|
|
857
989
|
const obj = attrsToObject(attrs2);
|
|
858
990
|
const inputType = obj.type;
|
|
859
991
|
delete obj.type;
|
|
@@ -863,75 +995,75 @@ function peg$parse(input, options) {
|
|
|
863
995
|
...obj
|
|
864
996
|
});
|
|
865
997
|
}
|
|
866
|
-
function peg$
|
|
998
|
+
function peg$f38(label, attrs2) {
|
|
867
999
|
return createNode("Textarea", {
|
|
868
1000
|
label: label || null,
|
|
869
1001
|
...attrsToObject(attrs2)
|
|
870
1002
|
});
|
|
871
1003
|
}
|
|
872
|
-
function peg$
|
|
1004
|
+
function peg$f39(label, options2, attrs2) {
|
|
873
1005
|
return createNode("Select", {
|
|
874
1006
|
label: label || null,
|
|
875
1007
|
options: options2 || [],
|
|
876
1008
|
...attrsToObject(attrs2)
|
|
877
1009
|
});
|
|
878
1010
|
}
|
|
879
|
-
function peg$
|
|
1011
|
+
function peg$f40(label, attrs2) {
|
|
880
1012
|
return createNode("Checkbox", {
|
|
881
1013
|
label: label || null,
|
|
882
1014
|
...attrsToObject(attrs2)
|
|
883
1015
|
});
|
|
884
1016
|
}
|
|
885
|
-
function peg$
|
|
1017
|
+
function peg$f41(label, attrs2) {
|
|
886
1018
|
return createNode("Radio", {
|
|
887
1019
|
label: label || null,
|
|
888
1020
|
...attrsToObject(attrs2)
|
|
889
1021
|
});
|
|
890
1022
|
}
|
|
891
|
-
function peg$
|
|
1023
|
+
function peg$f42(label, attrs2) {
|
|
892
1024
|
return createNode("Switch", {
|
|
893
1025
|
label: label || null,
|
|
894
1026
|
...attrsToObject(attrs2)
|
|
895
1027
|
});
|
|
896
1028
|
}
|
|
897
|
-
function peg$
|
|
1029
|
+
function peg$f43(label, attrs2) {
|
|
898
1030
|
return createNode("Slider", {
|
|
899
1031
|
label: label || null,
|
|
900
1032
|
...attrsToObject(attrs2)
|
|
901
1033
|
});
|
|
902
1034
|
}
|
|
903
|
-
function peg$
|
|
1035
|
+
function peg$f44(src, attrs2) {
|
|
904
1036
|
return createNode("Image", {
|
|
905
1037
|
src: src || null,
|
|
906
1038
|
...attrsToObject(attrs2)
|
|
907
1039
|
});
|
|
908
1040
|
}
|
|
909
|
-
function peg$
|
|
1041
|
+
function peg$f45(label, attrs2, block) {
|
|
910
1042
|
return createNode("Placeholder", {
|
|
911
1043
|
label: label || null,
|
|
912
1044
|
...attrsToObject(attrs2),
|
|
913
1045
|
children: block ? block[2] : []
|
|
914
1046
|
});
|
|
915
1047
|
}
|
|
916
|
-
function peg$
|
|
1048
|
+
function peg$f46(label, attrs2) {
|
|
917
1049
|
return createNode("Avatar", {
|
|
918
1050
|
name: label || null,
|
|
919
1051
|
...attrsToObject(attrs2)
|
|
920
1052
|
});
|
|
921
1053
|
}
|
|
922
|
-
function peg$
|
|
1054
|
+
function peg$f47(label, attrs2) {
|
|
923
1055
|
return createNode("Badge", {
|
|
924
1056
|
content: label,
|
|
925
1057
|
...attrsToObject(attrs2)
|
|
926
1058
|
});
|
|
927
1059
|
}
|
|
928
|
-
function peg$
|
|
1060
|
+
function peg$f48(name, attrs2) {
|
|
929
1061
|
return createNode("Icon", {
|
|
930
1062
|
name,
|
|
931
1063
|
...attrsToObject(attrs2)
|
|
932
1064
|
});
|
|
933
1065
|
}
|
|
934
|
-
function peg$
|
|
1066
|
+
function peg$f49(data, attrs2) {
|
|
935
1067
|
const columns = data.length > 0 ? data[0] : [];
|
|
936
1068
|
const rows = data.slice(1);
|
|
937
1069
|
return createNode("Table", {
|
|
@@ -940,16 +1072,16 @@ function peg$parse(input, options) {
|
|
|
940
1072
|
...attrsToObject(attrs2)
|
|
941
1073
|
});
|
|
942
1074
|
}
|
|
943
|
-
function peg$
|
|
1075
|
+
function peg$f50(attrs2, rows) {
|
|
944
1076
|
return createNode("Table", {
|
|
945
1077
|
...attrsToObject(attrs2),
|
|
946
1078
|
...rows
|
|
947
1079
|
});
|
|
948
1080
|
}
|
|
949
|
-
function peg$
|
|
1081
|
+
function peg$f51(first, rest) {
|
|
950
1082
|
return [first, ...rest.map((r) => r[2])];
|
|
951
1083
|
}
|
|
952
|
-
function peg$
|
|
1084
|
+
function peg$f52(items) {
|
|
953
1085
|
const columns = [];
|
|
954
1086
|
const rows = [];
|
|
955
1087
|
for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
|
|
@@ -958,72 +1090,72 @@ function peg$parse(input, options) {
|
|
|
958
1090
|
}
|
|
959
1091
|
return { columns, rows };
|
|
960
1092
|
}
|
|
961
|
-
function peg$
|
|
1093
|
+
function peg$f53(values) {
|
|
962
1094
|
return { kind: "columns", values };
|
|
963
1095
|
}
|
|
964
|
-
function peg$
|
|
1096
|
+
function peg$f54(values) {
|
|
965
1097
|
return { kind: "row", values };
|
|
966
1098
|
}
|
|
967
|
-
function peg$
|
|
1099
|
+
function peg$f55() {
|
|
968
1100
|
return null;
|
|
969
1101
|
}
|
|
970
|
-
function peg$
|
|
1102
|
+
function peg$f56(items, attrs2, block) {
|
|
971
1103
|
return createNode("List", {
|
|
972
1104
|
items: items || (block ? block : []),
|
|
973
1105
|
...attrsToObject(attrs2)
|
|
974
1106
|
});
|
|
975
1107
|
}
|
|
976
|
-
function peg$
|
|
1108
|
+
function peg$f57(items) {
|
|
977
1109
|
return items.map((i) => i[0]).filter((i) => i !== null);
|
|
978
1110
|
}
|
|
979
|
-
function peg$
|
|
1111
|
+
function peg$f58(label, attrs2, nested) {
|
|
980
1112
|
return createBlockNode("ListItem", {
|
|
981
1113
|
content: label,
|
|
982
1114
|
...attrsToObject(attrs2),
|
|
983
1115
|
children: nested || []
|
|
984
1116
|
});
|
|
985
1117
|
}
|
|
986
|
-
function peg$
|
|
1118
|
+
function peg$f59() {
|
|
987
1119
|
return null;
|
|
988
1120
|
}
|
|
989
|
-
function peg$
|
|
1121
|
+
function peg$f60(label, attrs2) {
|
|
990
1122
|
return createNode("Alert", {
|
|
991
1123
|
content: label,
|
|
992
1124
|
...attrsToObject(attrs2)
|
|
993
1125
|
});
|
|
994
1126
|
}
|
|
995
|
-
function peg$
|
|
1127
|
+
function peg$f61(label, attrs2) {
|
|
996
1128
|
return createNode("Toast", {
|
|
997
1129
|
content: label,
|
|
998
1130
|
...attrsToObject(attrs2)
|
|
999
1131
|
});
|
|
1000
1132
|
}
|
|
1001
|
-
function peg$
|
|
1133
|
+
function peg$f62(attrs2) {
|
|
1002
1134
|
return createNode("Progress", {
|
|
1003
1135
|
...attrsToObject(attrs2)
|
|
1004
1136
|
});
|
|
1005
1137
|
}
|
|
1006
|
-
function peg$
|
|
1138
|
+
function peg$f63(label, attrs2) {
|
|
1007
1139
|
return createNode("Spinner", {
|
|
1008
1140
|
label: label || null,
|
|
1009
1141
|
...attrsToObject(attrs2)
|
|
1010
1142
|
});
|
|
1011
1143
|
}
|
|
1012
|
-
function peg$
|
|
1144
|
+
function peg$f64(label, attrs2) {
|
|
1013
1145
|
return createNode("Tooltip", {
|
|
1014
1146
|
content: label,
|
|
1015
1147
|
...attrsToObject(attrs2),
|
|
1016
1148
|
children: []
|
|
1017
1149
|
});
|
|
1018
1150
|
}
|
|
1019
|
-
function peg$
|
|
1151
|
+
function peg$f65(label, attrs2, children) {
|
|
1020
1152
|
return createNode("Popover", {
|
|
1021
1153
|
title: label || null,
|
|
1022
1154
|
...attrsToObject(attrs2),
|
|
1023
1155
|
children
|
|
1024
1156
|
});
|
|
1025
1157
|
}
|
|
1026
|
-
function peg$
|
|
1158
|
+
function peg$f66(items, attrs2) {
|
|
1027
1159
|
const processedItems = items.map((item) => {
|
|
1028
1160
|
if (typeof item === "string") {
|
|
1029
1161
|
if (item === "---" || item === "-" || item === "divider") {
|
|
@@ -1038,106 +1170,106 @@ function peg$parse(input, options) {
|
|
|
1038
1170
|
items: processedItems
|
|
1039
1171
|
});
|
|
1040
1172
|
}
|
|
1041
|
-
function peg$
|
|
1173
|
+
function peg$f67(attrs2, items) {
|
|
1042
1174
|
return createNode("Dropdown", {
|
|
1043
1175
|
...attrsToObject(attrs2),
|
|
1044
1176
|
items
|
|
1045
1177
|
});
|
|
1046
1178
|
}
|
|
1047
|
-
function peg$
|
|
1179
|
+
function peg$f68(items) {
|
|
1048
1180
|
return items.map((i) => i[0]).filter((i) => i !== null);
|
|
1049
1181
|
}
|
|
1050
|
-
function peg$
|
|
1182
|
+
function peg$f69(label, attrs2) {
|
|
1051
1183
|
return createBlockNode("DropdownItem", { label, ...attrsToObject(attrs2) });
|
|
1052
1184
|
}
|
|
1053
|
-
function peg$
|
|
1185
|
+
function peg$f70() {
|
|
1054
1186
|
return createBlockNode("Divider", {});
|
|
1055
1187
|
}
|
|
1056
|
-
function peg$
|
|
1188
|
+
function peg$f71() {
|
|
1057
1189
|
return null;
|
|
1058
1190
|
}
|
|
1059
|
-
function peg$
|
|
1191
|
+
function peg$f72(items, attrs2, block) {
|
|
1060
1192
|
return createNode("Nav", {
|
|
1061
1193
|
items: items || [],
|
|
1062
1194
|
...attrsToObject(attrs2),
|
|
1063
1195
|
children: block || []
|
|
1064
1196
|
});
|
|
1065
1197
|
}
|
|
1066
|
-
function peg$
|
|
1198
|
+
function peg$f73(content) {
|
|
1067
1199
|
return content.map((c) => c[0]).filter((c) => c !== null);
|
|
1068
1200
|
}
|
|
1069
|
-
function peg$
|
|
1201
|
+
function peg$f74() {
|
|
1070
1202
|
return createBlockNode("Divider", {});
|
|
1071
1203
|
}
|
|
1072
|
-
function peg$
|
|
1204
|
+
function peg$f75() {
|
|
1073
1205
|
return null;
|
|
1074
1206
|
}
|
|
1075
|
-
function peg$
|
|
1207
|
+
function peg$f76(label, attrs2, items) {
|
|
1076
1208
|
return createBlockNode("NavGroup", {
|
|
1077
1209
|
label,
|
|
1078
1210
|
...attrsToObject(attrs2),
|
|
1079
1211
|
items: items.map((i) => i[0]).filter((i) => i !== null)
|
|
1080
1212
|
});
|
|
1081
1213
|
}
|
|
1082
|
-
function peg$
|
|
1214
|
+
function peg$f77() {
|
|
1083
1215
|
return createBlockNode("Divider", {});
|
|
1084
1216
|
}
|
|
1085
|
-
function peg$
|
|
1217
|
+
function peg$f78() {
|
|
1086
1218
|
return null;
|
|
1087
1219
|
}
|
|
1088
|
-
function peg$
|
|
1220
|
+
function peg$f79(label, attrs2) {
|
|
1089
1221
|
return createBlockNode("NavItem", {
|
|
1090
1222
|
label,
|
|
1091
1223
|
...attrsToObject(attrs2)
|
|
1092
1224
|
});
|
|
1093
1225
|
}
|
|
1094
|
-
function peg$
|
|
1226
|
+
function peg$f80(items, attrs2, block) {
|
|
1095
1227
|
return createNode("Tabs", {
|
|
1096
1228
|
items: items || [],
|
|
1097
1229
|
...attrsToObject(attrs2),
|
|
1098
1230
|
children: block || []
|
|
1099
1231
|
});
|
|
1100
1232
|
}
|
|
1101
|
-
function peg$
|
|
1233
|
+
function peg$f81(tabs) {
|
|
1102
1234
|
return tabs.map((t) => t[0]).filter((t) => t !== null);
|
|
1103
1235
|
}
|
|
1104
|
-
function peg$
|
|
1236
|
+
function peg$f82(label, attrs2, children) {
|
|
1105
1237
|
return {
|
|
1106
1238
|
label,
|
|
1107
1239
|
...attrsToObject(attrs2),
|
|
1108
1240
|
children
|
|
1109
1241
|
};
|
|
1110
1242
|
}
|
|
1111
|
-
function peg$
|
|
1243
|
+
function peg$f83() {
|
|
1112
1244
|
return null;
|
|
1113
1245
|
}
|
|
1114
|
-
function peg$
|
|
1246
|
+
function peg$f84(items, attrs2) {
|
|
1115
1247
|
return createNode("Breadcrumb", {
|
|
1116
1248
|
items,
|
|
1117
1249
|
...attrsToObject(attrs2)
|
|
1118
1250
|
});
|
|
1119
1251
|
}
|
|
1120
|
-
function peg$
|
|
1252
|
+
function peg$f85(attrs2) {
|
|
1121
1253
|
return createNode("Divider", {
|
|
1122
1254
|
...attrsToObject(attrs2)
|
|
1123
1255
|
});
|
|
1124
1256
|
}
|
|
1125
|
-
function peg$
|
|
1257
|
+
function peg$f86(num, attrs2) {
|
|
1126
1258
|
return createNode("Marker", {
|
|
1127
1259
|
number: num,
|
|
1128
1260
|
...attrsToObject(attrs2)
|
|
1129
1261
|
});
|
|
1130
1262
|
}
|
|
1131
|
-
function peg$
|
|
1263
|
+
function peg$f87(attrs2, items) {
|
|
1132
1264
|
return createNode("Annotations", {
|
|
1133
1265
|
...attrsToObject(attrs2),
|
|
1134
1266
|
children: items
|
|
1135
1267
|
});
|
|
1136
1268
|
}
|
|
1137
|
-
function peg$
|
|
1269
|
+
function peg$f88(items) {
|
|
1138
1270
|
return items.map((i) => i[0]).filter((i) => i !== null);
|
|
1139
1271
|
}
|
|
1140
|
-
function peg$
|
|
1272
|
+
function peg$f89(num, title, attrs2, children) {
|
|
1141
1273
|
return createNode("AnnotationItem", {
|
|
1142
1274
|
number: num,
|
|
1143
1275
|
title,
|
|
@@ -1145,7 +1277,7 @@ function peg$parse(input, options) {
|
|
|
1145
1277
|
children
|
|
1146
1278
|
});
|
|
1147
1279
|
}
|
|
1148
|
-
function peg$
|
|
1280
|
+
function peg$f90(num, title, attrs2) {
|
|
1149
1281
|
return createNode("AnnotationItem", {
|
|
1150
1282
|
number: num,
|
|
1151
1283
|
title,
|
|
@@ -1153,90 +1285,90 @@ function peg$parse(input, options) {
|
|
|
1153
1285
|
children: []
|
|
1154
1286
|
});
|
|
1155
1287
|
}
|
|
1156
|
-
function peg$
|
|
1288
|
+
function peg$f91() {
|
|
1157
1289
|
return null;
|
|
1158
1290
|
}
|
|
1159
|
-
function peg$
|
|
1291
|
+
function peg$f92(digits) {
|
|
1160
1292
|
return parseInt(digits.join(""), 10);
|
|
1161
1293
|
}
|
|
1162
|
-
function peg$
|
|
1294
|
+
function peg$f93(attrs2) {
|
|
1163
1295
|
return attrs2;
|
|
1164
1296
|
}
|
|
1165
|
-
function peg$
|
|
1297
|
+
function peg$f94(x, y) {
|
|
1166
1298
|
return [
|
|
1167
1299
|
{ name: "x", value: x },
|
|
1168
1300
|
{ name: "y", value: y }
|
|
1169
1301
|
];
|
|
1170
1302
|
}
|
|
1171
|
-
function peg$
|
|
1303
|
+
function peg$f95(name, value) {
|
|
1172
1304
|
return { name, value };
|
|
1173
1305
|
}
|
|
1174
|
-
function peg$
|
|
1306
|
+
function peg$f96(flag) {
|
|
1175
1307
|
return { name: flag, value: true };
|
|
1176
1308
|
}
|
|
1177
|
-
function peg$
|
|
1309
|
+
function peg$f97(name) {
|
|
1178
1310
|
return name;
|
|
1179
1311
|
}
|
|
1180
|
-
function peg$
|
|
1312
|
+
function peg$f98(chars) {
|
|
1181
1313
|
return chars.join("");
|
|
1182
1314
|
}
|
|
1183
|
-
function peg$
|
|
1315
|
+
function peg$f99(chars) {
|
|
1184
1316
|
return chars.join("");
|
|
1185
1317
|
}
|
|
1186
|
-
function peg$
|
|
1318
|
+
function peg$f100(char) {
|
|
1187
1319
|
return char;
|
|
1188
1320
|
}
|
|
1189
|
-
function peg$
|
|
1321
|
+
function peg$f101(seq) {
|
|
1190
1322
|
return seq;
|
|
1191
1323
|
}
|
|
1192
|
-
function peg$
|
|
1324
|
+
function peg$f102(char) {
|
|
1193
1325
|
return char;
|
|
1194
1326
|
}
|
|
1195
|
-
function peg$
|
|
1327
|
+
function peg$f103(seq) {
|
|
1196
1328
|
return seq;
|
|
1197
1329
|
}
|
|
1198
|
-
function peg$
|
|
1330
|
+
function peg$f104() {
|
|
1199
1331
|
return "\n";
|
|
1200
1332
|
}
|
|
1201
|
-
function peg$
|
|
1333
|
+
function peg$f105() {
|
|
1202
1334
|
return "\r";
|
|
1203
1335
|
}
|
|
1204
|
-
function peg$
|
|
1336
|
+
function peg$f106() {
|
|
1205
1337
|
return " ";
|
|
1206
1338
|
}
|
|
1207
|
-
function peg$
|
|
1339
|
+
function peg$f107() {
|
|
1208
1340
|
return "\\";
|
|
1209
1341
|
}
|
|
1210
|
-
function peg$
|
|
1342
|
+
function peg$f108() {
|
|
1211
1343
|
return '"';
|
|
1212
1344
|
}
|
|
1213
|
-
function peg$
|
|
1345
|
+
function peg$f109() {
|
|
1214
1346
|
return "'";
|
|
1215
1347
|
}
|
|
1216
|
-
function peg$
|
|
1348
|
+
function peg$f110(sign, digits, decimal) {
|
|
1217
1349
|
const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
|
|
1218
1350
|
return parseFloat(num);
|
|
1219
1351
|
}
|
|
1220
|
-
function peg$
|
|
1352
|
+
function peg$f111(sign, digits, decimal, unit) {
|
|
1221
1353
|
const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
|
|
1222
1354
|
return { value: parseFloat(num), unit };
|
|
1223
1355
|
}
|
|
1224
|
-
function peg$
|
|
1356
|
+
function peg$f112() {
|
|
1225
1357
|
return true;
|
|
1226
1358
|
}
|
|
1227
|
-
function peg$
|
|
1359
|
+
function peg$f113() {
|
|
1228
1360
|
return false;
|
|
1229
1361
|
}
|
|
1230
|
-
function peg$
|
|
1362
|
+
function peg$f114(head, tail) {
|
|
1231
1363
|
return head + tail.join("");
|
|
1232
1364
|
}
|
|
1233
|
-
function peg$
|
|
1365
|
+
function peg$f115(items) {
|
|
1234
1366
|
return items || [];
|
|
1235
1367
|
}
|
|
1236
|
-
function peg$
|
|
1368
|
+
function peg$f116(head, tail) {
|
|
1237
1369
|
return [head, ...tail.map((t) => t[3])];
|
|
1238
1370
|
}
|
|
1239
|
-
function peg$
|
|
1371
|
+
function peg$f117(props) {
|
|
1240
1372
|
const result = {};
|
|
1241
1373
|
if (props) {
|
|
1242
1374
|
for (const p of props) {
|
|
@@ -1245,13 +1377,13 @@ function peg$parse(input, options) {
|
|
|
1245
1377
|
}
|
|
1246
1378
|
return result;
|
|
1247
1379
|
}
|
|
1248
|
-
function peg$
|
|
1380
|
+
function peg$f118(head, tail) {
|
|
1249
1381
|
return [head, ...tail.map((t) => t[3])];
|
|
1250
1382
|
}
|
|
1251
|
-
function peg$
|
|
1383
|
+
function peg$f119(name, value) {
|
|
1252
1384
|
return { name, value };
|
|
1253
1385
|
}
|
|
1254
|
-
function peg$
|
|
1386
|
+
function peg$f120(name) {
|
|
1255
1387
|
return { name, value: true };
|
|
1256
1388
|
}
|
|
1257
1389
|
let peg$currPos = options.peg$currPos | 0;
|
|
@@ -2503,21 +2635,24 @@ function peg$parse(input, options) {
|
|
|
2503
2635
|
let s0, s1;
|
|
2504
2636
|
s0 = peg$parseComponentUse();
|
|
2505
2637
|
if (s0 === peg$FAILED) {
|
|
2506
|
-
s0 = peg$
|
|
2638
|
+
s0 = peg$parseRepeat();
|
|
2507
2639
|
if (s0 === peg$FAILED) {
|
|
2508
|
-
s0 = peg$
|
|
2640
|
+
s0 = peg$parseLayoutElement();
|
|
2509
2641
|
if (s0 === peg$FAILED) {
|
|
2510
|
-
s0 = peg$
|
|
2642
|
+
s0 = peg$parseContainerElement();
|
|
2511
2643
|
if (s0 === peg$FAILED) {
|
|
2512
|
-
s0 = peg$
|
|
2644
|
+
s0 = peg$parseUIElement();
|
|
2513
2645
|
if (s0 === peg$FAILED) {
|
|
2514
|
-
s0 = peg$
|
|
2515
|
-
|
|
2516
|
-
|
|
2517
|
-
|
|
2518
|
-
s1
|
|
2646
|
+
s0 = peg$parseSlot();
|
|
2647
|
+
if (s0 === peg$FAILED) {
|
|
2648
|
+
s0 = peg$currPos;
|
|
2649
|
+
s1 = peg$parseComment();
|
|
2650
|
+
if (s1 !== peg$FAILED) {
|
|
2651
|
+
peg$savedPos = s0;
|
|
2652
|
+
s1 = peg$f18();
|
|
2653
|
+
}
|
|
2654
|
+
s0 = s1;
|
|
2519
2655
|
}
|
|
2520
|
-
s0 = s1;
|
|
2521
2656
|
}
|
|
2522
2657
|
}
|
|
2523
2658
|
}
|
|
@@ -2525,6 +2660,71 @@ function peg$parse(input, options) {
|
|
|
2525
2660
|
}
|
|
2526
2661
|
return s0;
|
|
2527
2662
|
}
|
|
2663
|
+
function peg$parseRepeat() {
|
|
2664
|
+
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2665
|
+
s0 = peg$currPos;
|
|
2666
|
+
if (input.substr(peg$currPos, 6) === peg$c20) {
|
|
2667
|
+
s1 = peg$c20;
|
|
2668
|
+
peg$currPos += 6;
|
|
2669
|
+
} else {
|
|
2670
|
+
s1 = peg$FAILED;
|
|
2671
|
+
if (peg$silentFails === 0) {
|
|
2672
|
+
peg$fail(peg$e23);
|
|
2673
|
+
}
|
|
2674
|
+
}
|
|
2675
|
+
if (s1 !== peg$FAILED) {
|
|
2676
|
+
s2 = peg$parse_();
|
|
2677
|
+
s3 = peg$parseInteger();
|
|
2678
|
+
if (s3 !== peg$FAILED) {
|
|
2679
|
+
s4 = peg$parse_();
|
|
2680
|
+
if (input.charCodeAt(peg$currPos) === 123) {
|
|
2681
|
+
s5 = peg$c1;
|
|
2682
|
+
peg$currPos++;
|
|
2683
|
+
} else {
|
|
2684
|
+
s5 = peg$FAILED;
|
|
2685
|
+
if (peg$silentFails === 0) {
|
|
2686
|
+
peg$fail(peg$e1);
|
|
2687
|
+
}
|
|
2688
|
+
}
|
|
2689
|
+
if (s5 !== peg$FAILED) {
|
|
2690
|
+
s6 = peg$parse_();
|
|
2691
|
+
s7 = peg$parseChildren();
|
|
2692
|
+
if (s7 !== peg$FAILED) {
|
|
2693
|
+
s8 = peg$parse_();
|
|
2694
|
+
if (input.charCodeAt(peg$currPos) === 125) {
|
|
2695
|
+
s9 = peg$c2;
|
|
2696
|
+
peg$currPos++;
|
|
2697
|
+
} else {
|
|
2698
|
+
s9 = peg$FAILED;
|
|
2699
|
+
if (peg$silentFails === 0) {
|
|
2700
|
+
peg$fail(peg$e2);
|
|
2701
|
+
}
|
|
2702
|
+
}
|
|
2703
|
+
if (s9 !== peg$FAILED) {
|
|
2704
|
+
peg$savedPos = s0;
|
|
2705
|
+
s0 = peg$f19(s3, s7);
|
|
2706
|
+
} else {
|
|
2707
|
+
peg$currPos = s0;
|
|
2708
|
+
s0 = peg$FAILED;
|
|
2709
|
+
}
|
|
2710
|
+
} else {
|
|
2711
|
+
peg$currPos = s0;
|
|
2712
|
+
s0 = peg$FAILED;
|
|
2713
|
+
}
|
|
2714
|
+
} else {
|
|
2715
|
+
peg$currPos = s0;
|
|
2716
|
+
s0 = peg$FAILED;
|
|
2717
|
+
}
|
|
2718
|
+
} else {
|
|
2719
|
+
peg$currPos = s0;
|
|
2720
|
+
s0 = peg$FAILED;
|
|
2721
|
+
}
|
|
2722
|
+
} else {
|
|
2723
|
+
peg$currPos = s0;
|
|
2724
|
+
s0 = peg$FAILED;
|
|
2725
|
+
}
|
|
2726
|
+
return s0;
|
|
2727
|
+
}
|
|
2528
2728
|
function peg$parseLayoutElement() {
|
|
2529
2729
|
let s0;
|
|
2530
2730
|
s0 = peg$parseHeader();
|
|
@@ -2554,13 +2754,13 @@ function peg$parse(input, options) {
|
|
|
2554
2754
|
function peg$parseHeader() {
|
|
2555
2755
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2556
2756
|
s0 = peg$currPos;
|
|
2557
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
2558
|
-
s1 = peg$
|
|
2757
|
+
if (input.substr(peg$currPos, 6) === peg$c21) {
|
|
2758
|
+
s1 = peg$c21;
|
|
2559
2759
|
peg$currPos += 6;
|
|
2560
2760
|
} else {
|
|
2561
2761
|
s1 = peg$FAILED;
|
|
2562
2762
|
if (peg$silentFails === 0) {
|
|
2563
|
-
peg$fail(peg$
|
|
2763
|
+
peg$fail(peg$e24);
|
|
2564
2764
|
}
|
|
2565
2765
|
}
|
|
2566
2766
|
if (s1 !== peg$FAILED) {
|
|
@@ -2595,7 +2795,7 @@ function peg$parse(input, options) {
|
|
|
2595
2795
|
}
|
|
2596
2796
|
if (s9 !== peg$FAILED) {
|
|
2597
2797
|
peg$savedPos = s0;
|
|
2598
|
-
s0 = peg$
|
|
2798
|
+
s0 = peg$f20(s3, s7);
|
|
2599
2799
|
} else {
|
|
2600
2800
|
peg$currPos = s0;
|
|
2601
2801
|
s0 = peg$FAILED;
|
|
@@ -2617,13 +2817,13 @@ function peg$parse(input, options) {
|
|
|
2617
2817
|
function peg$parseMain() {
|
|
2618
2818
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2619
2819
|
s0 = peg$currPos;
|
|
2620
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
2621
|
-
s1 = peg$
|
|
2820
|
+
if (input.substr(peg$currPos, 4) === peg$c22) {
|
|
2821
|
+
s1 = peg$c22;
|
|
2622
2822
|
peg$currPos += 4;
|
|
2623
2823
|
} else {
|
|
2624
2824
|
s1 = peg$FAILED;
|
|
2625
2825
|
if (peg$silentFails === 0) {
|
|
2626
|
-
peg$fail(peg$
|
|
2826
|
+
peg$fail(peg$e25);
|
|
2627
2827
|
}
|
|
2628
2828
|
}
|
|
2629
2829
|
if (s1 !== peg$FAILED) {
|
|
@@ -2658,7 +2858,7 @@ function peg$parse(input, options) {
|
|
|
2658
2858
|
}
|
|
2659
2859
|
if (s9 !== peg$FAILED) {
|
|
2660
2860
|
peg$savedPos = s0;
|
|
2661
|
-
s0 = peg$
|
|
2861
|
+
s0 = peg$f21(s3, s7);
|
|
2662
2862
|
} else {
|
|
2663
2863
|
peg$currPos = s0;
|
|
2664
2864
|
s0 = peg$FAILED;
|
|
@@ -2680,13 +2880,13 @@ function peg$parse(input, options) {
|
|
|
2680
2880
|
function peg$parseFooter() {
|
|
2681
2881
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2682
2882
|
s0 = peg$currPos;
|
|
2683
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
2684
|
-
s1 = peg$
|
|
2883
|
+
if (input.substr(peg$currPos, 6) === peg$c23) {
|
|
2884
|
+
s1 = peg$c23;
|
|
2685
2885
|
peg$currPos += 6;
|
|
2686
2886
|
} else {
|
|
2687
2887
|
s1 = peg$FAILED;
|
|
2688
2888
|
if (peg$silentFails === 0) {
|
|
2689
|
-
peg$fail(peg$
|
|
2889
|
+
peg$fail(peg$e26);
|
|
2690
2890
|
}
|
|
2691
2891
|
}
|
|
2692
2892
|
if (s1 !== peg$FAILED) {
|
|
@@ -2721,7 +2921,7 @@ function peg$parse(input, options) {
|
|
|
2721
2921
|
}
|
|
2722
2922
|
if (s9 !== peg$FAILED) {
|
|
2723
2923
|
peg$savedPos = s0;
|
|
2724
|
-
s0 = peg$
|
|
2924
|
+
s0 = peg$f22(s3, s7);
|
|
2725
2925
|
} else {
|
|
2726
2926
|
peg$currPos = s0;
|
|
2727
2927
|
s0 = peg$FAILED;
|
|
@@ -2743,13 +2943,13 @@ function peg$parse(input, options) {
|
|
|
2743
2943
|
function peg$parseSidebar() {
|
|
2744
2944
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2745
2945
|
s0 = peg$currPos;
|
|
2746
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
2747
|
-
s1 = peg$
|
|
2946
|
+
if (input.substr(peg$currPos, 7) === peg$c24) {
|
|
2947
|
+
s1 = peg$c24;
|
|
2748
2948
|
peg$currPos += 7;
|
|
2749
2949
|
} else {
|
|
2750
2950
|
s1 = peg$FAILED;
|
|
2751
2951
|
if (peg$silentFails === 0) {
|
|
2752
|
-
peg$fail(peg$
|
|
2952
|
+
peg$fail(peg$e27);
|
|
2753
2953
|
}
|
|
2754
2954
|
}
|
|
2755
2955
|
if (s1 !== peg$FAILED) {
|
|
@@ -2784,7 +2984,7 @@ function peg$parse(input, options) {
|
|
|
2784
2984
|
}
|
|
2785
2985
|
if (s9 !== peg$FAILED) {
|
|
2786
2986
|
peg$savedPos = s0;
|
|
2787
|
-
s0 = peg$
|
|
2987
|
+
s0 = peg$f23(s3, s7);
|
|
2788
2988
|
} else {
|
|
2789
2989
|
peg$currPos = s0;
|
|
2790
2990
|
s0 = peg$FAILED;
|
|
@@ -2806,13 +3006,13 @@ function peg$parse(input, options) {
|
|
|
2806
3006
|
function peg$parseRow() {
|
|
2807
3007
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2808
3008
|
s0 = peg$currPos;
|
|
2809
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
2810
|
-
s1 = peg$
|
|
3009
|
+
if (input.substr(peg$currPos, 3) === peg$c25) {
|
|
3010
|
+
s1 = peg$c25;
|
|
2811
3011
|
peg$currPos += 3;
|
|
2812
3012
|
} else {
|
|
2813
3013
|
s1 = peg$FAILED;
|
|
2814
3014
|
if (peg$silentFails === 0) {
|
|
2815
|
-
peg$fail(peg$
|
|
3015
|
+
peg$fail(peg$e28);
|
|
2816
3016
|
}
|
|
2817
3017
|
}
|
|
2818
3018
|
if (s1 !== peg$FAILED) {
|
|
@@ -2847,7 +3047,7 @@ function peg$parse(input, options) {
|
|
|
2847
3047
|
}
|
|
2848
3048
|
if (s9 !== peg$FAILED) {
|
|
2849
3049
|
peg$savedPos = s0;
|
|
2850
|
-
s0 = peg$
|
|
3050
|
+
s0 = peg$f24(s3, s7);
|
|
2851
3051
|
} else {
|
|
2852
3052
|
peg$currPos = s0;
|
|
2853
3053
|
s0 = peg$FAILED;
|
|
@@ -2869,13 +3069,13 @@ function peg$parse(input, options) {
|
|
|
2869
3069
|
function peg$parseCol() {
|
|
2870
3070
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2871
3071
|
s0 = peg$currPos;
|
|
2872
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
2873
|
-
s1 = peg$
|
|
3072
|
+
if (input.substr(peg$currPos, 3) === peg$c26) {
|
|
3073
|
+
s1 = peg$c26;
|
|
2874
3074
|
peg$currPos += 3;
|
|
2875
3075
|
} else {
|
|
2876
3076
|
s1 = peg$FAILED;
|
|
2877
3077
|
if (peg$silentFails === 0) {
|
|
2878
|
-
peg$fail(peg$
|
|
3078
|
+
peg$fail(peg$e29);
|
|
2879
3079
|
}
|
|
2880
3080
|
}
|
|
2881
3081
|
if (s1 !== peg$FAILED) {
|
|
@@ -2910,7 +3110,7 @@ function peg$parse(input, options) {
|
|
|
2910
3110
|
}
|
|
2911
3111
|
if (s9 !== peg$FAILED) {
|
|
2912
3112
|
peg$savedPos = s0;
|
|
2913
|
-
s0 = peg$
|
|
3113
|
+
s0 = peg$f25(s3, s7);
|
|
2914
3114
|
} else {
|
|
2915
3115
|
peg$currPos = s0;
|
|
2916
3116
|
s0 = peg$FAILED;
|
|
@@ -2932,13 +3132,13 @@ function peg$parse(input, options) {
|
|
|
2932
3132
|
function peg$parseStack() {
|
|
2933
3133
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2934
3134
|
s0 = peg$currPos;
|
|
2935
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
2936
|
-
s1 = peg$
|
|
3135
|
+
if (input.substr(peg$currPos, 5) === peg$c27) {
|
|
3136
|
+
s1 = peg$c27;
|
|
2937
3137
|
peg$currPos += 5;
|
|
2938
3138
|
} else {
|
|
2939
3139
|
s1 = peg$FAILED;
|
|
2940
3140
|
if (peg$silentFails === 0) {
|
|
2941
|
-
peg$fail(peg$
|
|
3141
|
+
peg$fail(peg$e30);
|
|
2942
3142
|
}
|
|
2943
3143
|
}
|
|
2944
3144
|
if (s1 !== peg$FAILED) {
|
|
@@ -2973,7 +3173,7 @@ function peg$parse(input, options) {
|
|
|
2973
3173
|
}
|
|
2974
3174
|
if (s9 !== peg$FAILED) {
|
|
2975
3175
|
peg$savedPos = s0;
|
|
2976
|
-
s0 = peg$
|
|
3176
|
+
s0 = peg$f26(s3, s7);
|
|
2977
3177
|
} else {
|
|
2978
3178
|
peg$currPos = s0;
|
|
2979
3179
|
s0 = peg$FAILED;
|
|
@@ -2995,13 +3195,13 @@ function peg$parse(input, options) {
|
|
|
2995
3195
|
function peg$parseRelative() {
|
|
2996
3196
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
2997
3197
|
s0 = peg$currPos;
|
|
2998
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
2999
|
-
s1 = peg$
|
|
3198
|
+
if (input.substr(peg$currPos, 8) === peg$c28) {
|
|
3199
|
+
s1 = peg$c28;
|
|
3000
3200
|
peg$currPos += 8;
|
|
3001
3201
|
} else {
|
|
3002
3202
|
s1 = peg$FAILED;
|
|
3003
3203
|
if (peg$silentFails === 0) {
|
|
3004
|
-
peg$fail(peg$
|
|
3204
|
+
peg$fail(peg$e31);
|
|
3005
3205
|
}
|
|
3006
3206
|
}
|
|
3007
3207
|
if (s1 !== peg$FAILED) {
|
|
@@ -3036,7 +3236,7 @@ function peg$parse(input, options) {
|
|
|
3036
3236
|
}
|
|
3037
3237
|
if (s9 !== peg$FAILED) {
|
|
3038
3238
|
peg$savedPos = s0;
|
|
3039
|
-
s0 = peg$
|
|
3239
|
+
s0 = peg$f27(s3, s7);
|
|
3040
3240
|
} else {
|
|
3041
3241
|
peg$currPos = s0;
|
|
3042
3242
|
s0 = peg$FAILED;
|
|
@@ -3075,13 +3275,13 @@ function peg$parse(input, options) {
|
|
|
3075
3275
|
function peg$parseCard() {
|
|
3076
3276
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
|
|
3077
3277
|
s0 = peg$currPos;
|
|
3078
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
3079
|
-
s1 = peg$
|
|
3278
|
+
if (input.substr(peg$currPos, 4) === peg$c29) {
|
|
3279
|
+
s1 = peg$c29;
|
|
3080
3280
|
peg$currPos += 4;
|
|
3081
3281
|
} else {
|
|
3082
3282
|
s1 = peg$FAILED;
|
|
3083
3283
|
if (peg$silentFails === 0) {
|
|
3084
|
-
peg$fail(peg$
|
|
3284
|
+
peg$fail(peg$e32);
|
|
3085
3285
|
}
|
|
3086
3286
|
}
|
|
3087
3287
|
if (s1 !== peg$FAILED) {
|
|
@@ -3121,7 +3321,7 @@ function peg$parse(input, options) {
|
|
|
3121
3321
|
}
|
|
3122
3322
|
if (s11 !== peg$FAILED) {
|
|
3123
3323
|
peg$savedPos = s0;
|
|
3124
|
-
s0 = peg$
|
|
3324
|
+
s0 = peg$f28(s3, s5, s9);
|
|
3125
3325
|
} else {
|
|
3126
3326
|
peg$currPos = s0;
|
|
3127
3327
|
s0 = peg$FAILED;
|
|
@@ -3143,13 +3343,13 @@ function peg$parse(input, options) {
|
|
|
3143
3343
|
function peg$parseModal() {
|
|
3144
3344
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
|
|
3145
3345
|
s0 = peg$currPos;
|
|
3146
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
3147
|
-
s1 = peg$
|
|
3346
|
+
if (input.substr(peg$currPos, 5) === peg$c30) {
|
|
3347
|
+
s1 = peg$c30;
|
|
3148
3348
|
peg$currPos += 5;
|
|
3149
3349
|
} else {
|
|
3150
3350
|
s1 = peg$FAILED;
|
|
3151
3351
|
if (peg$silentFails === 0) {
|
|
3152
|
-
peg$fail(peg$
|
|
3352
|
+
peg$fail(peg$e33);
|
|
3153
3353
|
}
|
|
3154
3354
|
}
|
|
3155
3355
|
if (s1 !== peg$FAILED) {
|
|
@@ -3189,7 +3389,7 @@ function peg$parse(input, options) {
|
|
|
3189
3389
|
}
|
|
3190
3390
|
if (s11 !== peg$FAILED) {
|
|
3191
3391
|
peg$savedPos = s0;
|
|
3192
|
-
s0 = peg$
|
|
3392
|
+
s0 = peg$f29(s3, s5, s9);
|
|
3193
3393
|
} else {
|
|
3194
3394
|
peg$currPos = s0;
|
|
3195
3395
|
s0 = peg$FAILED;
|
|
@@ -3211,13 +3411,13 @@ function peg$parse(input, options) {
|
|
|
3211
3411
|
function peg$parseDrawer() {
|
|
3212
3412
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
|
|
3213
3413
|
s0 = peg$currPos;
|
|
3214
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
3215
|
-
s1 = peg$
|
|
3414
|
+
if (input.substr(peg$currPos, 6) === peg$c31) {
|
|
3415
|
+
s1 = peg$c31;
|
|
3216
3416
|
peg$currPos += 6;
|
|
3217
3417
|
} else {
|
|
3218
3418
|
s1 = peg$FAILED;
|
|
3219
3419
|
if (peg$silentFails === 0) {
|
|
3220
|
-
peg$fail(peg$
|
|
3420
|
+
peg$fail(peg$e34);
|
|
3221
3421
|
}
|
|
3222
3422
|
}
|
|
3223
3423
|
if (s1 !== peg$FAILED) {
|
|
@@ -3257,7 +3457,7 @@ function peg$parse(input, options) {
|
|
|
3257
3457
|
}
|
|
3258
3458
|
if (s11 !== peg$FAILED) {
|
|
3259
3459
|
peg$savedPos = s0;
|
|
3260
|
-
s0 = peg$
|
|
3460
|
+
s0 = peg$f30(s3, s5, s9);
|
|
3261
3461
|
} else {
|
|
3262
3462
|
peg$currPos = s0;
|
|
3263
3463
|
s0 = peg$FAILED;
|
|
@@ -3279,13 +3479,13 @@ function peg$parse(input, options) {
|
|
|
3279
3479
|
function peg$parseAccordion() {
|
|
3280
3480
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
|
|
3281
3481
|
s0 = peg$currPos;
|
|
3282
|
-
if (input.substr(peg$currPos, 9) === peg$
|
|
3283
|
-
s1 = peg$
|
|
3482
|
+
if (input.substr(peg$currPos, 9) === peg$c32) {
|
|
3483
|
+
s1 = peg$c32;
|
|
3284
3484
|
peg$currPos += 9;
|
|
3285
3485
|
} else {
|
|
3286
3486
|
s1 = peg$FAILED;
|
|
3287
3487
|
if (peg$silentFails === 0) {
|
|
3288
|
-
peg$fail(peg$
|
|
3488
|
+
peg$fail(peg$e35);
|
|
3289
3489
|
}
|
|
3290
3490
|
}
|
|
3291
3491
|
if (s1 !== peg$FAILED) {
|
|
@@ -3325,7 +3525,7 @@ function peg$parse(input, options) {
|
|
|
3325
3525
|
}
|
|
3326
3526
|
if (s11 !== peg$FAILED) {
|
|
3327
3527
|
peg$savedPos = s0;
|
|
3328
|
-
s0 = peg$
|
|
3528
|
+
s0 = peg$f31(s3, s5, s9);
|
|
3329
3529
|
} else {
|
|
3330
3530
|
peg$currPos = s0;
|
|
3331
3531
|
s0 = peg$FAILED;
|
|
@@ -3347,13 +3547,13 @@ function peg$parse(input, options) {
|
|
|
3347
3547
|
function peg$parseSection() {
|
|
3348
3548
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
|
|
3349
3549
|
s0 = peg$currPos;
|
|
3350
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
3351
|
-
s1 = peg$
|
|
3550
|
+
if (input.substr(peg$currPos, 7) === peg$c33) {
|
|
3551
|
+
s1 = peg$c33;
|
|
3352
3552
|
peg$currPos += 7;
|
|
3353
3553
|
} else {
|
|
3354
3554
|
s1 = peg$FAILED;
|
|
3355
3555
|
if (peg$silentFails === 0) {
|
|
3356
|
-
peg$fail(peg$
|
|
3556
|
+
peg$fail(peg$e36);
|
|
3357
3557
|
}
|
|
3358
3558
|
}
|
|
3359
3559
|
if (s1 !== peg$FAILED) {
|
|
@@ -3393,7 +3593,7 @@ function peg$parse(input, options) {
|
|
|
3393
3593
|
}
|
|
3394
3594
|
if (s11 !== peg$FAILED) {
|
|
3395
3595
|
peg$savedPos = s0;
|
|
3396
|
-
s0 = peg$
|
|
3596
|
+
s0 = peg$f32(s3, s5, s9);
|
|
3397
3597
|
} else {
|
|
3398
3598
|
peg$currPos = s0;
|
|
3399
3599
|
s0 = peg$FAILED;
|
|
@@ -3510,13 +3710,13 @@ function peg$parse(input, options) {
|
|
|
3510
3710
|
function peg$parseText() {
|
|
3511
3711
|
let s0, s1, s2, s3, s4, s5;
|
|
3512
3712
|
s0 = peg$currPos;
|
|
3513
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
3514
|
-
s1 = peg$
|
|
3713
|
+
if (input.substr(peg$currPos, 4) === peg$c34) {
|
|
3714
|
+
s1 = peg$c34;
|
|
3515
3715
|
peg$currPos += 4;
|
|
3516
3716
|
} else {
|
|
3517
3717
|
s1 = peg$FAILED;
|
|
3518
3718
|
if (peg$silentFails === 0) {
|
|
3519
|
-
peg$fail(peg$
|
|
3719
|
+
peg$fail(peg$e37);
|
|
3520
3720
|
}
|
|
3521
3721
|
}
|
|
3522
3722
|
if (s1 !== peg$FAILED) {
|
|
@@ -3529,7 +3729,7 @@ function peg$parse(input, options) {
|
|
|
3529
3729
|
s5 = null;
|
|
3530
3730
|
}
|
|
3531
3731
|
peg$savedPos = s0;
|
|
3532
|
-
s0 = peg$
|
|
3732
|
+
s0 = peg$f33(s3, s5);
|
|
3533
3733
|
} else {
|
|
3534
3734
|
peg$currPos = s0;
|
|
3535
3735
|
s0 = peg$FAILED;
|
|
@@ -3543,13 +3743,13 @@ function peg$parse(input, options) {
|
|
|
3543
3743
|
function peg$parseTitle() {
|
|
3544
3744
|
let s0, s1, s2, s3, s4, s5;
|
|
3545
3745
|
s0 = peg$currPos;
|
|
3546
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
3547
|
-
s1 = peg$
|
|
3746
|
+
if (input.substr(peg$currPos, 5) === peg$c35) {
|
|
3747
|
+
s1 = peg$c35;
|
|
3548
3748
|
peg$currPos += 5;
|
|
3549
3749
|
} else {
|
|
3550
3750
|
s1 = peg$FAILED;
|
|
3551
3751
|
if (peg$silentFails === 0) {
|
|
3552
|
-
peg$fail(peg$
|
|
3752
|
+
peg$fail(peg$e38);
|
|
3553
3753
|
}
|
|
3554
3754
|
}
|
|
3555
3755
|
if (s1 !== peg$FAILED) {
|
|
@@ -3562,7 +3762,7 @@ function peg$parse(input, options) {
|
|
|
3562
3762
|
s5 = null;
|
|
3563
3763
|
}
|
|
3564
3764
|
peg$savedPos = s0;
|
|
3565
|
-
s0 = peg$
|
|
3765
|
+
s0 = peg$f34(s3, s5);
|
|
3566
3766
|
} else {
|
|
3567
3767
|
peg$currPos = s0;
|
|
3568
3768
|
s0 = peg$FAILED;
|
|
@@ -3576,13 +3776,13 @@ function peg$parse(input, options) {
|
|
|
3576
3776
|
function peg$parseLink() {
|
|
3577
3777
|
let s0, s1, s2, s3, s4, s5;
|
|
3578
3778
|
s0 = peg$currPos;
|
|
3579
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
3580
|
-
s1 = peg$
|
|
3779
|
+
if (input.substr(peg$currPos, 4) === peg$c36) {
|
|
3780
|
+
s1 = peg$c36;
|
|
3581
3781
|
peg$currPos += 4;
|
|
3582
3782
|
} else {
|
|
3583
3783
|
s1 = peg$FAILED;
|
|
3584
3784
|
if (peg$silentFails === 0) {
|
|
3585
|
-
peg$fail(peg$
|
|
3785
|
+
peg$fail(peg$e39);
|
|
3586
3786
|
}
|
|
3587
3787
|
}
|
|
3588
3788
|
if (s1 !== peg$FAILED) {
|
|
@@ -3595,7 +3795,7 @@ function peg$parse(input, options) {
|
|
|
3595
3795
|
s5 = null;
|
|
3596
3796
|
}
|
|
3597
3797
|
peg$savedPos = s0;
|
|
3598
|
-
s0 = peg$
|
|
3798
|
+
s0 = peg$f35(s3, s5);
|
|
3599
3799
|
} else {
|
|
3600
3800
|
peg$currPos = s0;
|
|
3601
3801
|
s0 = peg$FAILED;
|
|
@@ -3609,13 +3809,13 @@ function peg$parse(input, options) {
|
|
|
3609
3809
|
function peg$parseButton() {
|
|
3610
3810
|
let s0, s1, s2, s3, s4, s5;
|
|
3611
3811
|
s0 = peg$currPos;
|
|
3612
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
3613
|
-
s1 = peg$
|
|
3812
|
+
if (input.substr(peg$currPos, 6) === peg$c37) {
|
|
3813
|
+
s1 = peg$c37;
|
|
3614
3814
|
peg$currPos += 6;
|
|
3615
3815
|
} else {
|
|
3616
3816
|
s1 = peg$FAILED;
|
|
3617
3817
|
if (peg$silentFails === 0) {
|
|
3618
|
-
peg$fail(peg$
|
|
3818
|
+
peg$fail(peg$e40);
|
|
3619
3819
|
}
|
|
3620
3820
|
}
|
|
3621
3821
|
if (s1 !== peg$FAILED) {
|
|
@@ -3628,7 +3828,7 @@ function peg$parse(input, options) {
|
|
|
3628
3828
|
s5 = null;
|
|
3629
3829
|
}
|
|
3630
3830
|
peg$savedPos = s0;
|
|
3631
|
-
s0 = peg$
|
|
3831
|
+
s0 = peg$f36(s3, s5);
|
|
3632
3832
|
} else {
|
|
3633
3833
|
peg$currPos = s0;
|
|
3634
3834
|
s0 = peg$FAILED;
|
|
@@ -3642,13 +3842,13 @@ function peg$parse(input, options) {
|
|
|
3642
3842
|
function peg$parseInput() {
|
|
3643
3843
|
let s0, s1, s2, s3, s4, s5;
|
|
3644
3844
|
s0 = peg$currPos;
|
|
3645
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
3646
|
-
s1 = peg$
|
|
3845
|
+
if (input.substr(peg$currPos, 5) === peg$c38) {
|
|
3846
|
+
s1 = peg$c38;
|
|
3647
3847
|
peg$currPos += 5;
|
|
3648
3848
|
} else {
|
|
3649
3849
|
s1 = peg$FAILED;
|
|
3650
3850
|
if (peg$silentFails === 0) {
|
|
3651
|
-
peg$fail(peg$
|
|
3851
|
+
peg$fail(peg$e41);
|
|
3652
3852
|
}
|
|
3653
3853
|
}
|
|
3654
3854
|
if (s1 !== peg$FAILED) {
|
|
@@ -3663,7 +3863,7 @@ function peg$parse(input, options) {
|
|
|
3663
3863
|
s5 = null;
|
|
3664
3864
|
}
|
|
3665
3865
|
peg$savedPos = s0;
|
|
3666
|
-
s0 = peg$
|
|
3866
|
+
s0 = peg$f37(s3, s5);
|
|
3667
3867
|
} else {
|
|
3668
3868
|
peg$currPos = s0;
|
|
3669
3869
|
s0 = peg$FAILED;
|
|
@@ -3673,13 +3873,13 @@ function peg$parse(input, options) {
|
|
|
3673
3873
|
function peg$parseTextarea() {
|
|
3674
3874
|
let s0, s1, s2, s3, s4, s5;
|
|
3675
3875
|
s0 = peg$currPos;
|
|
3676
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
3677
|
-
s1 = peg$
|
|
3876
|
+
if (input.substr(peg$currPos, 8) === peg$c39) {
|
|
3877
|
+
s1 = peg$c39;
|
|
3678
3878
|
peg$currPos += 8;
|
|
3679
3879
|
} else {
|
|
3680
3880
|
s1 = peg$FAILED;
|
|
3681
3881
|
if (peg$silentFails === 0) {
|
|
3682
|
-
peg$fail(peg$
|
|
3882
|
+
peg$fail(peg$e42);
|
|
3683
3883
|
}
|
|
3684
3884
|
}
|
|
3685
3885
|
if (s1 !== peg$FAILED) {
|
|
@@ -3694,7 +3894,7 @@ function peg$parse(input, options) {
|
|
|
3694
3894
|
s5 = null;
|
|
3695
3895
|
}
|
|
3696
3896
|
peg$savedPos = s0;
|
|
3697
|
-
s0 = peg$
|
|
3897
|
+
s0 = peg$f38(s3, s5);
|
|
3698
3898
|
} else {
|
|
3699
3899
|
peg$currPos = s0;
|
|
3700
3900
|
s0 = peg$FAILED;
|
|
@@ -3704,13 +3904,13 @@ function peg$parse(input, options) {
|
|
|
3704
3904
|
function peg$parseSelect() {
|
|
3705
3905
|
let s0, s1, s2, s3, s4, s5, s6, s7;
|
|
3706
3906
|
s0 = peg$currPos;
|
|
3707
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
3708
|
-
s1 = peg$
|
|
3907
|
+
if (input.substr(peg$currPos, 6) === peg$c40) {
|
|
3908
|
+
s1 = peg$c40;
|
|
3709
3909
|
peg$currPos += 6;
|
|
3710
3910
|
} else {
|
|
3711
3911
|
s1 = peg$FAILED;
|
|
3712
3912
|
if (peg$silentFails === 0) {
|
|
3713
|
-
peg$fail(peg$
|
|
3913
|
+
peg$fail(peg$e43);
|
|
3714
3914
|
}
|
|
3715
3915
|
}
|
|
3716
3916
|
if (s1 !== peg$FAILED) {
|
|
@@ -3730,7 +3930,7 @@ function peg$parse(input, options) {
|
|
|
3730
3930
|
s7 = null;
|
|
3731
3931
|
}
|
|
3732
3932
|
peg$savedPos = s0;
|
|
3733
|
-
s0 = peg$
|
|
3933
|
+
s0 = peg$f39(s3, s5, s7);
|
|
3734
3934
|
} else {
|
|
3735
3935
|
peg$currPos = s0;
|
|
3736
3936
|
s0 = peg$FAILED;
|
|
@@ -3740,13 +3940,13 @@ function peg$parse(input, options) {
|
|
|
3740
3940
|
function peg$parseCheckbox() {
|
|
3741
3941
|
let s0, s1, s2, s3, s4, s5;
|
|
3742
3942
|
s0 = peg$currPos;
|
|
3743
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
3744
|
-
s1 = peg$
|
|
3943
|
+
if (input.substr(peg$currPos, 8) === peg$c41) {
|
|
3944
|
+
s1 = peg$c41;
|
|
3745
3945
|
peg$currPos += 8;
|
|
3746
3946
|
} else {
|
|
3747
3947
|
s1 = peg$FAILED;
|
|
3748
3948
|
if (peg$silentFails === 0) {
|
|
3749
|
-
peg$fail(peg$
|
|
3949
|
+
peg$fail(peg$e44);
|
|
3750
3950
|
}
|
|
3751
3951
|
}
|
|
3752
3952
|
if (s1 !== peg$FAILED) {
|
|
@@ -3761,7 +3961,7 @@ function peg$parse(input, options) {
|
|
|
3761
3961
|
s5 = null;
|
|
3762
3962
|
}
|
|
3763
3963
|
peg$savedPos = s0;
|
|
3764
|
-
s0 = peg$
|
|
3964
|
+
s0 = peg$f40(s3, s5);
|
|
3765
3965
|
} else {
|
|
3766
3966
|
peg$currPos = s0;
|
|
3767
3967
|
s0 = peg$FAILED;
|
|
@@ -3771,13 +3971,13 @@ function peg$parse(input, options) {
|
|
|
3771
3971
|
function peg$parseRadio() {
|
|
3772
3972
|
let s0, s1, s2, s3, s4, s5;
|
|
3773
3973
|
s0 = peg$currPos;
|
|
3774
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
3775
|
-
s1 = peg$
|
|
3974
|
+
if (input.substr(peg$currPos, 5) === peg$c42) {
|
|
3975
|
+
s1 = peg$c42;
|
|
3776
3976
|
peg$currPos += 5;
|
|
3777
3977
|
} else {
|
|
3778
3978
|
s1 = peg$FAILED;
|
|
3779
3979
|
if (peg$silentFails === 0) {
|
|
3780
|
-
peg$fail(peg$
|
|
3980
|
+
peg$fail(peg$e45);
|
|
3781
3981
|
}
|
|
3782
3982
|
}
|
|
3783
3983
|
if (s1 !== peg$FAILED) {
|
|
@@ -3792,7 +3992,7 @@ function peg$parse(input, options) {
|
|
|
3792
3992
|
s5 = null;
|
|
3793
3993
|
}
|
|
3794
3994
|
peg$savedPos = s0;
|
|
3795
|
-
s0 = peg$
|
|
3995
|
+
s0 = peg$f41(s3, s5);
|
|
3796
3996
|
} else {
|
|
3797
3997
|
peg$currPos = s0;
|
|
3798
3998
|
s0 = peg$FAILED;
|
|
@@ -3802,13 +4002,13 @@ function peg$parse(input, options) {
|
|
|
3802
4002
|
function peg$parseSwitch() {
|
|
3803
4003
|
let s0, s1, s2, s3, s4, s5;
|
|
3804
4004
|
s0 = peg$currPos;
|
|
3805
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
3806
|
-
s1 = peg$
|
|
4005
|
+
if (input.substr(peg$currPos, 6) === peg$c43) {
|
|
4006
|
+
s1 = peg$c43;
|
|
3807
4007
|
peg$currPos += 6;
|
|
3808
4008
|
} else {
|
|
3809
4009
|
s1 = peg$FAILED;
|
|
3810
4010
|
if (peg$silentFails === 0) {
|
|
3811
|
-
peg$fail(peg$
|
|
4011
|
+
peg$fail(peg$e46);
|
|
3812
4012
|
}
|
|
3813
4013
|
}
|
|
3814
4014
|
if (s1 !== peg$FAILED) {
|
|
@@ -3823,7 +4023,7 @@ function peg$parse(input, options) {
|
|
|
3823
4023
|
s5 = null;
|
|
3824
4024
|
}
|
|
3825
4025
|
peg$savedPos = s0;
|
|
3826
|
-
s0 = peg$
|
|
4026
|
+
s0 = peg$f42(s3, s5);
|
|
3827
4027
|
} else {
|
|
3828
4028
|
peg$currPos = s0;
|
|
3829
4029
|
s0 = peg$FAILED;
|
|
@@ -3833,13 +4033,13 @@ function peg$parse(input, options) {
|
|
|
3833
4033
|
function peg$parseSlider() {
|
|
3834
4034
|
let s0, s1, s2, s3, s4, s5;
|
|
3835
4035
|
s0 = peg$currPos;
|
|
3836
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
3837
|
-
s1 = peg$
|
|
4036
|
+
if (input.substr(peg$currPos, 6) === peg$c44) {
|
|
4037
|
+
s1 = peg$c44;
|
|
3838
4038
|
peg$currPos += 6;
|
|
3839
4039
|
} else {
|
|
3840
4040
|
s1 = peg$FAILED;
|
|
3841
4041
|
if (peg$silentFails === 0) {
|
|
3842
|
-
peg$fail(peg$
|
|
4042
|
+
peg$fail(peg$e47);
|
|
3843
4043
|
}
|
|
3844
4044
|
}
|
|
3845
4045
|
if (s1 !== peg$FAILED) {
|
|
@@ -3854,7 +4054,7 @@ function peg$parse(input, options) {
|
|
|
3854
4054
|
s5 = null;
|
|
3855
4055
|
}
|
|
3856
4056
|
peg$savedPos = s0;
|
|
3857
|
-
s0 = peg$
|
|
4057
|
+
s0 = peg$f43(s3, s5);
|
|
3858
4058
|
} else {
|
|
3859
4059
|
peg$currPos = s0;
|
|
3860
4060
|
s0 = peg$FAILED;
|
|
@@ -3864,13 +4064,13 @@ function peg$parse(input, options) {
|
|
|
3864
4064
|
function peg$parseImage() {
|
|
3865
4065
|
let s0, s1, s2, s3, s4, s5;
|
|
3866
4066
|
s0 = peg$currPos;
|
|
3867
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
3868
|
-
s1 = peg$
|
|
4067
|
+
if (input.substr(peg$currPos, 5) === peg$c45) {
|
|
4068
|
+
s1 = peg$c45;
|
|
3869
4069
|
peg$currPos += 5;
|
|
3870
4070
|
} else {
|
|
3871
4071
|
s1 = peg$FAILED;
|
|
3872
4072
|
if (peg$silentFails === 0) {
|
|
3873
|
-
peg$fail(peg$
|
|
4073
|
+
peg$fail(peg$e48);
|
|
3874
4074
|
}
|
|
3875
4075
|
}
|
|
3876
4076
|
if (s1 !== peg$FAILED) {
|
|
@@ -3885,7 +4085,7 @@ function peg$parse(input, options) {
|
|
|
3885
4085
|
s5 = null;
|
|
3886
4086
|
}
|
|
3887
4087
|
peg$savedPos = s0;
|
|
3888
|
-
s0 = peg$
|
|
4088
|
+
s0 = peg$f44(s3, s5);
|
|
3889
4089
|
} else {
|
|
3890
4090
|
peg$currPos = s0;
|
|
3891
4091
|
s0 = peg$FAILED;
|
|
@@ -3895,13 +4095,13 @@ function peg$parse(input, options) {
|
|
|
3895
4095
|
function peg$parsePlaceholder() {
|
|
3896
4096
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
|
|
3897
4097
|
s0 = peg$currPos;
|
|
3898
|
-
if (input.substr(peg$currPos, 11) === peg$
|
|
3899
|
-
s1 = peg$
|
|
4098
|
+
if (input.substr(peg$currPos, 11) === peg$c46) {
|
|
4099
|
+
s1 = peg$c46;
|
|
3900
4100
|
peg$currPos += 11;
|
|
3901
4101
|
} else {
|
|
3902
4102
|
s1 = peg$FAILED;
|
|
3903
4103
|
if (peg$silentFails === 0) {
|
|
3904
|
-
peg$fail(peg$
|
|
4104
|
+
peg$fail(peg$e49);
|
|
3905
4105
|
}
|
|
3906
4106
|
}
|
|
3907
4107
|
if (s1 !== peg$FAILED) {
|
|
@@ -3959,7 +4159,7 @@ function peg$parse(input, options) {
|
|
|
3959
4159
|
s7 = null;
|
|
3960
4160
|
}
|
|
3961
4161
|
peg$savedPos = s0;
|
|
3962
|
-
s0 = peg$
|
|
4162
|
+
s0 = peg$f45(s3, s5, s7);
|
|
3963
4163
|
} else {
|
|
3964
4164
|
peg$currPos = s0;
|
|
3965
4165
|
s0 = peg$FAILED;
|
|
@@ -3969,13 +4169,13 @@ function peg$parse(input, options) {
|
|
|
3969
4169
|
function peg$parseAvatar() {
|
|
3970
4170
|
let s0, s1, s2, s3, s4, s5;
|
|
3971
4171
|
s0 = peg$currPos;
|
|
3972
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
3973
|
-
s1 = peg$
|
|
4172
|
+
if (input.substr(peg$currPos, 6) === peg$c47) {
|
|
4173
|
+
s1 = peg$c47;
|
|
3974
4174
|
peg$currPos += 6;
|
|
3975
4175
|
} else {
|
|
3976
4176
|
s1 = peg$FAILED;
|
|
3977
4177
|
if (peg$silentFails === 0) {
|
|
3978
|
-
peg$fail(peg$
|
|
4178
|
+
peg$fail(peg$e50);
|
|
3979
4179
|
}
|
|
3980
4180
|
}
|
|
3981
4181
|
if (s1 !== peg$FAILED) {
|
|
@@ -3990,7 +4190,7 @@ function peg$parse(input, options) {
|
|
|
3990
4190
|
s5 = null;
|
|
3991
4191
|
}
|
|
3992
4192
|
peg$savedPos = s0;
|
|
3993
|
-
s0 = peg$
|
|
4193
|
+
s0 = peg$f46(s3, s5);
|
|
3994
4194
|
} else {
|
|
3995
4195
|
peg$currPos = s0;
|
|
3996
4196
|
s0 = peg$FAILED;
|
|
@@ -4000,13 +4200,13 @@ function peg$parse(input, options) {
|
|
|
4000
4200
|
function peg$parseBadge() {
|
|
4001
4201
|
let s0, s1, s2, s3, s4, s5;
|
|
4002
4202
|
s0 = peg$currPos;
|
|
4003
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
4004
|
-
s1 = peg$
|
|
4203
|
+
if (input.substr(peg$currPos, 5) === peg$c48) {
|
|
4204
|
+
s1 = peg$c48;
|
|
4005
4205
|
peg$currPos += 5;
|
|
4006
4206
|
} else {
|
|
4007
4207
|
s1 = peg$FAILED;
|
|
4008
4208
|
if (peg$silentFails === 0) {
|
|
4009
|
-
peg$fail(peg$
|
|
4209
|
+
peg$fail(peg$e51);
|
|
4010
4210
|
}
|
|
4011
4211
|
}
|
|
4012
4212
|
if (s1 !== peg$FAILED) {
|
|
@@ -4019,7 +4219,7 @@ function peg$parse(input, options) {
|
|
|
4019
4219
|
s5 = null;
|
|
4020
4220
|
}
|
|
4021
4221
|
peg$savedPos = s0;
|
|
4022
|
-
s0 = peg$
|
|
4222
|
+
s0 = peg$f47(s3, s5);
|
|
4023
4223
|
} else {
|
|
4024
4224
|
peg$currPos = s0;
|
|
4025
4225
|
s0 = peg$FAILED;
|
|
@@ -4033,13 +4233,13 @@ function peg$parse(input, options) {
|
|
|
4033
4233
|
function peg$parseIcon() {
|
|
4034
4234
|
let s0, s1, s2, s3, s4, s5;
|
|
4035
4235
|
s0 = peg$currPos;
|
|
4036
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
4037
|
-
s1 = peg$
|
|
4236
|
+
if (input.substr(peg$currPos, 4) === peg$c49) {
|
|
4237
|
+
s1 = peg$c49;
|
|
4038
4238
|
peg$currPos += 4;
|
|
4039
4239
|
} else {
|
|
4040
4240
|
s1 = peg$FAILED;
|
|
4041
4241
|
if (peg$silentFails === 0) {
|
|
4042
|
-
peg$fail(peg$
|
|
4242
|
+
peg$fail(peg$e52);
|
|
4043
4243
|
}
|
|
4044
4244
|
}
|
|
4045
4245
|
if (s1 !== peg$FAILED) {
|
|
@@ -4052,7 +4252,7 @@ function peg$parse(input, options) {
|
|
|
4052
4252
|
s5 = null;
|
|
4053
4253
|
}
|
|
4054
4254
|
peg$savedPos = s0;
|
|
4055
|
-
s0 = peg$
|
|
4255
|
+
s0 = peg$f48(s3, s5);
|
|
4056
4256
|
} else {
|
|
4057
4257
|
peg$currPos = s0;
|
|
4058
4258
|
s0 = peg$FAILED;
|
|
@@ -4066,13 +4266,13 @@ function peg$parse(input, options) {
|
|
|
4066
4266
|
function peg$parseTable() {
|
|
4067
4267
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
4068
4268
|
s0 = peg$currPos;
|
|
4069
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
4070
|
-
s1 = peg$
|
|
4269
|
+
if (input.substr(peg$currPos, 5) === peg$c50) {
|
|
4270
|
+
s1 = peg$c50;
|
|
4071
4271
|
peg$currPos += 5;
|
|
4072
4272
|
} else {
|
|
4073
4273
|
s1 = peg$FAILED;
|
|
4074
4274
|
if (peg$silentFails === 0) {
|
|
4075
|
-
peg$fail(peg$
|
|
4275
|
+
peg$fail(peg$e53);
|
|
4076
4276
|
}
|
|
4077
4277
|
}
|
|
4078
4278
|
if (s1 !== peg$FAILED) {
|
|
@@ -4085,7 +4285,7 @@ function peg$parse(input, options) {
|
|
|
4085
4285
|
s5 = null;
|
|
4086
4286
|
}
|
|
4087
4287
|
peg$savedPos = s0;
|
|
4088
|
-
s0 = peg$
|
|
4288
|
+
s0 = peg$f49(s3, s5);
|
|
4089
4289
|
} else {
|
|
4090
4290
|
peg$currPos = s0;
|
|
4091
4291
|
s0 = peg$FAILED;
|
|
@@ -4096,13 +4296,13 @@ function peg$parse(input, options) {
|
|
|
4096
4296
|
}
|
|
4097
4297
|
if (s0 === peg$FAILED) {
|
|
4098
4298
|
s0 = peg$currPos;
|
|
4099
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
4100
|
-
s1 = peg$
|
|
4299
|
+
if (input.substr(peg$currPos, 5) === peg$c50) {
|
|
4300
|
+
s1 = peg$c50;
|
|
4101
4301
|
peg$currPos += 5;
|
|
4102
4302
|
} else {
|
|
4103
4303
|
s1 = peg$FAILED;
|
|
4104
4304
|
if (peg$silentFails === 0) {
|
|
4105
|
-
peg$fail(peg$
|
|
4305
|
+
peg$fail(peg$e53);
|
|
4106
4306
|
}
|
|
4107
4307
|
}
|
|
4108
4308
|
if (s1 !== peg$FAILED) {
|
|
@@ -4136,7 +4336,7 @@ function peg$parse(input, options) {
|
|
|
4136
4336
|
}
|
|
4137
4337
|
if (s9 !== peg$FAILED) {
|
|
4138
4338
|
peg$savedPos = s0;
|
|
4139
|
-
s0 = peg$
|
|
4339
|
+
s0 = peg$f50(s3, s7);
|
|
4140
4340
|
} else {
|
|
4141
4341
|
peg$currPos = s0;
|
|
4142
4342
|
s0 = peg$FAILED;
|
|
@@ -4156,12 +4356,12 @@ function peg$parse(input, options) {
|
|
|
4156
4356
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
|
|
4157
4357
|
s0 = peg$currPos;
|
|
4158
4358
|
if (input.charCodeAt(peg$currPos) === 91) {
|
|
4159
|
-
s1 = peg$
|
|
4359
|
+
s1 = peg$c51;
|
|
4160
4360
|
peg$currPos++;
|
|
4161
4361
|
} else {
|
|
4162
4362
|
s1 = peg$FAILED;
|
|
4163
4363
|
if (peg$silentFails === 0) {
|
|
4164
|
-
peg$fail(peg$
|
|
4364
|
+
peg$fail(peg$e54);
|
|
4165
4365
|
}
|
|
4166
4366
|
}
|
|
4167
4367
|
if (s1 !== peg$FAILED) {
|
|
@@ -4237,17 +4437,17 @@ function peg$parse(input, options) {
|
|
|
4237
4437
|
}
|
|
4238
4438
|
s7 = peg$parse_();
|
|
4239
4439
|
if (input.charCodeAt(peg$currPos) === 93) {
|
|
4240
|
-
s8 = peg$
|
|
4440
|
+
s8 = peg$c52;
|
|
4241
4441
|
peg$currPos++;
|
|
4242
4442
|
} else {
|
|
4243
4443
|
s8 = peg$FAILED;
|
|
4244
4444
|
if (peg$silentFails === 0) {
|
|
4245
|
-
peg$fail(peg$
|
|
4445
|
+
peg$fail(peg$e55);
|
|
4246
4446
|
}
|
|
4247
4447
|
}
|
|
4248
4448
|
if (s8 !== peg$FAILED) {
|
|
4249
4449
|
peg$savedPos = s0;
|
|
4250
|
-
s0 = peg$
|
|
4450
|
+
s0 = peg$f51(s3, s5);
|
|
4251
4451
|
} else {
|
|
4252
4452
|
peg$currPos = s0;
|
|
4253
4453
|
s0 = peg$FAILED;
|
|
@@ -4290,20 +4490,20 @@ function peg$parse(input, options) {
|
|
|
4290
4490
|
}
|
|
4291
4491
|
}
|
|
4292
4492
|
peg$savedPos = s0;
|
|
4293
|
-
s1 = peg$
|
|
4493
|
+
s1 = peg$f52(s1);
|
|
4294
4494
|
s0 = s1;
|
|
4295
4495
|
return s0;
|
|
4296
4496
|
}
|
|
4297
4497
|
function peg$parseTableRow() {
|
|
4298
4498
|
let s0, s1, s2, s3;
|
|
4299
4499
|
s0 = peg$currPos;
|
|
4300
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
4301
|
-
s1 = peg$
|
|
4500
|
+
if (input.substr(peg$currPos, 7) === peg$c53) {
|
|
4501
|
+
s1 = peg$c53;
|
|
4302
4502
|
peg$currPos += 7;
|
|
4303
4503
|
} else {
|
|
4304
4504
|
s1 = peg$FAILED;
|
|
4305
4505
|
if (peg$silentFails === 0) {
|
|
4306
|
-
peg$fail(peg$
|
|
4506
|
+
peg$fail(peg$e56);
|
|
4307
4507
|
}
|
|
4308
4508
|
}
|
|
4309
4509
|
if (s1 !== peg$FAILED) {
|
|
@@ -4311,7 +4511,7 @@ function peg$parse(input, options) {
|
|
|
4311
4511
|
s3 = peg$parseArray();
|
|
4312
4512
|
if (s3 !== peg$FAILED) {
|
|
4313
4513
|
peg$savedPos = s0;
|
|
4314
|
-
s0 = peg$
|
|
4514
|
+
s0 = peg$f53(s3);
|
|
4315
4515
|
} else {
|
|
4316
4516
|
peg$currPos = s0;
|
|
4317
4517
|
s0 = peg$FAILED;
|
|
@@ -4322,13 +4522,13 @@ function peg$parse(input, options) {
|
|
|
4322
4522
|
}
|
|
4323
4523
|
if (s0 === peg$FAILED) {
|
|
4324
4524
|
s0 = peg$currPos;
|
|
4325
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
4326
|
-
s1 = peg$
|
|
4525
|
+
if (input.substr(peg$currPos, 3) === peg$c25) {
|
|
4526
|
+
s1 = peg$c25;
|
|
4327
4527
|
peg$currPos += 3;
|
|
4328
4528
|
} else {
|
|
4329
4529
|
s1 = peg$FAILED;
|
|
4330
4530
|
if (peg$silentFails === 0) {
|
|
4331
|
-
peg$fail(peg$
|
|
4531
|
+
peg$fail(peg$e28);
|
|
4332
4532
|
}
|
|
4333
4533
|
}
|
|
4334
4534
|
if (s1 !== peg$FAILED) {
|
|
@@ -4336,7 +4536,7 @@ function peg$parse(input, options) {
|
|
|
4336
4536
|
s3 = peg$parseArray();
|
|
4337
4537
|
if (s3 !== peg$FAILED) {
|
|
4338
4538
|
peg$savedPos = s0;
|
|
4339
|
-
s0 = peg$
|
|
4539
|
+
s0 = peg$f54(s3);
|
|
4340
4540
|
} else {
|
|
4341
4541
|
peg$currPos = s0;
|
|
4342
4542
|
s0 = peg$FAILED;
|
|
@@ -4350,7 +4550,7 @@ function peg$parse(input, options) {
|
|
|
4350
4550
|
s1 = peg$parseComment();
|
|
4351
4551
|
if (s1 !== peg$FAILED) {
|
|
4352
4552
|
peg$savedPos = s0;
|
|
4353
|
-
s1 = peg$
|
|
4553
|
+
s1 = peg$f55();
|
|
4354
4554
|
}
|
|
4355
4555
|
s0 = s1;
|
|
4356
4556
|
}
|
|
@@ -4360,13 +4560,13 @@ function peg$parse(input, options) {
|
|
|
4360
4560
|
function peg$parseList() {
|
|
4361
4561
|
let s0, s1, s2, s3, s4, s5, s6, s7;
|
|
4362
4562
|
s0 = peg$currPos;
|
|
4363
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
4364
|
-
s1 = peg$
|
|
4563
|
+
if (input.substr(peg$currPos, 4) === peg$c54) {
|
|
4564
|
+
s1 = peg$c54;
|
|
4365
4565
|
peg$currPos += 4;
|
|
4366
4566
|
} else {
|
|
4367
4567
|
s1 = peg$FAILED;
|
|
4368
4568
|
if (peg$silentFails === 0) {
|
|
4369
|
-
peg$fail(peg$
|
|
4569
|
+
peg$fail(peg$e57);
|
|
4370
4570
|
}
|
|
4371
4571
|
}
|
|
4372
4572
|
if (s1 !== peg$FAILED) {
|
|
@@ -4386,7 +4586,7 @@ function peg$parse(input, options) {
|
|
|
4386
4586
|
s7 = null;
|
|
4387
4587
|
}
|
|
4388
4588
|
peg$savedPos = s0;
|
|
4389
|
-
s0 = peg$
|
|
4589
|
+
s0 = peg$f56(s3, s5, s7);
|
|
4390
4590
|
} else {
|
|
4391
4591
|
peg$currPos = s0;
|
|
4392
4592
|
s0 = peg$FAILED;
|
|
@@ -4442,7 +4642,7 @@ function peg$parse(input, options) {
|
|
|
4442
4642
|
}
|
|
4443
4643
|
if (s4 !== peg$FAILED) {
|
|
4444
4644
|
peg$savedPos = s0;
|
|
4445
|
-
s0 = peg$
|
|
4645
|
+
s0 = peg$f57(s3);
|
|
4446
4646
|
} else {
|
|
4447
4647
|
peg$currPos = s0;
|
|
4448
4648
|
s0 = peg$FAILED;
|
|
@@ -4456,13 +4656,13 @@ function peg$parse(input, options) {
|
|
|
4456
4656
|
function peg$parseListItem() {
|
|
4457
4657
|
let s0, s1, s2, s3, s4, s5, s6, s7;
|
|
4458
4658
|
s0 = peg$currPos;
|
|
4459
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
4460
|
-
s1 = peg$
|
|
4659
|
+
if (input.substr(peg$currPos, 4) === peg$c55) {
|
|
4660
|
+
s1 = peg$c55;
|
|
4461
4661
|
peg$currPos += 4;
|
|
4462
4662
|
} else {
|
|
4463
4663
|
s1 = peg$FAILED;
|
|
4464
4664
|
if (peg$silentFails === 0) {
|
|
4465
|
-
peg$fail(peg$
|
|
4665
|
+
peg$fail(peg$e58);
|
|
4466
4666
|
}
|
|
4467
4667
|
}
|
|
4468
4668
|
if (s1 !== peg$FAILED) {
|
|
@@ -4480,7 +4680,7 @@ function peg$parse(input, options) {
|
|
|
4480
4680
|
s7 = null;
|
|
4481
4681
|
}
|
|
4482
4682
|
peg$savedPos = s0;
|
|
4483
|
-
s0 = peg$
|
|
4683
|
+
s0 = peg$f58(s3, s5, s7);
|
|
4484
4684
|
} else {
|
|
4485
4685
|
peg$currPos = s0;
|
|
4486
4686
|
s0 = peg$FAILED;
|
|
@@ -4494,7 +4694,7 @@ function peg$parse(input, options) {
|
|
|
4494
4694
|
s1 = peg$parseComment();
|
|
4495
4695
|
if (s1 !== peg$FAILED) {
|
|
4496
4696
|
peg$savedPos = s0;
|
|
4497
|
-
s1 = peg$
|
|
4697
|
+
s1 = peg$f59();
|
|
4498
4698
|
}
|
|
4499
4699
|
s0 = s1;
|
|
4500
4700
|
}
|
|
@@ -4503,13 +4703,13 @@ function peg$parse(input, options) {
|
|
|
4503
4703
|
function peg$parseAlert() {
|
|
4504
4704
|
let s0, s1, s2, s3, s4, s5;
|
|
4505
4705
|
s0 = peg$currPos;
|
|
4506
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
4507
|
-
s1 = peg$
|
|
4706
|
+
if (input.substr(peg$currPos, 5) === peg$c56) {
|
|
4707
|
+
s1 = peg$c56;
|
|
4508
4708
|
peg$currPos += 5;
|
|
4509
4709
|
} else {
|
|
4510
4710
|
s1 = peg$FAILED;
|
|
4511
4711
|
if (peg$silentFails === 0) {
|
|
4512
|
-
peg$fail(peg$
|
|
4712
|
+
peg$fail(peg$e59);
|
|
4513
4713
|
}
|
|
4514
4714
|
}
|
|
4515
4715
|
if (s1 !== peg$FAILED) {
|
|
@@ -4522,7 +4722,7 @@ function peg$parse(input, options) {
|
|
|
4522
4722
|
s5 = null;
|
|
4523
4723
|
}
|
|
4524
4724
|
peg$savedPos = s0;
|
|
4525
|
-
s0 = peg$
|
|
4725
|
+
s0 = peg$f60(s3, s5);
|
|
4526
4726
|
} else {
|
|
4527
4727
|
peg$currPos = s0;
|
|
4528
4728
|
s0 = peg$FAILED;
|
|
@@ -4536,13 +4736,13 @@ function peg$parse(input, options) {
|
|
|
4536
4736
|
function peg$parseToast() {
|
|
4537
4737
|
let s0, s1, s2, s3, s4, s5;
|
|
4538
4738
|
s0 = peg$currPos;
|
|
4539
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
4540
|
-
s1 = peg$
|
|
4739
|
+
if (input.substr(peg$currPos, 5) === peg$c57) {
|
|
4740
|
+
s1 = peg$c57;
|
|
4541
4741
|
peg$currPos += 5;
|
|
4542
4742
|
} else {
|
|
4543
4743
|
s1 = peg$FAILED;
|
|
4544
4744
|
if (peg$silentFails === 0) {
|
|
4545
|
-
peg$fail(peg$
|
|
4745
|
+
peg$fail(peg$e60);
|
|
4546
4746
|
}
|
|
4547
4747
|
}
|
|
4548
4748
|
if (s1 !== peg$FAILED) {
|
|
@@ -4555,7 +4755,7 @@ function peg$parse(input, options) {
|
|
|
4555
4755
|
s5 = null;
|
|
4556
4756
|
}
|
|
4557
4757
|
peg$savedPos = s0;
|
|
4558
|
-
s0 = peg$
|
|
4758
|
+
s0 = peg$f61(s3, s5);
|
|
4559
4759
|
} else {
|
|
4560
4760
|
peg$currPos = s0;
|
|
4561
4761
|
s0 = peg$FAILED;
|
|
@@ -4569,13 +4769,13 @@ function peg$parse(input, options) {
|
|
|
4569
4769
|
function peg$parseProgress() {
|
|
4570
4770
|
let s0, s1, s2, s3;
|
|
4571
4771
|
s0 = peg$currPos;
|
|
4572
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
4573
|
-
s1 = peg$
|
|
4772
|
+
if (input.substr(peg$currPos, 8) === peg$c58) {
|
|
4773
|
+
s1 = peg$c58;
|
|
4574
4774
|
peg$currPos += 8;
|
|
4575
4775
|
} else {
|
|
4576
4776
|
s1 = peg$FAILED;
|
|
4577
4777
|
if (peg$silentFails === 0) {
|
|
4578
|
-
peg$fail(peg$
|
|
4778
|
+
peg$fail(peg$e61);
|
|
4579
4779
|
}
|
|
4580
4780
|
}
|
|
4581
4781
|
if (s1 !== peg$FAILED) {
|
|
@@ -4585,7 +4785,7 @@ function peg$parse(input, options) {
|
|
|
4585
4785
|
s3 = null;
|
|
4586
4786
|
}
|
|
4587
4787
|
peg$savedPos = s0;
|
|
4588
|
-
s0 = peg$
|
|
4788
|
+
s0 = peg$f62(s3);
|
|
4589
4789
|
} else {
|
|
4590
4790
|
peg$currPos = s0;
|
|
4591
4791
|
s0 = peg$FAILED;
|
|
@@ -4595,13 +4795,13 @@ function peg$parse(input, options) {
|
|
|
4595
4795
|
function peg$parseSpinner() {
|
|
4596
4796
|
let s0, s1, s2, s3, s4, s5;
|
|
4597
4797
|
s0 = peg$currPos;
|
|
4598
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
4599
|
-
s1 = peg$
|
|
4798
|
+
if (input.substr(peg$currPos, 7) === peg$c59) {
|
|
4799
|
+
s1 = peg$c59;
|
|
4600
4800
|
peg$currPos += 7;
|
|
4601
4801
|
} else {
|
|
4602
4802
|
s1 = peg$FAILED;
|
|
4603
4803
|
if (peg$silentFails === 0) {
|
|
4604
|
-
peg$fail(peg$
|
|
4804
|
+
peg$fail(peg$e62);
|
|
4605
4805
|
}
|
|
4606
4806
|
}
|
|
4607
4807
|
if (s1 !== peg$FAILED) {
|
|
@@ -4616,7 +4816,7 @@ function peg$parse(input, options) {
|
|
|
4616
4816
|
s5 = null;
|
|
4617
4817
|
}
|
|
4618
4818
|
peg$savedPos = s0;
|
|
4619
|
-
s0 = peg$
|
|
4819
|
+
s0 = peg$f63(s3, s5);
|
|
4620
4820
|
} else {
|
|
4621
4821
|
peg$currPos = s0;
|
|
4622
4822
|
s0 = peg$FAILED;
|
|
@@ -4626,13 +4826,13 @@ function peg$parse(input, options) {
|
|
|
4626
4826
|
function peg$parseTooltip() {
|
|
4627
4827
|
let s0, s1, s2, s3, s4, s5;
|
|
4628
4828
|
s0 = peg$currPos;
|
|
4629
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
4630
|
-
s1 = peg$
|
|
4829
|
+
if (input.substr(peg$currPos, 7) === peg$c60) {
|
|
4830
|
+
s1 = peg$c60;
|
|
4631
4831
|
peg$currPos += 7;
|
|
4632
4832
|
} else {
|
|
4633
4833
|
s1 = peg$FAILED;
|
|
4634
4834
|
if (peg$silentFails === 0) {
|
|
4635
|
-
peg$fail(peg$
|
|
4835
|
+
peg$fail(peg$e63);
|
|
4636
4836
|
}
|
|
4637
4837
|
}
|
|
4638
4838
|
if (s1 !== peg$FAILED) {
|
|
@@ -4645,7 +4845,7 @@ function peg$parse(input, options) {
|
|
|
4645
4845
|
s5 = null;
|
|
4646
4846
|
}
|
|
4647
4847
|
peg$savedPos = s0;
|
|
4648
|
-
s0 = peg$
|
|
4848
|
+
s0 = peg$f64(s3, s5);
|
|
4649
4849
|
} else {
|
|
4650
4850
|
peg$currPos = s0;
|
|
4651
4851
|
s0 = peg$FAILED;
|
|
@@ -4659,13 +4859,13 @@ function peg$parse(input, options) {
|
|
|
4659
4859
|
function peg$parsePopover() {
|
|
4660
4860
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
|
|
4661
4861
|
s0 = peg$currPos;
|
|
4662
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
4663
|
-
s1 = peg$
|
|
4862
|
+
if (input.substr(peg$currPos, 7) === peg$c61) {
|
|
4863
|
+
s1 = peg$c61;
|
|
4664
4864
|
peg$currPos += 7;
|
|
4665
4865
|
} else {
|
|
4666
4866
|
s1 = peg$FAILED;
|
|
4667
4867
|
if (peg$silentFails === 0) {
|
|
4668
|
-
peg$fail(peg$
|
|
4868
|
+
peg$fail(peg$e64);
|
|
4669
4869
|
}
|
|
4670
4870
|
}
|
|
4671
4871
|
if (s1 !== peg$FAILED) {
|
|
@@ -4705,7 +4905,7 @@ function peg$parse(input, options) {
|
|
|
4705
4905
|
}
|
|
4706
4906
|
if (s11 !== peg$FAILED) {
|
|
4707
4907
|
peg$savedPos = s0;
|
|
4708
|
-
s0 = peg$
|
|
4908
|
+
s0 = peg$f65(s3, s5, s9);
|
|
4709
4909
|
} else {
|
|
4710
4910
|
peg$currPos = s0;
|
|
4711
4911
|
s0 = peg$FAILED;
|
|
@@ -4727,13 +4927,13 @@ function peg$parse(input, options) {
|
|
|
4727
4927
|
function peg$parseDropdown() {
|
|
4728
4928
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
4729
4929
|
s0 = peg$currPos;
|
|
4730
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
4731
|
-
s1 = peg$
|
|
4930
|
+
if (input.substr(peg$currPos, 8) === peg$c62) {
|
|
4931
|
+
s1 = peg$c62;
|
|
4732
4932
|
peg$currPos += 8;
|
|
4733
4933
|
} else {
|
|
4734
4934
|
s1 = peg$FAILED;
|
|
4735
4935
|
if (peg$silentFails === 0) {
|
|
4736
|
-
peg$fail(peg$
|
|
4936
|
+
peg$fail(peg$e65);
|
|
4737
4937
|
}
|
|
4738
4938
|
}
|
|
4739
4939
|
if (s1 !== peg$FAILED) {
|
|
@@ -4746,7 +4946,7 @@ function peg$parse(input, options) {
|
|
|
4746
4946
|
s5 = null;
|
|
4747
4947
|
}
|
|
4748
4948
|
peg$savedPos = s0;
|
|
4749
|
-
s0 = peg$
|
|
4949
|
+
s0 = peg$f66(s3, s5);
|
|
4750
4950
|
} else {
|
|
4751
4951
|
peg$currPos = s0;
|
|
4752
4952
|
s0 = peg$FAILED;
|
|
@@ -4757,13 +4957,13 @@ function peg$parse(input, options) {
|
|
|
4757
4957
|
}
|
|
4758
4958
|
if (s0 === peg$FAILED) {
|
|
4759
4959
|
s0 = peg$currPos;
|
|
4760
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
4761
|
-
s1 = peg$
|
|
4960
|
+
if (input.substr(peg$currPos, 8) === peg$c62) {
|
|
4961
|
+
s1 = peg$c62;
|
|
4762
4962
|
peg$currPos += 8;
|
|
4763
4963
|
} else {
|
|
4764
4964
|
s1 = peg$FAILED;
|
|
4765
4965
|
if (peg$silentFails === 0) {
|
|
4766
|
-
peg$fail(peg$
|
|
4966
|
+
peg$fail(peg$e65);
|
|
4767
4967
|
}
|
|
4768
4968
|
}
|
|
4769
4969
|
if (s1 !== peg$FAILED) {
|
|
@@ -4797,7 +4997,7 @@ function peg$parse(input, options) {
|
|
|
4797
4997
|
}
|
|
4798
4998
|
if (s9 !== peg$FAILED) {
|
|
4799
4999
|
peg$savedPos = s0;
|
|
4800
|
-
s0 = peg$
|
|
5000
|
+
s0 = peg$f67(s3, s7);
|
|
4801
5001
|
} else {
|
|
4802
5002
|
peg$currPos = s0;
|
|
4803
5003
|
s0 = peg$FAILED;
|
|
@@ -4841,20 +5041,20 @@ function peg$parse(input, options) {
|
|
|
4841
5041
|
}
|
|
4842
5042
|
}
|
|
4843
5043
|
peg$savedPos = s0;
|
|
4844
|
-
s1 = peg$
|
|
5044
|
+
s1 = peg$f68(s1);
|
|
4845
5045
|
s0 = s1;
|
|
4846
5046
|
return s0;
|
|
4847
5047
|
}
|
|
4848
5048
|
function peg$parseDropdownItem() {
|
|
4849
5049
|
let s0, s1, s2, s3, s4, s5;
|
|
4850
5050
|
s0 = peg$currPos;
|
|
4851
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
4852
|
-
s1 = peg$
|
|
5051
|
+
if (input.substr(peg$currPos, 4) === peg$c55) {
|
|
5052
|
+
s1 = peg$c55;
|
|
4853
5053
|
peg$currPos += 4;
|
|
4854
5054
|
} else {
|
|
4855
5055
|
s1 = peg$FAILED;
|
|
4856
5056
|
if (peg$silentFails === 0) {
|
|
4857
|
-
peg$fail(peg$
|
|
5057
|
+
peg$fail(peg$e58);
|
|
4858
5058
|
}
|
|
4859
5059
|
}
|
|
4860
5060
|
if (s1 !== peg$FAILED) {
|
|
@@ -4867,7 +5067,7 @@ function peg$parse(input, options) {
|
|
|
4867
5067
|
s5 = null;
|
|
4868
5068
|
}
|
|
4869
5069
|
peg$savedPos = s0;
|
|
4870
|
-
s0 = peg$
|
|
5070
|
+
s0 = peg$f69(s3, s5);
|
|
4871
5071
|
} else {
|
|
4872
5072
|
peg$currPos = s0;
|
|
4873
5073
|
s0 = peg$FAILED;
|
|
@@ -4878,18 +5078,18 @@ function peg$parse(input, options) {
|
|
|
4878
5078
|
}
|
|
4879
5079
|
if (s0 === peg$FAILED) {
|
|
4880
5080
|
s0 = peg$currPos;
|
|
4881
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
4882
|
-
s1 = peg$
|
|
5081
|
+
if (input.substr(peg$currPos, 7) === peg$c63) {
|
|
5082
|
+
s1 = peg$c63;
|
|
4883
5083
|
peg$currPos += 7;
|
|
4884
5084
|
} else {
|
|
4885
5085
|
s1 = peg$FAILED;
|
|
4886
5086
|
if (peg$silentFails === 0) {
|
|
4887
|
-
peg$fail(peg$
|
|
5087
|
+
peg$fail(peg$e66);
|
|
4888
5088
|
}
|
|
4889
5089
|
}
|
|
4890
5090
|
if (s1 !== peg$FAILED) {
|
|
4891
5091
|
peg$savedPos = s0;
|
|
4892
|
-
s1 = peg$
|
|
5092
|
+
s1 = peg$f70();
|
|
4893
5093
|
}
|
|
4894
5094
|
s0 = s1;
|
|
4895
5095
|
if (s0 === peg$FAILED) {
|
|
@@ -4897,7 +5097,7 @@ function peg$parse(input, options) {
|
|
|
4897
5097
|
s1 = peg$parseComment();
|
|
4898
5098
|
if (s1 !== peg$FAILED) {
|
|
4899
5099
|
peg$savedPos = s0;
|
|
4900
|
-
s1 = peg$
|
|
5100
|
+
s1 = peg$f71();
|
|
4901
5101
|
}
|
|
4902
5102
|
s0 = s1;
|
|
4903
5103
|
}
|
|
@@ -4907,13 +5107,13 @@ function peg$parse(input, options) {
|
|
|
4907
5107
|
function peg$parseNav() {
|
|
4908
5108
|
let s0, s1, s2, s3, s4, s5, s6, s7;
|
|
4909
5109
|
s0 = peg$currPos;
|
|
4910
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
4911
|
-
s1 = peg$
|
|
5110
|
+
if (input.substr(peg$currPos, 3) === peg$c64) {
|
|
5111
|
+
s1 = peg$c64;
|
|
4912
5112
|
peg$currPos += 3;
|
|
4913
5113
|
} else {
|
|
4914
5114
|
s1 = peg$FAILED;
|
|
4915
5115
|
if (peg$silentFails === 0) {
|
|
4916
|
-
peg$fail(peg$
|
|
5116
|
+
peg$fail(peg$e67);
|
|
4917
5117
|
}
|
|
4918
5118
|
}
|
|
4919
5119
|
if (s1 !== peg$FAILED) {
|
|
@@ -4933,7 +5133,7 @@ function peg$parse(input, options) {
|
|
|
4933
5133
|
s7 = null;
|
|
4934
5134
|
}
|
|
4935
5135
|
peg$savedPos = s0;
|
|
4936
|
-
s0 = peg$
|
|
5136
|
+
s0 = peg$f72(s3, s5, s7);
|
|
4937
5137
|
} else {
|
|
4938
5138
|
peg$currPos = s0;
|
|
4939
5139
|
s0 = peg$FAILED;
|
|
@@ -4989,7 +5189,7 @@ function peg$parse(input, options) {
|
|
|
4989
5189
|
}
|
|
4990
5190
|
if (s4 !== peg$FAILED) {
|
|
4991
5191
|
peg$savedPos = s0;
|
|
4992
|
-
s0 = peg$
|
|
5192
|
+
s0 = peg$f73(s3);
|
|
4993
5193
|
} else {
|
|
4994
5194
|
peg$currPos = s0;
|
|
4995
5195
|
s0 = peg$FAILED;
|
|
@@ -5007,19 +5207,19 @@ function peg$parse(input, options) {
|
|
|
5007
5207
|
s0 = peg$parseNavItem();
|
|
5008
5208
|
if (s0 === peg$FAILED) {
|
|
5009
5209
|
s0 = peg$currPos;
|
|
5010
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
5011
|
-
s1 = peg$
|
|
5210
|
+
if (input.substr(peg$currPos, 7) === peg$c63) {
|
|
5211
|
+
s1 = peg$c63;
|
|
5012
5212
|
peg$currPos += 7;
|
|
5013
5213
|
} else {
|
|
5014
5214
|
s1 = peg$FAILED;
|
|
5015
5215
|
if (peg$silentFails === 0) {
|
|
5016
|
-
peg$fail(peg$
|
|
5216
|
+
peg$fail(peg$e66);
|
|
5017
5217
|
}
|
|
5018
5218
|
}
|
|
5019
5219
|
if (s1 !== peg$FAILED) {
|
|
5020
5220
|
s2 = peg$parse_();
|
|
5021
5221
|
peg$savedPos = s0;
|
|
5022
|
-
s0 = peg$
|
|
5222
|
+
s0 = peg$f74();
|
|
5023
5223
|
} else {
|
|
5024
5224
|
peg$currPos = s0;
|
|
5025
5225
|
s0 = peg$FAILED;
|
|
@@ -5029,7 +5229,7 @@ function peg$parse(input, options) {
|
|
|
5029
5229
|
s1 = peg$parseComment();
|
|
5030
5230
|
if (s1 !== peg$FAILED) {
|
|
5031
5231
|
peg$savedPos = s0;
|
|
5032
|
-
s1 = peg$
|
|
5232
|
+
s1 = peg$f75();
|
|
5033
5233
|
}
|
|
5034
5234
|
s0 = s1;
|
|
5035
5235
|
}
|
|
@@ -5040,13 +5240,13 @@ function peg$parse(input, options) {
|
|
|
5040
5240
|
function peg$parseNavGroup() {
|
|
5041
5241
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
|
|
5042
5242
|
s0 = peg$currPos;
|
|
5043
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
5044
|
-
s1 = peg$
|
|
5243
|
+
if (input.substr(peg$currPos, 5) === peg$c65) {
|
|
5244
|
+
s1 = peg$c65;
|
|
5045
5245
|
peg$currPos += 5;
|
|
5046
5246
|
} else {
|
|
5047
5247
|
s1 = peg$FAILED;
|
|
5048
5248
|
if (peg$silentFails === 0) {
|
|
5049
|
-
peg$fail(peg$
|
|
5249
|
+
peg$fail(peg$e68);
|
|
5050
5250
|
}
|
|
5051
5251
|
}
|
|
5052
5252
|
if (s1 !== peg$FAILED) {
|
|
@@ -5105,7 +5305,7 @@ function peg$parse(input, options) {
|
|
|
5105
5305
|
}
|
|
5106
5306
|
if (s10 !== peg$FAILED) {
|
|
5107
5307
|
peg$savedPos = s0;
|
|
5108
|
-
s0 = peg$
|
|
5308
|
+
s0 = peg$f76(s3, s5, s9);
|
|
5109
5309
|
} else {
|
|
5110
5310
|
peg$currPos = s0;
|
|
5111
5311
|
s0 = peg$FAILED;
|
|
@@ -5129,19 +5329,19 @@ function peg$parse(input, options) {
|
|
|
5129
5329
|
s0 = peg$parseNavItem();
|
|
5130
5330
|
if (s0 === peg$FAILED) {
|
|
5131
5331
|
s0 = peg$currPos;
|
|
5132
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
5133
|
-
s1 = peg$
|
|
5332
|
+
if (input.substr(peg$currPos, 7) === peg$c63) {
|
|
5333
|
+
s1 = peg$c63;
|
|
5134
5334
|
peg$currPos += 7;
|
|
5135
5335
|
} else {
|
|
5136
5336
|
s1 = peg$FAILED;
|
|
5137
5337
|
if (peg$silentFails === 0) {
|
|
5138
|
-
peg$fail(peg$
|
|
5338
|
+
peg$fail(peg$e66);
|
|
5139
5339
|
}
|
|
5140
5340
|
}
|
|
5141
5341
|
if (s1 !== peg$FAILED) {
|
|
5142
5342
|
s2 = peg$parse_();
|
|
5143
5343
|
peg$savedPos = s0;
|
|
5144
|
-
s0 = peg$
|
|
5344
|
+
s0 = peg$f77();
|
|
5145
5345
|
} else {
|
|
5146
5346
|
peg$currPos = s0;
|
|
5147
5347
|
s0 = peg$FAILED;
|
|
@@ -5151,7 +5351,7 @@ function peg$parse(input, options) {
|
|
|
5151
5351
|
s1 = peg$parseComment();
|
|
5152
5352
|
if (s1 !== peg$FAILED) {
|
|
5153
5353
|
peg$savedPos = s0;
|
|
5154
|
-
s1 = peg$
|
|
5354
|
+
s1 = peg$f78();
|
|
5155
5355
|
}
|
|
5156
5356
|
s0 = s1;
|
|
5157
5357
|
}
|
|
@@ -5161,13 +5361,13 @@ function peg$parse(input, options) {
|
|
|
5161
5361
|
function peg$parseNavItem() {
|
|
5162
5362
|
let s0, s1, s2, s3, s4, s5;
|
|
5163
5363
|
s0 = peg$currPos;
|
|
5164
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
5165
|
-
s1 = peg$
|
|
5364
|
+
if (input.substr(peg$currPos, 4) === peg$c55) {
|
|
5365
|
+
s1 = peg$c55;
|
|
5166
5366
|
peg$currPos += 4;
|
|
5167
5367
|
} else {
|
|
5168
5368
|
s1 = peg$FAILED;
|
|
5169
5369
|
if (peg$silentFails === 0) {
|
|
5170
|
-
peg$fail(peg$
|
|
5370
|
+
peg$fail(peg$e58);
|
|
5171
5371
|
}
|
|
5172
5372
|
}
|
|
5173
5373
|
if (s1 !== peg$FAILED) {
|
|
@@ -5180,7 +5380,7 @@ function peg$parse(input, options) {
|
|
|
5180
5380
|
s5 = null;
|
|
5181
5381
|
}
|
|
5182
5382
|
peg$savedPos = s0;
|
|
5183
|
-
s0 = peg$
|
|
5383
|
+
s0 = peg$f79(s3, s5);
|
|
5184
5384
|
} else {
|
|
5185
5385
|
peg$currPos = s0;
|
|
5186
5386
|
s0 = peg$FAILED;
|
|
@@ -5194,13 +5394,13 @@ function peg$parse(input, options) {
|
|
|
5194
5394
|
function peg$parseTabs() {
|
|
5195
5395
|
let s0, s1, s2, s3, s4, s5, s6, s7;
|
|
5196
5396
|
s0 = peg$currPos;
|
|
5197
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
5198
|
-
s1 = peg$
|
|
5397
|
+
if (input.substr(peg$currPos, 4) === peg$c66) {
|
|
5398
|
+
s1 = peg$c66;
|
|
5199
5399
|
peg$currPos += 4;
|
|
5200
5400
|
} else {
|
|
5201
5401
|
s1 = peg$FAILED;
|
|
5202
5402
|
if (peg$silentFails === 0) {
|
|
5203
|
-
peg$fail(peg$
|
|
5403
|
+
peg$fail(peg$e69);
|
|
5204
5404
|
}
|
|
5205
5405
|
}
|
|
5206
5406
|
if (s1 !== peg$FAILED) {
|
|
@@ -5220,7 +5420,7 @@ function peg$parse(input, options) {
|
|
|
5220
5420
|
s7 = null;
|
|
5221
5421
|
}
|
|
5222
5422
|
peg$savedPos = s0;
|
|
5223
|
-
s0 = peg$
|
|
5423
|
+
s0 = peg$f80(s3, s5, s7);
|
|
5224
5424
|
} else {
|
|
5225
5425
|
peg$currPos = s0;
|
|
5226
5426
|
s0 = peg$FAILED;
|
|
@@ -5276,7 +5476,7 @@ function peg$parse(input, options) {
|
|
|
5276
5476
|
}
|
|
5277
5477
|
if (s4 !== peg$FAILED) {
|
|
5278
5478
|
peg$savedPos = s0;
|
|
5279
|
-
s0 = peg$
|
|
5479
|
+
s0 = peg$f81(s3);
|
|
5280
5480
|
} else {
|
|
5281
5481
|
peg$currPos = s0;
|
|
5282
5482
|
s0 = peg$FAILED;
|
|
@@ -5290,13 +5490,13 @@ function peg$parse(input, options) {
|
|
|
5290
5490
|
function peg$parseTabItem() {
|
|
5291
5491
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
|
|
5292
5492
|
s0 = peg$currPos;
|
|
5293
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
5294
|
-
s1 = peg$
|
|
5493
|
+
if (input.substr(peg$currPos, 3) === peg$c67) {
|
|
5494
|
+
s1 = peg$c67;
|
|
5295
5495
|
peg$currPos += 3;
|
|
5296
5496
|
} else {
|
|
5297
5497
|
s1 = peg$FAILED;
|
|
5298
5498
|
if (peg$silentFails === 0) {
|
|
5299
|
-
peg$fail(peg$
|
|
5499
|
+
peg$fail(peg$e70);
|
|
5300
5500
|
}
|
|
5301
5501
|
}
|
|
5302
5502
|
if (s1 !== peg$FAILED) {
|
|
@@ -5334,7 +5534,7 @@ function peg$parse(input, options) {
|
|
|
5334
5534
|
}
|
|
5335
5535
|
if (s11 !== peg$FAILED) {
|
|
5336
5536
|
peg$savedPos = s0;
|
|
5337
|
-
s0 = peg$
|
|
5537
|
+
s0 = peg$f82(s3, s5, s9);
|
|
5338
5538
|
} else {
|
|
5339
5539
|
peg$currPos = s0;
|
|
5340
5540
|
s0 = peg$FAILED;
|
|
@@ -5360,7 +5560,7 @@ function peg$parse(input, options) {
|
|
|
5360
5560
|
s1 = peg$parseComment();
|
|
5361
5561
|
if (s1 !== peg$FAILED) {
|
|
5362
5562
|
peg$savedPos = s0;
|
|
5363
|
-
s1 = peg$
|
|
5563
|
+
s1 = peg$f83();
|
|
5364
5564
|
}
|
|
5365
5565
|
s0 = s1;
|
|
5366
5566
|
}
|
|
@@ -5369,13 +5569,13 @@ function peg$parse(input, options) {
|
|
|
5369
5569
|
function peg$parseBreadcrumb() {
|
|
5370
5570
|
let s0, s1, s2, s3, s4, s5;
|
|
5371
5571
|
s0 = peg$currPos;
|
|
5372
|
-
if (input.substr(peg$currPos, 10) === peg$
|
|
5373
|
-
s1 = peg$
|
|
5572
|
+
if (input.substr(peg$currPos, 10) === peg$c68) {
|
|
5573
|
+
s1 = peg$c68;
|
|
5374
5574
|
peg$currPos += 10;
|
|
5375
5575
|
} else {
|
|
5376
5576
|
s1 = peg$FAILED;
|
|
5377
5577
|
if (peg$silentFails === 0) {
|
|
5378
|
-
peg$fail(peg$
|
|
5578
|
+
peg$fail(peg$e71);
|
|
5379
5579
|
}
|
|
5380
5580
|
}
|
|
5381
5581
|
if (s1 !== peg$FAILED) {
|
|
@@ -5388,7 +5588,7 @@ function peg$parse(input, options) {
|
|
|
5388
5588
|
s5 = null;
|
|
5389
5589
|
}
|
|
5390
5590
|
peg$savedPos = s0;
|
|
5391
|
-
s0 = peg$
|
|
5591
|
+
s0 = peg$f84(s3, s5);
|
|
5392
5592
|
} else {
|
|
5393
5593
|
peg$currPos = s0;
|
|
5394
5594
|
s0 = peg$FAILED;
|
|
@@ -5402,13 +5602,13 @@ function peg$parse(input, options) {
|
|
|
5402
5602
|
function peg$parseDivider() {
|
|
5403
5603
|
let s0, s1, s2, s3;
|
|
5404
5604
|
s0 = peg$currPos;
|
|
5405
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
5406
|
-
s1 = peg$
|
|
5605
|
+
if (input.substr(peg$currPos, 7) === peg$c63) {
|
|
5606
|
+
s1 = peg$c63;
|
|
5407
5607
|
peg$currPos += 7;
|
|
5408
5608
|
} else {
|
|
5409
5609
|
s1 = peg$FAILED;
|
|
5410
5610
|
if (peg$silentFails === 0) {
|
|
5411
|
-
peg$fail(peg$
|
|
5611
|
+
peg$fail(peg$e66);
|
|
5412
5612
|
}
|
|
5413
5613
|
}
|
|
5414
5614
|
if (s1 !== peg$FAILED) {
|
|
@@ -5418,7 +5618,7 @@ function peg$parse(input, options) {
|
|
|
5418
5618
|
s3 = null;
|
|
5419
5619
|
}
|
|
5420
5620
|
peg$savedPos = s0;
|
|
5421
|
-
s0 = peg$
|
|
5621
|
+
s0 = peg$f85(s3);
|
|
5422
5622
|
} else {
|
|
5423
5623
|
peg$currPos = s0;
|
|
5424
5624
|
s0 = peg$FAILED;
|
|
@@ -5428,13 +5628,13 @@ function peg$parse(input, options) {
|
|
|
5428
5628
|
function peg$parseMarker() {
|
|
5429
5629
|
let s0, s1, s2, s3, s4, s5;
|
|
5430
5630
|
s0 = peg$currPos;
|
|
5431
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
5432
|
-
s1 = peg$
|
|
5631
|
+
if (input.substr(peg$currPos, 6) === peg$c69) {
|
|
5632
|
+
s1 = peg$c69;
|
|
5433
5633
|
peg$currPos += 6;
|
|
5434
5634
|
} else {
|
|
5435
5635
|
s1 = peg$FAILED;
|
|
5436
5636
|
if (peg$silentFails === 0) {
|
|
5437
|
-
peg$fail(peg$
|
|
5637
|
+
peg$fail(peg$e72);
|
|
5438
5638
|
}
|
|
5439
5639
|
}
|
|
5440
5640
|
if (s1 !== peg$FAILED) {
|
|
@@ -5447,7 +5647,7 @@ function peg$parse(input, options) {
|
|
|
5447
5647
|
s5 = null;
|
|
5448
5648
|
}
|
|
5449
5649
|
peg$savedPos = s0;
|
|
5450
|
-
s0 = peg$
|
|
5650
|
+
s0 = peg$f86(s3, s5);
|
|
5451
5651
|
} else {
|
|
5452
5652
|
peg$currPos = s0;
|
|
5453
5653
|
s0 = peg$FAILED;
|
|
@@ -5461,13 +5661,13 @@ function peg$parse(input, options) {
|
|
|
5461
5661
|
function peg$parseAnnotations() {
|
|
5462
5662
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
|
|
5463
5663
|
s0 = peg$currPos;
|
|
5464
|
-
if (input.substr(peg$currPos, 11) === peg$
|
|
5465
|
-
s1 = peg$
|
|
5664
|
+
if (input.substr(peg$currPos, 11) === peg$c70) {
|
|
5665
|
+
s1 = peg$c70;
|
|
5466
5666
|
peg$currPos += 11;
|
|
5467
5667
|
} else {
|
|
5468
5668
|
s1 = peg$FAILED;
|
|
5469
5669
|
if (peg$silentFails === 0) {
|
|
5470
|
-
peg$fail(peg$
|
|
5670
|
+
peg$fail(peg$e73);
|
|
5471
5671
|
}
|
|
5472
5672
|
}
|
|
5473
5673
|
if (s1 !== peg$FAILED) {
|
|
@@ -5501,7 +5701,7 @@ function peg$parse(input, options) {
|
|
|
5501
5701
|
}
|
|
5502
5702
|
if (s9 !== peg$FAILED) {
|
|
5503
5703
|
peg$savedPos = s0;
|
|
5504
|
-
s0 = peg$
|
|
5704
|
+
s0 = peg$f87(s3, s7);
|
|
5505
5705
|
} else {
|
|
5506
5706
|
peg$currPos = s0;
|
|
5507
5707
|
s0 = peg$FAILED;
|
|
@@ -5544,20 +5744,20 @@ function peg$parse(input, options) {
|
|
|
5544
5744
|
}
|
|
5545
5745
|
}
|
|
5546
5746
|
peg$savedPos = s0;
|
|
5547
|
-
s1 = peg$
|
|
5747
|
+
s1 = peg$f88(s1);
|
|
5548
5748
|
s0 = s1;
|
|
5549
5749
|
return s0;
|
|
5550
5750
|
}
|
|
5551
5751
|
function peg$parseAnnotationItem() {
|
|
5552
5752
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
|
|
5553
5753
|
s0 = peg$currPos;
|
|
5554
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
5555
|
-
s1 = peg$
|
|
5754
|
+
if (input.substr(peg$currPos, 4) === peg$c55) {
|
|
5755
|
+
s1 = peg$c55;
|
|
5556
5756
|
peg$currPos += 4;
|
|
5557
5757
|
} else {
|
|
5558
5758
|
s1 = peg$FAILED;
|
|
5559
5759
|
if (peg$silentFails === 0) {
|
|
5560
|
-
peg$fail(peg$
|
|
5760
|
+
peg$fail(peg$e58);
|
|
5561
5761
|
}
|
|
5562
5762
|
}
|
|
5563
5763
|
if (s1 !== peg$FAILED) {
|
|
@@ -5598,7 +5798,7 @@ function peg$parse(input, options) {
|
|
|
5598
5798
|
}
|
|
5599
5799
|
if (s13 !== peg$FAILED) {
|
|
5600
5800
|
peg$savedPos = s0;
|
|
5601
|
-
s0 = peg$
|
|
5801
|
+
s0 = peg$f89(s3, s5, s7, s11);
|
|
5602
5802
|
} else {
|
|
5603
5803
|
peg$currPos = s0;
|
|
5604
5804
|
s0 = peg$FAILED;
|
|
@@ -5625,13 +5825,13 @@ function peg$parse(input, options) {
|
|
|
5625
5825
|
}
|
|
5626
5826
|
if (s0 === peg$FAILED) {
|
|
5627
5827
|
s0 = peg$currPos;
|
|
5628
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
5629
|
-
s1 = peg$
|
|
5828
|
+
if (input.substr(peg$currPos, 4) === peg$c55) {
|
|
5829
|
+
s1 = peg$c55;
|
|
5630
5830
|
peg$currPos += 4;
|
|
5631
5831
|
} else {
|
|
5632
5832
|
s1 = peg$FAILED;
|
|
5633
5833
|
if (peg$silentFails === 0) {
|
|
5634
|
-
peg$fail(peg$
|
|
5834
|
+
peg$fail(peg$e58);
|
|
5635
5835
|
}
|
|
5636
5836
|
}
|
|
5637
5837
|
if (s1 !== peg$FAILED) {
|
|
@@ -5647,7 +5847,7 @@ function peg$parse(input, options) {
|
|
|
5647
5847
|
s7 = null;
|
|
5648
5848
|
}
|
|
5649
5849
|
peg$savedPos = s0;
|
|
5650
|
-
s0 = peg$
|
|
5850
|
+
s0 = peg$f90(s3, s5, s7);
|
|
5651
5851
|
} else {
|
|
5652
5852
|
peg$currPos = s0;
|
|
5653
5853
|
s0 = peg$FAILED;
|
|
@@ -5665,7 +5865,7 @@ function peg$parse(input, options) {
|
|
|
5665
5865
|
s1 = peg$parseComment();
|
|
5666
5866
|
if (s1 !== peg$FAILED) {
|
|
5667
5867
|
peg$savedPos = s0;
|
|
5668
|
-
s1 = peg$
|
|
5868
|
+
s1 = peg$f91();
|
|
5669
5869
|
}
|
|
5670
5870
|
s0 = s1;
|
|
5671
5871
|
}
|
|
@@ -5683,7 +5883,7 @@ function peg$parse(input, options) {
|
|
|
5683
5883
|
} else {
|
|
5684
5884
|
s2 = peg$FAILED;
|
|
5685
5885
|
if (peg$silentFails === 0) {
|
|
5686
|
-
peg$fail(peg$
|
|
5886
|
+
peg$fail(peg$e75);
|
|
5687
5887
|
}
|
|
5688
5888
|
}
|
|
5689
5889
|
if (s2 !== peg$FAILED) {
|
|
@@ -5695,7 +5895,7 @@ function peg$parse(input, options) {
|
|
|
5695
5895
|
} else {
|
|
5696
5896
|
s2 = peg$FAILED;
|
|
5697
5897
|
if (peg$silentFails === 0) {
|
|
5698
|
-
peg$fail(peg$
|
|
5898
|
+
peg$fail(peg$e75);
|
|
5699
5899
|
}
|
|
5700
5900
|
}
|
|
5701
5901
|
}
|
|
@@ -5704,14 +5904,14 @@ function peg$parse(input, options) {
|
|
|
5704
5904
|
}
|
|
5705
5905
|
if (s1 !== peg$FAILED) {
|
|
5706
5906
|
peg$savedPos = s0;
|
|
5707
|
-
s1 = peg$
|
|
5907
|
+
s1 = peg$f92(s1);
|
|
5708
5908
|
}
|
|
5709
5909
|
s0 = s1;
|
|
5710
5910
|
peg$silentFails--;
|
|
5711
5911
|
if (s0 === peg$FAILED) {
|
|
5712
5912
|
s1 = peg$FAILED;
|
|
5713
5913
|
if (peg$silentFails === 0) {
|
|
5714
|
-
peg$fail(peg$
|
|
5914
|
+
peg$fail(peg$e74);
|
|
5715
5915
|
}
|
|
5716
5916
|
}
|
|
5717
5917
|
return s0;
|
|
@@ -5731,7 +5931,7 @@ function peg$parse(input, options) {
|
|
|
5731
5931
|
}
|
|
5732
5932
|
if (s1 !== peg$FAILED) {
|
|
5733
5933
|
peg$savedPos = s0;
|
|
5734
|
-
s1 = peg$
|
|
5934
|
+
s1 = peg$f93(s1);
|
|
5735
5935
|
}
|
|
5736
5936
|
s0 = s1;
|
|
5737
5937
|
return s0;
|
|
@@ -5740,13 +5940,13 @@ function peg$parse(input, options) {
|
|
|
5740
5940
|
let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
|
|
5741
5941
|
s0 = peg$currPos;
|
|
5742
5942
|
s1 = peg$parse_();
|
|
5743
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
5744
|
-
s2 = peg$
|
|
5943
|
+
if (input.substr(peg$currPos, 2) === peg$c71) {
|
|
5944
|
+
s2 = peg$c71;
|
|
5745
5945
|
peg$currPos += 2;
|
|
5746
5946
|
} else {
|
|
5747
5947
|
s2 = peg$FAILED;
|
|
5748
5948
|
if (peg$silentFails === 0) {
|
|
5749
|
-
peg$fail(peg$
|
|
5949
|
+
peg$fail(peg$e76);
|
|
5750
5950
|
}
|
|
5751
5951
|
}
|
|
5752
5952
|
if (s2 !== peg$FAILED) {
|
|
@@ -5801,7 +6001,7 @@ function peg$parse(input, options) {
|
|
|
5801
6001
|
}
|
|
5802
6002
|
if (s13 !== peg$FAILED) {
|
|
5803
6003
|
peg$savedPos = s0;
|
|
5804
|
-
s0 = peg$
|
|
6004
|
+
s0 = peg$f94(s7, s11);
|
|
5805
6005
|
} else {
|
|
5806
6006
|
peg$currPos = s0;
|
|
5807
6007
|
s0 = peg$FAILED;
|
|
@@ -5850,7 +6050,7 @@ function peg$parse(input, options) {
|
|
|
5850
6050
|
s6 = peg$parseAttributeValue();
|
|
5851
6051
|
if (s6 !== peg$FAILED) {
|
|
5852
6052
|
peg$savedPos = s0;
|
|
5853
|
-
s0 = peg$
|
|
6053
|
+
s0 = peg$f95(s2, s6);
|
|
5854
6054
|
} else {
|
|
5855
6055
|
peg$currPos = s0;
|
|
5856
6056
|
s0 = peg$FAILED;
|
|
@@ -5882,7 +6082,7 @@ function peg$parse(input, options) {
|
|
|
5882
6082
|
} else {
|
|
5883
6083
|
s6 = peg$FAILED;
|
|
5884
6084
|
if (peg$silentFails === 0) {
|
|
5885
|
-
peg$fail(peg$
|
|
6085
|
+
peg$fail(peg$e77);
|
|
5886
6086
|
}
|
|
5887
6087
|
}
|
|
5888
6088
|
if (s6 === peg$FAILED) {
|
|
@@ -5945,7 +6145,7 @@ function peg$parse(input, options) {
|
|
|
5945
6145
|
}
|
|
5946
6146
|
if (s3 !== peg$FAILED) {
|
|
5947
6147
|
peg$savedPos = s0;
|
|
5948
|
-
s0 = peg$
|
|
6148
|
+
s0 = peg$f96(s2);
|
|
5949
6149
|
} else {
|
|
5950
6150
|
peg$currPos = s0;
|
|
5951
6151
|
s0 = peg$FAILED;
|
|
@@ -5975,7 +6175,7 @@ function peg$parse(input, options) {
|
|
|
5975
6175
|
s2 = peg$parseIdentifier();
|
|
5976
6176
|
if (s2 !== peg$FAILED) {
|
|
5977
6177
|
peg$savedPos = s0;
|
|
5978
|
-
s0 = peg$
|
|
6178
|
+
s0 = peg$f97(s2);
|
|
5979
6179
|
} else {
|
|
5980
6180
|
peg$currPos = s0;
|
|
5981
6181
|
s0 = peg$FAILED;
|
|
@@ -5999,503 +6199,514 @@ function peg$parse(input, options) {
|
|
|
5999
6199
|
}
|
|
6000
6200
|
}
|
|
6001
6201
|
if (s1 === peg$FAILED) {
|
|
6002
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6003
|
-
s1 = peg$
|
|
6202
|
+
if (input.substr(peg$currPos, 6) === peg$c21) {
|
|
6203
|
+
s1 = peg$c21;
|
|
6004
6204
|
peg$currPos += 6;
|
|
6005
6205
|
} else {
|
|
6006
6206
|
s1 = peg$FAILED;
|
|
6007
6207
|
if (peg$silentFails === 0) {
|
|
6008
|
-
peg$fail(peg$
|
|
6208
|
+
peg$fail(peg$e24);
|
|
6009
6209
|
}
|
|
6010
6210
|
}
|
|
6011
6211
|
if (s1 === peg$FAILED) {
|
|
6012
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6013
|
-
s1 = peg$
|
|
6212
|
+
if (input.substr(peg$currPos, 4) === peg$c22) {
|
|
6213
|
+
s1 = peg$c22;
|
|
6014
6214
|
peg$currPos += 4;
|
|
6015
6215
|
} else {
|
|
6016
6216
|
s1 = peg$FAILED;
|
|
6017
6217
|
if (peg$silentFails === 0) {
|
|
6018
|
-
peg$fail(peg$
|
|
6218
|
+
peg$fail(peg$e25);
|
|
6019
6219
|
}
|
|
6020
6220
|
}
|
|
6021
6221
|
if (s1 === peg$FAILED) {
|
|
6022
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6023
|
-
s1 = peg$
|
|
6222
|
+
if (input.substr(peg$currPos, 6) === peg$c23) {
|
|
6223
|
+
s1 = peg$c23;
|
|
6024
6224
|
peg$currPos += 6;
|
|
6025
6225
|
} else {
|
|
6026
6226
|
s1 = peg$FAILED;
|
|
6027
6227
|
if (peg$silentFails === 0) {
|
|
6028
|
-
peg$fail(peg$
|
|
6228
|
+
peg$fail(peg$e26);
|
|
6029
6229
|
}
|
|
6030
6230
|
}
|
|
6031
6231
|
if (s1 === peg$FAILED) {
|
|
6032
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
6033
|
-
s1 = peg$
|
|
6232
|
+
if (input.substr(peg$currPos, 7) === peg$c24) {
|
|
6233
|
+
s1 = peg$c24;
|
|
6034
6234
|
peg$currPos += 7;
|
|
6035
6235
|
} else {
|
|
6036
6236
|
s1 = peg$FAILED;
|
|
6037
6237
|
if (peg$silentFails === 0) {
|
|
6038
|
-
peg$fail(peg$
|
|
6238
|
+
peg$fail(peg$e27);
|
|
6039
6239
|
}
|
|
6040
6240
|
}
|
|
6041
6241
|
if (s1 === peg$FAILED) {
|
|
6042
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
6043
|
-
s1 = peg$
|
|
6242
|
+
if (input.substr(peg$currPos, 3) === peg$c25) {
|
|
6243
|
+
s1 = peg$c25;
|
|
6044
6244
|
peg$currPos += 3;
|
|
6045
6245
|
} else {
|
|
6046
6246
|
s1 = peg$FAILED;
|
|
6047
6247
|
if (peg$silentFails === 0) {
|
|
6048
|
-
peg$fail(peg$
|
|
6248
|
+
peg$fail(peg$e28);
|
|
6049
6249
|
}
|
|
6050
6250
|
}
|
|
6051
6251
|
if (s1 === peg$FAILED) {
|
|
6052
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
6053
|
-
s1 = peg$
|
|
6252
|
+
if (input.substr(peg$currPos, 3) === peg$c26) {
|
|
6253
|
+
s1 = peg$c26;
|
|
6054
6254
|
peg$currPos += 3;
|
|
6055
6255
|
} else {
|
|
6056
6256
|
s1 = peg$FAILED;
|
|
6057
6257
|
if (peg$silentFails === 0) {
|
|
6058
|
-
peg$fail(peg$
|
|
6258
|
+
peg$fail(peg$e29);
|
|
6059
6259
|
}
|
|
6060
6260
|
}
|
|
6061
6261
|
if (s1 === peg$FAILED) {
|
|
6062
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6063
|
-
s1 = peg$
|
|
6262
|
+
if (input.substr(peg$currPos, 5) === peg$c27) {
|
|
6263
|
+
s1 = peg$c27;
|
|
6064
6264
|
peg$currPos += 5;
|
|
6065
6265
|
} else {
|
|
6066
6266
|
s1 = peg$FAILED;
|
|
6067
6267
|
if (peg$silentFails === 0) {
|
|
6068
|
-
peg$fail(peg$
|
|
6268
|
+
peg$fail(peg$e30);
|
|
6069
6269
|
}
|
|
6070
6270
|
}
|
|
6071
6271
|
if (s1 === peg$FAILED) {
|
|
6072
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
6073
|
-
s1 = peg$
|
|
6272
|
+
if (input.substr(peg$currPos, 8) === peg$c28) {
|
|
6273
|
+
s1 = peg$c28;
|
|
6074
6274
|
peg$currPos += 8;
|
|
6075
6275
|
} else {
|
|
6076
6276
|
s1 = peg$FAILED;
|
|
6077
6277
|
if (peg$silentFails === 0) {
|
|
6078
|
-
peg$fail(peg$
|
|
6278
|
+
peg$fail(peg$e31);
|
|
6079
6279
|
}
|
|
6080
6280
|
}
|
|
6081
6281
|
if (s1 === peg$FAILED) {
|
|
6082
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6083
|
-
s1 = peg$
|
|
6282
|
+
if (input.substr(peg$currPos, 4) === peg$c29) {
|
|
6283
|
+
s1 = peg$c29;
|
|
6084
6284
|
peg$currPos += 4;
|
|
6085
6285
|
} else {
|
|
6086
6286
|
s1 = peg$FAILED;
|
|
6087
6287
|
if (peg$silentFails === 0) {
|
|
6088
|
-
peg$fail(peg$
|
|
6288
|
+
peg$fail(peg$e32);
|
|
6089
6289
|
}
|
|
6090
6290
|
}
|
|
6091
6291
|
if (s1 === peg$FAILED) {
|
|
6092
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6093
|
-
s1 = peg$
|
|
6292
|
+
if (input.substr(peg$currPos, 5) === peg$c30) {
|
|
6293
|
+
s1 = peg$c30;
|
|
6094
6294
|
peg$currPos += 5;
|
|
6095
6295
|
} else {
|
|
6096
6296
|
s1 = peg$FAILED;
|
|
6097
6297
|
if (peg$silentFails === 0) {
|
|
6098
|
-
peg$fail(peg$
|
|
6298
|
+
peg$fail(peg$e33);
|
|
6099
6299
|
}
|
|
6100
6300
|
}
|
|
6101
6301
|
if (s1 === peg$FAILED) {
|
|
6102
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6103
|
-
s1 = peg$
|
|
6302
|
+
if (input.substr(peg$currPos, 6) === peg$c31) {
|
|
6303
|
+
s1 = peg$c31;
|
|
6104
6304
|
peg$currPos += 6;
|
|
6105
6305
|
} else {
|
|
6106
6306
|
s1 = peg$FAILED;
|
|
6107
6307
|
if (peg$silentFails === 0) {
|
|
6108
|
-
peg$fail(peg$
|
|
6308
|
+
peg$fail(peg$e34);
|
|
6109
6309
|
}
|
|
6110
6310
|
}
|
|
6111
6311
|
if (s1 === peg$FAILED) {
|
|
6112
|
-
if (input.substr(peg$currPos, 9) === peg$
|
|
6113
|
-
s1 = peg$
|
|
6312
|
+
if (input.substr(peg$currPos, 9) === peg$c32) {
|
|
6313
|
+
s1 = peg$c32;
|
|
6114
6314
|
peg$currPos += 9;
|
|
6115
6315
|
} else {
|
|
6116
6316
|
s1 = peg$FAILED;
|
|
6117
6317
|
if (peg$silentFails === 0) {
|
|
6118
|
-
peg$fail(peg$
|
|
6318
|
+
peg$fail(peg$e35);
|
|
6119
6319
|
}
|
|
6120
6320
|
}
|
|
6121
6321
|
if (s1 === peg$FAILED) {
|
|
6122
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
6123
|
-
s1 = peg$
|
|
6322
|
+
if (input.substr(peg$currPos, 7) === peg$c33) {
|
|
6323
|
+
s1 = peg$c33;
|
|
6124
6324
|
peg$currPos += 7;
|
|
6125
6325
|
} else {
|
|
6126
6326
|
s1 = peg$FAILED;
|
|
6127
6327
|
if (peg$silentFails === 0) {
|
|
6128
|
-
peg$fail(peg$
|
|
6328
|
+
peg$fail(peg$e36);
|
|
6129
6329
|
}
|
|
6130
6330
|
}
|
|
6131
6331
|
if (s1 === peg$FAILED) {
|
|
6132
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6133
|
-
s1 = peg$
|
|
6332
|
+
if (input.substr(peg$currPos, 4) === peg$c34) {
|
|
6333
|
+
s1 = peg$c34;
|
|
6134
6334
|
peg$currPos += 4;
|
|
6135
6335
|
} else {
|
|
6136
6336
|
s1 = peg$FAILED;
|
|
6137
6337
|
if (peg$silentFails === 0) {
|
|
6138
|
-
peg$fail(peg$
|
|
6338
|
+
peg$fail(peg$e37);
|
|
6139
6339
|
}
|
|
6140
6340
|
}
|
|
6141
6341
|
if (s1 === peg$FAILED) {
|
|
6142
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6143
|
-
s1 = peg$
|
|
6342
|
+
if (input.substr(peg$currPos, 4) === peg$c36) {
|
|
6343
|
+
s1 = peg$c36;
|
|
6144
6344
|
peg$currPos += 4;
|
|
6145
6345
|
} else {
|
|
6146
6346
|
s1 = peg$FAILED;
|
|
6147
6347
|
if (peg$silentFails === 0) {
|
|
6148
|
-
peg$fail(peg$
|
|
6348
|
+
peg$fail(peg$e39);
|
|
6149
6349
|
}
|
|
6150
6350
|
}
|
|
6151
6351
|
if (s1 === peg$FAILED) {
|
|
6152
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6153
|
-
s1 = peg$
|
|
6352
|
+
if (input.substr(peg$currPos, 6) === peg$c37) {
|
|
6353
|
+
s1 = peg$c37;
|
|
6154
6354
|
peg$currPos += 6;
|
|
6155
6355
|
} else {
|
|
6156
6356
|
s1 = peg$FAILED;
|
|
6157
6357
|
if (peg$silentFails === 0) {
|
|
6158
|
-
peg$fail(peg$
|
|
6358
|
+
peg$fail(peg$e40);
|
|
6159
6359
|
}
|
|
6160
6360
|
}
|
|
6161
6361
|
if (s1 === peg$FAILED) {
|
|
6162
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6163
|
-
s1 = peg$
|
|
6362
|
+
if (input.substr(peg$currPos, 5) === peg$c38) {
|
|
6363
|
+
s1 = peg$c38;
|
|
6164
6364
|
peg$currPos += 5;
|
|
6165
6365
|
} else {
|
|
6166
6366
|
s1 = peg$FAILED;
|
|
6167
6367
|
if (peg$silentFails === 0) {
|
|
6168
|
-
peg$fail(peg$
|
|
6368
|
+
peg$fail(peg$e41);
|
|
6169
6369
|
}
|
|
6170
6370
|
}
|
|
6171
6371
|
if (s1 === peg$FAILED) {
|
|
6172
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
6173
|
-
s1 = peg$
|
|
6372
|
+
if (input.substr(peg$currPos, 8) === peg$c39) {
|
|
6373
|
+
s1 = peg$c39;
|
|
6174
6374
|
peg$currPos += 8;
|
|
6175
6375
|
} else {
|
|
6176
6376
|
s1 = peg$FAILED;
|
|
6177
6377
|
if (peg$silentFails === 0) {
|
|
6178
|
-
peg$fail(peg$
|
|
6378
|
+
peg$fail(peg$e42);
|
|
6179
6379
|
}
|
|
6180
6380
|
}
|
|
6181
6381
|
if (s1 === peg$FAILED) {
|
|
6182
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6183
|
-
s1 = peg$
|
|
6382
|
+
if (input.substr(peg$currPos, 6) === peg$c40) {
|
|
6383
|
+
s1 = peg$c40;
|
|
6184
6384
|
peg$currPos += 6;
|
|
6185
6385
|
} else {
|
|
6186
6386
|
s1 = peg$FAILED;
|
|
6187
6387
|
if (peg$silentFails === 0) {
|
|
6188
|
-
peg$fail(peg$
|
|
6388
|
+
peg$fail(peg$e43);
|
|
6189
6389
|
}
|
|
6190
6390
|
}
|
|
6191
6391
|
if (s1 === peg$FAILED) {
|
|
6192
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
6193
|
-
s1 = peg$
|
|
6392
|
+
if (input.substr(peg$currPos, 8) === peg$c41) {
|
|
6393
|
+
s1 = peg$c41;
|
|
6194
6394
|
peg$currPos += 8;
|
|
6195
6395
|
} else {
|
|
6196
6396
|
s1 = peg$FAILED;
|
|
6197
6397
|
if (peg$silentFails === 0) {
|
|
6198
|
-
peg$fail(peg$
|
|
6398
|
+
peg$fail(peg$e44);
|
|
6199
6399
|
}
|
|
6200
6400
|
}
|
|
6201
6401
|
if (s1 === peg$FAILED) {
|
|
6202
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6203
|
-
s1 = peg$
|
|
6402
|
+
if (input.substr(peg$currPos, 5) === peg$c42) {
|
|
6403
|
+
s1 = peg$c42;
|
|
6204
6404
|
peg$currPos += 5;
|
|
6205
6405
|
} else {
|
|
6206
6406
|
s1 = peg$FAILED;
|
|
6207
6407
|
if (peg$silentFails === 0) {
|
|
6208
|
-
peg$fail(peg$
|
|
6408
|
+
peg$fail(peg$e45);
|
|
6209
6409
|
}
|
|
6210
6410
|
}
|
|
6211
6411
|
if (s1 === peg$FAILED) {
|
|
6212
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6213
|
-
s1 = peg$
|
|
6412
|
+
if (input.substr(peg$currPos, 6) === peg$c43) {
|
|
6413
|
+
s1 = peg$c43;
|
|
6214
6414
|
peg$currPos += 6;
|
|
6215
6415
|
} else {
|
|
6216
6416
|
s1 = peg$FAILED;
|
|
6217
6417
|
if (peg$silentFails === 0) {
|
|
6218
|
-
peg$fail(peg$
|
|
6418
|
+
peg$fail(peg$e46);
|
|
6219
6419
|
}
|
|
6220
6420
|
}
|
|
6221
6421
|
if (s1 === peg$FAILED) {
|
|
6222
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6223
|
-
s1 = peg$
|
|
6422
|
+
if (input.substr(peg$currPos, 6) === peg$c44) {
|
|
6423
|
+
s1 = peg$c44;
|
|
6224
6424
|
peg$currPos += 6;
|
|
6225
6425
|
} else {
|
|
6226
6426
|
s1 = peg$FAILED;
|
|
6227
6427
|
if (peg$silentFails === 0) {
|
|
6228
|
-
peg$fail(peg$
|
|
6428
|
+
peg$fail(peg$e47);
|
|
6229
6429
|
}
|
|
6230
6430
|
}
|
|
6231
6431
|
if (s1 === peg$FAILED) {
|
|
6232
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6233
|
-
s1 = peg$
|
|
6432
|
+
if (input.substr(peg$currPos, 5) === peg$c45) {
|
|
6433
|
+
s1 = peg$c45;
|
|
6234
6434
|
peg$currPos += 5;
|
|
6235
6435
|
} else {
|
|
6236
6436
|
s1 = peg$FAILED;
|
|
6237
6437
|
if (peg$silentFails === 0) {
|
|
6238
|
-
peg$fail(peg$
|
|
6438
|
+
peg$fail(peg$e48);
|
|
6239
6439
|
}
|
|
6240
6440
|
}
|
|
6241
6441
|
if (s1 === peg$FAILED) {
|
|
6242
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6243
|
-
s1 = peg$
|
|
6442
|
+
if (input.substr(peg$currPos, 6) === peg$c47) {
|
|
6443
|
+
s1 = peg$c47;
|
|
6244
6444
|
peg$currPos += 6;
|
|
6245
6445
|
} else {
|
|
6246
6446
|
s1 = peg$FAILED;
|
|
6247
6447
|
if (peg$silentFails === 0) {
|
|
6248
|
-
peg$fail(peg$
|
|
6448
|
+
peg$fail(peg$e50);
|
|
6249
6449
|
}
|
|
6250
6450
|
}
|
|
6251
6451
|
if (s1 === peg$FAILED) {
|
|
6252
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6253
|
-
s1 = peg$
|
|
6452
|
+
if (input.substr(peg$currPos, 5) === peg$c48) {
|
|
6453
|
+
s1 = peg$c48;
|
|
6254
6454
|
peg$currPos += 5;
|
|
6255
6455
|
} else {
|
|
6256
6456
|
s1 = peg$FAILED;
|
|
6257
6457
|
if (peg$silentFails === 0) {
|
|
6258
|
-
peg$fail(peg$
|
|
6458
|
+
peg$fail(peg$e51);
|
|
6259
6459
|
}
|
|
6260
6460
|
}
|
|
6261
6461
|
if (s1 === peg$FAILED) {
|
|
6262
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6263
|
-
s1 = peg$
|
|
6462
|
+
if (input.substr(peg$currPos, 5) === peg$c50) {
|
|
6463
|
+
s1 = peg$c50;
|
|
6264
6464
|
peg$currPos += 5;
|
|
6265
6465
|
} else {
|
|
6266
6466
|
s1 = peg$FAILED;
|
|
6267
6467
|
if (peg$silentFails === 0) {
|
|
6268
|
-
peg$fail(peg$
|
|
6468
|
+
peg$fail(peg$e53);
|
|
6269
6469
|
}
|
|
6270
6470
|
}
|
|
6271
6471
|
if (s1 === peg$FAILED) {
|
|
6272
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
6273
|
-
s1 = peg$
|
|
6472
|
+
if (input.substr(peg$currPos, 7) === peg$c53) {
|
|
6473
|
+
s1 = peg$c53;
|
|
6274
6474
|
peg$currPos += 7;
|
|
6275
6475
|
} else {
|
|
6276
6476
|
s1 = peg$FAILED;
|
|
6277
6477
|
if (peg$silentFails === 0) {
|
|
6278
|
-
peg$fail(peg$
|
|
6478
|
+
peg$fail(peg$e56);
|
|
6279
6479
|
}
|
|
6280
6480
|
}
|
|
6281
6481
|
if (s1 === peg$FAILED) {
|
|
6282
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6283
|
-
s1 = peg$
|
|
6482
|
+
if (input.substr(peg$currPos, 4) === peg$c54) {
|
|
6483
|
+
s1 = peg$c54;
|
|
6284
6484
|
peg$currPos += 4;
|
|
6285
6485
|
} else {
|
|
6286
6486
|
s1 = peg$FAILED;
|
|
6287
6487
|
if (peg$silentFails === 0) {
|
|
6288
|
-
peg$fail(peg$
|
|
6488
|
+
peg$fail(peg$e57);
|
|
6289
6489
|
}
|
|
6290
6490
|
}
|
|
6291
6491
|
if (s1 === peg$FAILED) {
|
|
6292
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6293
|
-
s1 = peg$
|
|
6492
|
+
if (input.substr(peg$currPos, 4) === peg$c55) {
|
|
6493
|
+
s1 = peg$c55;
|
|
6294
6494
|
peg$currPos += 4;
|
|
6295
6495
|
} else {
|
|
6296
6496
|
s1 = peg$FAILED;
|
|
6297
6497
|
if (peg$silentFails === 0) {
|
|
6298
|
-
peg$fail(peg$
|
|
6498
|
+
peg$fail(peg$e58);
|
|
6299
6499
|
}
|
|
6300
6500
|
}
|
|
6301
6501
|
if (s1 === peg$FAILED) {
|
|
6302
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6303
|
-
s1 = peg$
|
|
6502
|
+
if (input.substr(peg$currPos, 5) === peg$c56) {
|
|
6503
|
+
s1 = peg$c56;
|
|
6304
6504
|
peg$currPos += 5;
|
|
6305
6505
|
} else {
|
|
6306
6506
|
s1 = peg$FAILED;
|
|
6307
6507
|
if (peg$silentFails === 0) {
|
|
6308
|
-
peg$fail(peg$
|
|
6508
|
+
peg$fail(peg$e59);
|
|
6309
6509
|
}
|
|
6310
6510
|
}
|
|
6311
6511
|
if (s1 === peg$FAILED) {
|
|
6312
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6313
|
-
s1 = peg$
|
|
6512
|
+
if (input.substr(peg$currPos, 5) === peg$c57) {
|
|
6513
|
+
s1 = peg$c57;
|
|
6314
6514
|
peg$currPos += 5;
|
|
6315
6515
|
} else {
|
|
6316
6516
|
s1 = peg$FAILED;
|
|
6317
6517
|
if (peg$silentFails === 0) {
|
|
6318
|
-
peg$fail(peg$
|
|
6518
|
+
peg$fail(peg$e60);
|
|
6319
6519
|
}
|
|
6320
6520
|
}
|
|
6321
6521
|
if (s1 === peg$FAILED) {
|
|
6322
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
6323
|
-
s1 = peg$
|
|
6522
|
+
if (input.substr(peg$currPos, 8) === peg$c58) {
|
|
6523
|
+
s1 = peg$c58;
|
|
6324
6524
|
peg$currPos += 8;
|
|
6325
6525
|
} else {
|
|
6326
6526
|
s1 = peg$FAILED;
|
|
6327
6527
|
if (peg$silentFails === 0) {
|
|
6328
|
-
peg$fail(peg$
|
|
6528
|
+
peg$fail(peg$e61);
|
|
6329
6529
|
}
|
|
6330
6530
|
}
|
|
6331
6531
|
if (s1 === peg$FAILED) {
|
|
6332
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
6333
|
-
s1 = peg$
|
|
6532
|
+
if (input.substr(peg$currPos, 7) === peg$c59) {
|
|
6533
|
+
s1 = peg$c59;
|
|
6334
6534
|
peg$currPos += 7;
|
|
6335
6535
|
} else {
|
|
6336
6536
|
s1 = peg$FAILED;
|
|
6337
6537
|
if (peg$silentFails === 0) {
|
|
6338
|
-
peg$fail(peg$
|
|
6538
|
+
peg$fail(peg$e62);
|
|
6339
6539
|
}
|
|
6340
6540
|
}
|
|
6341
6541
|
if (s1 === peg$FAILED) {
|
|
6342
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
6343
|
-
s1 = peg$
|
|
6542
|
+
if (input.substr(peg$currPos, 7) === peg$c60) {
|
|
6543
|
+
s1 = peg$c60;
|
|
6344
6544
|
peg$currPos += 7;
|
|
6345
6545
|
} else {
|
|
6346
6546
|
s1 = peg$FAILED;
|
|
6347
6547
|
if (peg$silentFails === 0) {
|
|
6348
|
-
peg$fail(peg$
|
|
6548
|
+
peg$fail(peg$e63);
|
|
6349
6549
|
}
|
|
6350
6550
|
}
|
|
6351
6551
|
if (s1 === peg$FAILED) {
|
|
6352
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
6353
|
-
s1 = peg$
|
|
6552
|
+
if (input.substr(peg$currPos, 7) === peg$c61) {
|
|
6553
|
+
s1 = peg$c61;
|
|
6354
6554
|
peg$currPos += 7;
|
|
6355
6555
|
} else {
|
|
6356
6556
|
s1 = peg$FAILED;
|
|
6357
6557
|
if (peg$silentFails === 0) {
|
|
6358
|
-
peg$fail(peg$
|
|
6558
|
+
peg$fail(peg$e64);
|
|
6359
6559
|
}
|
|
6360
6560
|
}
|
|
6361
6561
|
if (s1 === peg$FAILED) {
|
|
6362
|
-
if (input.substr(peg$currPos, 8) === peg$
|
|
6363
|
-
s1 = peg$
|
|
6562
|
+
if (input.substr(peg$currPos, 8) === peg$c62) {
|
|
6563
|
+
s1 = peg$c62;
|
|
6364
6564
|
peg$currPos += 8;
|
|
6365
6565
|
} else {
|
|
6366
6566
|
s1 = peg$FAILED;
|
|
6367
6567
|
if (peg$silentFails === 0) {
|
|
6368
|
-
peg$fail(peg$
|
|
6568
|
+
peg$fail(peg$e65);
|
|
6369
6569
|
}
|
|
6370
6570
|
}
|
|
6371
6571
|
if (s1 === peg$FAILED) {
|
|
6372
|
-
if (input.substr(peg$currPos, 7) === peg$
|
|
6373
|
-
s1 = peg$
|
|
6572
|
+
if (input.substr(peg$currPos, 7) === peg$c63) {
|
|
6573
|
+
s1 = peg$c63;
|
|
6374
6574
|
peg$currPos += 7;
|
|
6375
6575
|
} else {
|
|
6376
6576
|
s1 = peg$FAILED;
|
|
6377
6577
|
if (peg$silentFails === 0) {
|
|
6378
|
-
peg$fail(peg$
|
|
6578
|
+
peg$fail(peg$e66);
|
|
6379
6579
|
}
|
|
6380
6580
|
}
|
|
6381
6581
|
if (s1 === peg$FAILED) {
|
|
6382
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
6383
|
-
s1 = peg$
|
|
6582
|
+
if (input.substr(peg$currPos, 3) === peg$c64) {
|
|
6583
|
+
s1 = peg$c64;
|
|
6384
6584
|
peg$currPos += 3;
|
|
6385
6585
|
} else {
|
|
6386
6586
|
s1 = peg$FAILED;
|
|
6387
6587
|
if (peg$silentFails === 0) {
|
|
6388
|
-
peg$fail(peg$
|
|
6588
|
+
peg$fail(peg$e67);
|
|
6389
6589
|
}
|
|
6390
6590
|
}
|
|
6391
6591
|
if (s1 === peg$FAILED) {
|
|
6392
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6393
|
-
s1 = peg$
|
|
6592
|
+
if (input.substr(peg$currPos, 4) === peg$c66) {
|
|
6593
|
+
s1 = peg$c66;
|
|
6394
6594
|
peg$currPos += 4;
|
|
6395
6595
|
} else {
|
|
6396
6596
|
s1 = peg$FAILED;
|
|
6397
6597
|
if (peg$silentFails === 0) {
|
|
6398
|
-
peg$fail(peg$
|
|
6598
|
+
peg$fail(peg$e69);
|
|
6399
6599
|
}
|
|
6400
6600
|
}
|
|
6401
6601
|
if (s1 === peg$FAILED) {
|
|
6402
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
6403
|
-
s1 = peg$
|
|
6602
|
+
if (input.substr(peg$currPos, 3) === peg$c67) {
|
|
6603
|
+
s1 = peg$c67;
|
|
6404
6604
|
peg$currPos += 3;
|
|
6405
6605
|
} else {
|
|
6406
6606
|
s1 = peg$FAILED;
|
|
6407
6607
|
if (peg$silentFails === 0) {
|
|
6408
|
-
peg$fail(peg$
|
|
6608
|
+
peg$fail(peg$e70);
|
|
6409
6609
|
}
|
|
6410
6610
|
}
|
|
6411
6611
|
if (s1 === peg$FAILED) {
|
|
6412
|
-
if (input.substr(peg$currPos, 10) === peg$
|
|
6413
|
-
s1 = peg$
|
|
6612
|
+
if (input.substr(peg$currPos, 10) === peg$c68) {
|
|
6613
|
+
s1 = peg$c68;
|
|
6414
6614
|
peg$currPos += 10;
|
|
6415
6615
|
} else {
|
|
6416
6616
|
s1 = peg$FAILED;
|
|
6417
6617
|
if (peg$silentFails === 0) {
|
|
6418
|
-
peg$fail(peg$
|
|
6618
|
+
peg$fail(peg$e71);
|
|
6419
6619
|
}
|
|
6420
6620
|
}
|
|
6421
6621
|
if (s1 === peg$FAILED) {
|
|
6422
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
6423
|
-
s1 = peg$
|
|
6622
|
+
if (input.substr(peg$currPos, 5) === peg$c65) {
|
|
6623
|
+
s1 = peg$c65;
|
|
6424
6624
|
peg$currPos += 5;
|
|
6425
6625
|
} else {
|
|
6426
6626
|
s1 = peg$FAILED;
|
|
6427
6627
|
if (peg$silentFails === 0) {
|
|
6428
|
-
peg$fail(peg$
|
|
6628
|
+
peg$fail(peg$e68);
|
|
6429
6629
|
}
|
|
6430
6630
|
}
|
|
6431
6631
|
if (s1 === peg$FAILED) {
|
|
6432
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6433
|
-
s1 = peg$
|
|
6632
|
+
if (input.substr(peg$currPos, 6) === peg$c69) {
|
|
6633
|
+
s1 = peg$c69;
|
|
6434
6634
|
peg$currPos += 6;
|
|
6435
6635
|
} else {
|
|
6436
6636
|
s1 = peg$FAILED;
|
|
6437
6637
|
if (peg$silentFails === 0) {
|
|
6438
|
-
peg$fail(peg$
|
|
6638
|
+
peg$fail(peg$e72);
|
|
6439
6639
|
}
|
|
6440
6640
|
}
|
|
6441
6641
|
if (s1 === peg$FAILED) {
|
|
6442
|
-
if (input.substr(peg$currPos, 11) === peg$
|
|
6443
|
-
s1 = peg$
|
|
6642
|
+
if (input.substr(peg$currPos, 11) === peg$c70) {
|
|
6643
|
+
s1 = peg$c70;
|
|
6444
6644
|
peg$currPos += 11;
|
|
6445
6645
|
} else {
|
|
6446
6646
|
s1 = peg$FAILED;
|
|
6447
6647
|
if (peg$silentFails === 0) {
|
|
6448
|
-
peg$fail(peg$
|
|
6648
|
+
peg$fail(peg$e73);
|
|
6449
6649
|
}
|
|
6450
6650
|
}
|
|
6451
6651
|
if (s1 === peg$FAILED) {
|
|
6452
|
-
if (input.substr(peg$currPos, 6) === peg$
|
|
6453
|
-
s1 = peg$
|
|
6652
|
+
if (input.substr(peg$currPos, 6) === peg$c20) {
|
|
6653
|
+
s1 = peg$c20;
|
|
6454
6654
|
peg$currPos += 6;
|
|
6455
6655
|
} else {
|
|
6456
6656
|
s1 = peg$FAILED;
|
|
6457
6657
|
if (peg$silentFails === 0) {
|
|
6458
|
-
peg$fail(peg$
|
|
6658
|
+
peg$fail(peg$e23);
|
|
6459
6659
|
}
|
|
6460
6660
|
}
|
|
6461
6661
|
if (s1 === peg$FAILED) {
|
|
6462
|
-
if (input.substr(peg$currPos,
|
|
6463
|
-
s1 = peg$
|
|
6464
|
-
peg$currPos +=
|
|
6662
|
+
if (input.substr(peg$currPos, 6) === peg$c3) {
|
|
6663
|
+
s1 = peg$c3;
|
|
6664
|
+
peg$currPos += 6;
|
|
6465
6665
|
} else {
|
|
6466
6666
|
s1 = peg$FAILED;
|
|
6467
6667
|
if (peg$silentFails === 0) {
|
|
6468
|
-
peg$fail(peg$
|
|
6668
|
+
peg$fail(peg$e3);
|
|
6469
6669
|
}
|
|
6470
6670
|
}
|
|
6471
6671
|
if (s1 === peg$FAILED) {
|
|
6472
|
-
if (input.substr(peg$currPos,
|
|
6473
|
-
s1 = peg$
|
|
6474
|
-
peg$currPos +=
|
|
6672
|
+
if (input.substr(peg$currPos, 9) === peg$c4) {
|
|
6673
|
+
s1 = peg$c4;
|
|
6674
|
+
peg$currPos += 9;
|
|
6475
6675
|
} else {
|
|
6476
6676
|
s1 = peg$FAILED;
|
|
6477
6677
|
if (peg$silentFails === 0) {
|
|
6478
|
-
peg$fail(peg$
|
|
6678
|
+
peg$fail(peg$e4);
|
|
6479
6679
|
}
|
|
6480
6680
|
}
|
|
6481
6681
|
if (s1 === peg$FAILED) {
|
|
6482
|
-
if (input.substr(peg$currPos,
|
|
6483
|
-
s1 = peg$
|
|
6484
|
-
peg$currPos +=
|
|
6682
|
+
if (input.substr(peg$currPos, 3) === peg$c12) {
|
|
6683
|
+
s1 = peg$c12;
|
|
6684
|
+
peg$currPos += 3;
|
|
6485
6685
|
} else {
|
|
6486
6686
|
s1 = peg$FAILED;
|
|
6487
6687
|
if (peg$silentFails === 0) {
|
|
6488
|
-
peg$fail(peg$
|
|
6688
|
+
peg$fail(peg$e12);
|
|
6489
6689
|
}
|
|
6490
6690
|
}
|
|
6491
6691
|
if (s1 === peg$FAILED) {
|
|
6492
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
6493
|
-
s1 = peg$
|
|
6692
|
+
if (input.substr(peg$currPos, 4) === peg$c15) {
|
|
6693
|
+
s1 = peg$c15;
|
|
6494
6694
|
peg$currPos += 4;
|
|
6495
6695
|
} else {
|
|
6496
6696
|
s1 = peg$FAILED;
|
|
6497
6697
|
if (peg$silentFails === 0) {
|
|
6498
|
-
peg$fail(peg$
|
|
6698
|
+
peg$fail(peg$e15);
|
|
6699
|
+
}
|
|
6700
|
+
}
|
|
6701
|
+
if (s1 === peg$FAILED) {
|
|
6702
|
+
if (input.substr(peg$currPos, 4) === peg$c16) {
|
|
6703
|
+
s1 = peg$c16;
|
|
6704
|
+
peg$currPos += 4;
|
|
6705
|
+
} else {
|
|
6706
|
+
s1 = peg$FAILED;
|
|
6707
|
+
if (peg$silentFails === 0) {
|
|
6708
|
+
peg$fail(peg$e16);
|
|
6709
|
+
}
|
|
6499
6710
|
}
|
|
6500
6711
|
}
|
|
6501
6712
|
}
|
|
@@ -6580,7 +6791,7 @@ function peg$parse(input, options) {
|
|
|
6580
6791
|
} else {
|
|
6581
6792
|
s0 = peg$FAILED;
|
|
6582
6793
|
if (peg$silentFails === 0) {
|
|
6583
|
-
peg$fail(peg$
|
|
6794
|
+
peg$fail(peg$e78);
|
|
6584
6795
|
}
|
|
6585
6796
|
}
|
|
6586
6797
|
return s0;
|
|
@@ -6613,12 +6824,12 @@ function peg$parse(input, options) {
|
|
|
6613
6824
|
peg$silentFails++;
|
|
6614
6825
|
s0 = peg$currPos;
|
|
6615
6826
|
if (input.charCodeAt(peg$currPos) === 34) {
|
|
6616
|
-
s1 = peg$
|
|
6827
|
+
s1 = peg$c72;
|
|
6617
6828
|
peg$currPos++;
|
|
6618
6829
|
} else {
|
|
6619
6830
|
s1 = peg$FAILED;
|
|
6620
6831
|
if (peg$silentFails === 0) {
|
|
6621
|
-
peg$fail(peg$
|
|
6832
|
+
peg$fail(peg$e80);
|
|
6622
6833
|
}
|
|
6623
6834
|
}
|
|
6624
6835
|
if (s1 !== peg$FAILED) {
|
|
@@ -6629,17 +6840,17 @@ function peg$parse(input, options) {
|
|
|
6629
6840
|
s3 = peg$parseDoubleStringChar();
|
|
6630
6841
|
}
|
|
6631
6842
|
if (input.charCodeAt(peg$currPos) === 34) {
|
|
6632
|
-
s3 = peg$
|
|
6843
|
+
s3 = peg$c72;
|
|
6633
6844
|
peg$currPos++;
|
|
6634
6845
|
} else {
|
|
6635
6846
|
s3 = peg$FAILED;
|
|
6636
6847
|
if (peg$silentFails === 0) {
|
|
6637
|
-
peg$fail(peg$
|
|
6848
|
+
peg$fail(peg$e80);
|
|
6638
6849
|
}
|
|
6639
6850
|
}
|
|
6640
6851
|
if (s3 !== peg$FAILED) {
|
|
6641
6852
|
peg$savedPos = s0;
|
|
6642
|
-
s0 = peg$
|
|
6853
|
+
s0 = peg$f98(s2);
|
|
6643
6854
|
} else {
|
|
6644
6855
|
peg$currPos = s0;
|
|
6645
6856
|
s0 = peg$FAILED;
|
|
@@ -6651,12 +6862,12 @@ function peg$parse(input, options) {
|
|
|
6651
6862
|
if (s0 === peg$FAILED) {
|
|
6652
6863
|
s0 = peg$currPos;
|
|
6653
6864
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
6654
|
-
s1 = peg$
|
|
6865
|
+
s1 = peg$c73;
|
|
6655
6866
|
peg$currPos++;
|
|
6656
6867
|
} else {
|
|
6657
6868
|
s1 = peg$FAILED;
|
|
6658
6869
|
if (peg$silentFails === 0) {
|
|
6659
|
-
peg$fail(peg$
|
|
6870
|
+
peg$fail(peg$e81);
|
|
6660
6871
|
}
|
|
6661
6872
|
}
|
|
6662
6873
|
if (s1 !== peg$FAILED) {
|
|
@@ -6667,17 +6878,17 @@ function peg$parse(input, options) {
|
|
|
6667
6878
|
s3 = peg$parseSingleStringChar();
|
|
6668
6879
|
}
|
|
6669
6880
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
6670
|
-
s3 = peg$
|
|
6881
|
+
s3 = peg$c73;
|
|
6671
6882
|
peg$currPos++;
|
|
6672
6883
|
} else {
|
|
6673
6884
|
s3 = peg$FAILED;
|
|
6674
6885
|
if (peg$silentFails === 0) {
|
|
6675
|
-
peg$fail(peg$
|
|
6886
|
+
peg$fail(peg$e81);
|
|
6676
6887
|
}
|
|
6677
6888
|
}
|
|
6678
6889
|
if (s3 !== peg$FAILED) {
|
|
6679
6890
|
peg$savedPos = s0;
|
|
6680
|
-
s0 = peg$
|
|
6891
|
+
s0 = peg$f99(s2);
|
|
6681
6892
|
} else {
|
|
6682
6893
|
peg$currPos = s0;
|
|
6683
6894
|
s0 = peg$FAILED;
|
|
@@ -6691,7 +6902,7 @@ function peg$parse(input, options) {
|
|
|
6691
6902
|
if (s0 === peg$FAILED) {
|
|
6692
6903
|
s1 = peg$FAILED;
|
|
6693
6904
|
if (peg$silentFails === 0) {
|
|
6694
|
-
peg$fail(peg$
|
|
6905
|
+
peg$fail(peg$e79);
|
|
6695
6906
|
}
|
|
6696
6907
|
}
|
|
6697
6908
|
return s0;
|
|
@@ -6702,12 +6913,12 @@ function peg$parse(input, options) {
|
|
|
6702
6913
|
s1 = peg$currPos;
|
|
6703
6914
|
peg$silentFails++;
|
|
6704
6915
|
if (input.charCodeAt(peg$currPos) === 34) {
|
|
6705
|
-
s2 = peg$
|
|
6916
|
+
s2 = peg$c72;
|
|
6706
6917
|
peg$currPos++;
|
|
6707
6918
|
} else {
|
|
6708
6919
|
s2 = peg$FAILED;
|
|
6709
6920
|
if (peg$silentFails === 0) {
|
|
6710
|
-
peg$fail(peg$
|
|
6921
|
+
peg$fail(peg$e80);
|
|
6711
6922
|
}
|
|
6712
6923
|
}
|
|
6713
6924
|
peg$silentFails--;
|
|
@@ -6721,12 +6932,12 @@ function peg$parse(input, options) {
|
|
|
6721
6932
|
s2 = peg$currPos;
|
|
6722
6933
|
peg$silentFails++;
|
|
6723
6934
|
if (input.charCodeAt(peg$currPos) === 92) {
|
|
6724
|
-
s3 = peg$
|
|
6935
|
+
s3 = peg$c74;
|
|
6725
6936
|
peg$currPos++;
|
|
6726
6937
|
} else {
|
|
6727
6938
|
s3 = peg$FAILED;
|
|
6728
6939
|
if (peg$silentFails === 0) {
|
|
6729
|
-
peg$fail(peg$
|
|
6940
|
+
peg$fail(peg$e82);
|
|
6730
6941
|
}
|
|
6731
6942
|
}
|
|
6732
6943
|
peg$silentFails--;
|
|
@@ -6748,7 +6959,7 @@ function peg$parse(input, options) {
|
|
|
6748
6959
|
}
|
|
6749
6960
|
if (s3 !== peg$FAILED) {
|
|
6750
6961
|
peg$savedPos = s0;
|
|
6751
|
-
s0 = peg$
|
|
6962
|
+
s0 = peg$f100(s3);
|
|
6752
6963
|
} else {
|
|
6753
6964
|
peg$currPos = s0;
|
|
6754
6965
|
s0 = peg$FAILED;
|
|
@@ -6764,19 +6975,19 @@ function peg$parse(input, options) {
|
|
|
6764
6975
|
if (s0 === peg$FAILED) {
|
|
6765
6976
|
s0 = peg$currPos;
|
|
6766
6977
|
if (input.charCodeAt(peg$currPos) === 92) {
|
|
6767
|
-
s1 = peg$
|
|
6978
|
+
s1 = peg$c74;
|
|
6768
6979
|
peg$currPos++;
|
|
6769
6980
|
} else {
|
|
6770
6981
|
s1 = peg$FAILED;
|
|
6771
6982
|
if (peg$silentFails === 0) {
|
|
6772
|
-
peg$fail(peg$
|
|
6983
|
+
peg$fail(peg$e82);
|
|
6773
6984
|
}
|
|
6774
6985
|
}
|
|
6775
6986
|
if (s1 !== peg$FAILED) {
|
|
6776
6987
|
s2 = peg$parseEscapeSequence();
|
|
6777
6988
|
if (s2 !== peg$FAILED) {
|
|
6778
6989
|
peg$savedPos = s0;
|
|
6779
|
-
s0 = peg$
|
|
6990
|
+
s0 = peg$f101(s2);
|
|
6780
6991
|
} else {
|
|
6781
6992
|
peg$currPos = s0;
|
|
6782
6993
|
s0 = peg$FAILED;
|
|
@@ -6794,12 +7005,12 @@ function peg$parse(input, options) {
|
|
|
6794
7005
|
s1 = peg$currPos;
|
|
6795
7006
|
peg$silentFails++;
|
|
6796
7007
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
6797
|
-
s2 = peg$
|
|
7008
|
+
s2 = peg$c73;
|
|
6798
7009
|
peg$currPos++;
|
|
6799
7010
|
} else {
|
|
6800
7011
|
s2 = peg$FAILED;
|
|
6801
7012
|
if (peg$silentFails === 0) {
|
|
6802
|
-
peg$fail(peg$
|
|
7013
|
+
peg$fail(peg$e81);
|
|
6803
7014
|
}
|
|
6804
7015
|
}
|
|
6805
7016
|
peg$silentFails--;
|
|
@@ -6813,12 +7024,12 @@ function peg$parse(input, options) {
|
|
|
6813
7024
|
s2 = peg$currPos;
|
|
6814
7025
|
peg$silentFails++;
|
|
6815
7026
|
if (input.charCodeAt(peg$currPos) === 92) {
|
|
6816
|
-
s3 = peg$
|
|
7027
|
+
s3 = peg$c74;
|
|
6817
7028
|
peg$currPos++;
|
|
6818
7029
|
} else {
|
|
6819
7030
|
s3 = peg$FAILED;
|
|
6820
7031
|
if (peg$silentFails === 0) {
|
|
6821
|
-
peg$fail(peg$
|
|
7032
|
+
peg$fail(peg$e82);
|
|
6822
7033
|
}
|
|
6823
7034
|
}
|
|
6824
7035
|
peg$silentFails--;
|
|
@@ -6840,7 +7051,7 @@ function peg$parse(input, options) {
|
|
|
6840
7051
|
}
|
|
6841
7052
|
if (s3 !== peg$FAILED) {
|
|
6842
7053
|
peg$savedPos = s0;
|
|
6843
|
-
s0 = peg$
|
|
7054
|
+
s0 = peg$f102(s3);
|
|
6844
7055
|
} else {
|
|
6845
7056
|
peg$currPos = s0;
|
|
6846
7057
|
s0 = peg$FAILED;
|
|
@@ -6856,19 +7067,19 @@ function peg$parse(input, options) {
|
|
|
6856
7067
|
if (s0 === peg$FAILED) {
|
|
6857
7068
|
s0 = peg$currPos;
|
|
6858
7069
|
if (input.charCodeAt(peg$currPos) === 92) {
|
|
6859
|
-
s1 = peg$
|
|
7070
|
+
s1 = peg$c74;
|
|
6860
7071
|
peg$currPos++;
|
|
6861
7072
|
} else {
|
|
6862
7073
|
s1 = peg$FAILED;
|
|
6863
7074
|
if (peg$silentFails === 0) {
|
|
6864
|
-
peg$fail(peg$
|
|
7075
|
+
peg$fail(peg$e82);
|
|
6865
7076
|
}
|
|
6866
7077
|
}
|
|
6867
7078
|
if (s1 !== peg$FAILED) {
|
|
6868
7079
|
s2 = peg$parseEscapeSequence();
|
|
6869
7080
|
if (s2 !== peg$FAILED) {
|
|
6870
7081
|
peg$savedPos = s0;
|
|
6871
|
-
s0 = peg$
|
|
7082
|
+
s0 = peg$f103(s2);
|
|
6872
7083
|
} else {
|
|
6873
7084
|
peg$currPos = s0;
|
|
6874
7085
|
s0 = peg$FAILED;
|
|
@@ -6884,97 +7095,97 @@ function peg$parse(input, options) {
|
|
|
6884
7095
|
let s0, s1;
|
|
6885
7096
|
s0 = peg$currPos;
|
|
6886
7097
|
if (input.charCodeAt(peg$currPos) === 110) {
|
|
6887
|
-
s1 = peg$
|
|
7098
|
+
s1 = peg$c75;
|
|
6888
7099
|
peg$currPos++;
|
|
6889
7100
|
} else {
|
|
6890
7101
|
s1 = peg$FAILED;
|
|
6891
7102
|
if (peg$silentFails === 0) {
|
|
6892
|
-
peg$fail(peg$
|
|
7103
|
+
peg$fail(peg$e83);
|
|
6893
7104
|
}
|
|
6894
7105
|
}
|
|
6895
7106
|
if (s1 !== peg$FAILED) {
|
|
6896
7107
|
peg$savedPos = s0;
|
|
6897
|
-
s1 = peg$
|
|
7108
|
+
s1 = peg$f104();
|
|
6898
7109
|
}
|
|
6899
7110
|
s0 = s1;
|
|
6900
7111
|
if (s0 === peg$FAILED) {
|
|
6901
7112
|
s0 = peg$currPos;
|
|
6902
7113
|
if (input.charCodeAt(peg$currPos) === 114) {
|
|
6903
|
-
s1 = peg$
|
|
7114
|
+
s1 = peg$c76;
|
|
6904
7115
|
peg$currPos++;
|
|
6905
7116
|
} else {
|
|
6906
7117
|
s1 = peg$FAILED;
|
|
6907
7118
|
if (peg$silentFails === 0) {
|
|
6908
|
-
peg$fail(peg$
|
|
7119
|
+
peg$fail(peg$e84);
|
|
6909
7120
|
}
|
|
6910
7121
|
}
|
|
6911
7122
|
if (s1 !== peg$FAILED) {
|
|
6912
7123
|
peg$savedPos = s0;
|
|
6913
|
-
s1 = peg$
|
|
7124
|
+
s1 = peg$f105();
|
|
6914
7125
|
}
|
|
6915
7126
|
s0 = s1;
|
|
6916
7127
|
if (s0 === peg$FAILED) {
|
|
6917
7128
|
s0 = peg$currPos;
|
|
6918
7129
|
if (input.charCodeAt(peg$currPos) === 116) {
|
|
6919
|
-
s1 = peg$
|
|
7130
|
+
s1 = peg$c77;
|
|
6920
7131
|
peg$currPos++;
|
|
6921
7132
|
} else {
|
|
6922
7133
|
s1 = peg$FAILED;
|
|
6923
7134
|
if (peg$silentFails === 0) {
|
|
6924
|
-
peg$fail(peg$
|
|
7135
|
+
peg$fail(peg$e85);
|
|
6925
7136
|
}
|
|
6926
7137
|
}
|
|
6927
7138
|
if (s1 !== peg$FAILED) {
|
|
6928
7139
|
peg$savedPos = s0;
|
|
6929
|
-
s1 = peg$
|
|
7140
|
+
s1 = peg$f106();
|
|
6930
7141
|
}
|
|
6931
7142
|
s0 = s1;
|
|
6932
7143
|
if (s0 === peg$FAILED) {
|
|
6933
7144
|
s0 = peg$currPos;
|
|
6934
7145
|
if (input.charCodeAt(peg$currPos) === 92) {
|
|
6935
|
-
s1 = peg$
|
|
7146
|
+
s1 = peg$c74;
|
|
6936
7147
|
peg$currPos++;
|
|
6937
7148
|
} else {
|
|
6938
7149
|
s1 = peg$FAILED;
|
|
6939
7150
|
if (peg$silentFails === 0) {
|
|
6940
|
-
peg$fail(peg$
|
|
7151
|
+
peg$fail(peg$e82);
|
|
6941
7152
|
}
|
|
6942
7153
|
}
|
|
6943
7154
|
if (s1 !== peg$FAILED) {
|
|
6944
7155
|
peg$savedPos = s0;
|
|
6945
|
-
s1 = peg$
|
|
7156
|
+
s1 = peg$f107();
|
|
6946
7157
|
}
|
|
6947
7158
|
s0 = s1;
|
|
6948
7159
|
if (s0 === peg$FAILED) {
|
|
6949
7160
|
s0 = peg$currPos;
|
|
6950
7161
|
if (input.charCodeAt(peg$currPos) === 34) {
|
|
6951
|
-
s1 = peg$
|
|
7162
|
+
s1 = peg$c72;
|
|
6952
7163
|
peg$currPos++;
|
|
6953
7164
|
} else {
|
|
6954
7165
|
s1 = peg$FAILED;
|
|
6955
7166
|
if (peg$silentFails === 0) {
|
|
6956
|
-
peg$fail(peg$
|
|
7167
|
+
peg$fail(peg$e80);
|
|
6957
7168
|
}
|
|
6958
7169
|
}
|
|
6959
7170
|
if (s1 !== peg$FAILED) {
|
|
6960
7171
|
peg$savedPos = s0;
|
|
6961
|
-
s1 = peg$
|
|
7172
|
+
s1 = peg$f108();
|
|
6962
7173
|
}
|
|
6963
7174
|
s0 = s1;
|
|
6964
7175
|
if (s0 === peg$FAILED) {
|
|
6965
7176
|
s0 = peg$currPos;
|
|
6966
7177
|
if (input.charCodeAt(peg$currPos) === 39) {
|
|
6967
|
-
s1 = peg$
|
|
7178
|
+
s1 = peg$c73;
|
|
6968
7179
|
peg$currPos++;
|
|
6969
7180
|
} else {
|
|
6970
7181
|
s1 = peg$FAILED;
|
|
6971
7182
|
if (peg$silentFails === 0) {
|
|
6972
|
-
peg$fail(peg$
|
|
7183
|
+
peg$fail(peg$e81);
|
|
6973
7184
|
}
|
|
6974
7185
|
}
|
|
6975
7186
|
if (s1 !== peg$FAILED) {
|
|
6976
7187
|
peg$savedPos = s0;
|
|
6977
|
-
s1 = peg$
|
|
7188
|
+
s1 = peg$f109();
|
|
6978
7189
|
}
|
|
6979
7190
|
s0 = s1;
|
|
6980
7191
|
}
|
|
@@ -6989,12 +7200,12 @@ function peg$parse(input, options) {
|
|
|
6989
7200
|
peg$silentFails++;
|
|
6990
7201
|
s0 = peg$currPos;
|
|
6991
7202
|
if (input.charCodeAt(peg$currPos) === 45) {
|
|
6992
|
-
s1 = peg$
|
|
7203
|
+
s1 = peg$c78;
|
|
6993
7204
|
peg$currPos++;
|
|
6994
7205
|
} else {
|
|
6995
7206
|
s1 = peg$FAILED;
|
|
6996
7207
|
if (peg$silentFails === 0) {
|
|
6997
|
-
peg$fail(peg$
|
|
7208
|
+
peg$fail(peg$e87);
|
|
6998
7209
|
}
|
|
6999
7210
|
}
|
|
7000
7211
|
if (s1 === peg$FAILED) {
|
|
@@ -7007,7 +7218,7 @@ function peg$parse(input, options) {
|
|
|
7007
7218
|
} else {
|
|
7008
7219
|
s3 = peg$FAILED;
|
|
7009
7220
|
if (peg$silentFails === 0) {
|
|
7010
|
-
peg$fail(peg$
|
|
7221
|
+
peg$fail(peg$e75);
|
|
7011
7222
|
}
|
|
7012
7223
|
}
|
|
7013
7224
|
if (s3 !== peg$FAILED) {
|
|
@@ -7019,7 +7230,7 @@ function peg$parse(input, options) {
|
|
|
7019
7230
|
} else {
|
|
7020
7231
|
s3 = peg$FAILED;
|
|
7021
7232
|
if (peg$silentFails === 0) {
|
|
7022
|
-
peg$fail(peg$
|
|
7233
|
+
peg$fail(peg$e75);
|
|
7023
7234
|
}
|
|
7024
7235
|
}
|
|
7025
7236
|
}
|
|
@@ -7029,12 +7240,12 @@ function peg$parse(input, options) {
|
|
|
7029
7240
|
if (s2 !== peg$FAILED) {
|
|
7030
7241
|
s3 = peg$currPos;
|
|
7031
7242
|
if (input.charCodeAt(peg$currPos) === 46) {
|
|
7032
|
-
s4 = peg$
|
|
7243
|
+
s4 = peg$c79;
|
|
7033
7244
|
peg$currPos++;
|
|
7034
7245
|
} else {
|
|
7035
7246
|
s4 = peg$FAILED;
|
|
7036
7247
|
if (peg$silentFails === 0) {
|
|
7037
|
-
peg$fail(peg$
|
|
7248
|
+
peg$fail(peg$e88);
|
|
7038
7249
|
}
|
|
7039
7250
|
}
|
|
7040
7251
|
if (s4 !== peg$FAILED) {
|
|
@@ -7045,7 +7256,7 @@ function peg$parse(input, options) {
|
|
|
7045
7256
|
} else {
|
|
7046
7257
|
s6 = peg$FAILED;
|
|
7047
7258
|
if (peg$silentFails === 0) {
|
|
7048
|
-
peg$fail(peg$
|
|
7259
|
+
peg$fail(peg$e75);
|
|
7049
7260
|
}
|
|
7050
7261
|
}
|
|
7051
7262
|
if (s6 !== peg$FAILED) {
|
|
@@ -7057,7 +7268,7 @@ function peg$parse(input, options) {
|
|
|
7057
7268
|
} else {
|
|
7058
7269
|
s6 = peg$FAILED;
|
|
7059
7270
|
if (peg$silentFails === 0) {
|
|
7060
|
-
peg$fail(peg$
|
|
7271
|
+
peg$fail(peg$e75);
|
|
7061
7272
|
}
|
|
7062
7273
|
}
|
|
7063
7274
|
}
|
|
@@ -7079,7 +7290,7 @@ function peg$parse(input, options) {
|
|
|
7079
7290
|
s3 = null;
|
|
7080
7291
|
}
|
|
7081
7292
|
peg$savedPos = s0;
|
|
7082
|
-
s0 = peg$
|
|
7293
|
+
s0 = peg$f110(s1, s2, s3);
|
|
7083
7294
|
} else {
|
|
7084
7295
|
peg$currPos = s0;
|
|
7085
7296
|
s0 = peg$FAILED;
|
|
@@ -7088,7 +7299,7 @@ function peg$parse(input, options) {
|
|
|
7088
7299
|
if (s0 === peg$FAILED) {
|
|
7089
7300
|
s1 = peg$FAILED;
|
|
7090
7301
|
if (peg$silentFails === 0) {
|
|
7091
|
-
peg$fail(peg$
|
|
7302
|
+
peg$fail(peg$e86);
|
|
7092
7303
|
}
|
|
7093
7304
|
}
|
|
7094
7305
|
return s0;
|
|
@@ -7098,12 +7309,12 @@ function peg$parse(input, options) {
|
|
|
7098
7309
|
peg$silentFails++;
|
|
7099
7310
|
s0 = peg$currPos;
|
|
7100
7311
|
if (input.charCodeAt(peg$currPos) === 45) {
|
|
7101
|
-
s1 = peg$
|
|
7312
|
+
s1 = peg$c78;
|
|
7102
7313
|
peg$currPos++;
|
|
7103
7314
|
} else {
|
|
7104
7315
|
s1 = peg$FAILED;
|
|
7105
7316
|
if (peg$silentFails === 0) {
|
|
7106
|
-
peg$fail(peg$
|
|
7317
|
+
peg$fail(peg$e87);
|
|
7107
7318
|
}
|
|
7108
7319
|
}
|
|
7109
7320
|
if (s1 === peg$FAILED) {
|
|
@@ -7116,7 +7327,7 @@ function peg$parse(input, options) {
|
|
|
7116
7327
|
} else {
|
|
7117
7328
|
s3 = peg$FAILED;
|
|
7118
7329
|
if (peg$silentFails === 0) {
|
|
7119
|
-
peg$fail(peg$
|
|
7330
|
+
peg$fail(peg$e75);
|
|
7120
7331
|
}
|
|
7121
7332
|
}
|
|
7122
7333
|
if (s3 !== peg$FAILED) {
|
|
@@ -7128,7 +7339,7 @@ function peg$parse(input, options) {
|
|
|
7128
7339
|
} else {
|
|
7129
7340
|
s3 = peg$FAILED;
|
|
7130
7341
|
if (peg$silentFails === 0) {
|
|
7131
|
-
peg$fail(peg$
|
|
7342
|
+
peg$fail(peg$e75);
|
|
7132
7343
|
}
|
|
7133
7344
|
}
|
|
7134
7345
|
}
|
|
@@ -7138,12 +7349,12 @@ function peg$parse(input, options) {
|
|
|
7138
7349
|
if (s2 !== peg$FAILED) {
|
|
7139
7350
|
s3 = peg$currPos;
|
|
7140
7351
|
if (input.charCodeAt(peg$currPos) === 46) {
|
|
7141
|
-
s4 = peg$
|
|
7352
|
+
s4 = peg$c79;
|
|
7142
7353
|
peg$currPos++;
|
|
7143
7354
|
} else {
|
|
7144
7355
|
s4 = peg$FAILED;
|
|
7145
7356
|
if (peg$silentFails === 0) {
|
|
7146
|
-
peg$fail(peg$
|
|
7357
|
+
peg$fail(peg$e88);
|
|
7147
7358
|
}
|
|
7148
7359
|
}
|
|
7149
7360
|
if (s4 !== peg$FAILED) {
|
|
@@ -7154,7 +7365,7 @@ function peg$parse(input, options) {
|
|
|
7154
7365
|
} else {
|
|
7155
7366
|
s6 = peg$FAILED;
|
|
7156
7367
|
if (peg$silentFails === 0) {
|
|
7157
|
-
peg$fail(peg$
|
|
7368
|
+
peg$fail(peg$e75);
|
|
7158
7369
|
}
|
|
7159
7370
|
}
|
|
7160
7371
|
if (s6 !== peg$FAILED) {
|
|
@@ -7166,7 +7377,7 @@ function peg$parse(input, options) {
|
|
|
7166
7377
|
} else {
|
|
7167
7378
|
s6 = peg$FAILED;
|
|
7168
7379
|
if (peg$silentFails === 0) {
|
|
7169
|
-
peg$fail(peg$
|
|
7380
|
+
peg$fail(peg$e75);
|
|
7170
7381
|
}
|
|
7171
7382
|
}
|
|
7172
7383
|
}
|
|
@@ -7187,63 +7398,63 @@ function peg$parse(input, options) {
|
|
|
7187
7398
|
if (s3 === peg$FAILED) {
|
|
7188
7399
|
s3 = null;
|
|
7189
7400
|
}
|
|
7190
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7191
|
-
s4 = peg$
|
|
7401
|
+
if (input.substr(peg$currPos, 2) === peg$c80) {
|
|
7402
|
+
s4 = peg$c80;
|
|
7192
7403
|
peg$currPos += 2;
|
|
7193
7404
|
} else {
|
|
7194
7405
|
s4 = peg$FAILED;
|
|
7195
7406
|
if (peg$silentFails === 0) {
|
|
7196
|
-
peg$fail(peg$
|
|
7407
|
+
peg$fail(peg$e90);
|
|
7197
7408
|
}
|
|
7198
7409
|
}
|
|
7199
7410
|
if (s4 === peg$FAILED) {
|
|
7200
7411
|
if (input.charCodeAt(peg$currPos) === 37) {
|
|
7201
|
-
s4 = peg$
|
|
7412
|
+
s4 = peg$c81;
|
|
7202
7413
|
peg$currPos++;
|
|
7203
7414
|
} else {
|
|
7204
7415
|
s4 = peg$FAILED;
|
|
7205
7416
|
if (peg$silentFails === 0) {
|
|
7206
|
-
peg$fail(peg$
|
|
7417
|
+
peg$fail(peg$e91);
|
|
7207
7418
|
}
|
|
7208
7419
|
}
|
|
7209
7420
|
if (s4 === peg$FAILED) {
|
|
7210
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7211
|
-
s4 = peg$
|
|
7421
|
+
if (input.substr(peg$currPos, 2) === peg$c82) {
|
|
7422
|
+
s4 = peg$c82;
|
|
7212
7423
|
peg$currPos += 2;
|
|
7213
7424
|
} else {
|
|
7214
7425
|
s4 = peg$FAILED;
|
|
7215
7426
|
if (peg$silentFails === 0) {
|
|
7216
|
-
peg$fail(peg$
|
|
7427
|
+
peg$fail(peg$e92);
|
|
7217
7428
|
}
|
|
7218
7429
|
}
|
|
7219
7430
|
if (s4 === peg$FAILED) {
|
|
7220
|
-
if (input.substr(peg$currPos, 3) === peg$
|
|
7221
|
-
s4 = peg$
|
|
7431
|
+
if (input.substr(peg$currPos, 3) === peg$c83) {
|
|
7432
|
+
s4 = peg$c83;
|
|
7222
7433
|
peg$currPos += 3;
|
|
7223
7434
|
} else {
|
|
7224
7435
|
s4 = peg$FAILED;
|
|
7225
7436
|
if (peg$silentFails === 0) {
|
|
7226
|
-
peg$fail(peg$
|
|
7437
|
+
peg$fail(peg$e93);
|
|
7227
7438
|
}
|
|
7228
7439
|
}
|
|
7229
7440
|
if (s4 === peg$FAILED) {
|
|
7230
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7231
|
-
s4 = peg$
|
|
7441
|
+
if (input.substr(peg$currPos, 2) === peg$c84) {
|
|
7442
|
+
s4 = peg$c84;
|
|
7232
7443
|
peg$currPos += 2;
|
|
7233
7444
|
} else {
|
|
7234
7445
|
s4 = peg$FAILED;
|
|
7235
7446
|
if (peg$silentFails === 0) {
|
|
7236
|
-
peg$fail(peg$
|
|
7447
|
+
peg$fail(peg$e94);
|
|
7237
7448
|
}
|
|
7238
7449
|
}
|
|
7239
7450
|
if (s4 === peg$FAILED) {
|
|
7240
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7241
|
-
s4 = peg$
|
|
7451
|
+
if (input.substr(peg$currPos, 2) === peg$c85) {
|
|
7452
|
+
s4 = peg$c85;
|
|
7242
7453
|
peg$currPos += 2;
|
|
7243
7454
|
} else {
|
|
7244
7455
|
s4 = peg$FAILED;
|
|
7245
7456
|
if (peg$silentFails === 0) {
|
|
7246
|
-
peg$fail(peg$
|
|
7457
|
+
peg$fail(peg$e95);
|
|
7247
7458
|
}
|
|
7248
7459
|
}
|
|
7249
7460
|
}
|
|
@@ -7253,7 +7464,7 @@ function peg$parse(input, options) {
|
|
|
7253
7464
|
}
|
|
7254
7465
|
if (s4 !== peg$FAILED) {
|
|
7255
7466
|
peg$savedPos = s0;
|
|
7256
|
-
s0 = peg$
|
|
7467
|
+
s0 = peg$f111(s1, s2, s3, s4);
|
|
7257
7468
|
} else {
|
|
7258
7469
|
peg$currPos = s0;
|
|
7259
7470
|
s0 = peg$FAILED;
|
|
@@ -7266,7 +7477,7 @@ function peg$parse(input, options) {
|
|
|
7266
7477
|
if (s0 === peg$FAILED) {
|
|
7267
7478
|
s1 = peg$FAILED;
|
|
7268
7479
|
if (peg$silentFails === 0) {
|
|
7269
|
-
peg$fail(peg$
|
|
7480
|
+
peg$fail(peg$e89);
|
|
7270
7481
|
}
|
|
7271
7482
|
}
|
|
7272
7483
|
return s0;
|
|
@@ -7275,34 +7486,34 @@ function peg$parse(input, options) {
|
|
|
7275
7486
|
let s0, s1;
|
|
7276
7487
|
peg$silentFails++;
|
|
7277
7488
|
s0 = peg$currPos;
|
|
7278
|
-
if (input.substr(peg$currPos, 4) === peg$
|
|
7279
|
-
s1 = peg$
|
|
7489
|
+
if (input.substr(peg$currPos, 4) === peg$c86) {
|
|
7490
|
+
s1 = peg$c86;
|
|
7280
7491
|
peg$currPos += 4;
|
|
7281
7492
|
} else {
|
|
7282
7493
|
s1 = peg$FAILED;
|
|
7283
7494
|
if (peg$silentFails === 0) {
|
|
7284
|
-
peg$fail(peg$
|
|
7495
|
+
peg$fail(peg$e97);
|
|
7285
7496
|
}
|
|
7286
7497
|
}
|
|
7287
7498
|
if (s1 !== peg$FAILED) {
|
|
7288
7499
|
peg$savedPos = s0;
|
|
7289
|
-
s1 = peg$
|
|
7500
|
+
s1 = peg$f112();
|
|
7290
7501
|
}
|
|
7291
7502
|
s0 = s1;
|
|
7292
7503
|
if (s0 === peg$FAILED) {
|
|
7293
7504
|
s0 = peg$currPos;
|
|
7294
|
-
if (input.substr(peg$currPos, 5) === peg$
|
|
7295
|
-
s1 = peg$
|
|
7505
|
+
if (input.substr(peg$currPos, 5) === peg$c87) {
|
|
7506
|
+
s1 = peg$c87;
|
|
7296
7507
|
peg$currPos += 5;
|
|
7297
7508
|
} else {
|
|
7298
7509
|
s1 = peg$FAILED;
|
|
7299
7510
|
if (peg$silentFails === 0) {
|
|
7300
|
-
peg$fail(peg$
|
|
7511
|
+
peg$fail(peg$e98);
|
|
7301
7512
|
}
|
|
7302
7513
|
}
|
|
7303
7514
|
if (s1 !== peg$FAILED) {
|
|
7304
7515
|
peg$savedPos = s0;
|
|
7305
|
-
s1 = peg$
|
|
7516
|
+
s1 = peg$f113();
|
|
7306
7517
|
}
|
|
7307
7518
|
s0 = s1;
|
|
7308
7519
|
}
|
|
@@ -7310,7 +7521,7 @@ function peg$parse(input, options) {
|
|
|
7310
7521
|
if (s0 === peg$FAILED) {
|
|
7311
7522
|
s1 = peg$FAILED;
|
|
7312
7523
|
if (peg$silentFails === 0) {
|
|
7313
|
-
peg$fail(peg$
|
|
7524
|
+
peg$fail(peg$e96);
|
|
7314
7525
|
}
|
|
7315
7526
|
}
|
|
7316
7527
|
return s0;
|
|
@@ -7325,7 +7536,7 @@ function peg$parse(input, options) {
|
|
|
7325
7536
|
} else {
|
|
7326
7537
|
s1 = peg$FAILED;
|
|
7327
7538
|
if (peg$silentFails === 0) {
|
|
7328
|
-
peg$fail(peg$
|
|
7539
|
+
peg$fail(peg$e100);
|
|
7329
7540
|
}
|
|
7330
7541
|
}
|
|
7331
7542
|
if (s1 !== peg$FAILED) {
|
|
@@ -7336,7 +7547,7 @@ function peg$parse(input, options) {
|
|
|
7336
7547
|
} else {
|
|
7337
7548
|
s3 = peg$FAILED;
|
|
7338
7549
|
if (peg$silentFails === 0) {
|
|
7339
|
-
peg$fail(peg$
|
|
7550
|
+
peg$fail(peg$e78);
|
|
7340
7551
|
}
|
|
7341
7552
|
}
|
|
7342
7553
|
while (s3 !== peg$FAILED) {
|
|
@@ -7347,12 +7558,12 @@ function peg$parse(input, options) {
|
|
|
7347
7558
|
} else {
|
|
7348
7559
|
s3 = peg$FAILED;
|
|
7349
7560
|
if (peg$silentFails === 0) {
|
|
7350
|
-
peg$fail(peg$
|
|
7561
|
+
peg$fail(peg$e78);
|
|
7351
7562
|
}
|
|
7352
7563
|
}
|
|
7353
7564
|
}
|
|
7354
7565
|
peg$savedPos = s0;
|
|
7355
|
-
s0 = peg$
|
|
7566
|
+
s0 = peg$f114(s1, s2);
|
|
7356
7567
|
} else {
|
|
7357
7568
|
peg$currPos = s0;
|
|
7358
7569
|
s0 = peg$FAILED;
|
|
@@ -7361,7 +7572,7 @@ function peg$parse(input, options) {
|
|
|
7361
7572
|
if (s0 === peg$FAILED) {
|
|
7362
7573
|
s1 = peg$FAILED;
|
|
7363
7574
|
if (peg$silentFails === 0) {
|
|
7364
|
-
peg$fail(peg$
|
|
7575
|
+
peg$fail(peg$e99);
|
|
7365
7576
|
}
|
|
7366
7577
|
}
|
|
7367
7578
|
return s0;
|
|
@@ -7370,12 +7581,12 @@ function peg$parse(input, options) {
|
|
|
7370
7581
|
let s0, s1, s2, s3, s4, s5;
|
|
7371
7582
|
s0 = peg$currPos;
|
|
7372
7583
|
if (input.charCodeAt(peg$currPos) === 91) {
|
|
7373
|
-
s1 = peg$
|
|
7584
|
+
s1 = peg$c51;
|
|
7374
7585
|
peg$currPos++;
|
|
7375
7586
|
} else {
|
|
7376
7587
|
s1 = peg$FAILED;
|
|
7377
7588
|
if (peg$silentFails === 0) {
|
|
7378
|
-
peg$fail(peg$
|
|
7589
|
+
peg$fail(peg$e54);
|
|
7379
7590
|
}
|
|
7380
7591
|
}
|
|
7381
7592
|
if (s1 !== peg$FAILED) {
|
|
@@ -7386,17 +7597,17 @@ function peg$parse(input, options) {
|
|
|
7386
7597
|
}
|
|
7387
7598
|
s4 = peg$parse_();
|
|
7388
7599
|
if (input.charCodeAt(peg$currPos) === 93) {
|
|
7389
|
-
s5 = peg$
|
|
7600
|
+
s5 = peg$c52;
|
|
7390
7601
|
peg$currPos++;
|
|
7391
7602
|
} else {
|
|
7392
7603
|
s5 = peg$FAILED;
|
|
7393
7604
|
if (peg$silentFails === 0) {
|
|
7394
|
-
peg$fail(peg$
|
|
7605
|
+
peg$fail(peg$e55);
|
|
7395
7606
|
}
|
|
7396
7607
|
}
|
|
7397
7608
|
if (s5 !== peg$FAILED) {
|
|
7398
7609
|
peg$savedPos = s0;
|
|
7399
|
-
s0 = peg$
|
|
7610
|
+
s0 = peg$f115(s3);
|
|
7400
7611
|
} else {
|
|
7401
7612
|
peg$currPos = s0;
|
|
7402
7613
|
s0 = peg$FAILED;
|
|
@@ -7484,7 +7695,7 @@ function peg$parse(input, options) {
|
|
|
7484
7695
|
s3 = null;
|
|
7485
7696
|
}
|
|
7486
7697
|
peg$savedPos = s0;
|
|
7487
|
-
s0 = peg$
|
|
7698
|
+
s0 = peg$f116(s1, s2);
|
|
7488
7699
|
} else {
|
|
7489
7700
|
peg$currPos = s0;
|
|
7490
7701
|
s0 = peg$FAILED;
|
|
@@ -7538,7 +7749,7 @@ function peg$parse(input, options) {
|
|
|
7538
7749
|
}
|
|
7539
7750
|
if (s5 !== peg$FAILED) {
|
|
7540
7751
|
peg$savedPos = s0;
|
|
7541
|
-
s0 = peg$
|
|
7752
|
+
s0 = peg$f117(s3);
|
|
7542
7753
|
} else {
|
|
7543
7754
|
peg$currPos = s0;
|
|
7544
7755
|
s0 = peg$FAILED;
|
|
@@ -7605,7 +7816,7 @@ function peg$parse(input, options) {
|
|
|
7605
7816
|
}
|
|
7606
7817
|
}
|
|
7607
7818
|
peg$savedPos = s0;
|
|
7608
|
-
s0 = peg$
|
|
7819
|
+
s0 = peg$f118(s1, s2);
|
|
7609
7820
|
} else {
|
|
7610
7821
|
peg$currPos = s0;
|
|
7611
7822
|
s0 = peg$FAILED;
|
|
@@ -7632,7 +7843,7 @@ function peg$parse(input, options) {
|
|
|
7632
7843
|
s5 = peg$parseAttributeValue();
|
|
7633
7844
|
if (s5 !== peg$FAILED) {
|
|
7634
7845
|
peg$savedPos = s0;
|
|
7635
|
-
s0 = peg$
|
|
7846
|
+
s0 = peg$f119(s1, s5);
|
|
7636
7847
|
} else {
|
|
7637
7848
|
peg$currPos = s0;
|
|
7638
7849
|
s0 = peg$FAILED;
|
|
@@ -7650,7 +7861,7 @@ function peg$parse(input, options) {
|
|
|
7650
7861
|
s1 = peg$parseIdentifier();
|
|
7651
7862
|
if (s1 !== peg$FAILED) {
|
|
7652
7863
|
peg$savedPos = s0;
|
|
7653
|
-
s1 = peg$
|
|
7864
|
+
s1 = peg$f120(s1);
|
|
7654
7865
|
}
|
|
7655
7866
|
s0 = s1;
|
|
7656
7867
|
}
|
|
@@ -7683,7 +7894,7 @@ function peg$parse(input, options) {
|
|
|
7683
7894
|
} else {
|
|
7684
7895
|
s1 = peg$FAILED;
|
|
7685
7896
|
if (peg$silentFails === 0) {
|
|
7686
|
-
peg$fail(peg$
|
|
7897
|
+
peg$fail(peg$e101);
|
|
7687
7898
|
}
|
|
7688
7899
|
}
|
|
7689
7900
|
if (s1 !== peg$FAILED) {
|
|
@@ -7695,7 +7906,7 @@ function peg$parse(input, options) {
|
|
|
7695
7906
|
} else {
|
|
7696
7907
|
s1 = peg$FAILED;
|
|
7697
7908
|
if (peg$silentFails === 0) {
|
|
7698
|
-
peg$fail(peg$
|
|
7909
|
+
peg$fail(peg$e101);
|
|
7699
7910
|
}
|
|
7700
7911
|
}
|
|
7701
7912
|
}
|
|
@@ -7715,7 +7926,7 @@ function peg$parse(input, options) {
|
|
|
7715
7926
|
if (s0 === peg$FAILED) {
|
|
7716
7927
|
s1 = peg$FAILED;
|
|
7717
7928
|
if (peg$silentFails === 0) {
|
|
7718
|
-
peg$fail(peg$
|
|
7929
|
+
peg$fail(peg$e102);
|
|
7719
7930
|
}
|
|
7720
7931
|
}
|
|
7721
7932
|
return s0;
|
|
@@ -7740,7 +7951,7 @@ function peg$parse(input, options) {
|
|
|
7740
7951
|
} else {
|
|
7741
7952
|
s3 = peg$FAILED;
|
|
7742
7953
|
if (peg$silentFails === 0) {
|
|
7743
|
-
peg$fail(peg$
|
|
7954
|
+
peg$fail(peg$e103);
|
|
7744
7955
|
}
|
|
7745
7956
|
}
|
|
7746
7957
|
while (s3 !== peg$FAILED) {
|
|
@@ -7751,17 +7962,17 @@ function peg$parse(input, options) {
|
|
|
7751
7962
|
} else {
|
|
7752
7963
|
s3 = peg$FAILED;
|
|
7753
7964
|
if (peg$silentFails === 0) {
|
|
7754
|
-
peg$fail(peg$
|
|
7965
|
+
peg$fail(peg$e103);
|
|
7755
7966
|
}
|
|
7756
7967
|
}
|
|
7757
7968
|
}
|
|
7758
7969
|
if (input.charCodeAt(peg$currPos) === 10) {
|
|
7759
|
-
s3 = peg$
|
|
7970
|
+
s3 = peg$c88;
|
|
7760
7971
|
peg$currPos++;
|
|
7761
7972
|
} else {
|
|
7762
7973
|
s3 = peg$FAILED;
|
|
7763
7974
|
if (peg$silentFails === 0) {
|
|
7764
|
-
peg$fail(peg$
|
|
7975
|
+
peg$fail(peg$e104);
|
|
7765
7976
|
}
|
|
7766
7977
|
}
|
|
7767
7978
|
if (s3 === peg$FAILED) {
|
|
@@ -7814,13 +8025,13 @@ function peg$parse(input, options) {
|
|
|
7814
8025
|
s3 = peg$currPos;
|
|
7815
8026
|
s4 = peg$currPos;
|
|
7816
8027
|
peg$silentFails++;
|
|
7817
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7818
|
-
s5 = peg$
|
|
8028
|
+
if (input.substr(peg$currPos, 2) === peg$c89) {
|
|
8029
|
+
s5 = peg$c89;
|
|
7819
8030
|
peg$currPos += 2;
|
|
7820
8031
|
} else {
|
|
7821
8032
|
s5 = peg$FAILED;
|
|
7822
8033
|
if (peg$silentFails === 0) {
|
|
7823
|
-
peg$fail(peg$
|
|
8034
|
+
peg$fail(peg$e105);
|
|
7824
8035
|
}
|
|
7825
8036
|
}
|
|
7826
8037
|
peg$silentFails--;
|
|
@@ -7856,13 +8067,13 @@ function peg$parse(input, options) {
|
|
|
7856
8067
|
s3 = peg$currPos;
|
|
7857
8068
|
s4 = peg$currPos;
|
|
7858
8069
|
peg$silentFails++;
|
|
7859
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7860
|
-
s5 = peg$
|
|
8070
|
+
if (input.substr(peg$currPos, 2) === peg$c89) {
|
|
8071
|
+
s5 = peg$c89;
|
|
7861
8072
|
peg$currPos += 2;
|
|
7862
8073
|
} else {
|
|
7863
8074
|
s5 = peg$FAILED;
|
|
7864
8075
|
if (peg$silentFails === 0) {
|
|
7865
|
-
peg$fail(peg$
|
|
8076
|
+
peg$fail(peg$e105);
|
|
7866
8077
|
}
|
|
7867
8078
|
}
|
|
7868
8079
|
peg$silentFails--;
|
|
@@ -7894,13 +8105,13 @@ function peg$parse(input, options) {
|
|
|
7894
8105
|
s3 = peg$FAILED;
|
|
7895
8106
|
}
|
|
7896
8107
|
}
|
|
7897
|
-
if (input.substr(peg$currPos, 2) === peg$
|
|
7898
|
-
s3 = peg$
|
|
8108
|
+
if (input.substr(peg$currPos, 2) === peg$c89) {
|
|
8109
|
+
s3 = peg$c89;
|
|
7899
8110
|
peg$currPos += 2;
|
|
7900
8111
|
} else {
|
|
7901
8112
|
s3 = peg$FAILED;
|
|
7902
8113
|
if (peg$silentFails === 0) {
|
|
7903
|
-
peg$fail(peg$
|
|
8114
|
+
peg$fail(peg$e105);
|
|
7904
8115
|
}
|
|
7905
8116
|
}
|
|
7906
8117
|
if (s3 !== peg$FAILED) {
|
|
@@ -8075,6 +8286,7 @@ var GRAMMAR_ELEMENTS = {
|
|
|
8075
8286
|
component: "Component",
|
|
8076
8287
|
use: "ComponentUse",
|
|
8077
8288
|
slot: "Slot",
|
|
8289
|
+
repeat: "Repeat",
|
|
8078
8290
|
header: "Header",
|
|
8079
8291
|
main: "Main",
|
|
8080
8292
|
footer: "Footer",
|
|
@@ -8174,6 +8386,7 @@ var GRAMMAR_CHILD_KEYWORDS = [
|
|
|
8174
8386
|
"group",
|
|
8175
8387
|
"marker",
|
|
8176
8388
|
"annotations",
|
|
8389
|
+
"repeat",
|
|
8177
8390
|
"layout",
|
|
8178
8391
|
"component",
|
|
8179
8392
|
"use",
|
|
@@ -8565,6 +8778,16 @@ function printNodeLines(node, depth) {
|
|
|
8565
8778
|
return componentDefinitionLines(node, depth);
|
|
8566
8779
|
case "ComponentUse":
|
|
8567
8780
|
return componentUseLines(node, depth);
|
|
8781
|
+
// `repeat 6 { … }` — the count prints bare, as the grammar's positional
|
|
8782
|
+
// `Integer`, which is why this cannot go through `containerLines` (that
|
|
8783
|
+
// helper's only pre-attribute segment is an optional *quoted* label).
|
|
8784
|
+
case "Repeat":
|
|
8785
|
+
return blockLines(
|
|
8786
|
+
depth,
|
|
8787
|
+
["repeat", integerSegment(node, "count"), ...attrSegments(node, ["count"], node.type)],
|
|
8788
|
+
childrenLines(node, depth),
|
|
8789
|
+
"required"
|
|
8790
|
+
);
|
|
8568
8791
|
// -- containers without a label ----------------------------------------
|
|
8569
8792
|
case "Header":
|
|
8570
8793
|
case "Main":
|
|
@@ -12942,6 +13165,11 @@ var ATTRIBUTE_SPECS = [
|
|
|
12942
13165
|
type: "object[]",
|
|
12943
13166
|
description: "Typed application state declarations owned by a page or shared layout"
|
|
12944
13167
|
},
|
|
13168
|
+
{
|
|
13169
|
+
name: "variants",
|
|
13170
|
+
type: "string[]",
|
|
13171
|
+
description: "Named state variants of this page \u2014 each one renders the page again as a screen of its own"
|
|
13172
|
+
},
|
|
12945
13173
|
{
|
|
12946
13174
|
name: "id",
|
|
12947
13175
|
type: "string",
|
|
@@ -13059,7 +13287,8 @@ var COMPONENT_METADATA = {
|
|
|
13059
13287
|
"device",
|
|
13060
13288
|
"centered",
|
|
13061
13289
|
"uses",
|
|
13062
|
-
"states"
|
|
13290
|
+
"states",
|
|
13291
|
+
"variants"
|
|
13063
13292
|
],
|
|
13064
13293
|
hasChildren: true,
|
|
13065
13294
|
description: "Root container for a wireframe page. Multiple pages in one .wf file lay out side-by-side on a canvas; use at(x, y) for explicit placement, or omit for auto-flow. Give it uses=<layout> to draw it inside a shared layout instead of restating the shell."
|
|
@@ -13091,6 +13320,12 @@ var COMPONENT_METADATA = {
|
|
|
13091
13320
|
hasChildren: false,
|
|
13092
13321
|
description: "Mark content insertion: bare inside a layout, or named inside a reusable component."
|
|
13093
13322
|
},
|
|
13323
|
+
repeat: {
|
|
13324
|
+
category: "structure",
|
|
13325
|
+
attributes: [],
|
|
13326
|
+
hasChildren: true,
|
|
13327
|
+
description: "Draw the same body a fixed number of times: `repeat 6 { use skeletonCard() }`. The count is positional, and there is deliberately no index variable \u2014 every copy is identical, because copies that differ are data binding rather than a wireframe."
|
|
13328
|
+
},
|
|
13094
13329
|
header: {
|
|
13095
13330
|
category: "layout",
|
|
13096
13331
|
attributes: [...BOX_ATTRIBUTES, ...CONTAINER_ATTRIBUTES],
|
|
@@ -13728,6 +13963,8 @@ function pageTitle(page) {
|
|
|
13728
13963
|
const title = page.title?.trim();
|
|
13729
13964
|
return title !== void 0 && title.length > 0 ? title : void 0;
|
|
13730
13965
|
}
|
|
13966
|
+
var VARIANT_SEPARATOR = "#";
|
|
13967
|
+
var variantName = (name, variant) => `${name}${VARIANT_SEPARATOR}${variant}`;
|
|
13731
13968
|
function hasSlot(layout) {
|
|
13732
13969
|
let found = false;
|
|
13733
13970
|
for (const child of layout.children) {
|
|
@@ -13759,7 +13996,10 @@ function resolveShell(page, layouts) {
|
|
|
13759
13996
|
function buildSiteModel(doc) {
|
|
13760
13997
|
const pages = documentPages(doc);
|
|
13761
13998
|
const layouts = layoutsByName(doc);
|
|
13762
|
-
const screens = pages.map((page, index) =>
|
|
13999
|
+
const screens = pages.map((page, index) => {
|
|
14000
|
+
const variant = page.variant?.trim();
|
|
14001
|
+
return variant !== void 0 && variant.length > 0 ? { index, page, variant } : { index, page };
|
|
14002
|
+
});
|
|
13763
14003
|
const shells = [];
|
|
13764
14004
|
const shellByName = /* @__PURE__ */ new Map();
|
|
13765
14005
|
screens.forEach((screen) => {
|
|
@@ -13793,7 +14033,26 @@ function buildSiteModel(doc) {
|
|
|
13793
14033
|
}
|
|
13794
14034
|
}
|
|
13795
14035
|
for (const screen of screens) {
|
|
13796
|
-
|
|
14036
|
+
if (screen.variant === void 0) continue;
|
|
14037
|
+
for (const declared of [pageId(screen.page), pageTitle(screen.page)]) {
|
|
14038
|
+
if (declared === void 0) continue;
|
|
14039
|
+
const owner = names.get(declared);
|
|
14040
|
+
if (owner === void 0) continue;
|
|
14041
|
+
const winner = screens[owner].page;
|
|
14042
|
+
if (pageId(winner) !== pageId(screen.page) || pageTitle(winner) !== pageTitle(screen.page)) {
|
|
14043
|
+
continue;
|
|
14044
|
+
}
|
|
14045
|
+
const qualified = variantName(declared, screen.variant);
|
|
14046
|
+
if (!names.has(qualified)) names.set(qualified, screen.index);
|
|
14047
|
+
}
|
|
14048
|
+
}
|
|
14049
|
+
for (const screen of screens) {
|
|
14050
|
+
const bare = [pageId(screen.page), pageTitle(screen.page)];
|
|
14051
|
+
const variant = screen.variant;
|
|
14052
|
+
const declared = variant === void 0 ? bare : [
|
|
14053
|
+
...bare.map((name) => name === void 0 ? void 0 : variantName(name, variant)),
|
|
14054
|
+
...bare
|
|
14055
|
+
];
|
|
13797
14056
|
screen.name = declared.find(
|
|
13798
14057
|
(name) => name !== void 0 && names.get(name) === screen.index
|
|
13799
14058
|
);
|
|
@@ -61664,6 +61923,7 @@ var HtmlRenderer = class extends BaseRenderer {
|
|
|
61664
61923
|
* enabled so `renderNode` / `renderPage` can inject each node's path.
|
|
61665
61924
|
*/
|
|
61666
61925
|
render(document) {
|
|
61926
|
+
document = expandRepeats(document);
|
|
61667
61927
|
if (this.context.options.sourceAnchors) {
|
|
61668
61928
|
this.pathMap = buildAnchorPathMap(document, this.pageIndexBase);
|
|
61669
61929
|
}
|
|
@@ -62344,7 +62604,8 @@ function wrapBoard(pageHtml, placed, prefix) {
|
|
|
62344
62604
|
const { x, y, w, h, page } = placed;
|
|
62345
62605
|
const positionStyle = `position: absolute; left: ${x}px; top: ${y}px; width: ${w}px; height: ${h}px;`;
|
|
62346
62606
|
const titleAttr = page.title ? ` data-page-title="${escapeAttr(page.title)}"` : "";
|
|
62347
|
-
const
|
|
62607
|
+
const variantAttr = page.variant ? ` data-wf-variant="${escapeAttr(page.variant)}"` : "";
|
|
62608
|
+
const dataAttrs = ` data-page-x="${x}" data-page-y="${y}" data-page-w="${w}" data-page-h="${h}"${titleAttr}${variantAttr}`;
|
|
62348
62609
|
return `<div class="${prefix}-canvas-board" style="${positionStyle}"${dataAttrs}>
|
|
62349
62610
|
${pageHtml}
|
|
62350
62611
|
</div>`;
|
|
@@ -62931,6 +63192,7 @@ function renderHostedScreen(screen, shell, make, prefix) {
|
|
|
62931
63192
|
const marks = attrs([
|
|
62932
63193
|
["data-screen", String(screen.index)],
|
|
62933
63194
|
["data-screen-name", screen.name],
|
|
63195
|
+
["data-wf-variant", screen.variant],
|
|
62934
63196
|
[ID_SCOPE_ATTR, scope],
|
|
62935
63197
|
["data-wf-viewport-conflict", conflict]
|
|
62936
63198
|
]);
|
|
@@ -62944,6 +63206,7 @@ function renderStandaloneScreen(screen, make, prefix) {
|
|
|
62944
63206
|
const marks = attrs([
|
|
62945
63207
|
["data-screen", String(screen.index)],
|
|
62946
63208
|
["data-screen-name", screen.name],
|
|
63209
|
+
["data-wf-variant", screen.variant],
|
|
62947
63210
|
[ID_SCOPE_ATTR, scope],
|
|
62948
63211
|
["data-wf-uses-unresolved", screen.miss?.uses],
|
|
62949
63212
|
["data-wf-uses-reason", screen.miss?.reason]
|
|
@@ -63012,6 +63275,7 @@ function compactRuntimeInteractions(model, interactions) {
|
|
|
63012
63275
|
}
|
|
63013
63276
|
function renderSite(document, options = {}) {
|
|
63014
63277
|
const prefix = options.classPrefix ?? DEFAULT_PREFIX2;
|
|
63278
|
+
document = expandRepeats(expandVariants(document));
|
|
63015
63279
|
const model = buildSiteModel(document);
|
|
63016
63280
|
const interactionModel = collectInteractions(document);
|
|
63017
63281
|
const make = (idScope) => new HtmlRenderer({
|
|
@@ -63080,6 +63344,7 @@ ${runtime}
|
|
|
63080
63344
|
|
|
63081
63345
|
// src/renderer/index.ts
|
|
63082
63346
|
function render(document, options = {}) {
|
|
63347
|
+
document = expandVariants(document);
|
|
63083
63348
|
const isMultiPage = documentPages(document).length > 1;
|
|
63084
63349
|
if (isMultiPage) {
|
|
63085
63350
|
const result = renderCanvas(document, options);
|
|
@@ -63089,6 +63354,7 @@ function render(document, options = {}) {
|
|
|
63089
63354
|
return renderer.render(document);
|
|
63090
63355
|
}
|
|
63091
63356
|
function renderToHtml(document, options = {}) {
|
|
63357
|
+
document = expandVariants(document);
|
|
63092
63358
|
const { html, css } = render(document, options);
|
|
63093
63359
|
const prefix = options.classPrefix ?? "wf";
|
|
63094
63360
|
const isMultiPage = documentPages(document).length > 1;
|
|
@@ -63130,6 +63396,7 @@ ${html}
|
|
|
63130
63396
|
</html>`;
|
|
63131
63397
|
}
|
|
63132
63398
|
function renderToSvg(document, options = {}) {
|
|
63399
|
+
document = expandVariants(document);
|
|
63133
63400
|
const isMultiPage = documentPages(document).length > 1;
|
|
63134
63401
|
let width = options.width ?? 800;
|
|
63135
63402
|
let height = options.height ?? 600;
|
|
@@ -63202,7 +63469,8 @@ var POSITIONAL_PROPS = {
|
|
|
63202
63469
|
Layout: ["name"],
|
|
63203
63470
|
Component: ["name"],
|
|
63204
63471
|
ComponentUse: ["name", "namespace"],
|
|
63205
|
-
Slot: ["name"]
|
|
63472
|
+
Slot: ["name"],
|
|
63473
|
+
Repeat: ["count"]
|
|
63206
63474
|
};
|
|
63207
63475
|
function declaredName(value) {
|
|
63208
63476
|
const name = value?.trim();
|
|
@@ -65513,6 +65781,8 @@ export {
|
|
|
65513
65781
|
INTERACTIVE_ATTR_NAMES,
|
|
65514
65782
|
LUCIDE_ICON_NAMES,
|
|
65515
65783
|
NODE_TYPE_MAP,
|
|
65784
|
+
REPEAT_EXPANSION_BUDGET,
|
|
65785
|
+
RepeatBudgetError,
|
|
65516
65786
|
TYPED_INTERACTION_ATTR,
|
|
65517
65787
|
VALID_ATTRIBUTE_NAMES,
|
|
65518
65788
|
VALID_COMPONENT_NAMES,
|
|
@@ -65539,6 +65809,8 @@ export {
|
|
|
65539
65809
|
diff,
|
|
65540
65810
|
documentDefinitions,
|
|
65541
65811
|
documentPages,
|
|
65812
|
+
expandRepeats,
|
|
65813
|
+
expandVariants,
|
|
65542
65814
|
exportToFigma,
|
|
65543
65815
|
exportToFigmaString,
|
|
65544
65816
|
exportToJson,
|