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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.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,
@@ -72,6 +74,7 @@ __export(src_exports, {
72
74
  diff: () => diff,
73
75
  documentDefinitions: () => documentDefinitions,
74
76
  documentPages: () => documentPages,
77
+ expandRepeats: () => expandRepeats,
75
78
  exportToFigma: () => exportToFigma,
76
79
  exportToFigmaString: () => exportToFigmaString,
77
80
  exportToJson: () => exportToJson,
@@ -203,6 +206,7 @@ var CONTAINER_TYPES = [
203
206
  "Layout",
204
207
  "Component",
205
208
  "ComponentUse",
209
+ "Repeat",
206
210
  "Header",
207
211
  "Main",
208
212
  "Footer",
@@ -554,6 +558,82 @@ function collectParameterReferences(children) {
554
558
  return found;
555
559
  }
556
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
+
557
637
  // src/parser/generated-parser.js
558
638
  var peg$SyntaxError = class extends SyntaxError {
559
639
  constructor(message, expected, found, location) {
@@ -683,75 +763,76 @@ function peg$parse(input, options) {
683
763
  const peg$c17 = "\r\n";
684
764
  const peg$c18 = "//";
685
765
  const peg$c19 = "/*";
686
- const peg$c20 = "header";
687
- const peg$c21 = "main";
688
- const peg$c22 = "footer";
689
- const peg$c23 = "sidebar";
690
- const peg$c24 = "row";
691
- const peg$c25 = "col";
692
- const peg$c26 = "stack";
693
- const peg$c27 = "relative";
694
- const peg$c28 = "card";
695
- const peg$c29 = "modal";
696
- const peg$c30 = "drawer";
697
- const peg$c31 = "accordion";
698
- const peg$c32 = "section";
699
- const peg$c33 = "text";
700
- const peg$c34 = "title";
701
- const peg$c35 = "link";
702
- const peg$c36 = "button";
703
- const peg$c37 = "input";
704
- const peg$c38 = "textarea";
705
- const peg$c39 = "select";
706
- const peg$c40 = "checkbox";
707
- const peg$c41 = "radio";
708
- const peg$c42 = "switch";
709
- const peg$c43 = "slider";
710
- const peg$c44 = "image";
711
- const peg$c45 = "placeholder";
712
- const peg$c46 = "avatar";
713
- const peg$c47 = "badge";
714
- const peg$c48 = "icon";
715
- const peg$c49 = "table";
716
- const peg$c50 = "[";
717
- const peg$c51 = "]";
718
- const peg$c52 = "columns";
719
- const peg$c53 = "list";
720
- const peg$c54 = "item";
721
- const peg$c55 = "alert";
722
- const peg$c56 = "toast";
723
- const peg$c57 = "progress";
724
- const peg$c58 = "spinner";
725
- const peg$c59 = "tooltip";
726
- const peg$c60 = "popover";
727
- const peg$c61 = "dropdown";
728
- const peg$c62 = "divider";
729
- const peg$c63 = "nav";
730
- const peg$c64 = "group";
731
- const peg$c65 = "tabs";
732
- const peg$c66 = "tab";
733
- const peg$c67 = "breadcrumb";
734
- const peg$c68 = "marker";
735
- const peg$c69 = "annotations";
736
- const peg$c70 = "at";
737
- const peg$c71 = '"';
738
- const peg$c72 = "'";
739
- const peg$c73 = "\\";
740
- const peg$c74 = "n";
741
- const peg$c75 = "r";
742
- const peg$c76 = "t";
743
- const peg$c77 = "-";
744
- const peg$c78 = ".";
745
- const peg$c79 = "px";
746
- const peg$c80 = "%";
747
- const peg$c81 = "em";
748
- const peg$c82 = "rem";
749
- const peg$c83 = "vh";
750
- const peg$c84 = "vw";
751
- const peg$c85 = "true";
752
- const peg$c86 = "false";
753
- const peg$c87 = "\n";
754
- 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 = "*/";
755
836
  const peg$r0 = /^[ \t]/;
756
837
  const peg$r1 = /^[\n\r}]/;
757
838
  const peg$r2 = /^[0-9]/;
@@ -783,88 +864,89 @@ function peg$parse(input, options) {
783
864
  const peg$e20 = peg$literalExpectation("//", false);
784
865
  const peg$e21 = peg$literalExpectation("/*", false);
785
866
  const peg$e22 = peg$anyExpectation();
786
- const peg$e23 = peg$literalExpectation("header", false);
787
- const peg$e24 = peg$literalExpectation("main", false);
788
- const peg$e25 = peg$literalExpectation("footer", false);
789
- const peg$e26 = peg$literalExpectation("sidebar", false);
790
- const peg$e27 = peg$literalExpectation("row", false);
791
- const peg$e28 = peg$literalExpectation("col", false);
792
- const peg$e29 = peg$literalExpectation("stack", false);
793
- const peg$e30 = peg$literalExpectation("relative", false);
794
- const peg$e31 = peg$literalExpectation("card", false);
795
- const peg$e32 = peg$literalExpectation("modal", false);
796
- const peg$e33 = peg$literalExpectation("drawer", false);
797
- const peg$e34 = peg$literalExpectation("accordion", false);
798
- const peg$e35 = peg$literalExpectation("section", false);
799
- const peg$e36 = peg$literalExpectation("text", false);
800
- const peg$e37 = peg$literalExpectation("title", false);
801
- const peg$e38 = peg$literalExpectation("link", false);
802
- const peg$e39 = peg$literalExpectation("button", false);
803
- const peg$e40 = peg$literalExpectation("input", false);
804
- const peg$e41 = peg$literalExpectation("textarea", false);
805
- const peg$e42 = peg$literalExpectation("select", false);
806
- const peg$e43 = peg$literalExpectation("checkbox", false);
807
- const peg$e44 = peg$literalExpectation("radio", false);
808
- const peg$e45 = peg$literalExpectation("switch", false);
809
- const peg$e46 = peg$literalExpectation("slider", false);
810
- const peg$e47 = peg$literalExpectation("image", false);
811
- const peg$e48 = peg$literalExpectation("placeholder", false);
812
- const peg$e49 = peg$literalExpectation("avatar", false);
813
- const peg$e50 = peg$literalExpectation("badge", false);
814
- const peg$e51 = peg$literalExpectation("icon", false);
815
- const peg$e52 = peg$literalExpectation("table", false);
816
- const peg$e53 = peg$literalExpectation("[", false);
817
- const peg$e54 = peg$literalExpectation("]", false);
818
- const peg$e55 = peg$literalExpectation("columns", false);
819
- const peg$e56 = peg$literalExpectation("list", false);
820
- const peg$e57 = peg$literalExpectation("item", false);
821
- const peg$e58 = peg$literalExpectation("alert", false);
822
- const peg$e59 = peg$literalExpectation("toast", false);
823
- const peg$e60 = peg$literalExpectation("progress", false);
824
- const peg$e61 = peg$literalExpectation("spinner", false);
825
- const peg$e62 = peg$literalExpectation("tooltip", false);
826
- const peg$e63 = peg$literalExpectation("popover", false);
827
- const peg$e64 = peg$literalExpectation("dropdown", false);
828
- const peg$e65 = peg$literalExpectation("divider", false);
829
- const peg$e66 = peg$literalExpectation("nav", false);
830
- const peg$e67 = peg$literalExpectation("group", false);
831
- const peg$e68 = peg$literalExpectation("tabs", false);
832
- const peg$e69 = peg$literalExpectation("tab", false);
833
- const peg$e70 = peg$literalExpectation("breadcrumb", false);
834
- const peg$e71 = peg$literalExpectation("marker", false);
835
- const peg$e72 = peg$literalExpectation("annotations", false);
836
- const peg$e73 = peg$otherExpectation("integer");
837
- const peg$e74 = peg$classExpectation([["0", "9"]], false, false, false);
838
- const peg$e75 = peg$literalExpectation("at", false);
839
- const peg$e76 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
840
- const peg$e77 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
841
- const peg$e78 = peg$otherExpectation("string");
842
- const peg$e79 = peg$literalExpectation('"', false);
843
- const peg$e80 = peg$literalExpectation("'", false);
844
- const peg$e81 = peg$literalExpectation("\\", false);
845
- const peg$e82 = peg$literalExpectation("n", false);
846
- const peg$e83 = peg$literalExpectation("r", false);
847
- const peg$e84 = peg$literalExpectation("t", false);
848
- const peg$e85 = peg$otherExpectation("number");
849
- const peg$e86 = peg$literalExpectation("-", false);
850
- const peg$e87 = peg$literalExpectation(".", false);
851
- const peg$e88 = peg$otherExpectation("value with unit");
852
- const peg$e89 = peg$literalExpectation("px", false);
853
- const peg$e90 = peg$literalExpectation("%", false);
854
- const peg$e91 = peg$literalExpectation("em", false);
855
- const peg$e92 = peg$literalExpectation("rem", false);
856
- const peg$e93 = peg$literalExpectation("vh", false);
857
- const peg$e94 = peg$literalExpectation("vw", false);
858
- const peg$e95 = peg$otherExpectation("boolean");
859
- const peg$e96 = peg$literalExpectation("true", false);
860
- const peg$e97 = peg$literalExpectation("false", false);
861
- const peg$e98 = peg$otherExpectation("identifier");
862
- const peg$e99 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
863
- const peg$e100 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
864
- const peg$e101 = peg$otherExpectation("comment");
865
- const peg$e102 = peg$classExpectation(["\n"], true, false, false);
866
- const peg$e103 = peg$literalExpectation("\n", false);
867
- 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);
868
950
  function peg$f0(children) {
869
951
  return createNode("Document", {
870
952
  children: children.map((c) => c[0]).filter((c) => c !== null)
@@ -945,114 +1027,120 @@ function peg$parse(input, options) {
945
1027
  function peg$f18() {
946
1028
  return null;
947
1029
  }
948
- 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) {
949
1037
  return createNode("Header", {
950
1038
  ...attrsToObject(attrs2),
951
1039
  children
952
1040
  });
953
1041
  }
954
- function peg$f20(attrs2, children) {
1042
+ function peg$f21(attrs2, children) {
955
1043
  return createNode("Main", {
956
1044
  ...attrsToObject(attrs2),
957
1045
  children
958
1046
  });
959
1047
  }
960
- function peg$f21(attrs2, children) {
1048
+ function peg$f22(attrs2, children) {
961
1049
  return createNode("Footer", {
962
1050
  ...attrsToObject(attrs2),
963
1051
  children
964
1052
  });
965
1053
  }
966
- function peg$f22(attrs2, children) {
1054
+ function peg$f23(attrs2, children) {
967
1055
  return createNode("Sidebar", {
968
1056
  ...attrsToObject(attrs2),
969
1057
  children
970
1058
  });
971
1059
  }
972
- function peg$f23(attrs2, children) {
1060
+ function peg$f24(attrs2, children) {
973
1061
  return createNode("Row", {
974
1062
  ...attrsToObject(attrs2),
975
1063
  children
976
1064
  });
977
1065
  }
978
- function peg$f24(attrs2, children) {
1066
+ function peg$f25(attrs2, children) {
979
1067
  return createNode("Col", {
980
1068
  ...attrsToObject(attrs2),
981
1069
  children
982
1070
  });
983
1071
  }
984
- function peg$f25(attrs2, children) {
1072
+ function peg$f26(attrs2, children) {
985
1073
  return createNode("Stack", {
986
1074
  ...attrsToObject(attrs2),
987
1075
  children
988
1076
  });
989
1077
  }
990
- function peg$f26(attrs2, children) {
1078
+ function peg$f27(attrs2, children) {
991
1079
  return createNode("Relative", {
992
1080
  ...attrsToObject(attrs2),
993
1081
  children
994
1082
  });
995
1083
  }
996
- function peg$f27(label, attrs2, children) {
1084
+ function peg$f28(label, attrs2, children) {
997
1085
  return createNode("Card", {
998
1086
  title: label || null,
999
1087
  ...attrsToObject(attrs2),
1000
1088
  children
1001
1089
  });
1002
1090
  }
1003
- function peg$f28(label, attrs2, children) {
1091
+ function peg$f29(label, attrs2, children) {
1004
1092
  return createNode("Modal", {
1005
1093
  title: label || null,
1006
1094
  ...attrsToObject(attrs2),
1007
1095
  children
1008
1096
  });
1009
1097
  }
1010
- function peg$f29(label, attrs2, children) {
1098
+ function peg$f30(label, attrs2, children) {
1011
1099
  return createNode("Drawer", {
1012
1100
  title: label || null,
1013
1101
  ...attrsToObject(attrs2),
1014
1102
  children
1015
1103
  });
1016
1104
  }
1017
- function peg$f30(label, attrs2, children) {
1105
+ function peg$f31(label, attrs2, children) {
1018
1106
  return createNode("Accordion", {
1019
1107
  title: label || null,
1020
1108
  ...attrsToObject(attrs2),
1021
1109
  children
1022
1110
  });
1023
1111
  }
1024
- function peg$f31(label, attrs2, children) {
1112
+ function peg$f32(label, attrs2, children) {
1025
1113
  return createNode("Section", {
1026
1114
  title: label || null,
1027
1115
  ...attrsToObject(attrs2),
1028
1116
  children
1029
1117
  });
1030
1118
  }
1031
- function peg$f32(label, attrs2) {
1119
+ function peg$f33(label, attrs2) {
1032
1120
  return createNode("Text", {
1033
1121
  content: label,
1034
1122
  ...attrsToObject(attrs2)
1035
1123
  });
1036
1124
  }
1037
- function peg$f33(label, attrs2) {
1125
+ function peg$f34(label, attrs2) {
1038
1126
  return createNode("Title", {
1039
1127
  content: label,
1040
1128
  ...attrsToObject(attrs2)
1041
1129
  });
1042
1130
  }
1043
- function peg$f34(label, attrs2) {
1131
+ function peg$f35(label, attrs2) {
1044
1132
  return createNode("Link", {
1045
1133
  content: label,
1046
1134
  ...attrsToObject(attrs2)
1047
1135
  });
1048
1136
  }
1049
- function peg$f35(label, attrs2) {
1137
+ function peg$f36(label, attrs2) {
1050
1138
  return createNode("Button", {
1051
1139
  content: label,
1052
1140
  ...attrsToObject(attrs2)
1053
1141
  });
1054
1142
  }
1055
- function peg$f36(label, attrs2) {
1143
+ function peg$f37(label, attrs2) {
1056
1144
  const obj = attrsToObject(attrs2);
1057
1145
  const inputType = obj.type;
1058
1146
  delete obj.type;
@@ -1062,75 +1150,75 @@ function peg$parse(input, options) {
1062
1150
  ...obj
1063
1151
  });
1064
1152
  }
1065
- function peg$f37(label, attrs2) {
1153
+ function peg$f38(label, attrs2) {
1066
1154
  return createNode("Textarea", {
1067
1155
  label: label || null,
1068
1156
  ...attrsToObject(attrs2)
1069
1157
  });
1070
1158
  }
1071
- function peg$f38(label, options2, attrs2) {
1159
+ function peg$f39(label, options2, attrs2) {
1072
1160
  return createNode("Select", {
1073
1161
  label: label || null,
1074
1162
  options: options2 || [],
1075
1163
  ...attrsToObject(attrs2)
1076
1164
  });
1077
1165
  }
1078
- function peg$f39(label, attrs2) {
1166
+ function peg$f40(label, attrs2) {
1079
1167
  return createNode("Checkbox", {
1080
1168
  label: label || null,
1081
1169
  ...attrsToObject(attrs2)
1082
1170
  });
1083
1171
  }
1084
- function peg$f40(label, attrs2) {
1172
+ function peg$f41(label, attrs2) {
1085
1173
  return createNode("Radio", {
1086
1174
  label: label || null,
1087
1175
  ...attrsToObject(attrs2)
1088
1176
  });
1089
1177
  }
1090
- function peg$f41(label, attrs2) {
1178
+ function peg$f42(label, attrs2) {
1091
1179
  return createNode("Switch", {
1092
1180
  label: label || null,
1093
1181
  ...attrsToObject(attrs2)
1094
1182
  });
1095
1183
  }
1096
- function peg$f42(label, attrs2) {
1184
+ function peg$f43(label, attrs2) {
1097
1185
  return createNode("Slider", {
1098
1186
  label: label || null,
1099
1187
  ...attrsToObject(attrs2)
1100
1188
  });
1101
1189
  }
1102
- function peg$f43(src, attrs2) {
1190
+ function peg$f44(src, attrs2) {
1103
1191
  return createNode("Image", {
1104
1192
  src: src || null,
1105
1193
  ...attrsToObject(attrs2)
1106
1194
  });
1107
1195
  }
1108
- function peg$f44(label, attrs2, block) {
1196
+ function peg$f45(label, attrs2, block) {
1109
1197
  return createNode("Placeholder", {
1110
1198
  label: label || null,
1111
1199
  ...attrsToObject(attrs2),
1112
1200
  children: block ? block[2] : []
1113
1201
  });
1114
1202
  }
1115
- function peg$f45(label, attrs2) {
1203
+ function peg$f46(label, attrs2) {
1116
1204
  return createNode("Avatar", {
1117
1205
  name: label || null,
1118
1206
  ...attrsToObject(attrs2)
1119
1207
  });
1120
1208
  }
1121
- function peg$f46(label, attrs2) {
1209
+ function peg$f47(label, attrs2) {
1122
1210
  return createNode("Badge", {
1123
1211
  content: label,
1124
1212
  ...attrsToObject(attrs2)
1125
1213
  });
1126
1214
  }
1127
- function peg$f47(name, attrs2) {
1215
+ function peg$f48(name, attrs2) {
1128
1216
  return createNode("Icon", {
1129
1217
  name,
1130
1218
  ...attrsToObject(attrs2)
1131
1219
  });
1132
1220
  }
1133
- function peg$f48(data, attrs2) {
1221
+ function peg$f49(data, attrs2) {
1134
1222
  const columns = data.length > 0 ? data[0] : [];
1135
1223
  const rows = data.slice(1);
1136
1224
  return createNode("Table", {
@@ -1139,16 +1227,16 @@ function peg$parse(input, options) {
1139
1227
  ...attrsToObject(attrs2)
1140
1228
  });
1141
1229
  }
1142
- function peg$f49(attrs2, rows) {
1230
+ function peg$f50(attrs2, rows) {
1143
1231
  return createNode("Table", {
1144
1232
  ...attrsToObject(attrs2),
1145
1233
  ...rows
1146
1234
  });
1147
1235
  }
1148
- function peg$f50(first, rest) {
1236
+ function peg$f51(first, rest) {
1149
1237
  return [first, ...rest.map((r) => r[2])];
1150
1238
  }
1151
- function peg$f51(items) {
1239
+ function peg$f52(items) {
1152
1240
  const columns = [];
1153
1241
  const rows = [];
1154
1242
  for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
@@ -1157,72 +1245,72 @@ function peg$parse(input, options) {
1157
1245
  }
1158
1246
  return { columns, rows };
1159
1247
  }
1160
- function peg$f52(values) {
1248
+ function peg$f53(values) {
1161
1249
  return { kind: "columns", values };
1162
1250
  }
1163
- function peg$f53(values) {
1251
+ function peg$f54(values) {
1164
1252
  return { kind: "row", values };
1165
1253
  }
1166
- function peg$f54() {
1254
+ function peg$f55() {
1167
1255
  return null;
1168
1256
  }
1169
- function peg$f55(items, attrs2, block) {
1257
+ function peg$f56(items, attrs2, block) {
1170
1258
  return createNode("List", {
1171
1259
  items: items || (block ? block : []),
1172
1260
  ...attrsToObject(attrs2)
1173
1261
  });
1174
1262
  }
1175
- function peg$f56(items) {
1263
+ function peg$f57(items) {
1176
1264
  return items.map((i) => i[0]).filter((i) => i !== null);
1177
1265
  }
1178
- function peg$f57(label, attrs2, nested) {
1266
+ function peg$f58(label, attrs2, nested) {
1179
1267
  return createBlockNode("ListItem", {
1180
1268
  content: label,
1181
1269
  ...attrsToObject(attrs2),
1182
1270
  children: nested || []
1183
1271
  });
1184
1272
  }
1185
- function peg$f58() {
1273
+ function peg$f59() {
1186
1274
  return null;
1187
1275
  }
1188
- function peg$f59(label, attrs2) {
1276
+ function peg$f60(label, attrs2) {
1189
1277
  return createNode("Alert", {
1190
1278
  content: label,
1191
1279
  ...attrsToObject(attrs2)
1192
1280
  });
1193
1281
  }
1194
- function peg$f60(label, attrs2) {
1282
+ function peg$f61(label, attrs2) {
1195
1283
  return createNode("Toast", {
1196
1284
  content: label,
1197
1285
  ...attrsToObject(attrs2)
1198
1286
  });
1199
1287
  }
1200
- function peg$f61(attrs2) {
1288
+ function peg$f62(attrs2) {
1201
1289
  return createNode("Progress", {
1202
1290
  ...attrsToObject(attrs2)
1203
1291
  });
1204
1292
  }
1205
- function peg$f62(label, attrs2) {
1293
+ function peg$f63(label, attrs2) {
1206
1294
  return createNode("Spinner", {
1207
1295
  label: label || null,
1208
1296
  ...attrsToObject(attrs2)
1209
1297
  });
1210
1298
  }
1211
- function peg$f63(label, attrs2) {
1299
+ function peg$f64(label, attrs2) {
1212
1300
  return createNode("Tooltip", {
1213
1301
  content: label,
1214
1302
  ...attrsToObject(attrs2),
1215
1303
  children: []
1216
1304
  });
1217
1305
  }
1218
- function peg$f64(label, attrs2, children) {
1306
+ function peg$f65(label, attrs2, children) {
1219
1307
  return createNode("Popover", {
1220
1308
  title: label || null,
1221
1309
  ...attrsToObject(attrs2),
1222
1310
  children
1223
1311
  });
1224
1312
  }
1225
- function peg$f65(items, attrs2) {
1313
+ function peg$f66(items, attrs2) {
1226
1314
  const processedItems = items.map((item) => {
1227
1315
  if (typeof item === "string") {
1228
1316
  if (item === "---" || item === "-" || item === "divider") {
@@ -1237,106 +1325,106 @@ function peg$parse(input, options) {
1237
1325
  items: processedItems
1238
1326
  });
1239
1327
  }
1240
- function peg$f66(attrs2, items) {
1328
+ function peg$f67(attrs2, items) {
1241
1329
  return createNode("Dropdown", {
1242
1330
  ...attrsToObject(attrs2),
1243
1331
  items
1244
1332
  });
1245
1333
  }
1246
- function peg$f67(items) {
1334
+ function peg$f68(items) {
1247
1335
  return items.map((i) => i[0]).filter((i) => i !== null);
1248
1336
  }
1249
- function peg$f68(label, attrs2) {
1337
+ function peg$f69(label, attrs2) {
1250
1338
  return createBlockNode("DropdownItem", { label, ...attrsToObject(attrs2) });
1251
1339
  }
1252
- function peg$f69() {
1340
+ function peg$f70() {
1253
1341
  return createBlockNode("Divider", {});
1254
1342
  }
1255
- function peg$f70() {
1343
+ function peg$f71() {
1256
1344
  return null;
1257
1345
  }
1258
- function peg$f71(items, attrs2, block) {
1346
+ function peg$f72(items, attrs2, block) {
1259
1347
  return createNode("Nav", {
1260
1348
  items: items || [],
1261
1349
  ...attrsToObject(attrs2),
1262
1350
  children: block || []
1263
1351
  });
1264
1352
  }
1265
- function peg$f72(content) {
1353
+ function peg$f73(content) {
1266
1354
  return content.map((c) => c[0]).filter((c) => c !== null);
1267
1355
  }
1268
- function peg$f73() {
1356
+ function peg$f74() {
1269
1357
  return createBlockNode("Divider", {});
1270
1358
  }
1271
- function peg$f74() {
1359
+ function peg$f75() {
1272
1360
  return null;
1273
1361
  }
1274
- function peg$f75(label, attrs2, items) {
1362
+ function peg$f76(label, attrs2, items) {
1275
1363
  return createBlockNode("NavGroup", {
1276
1364
  label,
1277
1365
  ...attrsToObject(attrs2),
1278
1366
  items: items.map((i) => i[0]).filter((i) => i !== null)
1279
1367
  });
1280
1368
  }
1281
- function peg$f76() {
1369
+ function peg$f77() {
1282
1370
  return createBlockNode("Divider", {});
1283
1371
  }
1284
- function peg$f77() {
1372
+ function peg$f78() {
1285
1373
  return null;
1286
1374
  }
1287
- function peg$f78(label, attrs2) {
1375
+ function peg$f79(label, attrs2) {
1288
1376
  return createBlockNode("NavItem", {
1289
1377
  label,
1290
1378
  ...attrsToObject(attrs2)
1291
1379
  });
1292
1380
  }
1293
- function peg$f79(items, attrs2, block) {
1381
+ function peg$f80(items, attrs2, block) {
1294
1382
  return createNode("Tabs", {
1295
1383
  items: items || [],
1296
1384
  ...attrsToObject(attrs2),
1297
1385
  children: block || []
1298
1386
  });
1299
1387
  }
1300
- function peg$f80(tabs) {
1388
+ function peg$f81(tabs) {
1301
1389
  return tabs.map((t) => t[0]).filter((t) => t !== null);
1302
1390
  }
1303
- function peg$f81(label, attrs2, children) {
1391
+ function peg$f82(label, attrs2, children) {
1304
1392
  return {
1305
1393
  label,
1306
1394
  ...attrsToObject(attrs2),
1307
1395
  children
1308
1396
  };
1309
1397
  }
1310
- function peg$f82() {
1398
+ function peg$f83() {
1311
1399
  return null;
1312
1400
  }
1313
- function peg$f83(items, attrs2) {
1401
+ function peg$f84(items, attrs2) {
1314
1402
  return createNode("Breadcrumb", {
1315
1403
  items,
1316
1404
  ...attrsToObject(attrs2)
1317
1405
  });
1318
1406
  }
1319
- function peg$f84(attrs2) {
1407
+ function peg$f85(attrs2) {
1320
1408
  return createNode("Divider", {
1321
1409
  ...attrsToObject(attrs2)
1322
1410
  });
1323
1411
  }
1324
- function peg$f85(num, attrs2) {
1412
+ function peg$f86(num, attrs2) {
1325
1413
  return createNode("Marker", {
1326
1414
  number: num,
1327
1415
  ...attrsToObject(attrs2)
1328
1416
  });
1329
1417
  }
1330
- function peg$f86(attrs2, items) {
1418
+ function peg$f87(attrs2, items) {
1331
1419
  return createNode("Annotations", {
1332
1420
  ...attrsToObject(attrs2),
1333
1421
  children: items
1334
1422
  });
1335
1423
  }
1336
- function peg$f87(items) {
1424
+ function peg$f88(items) {
1337
1425
  return items.map((i) => i[0]).filter((i) => i !== null);
1338
1426
  }
1339
- function peg$f88(num, title, attrs2, children) {
1427
+ function peg$f89(num, title, attrs2, children) {
1340
1428
  return createNode("AnnotationItem", {
1341
1429
  number: num,
1342
1430
  title,
@@ -1344,7 +1432,7 @@ function peg$parse(input, options) {
1344
1432
  children
1345
1433
  });
1346
1434
  }
1347
- function peg$f89(num, title, attrs2) {
1435
+ function peg$f90(num, title, attrs2) {
1348
1436
  return createNode("AnnotationItem", {
1349
1437
  number: num,
1350
1438
  title,
@@ -1352,90 +1440,90 @@ function peg$parse(input, options) {
1352
1440
  children: []
1353
1441
  });
1354
1442
  }
1355
- function peg$f90() {
1443
+ function peg$f91() {
1356
1444
  return null;
1357
1445
  }
1358
- function peg$f91(digits) {
1446
+ function peg$f92(digits) {
1359
1447
  return parseInt(digits.join(""), 10);
1360
1448
  }
1361
- function peg$f92(attrs2) {
1449
+ function peg$f93(attrs2) {
1362
1450
  return attrs2;
1363
1451
  }
1364
- function peg$f93(x, y) {
1452
+ function peg$f94(x, y) {
1365
1453
  return [
1366
1454
  { name: "x", value: x },
1367
1455
  { name: "y", value: y }
1368
1456
  ];
1369
1457
  }
1370
- function peg$f94(name, value) {
1458
+ function peg$f95(name, value) {
1371
1459
  return { name, value };
1372
1460
  }
1373
- function peg$f95(flag) {
1461
+ function peg$f96(flag) {
1374
1462
  return { name: flag, value: true };
1375
1463
  }
1376
- function peg$f96(name) {
1464
+ function peg$f97(name) {
1377
1465
  return name;
1378
1466
  }
1379
- function peg$f97(chars) {
1467
+ function peg$f98(chars) {
1380
1468
  return chars.join("");
1381
1469
  }
1382
- function peg$f98(chars) {
1470
+ function peg$f99(chars) {
1383
1471
  return chars.join("");
1384
1472
  }
1385
- function peg$f99(char) {
1473
+ function peg$f100(char) {
1386
1474
  return char;
1387
1475
  }
1388
- function peg$f100(seq) {
1476
+ function peg$f101(seq) {
1389
1477
  return seq;
1390
1478
  }
1391
- function peg$f101(char) {
1479
+ function peg$f102(char) {
1392
1480
  return char;
1393
1481
  }
1394
- function peg$f102(seq) {
1482
+ function peg$f103(seq) {
1395
1483
  return seq;
1396
1484
  }
1397
- function peg$f103() {
1485
+ function peg$f104() {
1398
1486
  return "\n";
1399
1487
  }
1400
- function peg$f104() {
1488
+ function peg$f105() {
1401
1489
  return "\r";
1402
1490
  }
1403
- function peg$f105() {
1491
+ function peg$f106() {
1404
1492
  return " ";
1405
1493
  }
1406
- function peg$f106() {
1494
+ function peg$f107() {
1407
1495
  return "\\";
1408
1496
  }
1409
- function peg$f107() {
1497
+ function peg$f108() {
1410
1498
  return '"';
1411
1499
  }
1412
- function peg$f108() {
1500
+ function peg$f109() {
1413
1501
  return "'";
1414
1502
  }
1415
- function peg$f109(sign, digits, decimal) {
1503
+ function peg$f110(sign, digits, decimal) {
1416
1504
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1417
1505
  return parseFloat(num);
1418
1506
  }
1419
- function peg$f110(sign, digits, decimal, unit) {
1507
+ function peg$f111(sign, digits, decimal, unit) {
1420
1508
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1421
1509
  return { value: parseFloat(num), unit };
1422
1510
  }
1423
- function peg$f111() {
1511
+ function peg$f112() {
1424
1512
  return true;
1425
1513
  }
1426
- function peg$f112() {
1514
+ function peg$f113() {
1427
1515
  return false;
1428
1516
  }
1429
- function peg$f113(head, tail) {
1517
+ function peg$f114(head, tail) {
1430
1518
  return head + tail.join("");
1431
1519
  }
1432
- function peg$f114(items) {
1520
+ function peg$f115(items) {
1433
1521
  return items || [];
1434
1522
  }
1435
- function peg$f115(head, tail) {
1523
+ function peg$f116(head, tail) {
1436
1524
  return [head, ...tail.map((t) => t[3])];
1437
1525
  }
1438
- function peg$f116(props) {
1526
+ function peg$f117(props) {
1439
1527
  const result = {};
1440
1528
  if (props) {
1441
1529
  for (const p of props) {
@@ -1444,13 +1532,13 @@ function peg$parse(input, options) {
1444
1532
  }
1445
1533
  return result;
1446
1534
  }
1447
- function peg$f117(head, tail) {
1535
+ function peg$f118(head, tail) {
1448
1536
  return [head, ...tail.map((t) => t[3])];
1449
1537
  }
1450
- function peg$f118(name, value) {
1538
+ function peg$f119(name, value) {
1451
1539
  return { name, value };
1452
1540
  }
1453
- function peg$f119(name) {
1541
+ function peg$f120(name) {
1454
1542
  return { name, value: true };
1455
1543
  }
1456
1544
  let peg$currPos = options.peg$currPos | 0;
@@ -2702,21 +2790,24 @@ function peg$parse(input, options) {
2702
2790
  let s0, s1;
2703
2791
  s0 = peg$parseComponentUse();
2704
2792
  if (s0 === peg$FAILED) {
2705
- s0 = peg$parseLayoutElement();
2793
+ s0 = peg$parseRepeat();
2706
2794
  if (s0 === peg$FAILED) {
2707
- s0 = peg$parseContainerElement();
2795
+ s0 = peg$parseLayoutElement();
2708
2796
  if (s0 === peg$FAILED) {
2709
- s0 = peg$parseUIElement();
2797
+ s0 = peg$parseContainerElement();
2710
2798
  if (s0 === peg$FAILED) {
2711
- s0 = peg$parseSlot();
2799
+ s0 = peg$parseUIElement();
2712
2800
  if (s0 === peg$FAILED) {
2713
- s0 = peg$currPos;
2714
- s1 = peg$parseComment();
2715
- if (s1 !== peg$FAILED) {
2716
- peg$savedPos = s0;
2717
- 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;
2718
2810
  }
2719
- s0 = s1;
2720
2811
  }
2721
2812
  }
2722
2813
  }
@@ -2724,6 +2815,71 @@ function peg$parse(input, options) {
2724
2815
  }
2725
2816
  return s0;
2726
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
+ }
2727
2883
  function peg$parseLayoutElement() {
2728
2884
  let s0;
2729
2885
  s0 = peg$parseHeader();
@@ -2753,13 +2909,13 @@ function peg$parse(input, options) {
2753
2909
  function peg$parseHeader() {
2754
2910
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2755
2911
  s0 = peg$currPos;
2756
- if (input.substr(peg$currPos, 6) === peg$c20) {
2757
- s1 = peg$c20;
2912
+ if (input.substr(peg$currPos, 6) === peg$c21) {
2913
+ s1 = peg$c21;
2758
2914
  peg$currPos += 6;
2759
2915
  } else {
2760
2916
  s1 = peg$FAILED;
2761
2917
  if (peg$silentFails === 0) {
2762
- peg$fail(peg$e23);
2918
+ peg$fail(peg$e24);
2763
2919
  }
2764
2920
  }
2765
2921
  if (s1 !== peg$FAILED) {
@@ -2794,7 +2950,7 @@ function peg$parse(input, options) {
2794
2950
  }
2795
2951
  if (s9 !== peg$FAILED) {
2796
2952
  peg$savedPos = s0;
2797
- s0 = peg$f19(s3, s7);
2953
+ s0 = peg$f20(s3, s7);
2798
2954
  } else {
2799
2955
  peg$currPos = s0;
2800
2956
  s0 = peg$FAILED;
@@ -2816,13 +2972,13 @@ function peg$parse(input, options) {
2816
2972
  function peg$parseMain() {
2817
2973
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2818
2974
  s0 = peg$currPos;
2819
- if (input.substr(peg$currPos, 4) === peg$c21) {
2820
- s1 = peg$c21;
2975
+ if (input.substr(peg$currPos, 4) === peg$c22) {
2976
+ s1 = peg$c22;
2821
2977
  peg$currPos += 4;
2822
2978
  } else {
2823
2979
  s1 = peg$FAILED;
2824
2980
  if (peg$silentFails === 0) {
2825
- peg$fail(peg$e24);
2981
+ peg$fail(peg$e25);
2826
2982
  }
2827
2983
  }
2828
2984
  if (s1 !== peg$FAILED) {
@@ -2857,7 +3013,7 @@ function peg$parse(input, options) {
2857
3013
  }
2858
3014
  if (s9 !== peg$FAILED) {
2859
3015
  peg$savedPos = s0;
2860
- s0 = peg$f20(s3, s7);
3016
+ s0 = peg$f21(s3, s7);
2861
3017
  } else {
2862
3018
  peg$currPos = s0;
2863
3019
  s0 = peg$FAILED;
@@ -2879,13 +3035,13 @@ function peg$parse(input, options) {
2879
3035
  function peg$parseFooter() {
2880
3036
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2881
3037
  s0 = peg$currPos;
2882
- if (input.substr(peg$currPos, 6) === peg$c22) {
2883
- s1 = peg$c22;
3038
+ if (input.substr(peg$currPos, 6) === peg$c23) {
3039
+ s1 = peg$c23;
2884
3040
  peg$currPos += 6;
2885
3041
  } else {
2886
3042
  s1 = peg$FAILED;
2887
3043
  if (peg$silentFails === 0) {
2888
- peg$fail(peg$e25);
3044
+ peg$fail(peg$e26);
2889
3045
  }
2890
3046
  }
2891
3047
  if (s1 !== peg$FAILED) {
@@ -2920,7 +3076,7 @@ function peg$parse(input, options) {
2920
3076
  }
2921
3077
  if (s9 !== peg$FAILED) {
2922
3078
  peg$savedPos = s0;
2923
- s0 = peg$f21(s3, s7);
3079
+ s0 = peg$f22(s3, s7);
2924
3080
  } else {
2925
3081
  peg$currPos = s0;
2926
3082
  s0 = peg$FAILED;
@@ -2942,13 +3098,13 @@ function peg$parse(input, options) {
2942
3098
  function peg$parseSidebar() {
2943
3099
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2944
3100
  s0 = peg$currPos;
2945
- if (input.substr(peg$currPos, 7) === peg$c23) {
2946
- s1 = peg$c23;
3101
+ if (input.substr(peg$currPos, 7) === peg$c24) {
3102
+ s1 = peg$c24;
2947
3103
  peg$currPos += 7;
2948
3104
  } else {
2949
3105
  s1 = peg$FAILED;
2950
3106
  if (peg$silentFails === 0) {
2951
- peg$fail(peg$e26);
3107
+ peg$fail(peg$e27);
2952
3108
  }
2953
3109
  }
2954
3110
  if (s1 !== peg$FAILED) {
@@ -2983,7 +3139,7 @@ function peg$parse(input, options) {
2983
3139
  }
2984
3140
  if (s9 !== peg$FAILED) {
2985
3141
  peg$savedPos = s0;
2986
- s0 = peg$f22(s3, s7);
3142
+ s0 = peg$f23(s3, s7);
2987
3143
  } else {
2988
3144
  peg$currPos = s0;
2989
3145
  s0 = peg$FAILED;
@@ -3005,13 +3161,13 @@ function peg$parse(input, options) {
3005
3161
  function peg$parseRow() {
3006
3162
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3007
3163
  s0 = peg$currPos;
3008
- if (input.substr(peg$currPos, 3) === peg$c24) {
3009
- s1 = peg$c24;
3164
+ if (input.substr(peg$currPos, 3) === peg$c25) {
3165
+ s1 = peg$c25;
3010
3166
  peg$currPos += 3;
3011
3167
  } else {
3012
3168
  s1 = peg$FAILED;
3013
3169
  if (peg$silentFails === 0) {
3014
- peg$fail(peg$e27);
3170
+ peg$fail(peg$e28);
3015
3171
  }
3016
3172
  }
3017
3173
  if (s1 !== peg$FAILED) {
@@ -3046,7 +3202,7 @@ function peg$parse(input, options) {
3046
3202
  }
3047
3203
  if (s9 !== peg$FAILED) {
3048
3204
  peg$savedPos = s0;
3049
- s0 = peg$f23(s3, s7);
3205
+ s0 = peg$f24(s3, s7);
3050
3206
  } else {
3051
3207
  peg$currPos = s0;
3052
3208
  s0 = peg$FAILED;
@@ -3068,13 +3224,13 @@ function peg$parse(input, options) {
3068
3224
  function peg$parseCol() {
3069
3225
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3070
3226
  s0 = peg$currPos;
3071
- if (input.substr(peg$currPos, 3) === peg$c25) {
3072
- s1 = peg$c25;
3227
+ if (input.substr(peg$currPos, 3) === peg$c26) {
3228
+ s1 = peg$c26;
3073
3229
  peg$currPos += 3;
3074
3230
  } else {
3075
3231
  s1 = peg$FAILED;
3076
3232
  if (peg$silentFails === 0) {
3077
- peg$fail(peg$e28);
3233
+ peg$fail(peg$e29);
3078
3234
  }
3079
3235
  }
3080
3236
  if (s1 !== peg$FAILED) {
@@ -3109,7 +3265,7 @@ function peg$parse(input, options) {
3109
3265
  }
3110
3266
  if (s9 !== peg$FAILED) {
3111
3267
  peg$savedPos = s0;
3112
- s0 = peg$f24(s3, s7);
3268
+ s0 = peg$f25(s3, s7);
3113
3269
  } else {
3114
3270
  peg$currPos = s0;
3115
3271
  s0 = peg$FAILED;
@@ -3131,13 +3287,13 @@ function peg$parse(input, options) {
3131
3287
  function peg$parseStack() {
3132
3288
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3133
3289
  s0 = peg$currPos;
3134
- if (input.substr(peg$currPos, 5) === peg$c26) {
3135
- s1 = peg$c26;
3290
+ if (input.substr(peg$currPos, 5) === peg$c27) {
3291
+ s1 = peg$c27;
3136
3292
  peg$currPos += 5;
3137
3293
  } else {
3138
3294
  s1 = peg$FAILED;
3139
3295
  if (peg$silentFails === 0) {
3140
- peg$fail(peg$e29);
3296
+ peg$fail(peg$e30);
3141
3297
  }
3142
3298
  }
3143
3299
  if (s1 !== peg$FAILED) {
@@ -3172,7 +3328,7 @@ function peg$parse(input, options) {
3172
3328
  }
3173
3329
  if (s9 !== peg$FAILED) {
3174
3330
  peg$savedPos = s0;
3175
- s0 = peg$f25(s3, s7);
3331
+ s0 = peg$f26(s3, s7);
3176
3332
  } else {
3177
3333
  peg$currPos = s0;
3178
3334
  s0 = peg$FAILED;
@@ -3194,13 +3350,13 @@ function peg$parse(input, options) {
3194
3350
  function peg$parseRelative() {
3195
3351
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3196
3352
  s0 = peg$currPos;
3197
- if (input.substr(peg$currPos, 8) === peg$c27) {
3198
- s1 = peg$c27;
3353
+ if (input.substr(peg$currPos, 8) === peg$c28) {
3354
+ s1 = peg$c28;
3199
3355
  peg$currPos += 8;
3200
3356
  } else {
3201
3357
  s1 = peg$FAILED;
3202
3358
  if (peg$silentFails === 0) {
3203
- peg$fail(peg$e30);
3359
+ peg$fail(peg$e31);
3204
3360
  }
3205
3361
  }
3206
3362
  if (s1 !== peg$FAILED) {
@@ -3235,7 +3391,7 @@ function peg$parse(input, options) {
3235
3391
  }
3236
3392
  if (s9 !== peg$FAILED) {
3237
3393
  peg$savedPos = s0;
3238
- s0 = peg$f26(s3, s7);
3394
+ s0 = peg$f27(s3, s7);
3239
3395
  } else {
3240
3396
  peg$currPos = s0;
3241
3397
  s0 = peg$FAILED;
@@ -3274,13 +3430,13 @@ function peg$parse(input, options) {
3274
3430
  function peg$parseCard() {
3275
3431
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3276
3432
  s0 = peg$currPos;
3277
- if (input.substr(peg$currPos, 4) === peg$c28) {
3278
- s1 = peg$c28;
3433
+ if (input.substr(peg$currPos, 4) === peg$c29) {
3434
+ s1 = peg$c29;
3279
3435
  peg$currPos += 4;
3280
3436
  } else {
3281
3437
  s1 = peg$FAILED;
3282
3438
  if (peg$silentFails === 0) {
3283
- peg$fail(peg$e31);
3439
+ peg$fail(peg$e32);
3284
3440
  }
3285
3441
  }
3286
3442
  if (s1 !== peg$FAILED) {
@@ -3320,7 +3476,7 @@ function peg$parse(input, options) {
3320
3476
  }
3321
3477
  if (s11 !== peg$FAILED) {
3322
3478
  peg$savedPos = s0;
3323
- s0 = peg$f27(s3, s5, s9);
3479
+ s0 = peg$f28(s3, s5, s9);
3324
3480
  } else {
3325
3481
  peg$currPos = s0;
3326
3482
  s0 = peg$FAILED;
@@ -3342,13 +3498,13 @@ function peg$parse(input, options) {
3342
3498
  function peg$parseModal() {
3343
3499
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3344
3500
  s0 = peg$currPos;
3345
- if (input.substr(peg$currPos, 5) === peg$c29) {
3346
- s1 = peg$c29;
3501
+ if (input.substr(peg$currPos, 5) === peg$c30) {
3502
+ s1 = peg$c30;
3347
3503
  peg$currPos += 5;
3348
3504
  } else {
3349
3505
  s1 = peg$FAILED;
3350
3506
  if (peg$silentFails === 0) {
3351
- peg$fail(peg$e32);
3507
+ peg$fail(peg$e33);
3352
3508
  }
3353
3509
  }
3354
3510
  if (s1 !== peg$FAILED) {
@@ -3388,7 +3544,7 @@ function peg$parse(input, options) {
3388
3544
  }
3389
3545
  if (s11 !== peg$FAILED) {
3390
3546
  peg$savedPos = s0;
3391
- s0 = peg$f28(s3, s5, s9);
3547
+ s0 = peg$f29(s3, s5, s9);
3392
3548
  } else {
3393
3549
  peg$currPos = s0;
3394
3550
  s0 = peg$FAILED;
@@ -3410,13 +3566,13 @@ function peg$parse(input, options) {
3410
3566
  function peg$parseDrawer() {
3411
3567
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3412
3568
  s0 = peg$currPos;
3413
- if (input.substr(peg$currPos, 6) === peg$c30) {
3414
- s1 = peg$c30;
3569
+ if (input.substr(peg$currPos, 6) === peg$c31) {
3570
+ s1 = peg$c31;
3415
3571
  peg$currPos += 6;
3416
3572
  } else {
3417
3573
  s1 = peg$FAILED;
3418
3574
  if (peg$silentFails === 0) {
3419
- peg$fail(peg$e33);
3575
+ peg$fail(peg$e34);
3420
3576
  }
3421
3577
  }
3422
3578
  if (s1 !== peg$FAILED) {
@@ -3456,7 +3612,7 @@ function peg$parse(input, options) {
3456
3612
  }
3457
3613
  if (s11 !== peg$FAILED) {
3458
3614
  peg$savedPos = s0;
3459
- s0 = peg$f29(s3, s5, s9);
3615
+ s0 = peg$f30(s3, s5, s9);
3460
3616
  } else {
3461
3617
  peg$currPos = s0;
3462
3618
  s0 = peg$FAILED;
@@ -3478,13 +3634,13 @@ function peg$parse(input, options) {
3478
3634
  function peg$parseAccordion() {
3479
3635
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3480
3636
  s0 = peg$currPos;
3481
- if (input.substr(peg$currPos, 9) === peg$c31) {
3482
- s1 = peg$c31;
3637
+ if (input.substr(peg$currPos, 9) === peg$c32) {
3638
+ s1 = peg$c32;
3483
3639
  peg$currPos += 9;
3484
3640
  } else {
3485
3641
  s1 = peg$FAILED;
3486
3642
  if (peg$silentFails === 0) {
3487
- peg$fail(peg$e34);
3643
+ peg$fail(peg$e35);
3488
3644
  }
3489
3645
  }
3490
3646
  if (s1 !== peg$FAILED) {
@@ -3524,7 +3680,7 @@ function peg$parse(input, options) {
3524
3680
  }
3525
3681
  if (s11 !== peg$FAILED) {
3526
3682
  peg$savedPos = s0;
3527
- s0 = peg$f30(s3, s5, s9);
3683
+ s0 = peg$f31(s3, s5, s9);
3528
3684
  } else {
3529
3685
  peg$currPos = s0;
3530
3686
  s0 = peg$FAILED;
@@ -3546,13 +3702,13 @@ function peg$parse(input, options) {
3546
3702
  function peg$parseSection() {
3547
3703
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3548
3704
  s0 = peg$currPos;
3549
- if (input.substr(peg$currPos, 7) === peg$c32) {
3550
- s1 = peg$c32;
3705
+ if (input.substr(peg$currPos, 7) === peg$c33) {
3706
+ s1 = peg$c33;
3551
3707
  peg$currPos += 7;
3552
3708
  } else {
3553
3709
  s1 = peg$FAILED;
3554
3710
  if (peg$silentFails === 0) {
3555
- peg$fail(peg$e35);
3711
+ peg$fail(peg$e36);
3556
3712
  }
3557
3713
  }
3558
3714
  if (s1 !== peg$FAILED) {
@@ -3592,7 +3748,7 @@ function peg$parse(input, options) {
3592
3748
  }
3593
3749
  if (s11 !== peg$FAILED) {
3594
3750
  peg$savedPos = s0;
3595
- s0 = peg$f31(s3, s5, s9);
3751
+ s0 = peg$f32(s3, s5, s9);
3596
3752
  } else {
3597
3753
  peg$currPos = s0;
3598
3754
  s0 = peg$FAILED;
@@ -3709,13 +3865,13 @@ function peg$parse(input, options) {
3709
3865
  function peg$parseText() {
3710
3866
  let s0, s1, s2, s3, s4, s5;
3711
3867
  s0 = peg$currPos;
3712
- if (input.substr(peg$currPos, 4) === peg$c33) {
3713
- s1 = peg$c33;
3868
+ if (input.substr(peg$currPos, 4) === peg$c34) {
3869
+ s1 = peg$c34;
3714
3870
  peg$currPos += 4;
3715
3871
  } else {
3716
3872
  s1 = peg$FAILED;
3717
3873
  if (peg$silentFails === 0) {
3718
- peg$fail(peg$e36);
3874
+ peg$fail(peg$e37);
3719
3875
  }
3720
3876
  }
3721
3877
  if (s1 !== peg$FAILED) {
@@ -3728,7 +3884,7 @@ function peg$parse(input, options) {
3728
3884
  s5 = null;
3729
3885
  }
3730
3886
  peg$savedPos = s0;
3731
- s0 = peg$f32(s3, s5);
3887
+ s0 = peg$f33(s3, s5);
3732
3888
  } else {
3733
3889
  peg$currPos = s0;
3734
3890
  s0 = peg$FAILED;
@@ -3742,13 +3898,13 @@ function peg$parse(input, options) {
3742
3898
  function peg$parseTitle() {
3743
3899
  let s0, s1, s2, s3, s4, s5;
3744
3900
  s0 = peg$currPos;
3745
- if (input.substr(peg$currPos, 5) === peg$c34) {
3746
- s1 = peg$c34;
3901
+ if (input.substr(peg$currPos, 5) === peg$c35) {
3902
+ s1 = peg$c35;
3747
3903
  peg$currPos += 5;
3748
3904
  } else {
3749
3905
  s1 = peg$FAILED;
3750
3906
  if (peg$silentFails === 0) {
3751
- peg$fail(peg$e37);
3907
+ peg$fail(peg$e38);
3752
3908
  }
3753
3909
  }
3754
3910
  if (s1 !== peg$FAILED) {
@@ -3761,7 +3917,7 @@ function peg$parse(input, options) {
3761
3917
  s5 = null;
3762
3918
  }
3763
3919
  peg$savedPos = s0;
3764
- s0 = peg$f33(s3, s5);
3920
+ s0 = peg$f34(s3, s5);
3765
3921
  } else {
3766
3922
  peg$currPos = s0;
3767
3923
  s0 = peg$FAILED;
@@ -3775,13 +3931,13 @@ function peg$parse(input, options) {
3775
3931
  function peg$parseLink() {
3776
3932
  let s0, s1, s2, s3, s4, s5;
3777
3933
  s0 = peg$currPos;
3778
- if (input.substr(peg$currPos, 4) === peg$c35) {
3779
- s1 = peg$c35;
3934
+ if (input.substr(peg$currPos, 4) === peg$c36) {
3935
+ s1 = peg$c36;
3780
3936
  peg$currPos += 4;
3781
3937
  } else {
3782
3938
  s1 = peg$FAILED;
3783
3939
  if (peg$silentFails === 0) {
3784
- peg$fail(peg$e38);
3940
+ peg$fail(peg$e39);
3785
3941
  }
3786
3942
  }
3787
3943
  if (s1 !== peg$FAILED) {
@@ -3794,7 +3950,7 @@ function peg$parse(input, options) {
3794
3950
  s5 = null;
3795
3951
  }
3796
3952
  peg$savedPos = s0;
3797
- s0 = peg$f34(s3, s5);
3953
+ s0 = peg$f35(s3, s5);
3798
3954
  } else {
3799
3955
  peg$currPos = s0;
3800
3956
  s0 = peg$FAILED;
@@ -3808,13 +3964,13 @@ function peg$parse(input, options) {
3808
3964
  function peg$parseButton() {
3809
3965
  let s0, s1, s2, s3, s4, s5;
3810
3966
  s0 = peg$currPos;
3811
- if (input.substr(peg$currPos, 6) === peg$c36) {
3812
- s1 = peg$c36;
3967
+ if (input.substr(peg$currPos, 6) === peg$c37) {
3968
+ s1 = peg$c37;
3813
3969
  peg$currPos += 6;
3814
3970
  } else {
3815
3971
  s1 = peg$FAILED;
3816
3972
  if (peg$silentFails === 0) {
3817
- peg$fail(peg$e39);
3973
+ peg$fail(peg$e40);
3818
3974
  }
3819
3975
  }
3820
3976
  if (s1 !== peg$FAILED) {
@@ -3827,7 +3983,7 @@ function peg$parse(input, options) {
3827
3983
  s5 = null;
3828
3984
  }
3829
3985
  peg$savedPos = s0;
3830
- s0 = peg$f35(s3, s5);
3986
+ s0 = peg$f36(s3, s5);
3831
3987
  } else {
3832
3988
  peg$currPos = s0;
3833
3989
  s0 = peg$FAILED;
@@ -3841,13 +3997,13 @@ function peg$parse(input, options) {
3841
3997
  function peg$parseInput() {
3842
3998
  let s0, s1, s2, s3, s4, s5;
3843
3999
  s0 = peg$currPos;
3844
- if (input.substr(peg$currPos, 5) === peg$c37) {
3845
- s1 = peg$c37;
4000
+ if (input.substr(peg$currPos, 5) === peg$c38) {
4001
+ s1 = peg$c38;
3846
4002
  peg$currPos += 5;
3847
4003
  } else {
3848
4004
  s1 = peg$FAILED;
3849
4005
  if (peg$silentFails === 0) {
3850
- peg$fail(peg$e40);
4006
+ peg$fail(peg$e41);
3851
4007
  }
3852
4008
  }
3853
4009
  if (s1 !== peg$FAILED) {
@@ -3862,7 +4018,7 @@ function peg$parse(input, options) {
3862
4018
  s5 = null;
3863
4019
  }
3864
4020
  peg$savedPos = s0;
3865
- s0 = peg$f36(s3, s5);
4021
+ s0 = peg$f37(s3, s5);
3866
4022
  } else {
3867
4023
  peg$currPos = s0;
3868
4024
  s0 = peg$FAILED;
@@ -3872,13 +4028,13 @@ function peg$parse(input, options) {
3872
4028
  function peg$parseTextarea() {
3873
4029
  let s0, s1, s2, s3, s4, s5;
3874
4030
  s0 = peg$currPos;
3875
- if (input.substr(peg$currPos, 8) === peg$c38) {
3876
- s1 = peg$c38;
4031
+ if (input.substr(peg$currPos, 8) === peg$c39) {
4032
+ s1 = peg$c39;
3877
4033
  peg$currPos += 8;
3878
4034
  } else {
3879
4035
  s1 = peg$FAILED;
3880
4036
  if (peg$silentFails === 0) {
3881
- peg$fail(peg$e41);
4037
+ peg$fail(peg$e42);
3882
4038
  }
3883
4039
  }
3884
4040
  if (s1 !== peg$FAILED) {
@@ -3893,7 +4049,7 @@ function peg$parse(input, options) {
3893
4049
  s5 = null;
3894
4050
  }
3895
4051
  peg$savedPos = s0;
3896
- s0 = peg$f37(s3, s5);
4052
+ s0 = peg$f38(s3, s5);
3897
4053
  } else {
3898
4054
  peg$currPos = s0;
3899
4055
  s0 = peg$FAILED;
@@ -3903,13 +4059,13 @@ function peg$parse(input, options) {
3903
4059
  function peg$parseSelect() {
3904
4060
  let s0, s1, s2, s3, s4, s5, s6, s7;
3905
4061
  s0 = peg$currPos;
3906
- if (input.substr(peg$currPos, 6) === peg$c39) {
3907
- s1 = peg$c39;
4062
+ if (input.substr(peg$currPos, 6) === peg$c40) {
4063
+ s1 = peg$c40;
3908
4064
  peg$currPos += 6;
3909
4065
  } else {
3910
4066
  s1 = peg$FAILED;
3911
4067
  if (peg$silentFails === 0) {
3912
- peg$fail(peg$e42);
4068
+ peg$fail(peg$e43);
3913
4069
  }
3914
4070
  }
3915
4071
  if (s1 !== peg$FAILED) {
@@ -3929,7 +4085,7 @@ function peg$parse(input, options) {
3929
4085
  s7 = null;
3930
4086
  }
3931
4087
  peg$savedPos = s0;
3932
- s0 = peg$f38(s3, s5, s7);
4088
+ s0 = peg$f39(s3, s5, s7);
3933
4089
  } else {
3934
4090
  peg$currPos = s0;
3935
4091
  s0 = peg$FAILED;
@@ -3939,13 +4095,13 @@ function peg$parse(input, options) {
3939
4095
  function peg$parseCheckbox() {
3940
4096
  let s0, s1, s2, s3, s4, s5;
3941
4097
  s0 = peg$currPos;
3942
- if (input.substr(peg$currPos, 8) === peg$c40) {
3943
- s1 = peg$c40;
4098
+ if (input.substr(peg$currPos, 8) === peg$c41) {
4099
+ s1 = peg$c41;
3944
4100
  peg$currPos += 8;
3945
4101
  } else {
3946
4102
  s1 = peg$FAILED;
3947
4103
  if (peg$silentFails === 0) {
3948
- peg$fail(peg$e43);
4104
+ peg$fail(peg$e44);
3949
4105
  }
3950
4106
  }
3951
4107
  if (s1 !== peg$FAILED) {
@@ -3960,7 +4116,7 @@ function peg$parse(input, options) {
3960
4116
  s5 = null;
3961
4117
  }
3962
4118
  peg$savedPos = s0;
3963
- s0 = peg$f39(s3, s5);
4119
+ s0 = peg$f40(s3, s5);
3964
4120
  } else {
3965
4121
  peg$currPos = s0;
3966
4122
  s0 = peg$FAILED;
@@ -3970,13 +4126,13 @@ function peg$parse(input, options) {
3970
4126
  function peg$parseRadio() {
3971
4127
  let s0, s1, s2, s3, s4, s5;
3972
4128
  s0 = peg$currPos;
3973
- if (input.substr(peg$currPos, 5) === peg$c41) {
3974
- s1 = peg$c41;
4129
+ if (input.substr(peg$currPos, 5) === peg$c42) {
4130
+ s1 = peg$c42;
3975
4131
  peg$currPos += 5;
3976
4132
  } else {
3977
4133
  s1 = peg$FAILED;
3978
4134
  if (peg$silentFails === 0) {
3979
- peg$fail(peg$e44);
4135
+ peg$fail(peg$e45);
3980
4136
  }
3981
4137
  }
3982
4138
  if (s1 !== peg$FAILED) {
@@ -3991,7 +4147,7 @@ function peg$parse(input, options) {
3991
4147
  s5 = null;
3992
4148
  }
3993
4149
  peg$savedPos = s0;
3994
- s0 = peg$f40(s3, s5);
4150
+ s0 = peg$f41(s3, s5);
3995
4151
  } else {
3996
4152
  peg$currPos = s0;
3997
4153
  s0 = peg$FAILED;
@@ -4001,13 +4157,13 @@ function peg$parse(input, options) {
4001
4157
  function peg$parseSwitch() {
4002
4158
  let s0, s1, s2, s3, s4, s5;
4003
4159
  s0 = peg$currPos;
4004
- if (input.substr(peg$currPos, 6) === peg$c42) {
4005
- s1 = peg$c42;
4160
+ if (input.substr(peg$currPos, 6) === peg$c43) {
4161
+ s1 = peg$c43;
4006
4162
  peg$currPos += 6;
4007
4163
  } else {
4008
4164
  s1 = peg$FAILED;
4009
4165
  if (peg$silentFails === 0) {
4010
- peg$fail(peg$e45);
4166
+ peg$fail(peg$e46);
4011
4167
  }
4012
4168
  }
4013
4169
  if (s1 !== peg$FAILED) {
@@ -4022,7 +4178,7 @@ function peg$parse(input, options) {
4022
4178
  s5 = null;
4023
4179
  }
4024
4180
  peg$savedPos = s0;
4025
- s0 = peg$f41(s3, s5);
4181
+ s0 = peg$f42(s3, s5);
4026
4182
  } else {
4027
4183
  peg$currPos = s0;
4028
4184
  s0 = peg$FAILED;
@@ -4032,13 +4188,13 @@ function peg$parse(input, options) {
4032
4188
  function peg$parseSlider() {
4033
4189
  let s0, s1, s2, s3, s4, s5;
4034
4190
  s0 = peg$currPos;
4035
- if (input.substr(peg$currPos, 6) === peg$c43) {
4036
- s1 = peg$c43;
4191
+ if (input.substr(peg$currPos, 6) === peg$c44) {
4192
+ s1 = peg$c44;
4037
4193
  peg$currPos += 6;
4038
4194
  } else {
4039
4195
  s1 = peg$FAILED;
4040
4196
  if (peg$silentFails === 0) {
4041
- peg$fail(peg$e46);
4197
+ peg$fail(peg$e47);
4042
4198
  }
4043
4199
  }
4044
4200
  if (s1 !== peg$FAILED) {
@@ -4053,7 +4209,7 @@ function peg$parse(input, options) {
4053
4209
  s5 = null;
4054
4210
  }
4055
4211
  peg$savedPos = s0;
4056
- s0 = peg$f42(s3, s5);
4212
+ s0 = peg$f43(s3, s5);
4057
4213
  } else {
4058
4214
  peg$currPos = s0;
4059
4215
  s0 = peg$FAILED;
@@ -4063,13 +4219,13 @@ function peg$parse(input, options) {
4063
4219
  function peg$parseImage() {
4064
4220
  let s0, s1, s2, s3, s4, s5;
4065
4221
  s0 = peg$currPos;
4066
- if (input.substr(peg$currPos, 5) === peg$c44) {
4067
- s1 = peg$c44;
4222
+ if (input.substr(peg$currPos, 5) === peg$c45) {
4223
+ s1 = peg$c45;
4068
4224
  peg$currPos += 5;
4069
4225
  } else {
4070
4226
  s1 = peg$FAILED;
4071
4227
  if (peg$silentFails === 0) {
4072
- peg$fail(peg$e47);
4228
+ peg$fail(peg$e48);
4073
4229
  }
4074
4230
  }
4075
4231
  if (s1 !== peg$FAILED) {
@@ -4084,7 +4240,7 @@ function peg$parse(input, options) {
4084
4240
  s5 = null;
4085
4241
  }
4086
4242
  peg$savedPos = s0;
4087
- s0 = peg$f43(s3, s5);
4243
+ s0 = peg$f44(s3, s5);
4088
4244
  } else {
4089
4245
  peg$currPos = s0;
4090
4246
  s0 = peg$FAILED;
@@ -4094,13 +4250,13 @@ function peg$parse(input, options) {
4094
4250
  function peg$parsePlaceholder() {
4095
4251
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
4096
4252
  s0 = peg$currPos;
4097
- if (input.substr(peg$currPos, 11) === peg$c45) {
4098
- s1 = peg$c45;
4253
+ if (input.substr(peg$currPos, 11) === peg$c46) {
4254
+ s1 = peg$c46;
4099
4255
  peg$currPos += 11;
4100
4256
  } else {
4101
4257
  s1 = peg$FAILED;
4102
4258
  if (peg$silentFails === 0) {
4103
- peg$fail(peg$e48);
4259
+ peg$fail(peg$e49);
4104
4260
  }
4105
4261
  }
4106
4262
  if (s1 !== peg$FAILED) {
@@ -4158,7 +4314,7 @@ function peg$parse(input, options) {
4158
4314
  s7 = null;
4159
4315
  }
4160
4316
  peg$savedPos = s0;
4161
- s0 = peg$f44(s3, s5, s7);
4317
+ s0 = peg$f45(s3, s5, s7);
4162
4318
  } else {
4163
4319
  peg$currPos = s0;
4164
4320
  s0 = peg$FAILED;
@@ -4168,13 +4324,13 @@ function peg$parse(input, options) {
4168
4324
  function peg$parseAvatar() {
4169
4325
  let s0, s1, s2, s3, s4, s5;
4170
4326
  s0 = peg$currPos;
4171
- if (input.substr(peg$currPos, 6) === peg$c46) {
4172
- s1 = peg$c46;
4327
+ if (input.substr(peg$currPos, 6) === peg$c47) {
4328
+ s1 = peg$c47;
4173
4329
  peg$currPos += 6;
4174
4330
  } else {
4175
4331
  s1 = peg$FAILED;
4176
4332
  if (peg$silentFails === 0) {
4177
- peg$fail(peg$e49);
4333
+ peg$fail(peg$e50);
4178
4334
  }
4179
4335
  }
4180
4336
  if (s1 !== peg$FAILED) {
@@ -4189,7 +4345,7 @@ function peg$parse(input, options) {
4189
4345
  s5 = null;
4190
4346
  }
4191
4347
  peg$savedPos = s0;
4192
- s0 = peg$f45(s3, s5);
4348
+ s0 = peg$f46(s3, s5);
4193
4349
  } else {
4194
4350
  peg$currPos = s0;
4195
4351
  s0 = peg$FAILED;
@@ -4199,13 +4355,13 @@ function peg$parse(input, options) {
4199
4355
  function peg$parseBadge() {
4200
4356
  let s0, s1, s2, s3, s4, s5;
4201
4357
  s0 = peg$currPos;
4202
- if (input.substr(peg$currPos, 5) === peg$c47) {
4203
- s1 = peg$c47;
4358
+ if (input.substr(peg$currPos, 5) === peg$c48) {
4359
+ s1 = peg$c48;
4204
4360
  peg$currPos += 5;
4205
4361
  } else {
4206
4362
  s1 = peg$FAILED;
4207
4363
  if (peg$silentFails === 0) {
4208
- peg$fail(peg$e50);
4364
+ peg$fail(peg$e51);
4209
4365
  }
4210
4366
  }
4211
4367
  if (s1 !== peg$FAILED) {
@@ -4218,7 +4374,7 @@ function peg$parse(input, options) {
4218
4374
  s5 = null;
4219
4375
  }
4220
4376
  peg$savedPos = s0;
4221
- s0 = peg$f46(s3, s5);
4377
+ s0 = peg$f47(s3, s5);
4222
4378
  } else {
4223
4379
  peg$currPos = s0;
4224
4380
  s0 = peg$FAILED;
@@ -4232,13 +4388,13 @@ function peg$parse(input, options) {
4232
4388
  function peg$parseIcon() {
4233
4389
  let s0, s1, s2, s3, s4, s5;
4234
4390
  s0 = peg$currPos;
4235
- if (input.substr(peg$currPos, 4) === peg$c48) {
4236
- s1 = peg$c48;
4391
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4392
+ s1 = peg$c49;
4237
4393
  peg$currPos += 4;
4238
4394
  } else {
4239
4395
  s1 = peg$FAILED;
4240
4396
  if (peg$silentFails === 0) {
4241
- peg$fail(peg$e51);
4397
+ peg$fail(peg$e52);
4242
4398
  }
4243
4399
  }
4244
4400
  if (s1 !== peg$FAILED) {
@@ -4251,7 +4407,7 @@ function peg$parse(input, options) {
4251
4407
  s5 = null;
4252
4408
  }
4253
4409
  peg$savedPos = s0;
4254
- s0 = peg$f47(s3, s5);
4410
+ s0 = peg$f48(s3, s5);
4255
4411
  } else {
4256
4412
  peg$currPos = s0;
4257
4413
  s0 = peg$FAILED;
@@ -4265,13 +4421,13 @@ function peg$parse(input, options) {
4265
4421
  function peg$parseTable() {
4266
4422
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4267
4423
  s0 = peg$currPos;
4268
- if (input.substr(peg$currPos, 5) === peg$c49) {
4269
- s1 = peg$c49;
4424
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4425
+ s1 = peg$c50;
4270
4426
  peg$currPos += 5;
4271
4427
  } else {
4272
4428
  s1 = peg$FAILED;
4273
4429
  if (peg$silentFails === 0) {
4274
- peg$fail(peg$e52);
4430
+ peg$fail(peg$e53);
4275
4431
  }
4276
4432
  }
4277
4433
  if (s1 !== peg$FAILED) {
@@ -4284,7 +4440,7 @@ function peg$parse(input, options) {
4284
4440
  s5 = null;
4285
4441
  }
4286
4442
  peg$savedPos = s0;
4287
- s0 = peg$f48(s3, s5);
4443
+ s0 = peg$f49(s3, s5);
4288
4444
  } else {
4289
4445
  peg$currPos = s0;
4290
4446
  s0 = peg$FAILED;
@@ -4295,13 +4451,13 @@ function peg$parse(input, options) {
4295
4451
  }
4296
4452
  if (s0 === peg$FAILED) {
4297
4453
  s0 = peg$currPos;
4298
- if (input.substr(peg$currPos, 5) === peg$c49) {
4299
- s1 = peg$c49;
4454
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4455
+ s1 = peg$c50;
4300
4456
  peg$currPos += 5;
4301
4457
  } else {
4302
4458
  s1 = peg$FAILED;
4303
4459
  if (peg$silentFails === 0) {
4304
- peg$fail(peg$e52);
4460
+ peg$fail(peg$e53);
4305
4461
  }
4306
4462
  }
4307
4463
  if (s1 !== peg$FAILED) {
@@ -4335,7 +4491,7 @@ function peg$parse(input, options) {
4335
4491
  }
4336
4492
  if (s9 !== peg$FAILED) {
4337
4493
  peg$savedPos = s0;
4338
- s0 = peg$f49(s3, s7);
4494
+ s0 = peg$f50(s3, s7);
4339
4495
  } else {
4340
4496
  peg$currPos = s0;
4341
4497
  s0 = peg$FAILED;
@@ -4355,12 +4511,12 @@ function peg$parse(input, options) {
4355
4511
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
4356
4512
  s0 = peg$currPos;
4357
4513
  if (input.charCodeAt(peg$currPos) === 91) {
4358
- s1 = peg$c50;
4514
+ s1 = peg$c51;
4359
4515
  peg$currPos++;
4360
4516
  } else {
4361
4517
  s1 = peg$FAILED;
4362
4518
  if (peg$silentFails === 0) {
4363
- peg$fail(peg$e53);
4519
+ peg$fail(peg$e54);
4364
4520
  }
4365
4521
  }
4366
4522
  if (s1 !== peg$FAILED) {
@@ -4436,17 +4592,17 @@ function peg$parse(input, options) {
4436
4592
  }
4437
4593
  s7 = peg$parse_();
4438
4594
  if (input.charCodeAt(peg$currPos) === 93) {
4439
- s8 = peg$c51;
4595
+ s8 = peg$c52;
4440
4596
  peg$currPos++;
4441
4597
  } else {
4442
4598
  s8 = peg$FAILED;
4443
4599
  if (peg$silentFails === 0) {
4444
- peg$fail(peg$e54);
4600
+ peg$fail(peg$e55);
4445
4601
  }
4446
4602
  }
4447
4603
  if (s8 !== peg$FAILED) {
4448
4604
  peg$savedPos = s0;
4449
- s0 = peg$f50(s3, s5);
4605
+ s0 = peg$f51(s3, s5);
4450
4606
  } else {
4451
4607
  peg$currPos = s0;
4452
4608
  s0 = peg$FAILED;
@@ -4489,20 +4645,20 @@ function peg$parse(input, options) {
4489
4645
  }
4490
4646
  }
4491
4647
  peg$savedPos = s0;
4492
- s1 = peg$f51(s1);
4648
+ s1 = peg$f52(s1);
4493
4649
  s0 = s1;
4494
4650
  return s0;
4495
4651
  }
4496
4652
  function peg$parseTableRow() {
4497
4653
  let s0, s1, s2, s3;
4498
4654
  s0 = peg$currPos;
4499
- if (input.substr(peg$currPos, 7) === peg$c52) {
4500
- s1 = peg$c52;
4655
+ if (input.substr(peg$currPos, 7) === peg$c53) {
4656
+ s1 = peg$c53;
4501
4657
  peg$currPos += 7;
4502
4658
  } else {
4503
4659
  s1 = peg$FAILED;
4504
4660
  if (peg$silentFails === 0) {
4505
- peg$fail(peg$e55);
4661
+ peg$fail(peg$e56);
4506
4662
  }
4507
4663
  }
4508
4664
  if (s1 !== peg$FAILED) {
@@ -4510,7 +4666,7 @@ function peg$parse(input, options) {
4510
4666
  s3 = peg$parseArray();
4511
4667
  if (s3 !== peg$FAILED) {
4512
4668
  peg$savedPos = s0;
4513
- s0 = peg$f52(s3);
4669
+ s0 = peg$f53(s3);
4514
4670
  } else {
4515
4671
  peg$currPos = s0;
4516
4672
  s0 = peg$FAILED;
@@ -4521,13 +4677,13 @@ function peg$parse(input, options) {
4521
4677
  }
4522
4678
  if (s0 === peg$FAILED) {
4523
4679
  s0 = peg$currPos;
4524
- if (input.substr(peg$currPos, 3) === peg$c24) {
4525
- s1 = peg$c24;
4680
+ if (input.substr(peg$currPos, 3) === peg$c25) {
4681
+ s1 = peg$c25;
4526
4682
  peg$currPos += 3;
4527
4683
  } else {
4528
4684
  s1 = peg$FAILED;
4529
4685
  if (peg$silentFails === 0) {
4530
- peg$fail(peg$e27);
4686
+ peg$fail(peg$e28);
4531
4687
  }
4532
4688
  }
4533
4689
  if (s1 !== peg$FAILED) {
@@ -4535,7 +4691,7 @@ function peg$parse(input, options) {
4535
4691
  s3 = peg$parseArray();
4536
4692
  if (s3 !== peg$FAILED) {
4537
4693
  peg$savedPos = s0;
4538
- s0 = peg$f53(s3);
4694
+ s0 = peg$f54(s3);
4539
4695
  } else {
4540
4696
  peg$currPos = s0;
4541
4697
  s0 = peg$FAILED;
@@ -4549,7 +4705,7 @@ function peg$parse(input, options) {
4549
4705
  s1 = peg$parseComment();
4550
4706
  if (s1 !== peg$FAILED) {
4551
4707
  peg$savedPos = s0;
4552
- s1 = peg$f54();
4708
+ s1 = peg$f55();
4553
4709
  }
4554
4710
  s0 = s1;
4555
4711
  }
@@ -4559,13 +4715,13 @@ function peg$parse(input, options) {
4559
4715
  function peg$parseList() {
4560
4716
  let s0, s1, s2, s3, s4, s5, s6, s7;
4561
4717
  s0 = peg$currPos;
4562
- if (input.substr(peg$currPos, 4) === peg$c53) {
4563
- s1 = peg$c53;
4718
+ if (input.substr(peg$currPos, 4) === peg$c54) {
4719
+ s1 = peg$c54;
4564
4720
  peg$currPos += 4;
4565
4721
  } else {
4566
4722
  s1 = peg$FAILED;
4567
4723
  if (peg$silentFails === 0) {
4568
- peg$fail(peg$e56);
4724
+ peg$fail(peg$e57);
4569
4725
  }
4570
4726
  }
4571
4727
  if (s1 !== peg$FAILED) {
@@ -4585,7 +4741,7 @@ function peg$parse(input, options) {
4585
4741
  s7 = null;
4586
4742
  }
4587
4743
  peg$savedPos = s0;
4588
- s0 = peg$f55(s3, s5, s7);
4744
+ s0 = peg$f56(s3, s5, s7);
4589
4745
  } else {
4590
4746
  peg$currPos = s0;
4591
4747
  s0 = peg$FAILED;
@@ -4641,7 +4797,7 @@ function peg$parse(input, options) {
4641
4797
  }
4642
4798
  if (s4 !== peg$FAILED) {
4643
4799
  peg$savedPos = s0;
4644
- s0 = peg$f56(s3);
4800
+ s0 = peg$f57(s3);
4645
4801
  } else {
4646
4802
  peg$currPos = s0;
4647
4803
  s0 = peg$FAILED;
@@ -4655,13 +4811,13 @@ function peg$parse(input, options) {
4655
4811
  function peg$parseListItem() {
4656
4812
  let s0, s1, s2, s3, s4, s5, s6, s7;
4657
4813
  s0 = peg$currPos;
4658
- if (input.substr(peg$currPos, 4) === peg$c54) {
4659
- s1 = peg$c54;
4814
+ if (input.substr(peg$currPos, 4) === peg$c55) {
4815
+ s1 = peg$c55;
4660
4816
  peg$currPos += 4;
4661
4817
  } else {
4662
4818
  s1 = peg$FAILED;
4663
4819
  if (peg$silentFails === 0) {
4664
- peg$fail(peg$e57);
4820
+ peg$fail(peg$e58);
4665
4821
  }
4666
4822
  }
4667
4823
  if (s1 !== peg$FAILED) {
@@ -4679,7 +4835,7 @@ function peg$parse(input, options) {
4679
4835
  s7 = null;
4680
4836
  }
4681
4837
  peg$savedPos = s0;
4682
- s0 = peg$f57(s3, s5, s7);
4838
+ s0 = peg$f58(s3, s5, s7);
4683
4839
  } else {
4684
4840
  peg$currPos = s0;
4685
4841
  s0 = peg$FAILED;
@@ -4693,7 +4849,7 @@ function peg$parse(input, options) {
4693
4849
  s1 = peg$parseComment();
4694
4850
  if (s1 !== peg$FAILED) {
4695
4851
  peg$savedPos = s0;
4696
- s1 = peg$f58();
4852
+ s1 = peg$f59();
4697
4853
  }
4698
4854
  s0 = s1;
4699
4855
  }
@@ -4702,13 +4858,13 @@ function peg$parse(input, options) {
4702
4858
  function peg$parseAlert() {
4703
4859
  let s0, s1, s2, s3, s4, s5;
4704
4860
  s0 = peg$currPos;
4705
- if (input.substr(peg$currPos, 5) === peg$c55) {
4706
- s1 = peg$c55;
4861
+ if (input.substr(peg$currPos, 5) === peg$c56) {
4862
+ s1 = peg$c56;
4707
4863
  peg$currPos += 5;
4708
4864
  } else {
4709
4865
  s1 = peg$FAILED;
4710
4866
  if (peg$silentFails === 0) {
4711
- peg$fail(peg$e58);
4867
+ peg$fail(peg$e59);
4712
4868
  }
4713
4869
  }
4714
4870
  if (s1 !== peg$FAILED) {
@@ -4721,7 +4877,7 @@ function peg$parse(input, options) {
4721
4877
  s5 = null;
4722
4878
  }
4723
4879
  peg$savedPos = s0;
4724
- s0 = peg$f59(s3, s5);
4880
+ s0 = peg$f60(s3, s5);
4725
4881
  } else {
4726
4882
  peg$currPos = s0;
4727
4883
  s0 = peg$FAILED;
@@ -4735,13 +4891,13 @@ function peg$parse(input, options) {
4735
4891
  function peg$parseToast() {
4736
4892
  let s0, s1, s2, s3, s4, s5;
4737
4893
  s0 = peg$currPos;
4738
- if (input.substr(peg$currPos, 5) === peg$c56) {
4739
- s1 = peg$c56;
4894
+ if (input.substr(peg$currPos, 5) === peg$c57) {
4895
+ s1 = peg$c57;
4740
4896
  peg$currPos += 5;
4741
4897
  } else {
4742
4898
  s1 = peg$FAILED;
4743
4899
  if (peg$silentFails === 0) {
4744
- peg$fail(peg$e59);
4900
+ peg$fail(peg$e60);
4745
4901
  }
4746
4902
  }
4747
4903
  if (s1 !== peg$FAILED) {
@@ -4754,7 +4910,7 @@ function peg$parse(input, options) {
4754
4910
  s5 = null;
4755
4911
  }
4756
4912
  peg$savedPos = s0;
4757
- s0 = peg$f60(s3, s5);
4913
+ s0 = peg$f61(s3, s5);
4758
4914
  } else {
4759
4915
  peg$currPos = s0;
4760
4916
  s0 = peg$FAILED;
@@ -4768,13 +4924,13 @@ function peg$parse(input, options) {
4768
4924
  function peg$parseProgress() {
4769
4925
  let s0, s1, s2, s3;
4770
4926
  s0 = peg$currPos;
4771
- if (input.substr(peg$currPos, 8) === peg$c57) {
4772
- s1 = peg$c57;
4927
+ if (input.substr(peg$currPos, 8) === peg$c58) {
4928
+ s1 = peg$c58;
4773
4929
  peg$currPos += 8;
4774
4930
  } else {
4775
4931
  s1 = peg$FAILED;
4776
4932
  if (peg$silentFails === 0) {
4777
- peg$fail(peg$e60);
4933
+ peg$fail(peg$e61);
4778
4934
  }
4779
4935
  }
4780
4936
  if (s1 !== peg$FAILED) {
@@ -4784,7 +4940,7 @@ function peg$parse(input, options) {
4784
4940
  s3 = null;
4785
4941
  }
4786
4942
  peg$savedPos = s0;
4787
- s0 = peg$f61(s3);
4943
+ s0 = peg$f62(s3);
4788
4944
  } else {
4789
4945
  peg$currPos = s0;
4790
4946
  s0 = peg$FAILED;
@@ -4794,13 +4950,13 @@ function peg$parse(input, options) {
4794
4950
  function peg$parseSpinner() {
4795
4951
  let s0, s1, s2, s3, s4, s5;
4796
4952
  s0 = peg$currPos;
4797
- if (input.substr(peg$currPos, 7) === peg$c58) {
4798
- s1 = peg$c58;
4953
+ if (input.substr(peg$currPos, 7) === peg$c59) {
4954
+ s1 = peg$c59;
4799
4955
  peg$currPos += 7;
4800
4956
  } else {
4801
4957
  s1 = peg$FAILED;
4802
4958
  if (peg$silentFails === 0) {
4803
- peg$fail(peg$e61);
4959
+ peg$fail(peg$e62);
4804
4960
  }
4805
4961
  }
4806
4962
  if (s1 !== peg$FAILED) {
@@ -4815,7 +4971,7 @@ function peg$parse(input, options) {
4815
4971
  s5 = null;
4816
4972
  }
4817
4973
  peg$savedPos = s0;
4818
- s0 = peg$f62(s3, s5);
4974
+ s0 = peg$f63(s3, s5);
4819
4975
  } else {
4820
4976
  peg$currPos = s0;
4821
4977
  s0 = peg$FAILED;
@@ -4825,13 +4981,13 @@ function peg$parse(input, options) {
4825
4981
  function peg$parseTooltip() {
4826
4982
  let s0, s1, s2, s3, s4, s5;
4827
4983
  s0 = peg$currPos;
4828
- if (input.substr(peg$currPos, 7) === peg$c59) {
4829
- s1 = peg$c59;
4984
+ if (input.substr(peg$currPos, 7) === peg$c60) {
4985
+ s1 = peg$c60;
4830
4986
  peg$currPos += 7;
4831
4987
  } else {
4832
4988
  s1 = peg$FAILED;
4833
4989
  if (peg$silentFails === 0) {
4834
- peg$fail(peg$e62);
4990
+ peg$fail(peg$e63);
4835
4991
  }
4836
4992
  }
4837
4993
  if (s1 !== peg$FAILED) {
@@ -4844,7 +5000,7 @@ function peg$parse(input, options) {
4844
5000
  s5 = null;
4845
5001
  }
4846
5002
  peg$savedPos = s0;
4847
- s0 = peg$f63(s3, s5);
5003
+ s0 = peg$f64(s3, s5);
4848
5004
  } else {
4849
5005
  peg$currPos = s0;
4850
5006
  s0 = peg$FAILED;
@@ -4858,13 +5014,13 @@ function peg$parse(input, options) {
4858
5014
  function peg$parsePopover() {
4859
5015
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
4860
5016
  s0 = peg$currPos;
4861
- if (input.substr(peg$currPos, 7) === peg$c60) {
4862
- s1 = peg$c60;
5017
+ if (input.substr(peg$currPos, 7) === peg$c61) {
5018
+ s1 = peg$c61;
4863
5019
  peg$currPos += 7;
4864
5020
  } else {
4865
5021
  s1 = peg$FAILED;
4866
5022
  if (peg$silentFails === 0) {
4867
- peg$fail(peg$e63);
5023
+ peg$fail(peg$e64);
4868
5024
  }
4869
5025
  }
4870
5026
  if (s1 !== peg$FAILED) {
@@ -4904,7 +5060,7 @@ function peg$parse(input, options) {
4904
5060
  }
4905
5061
  if (s11 !== peg$FAILED) {
4906
5062
  peg$savedPos = s0;
4907
- s0 = peg$f64(s3, s5, s9);
5063
+ s0 = peg$f65(s3, s5, s9);
4908
5064
  } else {
4909
5065
  peg$currPos = s0;
4910
5066
  s0 = peg$FAILED;
@@ -4926,13 +5082,13 @@ function peg$parse(input, options) {
4926
5082
  function peg$parseDropdown() {
4927
5083
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4928
5084
  s0 = peg$currPos;
4929
- if (input.substr(peg$currPos, 8) === peg$c61) {
4930
- s1 = peg$c61;
5085
+ if (input.substr(peg$currPos, 8) === peg$c62) {
5086
+ s1 = peg$c62;
4931
5087
  peg$currPos += 8;
4932
5088
  } else {
4933
5089
  s1 = peg$FAILED;
4934
5090
  if (peg$silentFails === 0) {
4935
- peg$fail(peg$e64);
5091
+ peg$fail(peg$e65);
4936
5092
  }
4937
5093
  }
4938
5094
  if (s1 !== peg$FAILED) {
@@ -4945,7 +5101,7 @@ function peg$parse(input, options) {
4945
5101
  s5 = null;
4946
5102
  }
4947
5103
  peg$savedPos = s0;
4948
- s0 = peg$f65(s3, s5);
5104
+ s0 = peg$f66(s3, s5);
4949
5105
  } else {
4950
5106
  peg$currPos = s0;
4951
5107
  s0 = peg$FAILED;
@@ -4956,13 +5112,13 @@ function peg$parse(input, options) {
4956
5112
  }
4957
5113
  if (s0 === peg$FAILED) {
4958
5114
  s0 = peg$currPos;
4959
- if (input.substr(peg$currPos, 8) === peg$c61) {
4960
- s1 = peg$c61;
5115
+ if (input.substr(peg$currPos, 8) === peg$c62) {
5116
+ s1 = peg$c62;
4961
5117
  peg$currPos += 8;
4962
5118
  } else {
4963
5119
  s1 = peg$FAILED;
4964
5120
  if (peg$silentFails === 0) {
4965
- peg$fail(peg$e64);
5121
+ peg$fail(peg$e65);
4966
5122
  }
4967
5123
  }
4968
5124
  if (s1 !== peg$FAILED) {
@@ -4996,7 +5152,7 @@ function peg$parse(input, options) {
4996
5152
  }
4997
5153
  if (s9 !== peg$FAILED) {
4998
5154
  peg$savedPos = s0;
4999
- s0 = peg$f66(s3, s7);
5155
+ s0 = peg$f67(s3, s7);
5000
5156
  } else {
5001
5157
  peg$currPos = s0;
5002
5158
  s0 = peg$FAILED;
@@ -5040,20 +5196,20 @@ function peg$parse(input, options) {
5040
5196
  }
5041
5197
  }
5042
5198
  peg$savedPos = s0;
5043
- s1 = peg$f67(s1);
5199
+ s1 = peg$f68(s1);
5044
5200
  s0 = s1;
5045
5201
  return s0;
5046
5202
  }
5047
5203
  function peg$parseDropdownItem() {
5048
5204
  let s0, s1, s2, s3, s4, s5;
5049
5205
  s0 = peg$currPos;
5050
- if (input.substr(peg$currPos, 4) === peg$c54) {
5051
- s1 = peg$c54;
5206
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5207
+ s1 = peg$c55;
5052
5208
  peg$currPos += 4;
5053
5209
  } else {
5054
5210
  s1 = peg$FAILED;
5055
5211
  if (peg$silentFails === 0) {
5056
- peg$fail(peg$e57);
5212
+ peg$fail(peg$e58);
5057
5213
  }
5058
5214
  }
5059
5215
  if (s1 !== peg$FAILED) {
@@ -5066,7 +5222,7 @@ function peg$parse(input, options) {
5066
5222
  s5 = null;
5067
5223
  }
5068
5224
  peg$savedPos = s0;
5069
- s0 = peg$f68(s3, s5);
5225
+ s0 = peg$f69(s3, s5);
5070
5226
  } else {
5071
5227
  peg$currPos = s0;
5072
5228
  s0 = peg$FAILED;
@@ -5077,18 +5233,18 @@ function peg$parse(input, options) {
5077
5233
  }
5078
5234
  if (s0 === peg$FAILED) {
5079
5235
  s0 = peg$currPos;
5080
- if (input.substr(peg$currPos, 7) === peg$c62) {
5081
- s1 = peg$c62;
5236
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5237
+ s1 = peg$c63;
5082
5238
  peg$currPos += 7;
5083
5239
  } else {
5084
5240
  s1 = peg$FAILED;
5085
5241
  if (peg$silentFails === 0) {
5086
- peg$fail(peg$e65);
5242
+ peg$fail(peg$e66);
5087
5243
  }
5088
5244
  }
5089
5245
  if (s1 !== peg$FAILED) {
5090
5246
  peg$savedPos = s0;
5091
- s1 = peg$f69();
5247
+ s1 = peg$f70();
5092
5248
  }
5093
5249
  s0 = s1;
5094
5250
  if (s0 === peg$FAILED) {
@@ -5096,7 +5252,7 @@ function peg$parse(input, options) {
5096
5252
  s1 = peg$parseComment();
5097
5253
  if (s1 !== peg$FAILED) {
5098
5254
  peg$savedPos = s0;
5099
- s1 = peg$f70();
5255
+ s1 = peg$f71();
5100
5256
  }
5101
5257
  s0 = s1;
5102
5258
  }
@@ -5106,13 +5262,13 @@ function peg$parse(input, options) {
5106
5262
  function peg$parseNav() {
5107
5263
  let s0, s1, s2, s3, s4, s5, s6, s7;
5108
5264
  s0 = peg$currPos;
5109
- if (input.substr(peg$currPos, 3) === peg$c63) {
5110
- s1 = peg$c63;
5265
+ if (input.substr(peg$currPos, 3) === peg$c64) {
5266
+ s1 = peg$c64;
5111
5267
  peg$currPos += 3;
5112
5268
  } else {
5113
5269
  s1 = peg$FAILED;
5114
5270
  if (peg$silentFails === 0) {
5115
- peg$fail(peg$e66);
5271
+ peg$fail(peg$e67);
5116
5272
  }
5117
5273
  }
5118
5274
  if (s1 !== peg$FAILED) {
@@ -5132,7 +5288,7 @@ function peg$parse(input, options) {
5132
5288
  s7 = null;
5133
5289
  }
5134
5290
  peg$savedPos = s0;
5135
- s0 = peg$f71(s3, s5, s7);
5291
+ s0 = peg$f72(s3, s5, s7);
5136
5292
  } else {
5137
5293
  peg$currPos = s0;
5138
5294
  s0 = peg$FAILED;
@@ -5188,7 +5344,7 @@ function peg$parse(input, options) {
5188
5344
  }
5189
5345
  if (s4 !== peg$FAILED) {
5190
5346
  peg$savedPos = s0;
5191
- s0 = peg$f72(s3);
5347
+ s0 = peg$f73(s3);
5192
5348
  } else {
5193
5349
  peg$currPos = s0;
5194
5350
  s0 = peg$FAILED;
@@ -5206,19 +5362,19 @@ function peg$parse(input, options) {
5206
5362
  s0 = peg$parseNavItem();
5207
5363
  if (s0 === peg$FAILED) {
5208
5364
  s0 = peg$currPos;
5209
- if (input.substr(peg$currPos, 7) === peg$c62) {
5210
- s1 = peg$c62;
5365
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5366
+ s1 = peg$c63;
5211
5367
  peg$currPos += 7;
5212
5368
  } else {
5213
5369
  s1 = peg$FAILED;
5214
5370
  if (peg$silentFails === 0) {
5215
- peg$fail(peg$e65);
5371
+ peg$fail(peg$e66);
5216
5372
  }
5217
5373
  }
5218
5374
  if (s1 !== peg$FAILED) {
5219
5375
  s2 = peg$parse_();
5220
5376
  peg$savedPos = s0;
5221
- s0 = peg$f73();
5377
+ s0 = peg$f74();
5222
5378
  } else {
5223
5379
  peg$currPos = s0;
5224
5380
  s0 = peg$FAILED;
@@ -5228,7 +5384,7 @@ function peg$parse(input, options) {
5228
5384
  s1 = peg$parseComment();
5229
5385
  if (s1 !== peg$FAILED) {
5230
5386
  peg$savedPos = s0;
5231
- s1 = peg$f74();
5387
+ s1 = peg$f75();
5232
5388
  }
5233
5389
  s0 = s1;
5234
5390
  }
@@ -5239,13 +5395,13 @@ function peg$parse(input, options) {
5239
5395
  function peg$parseNavGroup() {
5240
5396
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
5241
5397
  s0 = peg$currPos;
5242
- if (input.substr(peg$currPos, 5) === peg$c64) {
5243
- s1 = peg$c64;
5398
+ if (input.substr(peg$currPos, 5) === peg$c65) {
5399
+ s1 = peg$c65;
5244
5400
  peg$currPos += 5;
5245
5401
  } else {
5246
5402
  s1 = peg$FAILED;
5247
5403
  if (peg$silentFails === 0) {
5248
- peg$fail(peg$e67);
5404
+ peg$fail(peg$e68);
5249
5405
  }
5250
5406
  }
5251
5407
  if (s1 !== peg$FAILED) {
@@ -5304,7 +5460,7 @@ function peg$parse(input, options) {
5304
5460
  }
5305
5461
  if (s10 !== peg$FAILED) {
5306
5462
  peg$savedPos = s0;
5307
- s0 = peg$f75(s3, s5, s9);
5463
+ s0 = peg$f76(s3, s5, s9);
5308
5464
  } else {
5309
5465
  peg$currPos = s0;
5310
5466
  s0 = peg$FAILED;
@@ -5328,19 +5484,19 @@ function peg$parse(input, options) {
5328
5484
  s0 = peg$parseNavItem();
5329
5485
  if (s0 === peg$FAILED) {
5330
5486
  s0 = peg$currPos;
5331
- if (input.substr(peg$currPos, 7) === peg$c62) {
5332
- s1 = peg$c62;
5487
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5488
+ s1 = peg$c63;
5333
5489
  peg$currPos += 7;
5334
5490
  } else {
5335
5491
  s1 = peg$FAILED;
5336
5492
  if (peg$silentFails === 0) {
5337
- peg$fail(peg$e65);
5493
+ peg$fail(peg$e66);
5338
5494
  }
5339
5495
  }
5340
5496
  if (s1 !== peg$FAILED) {
5341
5497
  s2 = peg$parse_();
5342
5498
  peg$savedPos = s0;
5343
- s0 = peg$f76();
5499
+ s0 = peg$f77();
5344
5500
  } else {
5345
5501
  peg$currPos = s0;
5346
5502
  s0 = peg$FAILED;
@@ -5350,7 +5506,7 @@ function peg$parse(input, options) {
5350
5506
  s1 = peg$parseComment();
5351
5507
  if (s1 !== peg$FAILED) {
5352
5508
  peg$savedPos = s0;
5353
- s1 = peg$f77();
5509
+ s1 = peg$f78();
5354
5510
  }
5355
5511
  s0 = s1;
5356
5512
  }
@@ -5360,13 +5516,13 @@ function peg$parse(input, options) {
5360
5516
  function peg$parseNavItem() {
5361
5517
  let s0, s1, s2, s3, s4, s5;
5362
5518
  s0 = peg$currPos;
5363
- if (input.substr(peg$currPos, 4) === peg$c54) {
5364
- s1 = peg$c54;
5519
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5520
+ s1 = peg$c55;
5365
5521
  peg$currPos += 4;
5366
5522
  } else {
5367
5523
  s1 = peg$FAILED;
5368
5524
  if (peg$silentFails === 0) {
5369
- peg$fail(peg$e57);
5525
+ peg$fail(peg$e58);
5370
5526
  }
5371
5527
  }
5372
5528
  if (s1 !== peg$FAILED) {
@@ -5379,7 +5535,7 @@ function peg$parse(input, options) {
5379
5535
  s5 = null;
5380
5536
  }
5381
5537
  peg$savedPos = s0;
5382
- s0 = peg$f78(s3, s5);
5538
+ s0 = peg$f79(s3, s5);
5383
5539
  } else {
5384
5540
  peg$currPos = s0;
5385
5541
  s0 = peg$FAILED;
@@ -5393,13 +5549,13 @@ function peg$parse(input, options) {
5393
5549
  function peg$parseTabs() {
5394
5550
  let s0, s1, s2, s3, s4, s5, s6, s7;
5395
5551
  s0 = peg$currPos;
5396
- if (input.substr(peg$currPos, 4) === peg$c65) {
5397
- s1 = peg$c65;
5552
+ if (input.substr(peg$currPos, 4) === peg$c66) {
5553
+ s1 = peg$c66;
5398
5554
  peg$currPos += 4;
5399
5555
  } else {
5400
5556
  s1 = peg$FAILED;
5401
5557
  if (peg$silentFails === 0) {
5402
- peg$fail(peg$e68);
5558
+ peg$fail(peg$e69);
5403
5559
  }
5404
5560
  }
5405
5561
  if (s1 !== peg$FAILED) {
@@ -5419,7 +5575,7 @@ function peg$parse(input, options) {
5419
5575
  s7 = null;
5420
5576
  }
5421
5577
  peg$savedPos = s0;
5422
- s0 = peg$f79(s3, s5, s7);
5578
+ s0 = peg$f80(s3, s5, s7);
5423
5579
  } else {
5424
5580
  peg$currPos = s0;
5425
5581
  s0 = peg$FAILED;
@@ -5475,7 +5631,7 @@ function peg$parse(input, options) {
5475
5631
  }
5476
5632
  if (s4 !== peg$FAILED) {
5477
5633
  peg$savedPos = s0;
5478
- s0 = peg$f80(s3);
5634
+ s0 = peg$f81(s3);
5479
5635
  } else {
5480
5636
  peg$currPos = s0;
5481
5637
  s0 = peg$FAILED;
@@ -5489,13 +5645,13 @@ function peg$parse(input, options) {
5489
5645
  function peg$parseTabItem() {
5490
5646
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
5491
5647
  s0 = peg$currPos;
5492
- if (input.substr(peg$currPos, 3) === peg$c66) {
5493
- s1 = peg$c66;
5648
+ if (input.substr(peg$currPos, 3) === peg$c67) {
5649
+ s1 = peg$c67;
5494
5650
  peg$currPos += 3;
5495
5651
  } else {
5496
5652
  s1 = peg$FAILED;
5497
5653
  if (peg$silentFails === 0) {
5498
- peg$fail(peg$e69);
5654
+ peg$fail(peg$e70);
5499
5655
  }
5500
5656
  }
5501
5657
  if (s1 !== peg$FAILED) {
@@ -5533,7 +5689,7 @@ function peg$parse(input, options) {
5533
5689
  }
5534
5690
  if (s11 !== peg$FAILED) {
5535
5691
  peg$savedPos = s0;
5536
- s0 = peg$f81(s3, s5, s9);
5692
+ s0 = peg$f82(s3, s5, s9);
5537
5693
  } else {
5538
5694
  peg$currPos = s0;
5539
5695
  s0 = peg$FAILED;
@@ -5559,7 +5715,7 @@ function peg$parse(input, options) {
5559
5715
  s1 = peg$parseComment();
5560
5716
  if (s1 !== peg$FAILED) {
5561
5717
  peg$savedPos = s0;
5562
- s1 = peg$f82();
5718
+ s1 = peg$f83();
5563
5719
  }
5564
5720
  s0 = s1;
5565
5721
  }
@@ -5568,13 +5724,13 @@ function peg$parse(input, options) {
5568
5724
  function peg$parseBreadcrumb() {
5569
5725
  let s0, s1, s2, s3, s4, s5;
5570
5726
  s0 = peg$currPos;
5571
- if (input.substr(peg$currPos, 10) === peg$c67) {
5572
- s1 = peg$c67;
5727
+ if (input.substr(peg$currPos, 10) === peg$c68) {
5728
+ s1 = peg$c68;
5573
5729
  peg$currPos += 10;
5574
5730
  } else {
5575
5731
  s1 = peg$FAILED;
5576
5732
  if (peg$silentFails === 0) {
5577
- peg$fail(peg$e70);
5733
+ peg$fail(peg$e71);
5578
5734
  }
5579
5735
  }
5580
5736
  if (s1 !== peg$FAILED) {
@@ -5587,7 +5743,7 @@ function peg$parse(input, options) {
5587
5743
  s5 = null;
5588
5744
  }
5589
5745
  peg$savedPos = s0;
5590
- s0 = peg$f83(s3, s5);
5746
+ s0 = peg$f84(s3, s5);
5591
5747
  } else {
5592
5748
  peg$currPos = s0;
5593
5749
  s0 = peg$FAILED;
@@ -5601,13 +5757,13 @@ function peg$parse(input, options) {
5601
5757
  function peg$parseDivider() {
5602
5758
  let s0, s1, s2, s3;
5603
5759
  s0 = peg$currPos;
5604
- if (input.substr(peg$currPos, 7) === peg$c62) {
5605
- s1 = peg$c62;
5760
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5761
+ s1 = peg$c63;
5606
5762
  peg$currPos += 7;
5607
5763
  } else {
5608
5764
  s1 = peg$FAILED;
5609
5765
  if (peg$silentFails === 0) {
5610
- peg$fail(peg$e65);
5766
+ peg$fail(peg$e66);
5611
5767
  }
5612
5768
  }
5613
5769
  if (s1 !== peg$FAILED) {
@@ -5617,7 +5773,7 @@ function peg$parse(input, options) {
5617
5773
  s3 = null;
5618
5774
  }
5619
5775
  peg$savedPos = s0;
5620
- s0 = peg$f84(s3);
5776
+ s0 = peg$f85(s3);
5621
5777
  } else {
5622
5778
  peg$currPos = s0;
5623
5779
  s0 = peg$FAILED;
@@ -5627,13 +5783,13 @@ function peg$parse(input, options) {
5627
5783
  function peg$parseMarker() {
5628
5784
  let s0, s1, s2, s3, s4, s5;
5629
5785
  s0 = peg$currPos;
5630
- if (input.substr(peg$currPos, 6) === peg$c68) {
5631
- s1 = peg$c68;
5786
+ if (input.substr(peg$currPos, 6) === peg$c69) {
5787
+ s1 = peg$c69;
5632
5788
  peg$currPos += 6;
5633
5789
  } else {
5634
5790
  s1 = peg$FAILED;
5635
5791
  if (peg$silentFails === 0) {
5636
- peg$fail(peg$e71);
5792
+ peg$fail(peg$e72);
5637
5793
  }
5638
5794
  }
5639
5795
  if (s1 !== peg$FAILED) {
@@ -5646,7 +5802,7 @@ function peg$parse(input, options) {
5646
5802
  s5 = null;
5647
5803
  }
5648
5804
  peg$savedPos = s0;
5649
- s0 = peg$f85(s3, s5);
5805
+ s0 = peg$f86(s3, s5);
5650
5806
  } else {
5651
5807
  peg$currPos = s0;
5652
5808
  s0 = peg$FAILED;
@@ -5660,13 +5816,13 @@ function peg$parse(input, options) {
5660
5816
  function peg$parseAnnotations() {
5661
5817
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
5662
5818
  s0 = peg$currPos;
5663
- if (input.substr(peg$currPos, 11) === peg$c69) {
5664
- s1 = peg$c69;
5819
+ if (input.substr(peg$currPos, 11) === peg$c70) {
5820
+ s1 = peg$c70;
5665
5821
  peg$currPos += 11;
5666
5822
  } else {
5667
5823
  s1 = peg$FAILED;
5668
5824
  if (peg$silentFails === 0) {
5669
- peg$fail(peg$e72);
5825
+ peg$fail(peg$e73);
5670
5826
  }
5671
5827
  }
5672
5828
  if (s1 !== peg$FAILED) {
@@ -5700,7 +5856,7 @@ function peg$parse(input, options) {
5700
5856
  }
5701
5857
  if (s9 !== peg$FAILED) {
5702
5858
  peg$savedPos = s0;
5703
- s0 = peg$f86(s3, s7);
5859
+ s0 = peg$f87(s3, s7);
5704
5860
  } else {
5705
5861
  peg$currPos = s0;
5706
5862
  s0 = peg$FAILED;
@@ -5743,20 +5899,20 @@ function peg$parse(input, options) {
5743
5899
  }
5744
5900
  }
5745
5901
  peg$savedPos = s0;
5746
- s1 = peg$f87(s1);
5902
+ s1 = peg$f88(s1);
5747
5903
  s0 = s1;
5748
5904
  return s0;
5749
5905
  }
5750
5906
  function peg$parseAnnotationItem() {
5751
5907
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5752
5908
  s0 = peg$currPos;
5753
- if (input.substr(peg$currPos, 4) === peg$c54) {
5754
- s1 = peg$c54;
5909
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5910
+ s1 = peg$c55;
5755
5911
  peg$currPos += 4;
5756
5912
  } else {
5757
5913
  s1 = peg$FAILED;
5758
5914
  if (peg$silentFails === 0) {
5759
- peg$fail(peg$e57);
5915
+ peg$fail(peg$e58);
5760
5916
  }
5761
5917
  }
5762
5918
  if (s1 !== peg$FAILED) {
@@ -5797,7 +5953,7 @@ function peg$parse(input, options) {
5797
5953
  }
5798
5954
  if (s13 !== peg$FAILED) {
5799
5955
  peg$savedPos = s0;
5800
- s0 = peg$f88(s3, s5, s7, s11);
5956
+ s0 = peg$f89(s3, s5, s7, s11);
5801
5957
  } else {
5802
5958
  peg$currPos = s0;
5803
5959
  s0 = peg$FAILED;
@@ -5824,13 +5980,13 @@ function peg$parse(input, options) {
5824
5980
  }
5825
5981
  if (s0 === peg$FAILED) {
5826
5982
  s0 = peg$currPos;
5827
- if (input.substr(peg$currPos, 4) === peg$c54) {
5828
- s1 = peg$c54;
5983
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5984
+ s1 = peg$c55;
5829
5985
  peg$currPos += 4;
5830
5986
  } else {
5831
5987
  s1 = peg$FAILED;
5832
5988
  if (peg$silentFails === 0) {
5833
- peg$fail(peg$e57);
5989
+ peg$fail(peg$e58);
5834
5990
  }
5835
5991
  }
5836
5992
  if (s1 !== peg$FAILED) {
@@ -5846,7 +6002,7 @@ function peg$parse(input, options) {
5846
6002
  s7 = null;
5847
6003
  }
5848
6004
  peg$savedPos = s0;
5849
- s0 = peg$f89(s3, s5, s7);
6005
+ s0 = peg$f90(s3, s5, s7);
5850
6006
  } else {
5851
6007
  peg$currPos = s0;
5852
6008
  s0 = peg$FAILED;
@@ -5864,7 +6020,7 @@ function peg$parse(input, options) {
5864
6020
  s1 = peg$parseComment();
5865
6021
  if (s1 !== peg$FAILED) {
5866
6022
  peg$savedPos = s0;
5867
- s1 = peg$f90();
6023
+ s1 = peg$f91();
5868
6024
  }
5869
6025
  s0 = s1;
5870
6026
  }
@@ -5882,7 +6038,7 @@ function peg$parse(input, options) {
5882
6038
  } else {
5883
6039
  s2 = peg$FAILED;
5884
6040
  if (peg$silentFails === 0) {
5885
- peg$fail(peg$e74);
6041
+ peg$fail(peg$e75);
5886
6042
  }
5887
6043
  }
5888
6044
  if (s2 !== peg$FAILED) {
@@ -5894,7 +6050,7 @@ function peg$parse(input, options) {
5894
6050
  } else {
5895
6051
  s2 = peg$FAILED;
5896
6052
  if (peg$silentFails === 0) {
5897
- peg$fail(peg$e74);
6053
+ peg$fail(peg$e75);
5898
6054
  }
5899
6055
  }
5900
6056
  }
@@ -5903,14 +6059,14 @@ function peg$parse(input, options) {
5903
6059
  }
5904
6060
  if (s1 !== peg$FAILED) {
5905
6061
  peg$savedPos = s0;
5906
- s1 = peg$f91(s1);
6062
+ s1 = peg$f92(s1);
5907
6063
  }
5908
6064
  s0 = s1;
5909
6065
  peg$silentFails--;
5910
6066
  if (s0 === peg$FAILED) {
5911
6067
  s1 = peg$FAILED;
5912
6068
  if (peg$silentFails === 0) {
5913
- peg$fail(peg$e73);
6069
+ peg$fail(peg$e74);
5914
6070
  }
5915
6071
  }
5916
6072
  return s0;
@@ -5930,7 +6086,7 @@ function peg$parse(input, options) {
5930
6086
  }
5931
6087
  if (s1 !== peg$FAILED) {
5932
6088
  peg$savedPos = s0;
5933
- s1 = peg$f92(s1);
6089
+ s1 = peg$f93(s1);
5934
6090
  }
5935
6091
  s0 = s1;
5936
6092
  return s0;
@@ -5939,13 +6095,13 @@ function peg$parse(input, options) {
5939
6095
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5940
6096
  s0 = peg$currPos;
5941
6097
  s1 = peg$parse_();
5942
- if (input.substr(peg$currPos, 2) === peg$c70) {
5943
- s2 = peg$c70;
6098
+ if (input.substr(peg$currPos, 2) === peg$c71) {
6099
+ s2 = peg$c71;
5944
6100
  peg$currPos += 2;
5945
6101
  } else {
5946
6102
  s2 = peg$FAILED;
5947
6103
  if (peg$silentFails === 0) {
5948
- peg$fail(peg$e75);
6104
+ peg$fail(peg$e76);
5949
6105
  }
5950
6106
  }
5951
6107
  if (s2 !== peg$FAILED) {
@@ -6000,7 +6156,7 @@ function peg$parse(input, options) {
6000
6156
  }
6001
6157
  if (s13 !== peg$FAILED) {
6002
6158
  peg$savedPos = s0;
6003
- s0 = peg$f93(s7, s11);
6159
+ s0 = peg$f94(s7, s11);
6004
6160
  } else {
6005
6161
  peg$currPos = s0;
6006
6162
  s0 = peg$FAILED;
@@ -6049,7 +6205,7 @@ function peg$parse(input, options) {
6049
6205
  s6 = peg$parseAttributeValue();
6050
6206
  if (s6 !== peg$FAILED) {
6051
6207
  peg$savedPos = s0;
6052
- s0 = peg$f94(s2, s6);
6208
+ s0 = peg$f95(s2, s6);
6053
6209
  } else {
6054
6210
  peg$currPos = s0;
6055
6211
  s0 = peg$FAILED;
@@ -6081,7 +6237,7 @@ function peg$parse(input, options) {
6081
6237
  } else {
6082
6238
  s6 = peg$FAILED;
6083
6239
  if (peg$silentFails === 0) {
6084
- peg$fail(peg$e76);
6240
+ peg$fail(peg$e77);
6085
6241
  }
6086
6242
  }
6087
6243
  if (s6 === peg$FAILED) {
@@ -6144,7 +6300,7 @@ function peg$parse(input, options) {
6144
6300
  }
6145
6301
  if (s3 !== peg$FAILED) {
6146
6302
  peg$savedPos = s0;
6147
- s0 = peg$f95(s2);
6303
+ s0 = peg$f96(s2);
6148
6304
  } else {
6149
6305
  peg$currPos = s0;
6150
6306
  s0 = peg$FAILED;
@@ -6174,7 +6330,7 @@ function peg$parse(input, options) {
6174
6330
  s2 = peg$parseIdentifier();
6175
6331
  if (s2 !== peg$FAILED) {
6176
6332
  peg$savedPos = s0;
6177
- s0 = peg$f96(s2);
6333
+ s0 = peg$f97(s2);
6178
6334
  } else {
6179
6335
  peg$currPos = s0;
6180
6336
  s0 = peg$FAILED;
@@ -6198,503 +6354,514 @@ function peg$parse(input, options) {
6198
6354
  }
6199
6355
  }
6200
6356
  if (s1 === peg$FAILED) {
6201
- if (input.substr(peg$currPos, 6) === peg$c20) {
6202
- s1 = peg$c20;
6357
+ if (input.substr(peg$currPos, 6) === peg$c21) {
6358
+ s1 = peg$c21;
6203
6359
  peg$currPos += 6;
6204
6360
  } else {
6205
6361
  s1 = peg$FAILED;
6206
6362
  if (peg$silentFails === 0) {
6207
- peg$fail(peg$e23);
6363
+ peg$fail(peg$e24);
6208
6364
  }
6209
6365
  }
6210
6366
  if (s1 === peg$FAILED) {
6211
- if (input.substr(peg$currPos, 4) === peg$c21) {
6212
- s1 = peg$c21;
6367
+ if (input.substr(peg$currPos, 4) === peg$c22) {
6368
+ s1 = peg$c22;
6213
6369
  peg$currPos += 4;
6214
6370
  } else {
6215
6371
  s1 = peg$FAILED;
6216
6372
  if (peg$silentFails === 0) {
6217
- peg$fail(peg$e24);
6373
+ peg$fail(peg$e25);
6218
6374
  }
6219
6375
  }
6220
6376
  if (s1 === peg$FAILED) {
6221
- if (input.substr(peg$currPos, 6) === peg$c22) {
6222
- s1 = peg$c22;
6377
+ if (input.substr(peg$currPos, 6) === peg$c23) {
6378
+ s1 = peg$c23;
6223
6379
  peg$currPos += 6;
6224
6380
  } else {
6225
6381
  s1 = peg$FAILED;
6226
6382
  if (peg$silentFails === 0) {
6227
- peg$fail(peg$e25);
6383
+ peg$fail(peg$e26);
6228
6384
  }
6229
6385
  }
6230
6386
  if (s1 === peg$FAILED) {
6231
- if (input.substr(peg$currPos, 7) === peg$c23) {
6232
- s1 = peg$c23;
6387
+ if (input.substr(peg$currPos, 7) === peg$c24) {
6388
+ s1 = peg$c24;
6233
6389
  peg$currPos += 7;
6234
6390
  } else {
6235
6391
  s1 = peg$FAILED;
6236
6392
  if (peg$silentFails === 0) {
6237
- peg$fail(peg$e26);
6393
+ peg$fail(peg$e27);
6238
6394
  }
6239
6395
  }
6240
6396
  if (s1 === peg$FAILED) {
6241
- if (input.substr(peg$currPos, 3) === peg$c24) {
6242
- s1 = peg$c24;
6397
+ if (input.substr(peg$currPos, 3) === peg$c25) {
6398
+ s1 = peg$c25;
6243
6399
  peg$currPos += 3;
6244
6400
  } else {
6245
6401
  s1 = peg$FAILED;
6246
6402
  if (peg$silentFails === 0) {
6247
- peg$fail(peg$e27);
6403
+ peg$fail(peg$e28);
6248
6404
  }
6249
6405
  }
6250
6406
  if (s1 === peg$FAILED) {
6251
- if (input.substr(peg$currPos, 3) === peg$c25) {
6252
- s1 = peg$c25;
6407
+ if (input.substr(peg$currPos, 3) === peg$c26) {
6408
+ s1 = peg$c26;
6253
6409
  peg$currPos += 3;
6254
6410
  } else {
6255
6411
  s1 = peg$FAILED;
6256
6412
  if (peg$silentFails === 0) {
6257
- peg$fail(peg$e28);
6413
+ peg$fail(peg$e29);
6258
6414
  }
6259
6415
  }
6260
6416
  if (s1 === peg$FAILED) {
6261
- if (input.substr(peg$currPos, 5) === peg$c26) {
6262
- s1 = peg$c26;
6417
+ if (input.substr(peg$currPos, 5) === peg$c27) {
6418
+ s1 = peg$c27;
6263
6419
  peg$currPos += 5;
6264
6420
  } else {
6265
6421
  s1 = peg$FAILED;
6266
6422
  if (peg$silentFails === 0) {
6267
- peg$fail(peg$e29);
6423
+ peg$fail(peg$e30);
6268
6424
  }
6269
6425
  }
6270
6426
  if (s1 === peg$FAILED) {
6271
- if (input.substr(peg$currPos, 8) === peg$c27) {
6272
- s1 = peg$c27;
6427
+ if (input.substr(peg$currPos, 8) === peg$c28) {
6428
+ s1 = peg$c28;
6273
6429
  peg$currPos += 8;
6274
6430
  } else {
6275
6431
  s1 = peg$FAILED;
6276
6432
  if (peg$silentFails === 0) {
6277
- peg$fail(peg$e30);
6433
+ peg$fail(peg$e31);
6278
6434
  }
6279
6435
  }
6280
6436
  if (s1 === peg$FAILED) {
6281
- if (input.substr(peg$currPos, 4) === peg$c28) {
6282
- s1 = peg$c28;
6437
+ if (input.substr(peg$currPos, 4) === peg$c29) {
6438
+ s1 = peg$c29;
6283
6439
  peg$currPos += 4;
6284
6440
  } else {
6285
6441
  s1 = peg$FAILED;
6286
6442
  if (peg$silentFails === 0) {
6287
- peg$fail(peg$e31);
6443
+ peg$fail(peg$e32);
6288
6444
  }
6289
6445
  }
6290
6446
  if (s1 === peg$FAILED) {
6291
- if (input.substr(peg$currPos, 5) === peg$c29) {
6292
- s1 = peg$c29;
6447
+ if (input.substr(peg$currPos, 5) === peg$c30) {
6448
+ s1 = peg$c30;
6293
6449
  peg$currPos += 5;
6294
6450
  } else {
6295
6451
  s1 = peg$FAILED;
6296
6452
  if (peg$silentFails === 0) {
6297
- peg$fail(peg$e32);
6453
+ peg$fail(peg$e33);
6298
6454
  }
6299
6455
  }
6300
6456
  if (s1 === peg$FAILED) {
6301
- if (input.substr(peg$currPos, 6) === peg$c30) {
6302
- s1 = peg$c30;
6457
+ if (input.substr(peg$currPos, 6) === peg$c31) {
6458
+ s1 = peg$c31;
6303
6459
  peg$currPos += 6;
6304
6460
  } else {
6305
6461
  s1 = peg$FAILED;
6306
6462
  if (peg$silentFails === 0) {
6307
- peg$fail(peg$e33);
6463
+ peg$fail(peg$e34);
6308
6464
  }
6309
6465
  }
6310
6466
  if (s1 === peg$FAILED) {
6311
- if (input.substr(peg$currPos, 9) === peg$c31) {
6312
- s1 = peg$c31;
6467
+ if (input.substr(peg$currPos, 9) === peg$c32) {
6468
+ s1 = peg$c32;
6313
6469
  peg$currPos += 9;
6314
6470
  } else {
6315
6471
  s1 = peg$FAILED;
6316
6472
  if (peg$silentFails === 0) {
6317
- peg$fail(peg$e34);
6473
+ peg$fail(peg$e35);
6318
6474
  }
6319
6475
  }
6320
6476
  if (s1 === peg$FAILED) {
6321
- if (input.substr(peg$currPos, 7) === peg$c32) {
6322
- s1 = peg$c32;
6477
+ if (input.substr(peg$currPos, 7) === peg$c33) {
6478
+ s1 = peg$c33;
6323
6479
  peg$currPos += 7;
6324
6480
  } else {
6325
6481
  s1 = peg$FAILED;
6326
6482
  if (peg$silentFails === 0) {
6327
- peg$fail(peg$e35);
6483
+ peg$fail(peg$e36);
6328
6484
  }
6329
6485
  }
6330
6486
  if (s1 === peg$FAILED) {
6331
- if (input.substr(peg$currPos, 4) === peg$c33) {
6332
- s1 = peg$c33;
6487
+ if (input.substr(peg$currPos, 4) === peg$c34) {
6488
+ s1 = peg$c34;
6333
6489
  peg$currPos += 4;
6334
6490
  } else {
6335
6491
  s1 = peg$FAILED;
6336
6492
  if (peg$silentFails === 0) {
6337
- peg$fail(peg$e36);
6493
+ peg$fail(peg$e37);
6338
6494
  }
6339
6495
  }
6340
6496
  if (s1 === peg$FAILED) {
6341
- if (input.substr(peg$currPos, 4) === peg$c35) {
6342
- s1 = peg$c35;
6497
+ if (input.substr(peg$currPos, 4) === peg$c36) {
6498
+ s1 = peg$c36;
6343
6499
  peg$currPos += 4;
6344
6500
  } else {
6345
6501
  s1 = peg$FAILED;
6346
6502
  if (peg$silentFails === 0) {
6347
- peg$fail(peg$e38);
6503
+ peg$fail(peg$e39);
6348
6504
  }
6349
6505
  }
6350
6506
  if (s1 === peg$FAILED) {
6351
- if (input.substr(peg$currPos, 6) === peg$c36) {
6352
- s1 = peg$c36;
6507
+ if (input.substr(peg$currPos, 6) === peg$c37) {
6508
+ s1 = peg$c37;
6353
6509
  peg$currPos += 6;
6354
6510
  } else {
6355
6511
  s1 = peg$FAILED;
6356
6512
  if (peg$silentFails === 0) {
6357
- peg$fail(peg$e39);
6513
+ peg$fail(peg$e40);
6358
6514
  }
6359
6515
  }
6360
6516
  if (s1 === peg$FAILED) {
6361
- if (input.substr(peg$currPos, 5) === peg$c37) {
6362
- s1 = peg$c37;
6517
+ if (input.substr(peg$currPos, 5) === peg$c38) {
6518
+ s1 = peg$c38;
6363
6519
  peg$currPos += 5;
6364
6520
  } else {
6365
6521
  s1 = peg$FAILED;
6366
6522
  if (peg$silentFails === 0) {
6367
- peg$fail(peg$e40);
6523
+ peg$fail(peg$e41);
6368
6524
  }
6369
6525
  }
6370
6526
  if (s1 === peg$FAILED) {
6371
- if (input.substr(peg$currPos, 8) === peg$c38) {
6372
- s1 = peg$c38;
6527
+ if (input.substr(peg$currPos, 8) === peg$c39) {
6528
+ s1 = peg$c39;
6373
6529
  peg$currPos += 8;
6374
6530
  } else {
6375
6531
  s1 = peg$FAILED;
6376
6532
  if (peg$silentFails === 0) {
6377
- peg$fail(peg$e41);
6533
+ peg$fail(peg$e42);
6378
6534
  }
6379
6535
  }
6380
6536
  if (s1 === peg$FAILED) {
6381
- if (input.substr(peg$currPos, 6) === peg$c39) {
6382
- s1 = peg$c39;
6537
+ if (input.substr(peg$currPos, 6) === peg$c40) {
6538
+ s1 = peg$c40;
6383
6539
  peg$currPos += 6;
6384
6540
  } else {
6385
6541
  s1 = peg$FAILED;
6386
6542
  if (peg$silentFails === 0) {
6387
- peg$fail(peg$e42);
6543
+ peg$fail(peg$e43);
6388
6544
  }
6389
6545
  }
6390
6546
  if (s1 === peg$FAILED) {
6391
- if (input.substr(peg$currPos, 8) === peg$c40) {
6392
- s1 = peg$c40;
6547
+ if (input.substr(peg$currPos, 8) === peg$c41) {
6548
+ s1 = peg$c41;
6393
6549
  peg$currPos += 8;
6394
6550
  } else {
6395
6551
  s1 = peg$FAILED;
6396
6552
  if (peg$silentFails === 0) {
6397
- peg$fail(peg$e43);
6553
+ peg$fail(peg$e44);
6398
6554
  }
6399
6555
  }
6400
6556
  if (s1 === peg$FAILED) {
6401
- if (input.substr(peg$currPos, 5) === peg$c41) {
6402
- s1 = peg$c41;
6557
+ if (input.substr(peg$currPos, 5) === peg$c42) {
6558
+ s1 = peg$c42;
6403
6559
  peg$currPos += 5;
6404
6560
  } else {
6405
6561
  s1 = peg$FAILED;
6406
6562
  if (peg$silentFails === 0) {
6407
- peg$fail(peg$e44);
6563
+ peg$fail(peg$e45);
6408
6564
  }
6409
6565
  }
6410
6566
  if (s1 === peg$FAILED) {
6411
- if (input.substr(peg$currPos, 6) === peg$c42) {
6412
- s1 = peg$c42;
6567
+ if (input.substr(peg$currPos, 6) === peg$c43) {
6568
+ s1 = peg$c43;
6413
6569
  peg$currPos += 6;
6414
6570
  } else {
6415
6571
  s1 = peg$FAILED;
6416
6572
  if (peg$silentFails === 0) {
6417
- peg$fail(peg$e45);
6573
+ peg$fail(peg$e46);
6418
6574
  }
6419
6575
  }
6420
6576
  if (s1 === peg$FAILED) {
6421
- if (input.substr(peg$currPos, 6) === peg$c43) {
6422
- s1 = peg$c43;
6577
+ if (input.substr(peg$currPos, 6) === peg$c44) {
6578
+ s1 = peg$c44;
6423
6579
  peg$currPos += 6;
6424
6580
  } else {
6425
6581
  s1 = peg$FAILED;
6426
6582
  if (peg$silentFails === 0) {
6427
- peg$fail(peg$e46);
6583
+ peg$fail(peg$e47);
6428
6584
  }
6429
6585
  }
6430
6586
  if (s1 === peg$FAILED) {
6431
- if (input.substr(peg$currPos, 5) === peg$c44) {
6432
- s1 = peg$c44;
6587
+ if (input.substr(peg$currPos, 5) === peg$c45) {
6588
+ s1 = peg$c45;
6433
6589
  peg$currPos += 5;
6434
6590
  } else {
6435
6591
  s1 = peg$FAILED;
6436
6592
  if (peg$silentFails === 0) {
6437
- peg$fail(peg$e47);
6593
+ peg$fail(peg$e48);
6438
6594
  }
6439
6595
  }
6440
6596
  if (s1 === peg$FAILED) {
6441
- if (input.substr(peg$currPos, 6) === peg$c46) {
6442
- s1 = peg$c46;
6597
+ if (input.substr(peg$currPos, 6) === peg$c47) {
6598
+ s1 = peg$c47;
6443
6599
  peg$currPos += 6;
6444
6600
  } else {
6445
6601
  s1 = peg$FAILED;
6446
6602
  if (peg$silentFails === 0) {
6447
- peg$fail(peg$e49);
6603
+ peg$fail(peg$e50);
6448
6604
  }
6449
6605
  }
6450
6606
  if (s1 === peg$FAILED) {
6451
- if (input.substr(peg$currPos, 5) === peg$c47) {
6452
- s1 = peg$c47;
6607
+ if (input.substr(peg$currPos, 5) === peg$c48) {
6608
+ s1 = peg$c48;
6453
6609
  peg$currPos += 5;
6454
6610
  } else {
6455
6611
  s1 = peg$FAILED;
6456
6612
  if (peg$silentFails === 0) {
6457
- peg$fail(peg$e50);
6613
+ peg$fail(peg$e51);
6458
6614
  }
6459
6615
  }
6460
6616
  if (s1 === peg$FAILED) {
6461
- if (input.substr(peg$currPos, 5) === peg$c49) {
6462
- s1 = peg$c49;
6617
+ if (input.substr(peg$currPos, 5) === peg$c50) {
6618
+ s1 = peg$c50;
6463
6619
  peg$currPos += 5;
6464
6620
  } else {
6465
6621
  s1 = peg$FAILED;
6466
6622
  if (peg$silentFails === 0) {
6467
- peg$fail(peg$e52);
6623
+ peg$fail(peg$e53);
6468
6624
  }
6469
6625
  }
6470
6626
  if (s1 === peg$FAILED) {
6471
- if (input.substr(peg$currPos, 7) === peg$c52) {
6472
- s1 = peg$c52;
6627
+ if (input.substr(peg$currPos, 7) === peg$c53) {
6628
+ s1 = peg$c53;
6473
6629
  peg$currPos += 7;
6474
6630
  } else {
6475
6631
  s1 = peg$FAILED;
6476
6632
  if (peg$silentFails === 0) {
6477
- peg$fail(peg$e55);
6633
+ peg$fail(peg$e56);
6478
6634
  }
6479
6635
  }
6480
6636
  if (s1 === peg$FAILED) {
6481
- if (input.substr(peg$currPos, 4) === peg$c53) {
6482
- s1 = peg$c53;
6637
+ if (input.substr(peg$currPos, 4) === peg$c54) {
6638
+ s1 = peg$c54;
6483
6639
  peg$currPos += 4;
6484
6640
  } else {
6485
6641
  s1 = peg$FAILED;
6486
6642
  if (peg$silentFails === 0) {
6487
- peg$fail(peg$e56);
6643
+ peg$fail(peg$e57);
6488
6644
  }
6489
6645
  }
6490
6646
  if (s1 === peg$FAILED) {
6491
- if (input.substr(peg$currPos, 4) === peg$c54) {
6492
- s1 = peg$c54;
6647
+ if (input.substr(peg$currPos, 4) === peg$c55) {
6648
+ s1 = peg$c55;
6493
6649
  peg$currPos += 4;
6494
6650
  } else {
6495
6651
  s1 = peg$FAILED;
6496
6652
  if (peg$silentFails === 0) {
6497
- peg$fail(peg$e57);
6653
+ peg$fail(peg$e58);
6498
6654
  }
6499
6655
  }
6500
6656
  if (s1 === peg$FAILED) {
6501
- if (input.substr(peg$currPos, 5) === peg$c55) {
6502
- s1 = peg$c55;
6657
+ if (input.substr(peg$currPos, 5) === peg$c56) {
6658
+ s1 = peg$c56;
6503
6659
  peg$currPos += 5;
6504
6660
  } else {
6505
6661
  s1 = peg$FAILED;
6506
6662
  if (peg$silentFails === 0) {
6507
- peg$fail(peg$e58);
6663
+ peg$fail(peg$e59);
6508
6664
  }
6509
6665
  }
6510
6666
  if (s1 === peg$FAILED) {
6511
- if (input.substr(peg$currPos, 5) === peg$c56) {
6512
- s1 = peg$c56;
6667
+ if (input.substr(peg$currPos, 5) === peg$c57) {
6668
+ s1 = peg$c57;
6513
6669
  peg$currPos += 5;
6514
6670
  } else {
6515
6671
  s1 = peg$FAILED;
6516
6672
  if (peg$silentFails === 0) {
6517
- peg$fail(peg$e59);
6673
+ peg$fail(peg$e60);
6518
6674
  }
6519
6675
  }
6520
6676
  if (s1 === peg$FAILED) {
6521
- if (input.substr(peg$currPos, 8) === peg$c57) {
6522
- s1 = peg$c57;
6677
+ if (input.substr(peg$currPos, 8) === peg$c58) {
6678
+ s1 = peg$c58;
6523
6679
  peg$currPos += 8;
6524
6680
  } else {
6525
6681
  s1 = peg$FAILED;
6526
6682
  if (peg$silentFails === 0) {
6527
- peg$fail(peg$e60);
6683
+ peg$fail(peg$e61);
6528
6684
  }
6529
6685
  }
6530
6686
  if (s1 === peg$FAILED) {
6531
- if (input.substr(peg$currPos, 7) === peg$c58) {
6532
- s1 = peg$c58;
6687
+ if (input.substr(peg$currPos, 7) === peg$c59) {
6688
+ s1 = peg$c59;
6533
6689
  peg$currPos += 7;
6534
6690
  } else {
6535
6691
  s1 = peg$FAILED;
6536
6692
  if (peg$silentFails === 0) {
6537
- peg$fail(peg$e61);
6693
+ peg$fail(peg$e62);
6538
6694
  }
6539
6695
  }
6540
6696
  if (s1 === peg$FAILED) {
6541
- if (input.substr(peg$currPos, 7) === peg$c59) {
6542
- s1 = peg$c59;
6697
+ if (input.substr(peg$currPos, 7) === peg$c60) {
6698
+ s1 = peg$c60;
6543
6699
  peg$currPos += 7;
6544
6700
  } else {
6545
6701
  s1 = peg$FAILED;
6546
6702
  if (peg$silentFails === 0) {
6547
- peg$fail(peg$e62);
6703
+ peg$fail(peg$e63);
6548
6704
  }
6549
6705
  }
6550
6706
  if (s1 === peg$FAILED) {
6551
- if (input.substr(peg$currPos, 7) === peg$c60) {
6552
- s1 = peg$c60;
6707
+ if (input.substr(peg$currPos, 7) === peg$c61) {
6708
+ s1 = peg$c61;
6553
6709
  peg$currPos += 7;
6554
6710
  } else {
6555
6711
  s1 = peg$FAILED;
6556
6712
  if (peg$silentFails === 0) {
6557
- peg$fail(peg$e63);
6713
+ peg$fail(peg$e64);
6558
6714
  }
6559
6715
  }
6560
6716
  if (s1 === peg$FAILED) {
6561
- if (input.substr(peg$currPos, 8) === peg$c61) {
6562
- s1 = peg$c61;
6717
+ if (input.substr(peg$currPos, 8) === peg$c62) {
6718
+ s1 = peg$c62;
6563
6719
  peg$currPos += 8;
6564
6720
  } else {
6565
6721
  s1 = peg$FAILED;
6566
6722
  if (peg$silentFails === 0) {
6567
- peg$fail(peg$e64);
6723
+ peg$fail(peg$e65);
6568
6724
  }
6569
6725
  }
6570
6726
  if (s1 === peg$FAILED) {
6571
- if (input.substr(peg$currPos, 7) === peg$c62) {
6572
- s1 = peg$c62;
6727
+ if (input.substr(peg$currPos, 7) === peg$c63) {
6728
+ s1 = peg$c63;
6573
6729
  peg$currPos += 7;
6574
6730
  } else {
6575
6731
  s1 = peg$FAILED;
6576
6732
  if (peg$silentFails === 0) {
6577
- peg$fail(peg$e65);
6733
+ peg$fail(peg$e66);
6578
6734
  }
6579
6735
  }
6580
6736
  if (s1 === peg$FAILED) {
6581
- if (input.substr(peg$currPos, 3) === peg$c63) {
6582
- s1 = peg$c63;
6737
+ if (input.substr(peg$currPos, 3) === peg$c64) {
6738
+ s1 = peg$c64;
6583
6739
  peg$currPos += 3;
6584
6740
  } else {
6585
6741
  s1 = peg$FAILED;
6586
6742
  if (peg$silentFails === 0) {
6587
- peg$fail(peg$e66);
6743
+ peg$fail(peg$e67);
6588
6744
  }
6589
6745
  }
6590
6746
  if (s1 === peg$FAILED) {
6591
- if (input.substr(peg$currPos, 4) === peg$c65) {
6592
- s1 = peg$c65;
6747
+ if (input.substr(peg$currPos, 4) === peg$c66) {
6748
+ s1 = peg$c66;
6593
6749
  peg$currPos += 4;
6594
6750
  } else {
6595
6751
  s1 = peg$FAILED;
6596
6752
  if (peg$silentFails === 0) {
6597
- peg$fail(peg$e68);
6753
+ peg$fail(peg$e69);
6598
6754
  }
6599
6755
  }
6600
6756
  if (s1 === peg$FAILED) {
6601
- if (input.substr(peg$currPos, 3) === peg$c66) {
6602
- s1 = peg$c66;
6757
+ if (input.substr(peg$currPos, 3) === peg$c67) {
6758
+ s1 = peg$c67;
6603
6759
  peg$currPos += 3;
6604
6760
  } else {
6605
6761
  s1 = peg$FAILED;
6606
6762
  if (peg$silentFails === 0) {
6607
- peg$fail(peg$e69);
6763
+ peg$fail(peg$e70);
6608
6764
  }
6609
6765
  }
6610
6766
  if (s1 === peg$FAILED) {
6611
- if (input.substr(peg$currPos, 10) === peg$c67) {
6612
- s1 = peg$c67;
6767
+ if (input.substr(peg$currPos, 10) === peg$c68) {
6768
+ s1 = peg$c68;
6613
6769
  peg$currPos += 10;
6614
6770
  } else {
6615
6771
  s1 = peg$FAILED;
6616
6772
  if (peg$silentFails === 0) {
6617
- peg$fail(peg$e70);
6773
+ peg$fail(peg$e71);
6618
6774
  }
6619
6775
  }
6620
6776
  if (s1 === peg$FAILED) {
6621
- if (input.substr(peg$currPos, 5) === peg$c64) {
6622
- s1 = peg$c64;
6777
+ if (input.substr(peg$currPos, 5) === peg$c65) {
6778
+ s1 = peg$c65;
6623
6779
  peg$currPos += 5;
6624
6780
  } else {
6625
6781
  s1 = peg$FAILED;
6626
6782
  if (peg$silentFails === 0) {
6627
- peg$fail(peg$e67);
6783
+ peg$fail(peg$e68);
6628
6784
  }
6629
6785
  }
6630
6786
  if (s1 === peg$FAILED) {
6631
- if (input.substr(peg$currPos, 6) === peg$c68) {
6632
- s1 = peg$c68;
6787
+ if (input.substr(peg$currPos, 6) === peg$c69) {
6788
+ s1 = peg$c69;
6633
6789
  peg$currPos += 6;
6634
6790
  } else {
6635
6791
  s1 = peg$FAILED;
6636
6792
  if (peg$silentFails === 0) {
6637
- peg$fail(peg$e71);
6793
+ peg$fail(peg$e72);
6638
6794
  }
6639
6795
  }
6640
6796
  if (s1 === peg$FAILED) {
6641
- if (input.substr(peg$currPos, 11) === peg$c69) {
6642
- s1 = peg$c69;
6797
+ if (input.substr(peg$currPos, 11) === peg$c70) {
6798
+ s1 = peg$c70;
6643
6799
  peg$currPos += 11;
6644
6800
  } else {
6645
6801
  s1 = peg$FAILED;
6646
6802
  if (peg$silentFails === 0) {
6647
- peg$fail(peg$e72);
6803
+ peg$fail(peg$e73);
6648
6804
  }
6649
6805
  }
6650
6806
  if (s1 === peg$FAILED) {
6651
- if (input.substr(peg$currPos, 6) === peg$c3) {
6652
- s1 = peg$c3;
6807
+ if (input.substr(peg$currPos, 6) === peg$c20) {
6808
+ s1 = peg$c20;
6653
6809
  peg$currPos += 6;
6654
6810
  } else {
6655
6811
  s1 = peg$FAILED;
6656
6812
  if (peg$silentFails === 0) {
6657
- peg$fail(peg$e3);
6813
+ peg$fail(peg$e23);
6658
6814
  }
6659
6815
  }
6660
6816
  if (s1 === peg$FAILED) {
6661
- if (input.substr(peg$currPos, 9) === peg$c4) {
6662
- s1 = peg$c4;
6663
- peg$currPos += 9;
6817
+ if (input.substr(peg$currPos, 6) === peg$c3) {
6818
+ s1 = peg$c3;
6819
+ peg$currPos += 6;
6664
6820
  } else {
6665
6821
  s1 = peg$FAILED;
6666
6822
  if (peg$silentFails === 0) {
6667
- peg$fail(peg$e4);
6823
+ peg$fail(peg$e3);
6668
6824
  }
6669
6825
  }
6670
6826
  if (s1 === peg$FAILED) {
6671
- if (input.substr(peg$currPos, 3) === peg$c12) {
6672
- s1 = peg$c12;
6673
- peg$currPos += 3;
6827
+ if (input.substr(peg$currPos, 9) === peg$c4) {
6828
+ s1 = peg$c4;
6829
+ peg$currPos += 9;
6674
6830
  } else {
6675
6831
  s1 = peg$FAILED;
6676
6832
  if (peg$silentFails === 0) {
6677
- peg$fail(peg$e12);
6833
+ peg$fail(peg$e4);
6678
6834
  }
6679
6835
  }
6680
6836
  if (s1 === peg$FAILED) {
6681
- if (input.substr(peg$currPos, 4) === peg$c15) {
6682
- s1 = peg$c15;
6683
- peg$currPos += 4;
6837
+ if (input.substr(peg$currPos, 3) === peg$c12) {
6838
+ s1 = peg$c12;
6839
+ peg$currPos += 3;
6684
6840
  } else {
6685
6841
  s1 = peg$FAILED;
6686
6842
  if (peg$silentFails === 0) {
6687
- peg$fail(peg$e15);
6843
+ peg$fail(peg$e12);
6688
6844
  }
6689
6845
  }
6690
6846
  if (s1 === peg$FAILED) {
6691
- if (input.substr(peg$currPos, 4) === peg$c16) {
6692
- s1 = peg$c16;
6847
+ if (input.substr(peg$currPos, 4) === peg$c15) {
6848
+ s1 = peg$c15;
6693
6849
  peg$currPos += 4;
6694
6850
  } else {
6695
6851
  s1 = peg$FAILED;
6696
6852
  if (peg$silentFails === 0) {
6697
- 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
+ }
6698
6865
  }
6699
6866
  }
6700
6867
  }
@@ -6779,7 +6946,7 @@ function peg$parse(input, options) {
6779
6946
  } else {
6780
6947
  s0 = peg$FAILED;
6781
6948
  if (peg$silentFails === 0) {
6782
- peg$fail(peg$e77);
6949
+ peg$fail(peg$e78);
6783
6950
  }
6784
6951
  }
6785
6952
  return s0;
@@ -6812,12 +6979,12 @@ function peg$parse(input, options) {
6812
6979
  peg$silentFails++;
6813
6980
  s0 = peg$currPos;
6814
6981
  if (input.charCodeAt(peg$currPos) === 34) {
6815
- s1 = peg$c71;
6982
+ s1 = peg$c72;
6816
6983
  peg$currPos++;
6817
6984
  } else {
6818
6985
  s1 = peg$FAILED;
6819
6986
  if (peg$silentFails === 0) {
6820
- peg$fail(peg$e79);
6987
+ peg$fail(peg$e80);
6821
6988
  }
6822
6989
  }
6823
6990
  if (s1 !== peg$FAILED) {
@@ -6828,17 +6995,17 @@ function peg$parse(input, options) {
6828
6995
  s3 = peg$parseDoubleStringChar();
6829
6996
  }
6830
6997
  if (input.charCodeAt(peg$currPos) === 34) {
6831
- s3 = peg$c71;
6998
+ s3 = peg$c72;
6832
6999
  peg$currPos++;
6833
7000
  } else {
6834
7001
  s3 = peg$FAILED;
6835
7002
  if (peg$silentFails === 0) {
6836
- peg$fail(peg$e79);
7003
+ peg$fail(peg$e80);
6837
7004
  }
6838
7005
  }
6839
7006
  if (s3 !== peg$FAILED) {
6840
7007
  peg$savedPos = s0;
6841
- s0 = peg$f97(s2);
7008
+ s0 = peg$f98(s2);
6842
7009
  } else {
6843
7010
  peg$currPos = s0;
6844
7011
  s0 = peg$FAILED;
@@ -6850,12 +7017,12 @@ function peg$parse(input, options) {
6850
7017
  if (s0 === peg$FAILED) {
6851
7018
  s0 = peg$currPos;
6852
7019
  if (input.charCodeAt(peg$currPos) === 39) {
6853
- s1 = peg$c72;
7020
+ s1 = peg$c73;
6854
7021
  peg$currPos++;
6855
7022
  } else {
6856
7023
  s1 = peg$FAILED;
6857
7024
  if (peg$silentFails === 0) {
6858
- peg$fail(peg$e80);
7025
+ peg$fail(peg$e81);
6859
7026
  }
6860
7027
  }
6861
7028
  if (s1 !== peg$FAILED) {
@@ -6866,17 +7033,17 @@ function peg$parse(input, options) {
6866
7033
  s3 = peg$parseSingleStringChar();
6867
7034
  }
6868
7035
  if (input.charCodeAt(peg$currPos) === 39) {
6869
- s3 = peg$c72;
7036
+ s3 = peg$c73;
6870
7037
  peg$currPos++;
6871
7038
  } else {
6872
7039
  s3 = peg$FAILED;
6873
7040
  if (peg$silentFails === 0) {
6874
- peg$fail(peg$e80);
7041
+ peg$fail(peg$e81);
6875
7042
  }
6876
7043
  }
6877
7044
  if (s3 !== peg$FAILED) {
6878
7045
  peg$savedPos = s0;
6879
- s0 = peg$f98(s2);
7046
+ s0 = peg$f99(s2);
6880
7047
  } else {
6881
7048
  peg$currPos = s0;
6882
7049
  s0 = peg$FAILED;
@@ -6890,7 +7057,7 @@ function peg$parse(input, options) {
6890
7057
  if (s0 === peg$FAILED) {
6891
7058
  s1 = peg$FAILED;
6892
7059
  if (peg$silentFails === 0) {
6893
- peg$fail(peg$e78);
7060
+ peg$fail(peg$e79);
6894
7061
  }
6895
7062
  }
6896
7063
  return s0;
@@ -6901,12 +7068,12 @@ function peg$parse(input, options) {
6901
7068
  s1 = peg$currPos;
6902
7069
  peg$silentFails++;
6903
7070
  if (input.charCodeAt(peg$currPos) === 34) {
6904
- s2 = peg$c71;
7071
+ s2 = peg$c72;
6905
7072
  peg$currPos++;
6906
7073
  } else {
6907
7074
  s2 = peg$FAILED;
6908
7075
  if (peg$silentFails === 0) {
6909
- peg$fail(peg$e79);
7076
+ peg$fail(peg$e80);
6910
7077
  }
6911
7078
  }
6912
7079
  peg$silentFails--;
@@ -6920,12 +7087,12 @@ function peg$parse(input, options) {
6920
7087
  s2 = peg$currPos;
6921
7088
  peg$silentFails++;
6922
7089
  if (input.charCodeAt(peg$currPos) === 92) {
6923
- s3 = peg$c73;
7090
+ s3 = peg$c74;
6924
7091
  peg$currPos++;
6925
7092
  } else {
6926
7093
  s3 = peg$FAILED;
6927
7094
  if (peg$silentFails === 0) {
6928
- peg$fail(peg$e81);
7095
+ peg$fail(peg$e82);
6929
7096
  }
6930
7097
  }
6931
7098
  peg$silentFails--;
@@ -6947,7 +7114,7 @@ function peg$parse(input, options) {
6947
7114
  }
6948
7115
  if (s3 !== peg$FAILED) {
6949
7116
  peg$savedPos = s0;
6950
- s0 = peg$f99(s3);
7117
+ s0 = peg$f100(s3);
6951
7118
  } else {
6952
7119
  peg$currPos = s0;
6953
7120
  s0 = peg$FAILED;
@@ -6963,19 +7130,19 @@ function peg$parse(input, options) {
6963
7130
  if (s0 === peg$FAILED) {
6964
7131
  s0 = peg$currPos;
6965
7132
  if (input.charCodeAt(peg$currPos) === 92) {
6966
- s1 = peg$c73;
7133
+ s1 = peg$c74;
6967
7134
  peg$currPos++;
6968
7135
  } else {
6969
7136
  s1 = peg$FAILED;
6970
7137
  if (peg$silentFails === 0) {
6971
- peg$fail(peg$e81);
7138
+ peg$fail(peg$e82);
6972
7139
  }
6973
7140
  }
6974
7141
  if (s1 !== peg$FAILED) {
6975
7142
  s2 = peg$parseEscapeSequence();
6976
7143
  if (s2 !== peg$FAILED) {
6977
7144
  peg$savedPos = s0;
6978
- s0 = peg$f100(s2);
7145
+ s0 = peg$f101(s2);
6979
7146
  } else {
6980
7147
  peg$currPos = s0;
6981
7148
  s0 = peg$FAILED;
@@ -6993,12 +7160,12 @@ function peg$parse(input, options) {
6993
7160
  s1 = peg$currPos;
6994
7161
  peg$silentFails++;
6995
7162
  if (input.charCodeAt(peg$currPos) === 39) {
6996
- s2 = peg$c72;
7163
+ s2 = peg$c73;
6997
7164
  peg$currPos++;
6998
7165
  } else {
6999
7166
  s2 = peg$FAILED;
7000
7167
  if (peg$silentFails === 0) {
7001
- peg$fail(peg$e80);
7168
+ peg$fail(peg$e81);
7002
7169
  }
7003
7170
  }
7004
7171
  peg$silentFails--;
@@ -7012,12 +7179,12 @@ function peg$parse(input, options) {
7012
7179
  s2 = peg$currPos;
7013
7180
  peg$silentFails++;
7014
7181
  if (input.charCodeAt(peg$currPos) === 92) {
7015
- s3 = peg$c73;
7182
+ s3 = peg$c74;
7016
7183
  peg$currPos++;
7017
7184
  } else {
7018
7185
  s3 = peg$FAILED;
7019
7186
  if (peg$silentFails === 0) {
7020
- peg$fail(peg$e81);
7187
+ peg$fail(peg$e82);
7021
7188
  }
7022
7189
  }
7023
7190
  peg$silentFails--;
@@ -7039,7 +7206,7 @@ function peg$parse(input, options) {
7039
7206
  }
7040
7207
  if (s3 !== peg$FAILED) {
7041
7208
  peg$savedPos = s0;
7042
- s0 = peg$f101(s3);
7209
+ s0 = peg$f102(s3);
7043
7210
  } else {
7044
7211
  peg$currPos = s0;
7045
7212
  s0 = peg$FAILED;
@@ -7055,19 +7222,19 @@ function peg$parse(input, options) {
7055
7222
  if (s0 === peg$FAILED) {
7056
7223
  s0 = peg$currPos;
7057
7224
  if (input.charCodeAt(peg$currPos) === 92) {
7058
- s1 = peg$c73;
7225
+ s1 = peg$c74;
7059
7226
  peg$currPos++;
7060
7227
  } else {
7061
7228
  s1 = peg$FAILED;
7062
7229
  if (peg$silentFails === 0) {
7063
- peg$fail(peg$e81);
7230
+ peg$fail(peg$e82);
7064
7231
  }
7065
7232
  }
7066
7233
  if (s1 !== peg$FAILED) {
7067
7234
  s2 = peg$parseEscapeSequence();
7068
7235
  if (s2 !== peg$FAILED) {
7069
7236
  peg$savedPos = s0;
7070
- s0 = peg$f102(s2);
7237
+ s0 = peg$f103(s2);
7071
7238
  } else {
7072
7239
  peg$currPos = s0;
7073
7240
  s0 = peg$FAILED;
@@ -7083,97 +7250,97 @@ function peg$parse(input, options) {
7083
7250
  let s0, s1;
7084
7251
  s0 = peg$currPos;
7085
7252
  if (input.charCodeAt(peg$currPos) === 110) {
7086
- s1 = peg$c74;
7253
+ s1 = peg$c75;
7087
7254
  peg$currPos++;
7088
7255
  } else {
7089
7256
  s1 = peg$FAILED;
7090
7257
  if (peg$silentFails === 0) {
7091
- peg$fail(peg$e82);
7258
+ peg$fail(peg$e83);
7092
7259
  }
7093
7260
  }
7094
7261
  if (s1 !== peg$FAILED) {
7095
7262
  peg$savedPos = s0;
7096
- s1 = peg$f103();
7263
+ s1 = peg$f104();
7097
7264
  }
7098
7265
  s0 = s1;
7099
7266
  if (s0 === peg$FAILED) {
7100
7267
  s0 = peg$currPos;
7101
7268
  if (input.charCodeAt(peg$currPos) === 114) {
7102
- s1 = peg$c75;
7269
+ s1 = peg$c76;
7103
7270
  peg$currPos++;
7104
7271
  } else {
7105
7272
  s1 = peg$FAILED;
7106
7273
  if (peg$silentFails === 0) {
7107
- peg$fail(peg$e83);
7274
+ peg$fail(peg$e84);
7108
7275
  }
7109
7276
  }
7110
7277
  if (s1 !== peg$FAILED) {
7111
7278
  peg$savedPos = s0;
7112
- s1 = peg$f104();
7279
+ s1 = peg$f105();
7113
7280
  }
7114
7281
  s0 = s1;
7115
7282
  if (s0 === peg$FAILED) {
7116
7283
  s0 = peg$currPos;
7117
7284
  if (input.charCodeAt(peg$currPos) === 116) {
7118
- s1 = peg$c76;
7285
+ s1 = peg$c77;
7119
7286
  peg$currPos++;
7120
7287
  } else {
7121
7288
  s1 = peg$FAILED;
7122
7289
  if (peg$silentFails === 0) {
7123
- peg$fail(peg$e84);
7290
+ peg$fail(peg$e85);
7124
7291
  }
7125
7292
  }
7126
7293
  if (s1 !== peg$FAILED) {
7127
7294
  peg$savedPos = s0;
7128
- s1 = peg$f105();
7295
+ s1 = peg$f106();
7129
7296
  }
7130
7297
  s0 = s1;
7131
7298
  if (s0 === peg$FAILED) {
7132
7299
  s0 = peg$currPos;
7133
7300
  if (input.charCodeAt(peg$currPos) === 92) {
7134
- s1 = peg$c73;
7301
+ s1 = peg$c74;
7135
7302
  peg$currPos++;
7136
7303
  } else {
7137
7304
  s1 = peg$FAILED;
7138
7305
  if (peg$silentFails === 0) {
7139
- peg$fail(peg$e81);
7306
+ peg$fail(peg$e82);
7140
7307
  }
7141
7308
  }
7142
7309
  if (s1 !== peg$FAILED) {
7143
7310
  peg$savedPos = s0;
7144
- s1 = peg$f106();
7311
+ s1 = peg$f107();
7145
7312
  }
7146
7313
  s0 = s1;
7147
7314
  if (s0 === peg$FAILED) {
7148
7315
  s0 = peg$currPos;
7149
7316
  if (input.charCodeAt(peg$currPos) === 34) {
7150
- s1 = peg$c71;
7317
+ s1 = peg$c72;
7151
7318
  peg$currPos++;
7152
7319
  } else {
7153
7320
  s1 = peg$FAILED;
7154
7321
  if (peg$silentFails === 0) {
7155
- peg$fail(peg$e79);
7322
+ peg$fail(peg$e80);
7156
7323
  }
7157
7324
  }
7158
7325
  if (s1 !== peg$FAILED) {
7159
7326
  peg$savedPos = s0;
7160
- s1 = peg$f107();
7327
+ s1 = peg$f108();
7161
7328
  }
7162
7329
  s0 = s1;
7163
7330
  if (s0 === peg$FAILED) {
7164
7331
  s0 = peg$currPos;
7165
7332
  if (input.charCodeAt(peg$currPos) === 39) {
7166
- s1 = peg$c72;
7333
+ s1 = peg$c73;
7167
7334
  peg$currPos++;
7168
7335
  } else {
7169
7336
  s1 = peg$FAILED;
7170
7337
  if (peg$silentFails === 0) {
7171
- peg$fail(peg$e80);
7338
+ peg$fail(peg$e81);
7172
7339
  }
7173
7340
  }
7174
7341
  if (s1 !== peg$FAILED) {
7175
7342
  peg$savedPos = s0;
7176
- s1 = peg$f108();
7343
+ s1 = peg$f109();
7177
7344
  }
7178
7345
  s0 = s1;
7179
7346
  }
@@ -7188,12 +7355,12 @@ function peg$parse(input, options) {
7188
7355
  peg$silentFails++;
7189
7356
  s0 = peg$currPos;
7190
7357
  if (input.charCodeAt(peg$currPos) === 45) {
7191
- s1 = peg$c77;
7358
+ s1 = peg$c78;
7192
7359
  peg$currPos++;
7193
7360
  } else {
7194
7361
  s1 = peg$FAILED;
7195
7362
  if (peg$silentFails === 0) {
7196
- peg$fail(peg$e86);
7363
+ peg$fail(peg$e87);
7197
7364
  }
7198
7365
  }
7199
7366
  if (s1 === peg$FAILED) {
@@ -7206,7 +7373,7 @@ function peg$parse(input, options) {
7206
7373
  } else {
7207
7374
  s3 = peg$FAILED;
7208
7375
  if (peg$silentFails === 0) {
7209
- peg$fail(peg$e74);
7376
+ peg$fail(peg$e75);
7210
7377
  }
7211
7378
  }
7212
7379
  if (s3 !== peg$FAILED) {
@@ -7218,7 +7385,7 @@ function peg$parse(input, options) {
7218
7385
  } else {
7219
7386
  s3 = peg$FAILED;
7220
7387
  if (peg$silentFails === 0) {
7221
- peg$fail(peg$e74);
7388
+ peg$fail(peg$e75);
7222
7389
  }
7223
7390
  }
7224
7391
  }
@@ -7228,12 +7395,12 @@ function peg$parse(input, options) {
7228
7395
  if (s2 !== peg$FAILED) {
7229
7396
  s3 = peg$currPos;
7230
7397
  if (input.charCodeAt(peg$currPos) === 46) {
7231
- s4 = peg$c78;
7398
+ s4 = peg$c79;
7232
7399
  peg$currPos++;
7233
7400
  } else {
7234
7401
  s4 = peg$FAILED;
7235
7402
  if (peg$silentFails === 0) {
7236
- peg$fail(peg$e87);
7403
+ peg$fail(peg$e88);
7237
7404
  }
7238
7405
  }
7239
7406
  if (s4 !== peg$FAILED) {
@@ -7244,7 +7411,7 @@ function peg$parse(input, options) {
7244
7411
  } else {
7245
7412
  s6 = peg$FAILED;
7246
7413
  if (peg$silentFails === 0) {
7247
- peg$fail(peg$e74);
7414
+ peg$fail(peg$e75);
7248
7415
  }
7249
7416
  }
7250
7417
  if (s6 !== peg$FAILED) {
@@ -7256,7 +7423,7 @@ function peg$parse(input, options) {
7256
7423
  } else {
7257
7424
  s6 = peg$FAILED;
7258
7425
  if (peg$silentFails === 0) {
7259
- peg$fail(peg$e74);
7426
+ peg$fail(peg$e75);
7260
7427
  }
7261
7428
  }
7262
7429
  }
@@ -7278,7 +7445,7 @@ function peg$parse(input, options) {
7278
7445
  s3 = null;
7279
7446
  }
7280
7447
  peg$savedPos = s0;
7281
- s0 = peg$f109(s1, s2, s3);
7448
+ s0 = peg$f110(s1, s2, s3);
7282
7449
  } else {
7283
7450
  peg$currPos = s0;
7284
7451
  s0 = peg$FAILED;
@@ -7287,7 +7454,7 @@ function peg$parse(input, options) {
7287
7454
  if (s0 === peg$FAILED) {
7288
7455
  s1 = peg$FAILED;
7289
7456
  if (peg$silentFails === 0) {
7290
- peg$fail(peg$e85);
7457
+ peg$fail(peg$e86);
7291
7458
  }
7292
7459
  }
7293
7460
  return s0;
@@ -7297,12 +7464,12 @@ function peg$parse(input, options) {
7297
7464
  peg$silentFails++;
7298
7465
  s0 = peg$currPos;
7299
7466
  if (input.charCodeAt(peg$currPos) === 45) {
7300
- s1 = peg$c77;
7467
+ s1 = peg$c78;
7301
7468
  peg$currPos++;
7302
7469
  } else {
7303
7470
  s1 = peg$FAILED;
7304
7471
  if (peg$silentFails === 0) {
7305
- peg$fail(peg$e86);
7472
+ peg$fail(peg$e87);
7306
7473
  }
7307
7474
  }
7308
7475
  if (s1 === peg$FAILED) {
@@ -7315,7 +7482,7 @@ function peg$parse(input, options) {
7315
7482
  } else {
7316
7483
  s3 = peg$FAILED;
7317
7484
  if (peg$silentFails === 0) {
7318
- peg$fail(peg$e74);
7485
+ peg$fail(peg$e75);
7319
7486
  }
7320
7487
  }
7321
7488
  if (s3 !== peg$FAILED) {
@@ -7327,7 +7494,7 @@ function peg$parse(input, options) {
7327
7494
  } else {
7328
7495
  s3 = peg$FAILED;
7329
7496
  if (peg$silentFails === 0) {
7330
- peg$fail(peg$e74);
7497
+ peg$fail(peg$e75);
7331
7498
  }
7332
7499
  }
7333
7500
  }
@@ -7337,12 +7504,12 @@ function peg$parse(input, options) {
7337
7504
  if (s2 !== peg$FAILED) {
7338
7505
  s3 = peg$currPos;
7339
7506
  if (input.charCodeAt(peg$currPos) === 46) {
7340
- s4 = peg$c78;
7507
+ s4 = peg$c79;
7341
7508
  peg$currPos++;
7342
7509
  } else {
7343
7510
  s4 = peg$FAILED;
7344
7511
  if (peg$silentFails === 0) {
7345
- peg$fail(peg$e87);
7512
+ peg$fail(peg$e88);
7346
7513
  }
7347
7514
  }
7348
7515
  if (s4 !== peg$FAILED) {
@@ -7353,7 +7520,7 @@ function peg$parse(input, options) {
7353
7520
  } else {
7354
7521
  s6 = peg$FAILED;
7355
7522
  if (peg$silentFails === 0) {
7356
- peg$fail(peg$e74);
7523
+ peg$fail(peg$e75);
7357
7524
  }
7358
7525
  }
7359
7526
  if (s6 !== peg$FAILED) {
@@ -7365,7 +7532,7 @@ function peg$parse(input, options) {
7365
7532
  } else {
7366
7533
  s6 = peg$FAILED;
7367
7534
  if (peg$silentFails === 0) {
7368
- peg$fail(peg$e74);
7535
+ peg$fail(peg$e75);
7369
7536
  }
7370
7537
  }
7371
7538
  }
@@ -7386,63 +7553,63 @@ function peg$parse(input, options) {
7386
7553
  if (s3 === peg$FAILED) {
7387
7554
  s3 = null;
7388
7555
  }
7389
- if (input.substr(peg$currPos, 2) === peg$c79) {
7390
- s4 = peg$c79;
7556
+ if (input.substr(peg$currPos, 2) === peg$c80) {
7557
+ s4 = peg$c80;
7391
7558
  peg$currPos += 2;
7392
7559
  } else {
7393
7560
  s4 = peg$FAILED;
7394
7561
  if (peg$silentFails === 0) {
7395
- peg$fail(peg$e89);
7562
+ peg$fail(peg$e90);
7396
7563
  }
7397
7564
  }
7398
7565
  if (s4 === peg$FAILED) {
7399
7566
  if (input.charCodeAt(peg$currPos) === 37) {
7400
- s4 = peg$c80;
7567
+ s4 = peg$c81;
7401
7568
  peg$currPos++;
7402
7569
  } else {
7403
7570
  s4 = peg$FAILED;
7404
7571
  if (peg$silentFails === 0) {
7405
- peg$fail(peg$e90);
7572
+ peg$fail(peg$e91);
7406
7573
  }
7407
7574
  }
7408
7575
  if (s4 === peg$FAILED) {
7409
- if (input.substr(peg$currPos, 2) === peg$c81) {
7410
- s4 = peg$c81;
7576
+ if (input.substr(peg$currPos, 2) === peg$c82) {
7577
+ s4 = peg$c82;
7411
7578
  peg$currPos += 2;
7412
7579
  } else {
7413
7580
  s4 = peg$FAILED;
7414
7581
  if (peg$silentFails === 0) {
7415
- peg$fail(peg$e91);
7582
+ peg$fail(peg$e92);
7416
7583
  }
7417
7584
  }
7418
7585
  if (s4 === peg$FAILED) {
7419
- if (input.substr(peg$currPos, 3) === peg$c82) {
7420
- s4 = peg$c82;
7586
+ if (input.substr(peg$currPos, 3) === peg$c83) {
7587
+ s4 = peg$c83;
7421
7588
  peg$currPos += 3;
7422
7589
  } else {
7423
7590
  s4 = peg$FAILED;
7424
7591
  if (peg$silentFails === 0) {
7425
- peg$fail(peg$e92);
7592
+ peg$fail(peg$e93);
7426
7593
  }
7427
7594
  }
7428
7595
  if (s4 === peg$FAILED) {
7429
- if (input.substr(peg$currPos, 2) === peg$c83) {
7430
- s4 = peg$c83;
7596
+ if (input.substr(peg$currPos, 2) === peg$c84) {
7597
+ s4 = peg$c84;
7431
7598
  peg$currPos += 2;
7432
7599
  } else {
7433
7600
  s4 = peg$FAILED;
7434
7601
  if (peg$silentFails === 0) {
7435
- peg$fail(peg$e93);
7602
+ peg$fail(peg$e94);
7436
7603
  }
7437
7604
  }
7438
7605
  if (s4 === peg$FAILED) {
7439
- if (input.substr(peg$currPos, 2) === peg$c84) {
7440
- s4 = peg$c84;
7606
+ if (input.substr(peg$currPos, 2) === peg$c85) {
7607
+ s4 = peg$c85;
7441
7608
  peg$currPos += 2;
7442
7609
  } else {
7443
7610
  s4 = peg$FAILED;
7444
7611
  if (peg$silentFails === 0) {
7445
- peg$fail(peg$e94);
7612
+ peg$fail(peg$e95);
7446
7613
  }
7447
7614
  }
7448
7615
  }
@@ -7452,7 +7619,7 @@ function peg$parse(input, options) {
7452
7619
  }
7453
7620
  if (s4 !== peg$FAILED) {
7454
7621
  peg$savedPos = s0;
7455
- s0 = peg$f110(s1, s2, s3, s4);
7622
+ s0 = peg$f111(s1, s2, s3, s4);
7456
7623
  } else {
7457
7624
  peg$currPos = s0;
7458
7625
  s0 = peg$FAILED;
@@ -7465,7 +7632,7 @@ function peg$parse(input, options) {
7465
7632
  if (s0 === peg$FAILED) {
7466
7633
  s1 = peg$FAILED;
7467
7634
  if (peg$silentFails === 0) {
7468
- peg$fail(peg$e88);
7635
+ peg$fail(peg$e89);
7469
7636
  }
7470
7637
  }
7471
7638
  return s0;
@@ -7474,34 +7641,34 @@ function peg$parse(input, options) {
7474
7641
  let s0, s1;
7475
7642
  peg$silentFails++;
7476
7643
  s0 = peg$currPos;
7477
- if (input.substr(peg$currPos, 4) === peg$c85) {
7478
- s1 = peg$c85;
7644
+ if (input.substr(peg$currPos, 4) === peg$c86) {
7645
+ s1 = peg$c86;
7479
7646
  peg$currPos += 4;
7480
7647
  } else {
7481
7648
  s1 = peg$FAILED;
7482
7649
  if (peg$silentFails === 0) {
7483
- peg$fail(peg$e96);
7650
+ peg$fail(peg$e97);
7484
7651
  }
7485
7652
  }
7486
7653
  if (s1 !== peg$FAILED) {
7487
7654
  peg$savedPos = s0;
7488
- s1 = peg$f111();
7655
+ s1 = peg$f112();
7489
7656
  }
7490
7657
  s0 = s1;
7491
7658
  if (s0 === peg$FAILED) {
7492
7659
  s0 = peg$currPos;
7493
- if (input.substr(peg$currPos, 5) === peg$c86) {
7494
- s1 = peg$c86;
7660
+ if (input.substr(peg$currPos, 5) === peg$c87) {
7661
+ s1 = peg$c87;
7495
7662
  peg$currPos += 5;
7496
7663
  } else {
7497
7664
  s1 = peg$FAILED;
7498
7665
  if (peg$silentFails === 0) {
7499
- peg$fail(peg$e97);
7666
+ peg$fail(peg$e98);
7500
7667
  }
7501
7668
  }
7502
7669
  if (s1 !== peg$FAILED) {
7503
7670
  peg$savedPos = s0;
7504
- s1 = peg$f112();
7671
+ s1 = peg$f113();
7505
7672
  }
7506
7673
  s0 = s1;
7507
7674
  }
@@ -7509,7 +7676,7 @@ function peg$parse(input, options) {
7509
7676
  if (s0 === peg$FAILED) {
7510
7677
  s1 = peg$FAILED;
7511
7678
  if (peg$silentFails === 0) {
7512
- peg$fail(peg$e95);
7679
+ peg$fail(peg$e96);
7513
7680
  }
7514
7681
  }
7515
7682
  return s0;
@@ -7524,7 +7691,7 @@ function peg$parse(input, options) {
7524
7691
  } else {
7525
7692
  s1 = peg$FAILED;
7526
7693
  if (peg$silentFails === 0) {
7527
- peg$fail(peg$e99);
7694
+ peg$fail(peg$e100);
7528
7695
  }
7529
7696
  }
7530
7697
  if (s1 !== peg$FAILED) {
@@ -7535,7 +7702,7 @@ function peg$parse(input, options) {
7535
7702
  } else {
7536
7703
  s3 = peg$FAILED;
7537
7704
  if (peg$silentFails === 0) {
7538
- peg$fail(peg$e77);
7705
+ peg$fail(peg$e78);
7539
7706
  }
7540
7707
  }
7541
7708
  while (s3 !== peg$FAILED) {
@@ -7546,12 +7713,12 @@ function peg$parse(input, options) {
7546
7713
  } else {
7547
7714
  s3 = peg$FAILED;
7548
7715
  if (peg$silentFails === 0) {
7549
- peg$fail(peg$e77);
7716
+ peg$fail(peg$e78);
7550
7717
  }
7551
7718
  }
7552
7719
  }
7553
7720
  peg$savedPos = s0;
7554
- s0 = peg$f113(s1, s2);
7721
+ s0 = peg$f114(s1, s2);
7555
7722
  } else {
7556
7723
  peg$currPos = s0;
7557
7724
  s0 = peg$FAILED;
@@ -7560,7 +7727,7 @@ function peg$parse(input, options) {
7560
7727
  if (s0 === peg$FAILED) {
7561
7728
  s1 = peg$FAILED;
7562
7729
  if (peg$silentFails === 0) {
7563
- peg$fail(peg$e98);
7730
+ peg$fail(peg$e99);
7564
7731
  }
7565
7732
  }
7566
7733
  return s0;
@@ -7569,12 +7736,12 @@ function peg$parse(input, options) {
7569
7736
  let s0, s1, s2, s3, s4, s5;
7570
7737
  s0 = peg$currPos;
7571
7738
  if (input.charCodeAt(peg$currPos) === 91) {
7572
- s1 = peg$c50;
7739
+ s1 = peg$c51;
7573
7740
  peg$currPos++;
7574
7741
  } else {
7575
7742
  s1 = peg$FAILED;
7576
7743
  if (peg$silentFails === 0) {
7577
- peg$fail(peg$e53);
7744
+ peg$fail(peg$e54);
7578
7745
  }
7579
7746
  }
7580
7747
  if (s1 !== peg$FAILED) {
@@ -7585,17 +7752,17 @@ function peg$parse(input, options) {
7585
7752
  }
7586
7753
  s4 = peg$parse_();
7587
7754
  if (input.charCodeAt(peg$currPos) === 93) {
7588
- s5 = peg$c51;
7755
+ s5 = peg$c52;
7589
7756
  peg$currPos++;
7590
7757
  } else {
7591
7758
  s5 = peg$FAILED;
7592
7759
  if (peg$silentFails === 0) {
7593
- peg$fail(peg$e54);
7760
+ peg$fail(peg$e55);
7594
7761
  }
7595
7762
  }
7596
7763
  if (s5 !== peg$FAILED) {
7597
7764
  peg$savedPos = s0;
7598
- s0 = peg$f114(s3);
7765
+ s0 = peg$f115(s3);
7599
7766
  } else {
7600
7767
  peg$currPos = s0;
7601
7768
  s0 = peg$FAILED;
@@ -7683,7 +7850,7 @@ function peg$parse(input, options) {
7683
7850
  s3 = null;
7684
7851
  }
7685
7852
  peg$savedPos = s0;
7686
- s0 = peg$f115(s1, s2);
7853
+ s0 = peg$f116(s1, s2);
7687
7854
  } else {
7688
7855
  peg$currPos = s0;
7689
7856
  s0 = peg$FAILED;
@@ -7737,7 +7904,7 @@ function peg$parse(input, options) {
7737
7904
  }
7738
7905
  if (s5 !== peg$FAILED) {
7739
7906
  peg$savedPos = s0;
7740
- s0 = peg$f116(s3);
7907
+ s0 = peg$f117(s3);
7741
7908
  } else {
7742
7909
  peg$currPos = s0;
7743
7910
  s0 = peg$FAILED;
@@ -7804,7 +7971,7 @@ function peg$parse(input, options) {
7804
7971
  }
7805
7972
  }
7806
7973
  peg$savedPos = s0;
7807
- s0 = peg$f117(s1, s2);
7974
+ s0 = peg$f118(s1, s2);
7808
7975
  } else {
7809
7976
  peg$currPos = s0;
7810
7977
  s0 = peg$FAILED;
@@ -7831,7 +7998,7 @@ function peg$parse(input, options) {
7831
7998
  s5 = peg$parseAttributeValue();
7832
7999
  if (s5 !== peg$FAILED) {
7833
8000
  peg$savedPos = s0;
7834
- s0 = peg$f118(s1, s5);
8001
+ s0 = peg$f119(s1, s5);
7835
8002
  } else {
7836
8003
  peg$currPos = s0;
7837
8004
  s0 = peg$FAILED;
@@ -7849,7 +8016,7 @@ function peg$parse(input, options) {
7849
8016
  s1 = peg$parseIdentifier();
7850
8017
  if (s1 !== peg$FAILED) {
7851
8018
  peg$savedPos = s0;
7852
- s1 = peg$f119(s1);
8019
+ s1 = peg$f120(s1);
7853
8020
  }
7854
8021
  s0 = s1;
7855
8022
  }
@@ -7882,7 +8049,7 @@ function peg$parse(input, options) {
7882
8049
  } else {
7883
8050
  s1 = peg$FAILED;
7884
8051
  if (peg$silentFails === 0) {
7885
- peg$fail(peg$e100);
8052
+ peg$fail(peg$e101);
7886
8053
  }
7887
8054
  }
7888
8055
  if (s1 !== peg$FAILED) {
@@ -7894,7 +8061,7 @@ function peg$parse(input, options) {
7894
8061
  } else {
7895
8062
  s1 = peg$FAILED;
7896
8063
  if (peg$silentFails === 0) {
7897
- peg$fail(peg$e100);
8064
+ peg$fail(peg$e101);
7898
8065
  }
7899
8066
  }
7900
8067
  }
@@ -7914,7 +8081,7 @@ function peg$parse(input, options) {
7914
8081
  if (s0 === peg$FAILED) {
7915
8082
  s1 = peg$FAILED;
7916
8083
  if (peg$silentFails === 0) {
7917
- peg$fail(peg$e101);
8084
+ peg$fail(peg$e102);
7918
8085
  }
7919
8086
  }
7920
8087
  return s0;
@@ -7939,7 +8106,7 @@ function peg$parse(input, options) {
7939
8106
  } else {
7940
8107
  s3 = peg$FAILED;
7941
8108
  if (peg$silentFails === 0) {
7942
- peg$fail(peg$e102);
8109
+ peg$fail(peg$e103);
7943
8110
  }
7944
8111
  }
7945
8112
  while (s3 !== peg$FAILED) {
@@ -7950,17 +8117,17 @@ function peg$parse(input, options) {
7950
8117
  } else {
7951
8118
  s3 = peg$FAILED;
7952
8119
  if (peg$silentFails === 0) {
7953
- peg$fail(peg$e102);
8120
+ peg$fail(peg$e103);
7954
8121
  }
7955
8122
  }
7956
8123
  }
7957
8124
  if (input.charCodeAt(peg$currPos) === 10) {
7958
- s3 = peg$c87;
8125
+ s3 = peg$c88;
7959
8126
  peg$currPos++;
7960
8127
  } else {
7961
8128
  s3 = peg$FAILED;
7962
8129
  if (peg$silentFails === 0) {
7963
- peg$fail(peg$e103);
8130
+ peg$fail(peg$e104);
7964
8131
  }
7965
8132
  }
7966
8133
  if (s3 === peg$FAILED) {
@@ -8013,13 +8180,13 @@ function peg$parse(input, options) {
8013
8180
  s3 = peg$currPos;
8014
8181
  s4 = peg$currPos;
8015
8182
  peg$silentFails++;
8016
- if (input.substr(peg$currPos, 2) === peg$c88) {
8017
- s5 = peg$c88;
8183
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8184
+ s5 = peg$c89;
8018
8185
  peg$currPos += 2;
8019
8186
  } else {
8020
8187
  s5 = peg$FAILED;
8021
8188
  if (peg$silentFails === 0) {
8022
- peg$fail(peg$e104);
8189
+ peg$fail(peg$e105);
8023
8190
  }
8024
8191
  }
8025
8192
  peg$silentFails--;
@@ -8055,13 +8222,13 @@ function peg$parse(input, options) {
8055
8222
  s3 = peg$currPos;
8056
8223
  s4 = peg$currPos;
8057
8224
  peg$silentFails++;
8058
- if (input.substr(peg$currPos, 2) === peg$c88) {
8059
- s5 = peg$c88;
8225
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8226
+ s5 = peg$c89;
8060
8227
  peg$currPos += 2;
8061
8228
  } else {
8062
8229
  s5 = peg$FAILED;
8063
8230
  if (peg$silentFails === 0) {
8064
- peg$fail(peg$e104);
8231
+ peg$fail(peg$e105);
8065
8232
  }
8066
8233
  }
8067
8234
  peg$silentFails--;
@@ -8093,13 +8260,13 @@ function peg$parse(input, options) {
8093
8260
  s3 = peg$FAILED;
8094
8261
  }
8095
8262
  }
8096
- if (input.substr(peg$currPos, 2) === peg$c88) {
8097
- s3 = peg$c88;
8263
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8264
+ s3 = peg$c89;
8098
8265
  peg$currPos += 2;
8099
8266
  } else {
8100
8267
  s3 = peg$FAILED;
8101
8268
  if (peg$silentFails === 0) {
8102
- peg$fail(peg$e104);
8269
+ peg$fail(peg$e105);
8103
8270
  }
8104
8271
  }
8105
8272
  if (s3 !== peg$FAILED) {
@@ -8274,6 +8441,7 @@ var GRAMMAR_ELEMENTS = {
8274
8441
  component: "Component",
8275
8442
  use: "ComponentUse",
8276
8443
  slot: "Slot",
8444
+ repeat: "Repeat",
8277
8445
  header: "Header",
8278
8446
  main: "Main",
8279
8447
  footer: "Footer",
@@ -8373,6 +8541,7 @@ var GRAMMAR_CHILD_KEYWORDS = [
8373
8541
  "group",
8374
8542
  "marker",
8375
8543
  "annotations",
8544
+ "repeat",
8376
8545
  "layout",
8377
8546
  "component",
8378
8547
  "use",
@@ -8764,6 +8933,16 @@ function printNodeLines(node, depth) {
8764
8933
  return componentDefinitionLines(node, depth);
8765
8934
  case "ComponentUse":
8766
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
+ );
8767
8946
  // -- containers without a label ----------------------------------------
8768
8947
  case "Header":
8769
8948
  case "Main":
@@ -13290,6 +13469,12 @@ var COMPONENT_METADATA = {
13290
13469
  hasChildren: false,
13291
13470
  description: "Mark content insertion: bare inside a layout, or named inside a reusable component."
13292
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
+ },
13293
13478
  header: {
13294
13479
  category: "layout",
13295
13480
  attributes: [...BOX_ATTRIBUTES, ...CONTAINER_ATTRIBUTES],
@@ -61863,6 +62048,7 @@ var HtmlRenderer = class extends BaseRenderer {
61863
62048
  * enabled so `renderNode` / `renderPage` can inject each node's path.
61864
62049
  */
61865
62050
  render(document) {
62051
+ document = expandRepeats(document);
61866
62052
  if (this.context.options.sourceAnchors) {
61867
62053
  this.pathMap = buildAnchorPathMap(document, this.pageIndexBase);
61868
62054
  }
@@ -63211,6 +63397,7 @@ function compactRuntimeInteractions(model, interactions) {
63211
63397
  }
63212
63398
  function renderSite(document, options = {}) {
63213
63399
  const prefix = options.classPrefix ?? DEFAULT_PREFIX2;
63400
+ document = expandRepeats(document);
63214
63401
  const model = buildSiteModel(document);
63215
63402
  const interactionModel = collectInteractions(document);
63216
63403
  const make = (idScope) => new HtmlRenderer({
@@ -63401,7 +63588,8 @@ var POSITIONAL_PROPS = {
63401
63588
  Layout: ["name"],
63402
63589
  Component: ["name"],
63403
63590
  ComponentUse: ["name", "namespace"],
63404
- Slot: ["name"]
63591
+ Slot: ["name"],
63592
+ Repeat: ["count"]
63405
63593
  };
63406
63594
  function declaredName(value) {
63407
63595
  const name = value?.trim();
@@ -65713,6 +65901,8 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65713
65901
  INTERACTIVE_ATTR_NAMES,
65714
65902
  LUCIDE_ICON_NAMES,
65715
65903
  NODE_TYPE_MAP,
65904
+ REPEAT_EXPANSION_BUDGET,
65905
+ RepeatBudgetError,
65716
65906
  TYPED_INTERACTION_ATTR,
65717
65907
  VALID_ATTRIBUTE_NAMES,
65718
65908
  VALID_COMPONENT_NAMES,
@@ -65739,6 +65929,7 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65739
65929
  diff,
65740
65930
  documentDefinitions,
65741
65931
  documentPages,
65932
+ expandRepeats,
65742
65933
  exportToFigma,
65743
65934
  exportToFigmaString,
65744
65935
  exportToJson,