@wireweave/core 3.1.0-beta.6 → 3.1.0-beta.7

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.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,82 @@ 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
+
358
435
  // src/parser/generated-parser.js
359
436
  var peg$SyntaxError = class extends SyntaxError {
360
437
  constructor(message, expected, found, location) {
@@ -484,75 +561,76 @@ function peg$parse(input, options) {
484
561
  const peg$c17 = "\r\n";
485
562
  const peg$c18 = "//";
486
563
  const peg$c19 = "/*";
487
- const peg$c20 = "header";
488
- const peg$c21 = "main";
489
- const peg$c22 = "footer";
490
- const peg$c23 = "sidebar";
491
- const peg$c24 = "row";
492
- const peg$c25 = "col";
493
- const peg$c26 = "stack";
494
- const peg$c27 = "relative";
495
- const peg$c28 = "card";
496
- const peg$c29 = "modal";
497
- const peg$c30 = "drawer";
498
- const peg$c31 = "accordion";
499
- const peg$c32 = "section";
500
- const peg$c33 = "text";
501
- const peg$c34 = "title";
502
- const peg$c35 = "link";
503
- const peg$c36 = "button";
504
- const peg$c37 = "input";
505
- const peg$c38 = "textarea";
506
- const peg$c39 = "select";
507
- const peg$c40 = "checkbox";
508
- const peg$c41 = "radio";
509
- const peg$c42 = "switch";
510
- const peg$c43 = "slider";
511
- const peg$c44 = "image";
512
- const peg$c45 = "placeholder";
513
- const peg$c46 = "avatar";
514
- const peg$c47 = "badge";
515
- const peg$c48 = "icon";
516
- const peg$c49 = "table";
517
- const peg$c50 = "[";
518
- const peg$c51 = "]";
519
- const peg$c52 = "columns";
520
- const peg$c53 = "list";
521
- const peg$c54 = "item";
522
- const peg$c55 = "alert";
523
- const peg$c56 = "toast";
524
- const peg$c57 = "progress";
525
- const peg$c58 = "spinner";
526
- const peg$c59 = "tooltip";
527
- const peg$c60 = "popover";
528
- const peg$c61 = "dropdown";
529
- const peg$c62 = "divider";
530
- const peg$c63 = "nav";
531
- const peg$c64 = "group";
532
- const peg$c65 = "tabs";
533
- const peg$c66 = "tab";
534
- const peg$c67 = "breadcrumb";
535
- const peg$c68 = "marker";
536
- const peg$c69 = "annotations";
537
- const peg$c70 = "at";
538
- const peg$c71 = '"';
539
- const peg$c72 = "'";
540
- const peg$c73 = "\\";
541
- const peg$c74 = "n";
542
- const peg$c75 = "r";
543
- const peg$c76 = "t";
544
- const peg$c77 = "-";
545
- const peg$c78 = ".";
546
- const peg$c79 = "px";
547
- const peg$c80 = "%";
548
- const peg$c81 = "em";
549
- const peg$c82 = "rem";
550
- const peg$c83 = "vh";
551
- const peg$c84 = "vw";
552
- const peg$c85 = "true";
553
- const peg$c86 = "false";
554
- const peg$c87 = "\n";
555
- const peg$c88 = "*/";
564
+ const peg$c20 = "repeat";
565
+ const peg$c21 = "header";
566
+ const peg$c22 = "main";
567
+ const peg$c23 = "footer";
568
+ const peg$c24 = "sidebar";
569
+ const peg$c25 = "row";
570
+ const peg$c26 = "col";
571
+ const peg$c27 = "stack";
572
+ const peg$c28 = "relative";
573
+ const peg$c29 = "card";
574
+ const peg$c30 = "modal";
575
+ const peg$c31 = "drawer";
576
+ const peg$c32 = "accordion";
577
+ const peg$c33 = "section";
578
+ const peg$c34 = "text";
579
+ const peg$c35 = "title";
580
+ const peg$c36 = "link";
581
+ const peg$c37 = "button";
582
+ const peg$c38 = "input";
583
+ const peg$c39 = "textarea";
584
+ const peg$c40 = "select";
585
+ const peg$c41 = "checkbox";
586
+ const peg$c42 = "radio";
587
+ const peg$c43 = "switch";
588
+ const peg$c44 = "slider";
589
+ const peg$c45 = "image";
590
+ const peg$c46 = "placeholder";
591
+ const peg$c47 = "avatar";
592
+ const peg$c48 = "badge";
593
+ const peg$c49 = "icon";
594
+ const peg$c50 = "table";
595
+ const peg$c51 = "[";
596
+ const peg$c52 = "]";
597
+ const peg$c53 = "columns";
598
+ const peg$c54 = "list";
599
+ const peg$c55 = "item";
600
+ const peg$c56 = "alert";
601
+ const peg$c57 = "toast";
602
+ const peg$c58 = "progress";
603
+ const peg$c59 = "spinner";
604
+ const peg$c60 = "tooltip";
605
+ const peg$c61 = "popover";
606
+ const peg$c62 = "dropdown";
607
+ const peg$c63 = "divider";
608
+ const peg$c64 = "nav";
609
+ const peg$c65 = "group";
610
+ const peg$c66 = "tabs";
611
+ const peg$c67 = "tab";
612
+ const peg$c68 = "breadcrumb";
613
+ const peg$c69 = "marker";
614
+ const peg$c70 = "annotations";
615
+ const peg$c71 = "at";
616
+ const peg$c72 = '"';
617
+ const peg$c73 = "'";
618
+ const peg$c74 = "\\";
619
+ const peg$c75 = "n";
620
+ const peg$c76 = "r";
621
+ const peg$c77 = "t";
622
+ const peg$c78 = "-";
623
+ const peg$c79 = ".";
624
+ const peg$c80 = "px";
625
+ const peg$c81 = "%";
626
+ const peg$c82 = "em";
627
+ const peg$c83 = "rem";
628
+ const peg$c84 = "vh";
629
+ const peg$c85 = "vw";
630
+ const peg$c86 = "true";
631
+ const peg$c87 = "false";
632
+ const peg$c88 = "\n";
633
+ const peg$c89 = "*/";
556
634
  const peg$r0 = /^[ \t]/;
557
635
  const peg$r1 = /^[\n\r}]/;
558
636
  const peg$r2 = /^[0-9]/;
@@ -584,88 +662,89 @@ function peg$parse(input, options) {
584
662
  const peg$e20 = peg$literalExpectation("//", false);
585
663
  const peg$e21 = peg$literalExpectation("/*", false);
586
664
  const peg$e22 = peg$anyExpectation();
587
- const peg$e23 = peg$literalExpectation("header", false);
588
- const peg$e24 = peg$literalExpectation("main", false);
589
- const peg$e25 = peg$literalExpectation("footer", false);
590
- const peg$e26 = peg$literalExpectation("sidebar", false);
591
- const peg$e27 = peg$literalExpectation("row", false);
592
- const peg$e28 = peg$literalExpectation("col", false);
593
- const peg$e29 = peg$literalExpectation("stack", false);
594
- const peg$e30 = peg$literalExpectation("relative", false);
595
- const peg$e31 = peg$literalExpectation("card", false);
596
- const peg$e32 = peg$literalExpectation("modal", false);
597
- const peg$e33 = peg$literalExpectation("drawer", false);
598
- const peg$e34 = peg$literalExpectation("accordion", false);
599
- const peg$e35 = peg$literalExpectation("section", false);
600
- const peg$e36 = peg$literalExpectation("text", false);
601
- const peg$e37 = peg$literalExpectation("title", false);
602
- const peg$e38 = peg$literalExpectation("link", false);
603
- const peg$e39 = peg$literalExpectation("button", false);
604
- const peg$e40 = peg$literalExpectation("input", false);
605
- const peg$e41 = peg$literalExpectation("textarea", false);
606
- const peg$e42 = peg$literalExpectation("select", false);
607
- const peg$e43 = peg$literalExpectation("checkbox", false);
608
- const peg$e44 = peg$literalExpectation("radio", false);
609
- const peg$e45 = peg$literalExpectation("switch", false);
610
- const peg$e46 = peg$literalExpectation("slider", false);
611
- const peg$e47 = peg$literalExpectation("image", false);
612
- const peg$e48 = peg$literalExpectation("placeholder", false);
613
- const peg$e49 = peg$literalExpectation("avatar", false);
614
- const peg$e50 = peg$literalExpectation("badge", false);
615
- const peg$e51 = peg$literalExpectation("icon", false);
616
- const peg$e52 = peg$literalExpectation("table", false);
617
- const peg$e53 = peg$literalExpectation("[", false);
618
- const peg$e54 = peg$literalExpectation("]", false);
619
- const peg$e55 = peg$literalExpectation("columns", false);
620
- const peg$e56 = peg$literalExpectation("list", false);
621
- const peg$e57 = peg$literalExpectation("item", false);
622
- const peg$e58 = peg$literalExpectation("alert", false);
623
- const peg$e59 = peg$literalExpectation("toast", false);
624
- const peg$e60 = peg$literalExpectation("progress", false);
625
- const peg$e61 = peg$literalExpectation("spinner", false);
626
- const peg$e62 = peg$literalExpectation("tooltip", false);
627
- const peg$e63 = peg$literalExpectation("popover", false);
628
- const peg$e64 = peg$literalExpectation("dropdown", false);
629
- const peg$e65 = peg$literalExpectation("divider", false);
630
- const peg$e66 = peg$literalExpectation("nav", false);
631
- const peg$e67 = peg$literalExpectation("group", false);
632
- const peg$e68 = peg$literalExpectation("tabs", false);
633
- const peg$e69 = peg$literalExpectation("tab", false);
634
- const peg$e70 = peg$literalExpectation("breadcrumb", false);
635
- const peg$e71 = peg$literalExpectation("marker", false);
636
- const peg$e72 = peg$literalExpectation("annotations", false);
637
- const peg$e73 = peg$otherExpectation("integer");
638
- const peg$e74 = peg$classExpectation([["0", "9"]], false, false, false);
639
- const peg$e75 = peg$literalExpectation("at", false);
640
- const peg$e76 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
641
- const peg$e77 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
642
- const peg$e78 = peg$otherExpectation("string");
643
- const peg$e79 = peg$literalExpectation('"', false);
644
- const peg$e80 = peg$literalExpectation("'", false);
645
- const peg$e81 = peg$literalExpectation("\\", false);
646
- const peg$e82 = peg$literalExpectation("n", false);
647
- const peg$e83 = peg$literalExpectation("r", false);
648
- const peg$e84 = peg$literalExpectation("t", false);
649
- const peg$e85 = peg$otherExpectation("number");
650
- const peg$e86 = peg$literalExpectation("-", false);
651
- const peg$e87 = peg$literalExpectation(".", false);
652
- const peg$e88 = peg$otherExpectation("value with unit");
653
- const peg$e89 = peg$literalExpectation("px", false);
654
- const peg$e90 = peg$literalExpectation("%", false);
655
- const peg$e91 = peg$literalExpectation("em", false);
656
- const peg$e92 = peg$literalExpectation("rem", false);
657
- const peg$e93 = peg$literalExpectation("vh", false);
658
- const peg$e94 = peg$literalExpectation("vw", false);
659
- const peg$e95 = peg$otherExpectation("boolean");
660
- const peg$e96 = peg$literalExpectation("true", false);
661
- const peg$e97 = peg$literalExpectation("false", false);
662
- const peg$e98 = peg$otherExpectation("identifier");
663
- const peg$e99 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
664
- const peg$e100 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
665
- const peg$e101 = peg$otherExpectation("comment");
666
- const peg$e102 = peg$classExpectation(["\n"], true, false, false);
667
- const peg$e103 = peg$literalExpectation("\n", false);
668
- const peg$e104 = peg$literalExpectation("*/", false);
665
+ const peg$e23 = peg$literalExpectation("repeat", false);
666
+ const peg$e24 = peg$literalExpectation("header", false);
667
+ const peg$e25 = peg$literalExpectation("main", false);
668
+ const peg$e26 = peg$literalExpectation("footer", false);
669
+ const peg$e27 = peg$literalExpectation("sidebar", false);
670
+ const peg$e28 = peg$literalExpectation("row", false);
671
+ const peg$e29 = peg$literalExpectation("col", false);
672
+ const peg$e30 = peg$literalExpectation("stack", false);
673
+ const peg$e31 = peg$literalExpectation("relative", false);
674
+ const peg$e32 = peg$literalExpectation("card", false);
675
+ const peg$e33 = peg$literalExpectation("modal", false);
676
+ const peg$e34 = peg$literalExpectation("drawer", false);
677
+ const peg$e35 = peg$literalExpectation("accordion", false);
678
+ const peg$e36 = peg$literalExpectation("section", false);
679
+ const peg$e37 = peg$literalExpectation("text", false);
680
+ const peg$e38 = peg$literalExpectation("title", false);
681
+ const peg$e39 = peg$literalExpectation("link", false);
682
+ const peg$e40 = peg$literalExpectation("button", false);
683
+ const peg$e41 = peg$literalExpectation("input", false);
684
+ const peg$e42 = peg$literalExpectation("textarea", false);
685
+ const peg$e43 = peg$literalExpectation("select", false);
686
+ const peg$e44 = peg$literalExpectation("checkbox", false);
687
+ const peg$e45 = peg$literalExpectation("radio", false);
688
+ const peg$e46 = peg$literalExpectation("switch", false);
689
+ const peg$e47 = peg$literalExpectation("slider", false);
690
+ const peg$e48 = peg$literalExpectation("image", false);
691
+ const peg$e49 = peg$literalExpectation("placeholder", false);
692
+ const peg$e50 = peg$literalExpectation("avatar", false);
693
+ const peg$e51 = peg$literalExpectation("badge", false);
694
+ const peg$e52 = peg$literalExpectation("icon", false);
695
+ const peg$e53 = peg$literalExpectation("table", false);
696
+ const peg$e54 = peg$literalExpectation("[", false);
697
+ const peg$e55 = peg$literalExpectation("]", false);
698
+ const peg$e56 = peg$literalExpectation("columns", false);
699
+ const peg$e57 = peg$literalExpectation("list", false);
700
+ const peg$e58 = peg$literalExpectation("item", false);
701
+ const peg$e59 = peg$literalExpectation("alert", false);
702
+ const peg$e60 = peg$literalExpectation("toast", false);
703
+ const peg$e61 = peg$literalExpectation("progress", false);
704
+ const peg$e62 = peg$literalExpectation("spinner", false);
705
+ const peg$e63 = peg$literalExpectation("tooltip", false);
706
+ const peg$e64 = peg$literalExpectation("popover", false);
707
+ const peg$e65 = peg$literalExpectation("dropdown", false);
708
+ const peg$e66 = peg$literalExpectation("divider", false);
709
+ const peg$e67 = peg$literalExpectation("nav", false);
710
+ const peg$e68 = peg$literalExpectation("group", false);
711
+ const peg$e69 = peg$literalExpectation("tabs", false);
712
+ const peg$e70 = peg$literalExpectation("tab", false);
713
+ const peg$e71 = peg$literalExpectation("breadcrumb", false);
714
+ const peg$e72 = peg$literalExpectation("marker", false);
715
+ const peg$e73 = peg$literalExpectation("annotations", false);
716
+ const peg$e74 = peg$otherExpectation("integer");
717
+ const peg$e75 = peg$classExpectation([["0", "9"]], false, false, false);
718
+ const peg$e76 = peg$literalExpectation("at", false);
719
+ const peg$e77 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
720
+ const peg$e78 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
721
+ const peg$e79 = peg$otherExpectation("string");
722
+ const peg$e80 = peg$literalExpectation('"', false);
723
+ const peg$e81 = peg$literalExpectation("'", false);
724
+ const peg$e82 = peg$literalExpectation("\\", false);
725
+ const peg$e83 = peg$literalExpectation("n", false);
726
+ const peg$e84 = peg$literalExpectation("r", false);
727
+ const peg$e85 = peg$literalExpectation("t", false);
728
+ const peg$e86 = peg$otherExpectation("number");
729
+ const peg$e87 = peg$literalExpectation("-", false);
730
+ const peg$e88 = peg$literalExpectation(".", false);
731
+ const peg$e89 = peg$otherExpectation("value with unit");
732
+ const peg$e90 = peg$literalExpectation("px", false);
733
+ const peg$e91 = peg$literalExpectation("%", false);
734
+ const peg$e92 = peg$literalExpectation("em", false);
735
+ const peg$e93 = peg$literalExpectation("rem", false);
736
+ const peg$e94 = peg$literalExpectation("vh", false);
737
+ const peg$e95 = peg$literalExpectation("vw", false);
738
+ const peg$e96 = peg$otherExpectation("boolean");
739
+ const peg$e97 = peg$literalExpectation("true", false);
740
+ const peg$e98 = peg$literalExpectation("false", false);
741
+ const peg$e99 = peg$otherExpectation("identifier");
742
+ const peg$e100 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
743
+ const peg$e101 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
744
+ const peg$e102 = peg$otherExpectation("comment");
745
+ const peg$e103 = peg$classExpectation(["\n"], true, false, false);
746
+ const peg$e104 = peg$literalExpectation("\n", false);
747
+ const peg$e105 = peg$literalExpectation("*/", false);
669
748
  function peg$f0(children) {
670
749
  return createNode("Document", {
671
750
  children: children.map((c) => c[0]).filter((c) => c !== null)
@@ -746,114 +825,120 @@ function peg$parse(input, options) {
746
825
  function peg$f18() {
747
826
  return null;
748
827
  }
749
- function peg$f19(attrs2, children) {
828
+ function peg$f19(count, children) {
829
+ return createNode("Repeat", {
830
+ count,
831
+ children
832
+ });
833
+ }
834
+ function peg$f20(attrs2, children) {
750
835
  return createNode("Header", {
751
836
  ...attrsToObject(attrs2),
752
837
  children
753
838
  });
754
839
  }
755
- function peg$f20(attrs2, children) {
840
+ function peg$f21(attrs2, children) {
756
841
  return createNode("Main", {
757
842
  ...attrsToObject(attrs2),
758
843
  children
759
844
  });
760
845
  }
761
- function peg$f21(attrs2, children) {
846
+ function peg$f22(attrs2, children) {
762
847
  return createNode("Footer", {
763
848
  ...attrsToObject(attrs2),
764
849
  children
765
850
  });
766
851
  }
767
- function peg$f22(attrs2, children) {
852
+ function peg$f23(attrs2, children) {
768
853
  return createNode("Sidebar", {
769
854
  ...attrsToObject(attrs2),
770
855
  children
771
856
  });
772
857
  }
773
- function peg$f23(attrs2, children) {
858
+ function peg$f24(attrs2, children) {
774
859
  return createNode("Row", {
775
860
  ...attrsToObject(attrs2),
776
861
  children
777
862
  });
778
863
  }
779
- function peg$f24(attrs2, children) {
864
+ function peg$f25(attrs2, children) {
780
865
  return createNode("Col", {
781
866
  ...attrsToObject(attrs2),
782
867
  children
783
868
  });
784
869
  }
785
- function peg$f25(attrs2, children) {
870
+ function peg$f26(attrs2, children) {
786
871
  return createNode("Stack", {
787
872
  ...attrsToObject(attrs2),
788
873
  children
789
874
  });
790
875
  }
791
- function peg$f26(attrs2, children) {
876
+ function peg$f27(attrs2, children) {
792
877
  return createNode("Relative", {
793
878
  ...attrsToObject(attrs2),
794
879
  children
795
880
  });
796
881
  }
797
- function peg$f27(label, attrs2, children) {
882
+ function peg$f28(label, attrs2, children) {
798
883
  return createNode("Card", {
799
884
  title: label || null,
800
885
  ...attrsToObject(attrs2),
801
886
  children
802
887
  });
803
888
  }
804
- function peg$f28(label, attrs2, children) {
889
+ function peg$f29(label, attrs2, children) {
805
890
  return createNode("Modal", {
806
891
  title: label || null,
807
892
  ...attrsToObject(attrs2),
808
893
  children
809
894
  });
810
895
  }
811
- function peg$f29(label, attrs2, children) {
896
+ function peg$f30(label, attrs2, children) {
812
897
  return createNode("Drawer", {
813
898
  title: label || null,
814
899
  ...attrsToObject(attrs2),
815
900
  children
816
901
  });
817
902
  }
818
- function peg$f30(label, attrs2, children) {
903
+ function peg$f31(label, attrs2, children) {
819
904
  return createNode("Accordion", {
820
905
  title: label || null,
821
906
  ...attrsToObject(attrs2),
822
907
  children
823
908
  });
824
909
  }
825
- function peg$f31(label, attrs2, children) {
910
+ function peg$f32(label, attrs2, children) {
826
911
  return createNode("Section", {
827
912
  title: label || null,
828
913
  ...attrsToObject(attrs2),
829
914
  children
830
915
  });
831
916
  }
832
- function peg$f32(label, attrs2) {
917
+ function peg$f33(label, attrs2) {
833
918
  return createNode("Text", {
834
919
  content: label,
835
920
  ...attrsToObject(attrs2)
836
921
  });
837
922
  }
838
- function peg$f33(label, attrs2) {
923
+ function peg$f34(label, attrs2) {
839
924
  return createNode("Title", {
840
925
  content: label,
841
926
  ...attrsToObject(attrs2)
842
927
  });
843
928
  }
844
- function peg$f34(label, attrs2) {
929
+ function peg$f35(label, attrs2) {
845
930
  return createNode("Link", {
846
931
  content: label,
847
932
  ...attrsToObject(attrs2)
848
933
  });
849
934
  }
850
- function peg$f35(label, attrs2) {
935
+ function peg$f36(label, attrs2) {
851
936
  return createNode("Button", {
852
937
  content: label,
853
938
  ...attrsToObject(attrs2)
854
939
  });
855
940
  }
856
- function peg$f36(label, attrs2) {
941
+ function peg$f37(label, attrs2) {
857
942
  const obj = attrsToObject(attrs2);
858
943
  const inputType = obj.type;
859
944
  delete obj.type;
@@ -863,75 +948,75 @@ function peg$parse(input, options) {
863
948
  ...obj
864
949
  });
865
950
  }
866
- function peg$f37(label, attrs2) {
951
+ function peg$f38(label, attrs2) {
867
952
  return createNode("Textarea", {
868
953
  label: label || null,
869
954
  ...attrsToObject(attrs2)
870
955
  });
871
956
  }
872
- function peg$f38(label, options2, attrs2) {
957
+ function peg$f39(label, options2, attrs2) {
873
958
  return createNode("Select", {
874
959
  label: label || null,
875
960
  options: options2 || [],
876
961
  ...attrsToObject(attrs2)
877
962
  });
878
963
  }
879
- function peg$f39(label, attrs2) {
964
+ function peg$f40(label, attrs2) {
880
965
  return createNode("Checkbox", {
881
966
  label: label || null,
882
967
  ...attrsToObject(attrs2)
883
968
  });
884
969
  }
885
- function peg$f40(label, attrs2) {
970
+ function peg$f41(label, attrs2) {
886
971
  return createNode("Radio", {
887
972
  label: label || null,
888
973
  ...attrsToObject(attrs2)
889
974
  });
890
975
  }
891
- function peg$f41(label, attrs2) {
976
+ function peg$f42(label, attrs2) {
892
977
  return createNode("Switch", {
893
978
  label: label || null,
894
979
  ...attrsToObject(attrs2)
895
980
  });
896
981
  }
897
- function peg$f42(label, attrs2) {
982
+ function peg$f43(label, attrs2) {
898
983
  return createNode("Slider", {
899
984
  label: label || null,
900
985
  ...attrsToObject(attrs2)
901
986
  });
902
987
  }
903
- function peg$f43(src, attrs2) {
988
+ function peg$f44(src, attrs2) {
904
989
  return createNode("Image", {
905
990
  src: src || null,
906
991
  ...attrsToObject(attrs2)
907
992
  });
908
993
  }
909
- function peg$f44(label, attrs2, block) {
994
+ function peg$f45(label, attrs2, block) {
910
995
  return createNode("Placeholder", {
911
996
  label: label || null,
912
997
  ...attrsToObject(attrs2),
913
998
  children: block ? block[2] : []
914
999
  });
915
1000
  }
916
- function peg$f45(label, attrs2) {
1001
+ function peg$f46(label, attrs2) {
917
1002
  return createNode("Avatar", {
918
1003
  name: label || null,
919
1004
  ...attrsToObject(attrs2)
920
1005
  });
921
1006
  }
922
- function peg$f46(label, attrs2) {
1007
+ function peg$f47(label, attrs2) {
923
1008
  return createNode("Badge", {
924
1009
  content: label,
925
1010
  ...attrsToObject(attrs2)
926
1011
  });
927
1012
  }
928
- function peg$f47(name, attrs2) {
1013
+ function peg$f48(name, attrs2) {
929
1014
  return createNode("Icon", {
930
1015
  name,
931
1016
  ...attrsToObject(attrs2)
932
1017
  });
933
1018
  }
934
- function peg$f48(data, attrs2) {
1019
+ function peg$f49(data, attrs2) {
935
1020
  const columns = data.length > 0 ? data[0] : [];
936
1021
  const rows = data.slice(1);
937
1022
  return createNode("Table", {
@@ -940,16 +1025,16 @@ function peg$parse(input, options) {
940
1025
  ...attrsToObject(attrs2)
941
1026
  });
942
1027
  }
943
- function peg$f49(attrs2, rows) {
1028
+ function peg$f50(attrs2, rows) {
944
1029
  return createNode("Table", {
945
1030
  ...attrsToObject(attrs2),
946
1031
  ...rows
947
1032
  });
948
1033
  }
949
- function peg$f50(first, rest) {
1034
+ function peg$f51(first, rest) {
950
1035
  return [first, ...rest.map((r) => r[2])];
951
1036
  }
952
- function peg$f51(items) {
1037
+ function peg$f52(items) {
953
1038
  const columns = [];
954
1039
  const rows = [];
955
1040
  for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
@@ -958,72 +1043,72 @@ function peg$parse(input, options) {
958
1043
  }
959
1044
  return { columns, rows };
960
1045
  }
961
- function peg$f52(values) {
1046
+ function peg$f53(values) {
962
1047
  return { kind: "columns", values };
963
1048
  }
964
- function peg$f53(values) {
1049
+ function peg$f54(values) {
965
1050
  return { kind: "row", values };
966
1051
  }
967
- function peg$f54() {
1052
+ function peg$f55() {
968
1053
  return null;
969
1054
  }
970
- function peg$f55(items, attrs2, block) {
1055
+ function peg$f56(items, attrs2, block) {
971
1056
  return createNode("List", {
972
1057
  items: items || (block ? block : []),
973
1058
  ...attrsToObject(attrs2)
974
1059
  });
975
1060
  }
976
- function peg$f56(items) {
1061
+ function peg$f57(items) {
977
1062
  return items.map((i) => i[0]).filter((i) => i !== null);
978
1063
  }
979
- function peg$f57(label, attrs2, nested) {
1064
+ function peg$f58(label, attrs2, nested) {
980
1065
  return createBlockNode("ListItem", {
981
1066
  content: label,
982
1067
  ...attrsToObject(attrs2),
983
1068
  children: nested || []
984
1069
  });
985
1070
  }
986
- function peg$f58() {
1071
+ function peg$f59() {
987
1072
  return null;
988
1073
  }
989
- function peg$f59(label, attrs2) {
1074
+ function peg$f60(label, attrs2) {
990
1075
  return createNode("Alert", {
991
1076
  content: label,
992
1077
  ...attrsToObject(attrs2)
993
1078
  });
994
1079
  }
995
- function peg$f60(label, attrs2) {
1080
+ function peg$f61(label, attrs2) {
996
1081
  return createNode("Toast", {
997
1082
  content: label,
998
1083
  ...attrsToObject(attrs2)
999
1084
  });
1000
1085
  }
1001
- function peg$f61(attrs2) {
1086
+ function peg$f62(attrs2) {
1002
1087
  return createNode("Progress", {
1003
1088
  ...attrsToObject(attrs2)
1004
1089
  });
1005
1090
  }
1006
- function peg$f62(label, attrs2) {
1091
+ function peg$f63(label, attrs2) {
1007
1092
  return createNode("Spinner", {
1008
1093
  label: label || null,
1009
1094
  ...attrsToObject(attrs2)
1010
1095
  });
1011
1096
  }
1012
- function peg$f63(label, attrs2) {
1097
+ function peg$f64(label, attrs2) {
1013
1098
  return createNode("Tooltip", {
1014
1099
  content: label,
1015
1100
  ...attrsToObject(attrs2),
1016
1101
  children: []
1017
1102
  });
1018
1103
  }
1019
- function peg$f64(label, attrs2, children) {
1104
+ function peg$f65(label, attrs2, children) {
1020
1105
  return createNode("Popover", {
1021
1106
  title: label || null,
1022
1107
  ...attrsToObject(attrs2),
1023
1108
  children
1024
1109
  });
1025
1110
  }
1026
- function peg$f65(items, attrs2) {
1111
+ function peg$f66(items, attrs2) {
1027
1112
  const processedItems = items.map((item) => {
1028
1113
  if (typeof item === "string") {
1029
1114
  if (item === "---" || item === "-" || item === "divider") {
@@ -1038,106 +1123,106 @@ function peg$parse(input, options) {
1038
1123
  items: processedItems
1039
1124
  });
1040
1125
  }
1041
- function peg$f66(attrs2, items) {
1126
+ function peg$f67(attrs2, items) {
1042
1127
  return createNode("Dropdown", {
1043
1128
  ...attrsToObject(attrs2),
1044
1129
  items
1045
1130
  });
1046
1131
  }
1047
- function peg$f67(items) {
1132
+ function peg$f68(items) {
1048
1133
  return items.map((i) => i[0]).filter((i) => i !== null);
1049
1134
  }
1050
- function peg$f68(label, attrs2) {
1135
+ function peg$f69(label, attrs2) {
1051
1136
  return createBlockNode("DropdownItem", { label, ...attrsToObject(attrs2) });
1052
1137
  }
1053
- function peg$f69() {
1138
+ function peg$f70() {
1054
1139
  return createBlockNode("Divider", {});
1055
1140
  }
1056
- function peg$f70() {
1141
+ function peg$f71() {
1057
1142
  return null;
1058
1143
  }
1059
- function peg$f71(items, attrs2, block) {
1144
+ function peg$f72(items, attrs2, block) {
1060
1145
  return createNode("Nav", {
1061
1146
  items: items || [],
1062
1147
  ...attrsToObject(attrs2),
1063
1148
  children: block || []
1064
1149
  });
1065
1150
  }
1066
- function peg$f72(content) {
1151
+ function peg$f73(content) {
1067
1152
  return content.map((c) => c[0]).filter((c) => c !== null);
1068
1153
  }
1069
- function peg$f73() {
1154
+ function peg$f74() {
1070
1155
  return createBlockNode("Divider", {});
1071
1156
  }
1072
- function peg$f74() {
1157
+ function peg$f75() {
1073
1158
  return null;
1074
1159
  }
1075
- function peg$f75(label, attrs2, items) {
1160
+ function peg$f76(label, attrs2, items) {
1076
1161
  return createBlockNode("NavGroup", {
1077
1162
  label,
1078
1163
  ...attrsToObject(attrs2),
1079
1164
  items: items.map((i) => i[0]).filter((i) => i !== null)
1080
1165
  });
1081
1166
  }
1082
- function peg$f76() {
1167
+ function peg$f77() {
1083
1168
  return createBlockNode("Divider", {});
1084
1169
  }
1085
- function peg$f77() {
1170
+ function peg$f78() {
1086
1171
  return null;
1087
1172
  }
1088
- function peg$f78(label, attrs2) {
1173
+ function peg$f79(label, attrs2) {
1089
1174
  return createBlockNode("NavItem", {
1090
1175
  label,
1091
1176
  ...attrsToObject(attrs2)
1092
1177
  });
1093
1178
  }
1094
- function peg$f79(items, attrs2, block) {
1179
+ function peg$f80(items, attrs2, block) {
1095
1180
  return createNode("Tabs", {
1096
1181
  items: items || [],
1097
1182
  ...attrsToObject(attrs2),
1098
1183
  children: block || []
1099
1184
  });
1100
1185
  }
1101
- function peg$f80(tabs) {
1186
+ function peg$f81(tabs) {
1102
1187
  return tabs.map((t) => t[0]).filter((t) => t !== null);
1103
1188
  }
1104
- function peg$f81(label, attrs2, children) {
1189
+ function peg$f82(label, attrs2, children) {
1105
1190
  return {
1106
1191
  label,
1107
1192
  ...attrsToObject(attrs2),
1108
1193
  children
1109
1194
  };
1110
1195
  }
1111
- function peg$f82() {
1196
+ function peg$f83() {
1112
1197
  return null;
1113
1198
  }
1114
- function peg$f83(items, attrs2) {
1199
+ function peg$f84(items, attrs2) {
1115
1200
  return createNode("Breadcrumb", {
1116
1201
  items,
1117
1202
  ...attrsToObject(attrs2)
1118
1203
  });
1119
1204
  }
1120
- function peg$f84(attrs2) {
1205
+ function peg$f85(attrs2) {
1121
1206
  return createNode("Divider", {
1122
1207
  ...attrsToObject(attrs2)
1123
1208
  });
1124
1209
  }
1125
- function peg$f85(num, attrs2) {
1210
+ function peg$f86(num, attrs2) {
1126
1211
  return createNode("Marker", {
1127
1212
  number: num,
1128
1213
  ...attrsToObject(attrs2)
1129
1214
  });
1130
1215
  }
1131
- function peg$f86(attrs2, items) {
1216
+ function peg$f87(attrs2, items) {
1132
1217
  return createNode("Annotations", {
1133
1218
  ...attrsToObject(attrs2),
1134
1219
  children: items
1135
1220
  });
1136
1221
  }
1137
- function peg$f87(items) {
1222
+ function peg$f88(items) {
1138
1223
  return items.map((i) => i[0]).filter((i) => i !== null);
1139
1224
  }
1140
- function peg$f88(num, title, attrs2, children) {
1225
+ function peg$f89(num, title, attrs2, children) {
1141
1226
  return createNode("AnnotationItem", {
1142
1227
  number: num,
1143
1228
  title,
@@ -1145,7 +1230,7 @@ function peg$parse(input, options) {
1145
1230
  children
1146
1231
  });
1147
1232
  }
1148
- function peg$f89(num, title, attrs2) {
1233
+ function peg$f90(num, title, attrs2) {
1149
1234
  return createNode("AnnotationItem", {
1150
1235
  number: num,
1151
1236
  title,
@@ -1153,90 +1238,90 @@ function peg$parse(input, options) {
1153
1238
  children: []
1154
1239
  });
1155
1240
  }
1156
- function peg$f90() {
1241
+ function peg$f91() {
1157
1242
  return null;
1158
1243
  }
1159
- function peg$f91(digits) {
1244
+ function peg$f92(digits) {
1160
1245
  return parseInt(digits.join(""), 10);
1161
1246
  }
1162
- function peg$f92(attrs2) {
1247
+ function peg$f93(attrs2) {
1163
1248
  return attrs2;
1164
1249
  }
1165
- function peg$f93(x, y) {
1250
+ function peg$f94(x, y) {
1166
1251
  return [
1167
1252
  { name: "x", value: x },
1168
1253
  { name: "y", value: y }
1169
1254
  ];
1170
1255
  }
1171
- function peg$f94(name, value) {
1256
+ function peg$f95(name, value) {
1172
1257
  return { name, value };
1173
1258
  }
1174
- function peg$f95(flag) {
1259
+ function peg$f96(flag) {
1175
1260
  return { name: flag, value: true };
1176
1261
  }
1177
- function peg$f96(name) {
1262
+ function peg$f97(name) {
1178
1263
  return name;
1179
1264
  }
1180
- function peg$f97(chars) {
1265
+ function peg$f98(chars) {
1181
1266
  return chars.join("");
1182
1267
  }
1183
- function peg$f98(chars) {
1268
+ function peg$f99(chars) {
1184
1269
  return chars.join("");
1185
1270
  }
1186
- function peg$f99(char) {
1271
+ function peg$f100(char) {
1187
1272
  return char;
1188
1273
  }
1189
- function peg$f100(seq) {
1274
+ function peg$f101(seq) {
1190
1275
  return seq;
1191
1276
  }
1192
- function peg$f101(char) {
1277
+ function peg$f102(char) {
1193
1278
  return char;
1194
1279
  }
1195
- function peg$f102(seq) {
1280
+ function peg$f103(seq) {
1196
1281
  return seq;
1197
1282
  }
1198
- function peg$f103() {
1283
+ function peg$f104() {
1199
1284
  return "\n";
1200
1285
  }
1201
- function peg$f104() {
1286
+ function peg$f105() {
1202
1287
  return "\r";
1203
1288
  }
1204
- function peg$f105() {
1289
+ function peg$f106() {
1205
1290
  return " ";
1206
1291
  }
1207
- function peg$f106() {
1292
+ function peg$f107() {
1208
1293
  return "\\";
1209
1294
  }
1210
- function peg$f107() {
1295
+ function peg$f108() {
1211
1296
  return '"';
1212
1297
  }
1213
- function peg$f108() {
1298
+ function peg$f109() {
1214
1299
  return "'";
1215
1300
  }
1216
- function peg$f109(sign, digits, decimal) {
1301
+ function peg$f110(sign, digits, decimal) {
1217
1302
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1218
1303
  return parseFloat(num);
1219
1304
  }
1220
- function peg$f110(sign, digits, decimal, unit) {
1305
+ function peg$f111(sign, digits, decimal, unit) {
1221
1306
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1222
1307
  return { value: parseFloat(num), unit };
1223
1308
  }
1224
- function peg$f111() {
1309
+ function peg$f112() {
1225
1310
  return true;
1226
1311
  }
1227
- function peg$f112() {
1312
+ function peg$f113() {
1228
1313
  return false;
1229
1314
  }
1230
- function peg$f113(head, tail) {
1315
+ function peg$f114(head, tail) {
1231
1316
  return head + tail.join("");
1232
1317
  }
1233
- function peg$f114(items) {
1318
+ function peg$f115(items) {
1234
1319
  return items || [];
1235
1320
  }
1236
- function peg$f115(head, tail) {
1321
+ function peg$f116(head, tail) {
1237
1322
  return [head, ...tail.map((t) => t[3])];
1238
1323
  }
1239
- function peg$f116(props) {
1324
+ function peg$f117(props) {
1240
1325
  const result = {};
1241
1326
  if (props) {
1242
1327
  for (const p of props) {
@@ -1245,13 +1330,13 @@ function peg$parse(input, options) {
1245
1330
  }
1246
1331
  return result;
1247
1332
  }
1248
- function peg$f117(head, tail) {
1333
+ function peg$f118(head, tail) {
1249
1334
  return [head, ...tail.map((t) => t[3])];
1250
1335
  }
1251
- function peg$f118(name, value) {
1336
+ function peg$f119(name, value) {
1252
1337
  return { name, value };
1253
1338
  }
1254
- function peg$f119(name) {
1339
+ function peg$f120(name) {
1255
1340
  return { name, value: true };
1256
1341
  }
1257
1342
  let peg$currPos = options.peg$currPos | 0;
@@ -2503,21 +2588,24 @@ function peg$parse(input, options) {
2503
2588
  let s0, s1;
2504
2589
  s0 = peg$parseComponentUse();
2505
2590
  if (s0 === peg$FAILED) {
2506
- s0 = peg$parseLayoutElement();
2591
+ s0 = peg$parseRepeat();
2507
2592
  if (s0 === peg$FAILED) {
2508
- s0 = peg$parseContainerElement();
2593
+ s0 = peg$parseLayoutElement();
2509
2594
  if (s0 === peg$FAILED) {
2510
- s0 = peg$parseUIElement();
2595
+ s0 = peg$parseContainerElement();
2511
2596
  if (s0 === peg$FAILED) {
2512
- s0 = peg$parseSlot();
2597
+ s0 = peg$parseUIElement();
2513
2598
  if (s0 === peg$FAILED) {
2514
- s0 = peg$currPos;
2515
- s1 = peg$parseComment();
2516
- if (s1 !== peg$FAILED) {
2517
- peg$savedPos = s0;
2518
- s1 = peg$f18();
2599
+ s0 = peg$parseSlot();
2600
+ if (s0 === peg$FAILED) {
2601
+ s0 = peg$currPos;
2602
+ s1 = peg$parseComment();
2603
+ if (s1 !== peg$FAILED) {
2604
+ peg$savedPos = s0;
2605
+ s1 = peg$f18();
2606
+ }
2607
+ s0 = s1;
2519
2608
  }
2520
- s0 = s1;
2521
2609
  }
2522
2610
  }
2523
2611
  }
@@ -2525,6 +2613,71 @@ function peg$parse(input, options) {
2525
2613
  }
2526
2614
  return s0;
2527
2615
  }
2616
+ function peg$parseRepeat() {
2617
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2618
+ s0 = peg$currPos;
2619
+ if (input.substr(peg$currPos, 6) === peg$c20) {
2620
+ s1 = peg$c20;
2621
+ peg$currPos += 6;
2622
+ } else {
2623
+ s1 = peg$FAILED;
2624
+ if (peg$silentFails === 0) {
2625
+ peg$fail(peg$e23);
2626
+ }
2627
+ }
2628
+ if (s1 !== peg$FAILED) {
2629
+ s2 = peg$parse_();
2630
+ s3 = peg$parseInteger();
2631
+ if (s3 !== peg$FAILED) {
2632
+ s4 = peg$parse_();
2633
+ if (input.charCodeAt(peg$currPos) === 123) {
2634
+ s5 = peg$c1;
2635
+ peg$currPos++;
2636
+ } else {
2637
+ s5 = peg$FAILED;
2638
+ if (peg$silentFails === 0) {
2639
+ peg$fail(peg$e1);
2640
+ }
2641
+ }
2642
+ if (s5 !== peg$FAILED) {
2643
+ s6 = peg$parse_();
2644
+ s7 = peg$parseChildren();
2645
+ if (s7 !== peg$FAILED) {
2646
+ s8 = peg$parse_();
2647
+ if (input.charCodeAt(peg$currPos) === 125) {
2648
+ s9 = peg$c2;
2649
+ peg$currPos++;
2650
+ } else {
2651
+ s9 = peg$FAILED;
2652
+ if (peg$silentFails === 0) {
2653
+ peg$fail(peg$e2);
2654
+ }
2655
+ }
2656
+ if (s9 !== peg$FAILED) {
2657
+ peg$savedPos = s0;
2658
+ s0 = peg$f19(s3, s7);
2659
+ } else {
2660
+ peg$currPos = s0;
2661
+ s0 = peg$FAILED;
2662
+ }
2663
+ } else {
2664
+ peg$currPos = s0;
2665
+ s0 = peg$FAILED;
2666
+ }
2667
+ } else {
2668
+ peg$currPos = s0;
2669
+ s0 = peg$FAILED;
2670
+ }
2671
+ } else {
2672
+ peg$currPos = s0;
2673
+ s0 = peg$FAILED;
2674
+ }
2675
+ } else {
2676
+ peg$currPos = s0;
2677
+ s0 = peg$FAILED;
2678
+ }
2679
+ return s0;
2680
+ }
2528
2681
  function peg$parseLayoutElement() {
2529
2682
  let s0;
2530
2683
  s0 = peg$parseHeader();
@@ -2554,13 +2707,13 @@ function peg$parse(input, options) {
2554
2707
  function peg$parseHeader() {
2555
2708
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2556
2709
  s0 = peg$currPos;
2557
- if (input.substr(peg$currPos, 6) === peg$c20) {
2558
- s1 = peg$c20;
2710
+ if (input.substr(peg$currPos, 6) === peg$c21) {
2711
+ s1 = peg$c21;
2559
2712
  peg$currPos += 6;
2560
2713
  } else {
2561
2714
  s1 = peg$FAILED;
2562
2715
  if (peg$silentFails === 0) {
2563
- peg$fail(peg$e23);
2716
+ peg$fail(peg$e24);
2564
2717
  }
2565
2718
  }
2566
2719
  if (s1 !== peg$FAILED) {
@@ -2595,7 +2748,7 @@ function peg$parse(input, options) {
2595
2748
  }
2596
2749
  if (s9 !== peg$FAILED) {
2597
2750
  peg$savedPos = s0;
2598
- s0 = peg$f19(s3, s7);
2751
+ s0 = peg$f20(s3, s7);
2599
2752
  } else {
2600
2753
  peg$currPos = s0;
2601
2754
  s0 = peg$FAILED;
@@ -2617,13 +2770,13 @@ function peg$parse(input, options) {
2617
2770
  function peg$parseMain() {
2618
2771
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2619
2772
  s0 = peg$currPos;
2620
- if (input.substr(peg$currPos, 4) === peg$c21) {
2621
- s1 = peg$c21;
2773
+ if (input.substr(peg$currPos, 4) === peg$c22) {
2774
+ s1 = peg$c22;
2622
2775
  peg$currPos += 4;
2623
2776
  } else {
2624
2777
  s1 = peg$FAILED;
2625
2778
  if (peg$silentFails === 0) {
2626
- peg$fail(peg$e24);
2779
+ peg$fail(peg$e25);
2627
2780
  }
2628
2781
  }
2629
2782
  if (s1 !== peg$FAILED) {
@@ -2658,7 +2811,7 @@ function peg$parse(input, options) {
2658
2811
  }
2659
2812
  if (s9 !== peg$FAILED) {
2660
2813
  peg$savedPos = s0;
2661
- s0 = peg$f20(s3, s7);
2814
+ s0 = peg$f21(s3, s7);
2662
2815
  } else {
2663
2816
  peg$currPos = s0;
2664
2817
  s0 = peg$FAILED;
@@ -2680,13 +2833,13 @@ function peg$parse(input, options) {
2680
2833
  function peg$parseFooter() {
2681
2834
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2682
2835
  s0 = peg$currPos;
2683
- if (input.substr(peg$currPos, 6) === peg$c22) {
2684
- s1 = peg$c22;
2836
+ if (input.substr(peg$currPos, 6) === peg$c23) {
2837
+ s1 = peg$c23;
2685
2838
  peg$currPos += 6;
2686
2839
  } else {
2687
2840
  s1 = peg$FAILED;
2688
2841
  if (peg$silentFails === 0) {
2689
- peg$fail(peg$e25);
2842
+ peg$fail(peg$e26);
2690
2843
  }
2691
2844
  }
2692
2845
  if (s1 !== peg$FAILED) {
@@ -2721,7 +2874,7 @@ function peg$parse(input, options) {
2721
2874
  }
2722
2875
  if (s9 !== peg$FAILED) {
2723
2876
  peg$savedPos = s0;
2724
- s0 = peg$f21(s3, s7);
2877
+ s0 = peg$f22(s3, s7);
2725
2878
  } else {
2726
2879
  peg$currPos = s0;
2727
2880
  s0 = peg$FAILED;
@@ -2743,13 +2896,13 @@ function peg$parse(input, options) {
2743
2896
  function peg$parseSidebar() {
2744
2897
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2745
2898
  s0 = peg$currPos;
2746
- if (input.substr(peg$currPos, 7) === peg$c23) {
2747
- s1 = peg$c23;
2899
+ if (input.substr(peg$currPos, 7) === peg$c24) {
2900
+ s1 = peg$c24;
2748
2901
  peg$currPos += 7;
2749
2902
  } else {
2750
2903
  s1 = peg$FAILED;
2751
2904
  if (peg$silentFails === 0) {
2752
- peg$fail(peg$e26);
2905
+ peg$fail(peg$e27);
2753
2906
  }
2754
2907
  }
2755
2908
  if (s1 !== peg$FAILED) {
@@ -2784,7 +2937,7 @@ function peg$parse(input, options) {
2784
2937
  }
2785
2938
  if (s9 !== peg$FAILED) {
2786
2939
  peg$savedPos = s0;
2787
- s0 = peg$f22(s3, s7);
2940
+ s0 = peg$f23(s3, s7);
2788
2941
  } else {
2789
2942
  peg$currPos = s0;
2790
2943
  s0 = peg$FAILED;
@@ -2806,13 +2959,13 @@ function peg$parse(input, options) {
2806
2959
  function peg$parseRow() {
2807
2960
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2808
2961
  s0 = peg$currPos;
2809
- if (input.substr(peg$currPos, 3) === peg$c24) {
2810
- s1 = peg$c24;
2962
+ if (input.substr(peg$currPos, 3) === peg$c25) {
2963
+ s1 = peg$c25;
2811
2964
  peg$currPos += 3;
2812
2965
  } else {
2813
2966
  s1 = peg$FAILED;
2814
2967
  if (peg$silentFails === 0) {
2815
- peg$fail(peg$e27);
2968
+ peg$fail(peg$e28);
2816
2969
  }
2817
2970
  }
2818
2971
  if (s1 !== peg$FAILED) {
@@ -2847,7 +3000,7 @@ function peg$parse(input, options) {
2847
3000
  }
2848
3001
  if (s9 !== peg$FAILED) {
2849
3002
  peg$savedPos = s0;
2850
- s0 = peg$f23(s3, s7);
3003
+ s0 = peg$f24(s3, s7);
2851
3004
  } else {
2852
3005
  peg$currPos = s0;
2853
3006
  s0 = peg$FAILED;
@@ -2869,13 +3022,13 @@ function peg$parse(input, options) {
2869
3022
  function peg$parseCol() {
2870
3023
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2871
3024
  s0 = peg$currPos;
2872
- if (input.substr(peg$currPos, 3) === peg$c25) {
2873
- s1 = peg$c25;
3025
+ if (input.substr(peg$currPos, 3) === peg$c26) {
3026
+ s1 = peg$c26;
2874
3027
  peg$currPos += 3;
2875
3028
  } else {
2876
3029
  s1 = peg$FAILED;
2877
3030
  if (peg$silentFails === 0) {
2878
- peg$fail(peg$e28);
3031
+ peg$fail(peg$e29);
2879
3032
  }
2880
3033
  }
2881
3034
  if (s1 !== peg$FAILED) {
@@ -2910,7 +3063,7 @@ function peg$parse(input, options) {
2910
3063
  }
2911
3064
  if (s9 !== peg$FAILED) {
2912
3065
  peg$savedPos = s0;
2913
- s0 = peg$f24(s3, s7);
3066
+ s0 = peg$f25(s3, s7);
2914
3067
  } else {
2915
3068
  peg$currPos = s0;
2916
3069
  s0 = peg$FAILED;
@@ -2932,13 +3085,13 @@ function peg$parse(input, options) {
2932
3085
  function peg$parseStack() {
2933
3086
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2934
3087
  s0 = peg$currPos;
2935
- if (input.substr(peg$currPos, 5) === peg$c26) {
2936
- s1 = peg$c26;
3088
+ if (input.substr(peg$currPos, 5) === peg$c27) {
3089
+ s1 = peg$c27;
2937
3090
  peg$currPos += 5;
2938
3091
  } else {
2939
3092
  s1 = peg$FAILED;
2940
3093
  if (peg$silentFails === 0) {
2941
- peg$fail(peg$e29);
3094
+ peg$fail(peg$e30);
2942
3095
  }
2943
3096
  }
2944
3097
  if (s1 !== peg$FAILED) {
@@ -2973,7 +3126,7 @@ function peg$parse(input, options) {
2973
3126
  }
2974
3127
  if (s9 !== peg$FAILED) {
2975
3128
  peg$savedPos = s0;
2976
- s0 = peg$f25(s3, s7);
3129
+ s0 = peg$f26(s3, s7);
2977
3130
  } else {
2978
3131
  peg$currPos = s0;
2979
3132
  s0 = peg$FAILED;
@@ -2995,13 +3148,13 @@ function peg$parse(input, options) {
2995
3148
  function peg$parseRelative() {
2996
3149
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2997
3150
  s0 = peg$currPos;
2998
- if (input.substr(peg$currPos, 8) === peg$c27) {
2999
- s1 = peg$c27;
3151
+ if (input.substr(peg$currPos, 8) === peg$c28) {
3152
+ s1 = peg$c28;
3000
3153
  peg$currPos += 8;
3001
3154
  } else {
3002
3155
  s1 = peg$FAILED;
3003
3156
  if (peg$silentFails === 0) {
3004
- peg$fail(peg$e30);
3157
+ peg$fail(peg$e31);
3005
3158
  }
3006
3159
  }
3007
3160
  if (s1 !== peg$FAILED) {
@@ -3036,7 +3189,7 @@ function peg$parse(input, options) {
3036
3189
  }
3037
3190
  if (s9 !== peg$FAILED) {
3038
3191
  peg$savedPos = s0;
3039
- s0 = peg$f26(s3, s7);
3192
+ s0 = peg$f27(s3, s7);
3040
3193
  } else {
3041
3194
  peg$currPos = s0;
3042
3195
  s0 = peg$FAILED;
@@ -3075,13 +3228,13 @@ function peg$parse(input, options) {
3075
3228
  function peg$parseCard() {
3076
3229
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3077
3230
  s0 = peg$currPos;
3078
- if (input.substr(peg$currPos, 4) === peg$c28) {
3079
- s1 = peg$c28;
3231
+ if (input.substr(peg$currPos, 4) === peg$c29) {
3232
+ s1 = peg$c29;
3080
3233
  peg$currPos += 4;
3081
3234
  } else {
3082
3235
  s1 = peg$FAILED;
3083
3236
  if (peg$silentFails === 0) {
3084
- peg$fail(peg$e31);
3237
+ peg$fail(peg$e32);
3085
3238
  }
3086
3239
  }
3087
3240
  if (s1 !== peg$FAILED) {
@@ -3121,7 +3274,7 @@ function peg$parse(input, options) {
3121
3274
  }
3122
3275
  if (s11 !== peg$FAILED) {
3123
3276
  peg$savedPos = s0;
3124
- s0 = peg$f27(s3, s5, s9);
3277
+ s0 = peg$f28(s3, s5, s9);
3125
3278
  } else {
3126
3279
  peg$currPos = s0;
3127
3280
  s0 = peg$FAILED;
@@ -3143,13 +3296,13 @@ function peg$parse(input, options) {
3143
3296
  function peg$parseModal() {
3144
3297
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3145
3298
  s0 = peg$currPos;
3146
- if (input.substr(peg$currPos, 5) === peg$c29) {
3147
- s1 = peg$c29;
3299
+ if (input.substr(peg$currPos, 5) === peg$c30) {
3300
+ s1 = peg$c30;
3148
3301
  peg$currPos += 5;
3149
3302
  } else {
3150
3303
  s1 = peg$FAILED;
3151
3304
  if (peg$silentFails === 0) {
3152
- peg$fail(peg$e32);
3305
+ peg$fail(peg$e33);
3153
3306
  }
3154
3307
  }
3155
3308
  if (s1 !== peg$FAILED) {
@@ -3189,7 +3342,7 @@ function peg$parse(input, options) {
3189
3342
  }
3190
3343
  if (s11 !== peg$FAILED) {
3191
3344
  peg$savedPos = s0;
3192
- s0 = peg$f28(s3, s5, s9);
3345
+ s0 = peg$f29(s3, s5, s9);
3193
3346
  } else {
3194
3347
  peg$currPos = s0;
3195
3348
  s0 = peg$FAILED;
@@ -3211,13 +3364,13 @@ function peg$parse(input, options) {
3211
3364
  function peg$parseDrawer() {
3212
3365
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3213
3366
  s0 = peg$currPos;
3214
- if (input.substr(peg$currPos, 6) === peg$c30) {
3215
- s1 = peg$c30;
3367
+ if (input.substr(peg$currPos, 6) === peg$c31) {
3368
+ s1 = peg$c31;
3216
3369
  peg$currPos += 6;
3217
3370
  } else {
3218
3371
  s1 = peg$FAILED;
3219
3372
  if (peg$silentFails === 0) {
3220
- peg$fail(peg$e33);
3373
+ peg$fail(peg$e34);
3221
3374
  }
3222
3375
  }
3223
3376
  if (s1 !== peg$FAILED) {
@@ -3257,7 +3410,7 @@ function peg$parse(input, options) {
3257
3410
  }
3258
3411
  if (s11 !== peg$FAILED) {
3259
3412
  peg$savedPos = s0;
3260
- s0 = peg$f29(s3, s5, s9);
3413
+ s0 = peg$f30(s3, s5, s9);
3261
3414
  } else {
3262
3415
  peg$currPos = s0;
3263
3416
  s0 = peg$FAILED;
@@ -3279,13 +3432,13 @@ function peg$parse(input, options) {
3279
3432
  function peg$parseAccordion() {
3280
3433
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3281
3434
  s0 = peg$currPos;
3282
- if (input.substr(peg$currPos, 9) === peg$c31) {
3283
- s1 = peg$c31;
3435
+ if (input.substr(peg$currPos, 9) === peg$c32) {
3436
+ s1 = peg$c32;
3284
3437
  peg$currPos += 9;
3285
3438
  } else {
3286
3439
  s1 = peg$FAILED;
3287
3440
  if (peg$silentFails === 0) {
3288
- peg$fail(peg$e34);
3441
+ peg$fail(peg$e35);
3289
3442
  }
3290
3443
  }
3291
3444
  if (s1 !== peg$FAILED) {
@@ -3325,7 +3478,7 @@ function peg$parse(input, options) {
3325
3478
  }
3326
3479
  if (s11 !== peg$FAILED) {
3327
3480
  peg$savedPos = s0;
3328
- s0 = peg$f30(s3, s5, s9);
3481
+ s0 = peg$f31(s3, s5, s9);
3329
3482
  } else {
3330
3483
  peg$currPos = s0;
3331
3484
  s0 = peg$FAILED;
@@ -3347,13 +3500,13 @@ function peg$parse(input, options) {
3347
3500
  function peg$parseSection() {
3348
3501
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3349
3502
  s0 = peg$currPos;
3350
- if (input.substr(peg$currPos, 7) === peg$c32) {
3351
- s1 = peg$c32;
3503
+ if (input.substr(peg$currPos, 7) === peg$c33) {
3504
+ s1 = peg$c33;
3352
3505
  peg$currPos += 7;
3353
3506
  } else {
3354
3507
  s1 = peg$FAILED;
3355
3508
  if (peg$silentFails === 0) {
3356
- peg$fail(peg$e35);
3509
+ peg$fail(peg$e36);
3357
3510
  }
3358
3511
  }
3359
3512
  if (s1 !== peg$FAILED) {
@@ -3393,7 +3546,7 @@ function peg$parse(input, options) {
3393
3546
  }
3394
3547
  if (s11 !== peg$FAILED) {
3395
3548
  peg$savedPos = s0;
3396
- s0 = peg$f31(s3, s5, s9);
3549
+ s0 = peg$f32(s3, s5, s9);
3397
3550
  } else {
3398
3551
  peg$currPos = s0;
3399
3552
  s0 = peg$FAILED;
@@ -3510,13 +3663,13 @@ function peg$parse(input, options) {
3510
3663
  function peg$parseText() {
3511
3664
  let s0, s1, s2, s3, s4, s5;
3512
3665
  s0 = peg$currPos;
3513
- if (input.substr(peg$currPos, 4) === peg$c33) {
3514
- s1 = peg$c33;
3666
+ if (input.substr(peg$currPos, 4) === peg$c34) {
3667
+ s1 = peg$c34;
3515
3668
  peg$currPos += 4;
3516
3669
  } else {
3517
3670
  s1 = peg$FAILED;
3518
3671
  if (peg$silentFails === 0) {
3519
- peg$fail(peg$e36);
3672
+ peg$fail(peg$e37);
3520
3673
  }
3521
3674
  }
3522
3675
  if (s1 !== peg$FAILED) {
@@ -3529,7 +3682,7 @@ function peg$parse(input, options) {
3529
3682
  s5 = null;
3530
3683
  }
3531
3684
  peg$savedPos = s0;
3532
- s0 = peg$f32(s3, s5);
3685
+ s0 = peg$f33(s3, s5);
3533
3686
  } else {
3534
3687
  peg$currPos = s0;
3535
3688
  s0 = peg$FAILED;
@@ -3543,13 +3696,13 @@ function peg$parse(input, options) {
3543
3696
  function peg$parseTitle() {
3544
3697
  let s0, s1, s2, s3, s4, s5;
3545
3698
  s0 = peg$currPos;
3546
- if (input.substr(peg$currPos, 5) === peg$c34) {
3547
- s1 = peg$c34;
3699
+ if (input.substr(peg$currPos, 5) === peg$c35) {
3700
+ s1 = peg$c35;
3548
3701
  peg$currPos += 5;
3549
3702
  } else {
3550
3703
  s1 = peg$FAILED;
3551
3704
  if (peg$silentFails === 0) {
3552
- peg$fail(peg$e37);
3705
+ peg$fail(peg$e38);
3553
3706
  }
3554
3707
  }
3555
3708
  if (s1 !== peg$FAILED) {
@@ -3562,7 +3715,7 @@ function peg$parse(input, options) {
3562
3715
  s5 = null;
3563
3716
  }
3564
3717
  peg$savedPos = s0;
3565
- s0 = peg$f33(s3, s5);
3718
+ s0 = peg$f34(s3, s5);
3566
3719
  } else {
3567
3720
  peg$currPos = s0;
3568
3721
  s0 = peg$FAILED;
@@ -3576,13 +3729,13 @@ function peg$parse(input, options) {
3576
3729
  function peg$parseLink() {
3577
3730
  let s0, s1, s2, s3, s4, s5;
3578
3731
  s0 = peg$currPos;
3579
- if (input.substr(peg$currPos, 4) === peg$c35) {
3580
- s1 = peg$c35;
3732
+ if (input.substr(peg$currPos, 4) === peg$c36) {
3733
+ s1 = peg$c36;
3581
3734
  peg$currPos += 4;
3582
3735
  } else {
3583
3736
  s1 = peg$FAILED;
3584
3737
  if (peg$silentFails === 0) {
3585
- peg$fail(peg$e38);
3738
+ peg$fail(peg$e39);
3586
3739
  }
3587
3740
  }
3588
3741
  if (s1 !== peg$FAILED) {
@@ -3595,7 +3748,7 @@ function peg$parse(input, options) {
3595
3748
  s5 = null;
3596
3749
  }
3597
3750
  peg$savedPos = s0;
3598
- s0 = peg$f34(s3, s5);
3751
+ s0 = peg$f35(s3, s5);
3599
3752
  } else {
3600
3753
  peg$currPos = s0;
3601
3754
  s0 = peg$FAILED;
@@ -3609,13 +3762,13 @@ function peg$parse(input, options) {
3609
3762
  function peg$parseButton() {
3610
3763
  let s0, s1, s2, s3, s4, s5;
3611
3764
  s0 = peg$currPos;
3612
- if (input.substr(peg$currPos, 6) === peg$c36) {
3613
- s1 = peg$c36;
3765
+ if (input.substr(peg$currPos, 6) === peg$c37) {
3766
+ s1 = peg$c37;
3614
3767
  peg$currPos += 6;
3615
3768
  } else {
3616
3769
  s1 = peg$FAILED;
3617
3770
  if (peg$silentFails === 0) {
3618
- peg$fail(peg$e39);
3771
+ peg$fail(peg$e40);
3619
3772
  }
3620
3773
  }
3621
3774
  if (s1 !== peg$FAILED) {
@@ -3628,7 +3781,7 @@ function peg$parse(input, options) {
3628
3781
  s5 = null;
3629
3782
  }
3630
3783
  peg$savedPos = s0;
3631
- s0 = peg$f35(s3, s5);
3784
+ s0 = peg$f36(s3, s5);
3632
3785
  } else {
3633
3786
  peg$currPos = s0;
3634
3787
  s0 = peg$FAILED;
@@ -3642,13 +3795,13 @@ function peg$parse(input, options) {
3642
3795
  function peg$parseInput() {
3643
3796
  let s0, s1, s2, s3, s4, s5;
3644
3797
  s0 = peg$currPos;
3645
- if (input.substr(peg$currPos, 5) === peg$c37) {
3646
- s1 = peg$c37;
3798
+ if (input.substr(peg$currPos, 5) === peg$c38) {
3799
+ s1 = peg$c38;
3647
3800
  peg$currPos += 5;
3648
3801
  } else {
3649
3802
  s1 = peg$FAILED;
3650
3803
  if (peg$silentFails === 0) {
3651
- peg$fail(peg$e40);
3804
+ peg$fail(peg$e41);
3652
3805
  }
3653
3806
  }
3654
3807
  if (s1 !== peg$FAILED) {
@@ -3663,7 +3816,7 @@ function peg$parse(input, options) {
3663
3816
  s5 = null;
3664
3817
  }
3665
3818
  peg$savedPos = s0;
3666
- s0 = peg$f36(s3, s5);
3819
+ s0 = peg$f37(s3, s5);
3667
3820
  } else {
3668
3821
  peg$currPos = s0;
3669
3822
  s0 = peg$FAILED;
@@ -3673,13 +3826,13 @@ function peg$parse(input, options) {
3673
3826
  function peg$parseTextarea() {
3674
3827
  let s0, s1, s2, s3, s4, s5;
3675
3828
  s0 = peg$currPos;
3676
- if (input.substr(peg$currPos, 8) === peg$c38) {
3677
- s1 = peg$c38;
3829
+ if (input.substr(peg$currPos, 8) === peg$c39) {
3830
+ s1 = peg$c39;
3678
3831
  peg$currPos += 8;
3679
3832
  } else {
3680
3833
  s1 = peg$FAILED;
3681
3834
  if (peg$silentFails === 0) {
3682
- peg$fail(peg$e41);
3835
+ peg$fail(peg$e42);
3683
3836
  }
3684
3837
  }
3685
3838
  if (s1 !== peg$FAILED) {
@@ -3694,7 +3847,7 @@ function peg$parse(input, options) {
3694
3847
  s5 = null;
3695
3848
  }
3696
3849
  peg$savedPos = s0;
3697
- s0 = peg$f37(s3, s5);
3850
+ s0 = peg$f38(s3, s5);
3698
3851
  } else {
3699
3852
  peg$currPos = s0;
3700
3853
  s0 = peg$FAILED;
@@ -3704,13 +3857,13 @@ function peg$parse(input, options) {
3704
3857
  function peg$parseSelect() {
3705
3858
  let s0, s1, s2, s3, s4, s5, s6, s7;
3706
3859
  s0 = peg$currPos;
3707
- if (input.substr(peg$currPos, 6) === peg$c39) {
3708
- s1 = peg$c39;
3860
+ if (input.substr(peg$currPos, 6) === peg$c40) {
3861
+ s1 = peg$c40;
3709
3862
  peg$currPos += 6;
3710
3863
  } else {
3711
3864
  s1 = peg$FAILED;
3712
3865
  if (peg$silentFails === 0) {
3713
- peg$fail(peg$e42);
3866
+ peg$fail(peg$e43);
3714
3867
  }
3715
3868
  }
3716
3869
  if (s1 !== peg$FAILED) {
@@ -3730,7 +3883,7 @@ function peg$parse(input, options) {
3730
3883
  s7 = null;
3731
3884
  }
3732
3885
  peg$savedPos = s0;
3733
- s0 = peg$f38(s3, s5, s7);
3886
+ s0 = peg$f39(s3, s5, s7);
3734
3887
  } else {
3735
3888
  peg$currPos = s0;
3736
3889
  s0 = peg$FAILED;
@@ -3740,13 +3893,13 @@ function peg$parse(input, options) {
3740
3893
  function peg$parseCheckbox() {
3741
3894
  let s0, s1, s2, s3, s4, s5;
3742
3895
  s0 = peg$currPos;
3743
- if (input.substr(peg$currPos, 8) === peg$c40) {
3744
- s1 = peg$c40;
3896
+ if (input.substr(peg$currPos, 8) === peg$c41) {
3897
+ s1 = peg$c41;
3745
3898
  peg$currPos += 8;
3746
3899
  } else {
3747
3900
  s1 = peg$FAILED;
3748
3901
  if (peg$silentFails === 0) {
3749
- peg$fail(peg$e43);
3902
+ peg$fail(peg$e44);
3750
3903
  }
3751
3904
  }
3752
3905
  if (s1 !== peg$FAILED) {
@@ -3761,7 +3914,7 @@ function peg$parse(input, options) {
3761
3914
  s5 = null;
3762
3915
  }
3763
3916
  peg$savedPos = s0;
3764
- s0 = peg$f39(s3, s5);
3917
+ s0 = peg$f40(s3, s5);
3765
3918
  } else {
3766
3919
  peg$currPos = s0;
3767
3920
  s0 = peg$FAILED;
@@ -3771,13 +3924,13 @@ function peg$parse(input, options) {
3771
3924
  function peg$parseRadio() {
3772
3925
  let s0, s1, s2, s3, s4, s5;
3773
3926
  s0 = peg$currPos;
3774
- if (input.substr(peg$currPos, 5) === peg$c41) {
3775
- s1 = peg$c41;
3927
+ if (input.substr(peg$currPos, 5) === peg$c42) {
3928
+ s1 = peg$c42;
3776
3929
  peg$currPos += 5;
3777
3930
  } else {
3778
3931
  s1 = peg$FAILED;
3779
3932
  if (peg$silentFails === 0) {
3780
- peg$fail(peg$e44);
3933
+ peg$fail(peg$e45);
3781
3934
  }
3782
3935
  }
3783
3936
  if (s1 !== peg$FAILED) {
@@ -3792,7 +3945,7 @@ function peg$parse(input, options) {
3792
3945
  s5 = null;
3793
3946
  }
3794
3947
  peg$savedPos = s0;
3795
- s0 = peg$f40(s3, s5);
3948
+ s0 = peg$f41(s3, s5);
3796
3949
  } else {
3797
3950
  peg$currPos = s0;
3798
3951
  s0 = peg$FAILED;
@@ -3802,13 +3955,13 @@ function peg$parse(input, options) {
3802
3955
  function peg$parseSwitch() {
3803
3956
  let s0, s1, s2, s3, s4, s5;
3804
3957
  s0 = peg$currPos;
3805
- if (input.substr(peg$currPos, 6) === peg$c42) {
3806
- s1 = peg$c42;
3958
+ if (input.substr(peg$currPos, 6) === peg$c43) {
3959
+ s1 = peg$c43;
3807
3960
  peg$currPos += 6;
3808
3961
  } else {
3809
3962
  s1 = peg$FAILED;
3810
3963
  if (peg$silentFails === 0) {
3811
- peg$fail(peg$e45);
3964
+ peg$fail(peg$e46);
3812
3965
  }
3813
3966
  }
3814
3967
  if (s1 !== peg$FAILED) {
@@ -3823,7 +3976,7 @@ function peg$parse(input, options) {
3823
3976
  s5 = null;
3824
3977
  }
3825
3978
  peg$savedPos = s0;
3826
- s0 = peg$f41(s3, s5);
3979
+ s0 = peg$f42(s3, s5);
3827
3980
  } else {
3828
3981
  peg$currPos = s0;
3829
3982
  s0 = peg$FAILED;
@@ -3833,13 +3986,13 @@ function peg$parse(input, options) {
3833
3986
  function peg$parseSlider() {
3834
3987
  let s0, s1, s2, s3, s4, s5;
3835
3988
  s0 = peg$currPos;
3836
- if (input.substr(peg$currPos, 6) === peg$c43) {
3837
- s1 = peg$c43;
3989
+ if (input.substr(peg$currPos, 6) === peg$c44) {
3990
+ s1 = peg$c44;
3838
3991
  peg$currPos += 6;
3839
3992
  } else {
3840
3993
  s1 = peg$FAILED;
3841
3994
  if (peg$silentFails === 0) {
3842
- peg$fail(peg$e46);
3995
+ peg$fail(peg$e47);
3843
3996
  }
3844
3997
  }
3845
3998
  if (s1 !== peg$FAILED) {
@@ -3854,7 +4007,7 @@ function peg$parse(input, options) {
3854
4007
  s5 = null;
3855
4008
  }
3856
4009
  peg$savedPos = s0;
3857
- s0 = peg$f42(s3, s5);
4010
+ s0 = peg$f43(s3, s5);
3858
4011
  } else {
3859
4012
  peg$currPos = s0;
3860
4013
  s0 = peg$FAILED;
@@ -3864,13 +4017,13 @@ function peg$parse(input, options) {
3864
4017
  function peg$parseImage() {
3865
4018
  let s0, s1, s2, s3, s4, s5;
3866
4019
  s0 = peg$currPos;
3867
- if (input.substr(peg$currPos, 5) === peg$c44) {
3868
- s1 = peg$c44;
4020
+ if (input.substr(peg$currPos, 5) === peg$c45) {
4021
+ s1 = peg$c45;
3869
4022
  peg$currPos += 5;
3870
4023
  } else {
3871
4024
  s1 = peg$FAILED;
3872
4025
  if (peg$silentFails === 0) {
3873
- peg$fail(peg$e47);
4026
+ peg$fail(peg$e48);
3874
4027
  }
3875
4028
  }
3876
4029
  if (s1 !== peg$FAILED) {
@@ -3885,7 +4038,7 @@ function peg$parse(input, options) {
3885
4038
  s5 = null;
3886
4039
  }
3887
4040
  peg$savedPos = s0;
3888
- s0 = peg$f43(s3, s5);
4041
+ s0 = peg$f44(s3, s5);
3889
4042
  } else {
3890
4043
  peg$currPos = s0;
3891
4044
  s0 = peg$FAILED;
@@ -3895,13 +4048,13 @@ function peg$parse(input, options) {
3895
4048
  function peg$parsePlaceholder() {
3896
4049
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
3897
4050
  s0 = peg$currPos;
3898
- if (input.substr(peg$currPos, 11) === peg$c45) {
3899
- s1 = peg$c45;
4051
+ if (input.substr(peg$currPos, 11) === peg$c46) {
4052
+ s1 = peg$c46;
3900
4053
  peg$currPos += 11;
3901
4054
  } else {
3902
4055
  s1 = peg$FAILED;
3903
4056
  if (peg$silentFails === 0) {
3904
- peg$fail(peg$e48);
4057
+ peg$fail(peg$e49);
3905
4058
  }
3906
4059
  }
3907
4060
  if (s1 !== peg$FAILED) {
@@ -3959,7 +4112,7 @@ function peg$parse(input, options) {
3959
4112
  s7 = null;
3960
4113
  }
3961
4114
  peg$savedPos = s0;
3962
- s0 = peg$f44(s3, s5, s7);
4115
+ s0 = peg$f45(s3, s5, s7);
3963
4116
  } else {
3964
4117
  peg$currPos = s0;
3965
4118
  s0 = peg$FAILED;
@@ -3969,13 +4122,13 @@ function peg$parse(input, options) {
3969
4122
  function peg$parseAvatar() {
3970
4123
  let s0, s1, s2, s3, s4, s5;
3971
4124
  s0 = peg$currPos;
3972
- if (input.substr(peg$currPos, 6) === peg$c46) {
3973
- s1 = peg$c46;
4125
+ if (input.substr(peg$currPos, 6) === peg$c47) {
4126
+ s1 = peg$c47;
3974
4127
  peg$currPos += 6;
3975
4128
  } else {
3976
4129
  s1 = peg$FAILED;
3977
4130
  if (peg$silentFails === 0) {
3978
- peg$fail(peg$e49);
4131
+ peg$fail(peg$e50);
3979
4132
  }
3980
4133
  }
3981
4134
  if (s1 !== peg$FAILED) {
@@ -3990,7 +4143,7 @@ function peg$parse(input, options) {
3990
4143
  s5 = null;
3991
4144
  }
3992
4145
  peg$savedPos = s0;
3993
- s0 = peg$f45(s3, s5);
4146
+ s0 = peg$f46(s3, s5);
3994
4147
  } else {
3995
4148
  peg$currPos = s0;
3996
4149
  s0 = peg$FAILED;
@@ -4000,13 +4153,13 @@ function peg$parse(input, options) {
4000
4153
  function peg$parseBadge() {
4001
4154
  let s0, s1, s2, s3, s4, s5;
4002
4155
  s0 = peg$currPos;
4003
- if (input.substr(peg$currPos, 5) === peg$c47) {
4004
- s1 = peg$c47;
4156
+ if (input.substr(peg$currPos, 5) === peg$c48) {
4157
+ s1 = peg$c48;
4005
4158
  peg$currPos += 5;
4006
4159
  } else {
4007
4160
  s1 = peg$FAILED;
4008
4161
  if (peg$silentFails === 0) {
4009
- peg$fail(peg$e50);
4162
+ peg$fail(peg$e51);
4010
4163
  }
4011
4164
  }
4012
4165
  if (s1 !== peg$FAILED) {
@@ -4019,7 +4172,7 @@ function peg$parse(input, options) {
4019
4172
  s5 = null;
4020
4173
  }
4021
4174
  peg$savedPos = s0;
4022
- s0 = peg$f46(s3, s5);
4175
+ s0 = peg$f47(s3, s5);
4023
4176
  } else {
4024
4177
  peg$currPos = s0;
4025
4178
  s0 = peg$FAILED;
@@ -4033,13 +4186,13 @@ function peg$parse(input, options) {
4033
4186
  function peg$parseIcon() {
4034
4187
  let s0, s1, s2, s3, s4, s5;
4035
4188
  s0 = peg$currPos;
4036
- if (input.substr(peg$currPos, 4) === peg$c48) {
4037
- s1 = peg$c48;
4189
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4190
+ s1 = peg$c49;
4038
4191
  peg$currPos += 4;
4039
4192
  } else {
4040
4193
  s1 = peg$FAILED;
4041
4194
  if (peg$silentFails === 0) {
4042
- peg$fail(peg$e51);
4195
+ peg$fail(peg$e52);
4043
4196
  }
4044
4197
  }
4045
4198
  if (s1 !== peg$FAILED) {
@@ -4052,7 +4205,7 @@ function peg$parse(input, options) {
4052
4205
  s5 = null;
4053
4206
  }
4054
4207
  peg$savedPos = s0;
4055
- s0 = peg$f47(s3, s5);
4208
+ s0 = peg$f48(s3, s5);
4056
4209
  } else {
4057
4210
  peg$currPos = s0;
4058
4211
  s0 = peg$FAILED;
@@ -4066,13 +4219,13 @@ function peg$parse(input, options) {
4066
4219
  function peg$parseTable() {
4067
4220
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4068
4221
  s0 = peg$currPos;
4069
- if (input.substr(peg$currPos, 5) === peg$c49) {
4070
- s1 = peg$c49;
4222
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4223
+ s1 = peg$c50;
4071
4224
  peg$currPos += 5;
4072
4225
  } else {
4073
4226
  s1 = peg$FAILED;
4074
4227
  if (peg$silentFails === 0) {
4075
- peg$fail(peg$e52);
4228
+ peg$fail(peg$e53);
4076
4229
  }
4077
4230
  }
4078
4231
  if (s1 !== peg$FAILED) {
@@ -4085,7 +4238,7 @@ function peg$parse(input, options) {
4085
4238
  s5 = null;
4086
4239
  }
4087
4240
  peg$savedPos = s0;
4088
- s0 = peg$f48(s3, s5);
4241
+ s0 = peg$f49(s3, s5);
4089
4242
  } else {
4090
4243
  peg$currPos = s0;
4091
4244
  s0 = peg$FAILED;
@@ -4096,13 +4249,13 @@ function peg$parse(input, options) {
4096
4249
  }
4097
4250
  if (s0 === peg$FAILED) {
4098
4251
  s0 = peg$currPos;
4099
- if (input.substr(peg$currPos, 5) === peg$c49) {
4100
- s1 = peg$c49;
4252
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4253
+ s1 = peg$c50;
4101
4254
  peg$currPos += 5;
4102
4255
  } else {
4103
4256
  s1 = peg$FAILED;
4104
4257
  if (peg$silentFails === 0) {
4105
- peg$fail(peg$e52);
4258
+ peg$fail(peg$e53);
4106
4259
  }
4107
4260
  }
4108
4261
  if (s1 !== peg$FAILED) {
@@ -4136,7 +4289,7 @@ function peg$parse(input, options) {
4136
4289
  }
4137
4290
  if (s9 !== peg$FAILED) {
4138
4291
  peg$savedPos = s0;
4139
- s0 = peg$f49(s3, s7);
4292
+ s0 = peg$f50(s3, s7);
4140
4293
  } else {
4141
4294
  peg$currPos = s0;
4142
4295
  s0 = peg$FAILED;
@@ -4156,12 +4309,12 @@ function peg$parse(input, options) {
4156
4309
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
4157
4310
  s0 = peg$currPos;
4158
4311
  if (input.charCodeAt(peg$currPos) === 91) {
4159
- s1 = peg$c50;
4312
+ s1 = peg$c51;
4160
4313
  peg$currPos++;
4161
4314
  } else {
4162
4315
  s1 = peg$FAILED;
4163
4316
  if (peg$silentFails === 0) {
4164
- peg$fail(peg$e53);
4317
+ peg$fail(peg$e54);
4165
4318
  }
4166
4319
  }
4167
4320
  if (s1 !== peg$FAILED) {
@@ -4237,17 +4390,17 @@ function peg$parse(input, options) {
4237
4390
  }
4238
4391
  s7 = peg$parse_();
4239
4392
  if (input.charCodeAt(peg$currPos) === 93) {
4240
- s8 = peg$c51;
4393
+ s8 = peg$c52;
4241
4394
  peg$currPos++;
4242
4395
  } else {
4243
4396
  s8 = peg$FAILED;
4244
4397
  if (peg$silentFails === 0) {
4245
- peg$fail(peg$e54);
4398
+ peg$fail(peg$e55);
4246
4399
  }
4247
4400
  }
4248
4401
  if (s8 !== peg$FAILED) {
4249
4402
  peg$savedPos = s0;
4250
- s0 = peg$f50(s3, s5);
4403
+ s0 = peg$f51(s3, s5);
4251
4404
  } else {
4252
4405
  peg$currPos = s0;
4253
4406
  s0 = peg$FAILED;
@@ -4290,20 +4443,20 @@ function peg$parse(input, options) {
4290
4443
  }
4291
4444
  }
4292
4445
  peg$savedPos = s0;
4293
- s1 = peg$f51(s1);
4446
+ s1 = peg$f52(s1);
4294
4447
  s0 = s1;
4295
4448
  return s0;
4296
4449
  }
4297
4450
  function peg$parseTableRow() {
4298
4451
  let s0, s1, s2, s3;
4299
4452
  s0 = peg$currPos;
4300
- if (input.substr(peg$currPos, 7) === peg$c52) {
4301
- s1 = peg$c52;
4453
+ if (input.substr(peg$currPos, 7) === peg$c53) {
4454
+ s1 = peg$c53;
4302
4455
  peg$currPos += 7;
4303
4456
  } else {
4304
4457
  s1 = peg$FAILED;
4305
4458
  if (peg$silentFails === 0) {
4306
- peg$fail(peg$e55);
4459
+ peg$fail(peg$e56);
4307
4460
  }
4308
4461
  }
4309
4462
  if (s1 !== peg$FAILED) {
@@ -4311,7 +4464,7 @@ function peg$parse(input, options) {
4311
4464
  s3 = peg$parseArray();
4312
4465
  if (s3 !== peg$FAILED) {
4313
4466
  peg$savedPos = s0;
4314
- s0 = peg$f52(s3);
4467
+ s0 = peg$f53(s3);
4315
4468
  } else {
4316
4469
  peg$currPos = s0;
4317
4470
  s0 = peg$FAILED;
@@ -4322,13 +4475,13 @@ function peg$parse(input, options) {
4322
4475
  }
4323
4476
  if (s0 === peg$FAILED) {
4324
4477
  s0 = peg$currPos;
4325
- if (input.substr(peg$currPos, 3) === peg$c24) {
4326
- s1 = peg$c24;
4478
+ if (input.substr(peg$currPos, 3) === peg$c25) {
4479
+ s1 = peg$c25;
4327
4480
  peg$currPos += 3;
4328
4481
  } else {
4329
4482
  s1 = peg$FAILED;
4330
4483
  if (peg$silentFails === 0) {
4331
- peg$fail(peg$e27);
4484
+ peg$fail(peg$e28);
4332
4485
  }
4333
4486
  }
4334
4487
  if (s1 !== peg$FAILED) {
@@ -4336,7 +4489,7 @@ function peg$parse(input, options) {
4336
4489
  s3 = peg$parseArray();
4337
4490
  if (s3 !== peg$FAILED) {
4338
4491
  peg$savedPos = s0;
4339
- s0 = peg$f53(s3);
4492
+ s0 = peg$f54(s3);
4340
4493
  } else {
4341
4494
  peg$currPos = s0;
4342
4495
  s0 = peg$FAILED;
@@ -4350,7 +4503,7 @@ function peg$parse(input, options) {
4350
4503
  s1 = peg$parseComment();
4351
4504
  if (s1 !== peg$FAILED) {
4352
4505
  peg$savedPos = s0;
4353
- s1 = peg$f54();
4506
+ s1 = peg$f55();
4354
4507
  }
4355
4508
  s0 = s1;
4356
4509
  }
@@ -4360,13 +4513,13 @@ function peg$parse(input, options) {
4360
4513
  function peg$parseList() {
4361
4514
  let s0, s1, s2, s3, s4, s5, s6, s7;
4362
4515
  s0 = peg$currPos;
4363
- if (input.substr(peg$currPos, 4) === peg$c53) {
4364
- s1 = peg$c53;
4516
+ if (input.substr(peg$currPos, 4) === peg$c54) {
4517
+ s1 = peg$c54;
4365
4518
  peg$currPos += 4;
4366
4519
  } else {
4367
4520
  s1 = peg$FAILED;
4368
4521
  if (peg$silentFails === 0) {
4369
- peg$fail(peg$e56);
4522
+ peg$fail(peg$e57);
4370
4523
  }
4371
4524
  }
4372
4525
  if (s1 !== peg$FAILED) {
@@ -4386,7 +4539,7 @@ function peg$parse(input, options) {
4386
4539
  s7 = null;
4387
4540
  }
4388
4541
  peg$savedPos = s0;
4389
- s0 = peg$f55(s3, s5, s7);
4542
+ s0 = peg$f56(s3, s5, s7);
4390
4543
  } else {
4391
4544
  peg$currPos = s0;
4392
4545
  s0 = peg$FAILED;
@@ -4442,7 +4595,7 @@ function peg$parse(input, options) {
4442
4595
  }
4443
4596
  if (s4 !== peg$FAILED) {
4444
4597
  peg$savedPos = s0;
4445
- s0 = peg$f56(s3);
4598
+ s0 = peg$f57(s3);
4446
4599
  } else {
4447
4600
  peg$currPos = s0;
4448
4601
  s0 = peg$FAILED;
@@ -4456,13 +4609,13 @@ function peg$parse(input, options) {
4456
4609
  function peg$parseListItem() {
4457
4610
  let s0, s1, s2, s3, s4, s5, s6, s7;
4458
4611
  s0 = peg$currPos;
4459
- if (input.substr(peg$currPos, 4) === peg$c54) {
4460
- s1 = peg$c54;
4612
+ if (input.substr(peg$currPos, 4) === peg$c55) {
4613
+ s1 = peg$c55;
4461
4614
  peg$currPos += 4;
4462
4615
  } else {
4463
4616
  s1 = peg$FAILED;
4464
4617
  if (peg$silentFails === 0) {
4465
- peg$fail(peg$e57);
4618
+ peg$fail(peg$e58);
4466
4619
  }
4467
4620
  }
4468
4621
  if (s1 !== peg$FAILED) {
@@ -4480,7 +4633,7 @@ function peg$parse(input, options) {
4480
4633
  s7 = null;
4481
4634
  }
4482
4635
  peg$savedPos = s0;
4483
- s0 = peg$f57(s3, s5, s7);
4636
+ s0 = peg$f58(s3, s5, s7);
4484
4637
  } else {
4485
4638
  peg$currPos = s0;
4486
4639
  s0 = peg$FAILED;
@@ -4494,7 +4647,7 @@ function peg$parse(input, options) {
4494
4647
  s1 = peg$parseComment();
4495
4648
  if (s1 !== peg$FAILED) {
4496
4649
  peg$savedPos = s0;
4497
- s1 = peg$f58();
4650
+ s1 = peg$f59();
4498
4651
  }
4499
4652
  s0 = s1;
4500
4653
  }
@@ -4503,13 +4656,13 @@ function peg$parse(input, options) {
4503
4656
  function peg$parseAlert() {
4504
4657
  let s0, s1, s2, s3, s4, s5;
4505
4658
  s0 = peg$currPos;
4506
- if (input.substr(peg$currPos, 5) === peg$c55) {
4507
- s1 = peg$c55;
4659
+ if (input.substr(peg$currPos, 5) === peg$c56) {
4660
+ s1 = peg$c56;
4508
4661
  peg$currPos += 5;
4509
4662
  } else {
4510
4663
  s1 = peg$FAILED;
4511
4664
  if (peg$silentFails === 0) {
4512
- peg$fail(peg$e58);
4665
+ peg$fail(peg$e59);
4513
4666
  }
4514
4667
  }
4515
4668
  if (s1 !== peg$FAILED) {
@@ -4522,7 +4675,7 @@ function peg$parse(input, options) {
4522
4675
  s5 = null;
4523
4676
  }
4524
4677
  peg$savedPos = s0;
4525
- s0 = peg$f59(s3, s5);
4678
+ s0 = peg$f60(s3, s5);
4526
4679
  } else {
4527
4680
  peg$currPos = s0;
4528
4681
  s0 = peg$FAILED;
@@ -4536,13 +4689,13 @@ function peg$parse(input, options) {
4536
4689
  function peg$parseToast() {
4537
4690
  let s0, s1, s2, s3, s4, s5;
4538
4691
  s0 = peg$currPos;
4539
- if (input.substr(peg$currPos, 5) === peg$c56) {
4540
- s1 = peg$c56;
4692
+ if (input.substr(peg$currPos, 5) === peg$c57) {
4693
+ s1 = peg$c57;
4541
4694
  peg$currPos += 5;
4542
4695
  } else {
4543
4696
  s1 = peg$FAILED;
4544
4697
  if (peg$silentFails === 0) {
4545
- peg$fail(peg$e59);
4698
+ peg$fail(peg$e60);
4546
4699
  }
4547
4700
  }
4548
4701
  if (s1 !== peg$FAILED) {
@@ -4555,7 +4708,7 @@ function peg$parse(input, options) {
4555
4708
  s5 = null;
4556
4709
  }
4557
4710
  peg$savedPos = s0;
4558
- s0 = peg$f60(s3, s5);
4711
+ s0 = peg$f61(s3, s5);
4559
4712
  } else {
4560
4713
  peg$currPos = s0;
4561
4714
  s0 = peg$FAILED;
@@ -4569,13 +4722,13 @@ function peg$parse(input, options) {
4569
4722
  function peg$parseProgress() {
4570
4723
  let s0, s1, s2, s3;
4571
4724
  s0 = peg$currPos;
4572
- if (input.substr(peg$currPos, 8) === peg$c57) {
4573
- s1 = peg$c57;
4725
+ if (input.substr(peg$currPos, 8) === peg$c58) {
4726
+ s1 = peg$c58;
4574
4727
  peg$currPos += 8;
4575
4728
  } else {
4576
4729
  s1 = peg$FAILED;
4577
4730
  if (peg$silentFails === 0) {
4578
- peg$fail(peg$e60);
4731
+ peg$fail(peg$e61);
4579
4732
  }
4580
4733
  }
4581
4734
  if (s1 !== peg$FAILED) {
@@ -4585,7 +4738,7 @@ function peg$parse(input, options) {
4585
4738
  s3 = null;
4586
4739
  }
4587
4740
  peg$savedPos = s0;
4588
- s0 = peg$f61(s3);
4741
+ s0 = peg$f62(s3);
4589
4742
  } else {
4590
4743
  peg$currPos = s0;
4591
4744
  s0 = peg$FAILED;
@@ -4595,13 +4748,13 @@ function peg$parse(input, options) {
4595
4748
  function peg$parseSpinner() {
4596
4749
  let s0, s1, s2, s3, s4, s5;
4597
4750
  s0 = peg$currPos;
4598
- if (input.substr(peg$currPos, 7) === peg$c58) {
4599
- s1 = peg$c58;
4751
+ if (input.substr(peg$currPos, 7) === peg$c59) {
4752
+ s1 = peg$c59;
4600
4753
  peg$currPos += 7;
4601
4754
  } else {
4602
4755
  s1 = peg$FAILED;
4603
4756
  if (peg$silentFails === 0) {
4604
- peg$fail(peg$e61);
4757
+ peg$fail(peg$e62);
4605
4758
  }
4606
4759
  }
4607
4760
  if (s1 !== peg$FAILED) {
@@ -4616,7 +4769,7 @@ function peg$parse(input, options) {
4616
4769
  s5 = null;
4617
4770
  }
4618
4771
  peg$savedPos = s0;
4619
- s0 = peg$f62(s3, s5);
4772
+ s0 = peg$f63(s3, s5);
4620
4773
  } else {
4621
4774
  peg$currPos = s0;
4622
4775
  s0 = peg$FAILED;
@@ -4626,13 +4779,13 @@ function peg$parse(input, options) {
4626
4779
  function peg$parseTooltip() {
4627
4780
  let s0, s1, s2, s3, s4, s5;
4628
4781
  s0 = peg$currPos;
4629
- if (input.substr(peg$currPos, 7) === peg$c59) {
4630
- s1 = peg$c59;
4782
+ if (input.substr(peg$currPos, 7) === peg$c60) {
4783
+ s1 = peg$c60;
4631
4784
  peg$currPos += 7;
4632
4785
  } else {
4633
4786
  s1 = peg$FAILED;
4634
4787
  if (peg$silentFails === 0) {
4635
- peg$fail(peg$e62);
4788
+ peg$fail(peg$e63);
4636
4789
  }
4637
4790
  }
4638
4791
  if (s1 !== peg$FAILED) {
@@ -4645,7 +4798,7 @@ function peg$parse(input, options) {
4645
4798
  s5 = null;
4646
4799
  }
4647
4800
  peg$savedPos = s0;
4648
- s0 = peg$f63(s3, s5);
4801
+ s0 = peg$f64(s3, s5);
4649
4802
  } else {
4650
4803
  peg$currPos = s0;
4651
4804
  s0 = peg$FAILED;
@@ -4659,13 +4812,13 @@ function peg$parse(input, options) {
4659
4812
  function peg$parsePopover() {
4660
4813
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
4661
4814
  s0 = peg$currPos;
4662
- if (input.substr(peg$currPos, 7) === peg$c60) {
4663
- s1 = peg$c60;
4815
+ if (input.substr(peg$currPos, 7) === peg$c61) {
4816
+ s1 = peg$c61;
4664
4817
  peg$currPos += 7;
4665
4818
  } else {
4666
4819
  s1 = peg$FAILED;
4667
4820
  if (peg$silentFails === 0) {
4668
- peg$fail(peg$e63);
4821
+ peg$fail(peg$e64);
4669
4822
  }
4670
4823
  }
4671
4824
  if (s1 !== peg$FAILED) {
@@ -4705,7 +4858,7 @@ function peg$parse(input, options) {
4705
4858
  }
4706
4859
  if (s11 !== peg$FAILED) {
4707
4860
  peg$savedPos = s0;
4708
- s0 = peg$f64(s3, s5, s9);
4861
+ s0 = peg$f65(s3, s5, s9);
4709
4862
  } else {
4710
4863
  peg$currPos = s0;
4711
4864
  s0 = peg$FAILED;
@@ -4727,13 +4880,13 @@ function peg$parse(input, options) {
4727
4880
  function peg$parseDropdown() {
4728
4881
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4729
4882
  s0 = peg$currPos;
4730
- if (input.substr(peg$currPos, 8) === peg$c61) {
4731
- s1 = peg$c61;
4883
+ if (input.substr(peg$currPos, 8) === peg$c62) {
4884
+ s1 = peg$c62;
4732
4885
  peg$currPos += 8;
4733
4886
  } else {
4734
4887
  s1 = peg$FAILED;
4735
4888
  if (peg$silentFails === 0) {
4736
- peg$fail(peg$e64);
4889
+ peg$fail(peg$e65);
4737
4890
  }
4738
4891
  }
4739
4892
  if (s1 !== peg$FAILED) {
@@ -4746,7 +4899,7 @@ function peg$parse(input, options) {
4746
4899
  s5 = null;
4747
4900
  }
4748
4901
  peg$savedPos = s0;
4749
- s0 = peg$f65(s3, s5);
4902
+ s0 = peg$f66(s3, s5);
4750
4903
  } else {
4751
4904
  peg$currPos = s0;
4752
4905
  s0 = peg$FAILED;
@@ -4757,13 +4910,13 @@ function peg$parse(input, options) {
4757
4910
  }
4758
4911
  if (s0 === peg$FAILED) {
4759
4912
  s0 = peg$currPos;
4760
- if (input.substr(peg$currPos, 8) === peg$c61) {
4761
- s1 = peg$c61;
4913
+ if (input.substr(peg$currPos, 8) === peg$c62) {
4914
+ s1 = peg$c62;
4762
4915
  peg$currPos += 8;
4763
4916
  } else {
4764
4917
  s1 = peg$FAILED;
4765
4918
  if (peg$silentFails === 0) {
4766
- peg$fail(peg$e64);
4919
+ peg$fail(peg$e65);
4767
4920
  }
4768
4921
  }
4769
4922
  if (s1 !== peg$FAILED) {
@@ -4797,7 +4950,7 @@ function peg$parse(input, options) {
4797
4950
  }
4798
4951
  if (s9 !== peg$FAILED) {
4799
4952
  peg$savedPos = s0;
4800
- s0 = peg$f66(s3, s7);
4953
+ s0 = peg$f67(s3, s7);
4801
4954
  } else {
4802
4955
  peg$currPos = s0;
4803
4956
  s0 = peg$FAILED;
@@ -4841,20 +4994,20 @@ function peg$parse(input, options) {
4841
4994
  }
4842
4995
  }
4843
4996
  peg$savedPos = s0;
4844
- s1 = peg$f67(s1);
4997
+ s1 = peg$f68(s1);
4845
4998
  s0 = s1;
4846
4999
  return s0;
4847
5000
  }
4848
5001
  function peg$parseDropdownItem() {
4849
5002
  let s0, s1, s2, s3, s4, s5;
4850
5003
  s0 = peg$currPos;
4851
- if (input.substr(peg$currPos, 4) === peg$c54) {
4852
- s1 = peg$c54;
5004
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5005
+ s1 = peg$c55;
4853
5006
  peg$currPos += 4;
4854
5007
  } else {
4855
5008
  s1 = peg$FAILED;
4856
5009
  if (peg$silentFails === 0) {
4857
- peg$fail(peg$e57);
5010
+ peg$fail(peg$e58);
4858
5011
  }
4859
5012
  }
4860
5013
  if (s1 !== peg$FAILED) {
@@ -4867,7 +5020,7 @@ function peg$parse(input, options) {
4867
5020
  s5 = null;
4868
5021
  }
4869
5022
  peg$savedPos = s0;
4870
- s0 = peg$f68(s3, s5);
5023
+ s0 = peg$f69(s3, s5);
4871
5024
  } else {
4872
5025
  peg$currPos = s0;
4873
5026
  s0 = peg$FAILED;
@@ -4878,18 +5031,18 @@ function peg$parse(input, options) {
4878
5031
  }
4879
5032
  if (s0 === peg$FAILED) {
4880
5033
  s0 = peg$currPos;
4881
- if (input.substr(peg$currPos, 7) === peg$c62) {
4882
- s1 = peg$c62;
5034
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5035
+ s1 = peg$c63;
4883
5036
  peg$currPos += 7;
4884
5037
  } else {
4885
5038
  s1 = peg$FAILED;
4886
5039
  if (peg$silentFails === 0) {
4887
- peg$fail(peg$e65);
5040
+ peg$fail(peg$e66);
4888
5041
  }
4889
5042
  }
4890
5043
  if (s1 !== peg$FAILED) {
4891
5044
  peg$savedPos = s0;
4892
- s1 = peg$f69();
5045
+ s1 = peg$f70();
4893
5046
  }
4894
5047
  s0 = s1;
4895
5048
  if (s0 === peg$FAILED) {
@@ -4897,7 +5050,7 @@ function peg$parse(input, options) {
4897
5050
  s1 = peg$parseComment();
4898
5051
  if (s1 !== peg$FAILED) {
4899
5052
  peg$savedPos = s0;
4900
- s1 = peg$f70();
5053
+ s1 = peg$f71();
4901
5054
  }
4902
5055
  s0 = s1;
4903
5056
  }
@@ -4907,13 +5060,13 @@ function peg$parse(input, options) {
4907
5060
  function peg$parseNav() {
4908
5061
  let s0, s1, s2, s3, s4, s5, s6, s7;
4909
5062
  s0 = peg$currPos;
4910
- if (input.substr(peg$currPos, 3) === peg$c63) {
4911
- s1 = peg$c63;
5063
+ if (input.substr(peg$currPos, 3) === peg$c64) {
5064
+ s1 = peg$c64;
4912
5065
  peg$currPos += 3;
4913
5066
  } else {
4914
5067
  s1 = peg$FAILED;
4915
5068
  if (peg$silentFails === 0) {
4916
- peg$fail(peg$e66);
5069
+ peg$fail(peg$e67);
4917
5070
  }
4918
5071
  }
4919
5072
  if (s1 !== peg$FAILED) {
@@ -4933,7 +5086,7 @@ function peg$parse(input, options) {
4933
5086
  s7 = null;
4934
5087
  }
4935
5088
  peg$savedPos = s0;
4936
- s0 = peg$f71(s3, s5, s7);
5089
+ s0 = peg$f72(s3, s5, s7);
4937
5090
  } else {
4938
5091
  peg$currPos = s0;
4939
5092
  s0 = peg$FAILED;
@@ -4989,7 +5142,7 @@ function peg$parse(input, options) {
4989
5142
  }
4990
5143
  if (s4 !== peg$FAILED) {
4991
5144
  peg$savedPos = s0;
4992
- s0 = peg$f72(s3);
5145
+ s0 = peg$f73(s3);
4993
5146
  } else {
4994
5147
  peg$currPos = s0;
4995
5148
  s0 = peg$FAILED;
@@ -5007,19 +5160,19 @@ function peg$parse(input, options) {
5007
5160
  s0 = peg$parseNavItem();
5008
5161
  if (s0 === peg$FAILED) {
5009
5162
  s0 = peg$currPos;
5010
- if (input.substr(peg$currPos, 7) === peg$c62) {
5011
- s1 = peg$c62;
5163
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5164
+ s1 = peg$c63;
5012
5165
  peg$currPos += 7;
5013
5166
  } else {
5014
5167
  s1 = peg$FAILED;
5015
5168
  if (peg$silentFails === 0) {
5016
- peg$fail(peg$e65);
5169
+ peg$fail(peg$e66);
5017
5170
  }
5018
5171
  }
5019
5172
  if (s1 !== peg$FAILED) {
5020
5173
  s2 = peg$parse_();
5021
5174
  peg$savedPos = s0;
5022
- s0 = peg$f73();
5175
+ s0 = peg$f74();
5023
5176
  } else {
5024
5177
  peg$currPos = s0;
5025
5178
  s0 = peg$FAILED;
@@ -5029,7 +5182,7 @@ function peg$parse(input, options) {
5029
5182
  s1 = peg$parseComment();
5030
5183
  if (s1 !== peg$FAILED) {
5031
5184
  peg$savedPos = s0;
5032
- s1 = peg$f74();
5185
+ s1 = peg$f75();
5033
5186
  }
5034
5187
  s0 = s1;
5035
5188
  }
@@ -5040,13 +5193,13 @@ function peg$parse(input, options) {
5040
5193
  function peg$parseNavGroup() {
5041
5194
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
5042
5195
  s0 = peg$currPos;
5043
- if (input.substr(peg$currPos, 5) === peg$c64) {
5044
- s1 = peg$c64;
5196
+ if (input.substr(peg$currPos, 5) === peg$c65) {
5197
+ s1 = peg$c65;
5045
5198
  peg$currPos += 5;
5046
5199
  } else {
5047
5200
  s1 = peg$FAILED;
5048
5201
  if (peg$silentFails === 0) {
5049
- peg$fail(peg$e67);
5202
+ peg$fail(peg$e68);
5050
5203
  }
5051
5204
  }
5052
5205
  if (s1 !== peg$FAILED) {
@@ -5105,7 +5258,7 @@ function peg$parse(input, options) {
5105
5258
  }
5106
5259
  if (s10 !== peg$FAILED) {
5107
5260
  peg$savedPos = s0;
5108
- s0 = peg$f75(s3, s5, s9);
5261
+ s0 = peg$f76(s3, s5, s9);
5109
5262
  } else {
5110
5263
  peg$currPos = s0;
5111
5264
  s0 = peg$FAILED;
@@ -5129,19 +5282,19 @@ function peg$parse(input, options) {
5129
5282
  s0 = peg$parseNavItem();
5130
5283
  if (s0 === peg$FAILED) {
5131
5284
  s0 = peg$currPos;
5132
- if (input.substr(peg$currPos, 7) === peg$c62) {
5133
- s1 = peg$c62;
5285
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5286
+ s1 = peg$c63;
5134
5287
  peg$currPos += 7;
5135
5288
  } else {
5136
5289
  s1 = peg$FAILED;
5137
5290
  if (peg$silentFails === 0) {
5138
- peg$fail(peg$e65);
5291
+ peg$fail(peg$e66);
5139
5292
  }
5140
5293
  }
5141
5294
  if (s1 !== peg$FAILED) {
5142
5295
  s2 = peg$parse_();
5143
5296
  peg$savedPos = s0;
5144
- s0 = peg$f76();
5297
+ s0 = peg$f77();
5145
5298
  } else {
5146
5299
  peg$currPos = s0;
5147
5300
  s0 = peg$FAILED;
@@ -5151,7 +5304,7 @@ function peg$parse(input, options) {
5151
5304
  s1 = peg$parseComment();
5152
5305
  if (s1 !== peg$FAILED) {
5153
5306
  peg$savedPos = s0;
5154
- s1 = peg$f77();
5307
+ s1 = peg$f78();
5155
5308
  }
5156
5309
  s0 = s1;
5157
5310
  }
@@ -5161,13 +5314,13 @@ function peg$parse(input, options) {
5161
5314
  function peg$parseNavItem() {
5162
5315
  let s0, s1, s2, s3, s4, s5;
5163
5316
  s0 = peg$currPos;
5164
- if (input.substr(peg$currPos, 4) === peg$c54) {
5165
- s1 = peg$c54;
5317
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5318
+ s1 = peg$c55;
5166
5319
  peg$currPos += 4;
5167
5320
  } else {
5168
5321
  s1 = peg$FAILED;
5169
5322
  if (peg$silentFails === 0) {
5170
- peg$fail(peg$e57);
5323
+ peg$fail(peg$e58);
5171
5324
  }
5172
5325
  }
5173
5326
  if (s1 !== peg$FAILED) {
@@ -5180,7 +5333,7 @@ function peg$parse(input, options) {
5180
5333
  s5 = null;
5181
5334
  }
5182
5335
  peg$savedPos = s0;
5183
- s0 = peg$f78(s3, s5);
5336
+ s0 = peg$f79(s3, s5);
5184
5337
  } else {
5185
5338
  peg$currPos = s0;
5186
5339
  s0 = peg$FAILED;
@@ -5194,13 +5347,13 @@ function peg$parse(input, options) {
5194
5347
  function peg$parseTabs() {
5195
5348
  let s0, s1, s2, s3, s4, s5, s6, s7;
5196
5349
  s0 = peg$currPos;
5197
- if (input.substr(peg$currPos, 4) === peg$c65) {
5198
- s1 = peg$c65;
5350
+ if (input.substr(peg$currPos, 4) === peg$c66) {
5351
+ s1 = peg$c66;
5199
5352
  peg$currPos += 4;
5200
5353
  } else {
5201
5354
  s1 = peg$FAILED;
5202
5355
  if (peg$silentFails === 0) {
5203
- peg$fail(peg$e68);
5356
+ peg$fail(peg$e69);
5204
5357
  }
5205
5358
  }
5206
5359
  if (s1 !== peg$FAILED) {
@@ -5220,7 +5373,7 @@ function peg$parse(input, options) {
5220
5373
  s7 = null;
5221
5374
  }
5222
5375
  peg$savedPos = s0;
5223
- s0 = peg$f79(s3, s5, s7);
5376
+ s0 = peg$f80(s3, s5, s7);
5224
5377
  } else {
5225
5378
  peg$currPos = s0;
5226
5379
  s0 = peg$FAILED;
@@ -5276,7 +5429,7 @@ function peg$parse(input, options) {
5276
5429
  }
5277
5430
  if (s4 !== peg$FAILED) {
5278
5431
  peg$savedPos = s0;
5279
- s0 = peg$f80(s3);
5432
+ s0 = peg$f81(s3);
5280
5433
  } else {
5281
5434
  peg$currPos = s0;
5282
5435
  s0 = peg$FAILED;
@@ -5290,13 +5443,13 @@ function peg$parse(input, options) {
5290
5443
  function peg$parseTabItem() {
5291
5444
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
5292
5445
  s0 = peg$currPos;
5293
- if (input.substr(peg$currPos, 3) === peg$c66) {
5294
- s1 = peg$c66;
5446
+ if (input.substr(peg$currPos, 3) === peg$c67) {
5447
+ s1 = peg$c67;
5295
5448
  peg$currPos += 3;
5296
5449
  } else {
5297
5450
  s1 = peg$FAILED;
5298
5451
  if (peg$silentFails === 0) {
5299
- peg$fail(peg$e69);
5452
+ peg$fail(peg$e70);
5300
5453
  }
5301
5454
  }
5302
5455
  if (s1 !== peg$FAILED) {
@@ -5334,7 +5487,7 @@ function peg$parse(input, options) {
5334
5487
  }
5335
5488
  if (s11 !== peg$FAILED) {
5336
5489
  peg$savedPos = s0;
5337
- s0 = peg$f81(s3, s5, s9);
5490
+ s0 = peg$f82(s3, s5, s9);
5338
5491
  } else {
5339
5492
  peg$currPos = s0;
5340
5493
  s0 = peg$FAILED;
@@ -5360,7 +5513,7 @@ function peg$parse(input, options) {
5360
5513
  s1 = peg$parseComment();
5361
5514
  if (s1 !== peg$FAILED) {
5362
5515
  peg$savedPos = s0;
5363
- s1 = peg$f82();
5516
+ s1 = peg$f83();
5364
5517
  }
5365
5518
  s0 = s1;
5366
5519
  }
@@ -5369,13 +5522,13 @@ function peg$parse(input, options) {
5369
5522
  function peg$parseBreadcrumb() {
5370
5523
  let s0, s1, s2, s3, s4, s5;
5371
5524
  s0 = peg$currPos;
5372
- if (input.substr(peg$currPos, 10) === peg$c67) {
5373
- s1 = peg$c67;
5525
+ if (input.substr(peg$currPos, 10) === peg$c68) {
5526
+ s1 = peg$c68;
5374
5527
  peg$currPos += 10;
5375
5528
  } else {
5376
5529
  s1 = peg$FAILED;
5377
5530
  if (peg$silentFails === 0) {
5378
- peg$fail(peg$e70);
5531
+ peg$fail(peg$e71);
5379
5532
  }
5380
5533
  }
5381
5534
  if (s1 !== peg$FAILED) {
@@ -5388,7 +5541,7 @@ function peg$parse(input, options) {
5388
5541
  s5 = null;
5389
5542
  }
5390
5543
  peg$savedPos = s0;
5391
- s0 = peg$f83(s3, s5);
5544
+ s0 = peg$f84(s3, s5);
5392
5545
  } else {
5393
5546
  peg$currPos = s0;
5394
5547
  s0 = peg$FAILED;
@@ -5402,13 +5555,13 @@ function peg$parse(input, options) {
5402
5555
  function peg$parseDivider() {
5403
5556
  let s0, s1, s2, s3;
5404
5557
  s0 = peg$currPos;
5405
- if (input.substr(peg$currPos, 7) === peg$c62) {
5406
- s1 = peg$c62;
5558
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5559
+ s1 = peg$c63;
5407
5560
  peg$currPos += 7;
5408
5561
  } else {
5409
5562
  s1 = peg$FAILED;
5410
5563
  if (peg$silentFails === 0) {
5411
- peg$fail(peg$e65);
5564
+ peg$fail(peg$e66);
5412
5565
  }
5413
5566
  }
5414
5567
  if (s1 !== peg$FAILED) {
@@ -5418,7 +5571,7 @@ function peg$parse(input, options) {
5418
5571
  s3 = null;
5419
5572
  }
5420
5573
  peg$savedPos = s0;
5421
- s0 = peg$f84(s3);
5574
+ s0 = peg$f85(s3);
5422
5575
  } else {
5423
5576
  peg$currPos = s0;
5424
5577
  s0 = peg$FAILED;
@@ -5428,13 +5581,13 @@ function peg$parse(input, options) {
5428
5581
  function peg$parseMarker() {
5429
5582
  let s0, s1, s2, s3, s4, s5;
5430
5583
  s0 = peg$currPos;
5431
- if (input.substr(peg$currPos, 6) === peg$c68) {
5432
- s1 = peg$c68;
5584
+ if (input.substr(peg$currPos, 6) === peg$c69) {
5585
+ s1 = peg$c69;
5433
5586
  peg$currPos += 6;
5434
5587
  } else {
5435
5588
  s1 = peg$FAILED;
5436
5589
  if (peg$silentFails === 0) {
5437
- peg$fail(peg$e71);
5590
+ peg$fail(peg$e72);
5438
5591
  }
5439
5592
  }
5440
5593
  if (s1 !== peg$FAILED) {
@@ -5447,7 +5600,7 @@ function peg$parse(input, options) {
5447
5600
  s5 = null;
5448
5601
  }
5449
5602
  peg$savedPos = s0;
5450
- s0 = peg$f85(s3, s5);
5603
+ s0 = peg$f86(s3, s5);
5451
5604
  } else {
5452
5605
  peg$currPos = s0;
5453
5606
  s0 = peg$FAILED;
@@ -5461,13 +5614,13 @@ function peg$parse(input, options) {
5461
5614
  function peg$parseAnnotations() {
5462
5615
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
5463
5616
  s0 = peg$currPos;
5464
- if (input.substr(peg$currPos, 11) === peg$c69) {
5465
- s1 = peg$c69;
5617
+ if (input.substr(peg$currPos, 11) === peg$c70) {
5618
+ s1 = peg$c70;
5466
5619
  peg$currPos += 11;
5467
5620
  } else {
5468
5621
  s1 = peg$FAILED;
5469
5622
  if (peg$silentFails === 0) {
5470
- peg$fail(peg$e72);
5623
+ peg$fail(peg$e73);
5471
5624
  }
5472
5625
  }
5473
5626
  if (s1 !== peg$FAILED) {
@@ -5501,7 +5654,7 @@ function peg$parse(input, options) {
5501
5654
  }
5502
5655
  if (s9 !== peg$FAILED) {
5503
5656
  peg$savedPos = s0;
5504
- s0 = peg$f86(s3, s7);
5657
+ s0 = peg$f87(s3, s7);
5505
5658
  } else {
5506
5659
  peg$currPos = s0;
5507
5660
  s0 = peg$FAILED;
@@ -5544,20 +5697,20 @@ function peg$parse(input, options) {
5544
5697
  }
5545
5698
  }
5546
5699
  peg$savedPos = s0;
5547
- s1 = peg$f87(s1);
5700
+ s1 = peg$f88(s1);
5548
5701
  s0 = s1;
5549
5702
  return s0;
5550
5703
  }
5551
5704
  function peg$parseAnnotationItem() {
5552
5705
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5553
5706
  s0 = peg$currPos;
5554
- if (input.substr(peg$currPos, 4) === peg$c54) {
5555
- s1 = peg$c54;
5707
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5708
+ s1 = peg$c55;
5556
5709
  peg$currPos += 4;
5557
5710
  } else {
5558
5711
  s1 = peg$FAILED;
5559
5712
  if (peg$silentFails === 0) {
5560
- peg$fail(peg$e57);
5713
+ peg$fail(peg$e58);
5561
5714
  }
5562
5715
  }
5563
5716
  if (s1 !== peg$FAILED) {
@@ -5598,7 +5751,7 @@ function peg$parse(input, options) {
5598
5751
  }
5599
5752
  if (s13 !== peg$FAILED) {
5600
5753
  peg$savedPos = s0;
5601
- s0 = peg$f88(s3, s5, s7, s11);
5754
+ s0 = peg$f89(s3, s5, s7, s11);
5602
5755
  } else {
5603
5756
  peg$currPos = s0;
5604
5757
  s0 = peg$FAILED;
@@ -5625,13 +5778,13 @@ function peg$parse(input, options) {
5625
5778
  }
5626
5779
  if (s0 === peg$FAILED) {
5627
5780
  s0 = peg$currPos;
5628
- if (input.substr(peg$currPos, 4) === peg$c54) {
5629
- s1 = peg$c54;
5781
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5782
+ s1 = peg$c55;
5630
5783
  peg$currPos += 4;
5631
5784
  } else {
5632
5785
  s1 = peg$FAILED;
5633
5786
  if (peg$silentFails === 0) {
5634
- peg$fail(peg$e57);
5787
+ peg$fail(peg$e58);
5635
5788
  }
5636
5789
  }
5637
5790
  if (s1 !== peg$FAILED) {
@@ -5647,7 +5800,7 @@ function peg$parse(input, options) {
5647
5800
  s7 = null;
5648
5801
  }
5649
5802
  peg$savedPos = s0;
5650
- s0 = peg$f89(s3, s5, s7);
5803
+ s0 = peg$f90(s3, s5, s7);
5651
5804
  } else {
5652
5805
  peg$currPos = s0;
5653
5806
  s0 = peg$FAILED;
@@ -5665,7 +5818,7 @@ function peg$parse(input, options) {
5665
5818
  s1 = peg$parseComment();
5666
5819
  if (s1 !== peg$FAILED) {
5667
5820
  peg$savedPos = s0;
5668
- s1 = peg$f90();
5821
+ s1 = peg$f91();
5669
5822
  }
5670
5823
  s0 = s1;
5671
5824
  }
@@ -5683,7 +5836,7 @@ function peg$parse(input, options) {
5683
5836
  } else {
5684
5837
  s2 = peg$FAILED;
5685
5838
  if (peg$silentFails === 0) {
5686
- peg$fail(peg$e74);
5839
+ peg$fail(peg$e75);
5687
5840
  }
5688
5841
  }
5689
5842
  if (s2 !== peg$FAILED) {
@@ -5695,7 +5848,7 @@ function peg$parse(input, options) {
5695
5848
  } else {
5696
5849
  s2 = peg$FAILED;
5697
5850
  if (peg$silentFails === 0) {
5698
- peg$fail(peg$e74);
5851
+ peg$fail(peg$e75);
5699
5852
  }
5700
5853
  }
5701
5854
  }
@@ -5704,14 +5857,14 @@ function peg$parse(input, options) {
5704
5857
  }
5705
5858
  if (s1 !== peg$FAILED) {
5706
5859
  peg$savedPos = s0;
5707
- s1 = peg$f91(s1);
5860
+ s1 = peg$f92(s1);
5708
5861
  }
5709
5862
  s0 = s1;
5710
5863
  peg$silentFails--;
5711
5864
  if (s0 === peg$FAILED) {
5712
5865
  s1 = peg$FAILED;
5713
5866
  if (peg$silentFails === 0) {
5714
- peg$fail(peg$e73);
5867
+ peg$fail(peg$e74);
5715
5868
  }
5716
5869
  }
5717
5870
  return s0;
@@ -5731,7 +5884,7 @@ function peg$parse(input, options) {
5731
5884
  }
5732
5885
  if (s1 !== peg$FAILED) {
5733
5886
  peg$savedPos = s0;
5734
- s1 = peg$f92(s1);
5887
+ s1 = peg$f93(s1);
5735
5888
  }
5736
5889
  s0 = s1;
5737
5890
  return s0;
@@ -5740,13 +5893,13 @@ function peg$parse(input, options) {
5740
5893
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5741
5894
  s0 = peg$currPos;
5742
5895
  s1 = peg$parse_();
5743
- if (input.substr(peg$currPos, 2) === peg$c70) {
5744
- s2 = peg$c70;
5896
+ if (input.substr(peg$currPos, 2) === peg$c71) {
5897
+ s2 = peg$c71;
5745
5898
  peg$currPos += 2;
5746
5899
  } else {
5747
5900
  s2 = peg$FAILED;
5748
5901
  if (peg$silentFails === 0) {
5749
- peg$fail(peg$e75);
5902
+ peg$fail(peg$e76);
5750
5903
  }
5751
5904
  }
5752
5905
  if (s2 !== peg$FAILED) {
@@ -5801,7 +5954,7 @@ function peg$parse(input, options) {
5801
5954
  }
5802
5955
  if (s13 !== peg$FAILED) {
5803
5956
  peg$savedPos = s0;
5804
- s0 = peg$f93(s7, s11);
5957
+ s0 = peg$f94(s7, s11);
5805
5958
  } else {
5806
5959
  peg$currPos = s0;
5807
5960
  s0 = peg$FAILED;
@@ -5850,7 +6003,7 @@ function peg$parse(input, options) {
5850
6003
  s6 = peg$parseAttributeValue();
5851
6004
  if (s6 !== peg$FAILED) {
5852
6005
  peg$savedPos = s0;
5853
- s0 = peg$f94(s2, s6);
6006
+ s0 = peg$f95(s2, s6);
5854
6007
  } else {
5855
6008
  peg$currPos = s0;
5856
6009
  s0 = peg$FAILED;
@@ -5882,7 +6035,7 @@ function peg$parse(input, options) {
5882
6035
  } else {
5883
6036
  s6 = peg$FAILED;
5884
6037
  if (peg$silentFails === 0) {
5885
- peg$fail(peg$e76);
6038
+ peg$fail(peg$e77);
5886
6039
  }
5887
6040
  }
5888
6041
  if (s6 === peg$FAILED) {
@@ -5945,7 +6098,7 @@ function peg$parse(input, options) {
5945
6098
  }
5946
6099
  if (s3 !== peg$FAILED) {
5947
6100
  peg$savedPos = s0;
5948
- s0 = peg$f95(s2);
6101
+ s0 = peg$f96(s2);
5949
6102
  } else {
5950
6103
  peg$currPos = s0;
5951
6104
  s0 = peg$FAILED;
@@ -5975,7 +6128,7 @@ function peg$parse(input, options) {
5975
6128
  s2 = peg$parseIdentifier();
5976
6129
  if (s2 !== peg$FAILED) {
5977
6130
  peg$savedPos = s0;
5978
- s0 = peg$f96(s2);
6131
+ s0 = peg$f97(s2);
5979
6132
  } else {
5980
6133
  peg$currPos = s0;
5981
6134
  s0 = peg$FAILED;
@@ -5999,503 +6152,514 @@ function peg$parse(input, options) {
5999
6152
  }
6000
6153
  }
6001
6154
  if (s1 === peg$FAILED) {
6002
- if (input.substr(peg$currPos, 6) === peg$c20) {
6003
- s1 = peg$c20;
6155
+ if (input.substr(peg$currPos, 6) === peg$c21) {
6156
+ s1 = peg$c21;
6004
6157
  peg$currPos += 6;
6005
6158
  } else {
6006
6159
  s1 = peg$FAILED;
6007
6160
  if (peg$silentFails === 0) {
6008
- peg$fail(peg$e23);
6161
+ peg$fail(peg$e24);
6009
6162
  }
6010
6163
  }
6011
6164
  if (s1 === peg$FAILED) {
6012
- if (input.substr(peg$currPos, 4) === peg$c21) {
6013
- s1 = peg$c21;
6165
+ if (input.substr(peg$currPos, 4) === peg$c22) {
6166
+ s1 = peg$c22;
6014
6167
  peg$currPos += 4;
6015
6168
  } else {
6016
6169
  s1 = peg$FAILED;
6017
6170
  if (peg$silentFails === 0) {
6018
- peg$fail(peg$e24);
6171
+ peg$fail(peg$e25);
6019
6172
  }
6020
6173
  }
6021
6174
  if (s1 === peg$FAILED) {
6022
- if (input.substr(peg$currPos, 6) === peg$c22) {
6023
- s1 = peg$c22;
6175
+ if (input.substr(peg$currPos, 6) === peg$c23) {
6176
+ s1 = peg$c23;
6024
6177
  peg$currPos += 6;
6025
6178
  } else {
6026
6179
  s1 = peg$FAILED;
6027
6180
  if (peg$silentFails === 0) {
6028
- peg$fail(peg$e25);
6181
+ peg$fail(peg$e26);
6029
6182
  }
6030
6183
  }
6031
6184
  if (s1 === peg$FAILED) {
6032
- if (input.substr(peg$currPos, 7) === peg$c23) {
6033
- s1 = peg$c23;
6185
+ if (input.substr(peg$currPos, 7) === peg$c24) {
6186
+ s1 = peg$c24;
6034
6187
  peg$currPos += 7;
6035
6188
  } else {
6036
6189
  s1 = peg$FAILED;
6037
6190
  if (peg$silentFails === 0) {
6038
- peg$fail(peg$e26);
6191
+ peg$fail(peg$e27);
6039
6192
  }
6040
6193
  }
6041
6194
  if (s1 === peg$FAILED) {
6042
- if (input.substr(peg$currPos, 3) === peg$c24) {
6043
- s1 = peg$c24;
6195
+ if (input.substr(peg$currPos, 3) === peg$c25) {
6196
+ s1 = peg$c25;
6044
6197
  peg$currPos += 3;
6045
6198
  } else {
6046
6199
  s1 = peg$FAILED;
6047
6200
  if (peg$silentFails === 0) {
6048
- peg$fail(peg$e27);
6201
+ peg$fail(peg$e28);
6049
6202
  }
6050
6203
  }
6051
6204
  if (s1 === peg$FAILED) {
6052
- if (input.substr(peg$currPos, 3) === peg$c25) {
6053
- s1 = peg$c25;
6205
+ if (input.substr(peg$currPos, 3) === peg$c26) {
6206
+ s1 = peg$c26;
6054
6207
  peg$currPos += 3;
6055
6208
  } else {
6056
6209
  s1 = peg$FAILED;
6057
6210
  if (peg$silentFails === 0) {
6058
- peg$fail(peg$e28);
6211
+ peg$fail(peg$e29);
6059
6212
  }
6060
6213
  }
6061
6214
  if (s1 === peg$FAILED) {
6062
- if (input.substr(peg$currPos, 5) === peg$c26) {
6063
- s1 = peg$c26;
6215
+ if (input.substr(peg$currPos, 5) === peg$c27) {
6216
+ s1 = peg$c27;
6064
6217
  peg$currPos += 5;
6065
6218
  } else {
6066
6219
  s1 = peg$FAILED;
6067
6220
  if (peg$silentFails === 0) {
6068
- peg$fail(peg$e29);
6221
+ peg$fail(peg$e30);
6069
6222
  }
6070
6223
  }
6071
6224
  if (s1 === peg$FAILED) {
6072
- if (input.substr(peg$currPos, 8) === peg$c27) {
6073
- s1 = peg$c27;
6225
+ if (input.substr(peg$currPos, 8) === peg$c28) {
6226
+ s1 = peg$c28;
6074
6227
  peg$currPos += 8;
6075
6228
  } else {
6076
6229
  s1 = peg$FAILED;
6077
6230
  if (peg$silentFails === 0) {
6078
- peg$fail(peg$e30);
6231
+ peg$fail(peg$e31);
6079
6232
  }
6080
6233
  }
6081
6234
  if (s1 === peg$FAILED) {
6082
- if (input.substr(peg$currPos, 4) === peg$c28) {
6083
- s1 = peg$c28;
6235
+ if (input.substr(peg$currPos, 4) === peg$c29) {
6236
+ s1 = peg$c29;
6084
6237
  peg$currPos += 4;
6085
6238
  } else {
6086
6239
  s1 = peg$FAILED;
6087
6240
  if (peg$silentFails === 0) {
6088
- peg$fail(peg$e31);
6241
+ peg$fail(peg$e32);
6089
6242
  }
6090
6243
  }
6091
6244
  if (s1 === peg$FAILED) {
6092
- if (input.substr(peg$currPos, 5) === peg$c29) {
6093
- s1 = peg$c29;
6245
+ if (input.substr(peg$currPos, 5) === peg$c30) {
6246
+ s1 = peg$c30;
6094
6247
  peg$currPos += 5;
6095
6248
  } else {
6096
6249
  s1 = peg$FAILED;
6097
6250
  if (peg$silentFails === 0) {
6098
- peg$fail(peg$e32);
6251
+ peg$fail(peg$e33);
6099
6252
  }
6100
6253
  }
6101
6254
  if (s1 === peg$FAILED) {
6102
- if (input.substr(peg$currPos, 6) === peg$c30) {
6103
- s1 = peg$c30;
6255
+ if (input.substr(peg$currPos, 6) === peg$c31) {
6256
+ s1 = peg$c31;
6104
6257
  peg$currPos += 6;
6105
6258
  } else {
6106
6259
  s1 = peg$FAILED;
6107
6260
  if (peg$silentFails === 0) {
6108
- peg$fail(peg$e33);
6261
+ peg$fail(peg$e34);
6109
6262
  }
6110
6263
  }
6111
6264
  if (s1 === peg$FAILED) {
6112
- if (input.substr(peg$currPos, 9) === peg$c31) {
6113
- s1 = peg$c31;
6265
+ if (input.substr(peg$currPos, 9) === peg$c32) {
6266
+ s1 = peg$c32;
6114
6267
  peg$currPos += 9;
6115
6268
  } else {
6116
6269
  s1 = peg$FAILED;
6117
6270
  if (peg$silentFails === 0) {
6118
- peg$fail(peg$e34);
6271
+ peg$fail(peg$e35);
6119
6272
  }
6120
6273
  }
6121
6274
  if (s1 === peg$FAILED) {
6122
- if (input.substr(peg$currPos, 7) === peg$c32) {
6123
- s1 = peg$c32;
6275
+ if (input.substr(peg$currPos, 7) === peg$c33) {
6276
+ s1 = peg$c33;
6124
6277
  peg$currPos += 7;
6125
6278
  } else {
6126
6279
  s1 = peg$FAILED;
6127
6280
  if (peg$silentFails === 0) {
6128
- peg$fail(peg$e35);
6281
+ peg$fail(peg$e36);
6129
6282
  }
6130
6283
  }
6131
6284
  if (s1 === peg$FAILED) {
6132
- if (input.substr(peg$currPos, 4) === peg$c33) {
6133
- s1 = peg$c33;
6285
+ if (input.substr(peg$currPos, 4) === peg$c34) {
6286
+ s1 = peg$c34;
6134
6287
  peg$currPos += 4;
6135
6288
  } else {
6136
6289
  s1 = peg$FAILED;
6137
6290
  if (peg$silentFails === 0) {
6138
- peg$fail(peg$e36);
6291
+ peg$fail(peg$e37);
6139
6292
  }
6140
6293
  }
6141
6294
  if (s1 === peg$FAILED) {
6142
- if (input.substr(peg$currPos, 4) === peg$c35) {
6143
- s1 = peg$c35;
6295
+ if (input.substr(peg$currPos, 4) === peg$c36) {
6296
+ s1 = peg$c36;
6144
6297
  peg$currPos += 4;
6145
6298
  } else {
6146
6299
  s1 = peg$FAILED;
6147
6300
  if (peg$silentFails === 0) {
6148
- peg$fail(peg$e38);
6301
+ peg$fail(peg$e39);
6149
6302
  }
6150
6303
  }
6151
6304
  if (s1 === peg$FAILED) {
6152
- if (input.substr(peg$currPos, 6) === peg$c36) {
6153
- s1 = peg$c36;
6305
+ if (input.substr(peg$currPos, 6) === peg$c37) {
6306
+ s1 = peg$c37;
6154
6307
  peg$currPos += 6;
6155
6308
  } else {
6156
6309
  s1 = peg$FAILED;
6157
6310
  if (peg$silentFails === 0) {
6158
- peg$fail(peg$e39);
6311
+ peg$fail(peg$e40);
6159
6312
  }
6160
6313
  }
6161
6314
  if (s1 === peg$FAILED) {
6162
- if (input.substr(peg$currPos, 5) === peg$c37) {
6163
- s1 = peg$c37;
6315
+ if (input.substr(peg$currPos, 5) === peg$c38) {
6316
+ s1 = peg$c38;
6164
6317
  peg$currPos += 5;
6165
6318
  } else {
6166
6319
  s1 = peg$FAILED;
6167
6320
  if (peg$silentFails === 0) {
6168
- peg$fail(peg$e40);
6321
+ peg$fail(peg$e41);
6169
6322
  }
6170
6323
  }
6171
6324
  if (s1 === peg$FAILED) {
6172
- if (input.substr(peg$currPos, 8) === peg$c38) {
6173
- s1 = peg$c38;
6325
+ if (input.substr(peg$currPos, 8) === peg$c39) {
6326
+ s1 = peg$c39;
6174
6327
  peg$currPos += 8;
6175
6328
  } else {
6176
6329
  s1 = peg$FAILED;
6177
6330
  if (peg$silentFails === 0) {
6178
- peg$fail(peg$e41);
6331
+ peg$fail(peg$e42);
6179
6332
  }
6180
6333
  }
6181
6334
  if (s1 === peg$FAILED) {
6182
- if (input.substr(peg$currPos, 6) === peg$c39) {
6183
- s1 = peg$c39;
6335
+ if (input.substr(peg$currPos, 6) === peg$c40) {
6336
+ s1 = peg$c40;
6184
6337
  peg$currPos += 6;
6185
6338
  } else {
6186
6339
  s1 = peg$FAILED;
6187
6340
  if (peg$silentFails === 0) {
6188
- peg$fail(peg$e42);
6341
+ peg$fail(peg$e43);
6189
6342
  }
6190
6343
  }
6191
6344
  if (s1 === peg$FAILED) {
6192
- if (input.substr(peg$currPos, 8) === peg$c40) {
6193
- s1 = peg$c40;
6345
+ if (input.substr(peg$currPos, 8) === peg$c41) {
6346
+ s1 = peg$c41;
6194
6347
  peg$currPos += 8;
6195
6348
  } else {
6196
6349
  s1 = peg$FAILED;
6197
6350
  if (peg$silentFails === 0) {
6198
- peg$fail(peg$e43);
6351
+ peg$fail(peg$e44);
6199
6352
  }
6200
6353
  }
6201
6354
  if (s1 === peg$FAILED) {
6202
- if (input.substr(peg$currPos, 5) === peg$c41) {
6203
- s1 = peg$c41;
6355
+ if (input.substr(peg$currPos, 5) === peg$c42) {
6356
+ s1 = peg$c42;
6204
6357
  peg$currPos += 5;
6205
6358
  } else {
6206
6359
  s1 = peg$FAILED;
6207
6360
  if (peg$silentFails === 0) {
6208
- peg$fail(peg$e44);
6361
+ peg$fail(peg$e45);
6209
6362
  }
6210
6363
  }
6211
6364
  if (s1 === peg$FAILED) {
6212
- if (input.substr(peg$currPos, 6) === peg$c42) {
6213
- s1 = peg$c42;
6365
+ if (input.substr(peg$currPos, 6) === peg$c43) {
6366
+ s1 = peg$c43;
6214
6367
  peg$currPos += 6;
6215
6368
  } else {
6216
6369
  s1 = peg$FAILED;
6217
6370
  if (peg$silentFails === 0) {
6218
- peg$fail(peg$e45);
6371
+ peg$fail(peg$e46);
6219
6372
  }
6220
6373
  }
6221
6374
  if (s1 === peg$FAILED) {
6222
- if (input.substr(peg$currPos, 6) === peg$c43) {
6223
- s1 = peg$c43;
6375
+ if (input.substr(peg$currPos, 6) === peg$c44) {
6376
+ s1 = peg$c44;
6224
6377
  peg$currPos += 6;
6225
6378
  } else {
6226
6379
  s1 = peg$FAILED;
6227
6380
  if (peg$silentFails === 0) {
6228
- peg$fail(peg$e46);
6381
+ peg$fail(peg$e47);
6229
6382
  }
6230
6383
  }
6231
6384
  if (s1 === peg$FAILED) {
6232
- if (input.substr(peg$currPos, 5) === peg$c44) {
6233
- s1 = peg$c44;
6385
+ if (input.substr(peg$currPos, 5) === peg$c45) {
6386
+ s1 = peg$c45;
6234
6387
  peg$currPos += 5;
6235
6388
  } else {
6236
6389
  s1 = peg$FAILED;
6237
6390
  if (peg$silentFails === 0) {
6238
- peg$fail(peg$e47);
6391
+ peg$fail(peg$e48);
6239
6392
  }
6240
6393
  }
6241
6394
  if (s1 === peg$FAILED) {
6242
- if (input.substr(peg$currPos, 6) === peg$c46) {
6243
- s1 = peg$c46;
6395
+ if (input.substr(peg$currPos, 6) === peg$c47) {
6396
+ s1 = peg$c47;
6244
6397
  peg$currPos += 6;
6245
6398
  } else {
6246
6399
  s1 = peg$FAILED;
6247
6400
  if (peg$silentFails === 0) {
6248
- peg$fail(peg$e49);
6401
+ peg$fail(peg$e50);
6249
6402
  }
6250
6403
  }
6251
6404
  if (s1 === peg$FAILED) {
6252
- if (input.substr(peg$currPos, 5) === peg$c47) {
6253
- s1 = peg$c47;
6405
+ if (input.substr(peg$currPos, 5) === peg$c48) {
6406
+ s1 = peg$c48;
6254
6407
  peg$currPos += 5;
6255
6408
  } else {
6256
6409
  s1 = peg$FAILED;
6257
6410
  if (peg$silentFails === 0) {
6258
- peg$fail(peg$e50);
6411
+ peg$fail(peg$e51);
6259
6412
  }
6260
6413
  }
6261
6414
  if (s1 === peg$FAILED) {
6262
- if (input.substr(peg$currPos, 5) === peg$c49) {
6263
- s1 = peg$c49;
6415
+ if (input.substr(peg$currPos, 5) === peg$c50) {
6416
+ s1 = peg$c50;
6264
6417
  peg$currPos += 5;
6265
6418
  } else {
6266
6419
  s1 = peg$FAILED;
6267
6420
  if (peg$silentFails === 0) {
6268
- peg$fail(peg$e52);
6421
+ peg$fail(peg$e53);
6269
6422
  }
6270
6423
  }
6271
6424
  if (s1 === peg$FAILED) {
6272
- if (input.substr(peg$currPos, 7) === peg$c52) {
6273
- s1 = peg$c52;
6425
+ if (input.substr(peg$currPos, 7) === peg$c53) {
6426
+ s1 = peg$c53;
6274
6427
  peg$currPos += 7;
6275
6428
  } else {
6276
6429
  s1 = peg$FAILED;
6277
6430
  if (peg$silentFails === 0) {
6278
- peg$fail(peg$e55);
6431
+ peg$fail(peg$e56);
6279
6432
  }
6280
6433
  }
6281
6434
  if (s1 === peg$FAILED) {
6282
- if (input.substr(peg$currPos, 4) === peg$c53) {
6283
- s1 = peg$c53;
6435
+ if (input.substr(peg$currPos, 4) === peg$c54) {
6436
+ s1 = peg$c54;
6284
6437
  peg$currPos += 4;
6285
6438
  } else {
6286
6439
  s1 = peg$FAILED;
6287
6440
  if (peg$silentFails === 0) {
6288
- peg$fail(peg$e56);
6441
+ peg$fail(peg$e57);
6289
6442
  }
6290
6443
  }
6291
6444
  if (s1 === peg$FAILED) {
6292
- if (input.substr(peg$currPos, 4) === peg$c54) {
6293
- s1 = peg$c54;
6445
+ if (input.substr(peg$currPos, 4) === peg$c55) {
6446
+ s1 = peg$c55;
6294
6447
  peg$currPos += 4;
6295
6448
  } else {
6296
6449
  s1 = peg$FAILED;
6297
6450
  if (peg$silentFails === 0) {
6298
- peg$fail(peg$e57);
6451
+ peg$fail(peg$e58);
6299
6452
  }
6300
6453
  }
6301
6454
  if (s1 === peg$FAILED) {
6302
- if (input.substr(peg$currPos, 5) === peg$c55) {
6303
- s1 = peg$c55;
6455
+ if (input.substr(peg$currPos, 5) === peg$c56) {
6456
+ s1 = peg$c56;
6304
6457
  peg$currPos += 5;
6305
6458
  } else {
6306
6459
  s1 = peg$FAILED;
6307
6460
  if (peg$silentFails === 0) {
6308
- peg$fail(peg$e58);
6461
+ peg$fail(peg$e59);
6309
6462
  }
6310
6463
  }
6311
6464
  if (s1 === peg$FAILED) {
6312
- if (input.substr(peg$currPos, 5) === peg$c56) {
6313
- s1 = peg$c56;
6465
+ if (input.substr(peg$currPos, 5) === peg$c57) {
6466
+ s1 = peg$c57;
6314
6467
  peg$currPos += 5;
6315
6468
  } else {
6316
6469
  s1 = peg$FAILED;
6317
6470
  if (peg$silentFails === 0) {
6318
- peg$fail(peg$e59);
6471
+ peg$fail(peg$e60);
6319
6472
  }
6320
6473
  }
6321
6474
  if (s1 === peg$FAILED) {
6322
- if (input.substr(peg$currPos, 8) === peg$c57) {
6323
- s1 = peg$c57;
6475
+ if (input.substr(peg$currPos, 8) === peg$c58) {
6476
+ s1 = peg$c58;
6324
6477
  peg$currPos += 8;
6325
6478
  } else {
6326
6479
  s1 = peg$FAILED;
6327
6480
  if (peg$silentFails === 0) {
6328
- peg$fail(peg$e60);
6481
+ peg$fail(peg$e61);
6329
6482
  }
6330
6483
  }
6331
6484
  if (s1 === peg$FAILED) {
6332
- if (input.substr(peg$currPos, 7) === peg$c58) {
6333
- s1 = peg$c58;
6485
+ if (input.substr(peg$currPos, 7) === peg$c59) {
6486
+ s1 = peg$c59;
6334
6487
  peg$currPos += 7;
6335
6488
  } else {
6336
6489
  s1 = peg$FAILED;
6337
6490
  if (peg$silentFails === 0) {
6338
- peg$fail(peg$e61);
6491
+ peg$fail(peg$e62);
6339
6492
  }
6340
6493
  }
6341
6494
  if (s1 === peg$FAILED) {
6342
- if (input.substr(peg$currPos, 7) === peg$c59) {
6343
- s1 = peg$c59;
6495
+ if (input.substr(peg$currPos, 7) === peg$c60) {
6496
+ s1 = peg$c60;
6344
6497
  peg$currPos += 7;
6345
6498
  } else {
6346
6499
  s1 = peg$FAILED;
6347
6500
  if (peg$silentFails === 0) {
6348
- peg$fail(peg$e62);
6501
+ peg$fail(peg$e63);
6349
6502
  }
6350
6503
  }
6351
6504
  if (s1 === peg$FAILED) {
6352
- if (input.substr(peg$currPos, 7) === peg$c60) {
6353
- s1 = peg$c60;
6505
+ if (input.substr(peg$currPos, 7) === peg$c61) {
6506
+ s1 = peg$c61;
6354
6507
  peg$currPos += 7;
6355
6508
  } else {
6356
6509
  s1 = peg$FAILED;
6357
6510
  if (peg$silentFails === 0) {
6358
- peg$fail(peg$e63);
6511
+ peg$fail(peg$e64);
6359
6512
  }
6360
6513
  }
6361
6514
  if (s1 === peg$FAILED) {
6362
- if (input.substr(peg$currPos, 8) === peg$c61) {
6363
- s1 = peg$c61;
6515
+ if (input.substr(peg$currPos, 8) === peg$c62) {
6516
+ s1 = peg$c62;
6364
6517
  peg$currPos += 8;
6365
6518
  } else {
6366
6519
  s1 = peg$FAILED;
6367
6520
  if (peg$silentFails === 0) {
6368
- peg$fail(peg$e64);
6521
+ peg$fail(peg$e65);
6369
6522
  }
6370
6523
  }
6371
6524
  if (s1 === peg$FAILED) {
6372
- if (input.substr(peg$currPos, 7) === peg$c62) {
6373
- s1 = peg$c62;
6525
+ if (input.substr(peg$currPos, 7) === peg$c63) {
6526
+ s1 = peg$c63;
6374
6527
  peg$currPos += 7;
6375
6528
  } else {
6376
6529
  s1 = peg$FAILED;
6377
6530
  if (peg$silentFails === 0) {
6378
- peg$fail(peg$e65);
6531
+ peg$fail(peg$e66);
6379
6532
  }
6380
6533
  }
6381
6534
  if (s1 === peg$FAILED) {
6382
- if (input.substr(peg$currPos, 3) === peg$c63) {
6383
- s1 = peg$c63;
6535
+ if (input.substr(peg$currPos, 3) === peg$c64) {
6536
+ s1 = peg$c64;
6384
6537
  peg$currPos += 3;
6385
6538
  } else {
6386
6539
  s1 = peg$FAILED;
6387
6540
  if (peg$silentFails === 0) {
6388
- peg$fail(peg$e66);
6541
+ peg$fail(peg$e67);
6389
6542
  }
6390
6543
  }
6391
6544
  if (s1 === peg$FAILED) {
6392
- if (input.substr(peg$currPos, 4) === peg$c65) {
6393
- s1 = peg$c65;
6545
+ if (input.substr(peg$currPos, 4) === peg$c66) {
6546
+ s1 = peg$c66;
6394
6547
  peg$currPos += 4;
6395
6548
  } else {
6396
6549
  s1 = peg$FAILED;
6397
6550
  if (peg$silentFails === 0) {
6398
- peg$fail(peg$e68);
6551
+ peg$fail(peg$e69);
6399
6552
  }
6400
6553
  }
6401
6554
  if (s1 === peg$FAILED) {
6402
- if (input.substr(peg$currPos, 3) === peg$c66) {
6403
- s1 = peg$c66;
6555
+ if (input.substr(peg$currPos, 3) === peg$c67) {
6556
+ s1 = peg$c67;
6404
6557
  peg$currPos += 3;
6405
6558
  } else {
6406
6559
  s1 = peg$FAILED;
6407
6560
  if (peg$silentFails === 0) {
6408
- peg$fail(peg$e69);
6561
+ peg$fail(peg$e70);
6409
6562
  }
6410
6563
  }
6411
6564
  if (s1 === peg$FAILED) {
6412
- if (input.substr(peg$currPos, 10) === peg$c67) {
6413
- s1 = peg$c67;
6565
+ if (input.substr(peg$currPos, 10) === peg$c68) {
6566
+ s1 = peg$c68;
6414
6567
  peg$currPos += 10;
6415
6568
  } else {
6416
6569
  s1 = peg$FAILED;
6417
6570
  if (peg$silentFails === 0) {
6418
- peg$fail(peg$e70);
6571
+ peg$fail(peg$e71);
6419
6572
  }
6420
6573
  }
6421
6574
  if (s1 === peg$FAILED) {
6422
- if (input.substr(peg$currPos, 5) === peg$c64) {
6423
- s1 = peg$c64;
6575
+ if (input.substr(peg$currPos, 5) === peg$c65) {
6576
+ s1 = peg$c65;
6424
6577
  peg$currPos += 5;
6425
6578
  } else {
6426
6579
  s1 = peg$FAILED;
6427
6580
  if (peg$silentFails === 0) {
6428
- peg$fail(peg$e67);
6581
+ peg$fail(peg$e68);
6429
6582
  }
6430
6583
  }
6431
6584
  if (s1 === peg$FAILED) {
6432
- if (input.substr(peg$currPos, 6) === peg$c68) {
6433
- s1 = peg$c68;
6585
+ if (input.substr(peg$currPos, 6) === peg$c69) {
6586
+ s1 = peg$c69;
6434
6587
  peg$currPos += 6;
6435
6588
  } else {
6436
6589
  s1 = peg$FAILED;
6437
6590
  if (peg$silentFails === 0) {
6438
- peg$fail(peg$e71);
6591
+ peg$fail(peg$e72);
6439
6592
  }
6440
6593
  }
6441
6594
  if (s1 === peg$FAILED) {
6442
- if (input.substr(peg$currPos, 11) === peg$c69) {
6443
- s1 = peg$c69;
6595
+ if (input.substr(peg$currPos, 11) === peg$c70) {
6596
+ s1 = peg$c70;
6444
6597
  peg$currPos += 11;
6445
6598
  } else {
6446
6599
  s1 = peg$FAILED;
6447
6600
  if (peg$silentFails === 0) {
6448
- peg$fail(peg$e72);
6601
+ peg$fail(peg$e73);
6449
6602
  }
6450
6603
  }
6451
6604
  if (s1 === peg$FAILED) {
6452
- if (input.substr(peg$currPos, 6) === peg$c3) {
6453
- s1 = peg$c3;
6605
+ if (input.substr(peg$currPos, 6) === peg$c20) {
6606
+ s1 = peg$c20;
6454
6607
  peg$currPos += 6;
6455
6608
  } else {
6456
6609
  s1 = peg$FAILED;
6457
6610
  if (peg$silentFails === 0) {
6458
- peg$fail(peg$e3);
6611
+ peg$fail(peg$e23);
6459
6612
  }
6460
6613
  }
6461
6614
  if (s1 === peg$FAILED) {
6462
- if (input.substr(peg$currPos, 9) === peg$c4) {
6463
- s1 = peg$c4;
6464
- peg$currPos += 9;
6615
+ if (input.substr(peg$currPos, 6) === peg$c3) {
6616
+ s1 = peg$c3;
6617
+ peg$currPos += 6;
6465
6618
  } else {
6466
6619
  s1 = peg$FAILED;
6467
6620
  if (peg$silentFails === 0) {
6468
- peg$fail(peg$e4);
6621
+ peg$fail(peg$e3);
6469
6622
  }
6470
6623
  }
6471
6624
  if (s1 === peg$FAILED) {
6472
- if (input.substr(peg$currPos, 3) === peg$c12) {
6473
- s1 = peg$c12;
6474
- peg$currPos += 3;
6625
+ if (input.substr(peg$currPos, 9) === peg$c4) {
6626
+ s1 = peg$c4;
6627
+ peg$currPos += 9;
6475
6628
  } else {
6476
6629
  s1 = peg$FAILED;
6477
6630
  if (peg$silentFails === 0) {
6478
- peg$fail(peg$e12);
6631
+ peg$fail(peg$e4);
6479
6632
  }
6480
6633
  }
6481
6634
  if (s1 === peg$FAILED) {
6482
- if (input.substr(peg$currPos, 4) === peg$c15) {
6483
- s1 = peg$c15;
6484
- peg$currPos += 4;
6635
+ if (input.substr(peg$currPos, 3) === peg$c12) {
6636
+ s1 = peg$c12;
6637
+ peg$currPos += 3;
6485
6638
  } else {
6486
6639
  s1 = peg$FAILED;
6487
6640
  if (peg$silentFails === 0) {
6488
- peg$fail(peg$e15);
6641
+ peg$fail(peg$e12);
6489
6642
  }
6490
6643
  }
6491
6644
  if (s1 === peg$FAILED) {
6492
- if (input.substr(peg$currPos, 4) === peg$c16) {
6493
- s1 = peg$c16;
6645
+ if (input.substr(peg$currPos, 4) === peg$c15) {
6646
+ s1 = peg$c15;
6494
6647
  peg$currPos += 4;
6495
6648
  } else {
6496
6649
  s1 = peg$FAILED;
6497
6650
  if (peg$silentFails === 0) {
6498
- peg$fail(peg$e16);
6651
+ peg$fail(peg$e15);
6652
+ }
6653
+ }
6654
+ if (s1 === peg$FAILED) {
6655
+ if (input.substr(peg$currPos, 4) === peg$c16) {
6656
+ s1 = peg$c16;
6657
+ peg$currPos += 4;
6658
+ } else {
6659
+ s1 = peg$FAILED;
6660
+ if (peg$silentFails === 0) {
6661
+ peg$fail(peg$e16);
6662
+ }
6499
6663
  }
6500
6664
  }
6501
6665
  }
@@ -6580,7 +6744,7 @@ function peg$parse(input, options) {
6580
6744
  } else {
6581
6745
  s0 = peg$FAILED;
6582
6746
  if (peg$silentFails === 0) {
6583
- peg$fail(peg$e77);
6747
+ peg$fail(peg$e78);
6584
6748
  }
6585
6749
  }
6586
6750
  return s0;
@@ -6613,12 +6777,12 @@ function peg$parse(input, options) {
6613
6777
  peg$silentFails++;
6614
6778
  s0 = peg$currPos;
6615
6779
  if (input.charCodeAt(peg$currPos) === 34) {
6616
- s1 = peg$c71;
6780
+ s1 = peg$c72;
6617
6781
  peg$currPos++;
6618
6782
  } else {
6619
6783
  s1 = peg$FAILED;
6620
6784
  if (peg$silentFails === 0) {
6621
- peg$fail(peg$e79);
6785
+ peg$fail(peg$e80);
6622
6786
  }
6623
6787
  }
6624
6788
  if (s1 !== peg$FAILED) {
@@ -6629,17 +6793,17 @@ function peg$parse(input, options) {
6629
6793
  s3 = peg$parseDoubleStringChar();
6630
6794
  }
6631
6795
  if (input.charCodeAt(peg$currPos) === 34) {
6632
- s3 = peg$c71;
6796
+ s3 = peg$c72;
6633
6797
  peg$currPos++;
6634
6798
  } else {
6635
6799
  s3 = peg$FAILED;
6636
6800
  if (peg$silentFails === 0) {
6637
- peg$fail(peg$e79);
6801
+ peg$fail(peg$e80);
6638
6802
  }
6639
6803
  }
6640
6804
  if (s3 !== peg$FAILED) {
6641
6805
  peg$savedPos = s0;
6642
- s0 = peg$f97(s2);
6806
+ s0 = peg$f98(s2);
6643
6807
  } else {
6644
6808
  peg$currPos = s0;
6645
6809
  s0 = peg$FAILED;
@@ -6651,12 +6815,12 @@ function peg$parse(input, options) {
6651
6815
  if (s0 === peg$FAILED) {
6652
6816
  s0 = peg$currPos;
6653
6817
  if (input.charCodeAt(peg$currPos) === 39) {
6654
- s1 = peg$c72;
6818
+ s1 = peg$c73;
6655
6819
  peg$currPos++;
6656
6820
  } else {
6657
6821
  s1 = peg$FAILED;
6658
6822
  if (peg$silentFails === 0) {
6659
- peg$fail(peg$e80);
6823
+ peg$fail(peg$e81);
6660
6824
  }
6661
6825
  }
6662
6826
  if (s1 !== peg$FAILED) {
@@ -6667,17 +6831,17 @@ function peg$parse(input, options) {
6667
6831
  s3 = peg$parseSingleStringChar();
6668
6832
  }
6669
6833
  if (input.charCodeAt(peg$currPos) === 39) {
6670
- s3 = peg$c72;
6834
+ s3 = peg$c73;
6671
6835
  peg$currPos++;
6672
6836
  } else {
6673
6837
  s3 = peg$FAILED;
6674
6838
  if (peg$silentFails === 0) {
6675
- peg$fail(peg$e80);
6839
+ peg$fail(peg$e81);
6676
6840
  }
6677
6841
  }
6678
6842
  if (s3 !== peg$FAILED) {
6679
6843
  peg$savedPos = s0;
6680
- s0 = peg$f98(s2);
6844
+ s0 = peg$f99(s2);
6681
6845
  } else {
6682
6846
  peg$currPos = s0;
6683
6847
  s0 = peg$FAILED;
@@ -6691,7 +6855,7 @@ function peg$parse(input, options) {
6691
6855
  if (s0 === peg$FAILED) {
6692
6856
  s1 = peg$FAILED;
6693
6857
  if (peg$silentFails === 0) {
6694
- peg$fail(peg$e78);
6858
+ peg$fail(peg$e79);
6695
6859
  }
6696
6860
  }
6697
6861
  return s0;
@@ -6702,12 +6866,12 @@ function peg$parse(input, options) {
6702
6866
  s1 = peg$currPos;
6703
6867
  peg$silentFails++;
6704
6868
  if (input.charCodeAt(peg$currPos) === 34) {
6705
- s2 = peg$c71;
6869
+ s2 = peg$c72;
6706
6870
  peg$currPos++;
6707
6871
  } else {
6708
6872
  s2 = peg$FAILED;
6709
6873
  if (peg$silentFails === 0) {
6710
- peg$fail(peg$e79);
6874
+ peg$fail(peg$e80);
6711
6875
  }
6712
6876
  }
6713
6877
  peg$silentFails--;
@@ -6721,12 +6885,12 @@ function peg$parse(input, options) {
6721
6885
  s2 = peg$currPos;
6722
6886
  peg$silentFails++;
6723
6887
  if (input.charCodeAt(peg$currPos) === 92) {
6724
- s3 = peg$c73;
6888
+ s3 = peg$c74;
6725
6889
  peg$currPos++;
6726
6890
  } else {
6727
6891
  s3 = peg$FAILED;
6728
6892
  if (peg$silentFails === 0) {
6729
- peg$fail(peg$e81);
6893
+ peg$fail(peg$e82);
6730
6894
  }
6731
6895
  }
6732
6896
  peg$silentFails--;
@@ -6748,7 +6912,7 @@ function peg$parse(input, options) {
6748
6912
  }
6749
6913
  if (s3 !== peg$FAILED) {
6750
6914
  peg$savedPos = s0;
6751
- s0 = peg$f99(s3);
6915
+ s0 = peg$f100(s3);
6752
6916
  } else {
6753
6917
  peg$currPos = s0;
6754
6918
  s0 = peg$FAILED;
@@ -6764,19 +6928,19 @@ function peg$parse(input, options) {
6764
6928
  if (s0 === peg$FAILED) {
6765
6929
  s0 = peg$currPos;
6766
6930
  if (input.charCodeAt(peg$currPos) === 92) {
6767
- s1 = peg$c73;
6931
+ s1 = peg$c74;
6768
6932
  peg$currPos++;
6769
6933
  } else {
6770
6934
  s1 = peg$FAILED;
6771
6935
  if (peg$silentFails === 0) {
6772
- peg$fail(peg$e81);
6936
+ peg$fail(peg$e82);
6773
6937
  }
6774
6938
  }
6775
6939
  if (s1 !== peg$FAILED) {
6776
6940
  s2 = peg$parseEscapeSequence();
6777
6941
  if (s2 !== peg$FAILED) {
6778
6942
  peg$savedPos = s0;
6779
- s0 = peg$f100(s2);
6943
+ s0 = peg$f101(s2);
6780
6944
  } else {
6781
6945
  peg$currPos = s0;
6782
6946
  s0 = peg$FAILED;
@@ -6794,12 +6958,12 @@ function peg$parse(input, options) {
6794
6958
  s1 = peg$currPos;
6795
6959
  peg$silentFails++;
6796
6960
  if (input.charCodeAt(peg$currPos) === 39) {
6797
- s2 = peg$c72;
6961
+ s2 = peg$c73;
6798
6962
  peg$currPos++;
6799
6963
  } else {
6800
6964
  s2 = peg$FAILED;
6801
6965
  if (peg$silentFails === 0) {
6802
- peg$fail(peg$e80);
6966
+ peg$fail(peg$e81);
6803
6967
  }
6804
6968
  }
6805
6969
  peg$silentFails--;
@@ -6813,12 +6977,12 @@ function peg$parse(input, options) {
6813
6977
  s2 = peg$currPos;
6814
6978
  peg$silentFails++;
6815
6979
  if (input.charCodeAt(peg$currPos) === 92) {
6816
- s3 = peg$c73;
6980
+ s3 = peg$c74;
6817
6981
  peg$currPos++;
6818
6982
  } else {
6819
6983
  s3 = peg$FAILED;
6820
6984
  if (peg$silentFails === 0) {
6821
- peg$fail(peg$e81);
6985
+ peg$fail(peg$e82);
6822
6986
  }
6823
6987
  }
6824
6988
  peg$silentFails--;
@@ -6840,7 +7004,7 @@ function peg$parse(input, options) {
6840
7004
  }
6841
7005
  if (s3 !== peg$FAILED) {
6842
7006
  peg$savedPos = s0;
6843
- s0 = peg$f101(s3);
7007
+ s0 = peg$f102(s3);
6844
7008
  } else {
6845
7009
  peg$currPos = s0;
6846
7010
  s0 = peg$FAILED;
@@ -6856,19 +7020,19 @@ function peg$parse(input, options) {
6856
7020
  if (s0 === peg$FAILED) {
6857
7021
  s0 = peg$currPos;
6858
7022
  if (input.charCodeAt(peg$currPos) === 92) {
6859
- s1 = peg$c73;
7023
+ s1 = peg$c74;
6860
7024
  peg$currPos++;
6861
7025
  } else {
6862
7026
  s1 = peg$FAILED;
6863
7027
  if (peg$silentFails === 0) {
6864
- peg$fail(peg$e81);
7028
+ peg$fail(peg$e82);
6865
7029
  }
6866
7030
  }
6867
7031
  if (s1 !== peg$FAILED) {
6868
7032
  s2 = peg$parseEscapeSequence();
6869
7033
  if (s2 !== peg$FAILED) {
6870
7034
  peg$savedPos = s0;
6871
- s0 = peg$f102(s2);
7035
+ s0 = peg$f103(s2);
6872
7036
  } else {
6873
7037
  peg$currPos = s0;
6874
7038
  s0 = peg$FAILED;
@@ -6884,97 +7048,97 @@ function peg$parse(input, options) {
6884
7048
  let s0, s1;
6885
7049
  s0 = peg$currPos;
6886
7050
  if (input.charCodeAt(peg$currPos) === 110) {
6887
- s1 = peg$c74;
7051
+ s1 = peg$c75;
6888
7052
  peg$currPos++;
6889
7053
  } else {
6890
7054
  s1 = peg$FAILED;
6891
7055
  if (peg$silentFails === 0) {
6892
- peg$fail(peg$e82);
7056
+ peg$fail(peg$e83);
6893
7057
  }
6894
7058
  }
6895
7059
  if (s1 !== peg$FAILED) {
6896
7060
  peg$savedPos = s0;
6897
- s1 = peg$f103();
7061
+ s1 = peg$f104();
6898
7062
  }
6899
7063
  s0 = s1;
6900
7064
  if (s0 === peg$FAILED) {
6901
7065
  s0 = peg$currPos;
6902
7066
  if (input.charCodeAt(peg$currPos) === 114) {
6903
- s1 = peg$c75;
7067
+ s1 = peg$c76;
6904
7068
  peg$currPos++;
6905
7069
  } else {
6906
7070
  s1 = peg$FAILED;
6907
7071
  if (peg$silentFails === 0) {
6908
- peg$fail(peg$e83);
7072
+ peg$fail(peg$e84);
6909
7073
  }
6910
7074
  }
6911
7075
  if (s1 !== peg$FAILED) {
6912
7076
  peg$savedPos = s0;
6913
- s1 = peg$f104();
7077
+ s1 = peg$f105();
6914
7078
  }
6915
7079
  s0 = s1;
6916
7080
  if (s0 === peg$FAILED) {
6917
7081
  s0 = peg$currPos;
6918
7082
  if (input.charCodeAt(peg$currPos) === 116) {
6919
- s1 = peg$c76;
7083
+ s1 = peg$c77;
6920
7084
  peg$currPos++;
6921
7085
  } else {
6922
7086
  s1 = peg$FAILED;
6923
7087
  if (peg$silentFails === 0) {
6924
- peg$fail(peg$e84);
7088
+ peg$fail(peg$e85);
6925
7089
  }
6926
7090
  }
6927
7091
  if (s1 !== peg$FAILED) {
6928
7092
  peg$savedPos = s0;
6929
- s1 = peg$f105();
7093
+ s1 = peg$f106();
6930
7094
  }
6931
7095
  s0 = s1;
6932
7096
  if (s0 === peg$FAILED) {
6933
7097
  s0 = peg$currPos;
6934
7098
  if (input.charCodeAt(peg$currPos) === 92) {
6935
- s1 = peg$c73;
7099
+ s1 = peg$c74;
6936
7100
  peg$currPos++;
6937
7101
  } else {
6938
7102
  s1 = peg$FAILED;
6939
7103
  if (peg$silentFails === 0) {
6940
- peg$fail(peg$e81);
7104
+ peg$fail(peg$e82);
6941
7105
  }
6942
7106
  }
6943
7107
  if (s1 !== peg$FAILED) {
6944
7108
  peg$savedPos = s0;
6945
- s1 = peg$f106();
7109
+ s1 = peg$f107();
6946
7110
  }
6947
7111
  s0 = s1;
6948
7112
  if (s0 === peg$FAILED) {
6949
7113
  s0 = peg$currPos;
6950
7114
  if (input.charCodeAt(peg$currPos) === 34) {
6951
- s1 = peg$c71;
7115
+ s1 = peg$c72;
6952
7116
  peg$currPos++;
6953
7117
  } else {
6954
7118
  s1 = peg$FAILED;
6955
7119
  if (peg$silentFails === 0) {
6956
- peg$fail(peg$e79);
7120
+ peg$fail(peg$e80);
6957
7121
  }
6958
7122
  }
6959
7123
  if (s1 !== peg$FAILED) {
6960
7124
  peg$savedPos = s0;
6961
- s1 = peg$f107();
7125
+ s1 = peg$f108();
6962
7126
  }
6963
7127
  s0 = s1;
6964
7128
  if (s0 === peg$FAILED) {
6965
7129
  s0 = peg$currPos;
6966
7130
  if (input.charCodeAt(peg$currPos) === 39) {
6967
- s1 = peg$c72;
7131
+ s1 = peg$c73;
6968
7132
  peg$currPos++;
6969
7133
  } else {
6970
7134
  s1 = peg$FAILED;
6971
7135
  if (peg$silentFails === 0) {
6972
- peg$fail(peg$e80);
7136
+ peg$fail(peg$e81);
6973
7137
  }
6974
7138
  }
6975
7139
  if (s1 !== peg$FAILED) {
6976
7140
  peg$savedPos = s0;
6977
- s1 = peg$f108();
7141
+ s1 = peg$f109();
6978
7142
  }
6979
7143
  s0 = s1;
6980
7144
  }
@@ -6989,12 +7153,12 @@ function peg$parse(input, options) {
6989
7153
  peg$silentFails++;
6990
7154
  s0 = peg$currPos;
6991
7155
  if (input.charCodeAt(peg$currPos) === 45) {
6992
- s1 = peg$c77;
7156
+ s1 = peg$c78;
6993
7157
  peg$currPos++;
6994
7158
  } else {
6995
7159
  s1 = peg$FAILED;
6996
7160
  if (peg$silentFails === 0) {
6997
- peg$fail(peg$e86);
7161
+ peg$fail(peg$e87);
6998
7162
  }
6999
7163
  }
7000
7164
  if (s1 === peg$FAILED) {
@@ -7007,7 +7171,7 @@ function peg$parse(input, options) {
7007
7171
  } else {
7008
7172
  s3 = peg$FAILED;
7009
7173
  if (peg$silentFails === 0) {
7010
- peg$fail(peg$e74);
7174
+ peg$fail(peg$e75);
7011
7175
  }
7012
7176
  }
7013
7177
  if (s3 !== peg$FAILED) {
@@ -7019,7 +7183,7 @@ function peg$parse(input, options) {
7019
7183
  } else {
7020
7184
  s3 = peg$FAILED;
7021
7185
  if (peg$silentFails === 0) {
7022
- peg$fail(peg$e74);
7186
+ peg$fail(peg$e75);
7023
7187
  }
7024
7188
  }
7025
7189
  }
@@ -7029,12 +7193,12 @@ function peg$parse(input, options) {
7029
7193
  if (s2 !== peg$FAILED) {
7030
7194
  s3 = peg$currPos;
7031
7195
  if (input.charCodeAt(peg$currPos) === 46) {
7032
- s4 = peg$c78;
7196
+ s4 = peg$c79;
7033
7197
  peg$currPos++;
7034
7198
  } else {
7035
7199
  s4 = peg$FAILED;
7036
7200
  if (peg$silentFails === 0) {
7037
- peg$fail(peg$e87);
7201
+ peg$fail(peg$e88);
7038
7202
  }
7039
7203
  }
7040
7204
  if (s4 !== peg$FAILED) {
@@ -7045,7 +7209,7 @@ function peg$parse(input, options) {
7045
7209
  } else {
7046
7210
  s6 = peg$FAILED;
7047
7211
  if (peg$silentFails === 0) {
7048
- peg$fail(peg$e74);
7212
+ peg$fail(peg$e75);
7049
7213
  }
7050
7214
  }
7051
7215
  if (s6 !== peg$FAILED) {
@@ -7057,7 +7221,7 @@ function peg$parse(input, options) {
7057
7221
  } else {
7058
7222
  s6 = peg$FAILED;
7059
7223
  if (peg$silentFails === 0) {
7060
- peg$fail(peg$e74);
7224
+ peg$fail(peg$e75);
7061
7225
  }
7062
7226
  }
7063
7227
  }
@@ -7079,7 +7243,7 @@ function peg$parse(input, options) {
7079
7243
  s3 = null;
7080
7244
  }
7081
7245
  peg$savedPos = s0;
7082
- s0 = peg$f109(s1, s2, s3);
7246
+ s0 = peg$f110(s1, s2, s3);
7083
7247
  } else {
7084
7248
  peg$currPos = s0;
7085
7249
  s0 = peg$FAILED;
@@ -7088,7 +7252,7 @@ function peg$parse(input, options) {
7088
7252
  if (s0 === peg$FAILED) {
7089
7253
  s1 = peg$FAILED;
7090
7254
  if (peg$silentFails === 0) {
7091
- peg$fail(peg$e85);
7255
+ peg$fail(peg$e86);
7092
7256
  }
7093
7257
  }
7094
7258
  return s0;
@@ -7098,12 +7262,12 @@ function peg$parse(input, options) {
7098
7262
  peg$silentFails++;
7099
7263
  s0 = peg$currPos;
7100
7264
  if (input.charCodeAt(peg$currPos) === 45) {
7101
- s1 = peg$c77;
7265
+ s1 = peg$c78;
7102
7266
  peg$currPos++;
7103
7267
  } else {
7104
7268
  s1 = peg$FAILED;
7105
7269
  if (peg$silentFails === 0) {
7106
- peg$fail(peg$e86);
7270
+ peg$fail(peg$e87);
7107
7271
  }
7108
7272
  }
7109
7273
  if (s1 === peg$FAILED) {
@@ -7116,7 +7280,7 @@ function peg$parse(input, options) {
7116
7280
  } else {
7117
7281
  s3 = peg$FAILED;
7118
7282
  if (peg$silentFails === 0) {
7119
- peg$fail(peg$e74);
7283
+ peg$fail(peg$e75);
7120
7284
  }
7121
7285
  }
7122
7286
  if (s3 !== peg$FAILED) {
@@ -7128,7 +7292,7 @@ function peg$parse(input, options) {
7128
7292
  } else {
7129
7293
  s3 = peg$FAILED;
7130
7294
  if (peg$silentFails === 0) {
7131
- peg$fail(peg$e74);
7295
+ peg$fail(peg$e75);
7132
7296
  }
7133
7297
  }
7134
7298
  }
@@ -7138,12 +7302,12 @@ function peg$parse(input, options) {
7138
7302
  if (s2 !== peg$FAILED) {
7139
7303
  s3 = peg$currPos;
7140
7304
  if (input.charCodeAt(peg$currPos) === 46) {
7141
- s4 = peg$c78;
7305
+ s4 = peg$c79;
7142
7306
  peg$currPos++;
7143
7307
  } else {
7144
7308
  s4 = peg$FAILED;
7145
7309
  if (peg$silentFails === 0) {
7146
- peg$fail(peg$e87);
7310
+ peg$fail(peg$e88);
7147
7311
  }
7148
7312
  }
7149
7313
  if (s4 !== peg$FAILED) {
@@ -7154,7 +7318,7 @@ function peg$parse(input, options) {
7154
7318
  } else {
7155
7319
  s6 = peg$FAILED;
7156
7320
  if (peg$silentFails === 0) {
7157
- peg$fail(peg$e74);
7321
+ peg$fail(peg$e75);
7158
7322
  }
7159
7323
  }
7160
7324
  if (s6 !== peg$FAILED) {
@@ -7166,7 +7330,7 @@ function peg$parse(input, options) {
7166
7330
  } else {
7167
7331
  s6 = peg$FAILED;
7168
7332
  if (peg$silentFails === 0) {
7169
- peg$fail(peg$e74);
7333
+ peg$fail(peg$e75);
7170
7334
  }
7171
7335
  }
7172
7336
  }
@@ -7187,63 +7351,63 @@ function peg$parse(input, options) {
7187
7351
  if (s3 === peg$FAILED) {
7188
7352
  s3 = null;
7189
7353
  }
7190
- if (input.substr(peg$currPos, 2) === peg$c79) {
7191
- s4 = peg$c79;
7354
+ if (input.substr(peg$currPos, 2) === peg$c80) {
7355
+ s4 = peg$c80;
7192
7356
  peg$currPos += 2;
7193
7357
  } else {
7194
7358
  s4 = peg$FAILED;
7195
7359
  if (peg$silentFails === 0) {
7196
- peg$fail(peg$e89);
7360
+ peg$fail(peg$e90);
7197
7361
  }
7198
7362
  }
7199
7363
  if (s4 === peg$FAILED) {
7200
7364
  if (input.charCodeAt(peg$currPos) === 37) {
7201
- s4 = peg$c80;
7365
+ s4 = peg$c81;
7202
7366
  peg$currPos++;
7203
7367
  } else {
7204
7368
  s4 = peg$FAILED;
7205
7369
  if (peg$silentFails === 0) {
7206
- peg$fail(peg$e90);
7370
+ peg$fail(peg$e91);
7207
7371
  }
7208
7372
  }
7209
7373
  if (s4 === peg$FAILED) {
7210
- if (input.substr(peg$currPos, 2) === peg$c81) {
7211
- s4 = peg$c81;
7374
+ if (input.substr(peg$currPos, 2) === peg$c82) {
7375
+ s4 = peg$c82;
7212
7376
  peg$currPos += 2;
7213
7377
  } else {
7214
7378
  s4 = peg$FAILED;
7215
7379
  if (peg$silentFails === 0) {
7216
- peg$fail(peg$e91);
7380
+ peg$fail(peg$e92);
7217
7381
  }
7218
7382
  }
7219
7383
  if (s4 === peg$FAILED) {
7220
- if (input.substr(peg$currPos, 3) === peg$c82) {
7221
- s4 = peg$c82;
7384
+ if (input.substr(peg$currPos, 3) === peg$c83) {
7385
+ s4 = peg$c83;
7222
7386
  peg$currPos += 3;
7223
7387
  } else {
7224
7388
  s4 = peg$FAILED;
7225
7389
  if (peg$silentFails === 0) {
7226
- peg$fail(peg$e92);
7390
+ peg$fail(peg$e93);
7227
7391
  }
7228
7392
  }
7229
7393
  if (s4 === peg$FAILED) {
7230
- if (input.substr(peg$currPos, 2) === peg$c83) {
7231
- s4 = peg$c83;
7394
+ if (input.substr(peg$currPos, 2) === peg$c84) {
7395
+ s4 = peg$c84;
7232
7396
  peg$currPos += 2;
7233
7397
  } else {
7234
7398
  s4 = peg$FAILED;
7235
7399
  if (peg$silentFails === 0) {
7236
- peg$fail(peg$e93);
7400
+ peg$fail(peg$e94);
7237
7401
  }
7238
7402
  }
7239
7403
  if (s4 === peg$FAILED) {
7240
- if (input.substr(peg$currPos, 2) === peg$c84) {
7241
- s4 = peg$c84;
7404
+ if (input.substr(peg$currPos, 2) === peg$c85) {
7405
+ s4 = peg$c85;
7242
7406
  peg$currPos += 2;
7243
7407
  } else {
7244
7408
  s4 = peg$FAILED;
7245
7409
  if (peg$silentFails === 0) {
7246
- peg$fail(peg$e94);
7410
+ peg$fail(peg$e95);
7247
7411
  }
7248
7412
  }
7249
7413
  }
@@ -7253,7 +7417,7 @@ function peg$parse(input, options) {
7253
7417
  }
7254
7418
  if (s4 !== peg$FAILED) {
7255
7419
  peg$savedPos = s0;
7256
- s0 = peg$f110(s1, s2, s3, s4);
7420
+ s0 = peg$f111(s1, s2, s3, s4);
7257
7421
  } else {
7258
7422
  peg$currPos = s0;
7259
7423
  s0 = peg$FAILED;
@@ -7266,7 +7430,7 @@ function peg$parse(input, options) {
7266
7430
  if (s0 === peg$FAILED) {
7267
7431
  s1 = peg$FAILED;
7268
7432
  if (peg$silentFails === 0) {
7269
- peg$fail(peg$e88);
7433
+ peg$fail(peg$e89);
7270
7434
  }
7271
7435
  }
7272
7436
  return s0;
@@ -7275,34 +7439,34 @@ function peg$parse(input, options) {
7275
7439
  let s0, s1;
7276
7440
  peg$silentFails++;
7277
7441
  s0 = peg$currPos;
7278
- if (input.substr(peg$currPos, 4) === peg$c85) {
7279
- s1 = peg$c85;
7442
+ if (input.substr(peg$currPos, 4) === peg$c86) {
7443
+ s1 = peg$c86;
7280
7444
  peg$currPos += 4;
7281
7445
  } else {
7282
7446
  s1 = peg$FAILED;
7283
7447
  if (peg$silentFails === 0) {
7284
- peg$fail(peg$e96);
7448
+ peg$fail(peg$e97);
7285
7449
  }
7286
7450
  }
7287
7451
  if (s1 !== peg$FAILED) {
7288
7452
  peg$savedPos = s0;
7289
- s1 = peg$f111();
7453
+ s1 = peg$f112();
7290
7454
  }
7291
7455
  s0 = s1;
7292
7456
  if (s0 === peg$FAILED) {
7293
7457
  s0 = peg$currPos;
7294
- if (input.substr(peg$currPos, 5) === peg$c86) {
7295
- s1 = peg$c86;
7458
+ if (input.substr(peg$currPos, 5) === peg$c87) {
7459
+ s1 = peg$c87;
7296
7460
  peg$currPos += 5;
7297
7461
  } else {
7298
7462
  s1 = peg$FAILED;
7299
7463
  if (peg$silentFails === 0) {
7300
- peg$fail(peg$e97);
7464
+ peg$fail(peg$e98);
7301
7465
  }
7302
7466
  }
7303
7467
  if (s1 !== peg$FAILED) {
7304
7468
  peg$savedPos = s0;
7305
- s1 = peg$f112();
7469
+ s1 = peg$f113();
7306
7470
  }
7307
7471
  s0 = s1;
7308
7472
  }
@@ -7310,7 +7474,7 @@ function peg$parse(input, options) {
7310
7474
  if (s0 === peg$FAILED) {
7311
7475
  s1 = peg$FAILED;
7312
7476
  if (peg$silentFails === 0) {
7313
- peg$fail(peg$e95);
7477
+ peg$fail(peg$e96);
7314
7478
  }
7315
7479
  }
7316
7480
  return s0;
@@ -7325,7 +7489,7 @@ function peg$parse(input, options) {
7325
7489
  } else {
7326
7490
  s1 = peg$FAILED;
7327
7491
  if (peg$silentFails === 0) {
7328
- peg$fail(peg$e99);
7492
+ peg$fail(peg$e100);
7329
7493
  }
7330
7494
  }
7331
7495
  if (s1 !== peg$FAILED) {
@@ -7336,7 +7500,7 @@ function peg$parse(input, options) {
7336
7500
  } else {
7337
7501
  s3 = peg$FAILED;
7338
7502
  if (peg$silentFails === 0) {
7339
- peg$fail(peg$e77);
7503
+ peg$fail(peg$e78);
7340
7504
  }
7341
7505
  }
7342
7506
  while (s3 !== peg$FAILED) {
@@ -7347,12 +7511,12 @@ function peg$parse(input, options) {
7347
7511
  } else {
7348
7512
  s3 = peg$FAILED;
7349
7513
  if (peg$silentFails === 0) {
7350
- peg$fail(peg$e77);
7514
+ peg$fail(peg$e78);
7351
7515
  }
7352
7516
  }
7353
7517
  }
7354
7518
  peg$savedPos = s0;
7355
- s0 = peg$f113(s1, s2);
7519
+ s0 = peg$f114(s1, s2);
7356
7520
  } else {
7357
7521
  peg$currPos = s0;
7358
7522
  s0 = peg$FAILED;
@@ -7361,7 +7525,7 @@ function peg$parse(input, options) {
7361
7525
  if (s0 === peg$FAILED) {
7362
7526
  s1 = peg$FAILED;
7363
7527
  if (peg$silentFails === 0) {
7364
- peg$fail(peg$e98);
7528
+ peg$fail(peg$e99);
7365
7529
  }
7366
7530
  }
7367
7531
  return s0;
@@ -7370,12 +7534,12 @@ function peg$parse(input, options) {
7370
7534
  let s0, s1, s2, s3, s4, s5;
7371
7535
  s0 = peg$currPos;
7372
7536
  if (input.charCodeAt(peg$currPos) === 91) {
7373
- s1 = peg$c50;
7537
+ s1 = peg$c51;
7374
7538
  peg$currPos++;
7375
7539
  } else {
7376
7540
  s1 = peg$FAILED;
7377
7541
  if (peg$silentFails === 0) {
7378
- peg$fail(peg$e53);
7542
+ peg$fail(peg$e54);
7379
7543
  }
7380
7544
  }
7381
7545
  if (s1 !== peg$FAILED) {
@@ -7386,17 +7550,17 @@ function peg$parse(input, options) {
7386
7550
  }
7387
7551
  s4 = peg$parse_();
7388
7552
  if (input.charCodeAt(peg$currPos) === 93) {
7389
- s5 = peg$c51;
7553
+ s5 = peg$c52;
7390
7554
  peg$currPos++;
7391
7555
  } else {
7392
7556
  s5 = peg$FAILED;
7393
7557
  if (peg$silentFails === 0) {
7394
- peg$fail(peg$e54);
7558
+ peg$fail(peg$e55);
7395
7559
  }
7396
7560
  }
7397
7561
  if (s5 !== peg$FAILED) {
7398
7562
  peg$savedPos = s0;
7399
- s0 = peg$f114(s3);
7563
+ s0 = peg$f115(s3);
7400
7564
  } else {
7401
7565
  peg$currPos = s0;
7402
7566
  s0 = peg$FAILED;
@@ -7484,7 +7648,7 @@ function peg$parse(input, options) {
7484
7648
  s3 = null;
7485
7649
  }
7486
7650
  peg$savedPos = s0;
7487
- s0 = peg$f115(s1, s2);
7651
+ s0 = peg$f116(s1, s2);
7488
7652
  } else {
7489
7653
  peg$currPos = s0;
7490
7654
  s0 = peg$FAILED;
@@ -7538,7 +7702,7 @@ function peg$parse(input, options) {
7538
7702
  }
7539
7703
  if (s5 !== peg$FAILED) {
7540
7704
  peg$savedPos = s0;
7541
- s0 = peg$f116(s3);
7705
+ s0 = peg$f117(s3);
7542
7706
  } else {
7543
7707
  peg$currPos = s0;
7544
7708
  s0 = peg$FAILED;
@@ -7605,7 +7769,7 @@ function peg$parse(input, options) {
7605
7769
  }
7606
7770
  }
7607
7771
  peg$savedPos = s0;
7608
- s0 = peg$f117(s1, s2);
7772
+ s0 = peg$f118(s1, s2);
7609
7773
  } else {
7610
7774
  peg$currPos = s0;
7611
7775
  s0 = peg$FAILED;
@@ -7632,7 +7796,7 @@ function peg$parse(input, options) {
7632
7796
  s5 = peg$parseAttributeValue();
7633
7797
  if (s5 !== peg$FAILED) {
7634
7798
  peg$savedPos = s0;
7635
- s0 = peg$f118(s1, s5);
7799
+ s0 = peg$f119(s1, s5);
7636
7800
  } else {
7637
7801
  peg$currPos = s0;
7638
7802
  s0 = peg$FAILED;
@@ -7650,7 +7814,7 @@ function peg$parse(input, options) {
7650
7814
  s1 = peg$parseIdentifier();
7651
7815
  if (s1 !== peg$FAILED) {
7652
7816
  peg$savedPos = s0;
7653
- s1 = peg$f119(s1);
7817
+ s1 = peg$f120(s1);
7654
7818
  }
7655
7819
  s0 = s1;
7656
7820
  }
@@ -7683,7 +7847,7 @@ function peg$parse(input, options) {
7683
7847
  } else {
7684
7848
  s1 = peg$FAILED;
7685
7849
  if (peg$silentFails === 0) {
7686
- peg$fail(peg$e100);
7850
+ peg$fail(peg$e101);
7687
7851
  }
7688
7852
  }
7689
7853
  if (s1 !== peg$FAILED) {
@@ -7695,7 +7859,7 @@ function peg$parse(input, options) {
7695
7859
  } else {
7696
7860
  s1 = peg$FAILED;
7697
7861
  if (peg$silentFails === 0) {
7698
- peg$fail(peg$e100);
7862
+ peg$fail(peg$e101);
7699
7863
  }
7700
7864
  }
7701
7865
  }
@@ -7715,7 +7879,7 @@ function peg$parse(input, options) {
7715
7879
  if (s0 === peg$FAILED) {
7716
7880
  s1 = peg$FAILED;
7717
7881
  if (peg$silentFails === 0) {
7718
- peg$fail(peg$e101);
7882
+ peg$fail(peg$e102);
7719
7883
  }
7720
7884
  }
7721
7885
  return s0;
@@ -7740,7 +7904,7 @@ function peg$parse(input, options) {
7740
7904
  } else {
7741
7905
  s3 = peg$FAILED;
7742
7906
  if (peg$silentFails === 0) {
7743
- peg$fail(peg$e102);
7907
+ peg$fail(peg$e103);
7744
7908
  }
7745
7909
  }
7746
7910
  while (s3 !== peg$FAILED) {
@@ -7751,17 +7915,17 @@ function peg$parse(input, options) {
7751
7915
  } else {
7752
7916
  s3 = peg$FAILED;
7753
7917
  if (peg$silentFails === 0) {
7754
- peg$fail(peg$e102);
7918
+ peg$fail(peg$e103);
7755
7919
  }
7756
7920
  }
7757
7921
  }
7758
7922
  if (input.charCodeAt(peg$currPos) === 10) {
7759
- s3 = peg$c87;
7923
+ s3 = peg$c88;
7760
7924
  peg$currPos++;
7761
7925
  } else {
7762
7926
  s3 = peg$FAILED;
7763
7927
  if (peg$silentFails === 0) {
7764
- peg$fail(peg$e103);
7928
+ peg$fail(peg$e104);
7765
7929
  }
7766
7930
  }
7767
7931
  if (s3 === peg$FAILED) {
@@ -7814,13 +7978,13 @@ function peg$parse(input, options) {
7814
7978
  s3 = peg$currPos;
7815
7979
  s4 = peg$currPos;
7816
7980
  peg$silentFails++;
7817
- if (input.substr(peg$currPos, 2) === peg$c88) {
7818
- s5 = peg$c88;
7981
+ if (input.substr(peg$currPos, 2) === peg$c89) {
7982
+ s5 = peg$c89;
7819
7983
  peg$currPos += 2;
7820
7984
  } else {
7821
7985
  s5 = peg$FAILED;
7822
7986
  if (peg$silentFails === 0) {
7823
- peg$fail(peg$e104);
7987
+ peg$fail(peg$e105);
7824
7988
  }
7825
7989
  }
7826
7990
  peg$silentFails--;
@@ -7856,13 +8020,13 @@ function peg$parse(input, options) {
7856
8020
  s3 = peg$currPos;
7857
8021
  s4 = peg$currPos;
7858
8022
  peg$silentFails++;
7859
- if (input.substr(peg$currPos, 2) === peg$c88) {
7860
- s5 = peg$c88;
8023
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8024
+ s5 = peg$c89;
7861
8025
  peg$currPos += 2;
7862
8026
  } else {
7863
8027
  s5 = peg$FAILED;
7864
8028
  if (peg$silentFails === 0) {
7865
- peg$fail(peg$e104);
8029
+ peg$fail(peg$e105);
7866
8030
  }
7867
8031
  }
7868
8032
  peg$silentFails--;
@@ -7894,13 +8058,13 @@ function peg$parse(input, options) {
7894
8058
  s3 = peg$FAILED;
7895
8059
  }
7896
8060
  }
7897
- if (input.substr(peg$currPos, 2) === peg$c88) {
7898
- s3 = peg$c88;
8061
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8062
+ s3 = peg$c89;
7899
8063
  peg$currPos += 2;
7900
8064
  } else {
7901
8065
  s3 = peg$FAILED;
7902
8066
  if (peg$silentFails === 0) {
7903
- peg$fail(peg$e104);
8067
+ peg$fail(peg$e105);
7904
8068
  }
7905
8069
  }
7906
8070
  if (s3 !== peg$FAILED) {
@@ -8075,6 +8239,7 @@ var GRAMMAR_ELEMENTS = {
8075
8239
  component: "Component",
8076
8240
  use: "ComponentUse",
8077
8241
  slot: "Slot",
8242
+ repeat: "Repeat",
8078
8243
  header: "Header",
8079
8244
  main: "Main",
8080
8245
  footer: "Footer",
@@ -8174,6 +8339,7 @@ var GRAMMAR_CHILD_KEYWORDS = [
8174
8339
  "group",
8175
8340
  "marker",
8176
8341
  "annotations",
8342
+ "repeat",
8177
8343
  "layout",
8178
8344
  "component",
8179
8345
  "use",
@@ -8565,6 +8731,16 @@ function printNodeLines(node, depth) {
8565
8731
  return componentDefinitionLines(node, depth);
8566
8732
  case "ComponentUse":
8567
8733
  return componentUseLines(node, depth);
8734
+ // `repeat 6 { … }` — the count prints bare, as the grammar's positional
8735
+ // `Integer`, which is why this cannot go through `containerLines` (that
8736
+ // helper's only pre-attribute segment is an optional *quoted* label).
8737
+ case "Repeat":
8738
+ return blockLines(
8739
+ depth,
8740
+ ["repeat", integerSegment(node, "count"), ...attrSegments(node, ["count"], node.type)],
8741
+ childrenLines(node, depth),
8742
+ "required"
8743
+ );
8568
8744
  // -- containers without a label ----------------------------------------
8569
8745
  case "Header":
8570
8746
  case "Main":
@@ -13091,6 +13267,12 @@ var COMPONENT_METADATA = {
13091
13267
  hasChildren: false,
13092
13268
  description: "Mark content insertion: bare inside a layout, or named inside a reusable component."
13093
13269
  },
13270
+ repeat: {
13271
+ category: "structure",
13272
+ attributes: [],
13273
+ hasChildren: true,
13274
+ 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."
13275
+ },
13094
13276
  header: {
13095
13277
  category: "layout",
13096
13278
  attributes: [...BOX_ATTRIBUTES, ...CONTAINER_ATTRIBUTES],
@@ -61664,6 +61846,7 @@ var HtmlRenderer = class extends BaseRenderer {
61664
61846
  * enabled so `renderNode` / `renderPage` can inject each node's path.
61665
61847
  */
61666
61848
  render(document) {
61849
+ document = expandRepeats(document);
61667
61850
  if (this.context.options.sourceAnchors) {
61668
61851
  this.pathMap = buildAnchorPathMap(document, this.pageIndexBase);
61669
61852
  }
@@ -63012,6 +63195,7 @@ function compactRuntimeInteractions(model, interactions) {
63012
63195
  }
63013
63196
  function renderSite(document, options = {}) {
63014
63197
  const prefix = options.classPrefix ?? DEFAULT_PREFIX2;
63198
+ document = expandRepeats(document);
63015
63199
  const model = buildSiteModel(document);
63016
63200
  const interactionModel = collectInteractions(document);
63017
63201
  const make = (idScope) => new HtmlRenderer({
@@ -63202,7 +63386,8 @@ var POSITIONAL_PROPS = {
63202
63386
  Layout: ["name"],
63203
63387
  Component: ["name"],
63204
63388
  ComponentUse: ["name", "namespace"],
63205
- Slot: ["name"]
63389
+ Slot: ["name"],
63390
+ Repeat: ["count"]
63206
63391
  };
63207
63392
  function declaredName(value) {
63208
63393
  const name = value?.trim();
@@ -65513,6 +65698,8 @@ export {
65513
65698
  INTERACTIVE_ATTR_NAMES,
65514
65699
  LUCIDE_ICON_NAMES,
65515
65700
  NODE_TYPE_MAP,
65701
+ REPEAT_EXPANSION_BUDGET,
65702
+ RepeatBudgetError,
65516
65703
  TYPED_INTERACTION_ATTR,
65517
65704
  VALID_ATTRIBUTE_NAMES,
65518
65705
  VALID_COMPONENT_NAMES,
@@ -65539,6 +65726,7 @@ export {
65539
65726
  diff,
65540
65727
  documentDefinitions,
65541
65728
  documentPages,
65729
+ expandRepeats,
65542
65730
  exportToFigma,
65543
65731
  exportToFigmaString,
65544
65732
  exportToJson,