@wireweave/core 3.1.0-beta.5 → 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.cjs CHANGED
@@ -46,6 +46,8 @@ __export(src_exports, {
46
46
  INTERACTIVE_ATTR_NAMES: () => INTERACTIVE_ATTR_NAMES,
47
47
  LUCIDE_ICON_NAMES: () => LUCIDE_ICON_NAMES,
48
48
  NODE_TYPE_MAP: () => NODE_TYPE_MAP,
49
+ REPEAT_EXPANSION_BUDGET: () => REPEAT_EXPANSION_BUDGET,
50
+ RepeatBudgetError: () => RepeatBudgetError,
49
51
  TYPED_INTERACTION_ATTR: () => TYPED_INTERACTION_ATTR,
50
52
  VALID_ATTRIBUTE_NAMES: () => VALID_ATTRIBUTE_NAMES,
51
53
  VALID_COMPONENT_NAMES: () => VALID_COMPONENT_NAMES,
@@ -60,6 +62,7 @@ __export(src_exports, {
60
62
  calculateViewportScale: () => calculateViewportScale,
61
63
  cloneNode: () => cloneNode,
62
64
  collectInteractions: () => collectInteractions,
65
+ collectParameterReferences: () => collectParameterReferences,
63
66
  compileApp: () => compileApp,
64
67
  contains: () => contains,
65
68
  countNodes: () => countNodes,
@@ -71,6 +74,7 @@ __export(src_exports, {
71
74
  diff: () => diff,
72
75
  documentDefinitions: () => documentDefinitions,
73
76
  documentPages: () => documentPages,
77
+ expandRepeats: () => expandRepeats,
74
78
  exportToFigma: () => exportToFigma,
75
79
  exportToFigmaString: () => exportToFigmaString,
76
80
  exportToJson: () => exportToJson,
@@ -172,6 +176,7 @@ __export(src_exports, {
172
176
  mapNodes: () => mapNodes,
173
177
  normalizeInteractionHandlers: () => normalizeInteractionHandlers,
174
178
  normalizeStateGuard: () => normalizeStateGuard,
179
+ parameterReferenceName: () => parameterReferenceName,
175
180
  parse: () => parse,
176
181
  parseViewportString: () => parseViewportString,
177
182
  printWireframe: () => printWireframe,
@@ -201,6 +206,7 @@ var CONTAINER_TYPES = [
201
206
  "Layout",
202
207
  "Component",
203
208
  "ComponentUse",
209
+ "Repeat",
204
210
  "Header",
205
211
  "Main",
206
212
  "Footer",
@@ -515,6 +521,119 @@ function getNodeTypes(node) {
515
521
  return types;
516
522
  }
517
523
 
524
+ // src/ast/component-parameters.ts
525
+ var PARAMETER_REFERENCE = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/;
526
+ function parameterReferenceName(value) {
527
+ return typeof value === "string" ? PARAMETER_REFERENCE.exec(value)?.[1] : void 0;
528
+ }
529
+ function collectParameterReferences(children) {
530
+ const found = [];
531
+ const visitValue = (value, key, node) => {
532
+ const name = parameterReferenceName(value);
533
+ if (name !== void 0) {
534
+ found.push({ name, key, node });
535
+ return;
536
+ }
537
+ if (Array.isArray(value)) {
538
+ for (const item of value) visitValue(item, key, node);
539
+ return;
540
+ }
541
+ if (value === null || typeof value !== "object") return;
542
+ for (const [childKey, item] of Object.entries(value)) {
543
+ if (childKey === "loc") continue;
544
+ visitValue(item, childKey, node);
545
+ }
546
+ };
547
+ const visitNode = (node) => {
548
+ if (node.type === "ComponentUse") return;
549
+ for (const [key, value] of Object.entries(node)) {
550
+ if (key === "loc" || key === "children") continue;
551
+ visitValue(value, key, node);
552
+ }
553
+ if ("children" in node && Array.isArray(node.children)) {
554
+ for (const child of node.children) visitNode(child);
555
+ }
556
+ };
557
+ for (const child of children) visitNode(child);
558
+ return found;
559
+ }
560
+
561
+ // src/ast/expand-repeats.ts
562
+ var REPEAT_EXPANSION_BUDGET = 500;
563
+ var RepeatBudgetError = class extends Error {
564
+ constructor(budget) {
565
+ super(
566
+ `repeat expansion exceeds ${budget} nodes \u2014 nesting multiplies, so check the nested counts rather than the outermost one`
567
+ );
568
+ this.name = "RepeatBudgetError";
569
+ }
570
+ };
571
+ function cloneNode2(value) {
572
+ if (Array.isArray(value)) return value.map(cloneNode2);
573
+ if (value === null || typeof value !== "object") return value;
574
+ const source = value;
575
+ const result = {};
576
+ for (const [key, item] of Object.entries(source)) {
577
+ result[key] = key === "loc" ? item : cloneNode2(item);
578
+ }
579
+ return result;
580
+ }
581
+ function containsRepeat(node) {
582
+ if (node.type === "Repeat") return true;
583
+ const children = node.children;
584
+ if (Array.isArray(children)) {
585
+ for (const child of children) if (containsRepeat(child)) return true;
586
+ }
587
+ const fills = node.fills;
588
+ if (Array.isArray(fills)) {
589
+ for (const fill of fills) {
590
+ for (const child of fill.children ?? []) if (containsRepeat(child)) return true;
591
+ }
592
+ }
593
+ return false;
594
+ }
595
+ function expandOne(node, budget) {
596
+ if (node.type === "Repeat") {
597
+ const repeat = node;
598
+ const count = Number.isInteger(repeat.count) && repeat.count > 0 ? repeat.count : 0;
599
+ const result = [];
600
+ for (let i = 0; i < count; i++) {
601
+ for (const child of repeat.children) {
602
+ for (const expanded of expandOne(child, budget)) {
603
+ budget.remaining -= 1;
604
+ if (budget.remaining < 0) throw new RepeatBudgetError(REPEAT_EXPANSION_BUDGET);
605
+ result.push(cloneNode2(expanded));
606
+ }
607
+ }
608
+ }
609
+ return result;
610
+ }
611
+ if (!containsRepeat(node)) return [node];
612
+ const clone = { ...node };
613
+ const children = clone.children;
614
+ if (Array.isArray(children)) {
615
+ clone.children = children.flatMap((child) => expandOne(child, budget));
616
+ }
617
+ const fills = clone.fills;
618
+ if (Array.isArray(fills)) {
619
+ clone.fills = fills.map((fill) => ({
620
+ ...fill,
621
+ children: (fill.children ?? []).flatMap((child) => expandOne(child, budget))
622
+ }));
623
+ }
624
+ return [clone];
625
+ }
626
+ function expandRepeats(document) {
627
+ if (!document.children.some((child) => containsRepeat(child))) return document;
628
+ const budget = { remaining: REPEAT_EXPANSION_BUDGET };
629
+ return {
630
+ ...document,
631
+ children: document.children.flatMap(
632
+ (child) => expandOne(child, budget)
633
+ )
634
+ };
635
+ }
636
+
518
637
  // src/parser/generated-parser.js
519
638
  var peg$SyntaxError = class extends SyntaxError {
520
639
  constructor(message, expected, found, location) {
@@ -644,75 +763,76 @@ function peg$parse(input, options) {
644
763
  const peg$c17 = "\r\n";
645
764
  const peg$c18 = "//";
646
765
  const peg$c19 = "/*";
647
- const peg$c20 = "header";
648
- const peg$c21 = "main";
649
- const peg$c22 = "footer";
650
- const peg$c23 = "sidebar";
651
- const peg$c24 = "row";
652
- const peg$c25 = "col";
653
- const peg$c26 = "stack";
654
- const peg$c27 = "relative";
655
- const peg$c28 = "card";
656
- const peg$c29 = "modal";
657
- const peg$c30 = "drawer";
658
- const peg$c31 = "accordion";
659
- const peg$c32 = "section";
660
- const peg$c33 = "text";
661
- const peg$c34 = "title";
662
- const peg$c35 = "link";
663
- const peg$c36 = "button";
664
- const peg$c37 = "input";
665
- const peg$c38 = "textarea";
666
- const peg$c39 = "select";
667
- const peg$c40 = "checkbox";
668
- const peg$c41 = "radio";
669
- const peg$c42 = "switch";
670
- const peg$c43 = "slider";
671
- const peg$c44 = "image";
672
- const peg$c45 = "placeholder";
673
- const peg$c46 = "avatar";
674
- const peg$c47 = "badge";
675
- const peg$c48 = "icon";
676
- const peg$c49 = "table";
677
- const peg$c50 = "[";
678
- const peg$c51 = "]";
679
- const peg$c52 = "columns";
680
- const peg$c53 = "list";
681
- const peg$c54 = "item";
682
- const peg$c55 = "alert";
683
- const peg$c56 = "toast";
684
- const peg$c57 = "progress";
685
- const peg$c58 = "spinner";
686
- const peg$c59 = "tooltip";
687
- const peg$c60 = "popover";
688
- const peg$c61 = "dropdown";
689
- const peg$c62 = "divider";
690
- const peg$c63 = "nav";
691
- const peg$c64 = "group";
692
- const peg$c65 = "tabs";
693
- const peg$c66 = "tab";
694
- const peg$c67 = "breadcrumb";
695
- const peg$c68 = "marker";
696
- const peg$c69 = "annotations";
697
- const peg$c70 = "at";
698
- const peg$c71 = '"';
699
- const peg$c72 = "'";
700
- const peg$c73 = "\\";
701
- const peg$c74 = "n";
702
- const peg$c75 = "r";
703
- const peg$c76 = "t";
704
- const peg$c77 = "-";
705
- const peg$c78 = ".";
706
- const peg$c79 = "px";
707
- const peg$c80 = "%";
708
- const peg$c81 = "em";
709
- const peg$c82 = "rem";
710
- const peg$c83 = "vh";
711
- const peg$c84 = "vw";
712
- const peg$c85 = "true";
713
- const peg$c86 = "false";
714
- const peg$c87 = "\n";
715
- const peg$c88 = "*/";
766
+ const peg$c20 = "repeat";
767
+ const peg$c21 = "header";
768
+ const peg$c22 = "main";
769
+ const peg$c23 = "footer";
770
+ const peg$c24 = "sidebar";
771
+ const peg$c25 = "row";
772
+ const peg$c26 = "col";
773
+ const peg$c27 = "stack";
774
+ const peg$c28 = "relative";
775
+ const peg$c29 = "card";
776
+ const peg$c30 = "modal";
777
+ const peg$c31 = "drawer";
778
+ const peg$c32 = "accordion";
779
+ const peg$c33 = "section";
780
+ const peg$c34 = "text";
781
+ const peg$c35 = "title";
782
+ const peg$c36 = "link";
783
+ const peg$c37 = "button";
784
+ const peg$c38 = "input";
785
+ const peg$c39 = "textarea";
786
+ const peg$c40 = "select";
787
+ const peg$c41 = "checkbox";
788
+ const peg$c42 = "radio";
789
+ const peg$c43 = "switch";
790
+ const peg$c44 = "slider";
791
+ const peg$c45 = "image";
792
+ const peg$c46 = "placeholder";
793
+ const peg$c47 = "avatar";
794
+ const peg$c48 = "badge";
795
+ const peg$c49 = "icon";
796
+ const peg$c50 = "table";
797
+ const peg$c51 = "[";
798
+ const peg$c52 = "]";
799
+ const peg$c53 = "columns";
800
+ const peg$c54 = "list";
801
+ const peg$c55 = "item";
802
+ const peg$c56 = "alert";
803
+ const peg$c57 = "toast";
804
+ const peg$c58 = "progress";
805
+ const peg$c59 = "spinner";
806
+ const peg$c60 = "tooltip";
807
+ const peg$c61 = "popover";
808
+ const peg$c62 = "dropdown";
809
+ const peg$c63 = "divider";
810
+ const peg$c64 = "nav";
811
+ const peg$c65 = "group";
812
+ const peg$c66 = "tabs";
813
+ const peg$c67 = "tab";
814
+ const peg$c68 = "breadcrumb";
815
+ const peg$c69 = "marker";
816
+ const peg$c70 = "annotations";
817
+ const peg$c71 = "at";
818
+ const peg$c72 = '"';
819
+ const peg$c73 = "'";
820
+ const peg$c74 = "\\";
821
+ const peg$c75 = "n";
822
+ const peg$c76 = "r";
823
+ const peg$c77 = "t";
824
+ const peg$c78 = "-";
825
+ const peg$c79 = ".";
826
+ const peg$c80 = "px";
827
+ const peg$c81 = "%";
828
+ const peg$c82 = "em";
829
+ const peg$c83 = "rem";
830
+ const peg$c84 = "vh";
831
+ const peg$c85 = "vw";
832
+ const peg$c86 = "true";
833
+ const peg$c87 = "false";
834
+ const peg$c88 = "\n";
835
+ const peg$c89 = "*/";
716
836
  const peg$r0 = /^[ \t]/;
717
837
  const peg$r1 = /^[\n\r}]/;
718
838
  const peg$r2 = /^[0-9]/;
@@ -744,88 +864,89 @@ function peg$parse(input, options) {
744
864
  const peg$e20 = peg$literalExpectation("//", false);
745
865
  const peg$e21 = peg$literalExpectation("/*", false);
746
866
  const peg$e22 = peg$anyExpectation();
747
- const peg$e23 = peg$literalExpectation("header", false);
748
- const peg$e24 = peg$literalExpectation("main", false);
749
- const peg$e25 = peg$literalExpectation("footer", false);
750
- const peg$e26 = peg$literalExpectation("sidebar", false);
751
- const peg$e27 = peg$literalExpectation("row", false);
752
- const peg$e28 = peg$literalExpectation("col", false);
753
- const peg$e29 = peg$literalExpectation("stack", false);
754
- const peg$e30 = peg$literalExpectation("relative", false);
755
- const peg$e31 = peg$literalExpectation("card", false);
756
- const peg$e32 = peg$literalExpectation("modal", false);
757
- const peg$e33 = peg$literalExpectation("drawer", false);
758
- const peg$e34 = peg$literalExpectation("accordion", false);
759
- const peg$e35 = peg$literalExpectation("section", false);
760
- const peg$e36 = peg$literalExpectation("text", false);
761
- const peg$e37 = peg$literalExpectation("title", false);
762
- const peg$e38 = peg$literalExpectation("link", false);
763
- const peg$e39 = peg$literalExpectation("button", false);
764
- const peg$e40 = peg$literalExpectation("input", false);
765
- const peg$e41 = peg$literalExpectation("textarea", false);
766
- const peg$e42 = peg$literalExpectation("select", false);
767
- const peg$e43 = peg$literalExpectation("checkbox", false);
768
- const peg$e44 = peg$literalExpectation("radio", false);
769
- const peg$e45 = peg$literalExpectation("switch", false);
770
- const peg$e46 = peg$literalExpectation("slider", false);
771
- const peg$e47 = peg$literalExpectation("image", false);
772
- const peg$e48 = peg$literalExpectation("placeholder", false);
773
- const peg$e49 = peg$literalExpectation("avatar", false);
774
- const peg$e50 = peg$literalExpectation("badge", false);
775
- const peg$e51 = peg$literalExpectation("icon", false);
776
- const peg$e52 = peg$literalExpectation("table", false);
777
- const peg$e53 = peg$literalExpectation("[", false);
778
- const peg$e54 = peg$literalExpectation("]", false);
779
- const peg$e55 = peg$literalExpectation("columns", false);
780
- const peg$e56 = peg$literalExpectation("list", false);
781
- const peg$e57 = peg$literalExpectation("item", false);
782
- const peg$e58 = peg$literalExpectation("alert", false);
783
- const peg$e59 = peg$literalExpectation("toast", false);
784
- const peg$e60 = peg$literalExpectation("progress", false);
785
- const peg$e61 = peg$literalExpectation("spinner", false);
786
- const peg$e62 = peg$literalExpectation("tooltip", false);
787
- const peg$e63 = peg$literalExpectation("popover", false);
788
- const peg$e64 = peg$literalExpectation("dropdown", false);
789
- const peg$e65 = peg$literalExpectation("divider", false);
790
- const peg$e66 = peg$literalExpectation("nav", false);
791
- const peg$e67 = peg$literalExpectation("group", false);
792
- const peg$e68 = peg$literalExpectation("tabs", false);
793
- const peg$e69 = peg$literalExpectation("tab", false);
794
- const peg$e70 = peg$literalExpectation("breadcrumb", false);
795
- const peg$e71 = peg$literalExpectation("marker", false);
796
- const peg$e72 = peg$literalExpectation("annotations", false);
797
- const peg$e73 = peg$otherExpectation("integer");
798
- const peg$e74 = peg$classExpectation([["0", "9"]], false, false, false);
799
- const peg$e75 = peg$literalExpectation("at", false);
800
- const peg$e76 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
801
- const peg$e77 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
802
- const peg$e78 = peg$otherExpectation("string");
803
- const peg$e79 = peg$literalExpectation('"', false);
804
- const peg$e80 = peg$literalExpectation("'", false);
805
- const peg$e81 = peg$literalExpectation("\\", false);
806
- const peg$e82 = peg$literalExpectation("n", false);
807
- const peg$e83 = peg$literalExpectation("r", false);
808
- const peg$e84 = peg$literalExpectation("t", false);
809
- const peg$e85 = peg$otherExpectation("number");
810
- const peg$e86 = peg$literalExpectation("-", false);
811
- const peg$e87 = peg$literalExpectation(".", false);
812
- const peg$e88 = peg$otherExpectation("value with unit");
813
- const peg$e89 = peg$literalExpectation("px", false);
814
- const peg$e90 = peg$literalExpectation("%", false);
815
- const peg$e91 = peg$literalExpectation("em", false);
816
- const peg$e92 = peg$literalExpectation("rem", false);
817
- const peg$e93 = peg$literalExpectation("vh", false);
818
- const peg$e94 = peg$literalExpectation("vw", false);
819
- const peg$e95 = peg$otherExpectation("boolean");
820
- const peg$e96 = peg$literalExpectation("true", false);
821
- const peg$e97 = peg$literalExpectation("false", false);
822
- const peg$e98 = peg$otherExpectation("identifier");
823
- const peg$e99 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
824
- const peg$e100 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
825
- const peg$e101 = peg$otherExpectation("comment");
826
- const peg$e102 = peg$classExpectation(["\n"], true, false, false);
827
- const peg$e103 = peg$literalExpectation("\n", false);
828
- const peg$e104 = peg$literalExpectation("*/", false);
867
+ const peg$e23 = peg$literalExpectation("repeat", false);
868
+ const peg$e24 = peg$literalExpectation("header", false);
869
+ const peg$e25 = peg$literalExpectation("main", false);
870
+ const peg$e26 = peg$literalExpectation("footer", false);
871
+ const peg$e27 = peg$literalExpectation("sidebar", false);
872
+ const peg$e28 = peg$literalExpectation("row", false);
873
+ const peg$e29 = peg$literalExpectation("col", false);
874
+ const peg$e30 = peg$literalExpectation("stack", false);
875
+ const peg$e31 = peg$literalExpectation("relative", false);
876
+ const peg$e32 = peg$literalExpectation("card", false);
877
+ const peg$e33 = peg$literalExpectation("modal", false);
878
+ const peg$e34 = peg$literalExpectation("drawer", false);
879
+ const peg$e35 = peg$literalExpectation("accordion", false);
880
+ const peg$e36 = peg$literalExpectation("section", false);
881
+ const peg$e37 = peg$literalExpectation("text", false);
882
+ const peg$e38 = peg$literalExpectation("title", false);
883
+ const peg$e39 = peg$literalExpectation("link", false);
884
+ const peg$e40 = peg$literalExpectation("button", false);
885
+ const peg$e41 = peg$literalExpectation("input", false);
886
+ const peg$e42 = peg$literalExpectation("textarea", false);
887
+ const peg$e43 = peg$literalExpectation("select", false);
888
+ const peg$e44 = peg$literalExpectation("checkbox", false);
889
+ const peg$e45 = peg$literalExpectation("radio", false);
890
+ const peg$e46 = peg$literalExpectation("switch", false);
891
+ const peg$e47 = peg$literalExpectation("slider", false);
892
+ const peg$e48 = peg$literalExpectation("image", false);
893
+ const peg$e49 = peg$literalExpectation("placeholder", false);
894
+ const peg$e50 = peg$literalExpectation("avatar", false);
895
+ const peg$e51 = peg$literalExpectation("badge", false);
896
+ const peg$e52 = peg$literalExpectation("icon", false);
897
+ const peg$e53 = peg$literalExpectation("table", false);
898
+ const peg$e54 = peg$literalExpectation("[", false);
899
+ const peg$e55 = peg$literalExpectation("]", false);
900
+ const peg$e56 = peg$literalExpectation("columns", false);
901
+ const peg$e57 = peg$literalExpectation("list", false);
902
+ const peg$e58 = peg$literalExpectation("item", false);
903
+ const peg$e59 = peg$literalExpectation("alert", false);
904
+ const peg$e60 = peg$literalExpectation("toast", false);
905
+ const peg$e61 = peg$literalExpectation("progress", false);
906
+ const peg$e62 = peg$literalExpectation("spinner", false);
907
+ const peg$e63 = peg$literalExpectation("tooltip", false);
908
+ const peg$e64 = peg$literalExpectation("popover", false);
909
+ const peg$e65 = peg$literalExpectation("dropdown", false);
910
+ const peg$e66 = peg$literalExpectation("divider", false);
911
+ const peg$e67 = peg$literalExpectation("nav", false);
912
+ const peg$e68 = peg$literalExpectation("group", false);
913
+ const peg$e69 = peg$literalExpectation("tabs", false);
914
+ const peg$e70 = peg$literalExpectation("tab", false);
915
+ const peg$e71 = peg$literalExpectation("breadcrumb", false);
916
+ const peg$e72 = peg$literalExpectation("marker", false);
917
+ const peg$e73 = peg$literalExpectation("annotations", false);
918
+ const peg$e74 = peg$otherExpectation("integer");
919
+ const peg$e75 = peg$classExpectation([["0", "9"]], false, false, false);
920
+ const peg$e76 = peg$literalExpectation("at", false);
921
+ const peg$e77 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
922
+ const peg$e78 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
923
+ const peg$e79 = peg$otherExpectation("string");
924
+ const peg$e80 = peg$literalExpectation('"', false);
925
+ const peg$e81 = peg$literalExpectation("'", false);
926
+ const peg$e82 = peg$literalExpectation("\\", false);
927
+ const peg$e83 = peg$literalExpectation("n", false);
928
+ const peg$e84 = peg$literalExpectation("r", false);
929
+ const peg$e85 = peg$literalExpectation("t", false);
930
+ const peg$e86 = peg$otherExpectation("number");
931
+ const peg$e87 = peg$literalExpectation("-", false);
932
+ const peg$e88 = peg$literalExpectation(".", false);
933
+ const peg$e89 = peg$otherExpectation("value with unit");
934
+ const peg$e90 = peg$literalExpectation("px", false);
935
+ const peg$e91 = peg$literalExpectation("%", false);
936
+ const peg$e92 = peg$literalExpectation("em", false);
937
+ const peg$e93 = peg$literalExpectation("rem", false);
938
+ const peg$e94 = peg$literalExpectation("vh", false);
939
+ const peg$e95 = peg$literalExpectation("vw", false);
940
+ const peg$e96 = peg$otherExpectation("boolean");
941
+ const peg$e97 = peg$literalExpectation("true", false);
942
+ const peg$e98 = peg$literalExpectation("false", false);
943
+ const peg$e99 = peg$otherExpectation("identifier");
944
+ const peg$e100 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
945
+ const peg$e101 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
946
+ const peg$e102 = peg$otherExpectation("comment");
947
+ const peg$e103 = peg$classExpectation(["\n"], true, false, false);
948
+ const peg$e104 = peg$literalExpectation("\n", false);
949
+ const peg$e105 = peg$literalExpectation("*/", false);
829
950
  function peg$f0(children) {
830
951
  return createNode("Document", {
831
952
  children: children.map((c) => c[0]).filter((c) => c !== null)
@@ -906,114 +1027,120 @@ function peg$parse(input, options) {
906
1027
  function peg$f18() {
907
1028
  return null;
908
1029
  }
909
- function peg$f19(attrs2, children) {
1030
+ function peg$f19(count, children) {
1031
+ return createNode("Repeat", {
1032
+ count,
1033
+ children
1034
+ });
1035
+ }
1036
+ function peg$f20(attrs2, children) {
910
1037
  return createNode("Header", {
911
1038
  ...attrsToObject(attrs2),
912
1039
  children
913
1040
  });
914
1041
  }
915
- function peg$f20(attrs2, children) {
1042
+ function peg$f21(attrs2, children) {
916
1043
  return createNode("Main", {
917
1044
  ...attrsToObject(attrs2),
918
1045
  children
919
1046
  });
920
1047
  }
921
- function peg$f21(attrs2, children) {
1048
+ function peg$f22(attrs2, children) {
922
1049
  return createNode("Footer", {
923
1050
  ...attrsToObject(attrs2),
924
1051
  children
925
1052
  });
926
1053
  }
927
- function peg$f22(attrs2, children) {
1054
+ function peg$f23(attrs2, children) {
928
1055
  return createNode("Sidebar", {
929
1056
  ...attrsToObject(attrs2),
930
1057
  children
931
1058
  });
932
1059
  }
933
- function peg$f23(attrs2, children) {
1060
+ function peg$f24(attrs2, children) {
934
1061
  return createNode("Row", {
935
1062
  ...attrsToObject(attrs2),
936
1063
  children
937
1064
  });
938
1065
  }
939
- function peg$f24(attrs2, children) {
1066
+ function peg$f25(attrs2, children) {
940
1067
  return createNode("Col", {
941
1068
  ...attrsToObject(attrs2),
942
1069
  children
943
1070
  });
944
1071
  }
945
- function peg$f25(attrs2, children) {
1072
+ function peg$f26(attrs2, children) {
946
1073
  return createNode("Stack", {
947
1074
  ...attrsToObject(attrs2),
948
1075
  children
949
1076
  });
950
1077
  }
951
- function peg$f26(attrs2, children) {
1078
+ function peg$f27(attrs2, children) {
952
1079
  return createNode("Relative", {
953
1080
  ...attrsToObject(attrs2),
954
1081
  children
955
1082
  });
956
1083
  }
957
- function peg$f27(label, attrs2, children) {
1084
+ function peg$f28(label, attrs2, children) {
958
1085
  return createNode("Card", {
959
1086
  title: label || null,
960
1087
  ...attrsToObject(attrs2),
961
1088
  children
962
1089
  });
963
1090
  }
964
- function peg$f28(label, attrs2, children) {
1091
+ function peg$f29(label, attrs2, children) {
965
1092
  return createNode("Modal", {
966
1093
  title: label || null,
967
1094
  ...attrsToObject(attrs2),
968
1095
  children
969
1096
  });
970
1097
  }
971
- function peg$f29(label, attrs2, children) {
1098
+ function peg$f30(label, attrs2, children) {
972
1099
  return createNode("Drawer", {
973
1100
  title: label || null,
974
1101
  ...attrsToObject(attrs2),
975
1102
  children
976
1103
  });
977
1104
  }
978
- function peg$f30(label, attrs2, children) {
1105
+ function peg$f31(label, attrs2, children) {
979
1106
  return createNode("Accordion", {
980
1107
  title: label || null,
981
1108
  ...attrsToObject(attrs2),
982
1109
  children
983
1110
  });
984
1111
  }
985
- function peg$f31(label, attrs2, children) {
1112
+ function peg$f32(label, attrs2, children) {
986
1113
  return createNode("Section", {
987
1114
  title: label || null,
988
1115
  ...attrsToObject(attrs2),
989
1116
  children
990
1117
  });
991
1118
  }
992
- function peg$f32(label, attrs2) {
1119
+ function peg$f33(label, attrs2) {
993
1120
  return createNode("Text", {
994
1121
  content: label,
995
1122
  ...attrsToObject(attrs2)
996
1123
  });
997
1124
  }
998
- function peg$f33(label, attrs2) {
1125
+ function peg$f34(label, attrs2) {
999
1126
  return createNode("Title", {
1000
1127
  content: label,
1001
1128
  ...attrsToObject(attrs2)
1002
1129
  });
1003
1130
  }
1004
- function peg$f34(label, attrs2) {
1131
+ function peg$f35(label, attrs2) {
1005
1132
  return createNode("Link", {
1006
1133
  content: label,
1007
1134
  ...attrsToObject(attrs2)
1008
1135
  });
1009
1136
  }
1010
- function peg$f35(label, attrs2) {
1137
+ function peg$f36(label, attrs2) {
1011
1138
  return createNode("Button", {
1012
1139
  content: label,
1013
1140
  ...attrsToObject(attrs2)
1014
1141
  });
1015
1142
  }
1016
- function peg$f36(label, attrs2) {
1143
+ function peg$f37(label, attrs2) {
1017
1144
  const obj = attrsToObject(attrs2);
1018
1145
  const inputType = obj.type;
1019
1146
  delete obj.type;
@@ -1023,75 +1150,75 @@ function peg$parse(input, options) {
1023
1150
  ...obj
1024
1151
  });
1025
1152
  }
1026
- function peg$f37(label, attrs2) {
1153
+ function peg$f38(label, attrs2) {
1027
1154
  return createNode("Textarea", {
1028
1155
  label: label || null,
1029
1156
  ...attrsToObject(attrs2)
1030
1157
  });
1031
1158
  }
1032
- function peg$f38(label, options2, attrs2) {
1159
+ function peg$f39(label, options2, attrs2) {
1033
1160
  return createNode("Select", {
1034
1161
  label: label || null,
1035
1162
  options: options2 || [],
1036
1163
  ...attrsToObject(attrs2)
1037
1164
  });
1038
1165
  }
1039
- function peg$f39(label, attrs2) {
1166
+ function peg$f40(label, attrs2) {
1040
1167
  return createNode("Checkbox", {
1041
1168
  label: label || null,
1042
1169
  ...attrsToObject(attrs2)
1043
1170
  });
1044
1171
  }
1045
- function peg$f40(label, attrs2) {
1172
+ function peg$f41(label, attrs2) {
1046
1173
  return createNode("Radio", {
1047
1174
  label: label || null,
1048
1175
  ...attrsToObject(attrs2)
1049
1176
  });
1050
1177
  }
1051
- function peg$f41(label, attrs2) {
1178
+ function peg$f42(label, attrs2) {
1052
1179
  return createNode("Switch", {
1053
1180
  label: label || null,
1054
1181
  ...attrsToObject(attrs2)
1055
1182
  });
1056
1183
  }
1057
- function peg$f42(label, attrs2) {
1184
+ function peg$f43(label, attrs2) {
1058
1185
  return createNode("Slider", {
1059
1186
  label: label || null,
1060
1187
  ...attrsToObject(attrs2)
1061
1188
  });
1062
1189
  }
1063
- function peg$f43(src, attrs2) {
1190
+ function peg$f44(src, attrs2) {
1064
1191
  return createNode("Image", {
1065
1192
  src: src || null,
1066
1193
  ...attrsToObject(attrs2)
1067
1194
  });
1068
1195
  }
1069
- function peg$f44(label, attrs2, block) {
1196
+ function peg$f45(label, attrs2, block) {
1070
1197
  return createNode("Placeholder", {
1071
1198
  label: label || null,
1072
1199
  ...attrsToObject(attrs2),
1073
1200
  children: block ? block[2] : []
1074
1201
  });
1075
1202
  }
1076
- function peg$f45(label, attrs2) {
1203
+ function peg$f46(label, attrs2) {
1077
1204
  return createNode("Avatar", {
1078
1205
  name: label || null,
1079
1206
  ...attrsToObject(attrs2)
1080
1207
  });
1081
1208
  }
1082
- function peg$f46(label, attrs2) {
1209
+ function peg$f47(label, attrs2) {
1083
1210
  return createNode("Badge", {
1084
1211
  content: label,
1085
1212
  ...attrsToObject(attrs2)
1086
1213
  });
1087
1214
  }
1088
- function peg$f47(name, attrs2) {
1215
+ function peg$f48(name, attrs2) {
1089
1216
  return createNode("Icon", {
1090
1217
  name,
1091
1218
  ...attrsToObject(attrs2)
1092
1219
  });
1093
1220
  }
1094
- function peg$f48(data, attrs2) {
1221
+ function peg$f49(data, attrs2) {
1095
1222
  const columns = data.length > 0 ? data[0] : [];
1096
1223
  const rows = data.slice(1);
1097
1224
  return createNode("Table", {
@@ -1100,16 +1227,16 @@ function peg$parse(input, options) {
1100
1227
  ...attrsToObject(attrs2)
1101
1228
  });
1102
1229
  }
1103
- function peg$f49(attrs2, rows) {
1230
+ function peg$f50(attrs2, rows) {
1104
1231
  return createNode("Table", {
1105
1232
  ...attrsToObject(attrs2),
1106
1233
  ...rows
1107
1234
  });
1108
1235
  }
1109
- function peg$f50(first, rest) {
1236
+ function peg$f51(first, rest) {
1110
1237
  return [first, ...rest.map((r) => r[2])];
1111
1238
  }
1112
- function peg$f51(items) {
1239
+ function peg$f52(items) {
1113
1240
  const columns = [];
1114
1241
  const rows = [];
1115
1242
  for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
@@ -1118,72 +1245,72 @@ function peg$parse(input, options) {
1118
1245
  }
1119
1246
  return { columns, rows };
1120
1247
  }
1121
- function peg$f52(values) {
1248
+ function peg$f53(values) {
1122
1249
  return { kind: "columns", values };
1123
1250
  }
1124
- function peg$f53(values) {
1251
+ function peg$f54(values) {
1125
1252
  return { kind: "row", values };
1126
1253
  }
1127
- function peg$f54() {
1254
+ function peg$f55() {
1128
1255
  return null;
1129
1256
  }
1130
- function peg$f55(items, attrs2, block) {
1257
+ function peg$f56(items, attrs2, block) {
1131
1258
  return createNode("List", {
1132
1259
  items: items || (block ? block : []),
1133
1260
  ...attrsToObject(attrs2)
1134
1261
  });
1135
1262
  }
1136
- function peg$f56(items) {
1263
+ function peg$f57(items) {
1137
1264
  return items.map((i) => i[0]).filter((i) => i !== null);
1138
1265
  }
1139
- function peg$f57(label, attrs2, nested) {
1266
+ function peg$f58(label, attrs2, nested) {
1140
1267
  return createBlockNode("ListItem", {
1141
1268
  content: label,
1142
1269
  ...attrsToObject(attrs2),
1143
1270
  children: nested || []
1144
1271
  });
1145
1272
  }
1146
- function peg$f58() {
1273
+ function peg$f59() {
1147
1274
  return null;
1148
1275
  }
1149
- function peg$f59(label, attrs2) {
1276
+ function peg$f60(label, attrs2) {
1150
1277
  return createNode("Alert", {
1151
1278
  content: label,
1152
1279
  ...attrsToObject(attrs2)
1153
1280
  });
1154
1281
  }
1155
- function peg$f60(label, attrs2) {
1282
+ function peg$f61(label, attrs2) {
1156
1283
  return createNode("Toast", {
1157
1284
  content: label,
1158
1285
  ...attrsToObject(attrs2)
1159
1286
  });
1160
1287
  }
1161
- function peg$f61(attrs2) {
1288
+ function peg$f62(attrs2) {
1162
1289
  return createNode("Progress", {
1163
1290
  ...attrsToObject(attrs2)
1164
1291
  });
1165
1292
  }
1166
- function peg$f62(label, attrs2) {
1293
+ function peg$f63(label, attrs2) {
1167
1294
  return createNode("Spinner", {
1168
1295
  label: label || null,
1169
1296
  ...attrsToObject(attrs2)
1170
1297
  });
1171
1298
  }
1172
- function peg$f63(label, attrs2) {
1299
+ function peg$f64(label, attrs2) {
1173
1300
  return createNode("Tooltip", {
1174
1301
  content: label,
1175
1302
  ...attrsToObject(attrs2),
1176
1303
  children: []
1177
1304
  });
1178
1305
  }
1179
- function peg$f64(label, attrs2, children) {
1306
+ function peg$f65(label, attrs2, children) {
1180
1307
  return createNode("Popover", {
1181
1308
  title: label || null,
1182
1309
  ...attrsToObject(attrs2),
1183
1310
  children
1184
1311
  });
1185
1312
  }
1186
- function peg$f65(items, attrs2) {
1313
+ function peg$f66(items, attrs2) {
1187
1314
  const processedItems = items.map((item) => {
1188
1315
  if (typeof item === "string") {
1189
1316
  if (item === "---" || item === "-" || item === "divider") {
@@ -1198,106 +1325,106 @@ function peg$parse(input, options) {
1198
1325
  items: processedItems
1199
1326
  });
1200
1327
  }
1201
- function peg$f66(attrs2, items) {
1328
+ function peg$f67(attrs2, items) {
1202
1329
  return createNode("Dropdown", {
1203
1330
  ...attrsToObject(attrs2),
1204
1331
  items
1205
1332
  });
1206
1333
  }
1207
- function peg$f67(items) {
1334
+ function peg$f68(items) {
1208
1335
  return items.map((i) => i[0]).filter((i) => i !== null);
1209
1336
  }
1210
- function peg$f68(label, attrs2) {
1337
+ function peg$f69(label, attrs2) {
1211
1338
  return createBlockNode("DropdownItem", { label, ...attrsToObject(attrs2) });
1212
1339
  }
1213
- function peg$f69() {
1340
+ function peg$f70() {
1214
1341
  return createBlockNode("Divider", {});
1215
1342
  }
1216
- function peg$f70() {
1343
+ function peg$f71() {
1217
1344
  return null;
1218
1345
  }
1219
- function peg$f71(items, attrs2, block) {
1346
+ function peg$f72(items, attrs2, block) {
1220
1347
  return createNode("Nav", {
1221
1348
  items: items || [],
1222
1349
  ...attrsToObject(attrs2),
1223
1350
  children: block || []
1224
1351
  });
1225
1352
  }
1226
- function peg$f72(content) {
1353
+ function peg$f73(content) {
1227
1354
  return content.map((c) => c[0]).filter((c) => c !== null);
1228
1355
  }
1229
- function peg$f73() {
1356
+ function peg$f74() {
1230
1357
  return createBlockNode("Divider", {});
1231
1358
  }
1232
- function peg$f74() {
1359
+ function peg$f75() {
1233
1360
  return null;
1234
1361
  }
1235
- function peg$f75(label, attrs2, items) {
1362
+ function peg$f76(label, attrs2, items) {
1236
1363
  return createBlockNode("NavGroup", {
1237
1364
  label,
1238
1365
  ...attrsToObject(attrs2),
1239
1366
  items: items.map((i) => i[0]).filter((i) => i !== null)
1240
1367
  });
1241
1368
  }
1242
- function peg$f76() {
1369
+ function peg$f77() {
1243
1370
  return createBlockNode("Divider", {});
1244
1371
  }
1245
- function peg$f77() {
1372
+ function peg$f78() {
1246
1373
  return null;
1247
1374
  }
1248
- function peg$f78(label, attrs2) {
1375
+ function peg$f79(label, attrs2) {
1249
1376
  return createBlockNode("NavItem", {
1250
1377
  label,
1251
1378
  ...attrsToObject(attrs2)
1252
1379
  });
1253
1380
  }
1254
- function peg$f79(items, attrs2, block) {
1381
+ function peg$f80(items, attrs2, block) {
1255
1382
  return createNode("Tabs", {
1256
1383
  items: items || [],
1257
1384
  ...attrsToObject(attrs2),
1258
1385
  children: block || []
1259
1386
  });
1260
1387
  }
1261
- function peg$f80(tabs) {
1388
+ function peg$f81(tabs) {
1262
1389
  return tabs.map((t) => t[0]).filter((t) => t !== null);
1263
1390
  }
1264
- function peg$f81(label, attrs2, children) {
1391
+ function peg$f82(label, attrs2, children) {
1265
1392
  return {
1266
1393
  label,
1267
1394
  ...attrsToObject(attrs2),
1268
1395
  children
1269
1396
  };
1270
1397
  }
1271
- function peg$f82() {
1398
+ function peg$f83() {
1272
1399
  return null;
1273
1400
  }
1274
- function peg$f83(items, attrs2) {
1401
+ function peg$f84(items, attrs2) {
1275
1402
  return createNode("Breadcrumb", {
1276
1403
  items,
1277
1404
  ...attrsToObject(attrs2)
1278
1405
  });
1279
1406
  }
1280
- function peg$f84(attrs2) {
1407
+ function peg$f85(attrs2) {
1281
1408
  return createNode("Divider", {
1282
1409
  ...attrsToObject(attrs2)
1283
1410
  });
1284
1411
  }
1285
- function peg$f85(num, attrs2) {
1412
+ function peg$f86(num, attrs2) {
1286
1413
  return createNode("Marker", {
1287
1414
  number: num,
1288
1415
  ...attrsToObject(attrs2)
1289
1416
  });
1290
1417
  }
1291
- function peg$f86(attrs2, items) {
1418
+ function peg$f87(attrs2, items) {
1292
1419
  return createNode("Annotations", {
1293
1420
  ...attrsToObject(attrs2),
1294
1421
  children: items
1295
1422
  });
1296
1423
  }
1297
- function peg$f87(items) {
1424
+ function peg$f88(items) {
1298
1425
  return items.map((i) => i[0]).filter((i) => i !== null);
1299
1426
  }
1300
- function peg$f88(num, title, attrs2, children) {
1427
+ function peg$f89(num, title, attrs2, children) {
1301
1428
  return createNode("AnnotationItem", {
1302
1429
  number: num,
1303
1430
  title,
@@ -1305,7 +1432,7 @@ function peg$parse(input, options) {
1305
1432
  children
1306
1433
  });
1307
1434
  }
1308
- function peg$f89(num, title, attrs2) {
1435
+ function peg$f90(num, title, attrs2) {
1309
1436
  return createNode("AnnotationItem", {
1310
1437
  number: num,
1311
1438
  title,
@@ -1313,90 +1440,90 @@ function peg$parse(input, options) {
1313
1440
  children: []
1314
1441
  });
1315
1442
  }
1316
- function peg$f90() {
1443
+ function peg$f91() {
1317
1444
  return null;
1318
1445
  }
1319
- function peg$f91(digits) {
1446
+ function peg$f92(digits) {
1320
1447
  return parseInt(digits.join(""), 10);
1321
1448
  }
1322
- function peg$f92(attrs2) {
1449
+ function peg$f93(attrs2) {
1323
1450
  return attrs2;
1324
1451
  }
1325
- function peg$f93(x, y) {
1452
+ function peg$f94(x, y) {
1326
1453
  return [
1327
1454
  { name: "x", value: x },
1328
1455
  { name: "y", value: y }
1329
1456
  ];
1330
1457
  }
1331
- function peg$f94(name, value) {
1458
+ function peg$f95(name, value) {
1332
1459
  return { name, value };
1333
1460
  }
1334
- function peg$f95(flag) {
1461
+ function peg$f96(flag) {
1335
1462
  return { name: flag, value: true };
1336
1463
  }
1337
- function peg$f96(name) {
1464
+ function peg$f97(name) {
1338
1465
  return name;
1339
1466
  }
1340
- function peg$f97(chars) {
1467
+ function peg$f98(chars) {
1341
1468
  return chars.join("");
1342
1469
  }
1343
- function peg$f98(chars) {
1470
+ function peg$f99(chars) {
1344
1471
  return chars.join("");
1345
1472
  }
1346
- function peg$f99(char) {
1473
+ function peg$f100(char) {
1347
1474
  return char;
1348
1475
  }
1349
- function peg$f100(seq) {
1476
+ function peg$f101(seq) {
1350
1477
  return seq;
1351
1478
  }
1352
- function peg$f101(char) {
1479
+ function peg$f102(char) {
1353
1480
  return char;
1354
1481
  }
1355
- function peg$f102(seq) {
1482
+ function peg$f103(seq) {
1356
1483
  return seq;
1357
1484
  }
1358
- function peg$f103() {
1485
+ function peg$f104() {
1359
1486
  return "\n";
1360
1487
  }
1361
- function peg$f104() {
1488
+ function peg$f105() {
1362
1489
  return "\r";
1363
1490
  }
1364
- function peg$f105() {
1491
+ function peg$f106() {
1365
1492
  return " ";
1366
1493
  }
1367
- function peg$f106() {
1494
+ function peg$f107() {
1368
1495
  return "\\";
1369
1496
  }
1370
- function peg$f107() {
1497
+ function peg$f108() {
1371
1498
  return '"';
1372
1499
  }
1373
- function peg$f108() {
1500
+ function peg$f109() {
1374
1501
  return "'";
1375
1502
  }
1376
- function peg$f109(sign, digits, decimal) {
1503
+ function peg$f110(sign, digits, decimal) {
1377
1504
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1378
1505
  return parseFloat(num);
1379
1506
  }
1380
- function peg$f110(sign, digits, decimal, unit) {
1507
+ function peg$f111(sign, digits, decimal, unit) {
1381
1508
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1382
1509
  return { value: parseFloat(num), unit };
1383
1510
  }
1384
- function peg$f111() {
1511
+ function peg$f112() {
1385
1512
  return true;
1386
1513
  }
1387
- function peg$f112() {
1514
+ function peg$f113() {
1388
1515
  return false;
1389
1516
  }
1390
- function peg$f113(head, tail) {
1517
+ function peg$f114(head, tail) {
1391
1518
  return head + tail.join("");
1392
1519
  }
1393
- function peg$f114(items) {
1520
+ function peg$f115(items) {
1394
1521
  return items || [];
1395
1522
  }
1396
- function peg$f115(head, tail) {
1523
+ function peg$f116(head, tail) {
1397
1524
  return [head, ...tail.map((t) => t[3])];
1398
1525
  }
1399
- function peg$f116(props) {
1526
+ function peg$f117(props) {
1400
1527
  const result = {};
1401
1528
  if (props) {
1402
1529
  for (const p of props) {
@@ -1405,13 +1532,13 @@ function peg$parse(input, options) {
1405
1532
  }
1406
1533
  return result;
1407
1534
  }
1408
- function peg$f117(head, tail) {
1535
+ function peg$f118(head, tail) {
1409
1536
  return [head, ...tail.map((t) => t[3])];
1410
1537
  }
1411
- function peg$f118(name, value) {
1538
+ function peg$f119(name, value) {
1412
1539
  return { name, value };
1413
1540
  }
1414
- function peg$f119(name) {
1541
+ function peg$f120(name) {
1415
1542
  return { name, value: true };
1416
1543
  }
1417
1544
  let peg$currPos = options.peg$currPos | 0;
@@ -2663,21 +2790,24 @@ function peg$parse(input, options) {
2663
2790
  let s0, s1;
2664
2791
  s0 = peg$parseComponentUse();
2665
2792
  if (s0 === peg$FAILED) {
2666
- s0 = peg$parseLayoutElement();
2793
+ s0 = peg$parseRepeat();
2667
2794
  if (s0 === peg$FAILED) {
2668
- s0 = peg$parseContainerElement();
2795
+ s0 = peg$parseLayoutElement();
2669
2796
  if (s0 === peg$FAILED) {
2670
- s0 = peg$parseUIElement();
2797
+ s0 = peg$parseContainerElement();
2671
2798
  if (s0 === peg$FAILED) {
2672
- s0 = peg$parseSlot();
2799
+ s0 = peg$parseUIElement();
2673
2800
  if (s0 === peg$FAILED) {
2674
- s0 = peg$currPos;
2675
- s1 = peg$parseComment();
2676
- if (s1 !== peg$FAILED) {
2677
- peg$savedPos = s0;
2678
- s1 = peg$f18();
2801
+ s0 = peg$parseSlot();
2802
+ if (s0 === peg$FAILED) {
2803
+ s0 = peg$currPos;
2804
+ s1 = peg$parseComment();
2805
+ if (s1 !== peg$FAILED) {
2806
+ peg$savedPos = s0;
2807
+ s1 = peg$f18();
2808
+ }
2809
+ s0 = s1;
2679
2810
  }
2680
- s0 = s1;
2681
2811
  }
2682
2812
  }
2683
2813
  }
@@ -2685,6 +2815,71 @@ function peg$parse(input, options) {
2685
2815
  }
2686
2816
  return s0;
2687
2817
  }
2818
+ function peg$parseRepeat() {
2819
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2820
+ s0 = peg$currPos;
2821
+ if (input.substr(peg$currPos, 6) === peg$c20) {
2822
+ s1 = peg$c20;
2823
+ peg$currPos += 6;
2824
+ } else {
2825
+ s1 = peg$FAILED;
2826
+ if (peg$silentFails === 0) {
2827
+ peg$fail(peg$e23);
2828
+ }
2829
+ }
2830
+ if (s1 !== peg$FAILED) {
2831
+ s2 = peg$parse_();
2832
+ s3 = peg$parseInteger();
2833
+ if (s3 !== peg$FAILED) {
2834
+ s4 = peg$parse_();
2835
+ if (input.charCodeAt(peg$currPos) === 123) {
2836
+ s5 = peg$c1;
2837
+ peg$currPos++;
2838
+ } else {
2839
+ s5 = peg$FAILED;
2840
+ if (peg$silentFails === 0) {
2841
+ peg$fail(peg$e1);
2842
+ }
2843
+ }
2844
+ if (s5 !== peg$FAILED) {
2845
+ s6 = peg$parse_();
2846
+ s7 = peg$parseChildren();
2847
+ if (s7 !== peg$FAILED) {
2848
+ s8 = peg$parse_();
2849
+ if (input.charCodeAt(peg$currPos) === 125) {
2850
+ s9 = peg$c2;
2851
+ peg$currPos++;
2852
+ } else {
2853
+ s9 = peg$FAILED;
2854
+ if (peg$silentFails === 0) {
2855
+ peg$fail(peg$e2);
2856
+ }
2857
+ }
2858
+ if (s9 !== peg$FAILED) {
2859
+ peg$savedPos = s0;
2860
+ s0 = peg$f19(s3, s7);
2861
+ } else {
2862
+ peg$currPos = s0;
2863
+ s0 = peg$FAILED;
2864
+ }
2865
+ } else {
2866
+ peg$currPos = s0;
2867
+ s0 = peg$FAILED;
2868
+ }
2869
+ } else {
2870
+ peg$currPos = s0;
2871
+ s0 = peg$FAILED;
2872
+ }
2873
+ } else {
2874
+ peg$currPos = s0;
2875
+ s0 = peg$FAILED;
2876
+ }
2877
+ } else {
2878
+ peg$currPos = s0;
2879
+ s0 = peg$FAILED;
2880
+ }
2881
+ return s0;
2882
+ }
2688
2883
  function peg$parseLayoutElement() {
2689
2884
  let s0;
2690
2885
  s0 = peg$parseHeader();
@@ -2714,13 +2909,13 @@ function peg$parse(input, options) {
2714
2909
  function peg$parseHeader() {
2715
2910
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2716
2911
  s0 = peg$currPos;
2717
- if (input.substr(peg$currPos, 6) === peg$c20) {
2718
- s1 = peg$c20;
2912
+ if (input.substr(peg$currPos, 6) === peg$c21) {
2913
+ s1 = peg$c21;
2719
2914
  peg$currPos += 6;
2720
2915
  } else {
2721
2916
  s1 = peg$FAILED;
2722
2917
  if (peg$silentFails === 0) {
2723
- peg$fail(peg$e23);
2918
+ peg$fail(peg$e24);
2724
2919
  }
2725
2920
  }
2726
2921
  if (s1 !== peg$FAILED) {
@@ -2755,7 +2950,7 @@ function peg$parse(input, options) {
2755
2950
  }
2756
2951
  if (s9 !== peg$FAILED) {
2757
2952
  peg$savedPos = s0;
2758
- s0 = peg$f19(s3, s7);
2953
+ s0 = peg$f20(s3, s7);
2759
2954
  } else {
2760
2955
  peg$currPos = s0;
2761
2956
  s0 = peg$FAILED;
@@ -2777,13 +2972,13 @@ function peg$parse(input, options) {
2777
2972
  function peg$parseMain() {
2778
2973
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2779
2974
  s0 = peg$currPos;
2780
- if (input.substr(peg$currPos, 4) === peg$c21) {
2781
- s1 = peg$c21;
2975
+ if (input.substr(peg$currPos, 4) === peg$c22) {
2976
+ s1 = peg$c22;
2782
2977
  peg$currPos += 4;
2783
2978
  } else {
2784
2979
  s1 = peg$FAILED;
2785
2980
  if (peg$silentFails === 0) {
2786
- peg$fail(peg$e24);
2981
+ peg$fail(peg$e25);
2787
2982
  }
2788
2983
  }
2789
2984
  if (s1 !== peg$FAILED) {
@@ -2818,7 +3013,7 @@ function peg$parse(input, options) {
2818
3013
  }
2819
3014
  if (s9 !== peg$FAILED) {
2820
3015
  peg$savedPos = s0;
2821
- s0 = peg$f20(s3, s7);
3016
+ s0 = peg$f21(s3, s7);
2822
3017
  } else {
2823
3018
  peg$currPos = s0;
2824
3019
  s0 = peg$FAILED;
@@ -2840,13 +3035,13 @@ function peg$parse(input, options) {
2840
3035
  function peg$parseFooter() {
2841
3036
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2842
3037
  s0 = peg$currPos;
2843
- if (input.substr(peg$currPos, 6) === peg$c22) {
2844
- s1 = peg$c22;
3038
+ if (input.substr(peg$currPos, 6) === peg$c23) {
3039
+ s1 = peg$c23;
2845
3040
  peg$currPos += 6;
2846
3041
  } else {
2847
3042
  s1 = peg$FAILED;
2848
3043
  if (peg$silentFails === 0) {
2849
- peg$fail(peg$e25);
3044
+ peg$fail(peg$e26);
2850
3045
  }
2851
3046
  }
2852
3047
  if (s1 !== peg$FAILED) {
@@ -2881,7 +3076,7 @@ function peg$parse(input, options) {
2881
3076
  }
2882
3077
  if (s9 !== peg$FAILED) {
2883
3078
  peg$savedPos = s0;
2884
- s0 = peg$f21(s3, s7);
3079
+ s0 = peg$f22(s3, s7);
2885
3080
  } else {
2886
3081
  peg$currPos = s0;
2887
3082
  s0 = peg$FAILED;
@@ -2903,13 +3098,13 @@ function peg$parse(input, options) {
2903
3098
  function peg$parseSidebar() {
2904
3099
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2905
3100
  s0 = peg$currPos;
2906
- if (input.substr(peg$currPos, 7) === peg$c23) {
2907
- s1 = peg$c23;
3101
+ if (input.substr(peg$currPos, 7) === peg$c24) {
3102
+ s1 = peg$c24;
2908
3103
  peg$currPos += 7;
2909
3104
  } else {
2910
3105
  s1 = peg$FAILED;
2911
3106
  if (peg$silentFails === 0) {
2912
- peg$fail(peg$e26);
3107
+ peg$fail(peg$e27);
2913
3108
  }
2914
3109
  }
2915
3110
  if (s1 !== peg$FAILED) {
@@ -2944,7 +3139,7 @@ function peg$parse(input, options) {
2944
3139
  }
2945
3140
  if (s9 !== peg$FAILED) {
2946
3141
  peg$savedPos = s0;
2947
- s0 = peg$f22(s3, s7);
3142
+ s0 = peg$f23(s3, s7);
2948
3143
  } else {
2949
3144
  peg$currPos = s0;
2950
3145
  s0 = peg$FAILED;
@@ -2966,13 +3161,13 @@ function peg$parse(input, options) {
2966
3161
  function peg$parseRow() {
2967
3162
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2968
3163
  s0 = peg$currPos;
2969
- if (input.substr(peg$currPos, 3) === peg$c24) {
2970
- s1 = peg$c24;
3164
+ if (input.substr(peg$currPos, 3) === peg$c25) {
3165
+ s1 = peg$c25;
2971
3166
  peg$currPos += 3;
2972
3167
  } else {
2973
3168
  s1 = peg$FAILED;
2974
3169
  if (peg$silentFails === 0) {
2975
- peg$fail(peg$e27);
3170
+ peg$fail(peg$e28);
2976
3171
  }
2977
3172
  }
2978
3173
  if (s1 !== peg$FAILED) {
@@ -3007,7 +3202,7 @@ function peg$parse(input, options) {
3007
3202
  }
3008
3203
  if (s9 !== peg$FAILED) {
3009
3204
  peg$savedPos = s0;
3010
- s0 = peg$f23(s3, s7);
3205
+ s0 = peg$f24(s3, s7);
3011
3206
  } else {
3012
3207
  peg$currPos = s0;
3013
3208
  s0 = peg$FAILED;
@@ -3029,13 +3224,13 @@ function peg$parse(input, options) {
3029
3224
  function peg$parseCol() {
3030
3225
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3031
3226
  s0 = peg$currPos;
3032
- if (input.substr(peg$currPos, 3) === peg$c25) {
3033
- s1 = peg$c25;
3227
+ if (input.substr(peg$currPos, 3) === peg$c26) {
3228
+ s1 = peg$c26;
3034
3229
  peg$currPos += 3;
3035
3230
  } else {
3036
3231
  s1 = peg$FAILED;
3037
3232
  if (peg$silentFails === 0) {
3038
- peg$fail(peg$e28);
3233
+ peg$fail(peg$e29);
3039
3234
  }
3040
3235
  }
3041
3236
  if (s1 !== peg$FAILED) {
@@ -3070,7 +3265,7 @@ function peg$parse(input, options) {
3070
3265
  }
3071
3266
  if (s9 !== peg$FAILED) {
3072
3267
  peg$savedPos = s0;
3073
- s0 = peg$f24(s3, s7);
3268
+ s0 = peg$f25(s3, s7);
3074
3269
  } else {
3075
3270
  peg$currPos = s0;
3076
3271
  s0 = peg$FAILED;
@@ -3092,13 +3287,13 @@ function peg$parse(input, options) {
3092
3287
  function peg$parseStack() {
3093
3288
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3094
3289
  s0 = peg$currPos;
3095
- if (input.substr(peg$currPos, 5) === peg$c26) {
3096
- s1 = peg$c26;
3290
+ if (input.substr(peg$currPos, 5) === peg$c27) {
3291
+ s1 = peg$c27;
3097
3292
  peg$currPos += 5;
3098
3293
  } else {
3099
3294
  s1 = peg$FAILED;
3100
3295
  if (peg$silentFails === 0) {
3101
- peg$fail(peg$e29);
3296
+ peg$fail(peg$e30);
3102
3297
  }
3103
3298
  }
3104
3299
  if (s1 !== peg$FAILED) {
@@ -3133,7 +3328,7 @@ function peg$parse(input, options) {
3133
3328
  }
3134
3329
  if (s9 !== peg$FAILED) {
3135
3330
  peg$savedPos = s0;
3136
- s0 = peg$f25(s3, s7);
3331
+ s0 = peg$f26(s3, s7);
3137
3332
  } else {
3138
3333
  peg$currPos = s0;
3139
3334
  s0 = peg$FAILED;
@@ -3155,13 +3350,13 @@ function peg$parse(input, options) {
3155
3350
  function peg$parseRelative() {
3156
3351
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3157
3352
  s0 = peg$currPos;
3158
- if (input.substr(peg$currPos, 8) === peg$c27) {
3159
- s1 = peg$c27;
3353
+ if (input.substr(peg$currPos, 8) === peg$c28) {
3354
+ s1 = peg$c28;
3160
3355
  peg$currPos += 8;
3161
3356
  } else {
3162
3357
  s1 = peg$FAILED;
3163
3358
  if (peg$silentFails === 0) {
3164
- peg$fail(peg$e30);
3359
+ peg$fail(peg$e31);
3165
3360
  }
3166
3361
  }
3167
3362
  if (s1 !== peg$FAILED) {
@@ -3196,7 +3391,7 @@ function peg$parse(input, options) {
3196
3391
  }
3197
3392
  if (s9 !== peg$FAILED) {
3198
3393
  peg$savedPos = s0;
3199
- s0 = peg$f26(s3, s7);
3394
+ s0 = peg$f27(s3, s7);
3200
3395
  } else {
3201
3396
  peg$currPos = s0;
3202
3397
  s0 = peg$FAILED;
@@ -3235,13 +3430,13 @@ function peg$parse(input, options) {
3235
3430
  function peg$parseCard() {
3236
3431
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3237
3432
  s0 = peg$currPos;
3238
- if (input.substr(peg$currPos, 4) === peg$c28) {
3239
- s1 = peg$c28;
3433
+ if (input.substr(peg$currPos, 4) === peg$c29) {
3434
+ s1 = peg$c29;
3240
3435
  peg$currPos += 4;
3241
3436
  } else {
3242
3437
  s1 = peg$FAILED;
3243
3438
  if (peg$silentFails === 0) {
3244
- peg$fail(peg$e31);
3439
+ peg$fail(peg$e32);
3245
3440
  }
3246
3441
  }
3247
3442
  if (s1 !== peg$FAILED) {
@@ -3281,7 +3476,7 @@ function peg$parse(input, options) {
3281
3476
  }
3282
3477
  if (s11 !== peg$FAILED) {
3283
3478
  peg$savedPos = s0;
3284
- s0 = peg$f27(s3, s5, s9);
3479
+ s0 = peg$f28(s3, s5, s9);
3285
3480
  } else {
3286
3481
  peg$currPos = s0;
3287
3482
  s0 = peg$FAILED;
@@ -3303,13 +3498,13 @@ function peg$parse(input, options) {
3303
3498
  function peg$parseModal() {
3304
3499
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3305
3500
  s0 = peg$currPos;
3306
- if (input.substr(peg$currPos, 5) === peg$c29) {
3307
- s1 = peg$c29;
3501
+ if (input.substr(peg$currPos, 5) === peg$c30) {
3502
+ s1 = peg$c30;
3308
3503
  peg$currPos += 5;
3309
3504
  } else {
3310
3505
  s1 = peg$FAILED;
3311
3506
  if (peg$silentFails === 0) {
3312
- peg$fail(peg$e32);
3507
+ peg$fail(peg$e33);
3313
3508
  }
3314
3509
  }
3315
3510
  if (s1 !== peg$FAILED) {
@@ -3349,7 +3544,7 @@ function peg$parse(input, options) {
3349
3544
  }
3350
3545
  if (s11 !== peg$FAILED) {
3351
3546
  peg$savedPos = s0;
3352
- s0 = peg$f28(s3, s5, s9);
3547
+ s0 = peg$f29(s3, s5, s9);
3353
3548
  } else {
3354
3549
  peg$currPos = s0;
3355
3550
  s0 = peg$FAILED;
@@ -3371,13 +3566,13 @@ function peg$parse(input, options) {
3371
3566
  function peg$parseDrawer() {
3372
3567
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3373
3568
  s0 = peg$currPos;
3374
- if (input.substr(peg$currPos, 6) === peg$c30) {
3375
- s1 = peg$c30;
3569
+ if (input.substr(peg$currPos, 6) === peg$c31) {
3570
+ s1 = peg$c31;
3376
3571
  peg$currPos += 6;
3377
3572
  } else {
3378
3573
  s1 = peg$FAILED;
3379
3574
  if (peg$silentFails === 0) {
3380
- peg$fail(peg$e33);
3575
+ peg$fail(peg$e34);
3381
3576
  }
3382
3577
  }
3383
3578
  if (s1 !== peg$FAILED) {
@@ -3417,7 +3612,7 @@ function peg$parse(input, options) {
3417
3612
  }
3418
3613
  if (s11 !== peg$FAILED) {
3419
3614
  peg$savedPos = s0;
3420
- s0 = peg$f29(s3, s5, s9);
3615
+ s0 = peg$f30(s3, s5, s9);
3421
3616
  } else {
3422
3617
  peg$currPos = s0;
3423
3618
  s0 = peg$FAILED;
@@ -3439,13 +3634,13 @@ function peg$parse(input, options) {
3439
3634
  function peg$parseAccordion() {
3440
3635
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3441
3636
  s0 = peg$currPos;
3442
- if (input.substr(peg$currPos, 9) === peg$c31) {
3443
- s1 = peg$c31;
3637
+ if (input.substr(peg$currPos, 9) === peg$c32) {
3638
+ s1 = peg$c32;
3444
3639
  peg$currPos += 9;
3445
3640
  } else {
3446
3641
  s1 = peg$FAILED;
3447
3642
  if (peg$silentFails === 0) {
3448
- peg$fail(peg$e34);
3643
+ peg$fail(peg$e35);
3449
3644
  }
3450
3645
  }
3451
3646
  if (s1 !== peg$FAILED) {
@@ -3485,7 +3680,7 @@ function peg$parse(input, options) {
3485
3680
  }
3486
3681
  if (s11 !== peg$FAILED) {
3487
3682
  peg$savedPos = s0;
3488
- s0 = peg$f30(s3, s5, s9);
3683
+ s0 = peg$f31(s3, s5, s9);
3489
3684
  } else {
3490
3685
  peg$currPos = s0;
3491
3686
  s0 = peg$FAILED;
@@ -3507,13 +3702,13 @@ function peg$parse(input, options) {
3507
3702
  function peg$parseSection() {
3508
3703
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3509
3704
  s0 = peg$currPos;
3510
- if (input.substr(peg$currPos, 7) === peg$c32) {
3511
- s1 = peg$c32;
3705
+ if (input.substr(peg$currPos, 7) === peg$c33) {
3706
+ s1 = peg$c33;
3512
3707
  peg$currPos += 7;
3513
3708
  } else {
3514
3709
  s1 = peg$FAILED;
3515
3710
  if (peg$silentFails === 0) {
3516
- peg$fail(peg$e35);
3711
+ peg$fail(peg$e36);
3517
3712
  }
3518
3713
  }
3519
3714
  if (s1 !== peg$FAILED) {
@@ -3553,7 +3748,7 @@ function peg$parse(input, options) {
3553
3748
  }
3554
3749
  if (s11 !== peg$FAILED) {
3555
3750
  peg$savedPos = s0;
3556
- s0 = peg$f31(s3, s5, s9);
3751
+ s0 = peg$f32(s3, s5, s9);
3557
3752
  } else {
3558
3753
  peg$currPos = s0;
3559
3754
  s0 = peg$FAILED;
@@ -3670,13 +3865,13 @@ function peg$parse(input, options) {
3670
3865
  function peg$parseText() {
3671
3866
  let s0, s1, s2, s3, s4, s5;
3672
3867
  s0 = peg$currPos;
3673
- if (input.substr(peg$currPos, 4) === peg$c33) {
3674
- s1 = peg$c33;
3868
+ if (input.substr(peg$currPos, 4) === peg$c34) {
3869
+ s1 = peg$c34;
3675
3870
  peg$currPos += 4;
3676
3871
  } else {
3677
3872
  s1 = peg$FAILED;
3678
3873
  if (peg$silentFails === 0) {
3679
- peg$fail(peg$e36);
3874
+ peg$fail(peg$e37);
3680
3875
  }
3681
3876
  }
3682
3877
  if (s1 !== peg$FAILED) {
@@ -3689,7 +3884,7 @@ function peg$parse(input, options) {
3689
3884
  s5 = null;
3690
3885
  }
3691
3886
  peg$savedPos = s0;
3692
- s0 = peg$f32(s3, s5);
3887
+ s0 = peg$f33(s3, s5);
3693
3888
  } else {
3694
3889
  peg$currPos = s0;
3695
3890
  s0 = peg$FAILED;
@@ -3703,13 +3898,13 @@ function peg$parse(input, options) {
3703
3898
  function peg$parseTitle() {
3704
3899
  let s0, s1, s2, s3, s4, s5;
3705
3900
  s0 = peg$currPos;
3706
- if (input.substr(peg$currPos, 5) === peg$c34) {
3707
- s1 = peg$c34;
3901
+ if (input.substr(peg$currPos, 5) === peg$c35) {
3902
+ s1 = peg$c35;
3708
3903
  peg$currPos += 5;
3709
3904
  } else {
3710
3905
  s1 = peg$FAILED;
3711
3906
  if (peg$silentFails === 0) {
3712
- peg$fail(peg$e37);
3907
+ peg$fail(peg$e38);
3713
3908
  }
3714
3909
  }
3715
3910
  if (s1 !== peg$FAILED) {
@@ -3722,7 +3917,7 @@ function peg$parse(input, options) {
3722
3917
  s5 = null;
3723
3918
  }
3724
3919
  peg$savedPos = s0;
3725
- s0 = peg$f33(s3, s5);
3920
+ s0 = peg$f34(s3, s5);
3726
3921
  } else {
3727
3922
  peg$currPos = s0;
3728
3923
  s0 = peg$FAILED;
@@ -3736,13 +3931,13 @@ function peg$parse(input, options) {
3736
3931
  function peg$parseLink() {
3737
3932
  let s0, s1, s2, s3, s4, s5;
3738
3933
  s0 = peg$currPos;
3739
- if (input.substr(peg$currPos, 4) === peg$c35) {
3740
- s1 = peg$c35;
3934
+ if (input.substr(peg$currPos, 4) === peg$c36) {
3935
+ s1 = peg$c36;
3741
3936
  peg$currPos += 4;
3742
3937
  } else {
3743
3938
  s1 = peg$FAILED;
3744
3939
  if (peg$silentFails === 0) {
3745
- peg$fail(peg$e38);
3940
+ peg$fail(peg$e39);
3746
3941
  }
3747
3942
  }
3748
3943
  if (s1 !== peg$FAILED) {
@@ -3755,7 +3950,7 @@ function peg$parse(input, options) {
3755
3950
  s5 = null;
3756
3951
  }
3757
3952
  peg$savedPos = s0;
3758
- s0 = peg$f34(s3, s5);
3953
+ s0 = peg$f35(s3, s5);
3759
3954
  } else {
3760
3955
  peg$currPos = s0;
3761
3956
  s0 = peg$FAILED;
@@ -3769,13 +3964,13 @@ function peg$parse(input, options) {
3769
3964
  function peg$parseButton() {
3770
3965
  let s0, s1, s2, s3, s4, s5;
3771
3966
  s0 = peg$currPos;
3772
- if (input.substr(peg$currPos, 6) === peg$c36) {
3773
- s1 = peg$c36;
3967
+ if (input.substr(peg$currPos, 6) === peg$c37) {
3968
+ s1 = peg$c37;
3774
3969
  peg$currPos += 6;
3775
3970
  } else {
3776
3971
  s1 = peg$FAILED;
3777
3972
  if (peg$silentFails === 0) {
3778
- peg$fail(peg$e39);
3973
+ peg$fail(peg$e40);
3779
3974
  }
3780
3975
  }
3781
3976
  if (s1 !== peg$FAILED) {
@@ -3788,7 +3983,7 @@ function peg$parse(input, options) {
3788
3983
  s5 = null;
3789
3984
  }
3790
3985
  peg$savedPos = s0;
3791
- s0 = peg$f35(s3, s5);
3986
+ s0 = peg$f36(s3, s5);
3792
3987
  } else {
3793
3988
  peg$currPos = s0;
3794
3989
  s0 = peg$FAILED;
@@ -3802,13 +3997,13 @@ function peg$parse(input, options) {
3802
3997
  function peg$parseInput() {
3803
3998
  let s0, s1, s2, s3, s4, s5;
3804
3999
  s0 = peg$currPos;
3805
- if (input.substr(peg$currPos, 5) === peg$c37) {
3806
- s1 = peg$c37;
4000
+ if (input.substr(peg$currPos, 5) === peg$c38) {
4001
+ s1 = peg$c38;
3807
4002
  peg$currPos += 5;
3808
4003
  } else {
3809
4004
  s1 = peg$FAILED;
3810
4005
  if (peg$silentFails === 0) {
3811
- peg$fail(peg$e40);
4006
+ peg$fail(peg$e41);
3812
4007
  }
3813
4008
  }
3814
4009
  if (s1 !== peg$FAILED) {
@@ -3823,7 +4018,7 @@ function peg$parse(input, options) {
3823
4018
  s5 = null;
3824
4019
  }
3825
4020
  peg$savedPos = s0;
3826
- s0 = peg$f36(s3, s5);
4021
+ s0 = peg$f37(s3, s5);
3827
4022
  } else {
3828
4023
  peg$currPos = s0;
3829
4024
  s0 = peg$FAILED;
@@ -3833,13 +4028,13 @@ function peg$parse(input, options) {
3833
4028
  function peg$parseTextarea() {
3834
4029
  let s0, s1, s2, s3, s4, s5;
3835
4030
  s0 = peg$currPos;
3836
- if (input.substr(peg$currPos, 8) === peg$c38) {
3837
- s1 = peg$c38;
4031
+ if (input.substr(peg$currPos, 8) === peg$c39) {
4032
+ s1 = peg$c39;
3838
4033
  peg$currPos += 8;
3839
4034
  } else {
3840
4035
  s1 = peg$FAILED;
3841
4036
  if (peg$silentFails === 0) {
3842
- peg$fail(peg$e41);
4037
+ peg$fail(peg$e42);
3843
4038
  }
3844
4039
  }
3845
4040
  if (s1 !== peg$FAILED) {
@@ -3854,7 +4049,7 @@ function peg$parse(input, options) {
3854
4049
  s5 = null;
3855
4050
  }
3856
4051
  peg$savedPos = s0;
3857
- s0 = peg$f37(s3, s5);
4052
+ s0 = peg$f38(s3, s5);
3858
4053
  } else {
3859
4054
  peg$currPos = s0;
3860
4055
  s0 = peg$FAILED;
@@ -3864,13 +4059,13 @@ function peg$parse(input, options) {
3864
4059
  function peg$parseSelect() {
3865
4060
  let s0, s1, s2, s3, s4, s5, s6, s7;
3866
4061
  s0 = peg$currPos;
3867
- if (input.substr(peg$currPos, 6) === peg$c39) {
3868
- s1 = peg$c39;
4062
+ if (input.substr(peg$currPos, 6) === peg$c40) {
4063
+ s1 = peg$c40;
3869
4064
  peg$currPos += 6;
3870
4065
  } else {
3871
4066
  s1 = peg$FAILED;
3872
4067
  if (peg$silentFails === 0) {
3873
- peg$fail(peg$e42);
4068
+ peg$fail(peg$e43);
3874
4069
  }
3875
4070
  }
3876
4071
  if (s1 !== peg$FAILED) {
@@ -3890,7 +4085,7 @@ function peg$parse(input, options) {
3890
4085
  s7 = null;
3891
4086
  }
3892
4087
  peg$savedPos = s0;
3893
- s0 = peg$f38(s3, s5, s7);
4088
+ s0 = peg$f39(s3, s5, s7);
3894
4089
  } else {
3895
4090
  peg$currPos = s0;
3896
4091
  s0 = peg$FAILED;
@@ -3900,13 +4095,13 @@ function peg$parse(input, options) {
3900
4095
  function peg$parseCheckbox() {
3901
4096
  let s0, s1, s2, s3, s4, s5;
3902
4097
  s0 = peg$currPos;
3903
- if (input.substr(peg$currPos, 8) === peg$c40) {
3904
- s1 = peg$c40;
4098
+ if (input.substr(peg$currPos, 8) === peg$c41) {
4099
+ s1 = peg$c41;
3905
4100
  peg$currPos += 8;
3906
4101
  } else {
3907
4102
  s1 = peg$FAILED;
3908
4103
  if (peg$silentFails === 0) {
3909
- peg$fail(peg$e43);
4104
+ peg$fail(peg$e44);
3910
4105
  }
3911
4106
  }
3912
4107
  if (s1 !== peg$FAILED) {
@@ -3921,7 +4116,7 @@ function peg$parse(input, options) {
3921
4116
  s5 = null;
3922
4117
  }
3923
4118
  peg$savedPos = s0;
3924
- s0 = peg$f39(s3, s5);
4119
+ s0 = peg$f40(s3, s5);
3925
4120
  } else {
3926
4121
  peg$currPos = s0;
3927
4122
  s0 = peg$FAILED;
@@ -3931,13 +4126,13 @@ function peg$parse(input, options) {
3931
4126
  function peg$parseRadio() {
3932
4127
  let s0, s1, s2, s3, s4, s5;
3933
4128
  s0 = peg$currPos;
3934
- if (input.substr(peg$currPos, 5) === peg$c41) {
3935
- s1 = peg$c41;
4129
+ if (input.substr(peg$currPos, 5) === peg$c42) {
4130
+ s1 = peg$c42;
3936
4131
  peg$currPos += 5;
3937
4132
  } else {
3938
4133
  s1 = peg$FAILED;
3939
4134
  if (peg$silentFails === 0) {
3940
- peg$fail(peg$e44);
4135
+ peg$fail(peg$e45);
3941
4136
  }
3942
4137
  }
3943
4138
  if (s1 !== peg$FAILED) {
@@ -3952,7 +4147,7 @@ function peg$parse(input, options) {
3952
4147
  s5 = null;
3953
4148
  }
3954
4149
  peg$savedPos = s0;
3955
- s0 = peg$f40(s3, s5);
4150
+ s0 = peg$f41(s3, s5);
3956
4151
  } else {
3957
4152
  peg$currPos = s0;
3958
4153
  s0 = peg$FAILED;
@@ -3962,13 +4157,13 @@ function peg$parse(input, options) {
3962
4157
  function peg$parseSwitch() {
3963
4158
  let s0, s1, s2, s3, s4, s5;
3964
4159
  s0 = peg$currPos;
3965
- if (input.substr(peg$currPos, 6) === peg$c42) {
3966
- s1 = peg$c42;
4160
+ if (input.substr(peg$currPos, 6) === peg$c43) {
4161
+ s1 = peg$c43;
3967
4162
  peg$currPos += 6;
3968
4163
  } else {
3969
4164
  s1 = peg$FAILED;
3970
4165
  if (peg$silentFails === 0) {
3971
- peg$fail(peg$e45);
4166
+ peg$fail(peg$e46);
3972
4167
  }
3973
4168
  }
3974
4169
  if (s1 !== peg$FAILED) {
@@ -3983,7 +4178,7 @@ function peg$parse(input, options) {
3983
4178
  s5 = null;
3984
4179
  }
3985
4180
  peg$savedPos = s0;
3986
- s0 = peg$f41(s3, s5);
4181
+ s0 = peg$f42(s3, s5);
3987
4182
  } else {
3988
4183
  peg$currPos = s0;
3989
4184
  s0 = peg$FAILED;
@@ -3993,13 +4188,13 @@ function peg$parse(input, options) {
3993
4188
  function peg$parseSlider() {
3994
4189
  let s0, s1, s2, s3, s4, s5;
3995
4190
  s0 = peg$currPos;
3996
- if (input.substr(peg$currPos, 6) === peg$c43) {
3997
- s1 = peg$c43;
4191
+ if (input.substr(peg$currPos, 6) === peg$c44) {
4192
+ s1 = peg$c44;
3998
4193
  peg$currPos += 6;
3999
4194
  } else {
4000
4195
  s1 = peg$FAILED;
4001
4196
  if (peg$silentFails === 0) {
4002
- peg$fail(peg$e46);
4197
+ peg$fail(peg$e47);
4003
4198
  }
4004
4199
  }
4005
4200
  if (s1 !== peg$FAILED) {
@@ -4014,7 +4209,7 @@ function peg$parse(input, options) {
4014
4209
  s5 = null;
4015
4210
  }
4016
4211
  peg$savedPos = s0;
4017
- s0 = peg$f42(s3, s5);
4212
+ s0 = peg$f43(s3, s5);
4018
4213
  } else {
4019
4214
  peg$currPos = s0;
4020
4215
  s0 = peg$FAILED;
@@ -4024,13 +4219,13 @@ function peg$parse(input, options) {
4024
4219
  function peg$parseImage() {
4025
4220
  let s0, s1, s2, s3, s4, s5;
4026
4221
  s0 = peg$currPos;
4027
- if (input.substr(peg$currPos, 5) === peg$c44) {
4028
- s1 = peg$c44;
4222
+ if (input.substr(peg$currPos, 5) === peg$c45) {
4223
+ s1 = peg$c45;
4029
4224
  peg$currPos += 5;
4030
4225
  } else {
4031
4226
  s1 = peg$FAILED;
4032
4227
  if (peg$silentFails === 0) {
4033
- peg$fail(peg$e47);
4228
+ peg$fail(peg$e48);
4034
4229
  }
4035
4230
  }
4036
4231
  if (s1 !== peg$FAILED) {
@@ -4045,7 +4240,7 @@ function peg$parse(input, options) {
4045
4240
  s5 = null;
4046
4241
  }
4047
4242
  peg$savedPos = s0;
4048
- s0 = peg$f43(s3, s5);
4243
+ s0 = peg$f44(s3, s5);
4049
4244
  } else {
4050
4245
  peg$currPos = s0;
4051
4246
  s0 = peg$FAILED;
@@ -4055,13 +4250,13 @@ function peg$parse(input, options) {
4055
4250
  function peg$parsePlaceholder() {
4056
4251
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
4057
4252
  s0 = peg$currPos;
4058
- if (input.substr(peg$currPos, 11) === peg$c45) {
4059
- s1 = peg$c45;
4253
+ if (input.substr(peg$currPos, 11) === peg$c46) {
4254
+ s1 = peg$c46;
4060
4255
  peg$currPos += 11;
4061
4256
  } else {
4062
4257
  s1 = peg$FAILED;
4063
4258
  if (peg$silentFails === 0) {
4064
- peg$fail(peg$e48);
4259
+ peg$fail(peg$e49);
4065
4260
  }
4066
4261
  }
4067
4262
  if (s1 !== peg$FAILED) {
@@ -4119,7 +4314,7 @@ function peg$parse(input, options) {
4119
4314
  s7 = null;
4120
4315
  }
4121
4316
  peg$savedPos = s0;
4122
- s0 = peg$f44(s3, s5, s7);
4317
+ s0 = peg$f45(s3, s5, s7);
4123
4318
  } else {
4124
4319
  peg$currPos = s0;
4125
4320
  s0 = peg$FAILED;
@@ -4129,13 +4324,13 @@ function peg$parse(input, options) {
4129
4324
  function peg$parseAvatar() {
4130
4325
  let s0, s1, s2, s3, s4, s5;
4131
4326
  s0 = peg$currPos;
4132
- if (input.substr(peg$currPos, 6) === peg$c46) {
4133
- s1 = peg$c46;
4327
+ if (input.substr(peg$currPos, 6) === peg$c47) {
4328
+ s1 = peg$c47;
4134
4329
  peg$currPos += 6;
4135
4330
  } else {
4136
4331
  s1 = peg$FAILED;
4137
4332
  if (peg$silentFails === 0) {
4138
- peg$fail(peg$e49);
4333
+ peg$fail(peg$e50);
4139
4334
  }
4140
4335
  }
4141
4336
  if (s1 !== peg$FAILED) {
@@ -4150,7 +4345,7 @@ function peg$parse(input, options) {
4150
4345
  s5 = null;
4151
4346
  }
4152
4347
  peg$savedPos = s0;
4153
- s0 = peg$f45(s3, s5);
4348
+ s0 = peg$f46(s3, s5);
4154
4349
  } else {
4155
4350
  peg$currPos = s0;
4156
4351
  s0 = peg$FAILED;
@@ -4160,13 +4355,13 @@ function peg$parse(input, options) {
4160
4355
  function peg$parseBadge() {
4161
4356
  let s0, s1, s2, s3, s4, s5;
4162
4357
  s0 = peg$currPos;
4163
- if (input.substr(peg$currPos, 5) === peg$c47) {
4164
- s1 = peg$c47;
4358
+ if (input.substr(peg$currPos, 5) === peg$c48) {
4359
+ s1 = peg$c48;
4165
4360
  peg$currPos += 5;
4166
4361
  } else {
4167
4362
  s1 = peg$FAILED;
4168
4363
  if (peg$silentFails === 0) {
4169
- peg$fail(peg$e50);
4364
+ peg$fail(peg$e51);
4170
4365
  }
4171
4366
  }
4172
4367
  if (s1 !== peg$FAILED) {
@@ -4179,7 +4374,7 @@ function peg$parse(input, options) {
4179
4374
  s5 = null;
4180
4375
  }
4181
4376
  peg$savedPos = s0;
4182
- s0 = peg$f46(s3, s5);
4377
+ s0 = peg$f47(s3, s5);
4183
4378
  } else {
4184
4379
  peg$currPos = s0;
4185
4380
  s0 = peg$FAILED;
@@ -4193,13 +4388,13 @@ function peg$parse(input, options) {
4193
4388
  function peg$parseIcon() {
4194
4389
  let s0, s1, s2, s3, s4, s5;
4195
4390
  s0 = peg$currPos;
4196
- if (input.substr(peg$currPos, 4) === peg$c48) {
4197
- s1 = peg$c48;
4391
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4392
+ s1 = peg$c49;
4198
4393
  peg$currPos += 4;
4199
4394
  } else {
4200
4395
  s1 = peg$FAILED;
4201
4396
  if (peg$silentFails === 0) {
4202
- peg$fail(peg$e51);
4397
+ peg$fail(peg$e52);
4203
4398
  }
4204
4399
  }
4205
4400
  if (s1 !== peg$FAILED) {
@@ -4212,7 +4407,7 @@ function peg$parse(input, options) {
4212
4407
  s5 = null;
4213
4408
  }
4214
4409
  peg$savedPos = s0;
4215
- s0 = peg$f47(s3, s5);
4410
+ s0 = peg$f48(s3, s5);
4216
4411
  } else {
4217
4412
  peg$currPos = s0;
4218
4413
  s0 = peg$FAILED;
@@ -4226,13 +4421,13 @@ function peg$parse(input, options) {
4226
4421
  function peg$parseTable() {
4227
4422
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4228
4423
  s0 = peg$currPos;
4229
- if (input.substr(peg$currPos, 5) === peg$c49) {
4230
- s1 = peg$c49;
4424
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4425
+ s1 = peg$c50;
4231
4426
  peg$currPos += 5;
4232
4427
  } else {
4233
4428
  s1 = peg$FAILED;
4234
4429
  if (peg$silentFails === 0) {
4235
- peg$fail(peg$e52);
4430
+ peg$fail(peg$e53);
4236
4431
  }
4237
4432
  }
4238
4433
  if (s1 !== peg$FAILED) {
@@ -4245,7 +4440,7 @@ function peg$parse(input, options) {
4245
4440
  s5 = null;
4246
4441
  }
4247
4442
  peg$savedPos = s0;
4248
- s0 = peg$f48(s3, s5);
4443
+ s0 = peg$f49(s3, s5);
4249
4444
  } else {
4250
4445
  peg$currPos = s0;
4251
4446
  s0 = peg$FAILED;
@@ -4256,13 +4451,13 @@ function peg$parse(input, options) {
4256
4451
  }
4257
4452
  if (s0 === peg$FAILED) {
4258
4453
  s0 = peg$currPos;
4259
- if (input.substr(peg$currPos, 5) === peg$c49) {
4260
- s1 = peg$c49;
4454
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4455
+ s1 = peg$c50;
4261
4456
  peg$currPos += 5;
4262
4457
  } else {
4263
4458
  s1 = peg$FAILED;
4264
4459
  if (peg$silentFails === 0) {
4265
- peg$fail(peg$e52);
4460
+ peg$fail(peg$e53);
4266
4461
  }
4267
4462
  }
4268
4463
  if (s1 !== peg$FAILED) {
@@ -4296,7 +4491,7 @@ function peg$parse(input, options) {
4296
4491
  }
4297
4492
  if (s9 !== peg$FAILED) {
4298
4493
  peg$savedPos = s0;
4299
- s0 = peg$f49(s3, s7);
4494
+ s0 = peg$f50(s3, s7);
4300
4495
  } else {
4301
4496
  peg$currPos = s0;
4302
4497
  s0 = peg$FAILED;
@@ -4316,12 +4511,12 @@ function peg$parse(input, options) {
4316
4511
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
4317
4512
  s0 = peg$currPos;
4318
4513
  if (input.charCodeAt(peg$currPos) === 91) {
4319
- s1 = peg$c50;
4514
+ s1 = peg$c51;
4320
4515
  peg$currPos++;
4321
4516
  } else {
4322
4517
  s1 = peg$FAILED;
4323
4518
  if (peg$silentFails === 0) {
4324
- peg$fail(peg$e53);
4519
+ peg$fail(peg$e54);
4325
4520
  }
4326
4521
  }
4327
4522
  if (s1 !== peg$FAILED) {
@@ -4397,17 +4592,17 @@ function peg$parse(input, options) {
4397
4592
  }
4398
4593
  s7 = peg$parse_();
4399
4594
  if (input.charCodeAt(peg$currPos) === 93) {
4400
- s8 = peg$c51;
4595
+ s8 = peg$c52;
4401
4596
  peg$currPos++;
4402
4597
  } else {
4403
4598
  s8 = peg$FAILED;
4404
4599
  if (peg$silentFails === 0) {
4405
- peg$fail(peg$e54);
4600
+ peg$fail(peg$e55);
4406
4601
  }
4407
4602
  }
4408
4603
  if (s8 !== peg$FAILED) {
4409
4604
  peg$savedPos = s0;
4410
- s0 = peg$f50(s3, s5);
4605
+ s0 = peg$f51(s3, s5);
4411
4606
  } else {
4412
4607
  peg$currPos = s0;
4413
4608
  s0 = peg$FAILED;
@@ -4450,20 +4645,20 @@ function peg$parse(input, options) {
4450
4645
  }
4451
4646
  }
4452
4647
  peg$savedPos = s0;
4453
- s1 = peg$f51(s1);
4648
+ s1 = peg$f52(s1);
4454
4649
  s0 = s1;
4455
4650
  return s0;
4456
4651
  }
4457
4652
  function peg$parseTableRow() {
4458
4653
  let s0, s1, s2, s3;
4459
4654
  s0 = peg$currPos;
4460
- if (input.substr(peg$currPos, 7) === peg$c52) {
4461
- s1 = peg$c52;
4655
+ if (input.substr(peg$currPos, 7) === peg$c53) {
4656
+ s1 = peg$c53;
4462
4657
  peg$currPos += 7;
4463
4658
  } else {
4464
4659
  s1 = peg$FAILED;
4465
4660
  if (peg$silentFails === 0) {
4466
- peg$fail(peg$e55);
4661
+ peg$fail(peg$e56);
4467
4662
  }
4468
4663
  }
4469
4664
  if (s1 !== peg$FAILED) {
@@ -4471,7 +4666,7 @@ function peg$parse(input, options) {
4471
4666
  s3 = peg$parseArray();
4472
4667
  if (s3 !== peg$FAILED) {
4473
4668
  peg$savedPos = s0;
4474
- s0 = peg$f52(s3);
4669
+ s0 = peg$f53(s3);
4475
4670
  } else {
4476
4671
  peg$currPos = s0;
4477
4672
  s0 = peg$FAILED;
@@ -4482,13 +4677,13 @@ function peg$parse(input, options) {
4482
4677
  }
4483
4678
  if (s0 === peg$FAILED) {
4484
4679
  s0 = peg$currPos;
4485
- if (input.substr(peg$currPos, 3) === peg$c24) {
4486
- s1 = peg$c24;
4680
+ if (input.substr(peg$currPos, 3) === peg$c25) {
4681
+ s1 = peg$c25;
4487
4682
  peg$currPos += 3;
4488
4683
  } else {
4489
4684
  s1 = peg$FAILED;
4490
4685
  if (peg$silentFails === 0) {
4491
- peg$fail(peg$e27);
4686
+ peg$fail(peg$e28);
4492
4687
  }
4493
4688
  }
4494
4689
  if (s1 !== peg$FAILED) {
@@ -4496,7 +4691,7 @@ function peg$parse(input, options) {
4496
4691
  s3 = peg$parseArray();
4497
4692
  if (s3 !== peg$FAILED) {
4498
4693
  peg$savedPos = s0;
4499
- s0 = peg$f53(s3);
4694
+ s0 = peg$f54(s3);
4500
4695
  } else {
4501
4696
  peg$currPos = s0;
4502
4697
  s0 = peg$FAILED;
@@ -4510,7 +4705,7 @@ function peg$parse(input, options) {
4510
4705
  s1 = peg$parseComment();
4511
4706
  if (s1 !== peg$FAILED) {
4512
4707
  peg$savedPos = s0;
4513
- s1 = peg$f54();
4708
+ s1 = peg$f55();
4514
4709
  }
4515
4710
  s0 = s1;
4516
4711
  }
@@ -4520,13 +4715,13 @@ function peg$parse(input, options) {
4520
4715
  function peg$parseList() {
4521
4716
  let s0, s1, s2, s3, s4, s5, s6, s7;
4522
4717
  s0 = peg$currPos;
4523
- if (input.substr(peg$currPos, 4) === peg$c53) {
4524
- s1 = peg$c53;
4718
+ if (input.substr(peg$currPos, 4) === peg$c54) {
4719
+ s1 = peg$c54;
4525
4720
  peg$currPos += 4;
4526
4721
  } else {
4527
4722
  s1 = peg$FAILED;
4528
4723
  if (peg$silentFails === 0) {
4529
- peg$fail(peg$e56);
4724
+ peg$fail(peg$e57);
4530
4725
  }
4531
4726
  }
4532
4727
  if (s1 !== peg$FAILED) {
@@ -4546,7 +4741,7 @@ function peg$parse(input, options) {
4546
4741
  s7 = null;
4547
4742
  }
4548
4743
  peg$savedPos = s0;
4549
- s0 = peg$f55(s3, s5, s7);
4744
+ s0 = peg$f56(s3, s5, s7);
4550
4745
  } else {
4551
4746
  peg$currPos = s0;
4552
4747
  s0 = peg$FAILED;
@@ -4602,7 +4797,7 @@ function peg$parse(input, options) {
4602
4797
  }
4603
4798
  if (s4 !== peg$FAILED) {
4604
4799
  peg$savedPos = s0;
4605
- s0 = peg$f56(s3);
4800
+ s0 = peg$f57(s3);
4606
4801
  } else {
4607
4802
  peg$currPos = s0;
4608
4803
  s0 = peg$FAILED;
@@ -4616,13 +4811,13 @@ function peg$parse(input, options) {
4616
4811
  function peg$parseListItem() {
4617
4812
  let s0, s1, s2, s3, s4, s5, s6, s7;
4618
4813
  s0 = peg$currPos;
4619
- if (input.substr(peg$currPos, 4) === peg$c54) {
4620
- s1 = peg$c54;
4814
+ if (input.substr(peg$currPos, 4) === peg$c55) {
4815
+ s1 = peg$c55;
4621
4816
  peg$currPos += 4;
4622
4817
  } else {
4623
4818
  s1 = peg$FAILED;
4624
4819
  if (peg$silentFails === 0) {
4625
- peg$fail(peg$e57);
4820
+ peg$fail(peg$e58);
4626
4821
  }
4627
4822
  }
4628
4823
  if (s1 !== peg$FAILED) {
@@ -4640,7 +4835,7 @@ function peg$parse(input, options) {
4640
4835
  s7 = null;
4641
4836
  }
4642
4837
  peg$savedPos = s0;
4643
- s0 = peg$f57(s3, s5, s7);
4838
+ s0 = peg$f58(s3, s5, s7);
4644
4839
  } else {
4645
4840
  peg$currPos = s0;
4646
4841
  s0 = peg$FAILED;
@@ -4654,7 +4849,7 @@ function peg$parse(input, options) {
4654
4849
  s1 = peg$parseComment();
4655
4850
  if (s1 !== peg$FAILED) {
4656
4851
  peg$savedPos = s0;
4657
- s1 = peg$f58();
4852
+ s1 = peg$f59();
4658
4853
  }
4659
4854
  s0 = s1;
4660
4855
  }
@@ -4663,13 +4858,13 @@ function peg$parse(input, options) {
4663
4858
  function peg$parseAlert() {
4664
4859
  let s0, s1, s2, s3, s4, s5;
4665
4860
  s0 = peg$currPos;
4666
- if (input.substr(peg$currPos, 5) === peg$c55) {
4667
- s1 = peg$c55;
4861
+ if (input.substr(peg$currPos, 5) === peg$c56) {
4862
+ s1 = peg$c56;
4668
4863
  peg$currPos += 5;
4669
4864
  } else {
4670
4865
  s1 = peg$FAILED;
4671
4866
  if (peg$silentFails === 0) {
4672
- peg$fail(peg$e58);
4867
+ peg$fail(peg$e59);
4673
4868
  }
4674
4869
  }
4675
4870
  if (s1 !== peg$FAILED) {
@@ -4682,7 +4877,7 @@ function peg$parse(input, options) {
4682
4877
  s5 = null;
4683
4878
  }
4684
4879
  peg$savedPos = s0;
4685
- s0 = peg$f59(s3, s5);
4880
+ s0 = peg$f60(s3, s5);
4686
4881
  } else {
4687
4882
  peg$currPos = s0;
4688
4883
  s0 = peg$FAILED;
@@ -4696,13 +4891,13 @@ function peg$parse(input, options) {
4696
4891
  function peg$parseToast() {
4697
4892
  let s0, s1, s2, s3, s4, s5;
4698
4893
  s0 = peg$currPos;
4699
- if (input.substr(peg$currPos, 5) === peg$c56) {
4700
- s1 = peg$c56;
4894
+ if (input.substr(peg$currPos, 5) === peg$c57) {
4895
+ s1 = peg$c57;
4701
4896
  peg$currPos += 5;
4702
4897
  } else {
4703
4898
  s1 = peg$FAILED;
4704
4899
  if (peg$silentFails === 0) {
4705
- peg$fail(peg$e59);
4900
+ peg$fail(peg$e60);
4706
4901
  }
4707
4902
  }
4708
4903
  if (s1 !== peg$FAILED) {
@@ -4715,7 +4910,7 @@ function peg$parse(input, options) {
4715
4910
  s5 = null;
4716
4911
  }
4717
4912
  peg$savedPos = s0;
4718
- s0 = peg$f60(s3, s5);
4913
+ s0 = peg$f61(s3, s5);
4719
4914
  } else {
4720
4915
  peg$currPos = s0;
4721
4916
  s0 = peg$FAILED;
@@ -4729,13 +4924,13 @@ function peg$parse(input, options) {
4729
4924
  function peg$parseProgress() {
4730
4925
  let s0, s1, s2, s3;
4731
4926
  s0 = peg$currPos;
4732
- if (input.substr(peg$currPos, 8) === peg$c57) {
4733
- s1 = peg$c57;
4927
+ if (input.substr(peg$currPos, 8) === peg$c58) {
4928
+ s1 = peg$c58;
4734
4929
  peg$currPos += 8;
4735
4930
  } else {
4736
4931
  s1 = peg$FAILED;
4737
4932
  if (peg$silentFails === 0) {
4738
- peg$fail(peg$e60);
4933
+ peg$fail(peg$e61);
4739
4934
  }
4740
4935
  }
4741
4936
  if (s1 !== peg$FAILED) {
@@ -4745,7 +4940,7 @@ function peg$parse(input, options) {
4745
4940
  s3 = null;
4746
4941
  }
4747
4942
  peg$savedPos = s0;
4748
- s0 = peg$f61(s3);
4943
+ s0 = peg$f62(s3);
4749
4944
  } else {
4750
4945
  peg$currPos = s0;
4751
4946
  s0 = peg$FAILED;
@@ -4755,13 +4950,13 @@ function peg$parse(input, options) {
4755
4950
  function peg$parseSpinner() {
4756
4951
  let s0, s1, s2, s3, s4, s5;
4757
4952
  s0 = peg$currPos;
4758
- if (input.substr(peg$currPos, 7) === peg$c58) {
4759
- s1 = peg$c58;
4953
+ if (input.substr(peg$currPos, 7) === peg$c59) {
4954
+ s1 = peg$c59;
4760
4955
  peg$currPos += 7;
4761
4956
  } else {
4762
4957
  s1 = peg$FAILED;
4763
4958
  if (peg$silentFails === 0) {
4764
- peg$fail(peg$e61);
4959
+ peg$fail(peg$e62);
4765
4960
  }
4766
4961
  }
4767
4962
  if (s1 !== peg$FAILED) {
@@ -4776,7 +4971,7 @@ function peg$parse(input, options) {
4776
4971
  s5 = null;
4777
4972
  }
4778
4973
  peg$savedPos = s0;
4779
- s0 = peg$f62(s3, s5);
4974
+ s0 = peg$f63(s3, s5);
4780
4975
  } else {
4781
4976
  peg$currPos = s0;
4782
4977
  s0 = peg$FAILED;
@@ -4786,13 +4981,13 @@ function peg$parse(input, options) {
4786
4981
  function peg$parseTooltip() {
4787
4982
  let s0, s1, s2, s3, s4, s5;
4788
4983
  s0 = peg$currPos;
4789
- if (input.substr(peg$currPos, 7) === peg$c59) {
4790
- s1 = peg$c59;
4984
+ if (input.substr(peg$currPos, 7) === peg$c60) {
4985
+ s1 = peg$c60;
4791
4986
  peg$currPos += 7;
4792
4987
  } else {
4793
4988
  s1 = peg$FAILED;
4794
4989
  if (peg$silentFails === 0) {
4795
- peg$fail(peg$e62);
4990
+ peg$fail(peg$e63);
4796
4991
  }
4797
4992
  }
4798
4993
  if (s1 !== peg$FAILED) {
@@ -4805,7 +5000,7 @@ function peg$parse(input, options) {
4805
5000
  s5 = null;
4806
5001
  }
4807
5002
  peg$savedPos = s0;
4808
- s0 = peg$f63(s3, s5);
5003
+ s0 = peg$f64(s3, s5);
4809
5004
  } else {
4810
5005
  peg$currPos = s0;
4811
5006
  s0 = peg$FAILED;
@@ -4819,13 +5014,13 @@ function peg$parse(input, options) {
4819
5014
  function peg$parsePopover() {
4820
5015
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
4821
5016
  s0 = peg$currPos;
4822
- if (input.substr(peg$currPos, 7) === peg$c60) {
4823
- s1 = peg$c60;
5017
+ if (input.substr(peg$currPos, 7) === peg$c61) {
5018
+ s1 = peg$c61;
4824
5019
  peg$currPos += 7;
4825
5020
  } else {
4826
5021
  s1 = peg$FAILED;
4827
5022
  if (peg$silentFails === 0) {
4828
- peg$fail(peg$e63);
5023
+ peg$fail(peg$e64);
4829
5024
  }
4830
5025
  }
4831
5026
  if (s1 !== peg$FAILED) {
@@ -4865,7 +5060,7 @@ function peg$parse(input, options) {
4865
5060
  }
4866
5061
  if (s11 !== peg$FAILED) {
4867
5062
  peg$savedPos = s0;
4868
- s0 = peg$f64(s3, s5, s9);
5063
+ s0 = peg$f65(s3, s5, s9);
4869
5064
  } else {
4870
5065
  peg$currPos = s0;
4871
5066
  s0 = peg$FAILED;
@@ -4887,13 +5082,13 @@ function peg$parse(input, options) {
4887
5082
  function peg$parseDropdown() {
4888
5083
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4889
5084
  s0 = peg$currPos;
4890
- if (input.substr(peg$currPos, 8) === peg$c61) {
4891
- s1 = peg$c61;
5085
+ if (input.substr(peg$currPos, 8) === peg$c62) {
5086
+ s1 = peg$c62;
4892
5087
  peg$currPos += 8;
4893
5088
  } else {
4894
5089
  s1 = peg$FAILED;
4895
5090
  if (peg$silentFails === 0) {
4896
- peg$fail(peg$e64);
5091
+ peg$fail(peg$e65);
4897
5092
  }
4898
5093
  }
4899
5094
  if (s1 !== peg$FAILED) {
@@ -4906,7 +5101,7 @@ function peg$parse(input, options) {
4906
5101
  s5 = null;
4907
5102
  }
4908
5103
  peg$savedPos = s0;
4909
- s0 = peg$f65(s3, s5);
5104
+ s0 = peg$f66(s3, s5);
4910
5105
  } else {
4911
5106
  peg$currPos = s0;
4912
5107
  s0 = peg$FAILED;
@@ -4917,13 +5112,13 @@ function peg$parse(input, options) {
4917
5112
  }
4918
5113
  if (s0 === peg$FAILED) {
4919
5114
  s0 = peg$currPos;
4920
- if (input.substr(peg$currPos, 8) === peg$c61) {
4921
- s1 = peg$c61;
5115
+ if (input.substr(peg$currPos, 8) === peg$c62) {
5116
+ s1 = peg$c62;
4922
5117
  peg$currPos += 8;
4923
5118
  } else {
4924
5119
  s1 = peg$FAILED;
4925
5120
  if (peg$silentFails === 0) {
4926
- peg$fail(peg$e64);
5121
+ peg$fail(peg$e65);
4927
5122
  }
4928
5123
  }
4929
5124
  if (s1 !== peg$FAILED) {
@@ -4957,7 +5152,7 @@ function peg$parse(input, options) {
4957
5152
  }
4958
5153
  if (s9 !== peg$FAILED) {
4959
5154
  peg$savedPos = s0;
4960
- s0 = peg$f66(s3, s7);
5155
+ s0 = peg$f67(s3, s7);
4961
5156
  } else {
4962
5157
  peg$currPos = s0;
4963
5158
  s0 = peg$FAILED;
@@ -5001,20 +5196,20 @@ function peg$parse(input, options) {
5001
5196
  }
5002
5197
  }
5003
5198
  peg$savedPos = s0;
5004
- s1 = peg$f67(s1);
5199
+ s1 = peg$f68(s1);
5005
5200
  s0 = s1;
5006
5201
  return s0;
5007
5202
  }
5008
5203
  function peg$parseDropdownItem() {
5009
5204
  let s0, s1, s2, s3, s4, s5;
5010
5205
  s0 = peg$currPos;
5011
- if (input.substr(peg$currPos, 4) === peg$c54) {
5012
- s1 = peg$c54;
5206
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5207
+ s1 = peg$c55;
5013
5208
  peg$currPos += 4;
5014
5209
  } else {
5015
5210
  s1 = peg$FAILED;
5016
5211
  if (peg$silentFails === 0) {
5017
- peg$fail(peg$e57);
5212
+ peg$fail(peg$e58);
5018
5213
  }
5019
5214
  }
5020
5215
  if (s1 !== peg$FAILED) {
@@ -5027,7 +5222,7 @@ function peg$parse(input, options) {
5027
5222
  s5 = null;
5028
5223
  }
5029
5224
  peg$savedPos = s0;
5030
- s0 = peg$f68(s3, s5);
5225
+ s0 = peg$f69(s3, s5);
5031
5226
  } else {
5032
5227
  peg$currPos = s0;
5033
5228
  s0 = peg$FAILED;
@@ -5038,18 +5233,18 @@ function peg$parse(input, options) {
5038
5233
  }
5039
5234
  if (s0 === peg$FAILED) {
5040
5235
  s0 = peg$currPos;
5041
- if (input.substr(peg$currPos, 7) === peg$c62) {
5042
- s1 = peg$c62;
5236
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5237
+ s1 = peg$c63;
5043
5238
  peg$currPos += 7;
5044
5239
  } else {
5045
5240
  s1 = peg$FAILED;
5046
5241
  if (peg$silentFails === 0) {
5047
- peg$fail(peg$e65);
5242
+ peg$fail(peg$e66);
5048
5243
  }
5049
5244
  }
5050
5245
  if (s1 !== peg$FAILED) {
5051
5246
  peg$savedPos = s0;
5052
- s1 = peg$f69();
5247
+ s1 = peg$f70();
5053
5248
  }
5054
5249
  s0 = s1;
5055
5250
  if (s0 === peg$FAILED) {
@@ -5057,7 +5252,7 @@ function peg$parse(input, options) {
5057
5252
  s1 = peg$parseComment();
5058
5253
  if (s1 !== peg$FAILED) {
5059
5254
  peg$savedPos = s0;
5060
- s1 = peg$f70();
5255
+ s1 = peg$f71();
5061
5256
  }
5062
5257
  s0 = s1;
5063
5258
  }
@@ -5067,13 +5262,13 @@ function peg$parse(input, options) {
5067
5262
  function peg$parseNav() {
5068
5263
  let s0, s1, s2, s3, s4, s5, s6, s7;
5069
5264
  s0 = peg$currPos;
5070
- if (input.substr(peg$currPos, 3) === peg$c63) {
5071
- s1 = peg$c63;
5265
+ if (input.substr(peg$currPos, 3) === peg$c64) {
5266
+ s1 = peg$c64;
5072
5267
  peg$currPos += 3;
5073
5268
  } else {
5074
5269
  s1 = peg$FAILED;
5075
5270
  if (peg$silentFails === 0) {
5076
- peg$fail(peg$e66);
5271
+ peg$fail(peg$e67);
5077
5272
  }
5078
5273
  }
5079
5274
  if (s1 !== peg$FAILED) {
@@ -5093,7 +5288,7 @@ function peg$parse(input, options) {
5093
5288
  s7 = null;
5094
5289
  }
5095
5290
  peg$savedPos = s0;
5096
- s0 = peg$f71(s3, s5, s7);
5291
+ s0 = peg$f72(s3, s5, s7);
5097
5292
  } else {
5098
5293
  peg$currPos = s0;
5099
5294
  s0 = peg$FAILED;
@@ -5149,7 +5344,7 @@ function peg$parse(input, options) {
5149
5344
  }
5150
5345
  if (s4 !== peg$FAILED) {
5151
5346
  peg$savedPos = s0;
5152
- s0 = peg$f72(s3);
5347
+ s0 = peg$f73(s3);
5153
5348
  } else {
5154
5349
  peg$currPos = s0;
5155
5350
  s0 = peg$FAILED;
@@ -5167,19 +5362,19 @@ function peg$parse(input, options) {
5167
5362
  s0 = peg$parseNavItem();
5168
5363
  if (s0 === peg$FAILED) {
5169
5364
  s0 = peg$currPos;
5170
- if (input.substr(peg$currPos, 7) === peg$c62) {
5171
- s1 = peg$c62;
5365
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5366
+ s1 = peg$c63;
5172
5367
  peg$currPos += 7;
5173
5368
  } else {
5174
5369
  s1 = peg$FAILED;
5175
5370
  if (peg$silentFails === 0) {
5176
- peg$fail(peg$e65);
5371
+ peg$fail(peg$e66);
5177
5372
  }
5178
5373
  }
5179
5374
  if (s1 !== peg$FAILED) {
5180
5375
  s2 = peg$parse_();
5181
5376
  peg$savedPos = s0;
5182
- s0 = peg$f73();
5377
+ s0 = peg$f74();
5183
5378
  } else {
5184
5379
  peg$currPos = s0;
5185
5380
  s0 = peg$FAILED;
@@ -5189,7 +5384,7 @@ function peg$parse(input, options) {
5189
5384
  s1 = peg$parseComment();
5190
5385
  if (s1 !== peg$FAILED) {
5191
5386
  peg$savedPos = s0;
5192
- s1 = peg$f74();
5387
+ s1 = peg$f75();
5193
5388
  }
5194
5389
  s0 = s1;
5195
5390
  }
@@ -5200,13 +5395,13 @@ function peg$parse(input, options) {
5200
5395
  function peg$parseNavGroup() {
5201
5396
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
5202
5397
  s0 = peg$currPos;
5203
- if (input.substr(peg$currPos, 5) === peg$c64) {
5204
- s1 = peg$c64;
5398
+ if (input.substr(peg$currPos, 5) === peg$c65) {
5399
+ s1 = peg$c65;
5205
5400
  peg$currPos += 5;
5206
5401
  } else {
5207
5402
  s1 = peg$FAILED;
5208
5403
  if (peg$silentFails === 0) {
5209
- peg$fail(peg$e67);
5404
+ peg$fail(peg$e68);
5210
5405
  }
5211
5406
  }
5212
5407
  if (s1 !== peg$FAILED) {
@@ -5265,7 +5460,7 @@ function peg$parse(input, options) {
5265
5460
  }
5266
5461
  if (s10 !== peg$FAILED) {
5267
5462
  peg$savedPos = s0;
5268
- s0 = peg$f75(s3, s5, s9);
5463
+ s0 = peg$f76(s3, s5, s9);
5269
5464
  } else {
5270
5465
  peg$currPos = s0;
5271
5466
  s0 = peg$FAILED;
@@ -5289,19 +5484,19 @@ function peg$parse(input, options) {
5289
5484
  s0 = peg$parseNavItem();
5290
5485
  if (s0 === peg$FAILED) {
5291
5486
  s0 = peg$currPos;
5292
- if (input.substr(peg$currPos, 7) === peg$c62) {
5293
- s1 = peg$c62;
5487
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5488
+ s1 = peg$c63;
5294
5489
  peg$currPos += 7;
5295
5490
  } else {
5296
5491
  s1 = peg$FAILED;
5297
5492
  if (peg$silentFails === 0) {
5298
- peg$fail(peg$e65);
5493
+ peg$fail(peg$e66);
5299
5494
  }
5300
5495
  }
5301
5496
  if (s1 !== peg$FAILED) {
5302
5497
  s2 = peg$parse_();
5303
5498
  peg$savedPos = s0;
5304
- s0 = peg$f76();
5499
+ s0 = peg$f77();
5305
5500
  } else {
5306
5501
  peg$currPos = s0;
5307
5502
  s0 = peg$FAILED;
@@ -5311,7 +5506,7 @@ function peg$parse(input, options) {
5311
5506
  s1 = peg$parseComment();
5312
5507
  if (s1 !== peg$FAILED) {
5313
5508
  peg$savedPos = s0;
5314
- s1 = peg$f77();
5509
+ s1 = peg$f78();
5315
5510
  }
5316
5511
  s0 = s1;
5317
5512
  }
@@ -5321,13 +5516,13 @@ function peg$parse(input, options) {
5321
5516
  function peg$parseNavItem() {
5322
5517
  let s0, s1, s2, s3, s4, s5;
5323
5518
  s0 = peg$currPos;
5324
- if (input.substr(peg$currPos, 4) === peg$c54) {
5325
- s1 = peg$c54;
5519
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5520
+ s1 = peg$c55;
5326
5521
  peg$currPos += 4;
5327
5522
  } else {
5328
5523
  s1 = peg$FAILED;
5329
5524
  if (peg$silentFails === 0) {
5330
- peg$fail(peg$e57);
5525
+ peg$fail(peg$e58);
5331
5526
  }
5332
5527
  }
5333
5528
  if (s1 !== peg$FAILED) {
@@ -5340,7 +5535,7 @@ function peg$parse(input, options) {
5340
5535
  s5 = null;
5341
5536
  }
5342
5537
  peg$savedPos = s0;
5343
- s0 = peg$f78(s3, s5);
5538
+ s0 = peg$f79(s3, s5);
5344
5539
  } else {
5345
5540
  peg$currPos = s0;
5346
5541
  s0 = peg$FAILED;
@@ -5354,13 +5549,13 @@ function peg$parse(input, options) {
5354
5549
  function peg$parseTabs() {
5355
5550
  let s0, s1, s2, s3, s4, s5, s6, s7;
5356
5551
  s0 = peg$currPos;
5357
- if (input.substr(peg$currPos, 4) === peg$c65) {
5358
- s1 = peg$c65;
5552
+ if (input.substr(peg$currPos, 4) === peg$c66) {
5553
+ s1 = peg$c66;
5359
5554
  peg$currPos += 4;
5360
5555
  } else {
5361
5556
  s1 = peg$FAILED;
5362
5557
  if (peg$silentFails === 0) {
5363
- peg$fail(peg$e68);
5558
+ peg$fail(peg$e69);
5364
5559
  }
5365
5560
  }
5366
5561
  if (s1 !== peg$FAILED) {
@@ -5380,7 +5575,7 @@ function peg$parse(input, options) {
5380
5575
  s7 = null;
5381
5576
  }
5382
5577
  peg$savedPos = s0;
5383
- s0 = peg$f79(s3, s5, s7);
5578
+ s0 = peg$f80(s3, s5, s7);
5384
5579
  } else {
5385
5580
  peg$currPos = s0;
5386
5581
  s0 = peg$FAILED;
@@ -5436,7 +5631,7 @@ function peg$parse(input, options) {
5436
5631
  }
5437
5632
  if (s4 !== peg$FAILED) {
5438
5633
  peg$savedPos = s0;
5439
- s0 = peg$f80(s3);
5634
+ s0 = peg$f81(s3);
5440
5635
  } else {
5441
5636
  peg$currPos = s0;
5442
5637
  s0 = peg$FAILED;
@@ -5450,13 +5645,13 @@ function peg$parse(input, options) {
5450
5645
  function peg$parseTabItem() {
5451
5646
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
5452
5647
  s0 = peg$currPos;
5453
- if (input.substr(peg$currPos, 3) === peg$c66) {
5454
- s1 = peg$c66;
5648
+ if (input.substr(peg$currPos, 3) === peg$c67) {
5649
+ s1 = peg$c67;
5455
5650
  peg$currPos += 3;
5456
5651
  } else {
5457
5652
  s1 = peg$FAILED;
5458
5653
  if (peg$silentFails === 0) {
5459
- peg$fail(peg$e69);
5654
+ peg$fail(peg$e70);
5460
5655
  }
5461
5656
  }
5462
5657
  if (s1 !== peg$FAILED) {
@@ -5494,7 +5689,7 @@ function peg$parse(input, options) {
5494
5689
  }
5495
5690
  if (s11 !== peg$FAILED) {
5496
5691
  peg$savedPos = s0;
5497
- s0 = peg$f81(s3, s5, s9);
5692
+ s0 = peg$f82(s3, s5, s9);
5498
5693
  } else {
5499
5694
  peg$currPos = s0;
5500
5695
  s0 = peg$FAILED;
@@ -5520,7 +5715,7 @@ function peg$parse(input, options) {
5520
5715
  s1 = peg$parseComment();
5521
5716
  if (s1 !== peg$FAILED) {
5522
5717
  peg$savedPos = s0;
5523
- s1 = peg$f82();
5718
+ s1 = peg$f83();
5524
5719
  }
5525
5720
  s0 = s1;
5526
5721
  }
@@ -5529,13 +5724,13 @@ function peg$parse(input, options) {
5529
5724
  function peg$parseBreadcrumb() {
5530
5725
  let s0, s1, s2, s3, s4, s5;
5531
5726
  s0 = peg$currPos;
5532
- if (input.substr(peg$currPos, 10) === peg$c67) {
5533
- s1 = peg$c67;
5727
+ if (input.substr(peg$currPos, 10) === peg$c68) {
5728
+ s1 = peg$c68;
5534
5729
  peg$currPos += 10;
5535
5730
  } else {
5536
5731
  s1 = peg$FAILED;
5537
5732
  if (peg$silentFails === 0) {
5538
- peg$fail(peg$e70);
5733
+ peg$fail(peg$e71);
5539
5734
  }
5540
5735
  }
5541
5736
  if (s1 !== peg$FAILED) {
@@ -5548,7 +5743,7 @@ function peg$parse(input, options) {
5548
5743
  s5 = null;
5549
5744
  }
5550
5745
  peg$savedPos = s0;
5551
- s0 = peg$f83(s3, s5);
5746
+ s0 = peg$f84(s3, s5);
5552
5747
  } else {
5553
5748
  peg$currPos = s0;
5554
5749
  s0 = peg$FAILED;
@@ -5562,13 +5757,13 @@ function peg$parse(input, options) {
5562
5757
  function peg$parseDivider() {
5563
5758
  let s0, s1, s2, s3;
5564
5759
  s0 = peg$currPos;
5565
- if (input.substr(peg$currPos, 7) === peg$c62) {
5566
- s1 = peg$c62;
5760
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5761
+ s1 = peg$c63;
5567
5762
  peg$currPos += 7;
5568
5763
  } else {
5569
5764
  s1 = peg$FAILED;
5570
5765
  if (peg$silentFails === 0) {
5571
- peg$fail(peg$e65);
5766
+ peg$fail(peg$e66);
5572
5767
  }
5573
5768
  }
5574
5769
  if (s1 !== peg$FAILED) {
@@ -5578,7 +5773,7 @@ function peg$parse(input, options) {
5578
5773
  s3 = null;
5579
5774
  }
5580
5775
  peg$savedPos = s0;
5581
- s0 = peg$f84(s3);
5776
+ s0 = peg$f85(s3);
5582
5777
  } else {
5583
5778
  peg$currPos = s0;
5584
5779
  s0 = peg$FAILED;
@@ -5588,13 +5783,13 @@ function peg$parse(input, options) {
5588
5783
  function peg$parseMarker() {
5589
5784
  let s0, s1, s2, s3, s4, s5;
5590
5785
  s0 = peg$currPos;
5591
- if (input.substr(peg$currPos, 6) === peg$c68) {
5592
- s1 = peg$c68;
5786
+ if (input.substr(peg$currPos, 6) === peg$c69) {
5787
+ s1 = peg$c69;
5593
5788
  peg$currPos += 6;
5594
5789
  } else {
5595
5790
  s1 = peg$FAILED;
5596
5791
  if (peg$silentFails === 0) {
5597
- peg$fail(peg$e71);
5792
+ peg$fail(peg$e72);
5598
5793
  }
5599
5794
  }
5600
5795
  if (s1 !== peg$FAILED) {
@@ -5607,7 +5802,7 @@ function peg$parse(input, options) {
5607
5802
  s5 = null;
5608
5803
  }
5609
5804
  peg$savedPos = s0;
5610
- s0 = peg$f85(s3, s5);
5805
+ s0 = peg$f86(s3, s5);
5611
5806
  } else {
5612
5807
  peg$currPos = s0;
5613
5808
  s0 = peg$FAILED;
@@ -5621,13 +5816,13 @@ function peg$parse(input, options) {
5621
5816
  function peg$parseAnnotations() {
5622
5817
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
5623
5818
  s0 = peg$currPos;
5624
- if (input.substr(peg$currPos, 11) === peg$c69) {
5625
- s1 = peg$c69;
5819
+ if (input.substr(peg$currPos, 11) === peg$c70) {
5820
+ s1 = peg$c70;
5626
5821
  peg$currPos += 11;
5627
5822
  } else {
5628
5823
  s1 = peg$FAILED;
5629
5824
  if (peg$silentFails === 0) {
5630
- peg$fail(peg$e72);
5825
+ peg$fail(peg$e73);
5631
5826
  }
5632
5827
  }
5633
5828
  if (s1 !== peg$FAILED) {
@@ -5661,7 +5856,7 @@ function peg$parse(input, options) {
5661
5856
  }
5662
5857
  if (s9 !== peg$FAILED) {
5663
5858
  peg$savedPos = s0;
5664
- s0 = peg$f86(s3, s7);
5859
+ s0 = peg$f87(s3, s7);
5665
5860
  } else {
5666
5861
  peg$currPos = s0;
5667
5862
  s0 = peg$FAILED;
@@ -5704,20 +5899,20 @@ function peg$parse(input, options) {
5704
5899
  }
5705
5900
  }
5706
5901
  peg$savedPos = s0;
5707
- s1 = peg$f87(s1);
5902
+ s1 = peg$f88(s1);
5708
5903
  s0 = s1;
5709
5904
  return s0;
5710
5905
  }
5711
5906
  function peg$parseAnnotationItem() {
5712
5907
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5713
5908
  s0 = peg$currPos;
5714
- if (input.substr(peg$currPos, 4) === peg$c54) {
5715
- s1 = peg$c54;
5909
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5910
+ s1 = peg$c55;
5716
5911
  peg$currPos += 4;
5717
5912
  } else {
5718
5913
  s1 = peg$FAILED;
5719
5914
  if (peg$silentFails === 0) {
5720
- peg$fail(peg$e57);
5915
+ peg$fail(peg$e58);
5721
5916
  }
5722
5917
  }
5723
5918
  if (s1 !== peg$FAILED) {
@@ -5758,7 +5953,7 @@ function peg$parse(input, options) {
5758
5953
  }
5759
5954
  if (s13 !== peg$FAILED) {
5760
5955
  peg$savedPos = s0;
5761
- s0 = peg$f88(s3, s5, s7, s11);
5956
+ s0 = peg$f89(s3, s5, s7, s11);
5762
5957
  } else {
5763
5958
  peg$currPos = s0;
5764
5959
  s0 = peg$FAILED;
@@ -5785,13 +5980,13 @@ function peg$parse(input, options) {
5785
5980
  }
5786
5981
  if (s0 === peg$FAILED) {
5787
5982
  s0 = peg$currPos;
5788
- if (input.substr(peg$currPos, 4) === peg$c54) {
5789
- s1 = peg$c54;
5983
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5984
+ s1 = peg$c55;
5790
5985
  peg$currPos += 4;
5791
5986
  } else {
5792
5987
  s1 = peg$FAILED;
5793
5988
  if (peg$silentFails === 0) {
5794
- peg$fail(peg$e57);
5989
+ peg$fail(peg$e58);
5795
5990
  }
5796
5991
  }
5797
5992
  if (s1 !== peg$FAILED) {
@@ -5807,7 +6002,7 @@ function peg$parse(input, options) {
5807
6002
  s7 = null;
5808
6003
  }
5809
6004
  peg$savedPos = s0;
5810
- s0 = peg$f89(s3, s5, s7);
6005
+ s0 = peg$f90(s3, s5, s7);
5811
6006
  } else {
5812
6007
  peg$currPos = s0;
5813
6008
  s0 = peg$FAILED;
@@ -5825,7 +6020,7 @@ function peg$parse(input, options) {
5825
6020
  s1 = peg$parseComment();
5826
6021
  if (s1 !== peg$FAILED) {
5827
6022
  peg$savedPos = s0;
5828
- s1 = peg$f90();
6023
+ s1 = peg$f91();
5829
6024
  }
5830
6025
  s0 = s1;
5831
6026
  }
@@ -5843,7 +6038,7 @@ function peg$parse(input, options) {
5843
6038
  } else {
5844
6039
  s2 = peg$FAILED;
5845
6040
  if (peg$silentFails === 0) {
5846
- peg$fail(peg$e74);
6041
+ peg$fail(peg$e75);
5847
6042
  }
5848
6043
  }
5849
6044
  if (s2 !== peg$FAILED) {
@@ -5855,7 +6050,7 @@ function peg$parse(input, options) {
5855
6050
  } else {
5856
6051
  s2 = peg$FAILED;
5857
6052
  if (peg$silentFails === 0) {
5858
- peg$fail(peg$e74);
6053
+ peg$fail(peg$e75);
5859
6054
  }
5860
6055
  }
5861
6056
  }
@@ -5864,14 +6059,14 @@ function peg$parse(input, options) {
5864
6059
  }
5865
6060
  if (s1 !== peg$FAILED) {
5866
6061
  peg$savedPos = s0;
5867
- s1 = peg$f91(s1);
6062
+ s1 = peg$f92(s1);
5868
6063
  }
5869
6064
  s0 = s1;
5870
6065
  peg$silentFails--;
5871
6066
  if (s0 === peg$FAILED) {
5872
6067
  s1 = peg$FAILED;
5873
6068
  if (peg$silentFails === 0) {
5874
- peg$fail(peg$e73);
6069
+ peg$fail(peg$e74);
5875
6070
  }
5876
6071
  }
5877
6072
  return s0;
@@ -5891,7 +6086,7 @@ function peg$parse(input, options) {
5891
6086
  }
5892
6087
  if (s1 !== peg$FAILED) {
5893
6088
  peg$savedPos = s0;
5894
- s1 = peg$f92(s1);
6089
+ s1 = peg$f93(s1);
5895
6090
  }
5896
6091
  s0 = s1;
5897
6092
  return s0;
@@ -5900,13 +6095,13 @@ function peg$parse(input, options) {
5900
6095
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5901
6096
  s0 = peg$currPos;
5902
6097
  s1 = peg$parse_();
5903
- if (input.substr(peg$currPos, 2) === peg$c70) {
5904
- s2 = peg$c70;
6098
+ if (input.substr(peg$currPos, 2) === peg$c71) {
6099
+ s2 = peg$c71;
5905
6100
  peg$currPos += 2;
5906
6101
  } else {
5907
6102
  s2 = peg$FAILED;
5908
6103
  if (peg$silentFails === 0) {
5909
- peg$fail(peg$e75);
6104
+ peg$fail(peg$e76);
5910
6105
  }
5911
6106
  }
5912
6107
  if (s2 !== peg$FAILED) {
@@ -5961,7 +6156,7 @@ function peg$parse(input, options) {
5961
6156
  }
5962
6157
  if (s13 !== peg$FAILED) {
5963
6158
  peg$savedPos = s0;
5964
- s0 = peg$f93(s7, s11);
6159
+ s0 = peg$f94(s7, s11);
5965
6160
  } else {
5966
6161
  peg$currPos = s0;
5967
6162
  s0 = peg$FAILED;
@@ -6010,7 +6205,7 @@ function peg$parse(input, options) {
6010
6205
  s6 = peg$parseAttributeValue();
6011
6206
  if (s6 !== peg$FAILED) {
6012
6207
  peg$savedPos = s0;
6013
- s0 = peg$f94(s2, s6);
6208
+ s0 = peg$f95(s2, s6);
6014
6209
  } else {
6015
6210
  peg$currPos = s0;
6016
6211
  s0 = peg$FAILED;
@@ -6042,7 +6237,7 @@ function peg$parse(input, options) {
6042
6237
  } else {
6043
6238
  s6 = peg$FAILED;
6044
6239
  if (peg$silentFails === 0) {
6045
- peg$fail(peg$e76);
6240
+ peg$fail(peg$e77);
6046
6241
  }
6047
6242
  }
6048
6243
  if (s6 === peg$FAILED) {
@@ -6105,7 +6300,7 @@ function peg$parse(input, options) {
6105
6300
  }
6106
6301
  if (s3 !== peg$FAILED) {
6107
6302
  peg$savedPos = s0;
6108
- s0 = peg$f95(s2);
6303
+ s0 = peg$f96(s2);
6109
6304
  } else {
6110
6305
  peg$currPos = s0;
6111
6306
  s0 = peg$FAILED;
@@ -6135,7 +6330,7 @@ function peg$parse(input, options) {
6135
6330
  s2 = peg$parseIdentifier();
6136
6331
  if (s2 !== peg$FAILED) {
6137
6332
  peg$savedPos = s0;
6138
- s0 = peg$f96(s2);
6333
+ s0 = peg$f97(s2);
6139
6334
  } else {
6140
6335
  peg$currPos = s0;
6141
6336
  s0 = peg$FAILED;
@@ -6159,503 +6354,514 @@ function peg$parse(input, options) {
6159
6354
  }
6160
6355
  }
6161
6356
  if (s1 === peg$FAILED) {
6162
- if (input.substr(peg$currPos, 6) === peg$c20) {
6163
- s1 = peg$c20;
6357
+ if (input.substr(peg$currPos, 6) === peg$c21) {
6358
+ s1 = peg$c21;
6164
6359
  peg$currPos += 6;
6165
6360
  } else {
6166
6361
  s1 = peg$FAILED;
6167
6362
  if (peg$silentFails === 0) {
6168
- peg$fail(peg$e23);
6363
+ peg$fail(peg$e24);
6169
6364
  }
6170
6365
  }
6171
6366
  if (s1 === peg$FAILED) {
6172
- if (input.substr(peg$currPos, 4) === peg$c21) {
6173
- s1 = peg$c21;
6367
+ if (input.substr(peg$currPos, 4) === peg$c22) {
6368
+ s1 = peg$c22;
6174
6369
  peg$currPos += 4;
6175
6370
  } else {
6176
6371
  s1 = peg$FAILED;
6177
6372
  if (peg$silentFails === 0) {
6178
- peg$fail(peg$e24);
6373
+ peg$fail(peg$e25);
6179
6374
  }
6180
6375
  }
6181
6376
  if (s1 === peg$FAILED) {
6182
- if (input.substr(peg$currPos, 6) === peg$c22) {
6183
- s1 = peg$c22;
6377
+ if (input.substr(peg$currPos, 6) === peg$c23) {
6378
+ s1 = peg$c23;
6184
6379
  peg$currPos += 6;
6185
6380
  } else {
6186
6381
  s1 = peg$FAILED;
6187
6382
  if (peg$silentFails === 0) {
6188
- peg$fail(peg$e25);
6383
+ peg$fail(peg$e26);
6189
6384
  }
6190
6385
  }
6191
6386
  if (s1 === peg$FAILED) {
6192
- if (input.substr(peg$currPos, 7) === peg$c23) {
6193
- s1 = peg$c23;
6387
+ if (input.substr(peg$currPos, 7) === peg$c24) {
6388
+ s1 = peg$c24;
6194
6389
  peg$currPos += 7;
6195
6390
  } else {
6196
6391
  s1 = peg$FAILED;
6197
6392
  if (peg$silentFails === 0) {
6198
- peg$fail(peg$e26);
6393
+ peg$fail(peg$e27);
6199
6394
  }
6200
6395
  }
6201
6396
  if (s1 === peg$FAILED) {
6202
- if (input.substr(peg$currPos, 3) === peg$c24) {
6203
- s1 = peg$c24;
6397
+ if (input.substr(peg$currPos, 3) === peg$c25) {
6398
+ s1 = peg$c25;
6204
6399
  peg$currPos += 3;
6205
6400
  } else {
6206
6401
  s1 = peg$FAILED;
6207
6402
  if (peg$silentFails === 0) {
6208
- peg$fail(peg$e27);
6403
+ peg$fail(peg$e28);
6209
6404
  }
6210
6405
  }
6211
6406
  if (s1 === peg$FAILED) {
6212
- if (input.substr(peg$currPos, 3) === peg$c25) {
6213
- s1 = peg$c25;
6407
+ if (input.substr(peg$currPos, 3) === peg$c26) {
6408
+ s1 = peg$c26;
6214
6409
  peg$currPos += 3;
6215
6410
  } else {
6216
6411
  s1 = peg$FAILED;
6217
6412
  if (peg$silentFails === 0) {
6218
- peg$fail(peg$e28);
6413
+ peg$fail(peg$e29);
6219
6414
  }
6220
6415
  }
6221
6416
  if (s1 === peg$FAILED) {
6222
- if (input.substr(peg$currPos, 5) === peg$c26) {
6223
- s1 = peg$c26;
6417
+ if (input.substr(peg$currPos, 5) === peg$c27) {
6418
+ s1 = peg$c27;
6224
6419
  peg$currPos += 5;
6225
6420
  } else {
6226
6421
  s1 = peg$FAILED;
6227
6422
  if (peg$silentFails === 0) {
6228
- peg$fail(peg$e29);
6423
+ peg$fail(peg$e30);
6229
6424
  }
6230
6425
  }
6231
6426
  if (s1 === peg$FAILED) {
6232
- if (input.substr(peg$currPos, 8) === peg$c27) {
6233
- s1 = peg$c27;
6427
+ if (input.substr(peg$currPos, 8) === peg$c28) {
6428
+ s1 = peg$c28;
6234
6429
  peg$currPos += 8;
6235
6430
  } else {
6236
6431
  s1 = peg$FAILED;
6237
6432
  if (peg$silentFails === 0) {
6238
- peg$fail(peg$e30);
6433
+ peg$fail(peg$e31);
6239
6434
  }
6240
6435
  }
6241
6436
  if (s1 === peg$FAILED) {
6242
- if (input.substr(peg$currPos, 4) === peg$c28) {
6243
- s1 = peg$c28;
6437
+ if (input.substr(peg$currPos, 4) === peg$c29) {
6438
+ s1 = peg$c29;
6244
6439
  peg$currPos += 4;
6245
6440
  } else {
6246
6441
  s1 = peg$FAILED;
6247
6442
  if (peg$silentFails === 0) {
6248
- peg$fail(peg$e31);
6443
+ peg$fail(peg$e32);
6249
6444
  }
6250
6445
  }
6251
6446
  if (s1 === peg$FAILED) {
6252
- if (input.substr(peg$currPos, 5) === peg$c29) {
6253
- s1 = peg$c29;
6447
+ if (input.substr(peg$currPos, 5) === peg$c30) {
6448
+ s1 = peg$c30;
6254
6449
  peg$currPos += 5;
6255
6450
  } else {
6256
6451
  s1 = peg$FAILED;
6257
6452
  if (peg$silentFails === 0) {
6258
- peg$fail(peg$e32);
6453
+ peg$fail(peg$e33);
6259
6454
  }
6260
6455
  }
6261
6456
  if (s1 === peg$FAILED) {
6262
- if (input.substr(peg$currPos, 6) === peg$c30) {
6263
- s1 = peg$c30;
6457
+ if (input.substr(peg$currPos, 6) === peg$c31) {
6458
+ s1 = peg$c31;
6264
6459
  peg$currPos += 6;
6265
6460
  } else {
6266
6461
  s1 = peg$FAILED;
6267
6462
  if (peg$silentFails === 0) {
6268
- peg$fail(peg$e33);
6463
+ peg$fail(peg$e34);
6269
6464
  }
6270
6465
  }
6271
6466
  if (s1 === peg$FAILED) {
6272
- if (input.substr(peg$currPos, 9) === peg$c31) {
6273
- s1 = peg$c31;
6467
+ if (input.substr(peg$currPos, 9) === peg$c32) {
6468
+ s1 = peg$c32;
6274
6469
  peg$currPos += 9;
6275
6470
  } else {
6276
6471
  s1 = peg$FAILED;
6277
6472
  if (peg$silentFails === 0) {
6278
- peg$fail(peg$e34);
6473
+ peg$fail(peg$e35);
6279
6474
  }
6280
6475
  }
6281
6476
  if (s1 === peg$FAILED) {
6282
- if (input.substr(peg$currPos, 7) === peg$c32) {
6283
- s1 = peg$c32;
6477
+ if (input.substr(peg$currPos, 7) === peg$c33) {
6478
+ s1 = peg$c33;
6284
6479
  peg$currPos += 7;
6285
6480
  } else {
6286
6481
  s1 = peg$FAILED;
6287
6482
  if (peg$silentFails === 0) {
6288
- peg$fail(peg$e35);
6483
+ peg$fail(peg$e36);
6289
6484
  }
6290
6485
  }
6291
6486
  if (s1 === peg$FAILED) {
6292
- if (input.substr(peg$currPos, 4) === peg$c33) {
6293
- s1 = peg$c33;
6487
+ if (input.substr(peg$currPos, 4) === peg$c34) {
6488
+ s1 = peg$c34;
6294
6489
  peg$currPos += 4;
6295
6490
  } else {
6296
6491
  s1 = peg$FAILED;
6297
6492
  if (peg$silentFails === 0) {
6298
- peg$fail(peg$e36);
6493
+ peg$fail(peg$e37);
6299
6494
  }
6300
6495
  }
6301
6496
  if (s1 === peg$FAILED) {
6302
- if (input.substr(peg$currPos, 4) === peg$c35) {
6303
- s1 = peg$c35;
6497
+ if (input.substr(peg$currPos, 4) === peg$c36) {
6498
+ s1 = peg$c36;
6304
6499
  peg$currPos += 4;
6305
6500
  } else {
6306
6501
  s1 = peg$FAILED;
6307
6502
  if (peg$silentFails === 0) {
6308
- peg$fail(peg$e38);
6503
+ peg$fail(peg$e39);
6309
6504
  }
6310
6505
  }
6311
6506
  if (s1 === peg$FAILED) {
6312
- if (input.substr(peg$currPos, 6) === peg$c36) {
6313
- s1 = peg$c36;
6507
+ if (input.substr(peg$currPos, 6) === peg$c37) {
6508
+ s1 = peg$c37;
6314
6509
  peg$currPos += 6;
6315
6510
  } else {
6316
6511
  s1 = peg$FAILED;
6317
6512
  if (peg$silentFails === 0) {
6318
- peg$fail(peg$e39);
6513
+ peg$fail(peg$e40);
6319
6514
  }
6320
6515
  }
6321
6516
  if (s1 === peg$FAILED) {
6322
- if (input.substr(peg$currPos, 5) === peg$c37) {
6323
- s1 = peg$c37;
6517
+ if (input.substr(peg$currPos, 5) === peg$c38) {
6518
+ s1 = peg$c38;
6324
6519
  peg$currPos += 5;
6325
6520
  } else {
6326
6521
  s1 = peg$FAILED;
6327
6522
  if (peg$silentFails === 0) {
6328
- peg$fail(peg$e40);
6523
+ peg$fail(peg$e41);
6329
6524
  }
6330
6525
  }
6331
6526
  if (s1 === peg$FAILED) {
6332
- if (input.substr(peg$currPos, 8) === peg$c38) {
6333
- s1 = peg$c38;
6527
+ if (input.substr(peg$currPos, 8) === peg$c39) {
6528
+ s1 = peg$c39;
6334
6529
  peg$currPos += 8;
6335
6530
  } else {
6336
6531
  s1 = peg$FAILED;
6337
6532
  if (peg$silentFails === 0) {
6338
- peg$fail(peg$e41);
6533
+ peg$fail(peg$e42);
6339
6534
  }
6340
6535
  }
6341
6536
  if (s1 === peg$FAILED) {
6342
- if (input.substr(peg$currPos, 6) === peg$c39) {
6343
- s1 = peg$c39;
6537
+ if (input.substr(peg$currPos, 6) === peg$c40) {
6538
+ s1 = peg$c40;
6344
6539
  peg$currPos += 6;
6345
6540
  } else {
6346
6541
  s1 = peg$FAILED;
6347
6542
  if (peg$silentFails === 0) {
6348
- peg$fail(peg$e42);
6543
+ peg$fail(peg$e43);
6349
6544
  }
6350
6545
  }
6351
6546
  if (s1 === peg$FAILED) {
6352
- if (input.substr(peg$currPos, 8) === peg$c40) {
6353
- s1 = peg$c40;
6547
+ if (input.substr(peg$currPos, 8) === peg$c41) {
6548
+ s1 = peg$c41;
6354
6549
  peg$currPos += 8;
6355
6550
  } else {
6356
6551
  s1 = peg$FAILED;
6357
6552
  if (peg$silentFails === 0) {
6358
- peg$fail(peg$e43);
6553
+ peg$fail(peg$e44);
6359
6554
  }
6360
6555
  }
6361
6556
  if (s1 === peg$FAILED) {
6362
- if (input.substr(peg$currPos, 5) === peg$c41) {
6363
- s1 = peg$c41;
6557
+ if (input.substr(peg$currPos, 5) === peg$c42) {
6558
+ s1 = peg$c42;
6364
6559
  peg$currPos += 5;
6365
6560
  } else {
6366
6561
  s1 = peg$FAILED;
6367
6562
  if (peg$silentFails === 0) {
6368
- peg$fail(peg$e44);
6563
+ peg$fail(peg$e45);
6369
6564
  }
6370
6565
  }
6371
6566
  if (s1 === peg$FAILED) {
6372
- if (input.substr(peg$currPos, 6) === peg$c42) {
6373
- s1 = peg$c42;
6567
+ if (input.substr(peg$currPos, 6) === peg$c43) {
6568
+ s1 = peg$c43;
6374
6569
  peg$currPos += 6;
6375
6570
  } else {
6376
6571
  s1 = peg$FAILED;
6377
6572
  if (peg$silentFails === 0) {
6378
- peg$fail(peg$e45);
6573
+ peg$fail(peg$e46);
6379
6574
  }
6380
6575
  }
6381
6576
  if (s1 === peg$FAILED) {
6382
- if (input.substr(peg$currPos, 6) === peg$c43) {
6383
- s1 = peg$c43;
6577
+ if (input.substr(peg$currPos, 6) === peg$c44) {
6578
+ s1 = peg$c44;
6384
6579
  peg$currPos += 6;
6385
6580
  } else {
6386
6581
  s1 = peg$FAILED;
6387
6582
  if (peg$silentFails === 0) {
6388
- peg$fail(peg$e46);
6583
+ peg$fail(peg$e47);
6389
6584
  }
6390
6585
  }
6391
6586
  if (s1 === peg$FAILED) {
6392
- if (input.substr(peg$currPos, 5) === peg$c44) {
6393
- s1 = peg$c44;
6587
+ if (input.substr(peg$currPos, 5) === peg$c45) {
6588
+ s1 = peg$c45;
6394
6589
  peg$currPos += 5;
6395
6590
  } else {
6396
6591
  s1 = peg$FAILED;
6397
6592
  if (peg$silentFails === 0) {
6398
- peg$fail(peg$e47);
6593
+ peg$fail(peg$e48);
6399
6594
  }
6400
6595
  }
6401
6596
  if (s1 === peg$FAILED) {
6402
- if (input.substr(peg$currPos, 6) === peg$c46) {
6403
- s1 = peg$c46;
6597
+ if (input.substr(peg$currPos, 6) === peg$c47) {
6598
+ s1 = peg$c47;
6404
6599
  peg$currPos += 6;
6405
6600
  } else {
6406
6601
  s1 = peg$FAILED;
6407
6602
  if (peg$silentFails === 0) {
6408
- peg$fail(peg$e49);
6603
+ peg$fail(peg$e50);
6409
6604
  }
6410
6605
  }
6411
6606
  if (s1 === peg$FAILED) {
6412
- if (input.substr(peg$currPos, 5) === peg$c47) {
6413
- s1 = peg$c47;
6607
+ if (input.substr(peg$currPos, 5) === peg$c48) {
6608
+ s1 = peg$c48;
6414
6609
  peg$currPos += 5;
6415
6610
  } else {
6416
6611
  s1 = peg$FAILED;
6417
6612
  if (peg$silentFails === 0) {
6418
- peg$fail(peg$e50);
6613
+ peg$fail(peg$e51);
6419
6614
  }
6420
6615
  }
6421
6616
  if (s1 === peg$FAILED) {
6422
- if (input.substr(peg$currPos, 5) === peg$c49) {
6423
- s1 = peg$c49;
6617
+ if (input.substr(peg$currPos, 5) === peg$c50) {
6618
+ s1 = peg$c50;
6424
6619
  peg$currPos += 5;
6425
6620
  } else {
6426
6621
  s1 = peg$FAILED;
6427
6622
  if (peg$silentFails === 0) {
6428
- peg$fail(peg$e52);
6623
+ peg$fail(peg$e53);
6429
6624
  }
6430
6625
  }
6431
6626
  if (s1 === peg$FAILED) {
6432
- if (input.substr(peg$currPos, 7) === peg$c52) {
6433
- s1 = peg$c52;
6627
+ if (input.substr(peg$currPos, 7) === peg$c53) {
6628
+ s1 = peg$c53;
6434
6629
  peg$currPos += 7;
6435
6630
  } else {
6436
6631
  s1 = peg$FAILED;
6437
6632
  if (peg$silentFails === 0) {
6438
- peg$fail(peg$e55);
6633
+ peg$fail(peg$e56);
6439
6634
  }
6440
6635
  }
6441
6636
  if (s1 === peg$FAILED) {
6442
- if (input.substr(peg$currPos, 4) === peg$c53) {
6443
- s1 = peg$c53;
6637
+ if (input.substr(peg$currPos, 4) === peg$c54) {
6638
+ s1 = peg$c54;
6444
6639
  peg$currPos += 4;
6445
6640
  } else {
6446
6641
  s1 = peg$FAILED;
6447
6642
  if (peg$silentFails === 0) {
6448
- peg$fail(peg$e56);
6643
+ peg$fail(peg$e57);
6449
6644
  }
6450
6645
  }
6451
6646
  if (s1 === peg$FAILED) {
6452
- if (input.substr(peg$currPos, 4) === peg$c54) {
6453
- s1 = peg$c54;
6647
+ if (input.substr(peg$currPos, 4) === peg$c55) {
6648
+ s1 = peg$c55;
6454
6649
  peg$currPos += 4;
6455
6650
  } else {
6456
6651
  s1 = peg$FAILED;
6457
6652
  if (peg$silentFails === 0) {
6458
- peg$fail(peg$e57);
6653
+ peg$fail(peg$e58);
6459
6654
  }
6460
6655
  }
6461
6656
  if (s1 === peg$FAILED) {
6462
- if (input.substr(peg$currPos, 5) === peg$c55) {
6463
- s1 = peg$c55;
6657
+ if (input.substr(peg$currPos, 5) === peg$c56) {
6658
+ s1 = peg$c56;
6464
6659
  peg$currPos += 5;
6465
6660
  } else {
6466
6661
  s1 = peg$FAILED;
6467
6662
  if (peg$silentFails === 0) {
6468
- peg$fail(peg$e58);
6663
+ peg$fail(peg$e59);
6469
6664
  }
6470
6665
  }
6471
6666
  if (s1 === peg$FAILED) {
6472
- if (input.substr(peg$currPos, 5) === peg$c56) {
6473
- s1 = peg$c56;
6667
+ if (input.substr(peg$currPos, 5) === peg$c57) {
6668
+ s1 = peg$c57;
6474
6669
  peg$currPos += 5;
6475
6670
  } else {
6476
6671
  s1 = peg$FAILED;
6477
6672
  if (peg$silentFails === 0) {
6478
- peg$fail(peg$e59);
6673
+ peg$fail(peg$e60);
6479
6674
  }
6480
6675
  }
6481
6676
  if (s1 === peg$FAILED) {
6482
- if (input.substr(peg$currPos, 8) === peg$c57) {
6483
- s1 = peg$c57;
6677
+ if (input.substr(peg$currPos, 8) === peg$c58) {
6678
+ s1 = peg$c58;
6484
6679
  peg$currPos += 8;
6485
6680
  } else {
6486
6681
  s1 = peg$FAILED;
6487
6682
  if (peg$silentFails === 0) {
6488
- peg$fail(peg$e60);
6683
+ peg$fail(peg$e61);
6489
6684
  }
6490
6685
  }
6491
6686
  if (s1 === peg$FAILED) {
6492
- if (input.substr(peg$currPos, 7) === peg$c58) {
6493
- s1 = peg$c58;
6687
+ if (input.substr(peg$currPos, 7) === peg$c59) {
6688
+ s1 = peg$c59;
6494
6689
  peg$currPos += 7;
6495
6690
  } else {
6496
6691
  s1 = peg$FAILED;
6497
6692
  if (peg$silentFails === 0) {
6498
- peg$fail(peg$e61);
6693
+ peg$fail(peg$e62);
6499
6694
  }
6500
6695
  }
6501
6696
  if (s1 === peg$FAILED) {
6502
- if (input.substr(peg$currPos, 7) === peg$c59) {
6503
- s1 = peg$c59;
6697
+ if (input.substr(peg$currPos, 7) === peg$c60) {
6698
+ s1 = peg$c60;
6504
6699
  peg$currPos += 7;
6505
6700
  } else {
6506
6701
  s1 = peg$FAILED;
6507
6702
  if (peg$silentFails === 0) {
6508
- peg$fail(peg$e62);
6703
+ peg$fail(peg$e63);
6509
6704
  }
6510
6705
  }
6511
6706
  if (s1 === peg$FAILED) {
6512
- if (input.substr(peg$currPos, 7) === peg$c60) {
6513
- s1 = peg$c60;
6707
+ if (input.substr(peg$currPos, 7) === peg$c61) {
6708
+ s1 = peg$c61;
6514
6709
  peg$currPos += 7;
6515
6710
  } else {
6516
6711
  s1 = peg$FAILED;
6517
6712
  if (peg$silentFails === 0) {
6518
- peg$fail(peg$e63);
6713
+ peg$fail(peg$e64);
6519
6714
  }
6520
6715
  }
6521
6716
  if (s1 === peg$FAILED) {
6522
- if (input.substr(peg$currPos, 8) === peg$c61) {
6523
- s1 = peg$c61;
6717
+ if (input.substr(peg$currPos, 8) === peg$c62) {
6718
+ s1 = peg$c62;
6524
6719
  peg$currPos += 8;
6525
6720
  } else {
6526
6721
  s1 = peg$FAILED;
6527
6722
  if (peg$silentFails === 0) {
6528
- peg$fail(peg$e64);
6723
+ peg$fail(peg$e65);
6529
6724
  }
6530
6725
  }
6531
6726
  if (s1 === peg$FAILED) {
6532
- if (input.substr(peg$currPos, 7) === peg$c62) {
6533
- s1 = peg$c62;
6727
+ if (input.substr(peg$currPos, 7) === peg$c63) {
6728
+ s1 = peg$c63;
6534
6729
  peg$currPos += 7;
6535
6730
  } else {
6536
6731
  s1 = peg$FAILED;
6537
6732
  if (peg$silentFails === 0) {
6538
- peg$fail(peg$e65);
6733
+ peg$fail(peg$e66);
6539
6734
  }
6540
6735
  }
6541
6736
  if (s1 === peg$FAILED) {
6542
- if (input.substr(peg$currPos, 3) === peg$c63) {
6543
- s1 = peg$c63;
6737
+ if (input.substr(peg$currPos, 3) === peg$c64) {
6738
+ s1 = peg$c64;
6544
6739
  peg$currPos += 3;
6545
6740
  } else {
6546
6741
  s1 = peg$FAILED;
6547
6742
  if (peg$silentFails === 0) {
6548
- peg$fail(peg$e66);
6743
+ peg$fail(peg$e67);
6549
6744
  }
6550
6745
  }
6551
6746
  if (s1 === peg$FAILED) {
6552
- if (input.substr(peg$currPos, 4) === peg$c65) {
6553
- s1 = peg$c65;
6747
+ if (input.substr(peg$currPos, 4) === peg$c66) {
6748
+ s1 = peg$c66;
6554
6749
  peg$currPos += 4;
6555
6750
  } else {
6556
6751
  s1 = peg$FAILED;
6557
6752
  if (peg$silentFails === 0) {
6558
- peg$fail(peg$e68);
6753
+ peg$fail(peg$e69);
6559
6754
  }
6560
6755
  }
6561
6756
  if (s1 === peg$FAILED) {
6562
- if (input.substr(peg$currPos, 3) === peg$c66) {
6563
- s1 = peg$c66;
6757
+ if (input.substr(peg$currPos, 3) === peg$c67) {
6758
+ s1 = peg$c67;
6564
6759
  peg$currPos += 3;
6565
6760
  } else {
6566
6761
  s1 = peg$FAILED;
6567
6762
  if (peg$silentFails === 0) {
6568
- peg$fail(peg$e69);
6763
+ peg$fail(peg$e70);
6569
6764
  }
6570
6765
  }
6571
6766
  if (s1 === peg$FAILED) {
6572
- if (input.substr(peg$currPos, 10) === peg$c67) {
6573
- s1 = peg$c67;
6767
+ if (input.substr(peg$currPos, 10) === peg$c68) {
6768
+ s1 = peg$c68;
6574
6769
  peg$currPos += 10;
6575
6770
  } else {
6576
6771
  s1 = peg$FAILED;
6577
6772
  if (peg$silentFails === 0) {
6578
- peg$fail(peg$e70);
6773
+ peg$fail(peg$e71);
6579
6774
  }
6580
6775
  }
6581
6776
  if (s1 === peg$FAILED) {
6582
- if (input.substr(peg$currPos, 5) === peg$c64) {
6583
- s1 = peg$c64;
6777
+ if (input.substr(peg$currPos, 5) === peg$c65) {
6778
+ s1 = peg$c65;
6584
6779
  peg$currPos += 5;
6585
6780
  } else {
6586
6781
  s1 = peg$FAILED;
6587
6782
  if (peg$silentFails === 0) {
6588
- peg$fail(peg$e67);
6783
+ peg$fail(peg$e68);
6589
6784
  }
6590
6785
  }
6591
6786
  if (s1 === peg$FAILED) {
6592
- if (input.substr(peg$currPos, 6) === peg$c68) {
6593
- s1 = peg$c68;
6787
+ if (input.substr(peg$currPos, 6) === peg$c69) {
6788
+ s1 = peg$c69;
6594
6789
  peg$currPos += 6;
6595
6790
  } else {
6596
6791
  s1 = peg$FAILED;
6597
6792
  if (peg$silentFails === 0) {
6598
- peg$fail(peg$e71);
6793
+ peg$fail(peg$e72);
6599
6794
  }
6600
6795
  }
6601
6796
  if (s1 === peg$FAILED) {
6602
- if (input.substr(peg$currPos, 11) === peg$c69) {
6603
- s1 = peg$c69;
6797
+ if (input.substr(peg$currPos, 11) === peg$c70) {
6798
+ s1 = peg$c70;
6604
6799
  peg$currPos += 11;
6605
6800
  } else {
6606
6801
  s1 = peg$FAILED;
6607
6802
  if (peg$silentFails === 0) {
6608
- peg$fail(peg$e72);
6803
+ peg$fail(peg$e73);
6609
6804
  }
6610
6805
  }
6611
6806
  if (s1 === peg$FAILED) {
6612
- if (input.substr(peg$currPos, 6) === peg$c3) {
6613
- s1 = peg$c3;
6807
+ if (input.substr(peg$currPos, 6) === peg$c20) {
6808
+ s1 = peg$c20;
6614
6809
  peg$currPos += 6;
6615
6810
  } else {
6616
6811
  s1 = peg$FAILED;
6617
6812
  if (peg$silentFails === 0) {
6618
- peg$fail(peg$e3);
6813
+ peg$fail(peg$e23);
6619
6814
  }
6620
6815
  }
6621
6816
  if (s1 === peg$FAILED) {
6622
- if (input.substr(peg$currPos, 9) === peg$c4) {
6623
- s1 = peg$c4;
6624
- peg$currPos += 9;
6817
+ if (input.substr(peg$currPos, 6) === peg$c3) {
6818
+ s1 = peg$c3;
6819
+ peg$currPos += 6;
6625
6820
  } else {
6626
6821
  s1 = peg$FAILED;
6627
6822
  if (peg$silentFails === 0) {
6628
- peg$fail(peg$e4);
6823
+ peg$fail(peg$e3);
6629
6824
  }
6630
6825
  }
6631
6826
  if (s1 === peg$FAILED) {
6632
- if (input.substr(peg$currPos, 3) === peg$c12) {
6633
- s1 = peg$c12;
6634
- peg$currPos += 3;
6827
+ if (input.substr(peg$currPos, 9) === peg$c4) {
6828
+ s1 = peg$c4;
6829
+ peg$currPos += 9;
6635
6830
  } else {
6636
6831
  s1 = peg$FAILED;
6637
6832
  if (peg$silentFails === 0) {
6638
- peg$fail(peg$e12);
6833
+ peg$fail(peg$e4);
6639
6834
  }
6640
6835
  }
6641
6836
  if (s1 === peg$FAILED) {
6642
- if (input.substr(peg$currPos, 4) === peg$c15) {
6643
- s1 = peg$c15;
6644
- peg$currPos += 4;
6837
+ if (input.substr(peg$currPos, 3) === peg$c12) {
6838
+ s1 = peg$c12;
6839
+ peg$currPos += 3;
6645
6840
  } else {
6646
6841
  s1 = peg$FAILED;
6647
6842
  if (peg$silentFails === 0) {
6648
- peg$fail(peg$e15);
6843
+ peg$fail(peg$e12);
6649
6844
  }
6650
6845
  }
6651
6846
  if (s1 === peg$FAILED) {
6652
- if (input.substr(peg$currPos, 4) === peg$c16) {
6653
- s1 = peg$c16;
6847
+ if (input.substr(peg$currPos, 4) === peg$c15) {
6848
+ s1 = peg$c15;
6654
6849
  peg$currPos += 4;
6655
6850
  } else {
6656
6851
  s1 = peg$FAILED;
6657
6852
  if (peg$silentFails === 0) {
6658
- peg$fail(peg$e16);
6853
+ peg$fail(peg$e15);
6854
+ }
6855
+ }
6856
+ if (s1 === peg$FAILED) {
6857
+ if (input.substr(peg$currPos, 4) === peg$c16) {
6858
+ s1 = peg$c16;
6859
+ peg$currPos += 4;
6860
+ } else {
6861
+ s1 = peg$FAILED;
6862
+ if (peg$silentFails === 0) {
6863
+ peg$fail(peg$e16);
6864
+ }
6659
6865
  }
6660
6866
  }
6661
6867
  }
@@ -6740,7 +6946,7 @@ function peg$parse(input, options) {
6740
6946
  } else {
6741
6947
  s0 = peg$FAILED;
6742
6948
  if (peg$silentFails === 0) {
6743
- peg$fail(peg$e77);
6949
+ peg$fail(peg$e78);
6744
6950
  }
6745
6951
  }
6746
6952
  return s0;
@@ -6773,12 +6979,12 @@ function peg$parse(input, options) {
6773
6979
  peg$silentFails++;
6774
6980
  s0 = peg$currPos;
6775
6981
  if (input.charCodeAt(peg$currPos) === 34) {
6776
- s1 = peg$c71;
6982
+ s1 = peg$c72;
6777
6983
  peg$currPos++;
6778
6984
  } else {
6779
6985
  s1 = peg$FAILED;
6780
6986
  if (peg$silentFails === 0) {
6781
- peg$fail(peg$e79);
6987
+ peg$fail(peg$e80);
6782
6988
  }
6783
6989
  }
6784
6990
  if (s1 !== peg$FAILED) {
@@ -6789,17 +6995,17 @@ function peg$parse(input, options) {
6789
6995
  s3 = peg$parseDoubleStringChar();
6790
6996
  }
6791
6997
  if (input.charCodeAt(peg$currPos) === 34) {
6792
- s3 = peg$c71;
6998
+ s3 = peg$c72;
6793
6999
  peg$currPos++;
6794
7000
  } else {
6795
7001
  s3 = peg$FAILED;
6796
7002
  if (peg$silentFails === 0) {
6797
- peg$fail(peg$e79);
7003
+ peg$fail(peg$e80);
6798
7004
  }
6799
7005
  }
6800
7006
  if (s3 !== peg$FAILED) {
6801
7007
  peg$savedPos = s0;
6802
- s0 = peg$f97(s2);
7008
+ s0 = peg$f98(s2);
6803
7009
  } else {
6804
7010
  peg$currPos = s0;
6805
7011
  s0 = peg$FAILED;
@@ -6811,12 +7017,12 @@ function peg$parse(input, options) {
6811
7017
  if (s0 === peg$FAILED) {
6812
7018
  s0 = peg$currPos;
6813
7019
  if (input.charCodeAt(peg$currPos) === 39) {
6814
- s1 = peg$c72;
7020
+ s1 = peg$c73;
6815
7021
  peg$currPos++;
6816
7022
  } else {
6817
7023
  s1 = peg$FAILED;
6818
7024
  if (peg$silentFails === 0) {
6819
- peg$fail(peg$e80);
7025
+ peg$fail(peg$e81);
6820
7026
  }
6821
7027
  }
6822
7028
  if (s1 !== peg$FAILED) {
@@ -6827,17 +7033,17 @@ function peg$parse(input, options) {
6827
7033
  s3 = peg$parseSingleStringChar();
6828
7034
  }
6829
7035
  if (input.charCodeAt(peg$currPos) === 39) {
6830
- s3 = peg$c72;
7036
+ s3 = peg$c73;
6831
7037
  peg$currPos++;
6832
7038
  } else {
6833
7039
  s3 = peg$FAILED;
6834
7040
  if (peg$silentFails === 0) {
6835
- peg$fail(peg$e80);
7041
+ peg$fail(peg$e81);
6836
7042
  }
6837
7043
  }
6838
7044
  if (s3 !== peg$FAILED) {
6839
7045
  peg$savedPos = s0;
6840
- s0 = peg$f98(s2);
7046
+ s0 = peg$f99(s2);
6841
7047
  } else {
6842
7048
  peg$currPos = s0;
6843
7049
  s0 = peg$FAILED;
@@ -6851,7 +7057,7 @@ function peg$parse(input, options) {
6851
7057
  if (s0 === peg$FAILED) {
6852
7058
  s1 = peg$FAILED;
6853
7059
  if (peg$silentFails === 0) {
6854
- peg$fail(peg$e78);
7060
+ peg$fail(peg$e79);
6855
7061
  }
6856
7062
  }
6857
7063
  return s0;
@@ -6862,12 +7068,12 @@ function peg$parse(input, options) {
6862
7068
  s1 = peg$currPos;
6863
7069
  peg$silentFails++;
6864
7070
  if (input.charCodeAt(peg$currPos) === 34) {
6865
- s2 = peg$c71;
7071
+ s2 = peg$c72;
6866
7072
  peg$currPos++;
6867
7073
  } else {
6868
7074
  s2 = peg$FAILED;
6869
7075
  if (peg$silentFails === 0) {
6870
- peg$fail(peg$e79);
7076
+ peg$fail(peg$e80);
6871
7077
  }
6872
7078
  }
6873
7079
  peg$silentFails--;
@@ -6881,12 +7087,12 @@ function peg$parse(input, options) {
6881
7087
  s2 = peg$currPos;
6882
7088
  peg$silentFails++;
6883
7089
  if (input.charCodeAt(peg$currPos) === 92) {
6884
- s3 = peg$c73;
7090
+ s3 = peg$c74;
6885
7091
  peg$currPos++;
6886
7092
  } else {
6887
7093
  s3 = peg$FAILED;
6888
7094
  if (peg$silentFails === 0) {
6889
- peg$fail(peg$e81);
7095
+ peg$fail(peg$e82);
6890
7096
  }
6891
7097
  }
6892
7098
  peg$silentFails--;
@@ -6908,7 +7114,7 @@ function peg$parse(input, options) {
6908
7114
  }
6909
7115
  if (s3 !== peg$FAILED) {
6910
7116
  peg$savedPos = s0;
6911
- s0 = peg$f99(s3);
7117
+ s0 = peg$f100(s3);
6912
7118
  } else {
6913
7119
  peg$currPos = s0;
6914
7120
  s0 = peg$FAILED;
@@ -6924,19 +7130,19 @@ function peg$parse(input, options) {
6924
7130
  if (s0 === peg$FAILED) {
6925
7131
  s0 = peg$currPos;
6926
7132
  if (input.charCodeAt(peg$currPos) === 92) {
6927
- s1 = peg$c73;
7133
+ s1 = peg$c74;
6928
7134
  peg$currPos++;
6929
7135
  } else {
6930
7136
  s1 = peg$FAILED;
6931
7137
  if (peg$silentFails === 0) {
6932
- peg$fail(peg$e81);
7138
+ peg$fail(peg$e82);
6933
7139
  }
6934
7140
  }
6935
7141
  if (s1 !== peg$FAILED) {
6936
7142
  s2 = peg$parseEscapeSequence();
6937
7143
  if (s2 !== peg$FAILED) {
6938
7144
  peg$savedPos = s0;
6939
- s0 = peg$f100(s2);
7145
+ s0 = peg$f101(s2);
6940
7146
  } else {
6941
7147
  peg$currPos = s0;
6942
7148
  s0 = peg$FAILED;
@@ -6954,12 +7160,12 @@ function peg$parse(input, options) {
6954
7160
  s1 = peg$currPos;
6955
7161
  peg$silentFails++;
6956
7162
  if (input.charCodeAt(peg$currPos) === 39) {
6957
- s2 = peg$c72;
7163
+ s2 = peg$c73;
6958
7164
  peg$currPos++;
6959
7165
  } else {
6960
7166
  s2 = peg$FAILED;
6961
7167
  if (peg$silentFails === 0) {
6962
- peg$fail(peg$e80);
7168
+ peg$fail(peg$e81);
6963
7169
  }
6964
7170
  }
6965
7171
  peg$silentFails--;
@@ -6973,12 +7179,12 @@ function peg$parse(input, options) {
6973
7179
  s2 = peg$currPos;
6974
7180
  peg$silentFails++;
6975
7181
  if (input.charCodeAt(peg$currPos) === 92) {
6976
- s3 = peg$c73;
7182
+ s3 = peg$c74;
6977
7183
  peg$currPos++;
6978
7184
  } else {
6979
7185
  s3 = peg$FAILED;
6980
7186
  if (peg$silentFails === 0) {
6981
- peg$fail(peg$e81);
7187
+ peg$fail(peg$e82);
6982
7188
  }
6983
7189
  }
6984
7190
  peg$silentFails--;
@@ -7000,7 +7206,7 @@ function peg$parse(input, options) {
7000
7206
  }
7001
7207
  if (s3 !== peg$FAILED) {
7002
7208
  peg$savedPos = s0;
7003
- s0 = peg$f101(s3);
7209
+ s0 = peg$f102(s3);
7004
7210
  } else {
7005
7211
  peg$currPos = s0;
7006
7212
  s0 = peg$FAILED;
@@ -7016,19 +7222,19 @@ function peg$parse(input, options) {
7016
7222
  if (s0 === peg$FAILED) {
7017
7223
  s0 = peg$currPos;
7018
7224
  if (input.charCodeAt(peg$currPos) === 92) {
7019
- s1 = peg$c73;
7225
+ s1 = peg$c74;
7020
7226
  peg$currPos++;
7021
7227
  } else {
7022
7228
  s1 = peg$FAILED;
7023
7229
  if (peg$silentFails === 0) {
7024
- peg$fail(peg$e81);
7230
+ peg$fail(peg$e82);
7025
7231
  }
7026
7232
  }
7027
7233
  if (s1 !== peg$FAILED) {
7028
7234
  s2 = peg$parseEscapeSequence();
7029
7235
  if (s2 !== peg$FAILED) {
7030
7236
  peg$savedPos = s0;
7031
- s0 = peg$f102(s2);
7237
+ s0 = peg$f103(s2);
7032
7238
  } else {
7033
7239
  peg$currPos = s0;
7034
7240
  s0 = peg$FAILED;
@@ -7044,97 +7250,97 @@ function peg$parse(input, options) {
7044
7250
  let s0, s1;
7045
7251
  s0 = peg$currPos;
7046
7252
  if (input.charCodeAt(peg$currPos) === 110) {
7047
- s1 = peg$c74;
7253
+ s1 = peg$c75;
7048
7254
  peg$currPos++;
7049
7255
  } else {
7050
7256
  s1 = peg$FAILED;
7051
7257
  if (peg$silentFails === 0) {
7052
- peg$fail(peg$e82);
7258
+ peg$fail(peg$e83);
7053
7259
  }
7054
7260
  }
7055
7261
  if (s1 !== peg$FAILED) {
7056
7262
  peg$savedPos = s0;
7057
- s1 = peg$f103();
7263
+ s1 = peg$f104();
7058
7264
  }
7059
7265
  s0 = s1;
7060
7266
  if (s0 === peg$FAILED) {
7061
7267
  s0 = peg$currPos;
7062
7268
  if (input.charCodeAt(peg$currPos) === 114) {
7063
- s1 = peg$c75;
7269
+ s1 = peg$c76;
7064
7270
  peg$currPos++;
7065
7271
  } else {
7066
7272
  s1 = peg$FAILED;
7067
7273
  if (peg$silentFails === 0) {
7068
- peg$fail(peg$e83);
7274
+ peg$fail(peg$e84);
7069
7275
  }
7070
7276
  }
7071
7277
  if (s1 !== peg$FAILED) {
7072
7278
  peg$savedPos = s0;
7073
- s1 = peg$f104();
7279
+ s1 = peg$f105();
7074
7280
  }
7075
7281
  s0 = s1;
7076
7282
  if (s0 === peg$FAILED) {
7077
7283
  s0 = peg$currPos;
7078
7284
  if (input.charCodeAt(peg$currPos) === 116) {
7079
- s1 = peg$c76;
7285
+ s1 = peg$c77;
7080
7286
  peg$currPos++;
7081
7287
  } else {
7082
7288
  s1 = peg$FAILED;
7083
7289
  if (peg$silentFails === 0) {
7084
- peg$fail(peg$e84);
7290
+ peg$fail(peg$e85);
7085
7291
  }
7086
7292
  }
7087
7293
  if (s1 !== peg$FAILED) {
7088
7294
  peg$savedPos = s0;
7089
- s1 = peg$f105();
7295
+ s1 = peg$f106();
7090
7296
  }
7091
7297
  s0 = s1;
7092
7298
  if (s0 === peg$FAILED) {
7093
7299
  s0 = peg$currPos;
7094
7300
  if (input.charCodeAt(peg$currPos) === 92) {
7095
- s1 = peg$c73;
7301
+ s1 = peg$c74;
7096
7302
  peg$currPos++;
7097
7303
  } else {
7098
7304
  s1 = peg$FAILED;
7099
7305
  if (peg$silentFails === 0) {
7100
- peg$fail(peg$e81);
7306
+ peg$fail(peg$e82);
7101
7307
  }
7102
7308
  }
7103
7309
  if (s1 !== peg$FAILED) {
7104
7310
  peg$savedPos = s0;
7105
- s1 = peg$f106();
7311
+ s1 = peg$f107();
7106
7312
  }
7107
7313
  s0 = s1;
7108
7314
  if (s0 === peg$FAILED) {
7109
7315
  s0 = peg$currPos;
7110
7316
  if (input.charCodeAt(peg$currPos) === 34) {
7111
- s1 = peg$c71;
7317
+ s1 = peg$c72;
7112
7318
  peg$currPos++;
7113
7319
  } else {
7114
7320
  s1 = peg$FAILED;
7115
7321
  if (peg$silentFails === 0) {
7116
- peg$fail(peg$e79);
7322
+ peg$fail(peg$e80);
7117
7323
  }
7118
7324
  }
7119
7325
  if (s1 !== peg$FAILED) {
7120
7326
  peg$savedPos = s0;
7121
- s1 = peg$f107();
7327
+ s1 = peg$f108();
7122
7328
  }
7123
7329
  s0 = s1;
7124
7330
  if (s0 === peg$FAILED) {
7125
7331
  s0 = peg$currPos;
7126
7332
  if (input.charCodeAt(peg$currPos) === 39) {
7127
- s1 = peg$c72;
7333
+ s1 = peg$c73;
7128
7334
  peg$currPos++;
7129
7335
  } else {
7130
7336
  s1 = peg$FAILED;
7131
7337
  if (peg$silentFails === 0) {
7132
- peg$fail(peg$e80);
7338
+ peg$fail(peg$e81);
7133
7339
  }
7134
7340
  }
7135
7341
  if (s1 !== peg$FAILED) {
7136
7342
  peg$savedPos = s0;
7137
- s1 = peg$f108();
7343
+ s1 = peg$f109();
7138
7344
  }
7139
7345
  s0 = s1;
7140
7346
  }
@@ -7149,12 +7355,12 @@ function peg$parse(input, options) {
7149
7355
  peg$silentFails++;
7150
7356
  s0 = peg$currPos;
7151
7357
  if (input.charCodeAt(peg$currPos) === 45) {
7152
- s1 = peg$c77;
7358
+ s1 = peg$c78;
7153
7359
  peg$currPos++;
7154
7360
  } else {
7155
7361
  s1 = peg$FAILED;
7156
7362
  if (peg$silentFails === 0) {
7157
- peg$fail(peg$e86);
7363
+ peg$fail(peg$e87);
7158
7364
  }
7159
7365
  }
7160
7366
  if (s1 === peg$FAILED) {
@@ -7167,7 +7373,7 @@ function peg$parse(input, options) {
7167
7373
  } else {
7168
7374
  s3 = peg$FAILED;
7169
7375
  if (peg$silentFails === 0) {
7170
- peg$fail(peg$e74);
7376
+ peg$fail(peg$e75);
7171
7377
  }
7172
7378
  }
7173
7379
  if (s3 !== peg$FAILED) {
@@ -7179,7 +7385,7 @@ function peg$parse(input, options) {
7179
7385
  } else {
7180
7386
  s3 = peg$FAILED;
7181
7387
  if (peg$silentFails === 0) {
7182
- peg$fail(peg$e74);
7388
+ peg$fail(peg$e75);
7183
7389
  }
7184
7390
  }
7185
7391
  }
@@ -7189,12 +7395,12 @@ function peg$parse(input, options) {
7189
7395
  if (s2 !== peg$FAILED) {
7190
7396
  s3 = peg$currPos;
7191
7397
  if (input.charCodeAt(peg$currPos) === 46) {
7192
- s4 = peg$c78;
7398
+ s4 = peg$c79;
7193
7399
  peg$currPos++;
7194
7400
  } else {
7195
7401
  s4 = peg$FAILED;
7196
7402
  if (peg$silentFails === 0) {
7197
- peg$fail(peg$e87);
7403
+ peg$fail(peg$e88);
7198
7404
  }
7199
7405
  }
7200
7406
  if (s4 !== peg$FAILED) {
@@ -7205,7 +7411,7 @@ function peg$parse(input, options) {
7205
7411
  } else {
7206
7412
  s6 = peg$FAILED;
7207
7413
  if (peg$silentFails === 0) {
7208
- peg$fail(peg$e74);
7414
+ peg$fail(peg$e75);
7209
7415
  }
7210
7416
  }
7211
7417
  if (s6 !== peg$FAILED) {
@@ -7217,7 +7423,7 @@ function peg$parse(input, options) {
7217
7423
  } else {
7218
7424
  s6 = peg$FAILED;
7219
7425
  if (peg$silentFails === 0) {
7220
- peg$fail(peg$e74);
7426
+ peg$fail(peg$e75);
7221
7427
  }
7222
7428
  }
7223
7429
  }
@@ -7239,7 +7445,7 @@ function peg$parse(input, options) {
7239
7445
  s3 = null;
7240
7446
  }
7241
7447
  peg$savedPos = s0;
7242
- s0 = peg$f109(s1, s2, s3);
7448
+ s0 = peg$f110(s1, s2, s3);
7243
7449
  } else {
7244
7450
  peg$currPos = s0;
7245
7451
  s0 = peg$FAILED;
@@ -7248,7 +7454,7 @@ function peg$parse(input, options) {
7248
7454
  if (s0 === peg$FAILED) {
7249
7455
  s1 = peg$FAILED;
7250
7456
  if (peg$silentFails === 0) {
7251
- peg$fail(peg$e85);
7457
+ peg$fail(peg$e86);
7252
7458
  }
7253
7459
  }
7254
7460
  return s0;
@@ -7258,12 +7464,12 @@ function peg$parse(input, options) {
7258
7464
  peg$silentFails++;
7259
7465
  s0 = peg$currPos;
7260
7466
  if (input.charCodeAt(peg$currPos) === 45) {
7261
- s1 = peg$c77;
7467
+ s1 = peg$c78;
7262
7468
  peg$currPos++;
7263
7469
  } else {
7264
7470
  s1 = peg$FAILED;
7265
7471
  if (peg$silentFails === 0) {
7266
- peg$fail(peg$e86);
7472
+ peg$fail(peg$e87);
7267
7473
  }
7268
7474
  }
7269
7475
  if (s1 === peg$FAILED) {
@@ -7276,7 +7482,7 @@ function peg$parse(input, options) {
7276
7482
  } else {
7277
7483
  s3 = peg$FAILED;
7278
7484
  if (peg$silentFails === 0) {
7279
- peg$fail(peg$e74);
7485
+ peg$fail(peg$e75);
7280
7486
  }
7281
7487
  }
7282
7488
  if (s3 !== peg$FAILED) {
@@ -7288,7 +7494,7 @@ function peg$parse(input, options) {
7288
7494
  } else {
7289
7495
  s3 = peg$FAILED;
7290
7496
  if (peg$silentFails === 0) {
7291
- peg$fail(peg$e74);
7497
+ peg$fail(peg$e75);
7292
7498
  }
7293
7499
  }
7294
7500
  }
@@ -7298,12 +7504,12 @@ function peg$parse(input, options) {
7298
7504
  if (s2 !== peg$FAILED) {
7299
7505
  s3 = peg$currPos;
7300
7506
  if (input.charCodeAt(peg$currPos) === 46) {
7301
- s4 = peg$c78;
7507
+ s4 = peg$c79;
7302
7508
  peg$currPos++;
7303
7509
  } else {
7304
7510
  s4 = peg$FAILED;
7305
7511
  if (peg$silentFails === 0) {
7306
- peg$fail(peg$e87);
7512
+ peg$fail(peg$e88);
7307
7513
  }
7308
7514
  }
7309
7515
  if (s4 !== peg$FAILED) {
@@ -7314,7 +7520,7 @@ function peg$parse(input, options) {
7314
7520
  } else {
7315
7521
  s6 = peg$FAILED;
7316
7522
  if (peg$silentFails === 0) {
7317
- peg$fail(peg$e74);
7523
+ peg$fail(peg$e75);
7318
7524
  }
7319
7525
  }
7320
7526
  if (s6 !== peg$FAILED) {
@@ -7326,7 +7532,7 @@ function peg$parse(input, options) {
7326
7532
  } else {
7327
7533
  s6 = peg$FAILED;
7328
7534
  if (peg$silentFails === 0) {
7329
- peg$fail(peg$e74);
7535
+ peg$fail(peg$e75);
7330
7536
  }
7331
7537
  }
7332
7538
  }
@@ -7347,63 +7553,63 @@ function peg$parse(input, options) {
7347
7553
  if (s3 === peg$FAILED) {
7348
7554
  s3 = null;
7349
7555
  }
7350
- if (input.substr(peg$currPos, 2) === peg$c79) {
7351
- s4 = peg$c79;
7556
+ if (input.substr(peg$currPos, 2) === peg$c80) {
7557
+ s4 = peg$c80;
7352
7558
  peg$currPos += 2;
7353
7559
  } else {
7354
7560
  s4 = peg$FAILED;
7355
7561
  if (peg$silentFails === 0) {
7356
- peg$fail(peg$e89);
7562
+ peg$fail(peg$e90);
7357
7563
  }
7358
7564
  }
7359
7565
  if (s4 === peg$FAILED) {
7360
7566
  if (input.charCodeAt(peg$currPos) === 37) {
7361
- s4 = peg$c80;
7567
+ s4 = peg$c81;
7362
7568
  peg$currPos++;
7363
7569
  } else {
7364
7570
  s4 = peg$FAILED;
7365
7571
  if (peg$silentFails === 0) {
7366
- peg$fail(peg$e90);
7572
+ peg$fail(peg$e91);
7367
7573
  }
7368
7574
  }
7369
7575
  if (s4 === peg$FAILED) {
7370
- if (input.substr(peg$currPos, 2) === peg$c81) {
7371
- s4 = peg$c81;
7576
+ if (input.substr(peg$currPos, 2) === peg$c82) {
7577
+ s4 = peg$c82;
7372
7578
  peg$currPos += 2;
7373
7579
  } else {
7374
7580
  s4 = peg$FAILED;
7375
7581
  if (peg$silentFails === 0) {
7376
- peg$fail(peg$e91);
7582
+ peg$fail(peg$e92);
7377
7583
  }
7378
7584
  }
7379
7585
  if (s4 === peg$FAILED) {
7380
- if (input.substr(peg$currPos, 3) === peg$c82) {
7381
- s4 = peg$c82;
7586
+ if (input.substr(peg$currPos, 3) === peg$c83) {
7587
+ s4 = peg$c83;
7382
7588
  peg$currPos += 3;
7383
7589
  } else {
7384
7590
  s4 = peg$FAILED;
7385
7591
  if (peg$silentFails === 0) {
7386
- peg$fail(peg$e92);
7592
+ peg$fail(peg$e93);
7387
7593
  }
7388
7594
  }
7389
7595
  if (s4 === peg$FAILED) {
7390
- if (input.substr(peg$currPos, 2) === peg$c83) {
7391
- s4 = peg$c83;
7596
+ if (input.substr(peg$currPos, 2) === peg$c84) {
7597
+ s4 = peg$c84;
7392
7598
  peg$currPos += 2;
7393
7599
  } else {
7394
7600
  s4 = peg$FAILED;
7395
7601
  if (peg$silentFails === 0) {
7396
- peg$fail(peg$e93);
7602
+ peg$fail(peg$e94);
7397
7603
  }
7398
7604
  }
7399
7605
  if (s4 === peg$FAILED) {
7400
- if (input.substr(peg$currPos, 2) === peg$c84) {
7401
- s4 = peg$c84;
7606
+ if (input.substr(peg$currPos, 2) === peg$c85) {
7607
+ s4 = peg$c85;
7402
7608
  peg$currPos += 2;
7403
7609
  } else {
7404
7610
  s4 = peg$FAILED;
7405
7611
  if (peg$silentFails === 0) {
7406
- peg$fail(peg$e94);
7612
+ peg$fail(peg$e95);
7407
7613
  }
7408
7614
  }
7409
7615
  }
@@ -7413,7 +7619,7 @@ function peg$parse(input, options) {
7413
7619
  }
7414
7620
  if (s4 !== peg$FAILED) {
7415
7621
  peg$savedPos = s0;
7416
- s0 = peg$f110(s1, s2, s3, s4);
7622
+ s0 = peg$f111(s1, s2, s3, s4);
7417
7623
  } else {
7418
7624
  peg$currPos = s0;
7419
7625
  s0 = peg$FAILED;
@@ -7426,7 +7632,7 @@ function peg$parse(input, options) {
7426
7632
  if (s0 === peg$FAILED) {
7427
7633
  s1 = peg$FAILED;
7428
7634
  if (peg$silentFails === 0) {
7429
- peg$fail(peg$e88);
7635
+ peg$fail(peg$e89);
7430
7636
  }
7431
7637
  }
7432
7638
  return s0;
@@ -7435,34 +7641,34 @@ function peg$parse(input, options) {
7435
7641
  let s0, s1;
7436
7642
  peg$silentFails++;
7437
7643
  s0 = peg$currPos;
7438
- if (input.substr(peg$currPos, 4) === peg$c85) {
7439
- s1 = peg$c85;
7644
+ if (input.substr(peg$currPos, 4) === peg$c86) {
7645
+ s1 = peg$c86;
7440
7646
  peg$currPos += 4;
7441
7647
  } else {
7442
7648
  s1 = peg$FAILED;
7443
7649
  if (peg$silentFails === 0) {
7444
- peg$fail(peg$e96);
7650
+ peg$fail(peg$e97);
7445
7651
  }
7446
7652
  }
7447
7653
  if (s1 !== peg$FAILED) {
7448
7654
  peg$savedPos = s0;
7449
- s1 = peg$f111();
7655
+ s1 = peg$f112();
7450
7656
  }
7451
7657
  s0 = s1;
7452
7658
  if (s0 === peg$FAILED) {
7453
7659
  s0 = peg$currPos;
7454
- if (input.substr(peg$currPos, 5) === peg$c86) {
7455
- s1 = peg$c86;
7660
+ if (input.substr(peg$currPos, 5) === peg$c87) {
7661
+ s1 = peg$c87;
7456
7662
  peg$currPos += 5;
7457
7663
  } else {
7458
7664
  s1 = peg$FAILED;
7459
7665
  if (peg$silentFails === 0) {
7460
- peg$fail(peg$e97);
7666
+ peg$fail(peg$e98);
7461
7667
  }
7462
7668
  }
7463
7669
  if (s1 !== peg$FAILED) {
7464
7670
  peg$savedPos = s0;
7465
- s1 = peg$f112();
7671
+ s1 = peg$f113();
7466
7672
  }
7467
7673
  s0 = s1;
7468
7674
  }
@@ -7470,7 +7676,7 @@ function peg$parse(input, options) {
7470
7676
  if (s0 === peg$FAILED) {
7471
7677
  s1 = peg$FAILED;
7472
7678
  if (peg$silentFails === 0) {
7473
- peg$fail(peg$e95);
7679
+ peg$fail(peg$e96);
7474
7680
  }
7475
7681
  }
7476
7682
  return s0;
@@ -7485,7 +7691,7 @@ function peg$parse(input, options) {
7485
7691
  } else {
7486
7692
  s1 = peg$FAILED;
7487
7693
  if (peg$silentFails === 0) {
7488
- peg$fail(peg$e99);
7694
+ peg$fail(peg$e100);
7489
7695
  }
7490
7696
  }
7491
7697
  if (s1 !== peg$FAILED) {
@@ -7496,7 +7702,7 @@ function peg$parse(input, options) {
7496
7702
  } else {
7497
7703
  s3 = peg$FAILED;
7498
7704
  if (peg$silentFails === 0) {
7499
- peg$fail(peg$e77);
7705
+ peg$fail(peg$e78);
7500
7706
  }
7501
7707
  }
7502
7708
  while (s3 !== peg$FAILED) {
@@ -7507,12 +7713,12 @@ function peg$parse(input, options) {
7507
7713
  } else {
7508
7714
  s3 = peg$FAILED;
7509
7715
  if (peg$silentFails === 0) {
7510
- peg$fail(peg$e77);
7716
+ peg$fail(peg$e78);
7511
7717
  }
7512
7718
  }
7513
7719
  }
7514
7720
  peg$savedPos = s0;
7515
- s0 = peg$f113(s1, s2);
7721
+ s0 = peg$f114(s1, s2);
7516
7722
  } else {
7517
7723
  peg$currPos = s0;
7518
7724
  s0 = peg$FAILED;
@@ -7521,7 +7727,7 @@ function peg$parse(input, options) {
7521
7727
  if (s0 === peg$FAILED) {
7522
7728
  s1 = peg$FAILED;
7523
7729
  if (peg$silentFails === 0) {
7524
- peg$fail(peg$e98);
7730
+ peg$fail(peg$e99);
7525
7731
  }
7526
7732
  }
7527
7733
  return s0;
@@ -7530,12 +7736,12 @@ function peg$parse(input, options) {
7530
7736
  let s0, s1, s2, s3, s4, s5;
7531
7737
  s0 = peg$currPos;
7532
7738
  if (input.charCodeAt(peg$currPos) === 91) {
7533
- s1 = peg$c50;
7739
+ s1 = peg$c51;
7534
7740
  peg$currPos++;
7535
7741
  } else {
7536
7742
  s1 = peg$FAILED;
7537
7743
  if (peg$silentFails === 0) {
7538
- peg$fail(peg$e53);
7744
+ peg$fail(peg$e54);
7539
7745
  }
7540
7746
  }
7541
7747
  if (s1 !== peg$FAILED) {
@@ -7546,17 +7752,17 @@ function peg$parse(input, options) {
7546
7752
  }
7547
7753
  s4 = peg$parse_();
7548
7754
  if (input.charCodeAt(peg$currPos) === 93) {
7549
- s5 = peg$c51;
7755
+ s5 = peg$c52;
7550
7756
  peg$currPos++;
7551
7757
  } else {
7552
7758
  s5 = peg$FAILED;
7553
7759
  if (peg$silentFails === 0) {
7554
- peg$fail(peg$e54);
7760
+ peg$fail(peg$e55);
7555
7761
  }
7556
7762
  }
7557
7763
  if (s5 !== peg$FAILED) {
7558
7764
  peg$savedPos = s0;
7559
- s0 = peg$f114(s3);
7765
+ s0 = peg$f115(s3);
7560
7766
  } else {
7561
7767
  peg$currPos = s0;
7562
7768
  s0 = peg$FAILED;
@@ -7644,7 +7850,7 @@ function peg$parse(input, options) {
7644
7850
  s3 = null;
7645
7851
  }
7646
7852
  peg$savedPos = s0;
7647
- s0 = peg$f115(s1, s2);
7853
+ s0 = peg$f116(s1, s2);
7648
7854
  } else {
7649
7855
  peg$currPos = s0;
7650
7856
  s0 = peg$FAILED;
@@ -7698,7 +7904,7 @@ function peg$parse(input, options) {
7698
7904
  }
7699
7905
  if (s5 !== peg$FAILED) {
7700
7906
  peg$savedPos = s0;
7701
- s0 = peg$f116(s3);
7907
+ s0 = peg$f117(s3);
7702
7908
  } else {
7703
7909
  peg$currPos = s0;
7704
7910
  s0 = peg$FAILED;
@@ -7765,7 +7971,7 @@ function peg$parse(input, options) {
7765
7971
  }
7766
7972
  }
7767
7973
  peg$savedPos = s0;
7768
- s0 = peg$f117(s1, s2);
7974
+ s0 = peg$f118(s1, s2);
7769
7975
  } else {
7770
7976
  peg$currPos = s0;
7771
7977
  s0 = peg$FAILED;
@@ -7792,7 +7998,7 @@ function peg$parse(input, options) {
7792
7998
  s5 = peg$parseAttributeValue();
7793
7999
  if (s5 !== peg$FAILED) {
7794
8000
  peg$savedPos = s0;
7795
- s0 = peg$f118(s1, s5);
8001
+ s0 = peg$f119(s1, s5);
7796
8002
  } else {
7797
8003
  peg$currPos = s0;
7798
8004
  s0 = peg$FAILED;
@@ -7810,7 +8016,7 @@ function peg$parse(input, options) {
7810
8016
  s1 = peg$parseIdentifier();
7811
8017
  if (s1 !== peg$FAILED) {
7812
8018
  peg$savedPos = s0;
7813
- s1 = peg$f119(s1);
8019
+ s1 = peg$f120(s1);
7814
8020
  }
7815
8021
  s0 = s1;
7816
8022
  }
@@ -7843,7 +8049,7 @@ function peg$parse(input, options) {
7843
8049
  } else {
7844
8050
  s1 = peg$FAILED;
7845
8051
  if (peg$silentFails === 0) {
7846
- peg$fail(peg$e100);
8052
+ peg$fail(peg$e101);
7847
8053
  }
7848
8054
  }
7849
8055
  if (s1 !== peg$FAILED) {
@@ -7855,7 +8061,7 @@ function peg$parse(input, options) {
7855
8061
  } else {
7856
8062
  s1 = peg$FAILED;
7857
8063
  if (peg$silentFails === 0) {
7858
- peg$fail(peg$e100);
8064
+ peg$fail(peg$e101);
7859
8065
  }
7860
8066
  }
7861
8067
  }
@@ -7875,7 +8081,7 @@ function peg$parse(input, options) {
7875
8081
  if (s0 === peg$FAILED) {
7876
8082
  s1 = peg$FAILED;
7877
8083
  if (peg$silentFails === 0) {
7878
- peg$fail(peg$e101);
8084
+ peg$fail(peg$e102);
7879
8085
  }
7880
8086
  }
7881
8087
  return s0;
@@ -7900,7 +8106,7 @@ function peg$parse(input, options) {
7900
8106
  } else {
7901
8107
  s3 = peg$FAILED;
7902
8108
  if (peg$silentFails === 0) {
7903
- peg$fail(peg$e102);
8109
+ peg$fail(peg$e103);
7904
8110
  }
7905
8111
  }
7906
8112
  while (s3 !== peg$FAILED) {
@@ -7911,17 +8117,17 @@ function peg$parse(input, options) {
7911
8117
  } else {
7912
8118
  s3 = peg$FAILED;
7913
8119
  if (peg$silentFails === 0) {
7914
- peg$fail(peg$e102);
8120
+ peg$fail(peg$e103);
7915
8121
  }
7916
8122
  }
7917
8123
  }
7918
8124
  if (input.charCodeAt(peg$currPos) === 10) {
7919
- s3 = peg$c87;
8125
+ s3 = peg$c88;
7920
8126
  peg$currPos++;
7921
8127
  } else {
7922
8128
  s3 = peg$FAILED;
7923
8129
  if (peg$silentFails === 0) {
7924
- peg$fail(peg$e103);
8130
+ peg$fail(peg$e104);
7925
8131
  }
7926
8132
  }
7927
8133
  if (s3 === peg$FAILED) {
@@ -7974,13 +8180,13 @@ function peg$parse(input, options) {
7974
8180
  s3 = peg$currPos;
7975
8181
  s4 = peg$currPos;
7976
8182
  peg$silentFails++;
7977
- if (input.substr(peg$currPos, 2) === peg$c88) {
7978
- s5 = peg$c88;
8183
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8184
+ s5 = peg$c89;
7979
8185
  peg$currPos += 2;
7980
8186
  } else {
7981
8187
  s5 = peg$FAILED;
7982
8188
  if (peg$silentFails === 0) {
7983
- peg$fail(peg$e104);
8189
+ peg$fail(peg$e105);
7984
8190
  }
7985
8191
  }
7986
8192
  peg$silentFails--;
@@ -8016,13 +8222,13 @@ function peg$parse(input, options) {
8016
8222
  s3 = peg$currPos;
8017
8223
  s4 = peg$currPos;
8018
8224
  peg$silentFails++;
8019
- if (input.substr(peg$currPos, 2) === peg$c88) {
8020
- s5 = peg$c88;
8225
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8226
+ s5 = peg$c89;
8021
8227
  peg$currPos += 2;
8022
8228
  } else {
8023
8229
  s5 = peg$FAILED;
8024
8230
  if (peg$silentFails === 0) {
8025
- peg$fail(peg$e104);
8231
+ peg$fail(peg$e105);
8026
8232
  }
8027
8233
  }
8028
8234
  peg$silentFails--;
@@ -8054,13 +8260,13 @@ function peg$parse(input, options) {
8054
8260
  s3 = peg$FAILED;
8055
8261
  }
8056
8262
  }
8057
- if (input.substr(peg$currPos, 2) === peg$c88) {
8058
- s3 = peg$c88;
8263
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8264
+ s3 = peg$c89;
8059
8265
  peg$currPos += 2;
8060
8266
  } else {
8061
8267
  s3 = peg$FAILED;
8062
8268
  if (peg$silentFails === 0) {
8063
- peg$fail(peg$e104);
8269
+ peg$fail(peg$e105);
8064
8270
  }
8065
8271
  }
8066
8272
  if (s3 !== peg$FAILED) {
@@ -8235,6 +8441,7 @@ var GRAMMAR_ELEMENTS = {
8235
8441
  component: "Component",
8236
8442
  use: "ComponentUse",
8237
8443
  slot: "Slot",
8444
+ repeat: "Repeat",
8238
8445
  header: "Header",
8239
8446
  main: "Main",
8240
8447
  footer: "Footer",
@@ -8334,6 +8541,7 @@ var GRAMMAR_CHILD_KEYWORDS = [
8334
8541
  "group",
8335
8542
  "marker",
8336
8543
  "annotations",
8544
+ "repeat",
8337
8545
  "layout",
8338
8546
  "component",
8339
8547
  "use",
@@ -8725,6 +8933,16 @@ function printNodeLines(node, depth) {
8725
8933
  return componentDefinitionLines(node, depth);
8726
8934
  case "ComponentUse":
8727
8935
  return componentUseLines(node, depth);
8936
+ // `repeat 6 { … }` — the count prints bare, as the grammar's positional
8937
+ // `Integer`, which is why this cannot go through `containerLines` (that
8938
+ // helper's only pre-attribute segment is an optional *quoted* label).
8939
+ case "Repeat":
8940
+ return blockLines(
8941
+ depth,
8942
+ ["repeat", integerSegment(node, "count"), ...attrSegments(node, ["count"], node.type)],
8943
+ childrenLines(node, depth),
8944
+ "required"
8945
+ );
8728
8946
  // -- containers without a label ----------------------------------------
8729
8947
  case "Header":
8730
8948
  case "Main":
@@ -13251,6 +13469,12 @@ var COMPONENT_METADATA = {
13251
13469
  hasChildren: false,
13252
13470
  description: "Mark content insertion: bare inside a layout, or named inside a reusable component."
13253
13471
  },
13472
+ repeat: {
13473
+ category: "structure",
13474
+ attributes: [],
13475
+ hasChildren: true,
13476
+ 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."
13477
+ },
13254
13478
  header: {
13255
13479
  category: "layout",
13256
13480
  attributes: [...BOX_ATTRIBUTES, ...CONTAINER_ATTRIBUTES],
@@ -61824,6 +62048,7 @@ var HtmlRenderer = class extends BaseRenderer {
61824
62048
  * enabled so `renderNode` / `renderPage` can inject each node's path.
61825
62049
  */
61826
62050
  render(document) {
62051
+ document = expandRepeats(document);
61827
62052
  if (this.context.options.sourceAnchors) {
61828
62053
  this.pathMap = buildAnchorPathMap(document, this.pageIndexBase);
61829
62054
  }
@@ -63172,6 +63397,7 @@ function compactRuntimeInteractions(model, interactions) {
63172
63397
  }
63173
63398
  function renderSite(document, options = {}) {
63174
63399
  const prefix = options.classPrefix ?? DEFAULT_PREFIX2;
63400
+ document = expandRepeats(document);
63175
63401
  const model = buildSiteModel(document);
63176
63402
  const interactionModel = collectInteractions(document);
63177
63403
  const make = (idScope) => new HtmlRenderer({
@@ -63362,7 +63588,8 @@ var POSITIONAL_PROPS = {
63362
63588
  Layout: ["name"],
63363
63589
  Component: ["name"],
63364
63590
  ComponentUse: ["name", "namespace"],
63365
- Slot: ["name"]
63591
+ Slot: ["name"],
63592
+ Repeat: ["count"]
63366
63593
  };
63367
63594
  function declaredName(value) {
63368
63595
  const name = value?.trim();
@@ -63504,18 +63731,6 @@ function checkComponentContracts(ast, addError) {
63504
63731
  }
63505
63732
  slots.add(name);
63506
63733
  }
63507
- for (const [key, value] of Object.entries(node)) {
63508
- if (key === "loc" || key === "children" || typeof value !== "string") continue;
63509
- const name = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/.exec(value)?.[1];
63510
- if (name !== void 0 && !parameters.has(name) && !report(
63511
- node,
63512
- path,
63513
- `Unknown component parameter reference "$${name}" in component "${definition.name}"`,
63514
- key
63515
- )) {
63516
- return false;
63517
- }
63518
- }
63519
63734
  for (let childIndex = 0; childIndex < childrenOf2(node).length; childIndex++) {
63520
63735
  const child = childrenOf2(node)[childIndex];
63521
63736
  if (child && !inspect(child, `${path}.children[${childIndex}]`)) return false;
@@ -63526,6 +63741,17 @@ function checkComponentContracts(ast, addError) {
63526
63741
  const child = definition.children[childIndex];
63527
63742
  if (child && !inspect(child, `pages[${index}].children[${childIndex}]`)) return false;
63528
63743
  }
63744
+ for (const reference of collectParameterReferences(definition.children)) {
63745
+ if (parameters.has(reference.name)) continue;
63746
+ if (!report(
63747
+ reference.node,
63748
+ `pages[${index}]`,
63749
+ `Unknown component parameter reference "$${reference.name}" in component "${definition.name}"`,
63750
+ reference.key
63751
+ )) {
63752
+ return false;
63753
+ }
63754
+ }
63529
63755
  }
63530
63756
  const validateUse = (use, path) => {
63531
63757
  const definition = use.namespace === void 0 ? definitions.get(use.name) : void 0;
@@ -65306,27 +65532,24 @@ function validateComponentDefinitions(definitions, diagnostics) {
65306
65532
  slotNames.add(name);
65307
65533
  }
65308
65534
  }
65309
- for (const [key, value] of Object.entries(node)) {
65310
- if (key === "loc" || key === "children" || typeof value !== "string") continue;
65311
- const name = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/.exec(value)?.[1];
65312
- if (name !== void 0 && !parameterNames.has(name)) {
65313
- diagnostics.push({
65314
- code: "invalid-component-definition",
65315
- message: `Unknown parameter reference "$${name}" in component "${pending.namespace}:${pending.input.id}"`,
65316
- source: pending.input.source
65317
- });
65318
- invalid.add(pending.nodeId);
65319
- }
65320
- }
65321
65535
  for (const child of childNodes(node)) inspect(child);
65322
65536
  };
65323
65537
  for (const child of definition.children) inspect(child);
65538
+ for (const reference of collectParameterReferences(definition.children)) {
65539
+ if (parameterNames.has(reference.name)) continue;
65540
+ diagnostics.push({
65541
+ code: "invalid-component-definition",
65542
+ message: `Unknown parameter reference "$${reference.name}" in component "${pending.namespace}:${pending.input.id}"`,
65543
+ source: pending.input.source
65544
+ });
65545
+ invalid.add(pending.nodeId);
65546
+ }
65324
65547
  }
65325
65548
  return invalid;
65326
65549
  }
65327
65550
  function substituteTemplate(value, inputs) {
65328
65551
  if (typeof value === "string") {
65329
- const name = /^\$([a-zA-Z_][a-zA-Z0-9_-]*)$/.exec(value)?.[1];
65552
+ const name = parameterReferenceName(value);
65330
65553
  return name !== void 0 && name in inputs ? inputs[name] : value;
65331
65554
  }
65332
65555
  if (Array.isArray(value)) return value.map((item) => substituteTemplate(item, inputs));
@@ -65678,6 +65901,8 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65678
65901
  INTERACTIVE_ATTR_NAMES,
65679
65902
  LUCIDE_ICON_NAMES,
65680
65903
  NODE_TYPE_MAP,
65904
+ REPEAT_EXPANSION_BUDGET,
65905
+ RepeatBudgetError,
65681
65906
  TYPED_INTERACTION_ATTR,
65682
65907
  VALID_ATTRIBUTE_NAMES,
65683
65908
  VALID_COMPONENT_NAMES,
@@ -65692,6 +65917,7 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65692
65917
  calculateViewportScale,
65693
65918
  cloneNode,
65694
65919
  collectInteractions,
65920
+ collectParameterReferences,
65695
65921
  compileApp,
65696
65922
  contains,
65697
65923
  countNodes,
@@ -65703,6 +65929,7 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65703
65929
  diff,
65704
65930
  documentDefinitions,
65705
65931
  documentPages,
65932
+ expandRepeats,
65706
65933
  exportToFigma,
65707
65934
  exportToFigmaString,
65708
65935
  exportToJson,
@@ -65804,6 +66031,7 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65804
66031
  mapNodes,
65805
66032
  normalizeInteractionHandlers,
65806
66033
  normalizeStateGuard,
66034
+ parameterReferenceName,
65807
66035
  parse,
65808
66036
  parseViewportString,
65809
66037
  printWireframe,