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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.cjs 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,8 @@ __export(src_exports, {
72
74
  diff: () => diff,
73
75
  documentDefinitions: () => documentDefinitions,
74
76
  documentPages: () => documentPages,
77
+ expandRepeats: () => expandRepeats,
78
+ expandVariants: () => expandVariants,
75
79
  exportToFigma: () => exportToFigma,
76
80
  exportToFigmaString: () => exportToFigmaString,
77
81
  exportToJson: () => exportToJson,
@@ -203,6 +207,7 @@ var CONTAINER_TYPES = [
203
207
  "Layout",
204
208
  "Component",
205
209
  "ComponentUse",
210
+ "Repeat",
206
211
  "Header",
207
212
  "Main",
208
213
  "Footer",
@@ -554,6 +559,129 @@ function collectParameterReferences(children) {
554
559
  return found;
555
560
  }
556
561
 
562
+ // src/ast/expand-repeats.ts
563
+ var REPEAT_EXPANSION_BUDGET = 500;
564
+ var RepeatBudgetError = class extends Error {
565
+ constructor(budget) {
566
+ super(
567
+ `repeat expansion exceeds ${budget} nodes \u2014 nesting multiplies, so check the nested counts rather than the outermost one`
568
+ );
569
+ this.name = "RepeatBudgetError";
570
+ }
571
+ };
572
+ function cloneNode2(value) {
573
+ if (Array.isArray(value)) return value.map(cloneNode2);
574
+ if (value === null || typeof value !== "object") return value;
575
+ const source = value;
576
+ const result = {};
577
+ for (const [key, item] of Object.entries(source)) {
578
+ result[key] = key === "loc" ? item : cloneNode2(item);
579
+ }
580
+ return result;
581
+ }
582
+ function containsRepeat(node) {
583
+ if (node.type === "Repeat") return true;
584
+ const children = node.children;
585
+ if (Array.isArray(children)) {
586
+ for (const child of children) if (containsRepeat(child)) return true;
587
+ }
588
+ const fills = node.fills;
589
+ if (Array.isArray(fills)) {
590
+ for (const fill of fills) {
591
+ for (const child of fill.children ?? []) if (containsRepeat(child)) return true;
592
+ }
593
+ }
594
+ return false;
595
+ }
596
+ function expandOne(node, budget) {
597
+ if (node.type === "Repeat") {
598
+ const repeat = node;
599
+ const count = Number.isInteger(repeat.count) && repeat.count > 0 ? repeat.count : 0;
600
+ const result = [];
601
+ for (let i = 0; i < count; i++) {
602
+ for (const child of repeat.children) {
603
+ for (const expanded of expandOne(child, budget)) {
604
+ budget.remaining -= 1;
605
+ if (budget.remaining < 0) throw new RepeatBudgetError(REPEAT_EXPANSION_BUDGET);
606
+ result.push(cloneNode2(expanded));
607
+ }
608
+ }
609
+ }
610
+ return result;
611
+ }
612
+ if (!containsRepeat(node)) return [node];
613
+ const clone = { ...node };
614
+ const children = clone.children;
615
+ if (Array.isArray(children)) {
616
+ clone.children = children.flatMap((child) => expandOne(child, budget));
617
+ }
618
+ const fills = clone.fills;
619
+ if (Array.isArray(fills)) {
620
+ clone.fills = fills.map((fill) => ({
621
+ ...fill,
622
+ children: (fill.children ?? []).flatMap((child) => expandOne(child, budget))
623
+ }));
624
+ }
625
+ return [clone];
626
+ }
627
+ function expandRepeats(document) {
628
+ if (!document.children.some((child) => containsRepeat(child))) return document;
629
+ const budget = { remaining: REPEAT_EXPANSION_BUDGET };
630
+ return {
631
+ ...document,
632
+ children: document.children.flatMap(
633
+ (child) => expandOne(child, budget)
634
+ )
635
+ };
636
+ }
637
+
638
+ // src/ast/expand-variants.ts
639
+ function cloneNode3(value) {
640
+ if (Array.isArray(value)) return value.map(cloneNode3);
641
+ if (value === null || typeof value !== "object") return value;
642
+ const source = value;
643
+ const result = {};
644
+ for (const [key, item] of Object.entries(source)) {
645
+ result[key] = key === "loc" ? item : cloneNode3(item);
646
+ }
647
+ return result;
648
+ }
649
+ function variantNames(page) {
650
+ const declared = page.variants;
651
+ if (!Array.isArray(declared)) return [];
652
+ const seen = /* @__PURE__ */ new Set();
653
+ const names = [];
654
+ for (const raw of declared) {
655
+ if (typeof raw !== "string") continue;
656
+ const name = raw.trim();
657
+ if (name.length === 0 || seen.has(name)) continue;
658
+ seen.add(name);
659
+ names.push(name);
660
+ }
661
+ return names;
662
+ }
663
+ function hasVariants(document) {
664
+ return document.children.some((child) => child.type === "Page" && variantNames(child).length > 0);
665
+ }
666
+ function expandVariants(document) {
667
+ if (!hasVariants(document)) return document;
668
+ return {
669
+ ...document,
670
+ children: document.children.flatMap((child) => {
671
+ if (child.type !== "Page") return [child];
672
+ const names = variantNames(child);
673
+ if (names.length === 0) return [child];
674
+ return names.map((variant, position) => {
675
+ const clone = cloneNode3(child);
676
+ delete clone.variants;
677
+ clone.variant = variant;
678
+ if (position > 0) delete clone.states;
679
+ return clone;
680
+ });
681
+ })
682
+ };
683
+ }
684
+
557
685
  // src/parser/generated-parser.js
558
686
  var peg$SyntaxError = class extends SyntaxError {
559
687
  constructor(message, expected, found, location) {
@@ -683,75 +811,76 @@ function peg$parse(input, options) {
683
811
  const peg$c17 = "\r\n";
684
812
  const peg$c18 = "//";
685
813
  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 = "*/";
814
+ const peg$c20 = "repeat";
815
+ const peg$c21 = "header";
816
+ const peg$c22 = "main";
817
+ const peg$c23 = "footer";
818
+ const peg$c24 = "sidebar";
819
+ const peg$c25 = "row";
820
+ const peg$c26 = "col";
821
+ const peg$c27 = "stack";
822
+ const peg$c28 = "relative";
823
+ const peg$c29 = "card";
824
+ const peg$c30 = "modal";
825
+ const peg$c31 = "drawer";
826
+ const peg$c32 = "accordion";
827
+ const peg$c33 = "section";
828
+ const peg$c34 = "text";
829
+ const peg$c35 = "title";
830
+ const peg$c36 = "link";
831
+ const peg$c37 = "button";
832
+ const peg$c38 = "input";
833
+ const peg$c39 = "textarea";
834
+ const peg$c40 = "select";
835
+ const peg$c41 = "checkbox";
836
+ const peg$c42 = "radio";
837
+ const peg$c43 = "switch";
838
+ const peg$c44 = "slider";
839
+ const peg$c45 = "image";
840
+ const peg$c46 = "placeholder";
841
+ const peg$c47 = "avatar";
842
+ const peg$c48 = "badge";
843
+ const peg$c49 = "icon";
844
+ const peg$c50 = "table";
845
+ const peg$c51 = "[";
846
+ const peg$c52 = "]";
847
+ const peg$c53 = "columns";
848
+ const peg$c54 = "list";
849
+ const peg$c55 = "item";
850
+ const peg$c56 = "alert";
851
+ const peg$c57 = "toast";
852
+ const peg$c58 = "progress";
853
+ const peg$c59 = "spinner";
854
+ const peg$c60 = "tooltip";
855
+ const peg$c61 = "popover";
856
+ const peg$c62 = "dropdown";
857
+ const peg$c63 = "divider";
858
+ const peg$c64 = "nav";
859
+ const peg$c65 = "group";
860
+ const peg$c66 = "tabs";
861
+ const peg$c67 = "tab";
862
+ const peg$c68 = "breadcrumb";
863
+ const peg$c69 = "marker";
864
+ const peg$c70 = "annotations";
865
+ const peg$c71 = "at";
866
+ const peg$c72 = '"';
867
+ const peg$c73 = "'";
868
+ const peg$c74 = "\\";
869
+ const peg$c75 = "n";
870
+ const peg$c76 = "r";
871
+ const peg$c77 = "t";
872
+ const peg$c78 = "-";
873
+ const peg$c79 = ".";
874
+ const peg$c80 = "px";
875
+ const peg$c81 = "%";
876
+ const peg$c82 = "em";
877
+ const peg$c83 = "rem";
878
+ const peg$c84 = "vh";
879
+ const peg$c85 = "vw";
880
+ const peg$c86 = "true";
881
+ const peg$c87 = "false";
882
+ const peg$c88 = "\n";
883
+ const peg$c89 = "*/";
755
884
  const peg$r0 = /^[ \t]/;
756
885
  const peg$r1 = /^[\n\r}]/;
757
886
  const peg$r2 = /^[0-9]/;
@@ -783,88 +912,89 @@ function peg$parse(input, options) {
783
912
  const peg$e20 = peg$literalExpectation("//", false);
784
913
  const peg$e21 = peg$literalExpectation("/*", false);
785
914
  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);
915
+ const peg$e23 = peg$literalExpectation("repeat", false);
916
+ const peg$e24 = peg$literalExpectation("header", false);
917
+ const peg$e25 = peg$literalExpectation("main", false);
918
+ const peg$e26 = peg$literalExpectation("footer", false);
919
+ const peg$e27 = peg$literalExpectation("sidebar", false);
920
+ const peg$e28 = peg$literalExpectation("row", false);
921
+ const peg$e29 = peg$literalExpectation("col", false);
922
+ const peg$e30 = peg$literalExpectation("stack", false);
923
+ const peg$e31 = peg$literalExpectation("relative", false);
924
+ const peg$e32 = peg$literalExpectation("card", false);
925
+ const peg$e33 = peg$literalExpectation("modal", false);
926
+ const peg$e34 = peg$literalExpectation("drawer", false);
927
+ const peg$e35 = peg$literalExpectation("accordion", false);
928
+ const peg$e36 = peg$literalExpectation("section", false);
929
+ const peg$e37 = peg$literalExpectation("text", false);
930
+ const peg$e38 = peg$literalExpectation("title", false);
931
+ const peg$e39 = peg$literalExpectation("link", false);
932
+ const peg$e40 = peg$literalExpectation("button", false);
933
+ const peg$e41 = peg$literalExpectation("input", false);
934
+ const peg$e42 = peg$literalExpectation("textarea", false);
935
+ const peg$e43 = peg$literalExpectation("select", false);
936
+ const peg$e44 = peg$literalExpectation("checkbox", false);
937
+ const peg$e45 = peg$literalExpectation("radio", false);
938
+ const peg$e46 = peg$literalExpectation("switch", false);
939
+ const peg$e47 = peg$literalExpectation("slider", false);
940
+ const peg$e48 = peg$literalExpectation("image", false);
941
+ const peg$e49 = peg$literalExpectation("placeholder", false);
942
+ const peg$e50 = peg$literalExpectation("avatar", false);
943
+ const peg$e51 = peg$literalExpectation("badge", false);
944
+ const peg$e52 = peg$literalExpectation("icon", false);
945
+ const peg$e53 = peg$literalExpectation("table", false);
946
+ const peg$e54 = peg$literalExpectation("[", false);
947
+ const peg$e55 = peg$literalExpectation("]", false);
948
+ const peg$e56 = peg$literalExpectation("columns", false);
949
+ const peg$e57 = peg$literalExpectation("list", false);
950
+ const peg$e58 = peg$literalExpectation("item", false);
951
+ const peg$e59 = peg$literalExpectation("alert", false);
952
+ const peg$e60 = peg$literalExpectation("toast", false);
953
+ const peg$e61 = peg$literalExpectation("progress", false);
954
+ const peg$e62 = peg$literalExpectation("spinner", false);
955
+ const peg$e63 = peg$literalExpectation("tooltip", false);
956
+ const peg$e64 = peg$literalExpectation("popover", false);
957
+ const peg$e65 = peg$literalExpectation("dropdown", false);
958
+ const peg$e66 = peg$literalExpectation("divider", false);
959
+ const peg$e67 = peg$literalExpectation("nav", false);
960
+ const peg$e68 = peg$literalExpectation("group", false);
961
+ const peg$e69 = peg$literalExpectation("tabs", false);
962
+ const peg$e70 = peg$literalExpectation("tab", false);
963
+ const peg$e71 = peg$literalExpectation("breadcrumb", false);
964
+ const peg$e72 = peg$literalExpectation("marker", false);
965
+ const peg$e73 = peg$literalExpectation("annotations", false);
966
+ const peg$e74 = peg$otherExpectation("integer");
967
+ const peg$e75 = peg$classExpectation([["0", "9"]], false, false, false);
968
+ const peg$e76 = peg$literalExpectation("at", false);
969
+ const peg$e77 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
970
+ const peg$e78 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
971
+ const peg$e79 = peg$otherExpectation("string");
972
+ const peg$e80 = peg$literalExpectation('"', false);
973
+ const peg$e81 = peg$literalExpectation("'", false);
974
+ const peg$e82 = peg$literalExpectation("\\", false);
975
+ const peg$e83 = peg$literalExpectation("n", false);
976
+ const peg$e84 = peg$literalExpectation("r", false);
977
+ const peg$e85 = peg$literalExpectation("t", false);
978
+ const peg$e86 = peg$otherExpectation("number");
979
+ const peg$e87 = peg$literalExpectation("-", false);
980
+ const peg$e88 = peg$literalExpectation(".", false);
981
+ const peg$e89 = peg$otherExpectation("value with unit");
982
+ const peg$e90 = peg$literalExpectation("px", false);
983
+ const peg$e91 = peg$literalExpectation("%", false);
984
+ const peg$e92 = peg$literalExpectation("em", false);
985
+ const peg$e93 = peg$literalExpectation("rem", false);
986
+ const peg$e94 = peg$literalExpectation("vh", false);
987
+ const peg$e95 = peg$literalExpectation("vw", false);
988
+ const peg$e96 = peg$otherExpectation("boolean");
989
+ const peg$e97 = peg$literalExpectation("true", false);
990
+ const peg$e98 = peg$literalExpectation("false", false);
991
+ const peg$e99 = peg$otherExpectation("identifier");
992
+ const peg$e100 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
993
+ const peg$e101 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
994
+ const peg$e102 = peg$otherExpectation("comment");
995
+ const peg$e103 = peg$classExpectation(["\n"], true, false, false);
996
+ const peg$e104 = peg$literalExpectation("\n", false);
997
+ const peg$e105 = peg$literalExpectation("*/", false);
868
998
  function peg$f0(children) {
869
999
  return createNode("Document", {
870
1000
  children: children.map((c) => c[0]).filter((c) => c !== null)
@@ -945,114 +1075,120 @@ function peg$parse(input, options) {
945
1075
  function peg$f18() {
946
1076
  return null;
947
1077
  }
948
- function peg$f19(attrs2, children) {
1078
+ function peg$f19(count, children) {
1079
+ return createNode("Repeat", {
1080
+ count,
1081
+ children
1082
+ });
1083
+ }
1084
+ function peg$f20(attrs2, children) {
949
1085
  return createNode("Header", {
950
1086
  ...attrsToObject(attrs2),
951
1087
  children
952
1088
  });
953
1089
  }
954
- function peg$f20(attrs2, children) {
1090
+ function peg$f21(attrs2, children) {
955
1091
  return createNode("Main", {
956
1092
  ...attrsToObject(attrs2),
957
1093
  children
958
1094
  });
959
1095
  }
960
- function peg$f21(attrs2, children) {
1096
+ function peg$f22(attrs2, children) {
961
1097
  return createNode("Footer", {
962
1098
  ...attrsToObject(attrs2),
963
1099
  children
964
1100
  });
965
1101
  }
966
- function peg$f22(attrs2, children) {
1102
+ function peg$f23(attrs2, children) {
967
1103
  return createNode("Sidebar", {
968
1104
  ...attrsToObject(attrs2),
969
1105
  children
970
1106
  });
971
1107
  }
972
- function peg$f23(attrs2, children) {
1108
+ function peg$f24(attrs2, children) {
973
1109
  return createNode("Row", {
974
1110
  ...attrsToObject(attrs2),
975
1111
  children
976
1112
  });
977
1113
  }
978
- function peg$f24(attrs2, children) {
1114
+ function peg$f25(attrs2, children) {
979
1115
  return createNode("Col", {
980
1116
  ...attrsToObject(attrs2),
981
1117
  children
982
1118
  });
983
1119
  }
984
- function peg$f25(attrs2, children) {
1120
+ function peg$f26(attrs2, children) {
985
1121
  return createNode("Stack", {
986
1122
  ...attrsToObject(attrs2),
987
1123
  children
988
1124
  });
989
1125
  }
990
- function peg$f26(attrs2, children) {
1126
+ function peg$f27(attrs2, children) {
991
1127
  return createNode("Relative", {
992
1128
  ...attrsToObject(attrs2),
993
1129
  children
994
1130
  });
995
1131
  }
996
- function peg$f27(label, attrs2, children) {
1132
+ function peg$f28(label, attrs2, children) {
997
1133
  return createNode("Card", {
998
1134
  title: label || null,
999
1135
  ...attrsToObject(attrs2),
1000
1136
  children
1001
1137
  });
1002
1138
  }
1003
- function peg$f28(label, attrs2, children) {
1139
+ function peg$f29(label, attrs2, children) {
1004
1140
  return createNode("Modal", {
1005
1141
  title: label || null,
1006
1142
  ...attrsToObject(attrs2),
1007
1143
  children
1008
1144
  });
1009
1145
  }
1010
- function peg$f29(label, attrs2, children) {
1146
+ function peg$f30(label, attrs2, children) {
1011
1147
  return createNode("Drawer", {
1012
1148
  title: label || null,
1013
1149
  ...attrsToObject(attrs2),
1014
1150
  children
1015
1151
  });
1016
1152
  }
1017
- function peg$f30(label, attrs2, children) {
1153
+ function peg$f31(label, attrs2, children) {
1018
1154
  return createNode("Accordion", {
1019
1155
  title: label || null,
1020
1156
  ...attrsToObject(attrs2),
1021
1157
  children
1022
1158
  });
1023
1159
  }
1024
- function peg$f31(label, attrs2, children) {
1160
+ function peg$f32(label, attrs2, children) {
1025
1161
  return createNode("Section", {
1026
1162
  title: label || null,
1027
1163
  ...attrsToObject(attrs2),
1028
1164
  children
1029
1165
  });
1030
1166
  }
1031
- function peg$f32(label, attrs2) {
1167
+ function peg$f33(label, attrs2) {
1032
1168
  return createNode("Text", {
1033
1169
  content: label,
1034
1170
  ...attrsToObject(attrs2)
1035
1171
  });
1036
1172
  }
1037
- function peg$f33(label, attrs2) {
1173
+ function peg$f34(label, attrs2) {
1038
1174
  return createNode("Title", {
1039
1175
  content: label,
1040
1176
  ...attrsToObject(attrs2)
1041
1177
  });
1042
1178
  }
1043
- function peg$f34(label, attrs2) {
1179
+ function peg$f35(label, attrs2) {
1044
1180
  return createNode("Link", {
1045
1181
  content: label,
1046
1182
  ...attrsToObject(attrs2)
1047
1183
  });
1048
1184
  }
1049
- function peg$f35(label, attrs2) {
1185
+ function peg$f36(label, attrs2) {
1050
1186
  return createNode("Button", {
1051
1187
  content: label,
1052
1188
  ...attrsToObject(attrs2)
1053
1189
  });
1054
1190
  }
1055
- function peg$f36(label, attrs2) {
1191
+ function peg$f37(label, attrs2) {
1056
1192
  const obj = attrsToObject(attrs2);
1057
1193
  const inputType = obj.type;
1058
1194
  delete obj.type;
@@ -1062,75 +1198,75 @@ function peg$parse(input, options) {
1062
1198
  ...obj
1063
1199
  });
1064
1200
  }
1065
- function peg$f37(label, attrs2) {
1201
+ function peg$f38(label, attrs2) {
1066
1202
  return createNode("Textarea", {
1067
1203
  label: label || null,
1068
1204
  ...attrsToObject(attrs2)
1069
1205
  });
1070
1206
  }
1071
- function peg$f38(label, options2, attrs2) {
1207
+ function peg$f39(label, options2, attrs2) {
1072
1208
  return createNode("Select", {
1073
1209
  label: label || null,
1074
1210
  options: options2 || [],
1075
1211
  ...attrsToObject(attrs2)
1076
1212
  });
1077
1213
  }
1078
- function peg$f39(label, attrs2) {
1214
+ function peg$f40(label, attrs2) {
1079
1215
  return createNode("Checkbox", {
1080
1216
  label: label || null,
1081
1217
  ...attrsToObject(attrs2)
1082
1218
  });
1083
1219
  }
1084
- function peg$f40(label, attrs2) {
1220
+ function peg$f41(label, attrs2) {
1085
1221
  return createNode("Radio", {
1086
1222
  label: label || null,
1087
1223
  ...attrsToObject(attrs2)
1088
1224
  });
1089
1225
  }
1090
- function peg$f41(label, attrs2) {
1226
+ function peg$f42(label, attrs2) {
1091
1227
  return createNode("Switch", {
1092
1228
  label: label || null,
1093
1229
  ...attrsToObject(attrs2)
1094
1230
  });
1095
1231
  }
1096
- function peg$f42(label, attrs2) {
1232
+ function peg$f43(label, attrs2) {
1097
1233
  return createNode("Slider", {
1098
1234
  label: label || null,
1099
1235
  ...attrsToObject(attrs2)
1100
1236
  });
1101
1237
  }
1102
- function peg$f43(src, attrs2) {
1238
+ function peg$f44(src, attrs2) {
1103
1239
  return createNode("Image", {
1104
1240
  src: src || null,
1105
1241
  ...attrsToObject(attrs2)
1106
1242
  });
1107
1243
  }
1108
- function peg$f44(label, attrs2, block) {
1244
+ function peg$f45(label, attrs2, block) {
1109
1245
  return createNode("Placeholder", {
1110
1246
  label: label || null,
1111
1247
  ...attrsToObject(attrs2),
1112
1248
  children: block ? block[2] : []
1113
1249
  });
1114
1250
  }
1115
- function peg$f45(label, attrs2) {
1251
+ function peg$f46(label, attrs2) {
1116
1252
  return createNode("Avatar", {
1117
1253
  name: label || null,
1118
1254
  ...attrsToObject(attrs2)
1119
1255
  });
1120
1256
  }
1121
- function peg$f46(label, attrs2) {
1257
+ function peg$f47(label, attrs2) {
1122
1258
  return createNode("Badge", {
1123
1259
  content: label,
1124
1260
  ...attrsToObject(attrs2)
1125
1261
  });
1126
1262
  }
1127
- function peg$f47(name, attrs2) {
1263
+ function peg$f48(name, attrs2) {
1128
1264
  return createNode("Icon", {
1129
1265
  name,
1130
1266
  ...attrsToObject(attrs2)
1131
1267
  });
1132
1268
  }
1133
- function peg$f48(data, attrs2) {
1269
+ function peg$f49(data, attrs2) {
1134
1270
  const columns = data.length > 0 ? data[0] : [];
1135
1271
  const rows = data.slice(1);
1136
1272
  return createNode("Table", {
@@ -1139,16 +1275,16 @@ function peg$parse(input, options) {
1139
1275
  ...attrsToObject(attrs2)
1140
1276
  });
1141
1277
  }
1142
- function peg$f49(attrs2, rows) {
1278
+ function peg$f50(attrs2, rows) {
1143
1279
  return createNode("Table", {
1144
1280
  ...attrsToObject(attrs2),
1145
1281
  ...rows
1146
1282
  });
1147
1283
  }
1148
- function peg$f50(first, rest) {
1284
+ function peg$f51(first, rest) {
1149
1285
  return [first, ...rest.map((r) => r[2])];
1150
1286
  }
1151
- function peg$f51(items) {
1287
+ function peg$f52(items) {
1152
1288
  const columns = [];
1153
1289
  const rows = [];
1154
1290
  for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
@@ -1157,72 +1293,72 @@ function peg$parse(input, options) {
1157
1293
  }
1158
1294
  return { columns, rows };
1159
1295
  }
1160
- function peg$f52(values) {
1296
+ function peg$f53(values) {
1161
1297
  return { kind: "columns", values };
1162
1298
  }
1163
- function peg$f53(values) {
1299
+ function peg$f54(values) {
1164
1300
  return { kind: "row", values };
1165
1301
  }
1166
- function peg$f54() {
1302
+ function peg$f55() {
1167
1303
  return null;
1168
1304
  }
1169
- function peg$f55(items, attrs2, block) {
1305
+ function peg$f56(items, attrs2, block) {
1170
1306
  return createNode("List", {
1171
1307
  items: items || (block ? block : []),
1172
1308
  ...attrsToObject(attrs2)
1173
1309
  });
1174
1310
  }
1175
- function peg$f56(items) {
1311
+ function peg$f57(items) {
1176
1312
  return items.map((i) => i[0]).filter((i) => i !== null);
1177
1313
  }
1178
- function peg$f57(label, attrs2, nested) {
1314
+ function peg$f58(label, attrs2, nested) {
1179
1315
  return createBlockNode("ListItem", {
1180
1316
  content: label,
1181
1317
  ...attrsToObject(attrs2),
1182
1318
  children: nested || []
1183
1319
  });
1184
1320
  }
1185
- function peg$f58() {
1321
+ function peg$f59() {
1186
1322
  return null;
1187
1323
  }
1188
- function peg$f59(label, attrs2) {
1324
+ function peg$f60(label, attrs2) {
1189
1325
  return createNode("Alert", {
1190
1326
  content: label,
1191
1327
  ...attrsToObject(attrs2)
1192
1328
  });
1193
1329
  }
1194
- function peg$f60(label, attrs2) {
1330
+ function peg$f61(label, attrs2) {
1195
1331
  return createNode("Toast", {
1196
1332
  content: label,
1197
1333
  ...attrsToObject(attrs2)
1198
1334
  });
1199
1335
  }
1200
- function peg$f61(attrs2) {
1336
+ function peg$f62(attrs2) {
1201
1337
  return createNode("Progress", {
1202
1338
  ...attrsToObject(attrs2)
1203
1339
  });
1204
1340
  }
1205
- function peg$f62(label, attrs2) {
1341
+ function peg$f63(label, attrs2) {
1206
1342
  return createNode("Spinner", {
1207
1343
  label: label || null,
1208
1344
  ...attrsToObject(attrs2)
1209
1345
  });
1210
1346
  }
1211
- function peg$f63(label, attrs2) {
1347
+ function peg$f64(label, attrs2) {
1212
1348
  return createNode("Tooltip", {
1213
1349
  content: label,
1214
1350
  ...attrsToObject(attrs2),
1215
1351
  children: []
1216
1352
  });
1217
1353
  }
1218
- function peg$f64(label, attrs2, children) {
1354
+ function peg$f65(label, attrs2, children) {
1219
1355
  return createNode("Popover", {
1220
1356
  title: label || null,
1221
1357
  ...attrsToObject(attrs2),
1222
1358
  children
1223
1359
  });
1224
1360
  }
1225
- function peg$f65(items, attrs2) {
1361
+ function peg$f66(items, attrs2) {
1226
1362
  const processedItems = items.map((item) => {
1227
1363
  if (typeof item === "string") {
1228
1364
  if (item === "---" || item === "-" || item === "divider") {
@@ -1237,106 +1373,106 @@ function peg$parse(input, options) {
1237
1373
  items: processedItems
1238
1374
  });
1239
1375
  }
1240
- function peg$f66(attrs2, items) {
1376
+ function peg$f67(attrs2, items) {
1241
1377
  return createNode("Dropdown", {
1242
1378
  ...attrsToObject(attrs2),
1243
1379
  items
1244
1380
  });
1245
1381
  }
1246
- function peg$f67(items) {
1382
+ function peg$f68(items) {
1247
1383
  return items.map((i) => i[0]).filter((i) => i !== null);
1248
1384
  }
1249
- function peg$f68(label, attrs2) {
1385
+ function peg$f69(label, attrs2) {
1250
1386
  return createBlockNode("DropdownItem", { label, ...attrsToObject(attrs2) });
1251
1387
  }
1252
- function peg$f69() {
1388
+ function peg$f70() {
1253
1389
  return createBlockNode("Divider", {});
1254
1390
  }
1255
- function peg$f70() {
1391
+ function peg$f71() {
1256
1392
  return null;
1257
1393
  }
1258
- function peg$f71(items, attrs2, block) {
1394
+ function peg$f72(items, attrs2, block) {
1259
1395
  return createNode("Nav", {
1260
1396
  items: items || [],
1261
1397
  ...attrsToObject(attrs2),
1262
1398
  children: block || []
1263
1399
  });
1264
1400
  }
1265
- function peg$f72(content) {
1401
+ function peg$f73(content) {
1266
1402
  return content.map((c) => c[0]).filter((c) => c !== null);
1267
1403
  }
1268
- function peg$f73() {
1404
+ function peg$f74() {
1269
1405
  return createBlockNode("Divider", {});
1270
1406
  }
1271
- function peg$f74() {
1407
+ function peg$f75() {
1272
1408
  return null;
1273
1409
  }
1274
- function peg$f75(label, attrs2, items) {
1410
+ function peg$f76(label, attrs2, items) {
1275
1411
  return createBlockNode("NavGroup", {
1276
1412
  label,
1277
1413
  ...attrsToObject(attrs2),
1278
1414
  items: items.map((i) => i[0]).filter((i) => i !== null)
1279
1415
  });
1280
1416
  }
1281
- function peg$f76() {
1417
+ function peg$f77() {
1282
1418
  return createBlockNode("Divider", {});
1283
1419
  }
1284
- function peg$f77() {
1420
+ function peg$f78() {
1285
1421
  return null;
1286
1422
  }
1287
- function peg$f78(label, attrs2) {
1423
+ function peg$f79(label, attrs2) {
1288
1424
  return createBlockNode("NavItem", {
1289
1425
  label,
1290
1426
  ...attrsToObject(attrs2)
1291
1427
  });
1292
1428
  }
1293
- function peg$f79(items, attrs2, block) {
1429
+ function peg$f80(items, attrs2, block) {
1294
1430
  return createNode("Tabs", {
1295
1431
  items: items || [],
1296
1432
  ...attrsToObject(attrs2),
1297
1433
  children: block || []
1298
1434
  });
1299
1435
  }
1300
- function peg$f80(tabs) {
1436
+ function peg$f81(tabs) {
1301
1437
  return tabs.map((t) => t[0]).filter((t) => t !== null);
1302
1438
  }
1303
- function peg$f81(label, attrs2, children) {
1439
+ function peg$f82(label, attrs2, children) {
1304
1440
  return {
1305
1441
  label,
1306
1442
  ...attrsToObject(attrs2),
1307
1443
  children
1308
1444
  };
1309
1445
  }
1310
- function peg$f82() {
1446
+ function peg$f83() {
1311
1447
  return null;
1312
1448
  }
1313
- function peg$f83(items, attrs2) {
1449
+ function peg$f84(items, attrs2) {
1314
1450
  return createNode("Breadcrumb", {
1315
1451
  items,
1316
1452
  ...attrsToObject(attrs2)
1317
1453
  });
1318
1454
  }
1319
- function peg$f84(attrs2) {
1455
+ function peg$f85(attrs2) {
1320
1456
  return createNode("Divider", {
1321
1457
  ...attrsToObject(attrs2)
1322
1458
  });
1323
1459
  }
1324
- function peg$f85(num, attrs2) {
1460
+ function peg$f86(num, attrs2) {
1325
1461
  return createNode("Marker", {
1326
1462
  number: num,
1327
1463
  ...attrsToObject(attrs2)
1328
1464
  });
1329
1465
  }
1330
- function peg$f86(attrs2, items) {
1466
+ function peg$f87(attrs2, items) {
1331
1467
  return createNode("Annotations", {
1332
1468
  ...attrsToObject(attrs2),
1333
1469
  children: items
1334
1470
  });
1335
1471
  }
1336
- function peg$f87(items) {
1472
+ function peg$f88(items) {
1337
1473
  return items.map((i) => i[0]).filter((i) => i !== null);
1338
1474
  }
1339
- function peg$f88(num, title, attrs2, children) {
1475
+ function peg$f89(num, title, attrs2, children) {
1340
1476
  return createNode("AnnotationItem", {
1341
1477
  number: num,
1342
1478
  title,
@@ -1344,7 +1480,7 @@ function peg$parse(input, options) {
1344
1480
  children
1345
1481
  });
1346
1482
  }
1347
- function peg$f89(num, title, attrs2) {
1483
+ function peg$f90(num, title, attrs2) {
1348
1484
  return createNode("AnnotationItem", {
1349
1485
  number: num,
1350
1486
  title,
@@ -1352,90 +1488,90 @@ function peg$parse(input, options) {
1352
1488
  children: []
1353
1489
  });
1354
1490
  }
1355
- function peg$f90() {
1491
+ function peg$f91() {
1356
1492
  return null;
1357
1493
  }
1358
- function peg$f91(digits) {
1494
+ function peg$f92(digits) {
1359
1495
  return parseInt(digits.join(""), 10);
1360
1496
  }
1361
- function peg$f92(attrs2) {
1497
+ function peg$f93(attrs2) {
1362
1498
  return attrs2;
1363
1499
  }
1364
- function peg$f93(x, y) {
1500
+ function peg$f94(x, y) {
1365
1501
  return [
1366
1502
  { name: "x", value: x },
1367
1503
  { name: "y", value: y }
1368
1504
  ];
1369
1505
  }
1370
- function peg$f94(name, value) {
1506
+ function peg$f95(name, value) {
1371
1507
  return { name, value };
1372
1508
  }
1373
- function peg$f95(flag) {
1509
+ function peg$f96(flag) {
1374
1510
  return { name: flag, value: true };
1375
1511
  }
1376
- function peg$f96(name) {
1512
+ function peg$f97(name) {
1377
1513
  return name;
1378
1514
  }
1379
- function peg$f97(chars) {
1515
+ function peg$f98(chars) {
1380
1516
  return chars.join("");
1381
1517
  }
1382
- function peg$f98(chars) {
1518
+ function peg$f99(chars) {
1383
1519
  return chars.join("");
1384
1520
  }
1385
- function peg$f99(char) {
1521
+ function peg$f100(char) {
1386
1522
  return char;
1387
1523
  }
1388
- function peg$f100(seq) {
1524
+ function peg$f101(seq) {
1389
1525
  return seq;
1390
1526
  }
1391
- function peg$f101(char) {
1527
+ function peg$f102(char) {
1392
1528
  return char;
1393
1529
  }
1394
- function peg$f102(seq) {
1530
+ function peg$f103(seq) {
1395
1531
  return seq;
1396
1532
  }
1397
- function peg$f103() {
1533
+ function peg$f104() {
1398
1534
  return "\n";
1399
1535
  }
1400
- function peg$f104() {
1536
+ function peg$f105() {
1401
1537
  return "\r";
1402
1538
  }
1403
- function peg$f105() {
1539
+ function peg$f106() {
1404
1540
  return " ";
1405
1541
  }
1406
- function peg$f106() {
1542
+ function peg$f107() {
1407
1543
  return "\\";
1408
1544
  }
1409
- function peg$f107() {
1545
+ function peg$f108() {
1410
1546
  return '"';
1411
1547
  }
1412
- function peg$f108() {
1548
+ function peg$f109() {
1413
1549
  return "'";
1414
1550
  }
1415
- function peg$f109(sign, digits, decimal) {
1551
+ function peg$f110(sign, digits, decimal) {
1416
1552
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1417
1553
  return parseFloat(num);
1418
1554
  }
1419
- function peg$f110(sign, digits, decimal, unit) {
1555
+ function peg$f111(sign, digits, decimal, unit) {
1420
1556
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1421
1557
  return { value: parseFloat(num), unit };
1422
1558
  }
1423
- function peg$f111() {
1559
+ function peg$f112() {
1424
1560
  return true;
1425
1561
  }
1426
- function peg$f112() {
1562
+ function peg$f113() {
1427
1563
  return false;
1428
1564
  }
1429
- function peg$f113(head, tail) {
1565
+ function peg$f114(head, tail) {
1430
1566
  return head + tail.join("");
1431
1567
  }
1432
- function peg$f114(items) {
1568
+ function peg$f115(items) {
1433
1569
  return items || [];
1434
1570
  }
1435
- function peg$f115(head, tail) {
1571
+ function peg$f116(head, tail) {
1436
1572
  return [head, ...tail.map((t) => t[3])];
1437
1573
  }
1438
- function peg$f116(props) {
1574
+ function peg$f117(props) {
1439
1575
  const result = {};
1440
1576
  if (props) {
1441
1577
  for (const p of props) {
@@ -1444,13 +1580,13 @@ function peg$parse(input, options) {
1444
1580
  }
1445
1581
  return result;
1446
1582
  }
1447
- function peg$f117(head, tail) {
1583
+ function peg$f118(head, tail) {
1448
1584
  return [head, ...tail.map((t) => t[3])];
1449
1585
  }
1450
- function peg$f118(name, value) {
1586
+ function peg$f119(name, value) {
1451
1587
  return { name, value };
1452
1588
  }
1453
- function peg$f119(name) {
1589
+ function peg$f120(name) {
1454
1590
  return { name, value: true };
1455
1591
  }
1456
1592
  let peg$currPos = options.peg$currPos | 0;
@@ -2702,21 +2838,24 @@ function peg$parse(input, options) {
2702
2838
  let s0, s1;
2703
2839
  s0 = peg$parseComponentUse();
2704
2840
  if (s0 === peg$FAILED) {
2705
- s0 = peg$parseLayoutElement();
2841
+ s0 = peg$parseRepeat();
2706
2842
  if (s0 === peg$FAILED) {
2707
- s0 = peg$parseContainerElement();
2843
+ s0 = peg$parseLayoutElement();
2708
2844
  if (s0 === peg$FAILED) {
2709
- s0 = peg$parseUIElement();
2845
+ s0 = peg$parseContainerElement();
2710
2846
  if (s0 === peg$FAILED) {
2711
- s0 = peg$parseSlot();
2847
+ s0 = peg$parseUIElement();
2712
2848
  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();
2849
+ s0 = peg$parseSlot();
2850
+ if (s0 === peg$FAILED) {
2851
+ s0 = peg$currPos;
2852
+ s1 = peg$parseComment();
2853
+ if (s1 !== peg$FAILED) {
2854
+ peg$savedPos = s0;
2855
+ s1 = peg$f18();
2856
+ }
2857
+ s0 = s1;
2718
2858
  }
2719
- s0 = s1;
2720
2859
  }
2721
2860
  }
2722
2861
  }
@@ -2724,6 +2863,71 @@ function peg$parse(input, options) {
2724
2863
  }
2725
2864
  return s0;
2726
2865
  }
2866
+ function peg$parseRepeat() {
2867
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2868
+ s0 = peg$currPos;
2869
+ if (input.substr(peg$currPos, 6) === peg$c20) {
2870
+ s1 = peg$c20;
2871
+ peg$currPos += 6;
2872
+ } else {
2873
+ s1 = peg$FAILED;
2874
+ if (peg$silentFails === 0) {
2875
+ peg$fail(peg$e23);
2876
+ }
2877
+ }
2878
+ if (s1 !== peg$FAILED) {
2879
+ s2 = peg$parse_();
2880
+ s3 = peg$parseInteger();
2881
+ if (s3 !== peg$FAILED) {
2882
+ s4 = peg$parse_();
2883
+ if (input.charCodeAt(peg$currPos) === 123) {
2884
+ s5 = peg$c1;
2885
+ peg$currPos++;
2886
+ } else {
2887
+ s5 = peg$FAILED;
2888
+ if (peg$silentFails === 0) {
2889
+ peg$fail(peg$e1);
2890
+ }
2891
+ }
2892
+ if (s5 !== peg$FAILED) {
2893
+ s6 = peg$parse_();
2894
+ s7 = peg$parseChildren();
2895
+ if (s7 !== peg$FAILED) {
2896
+ s8 = peg$parse_();
2897
+ if (input.charCodeAt(peg$currPos) === 125) {
2898
+ s9 = peg$c2;
2899
+ peg$currPos++;
2900
+ } else {
2901
+ s9 = peg$FAILED;
2902
+ if (peg$silentFails === 0) {
2903
+ peg$fail(peg$e2);
2904
+ }
2905
+ }
2906
+ if (s9 !== peg$FAILED) {
2907
+ peg$savedPos = s0;
2908
+ s0 = peg$f19(s3, s7);
2909
+ } else {
2910
+ peg$currPos = s0;
2911
+ s0 = peg$FAILED;
2912
+ }
2913
+ } else {
2914
+ peg$currPos = s0;
2915
+ s0 = peg$FAILED;
2916
+ }
2917
+ } else {
2918
+ peg$currPos = s0;
2919
+ s0 = peg$FAILED;
2920
+ }
2921
+ } else {
2922
+ peg$currPos = s0;
2923
+ s0 = peg$FAILED;
2924
+ }
2925
+ } else {
2926
+ peg$currPos = s0;
2927
+ s0 = peg$FAILED;
2928
+ }
2929
+ return s0;
2930
+ }
2727
2931
  function peg$parseLayoutElement() {
2728
2932
  let s0;
2729
2933
  s0 = peg$parseHeader();
@@ -2753,13 +2957,13 @@ function peg$parse(input, options) {
2753
2957
  function peg$parseHeader() {
2754
2958
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2755
2959
  s0 = peg$currPos;
2756
- if (input.substr(peg$currPos, 6) === peg$c20) {
2757
- s1 = peg$c20;
2960
+ if (input.substr(peg$currPos, 6) === peg$c21) {
2961
+ s1 = peg$c21;
2758
2962
  peg$currPos += 6;
2759
2963
  } else {
2760
2964
  s1 = peg$FAILED;
2761
2965
  if (peg$silentFails === 0) {
2762
- peg$fail(peg$e23);
2966
+ peg$fail(peg$e24);
2763
2967
  }
2764
2968
  }
2765
2969
  if (s1 !== peg$FAILED) {
@@ -2794,7 +2998,7 @@ function peg$parse(input, options) {
2794
2998
  }
2795
2999
  if (s9 !== peg$FAILED) {
2796
3000
  peg$savedPos = s0;
2797
- s0 = peg$f19(s3, s7);
3001
+ s0 = peg$f20(s3, s7);
2798
3002
  } else {
2799
3003
  peg$currPos = s0;
2800
3004
  s0 = peg$FAILED;
@@ -2816,13 +3020,13 @@ function peg$parse(input, options) {
2816
3020
  function peg$parseMain() {
2817
3021
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2818
3022
  s0 = peg$currPos;
2819
- if (input.substr(peg$currPos, 4) === peg$c21) {
2820
- s1 = peg$c21;
3023
+ if (input.substr(peg$currPos, 4) === peg$c22) {
3024
+ s1 = peg$c22;
2821
3025
  peg$currPos += 4;
2822
3026
  } else {
2823
3027
  s1 = peg$FAILED;
2824
3028
  if (peg$silentFails === 0) {
2825
- peg$fail(peg$e24);
3029
+ peg$fail(peg$e25);
2826
3030
  }
2827
3031
  }
2828
3032
  if (s1 !== peg$FAILED) {
@@ -2857,7 +3061,7 @@ function peg$parse(input, options) {
2857
3061
  }
2858
3062
  if (s9 !== peg$FAILED) {
2859
3063
  peg$savedPos = s0;
2860
- s0 = peg$f20(s3, s7);
3064
+ s0 = peg$f21(s3, s7);
2861
3065
  } else {
2862
3066
  peg$currPos = s0;
2863
3067
  s0 = peg$FAILED;
@@ -2879,13 +3083,13 @@ function peg$parse(input, options) {
2879
3083
  function peg$parseFooter() {
2880
3084
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2881
3085
  s0 = peg$currPos;
2882
- if (input.substr(peg$currPos, 6) === peg$c22) {
2883
- s1 = peg$c22;
3086
+ if (input.substr(peg$currPos, 6) === peg$c23) {
3087
+ s1 = peg$c23;
2884
3088
  peg$currPos += 6;
2885
3089
  } else {
2886
3090
  s1 = peg$FAILED;
2887
3091
  if (peg$silentFails === 0) {
2888
- peg$fail(peg$e25);
3092
+ peg$fail(peg$e26);
2889
3093
  }
2890
3094
  }
2891
3095
  if (s1 !== peg$FAILED) {
@@ -2920,7 +3124,7 @@ function peg$parse(input, options) {
2920
3124
  }
2921
3125
  if (s9 !== peg$FAILED) {
2922
3126
  peg$savedPos = s0;
2923
- s0 = peg$f21(s3, s7);
3127
+ s0 = peg$f22(s3, s7);
2924
3128
  } else {
2925
3129
  peg$currPos = s0;
2926
3130
  s0 = peg$FAILED;
@@ -2942,13 +3146,13 @@ function peg$parse(input, options) {
2942
3146
  function peg$parseSidebar() {
2943
3147
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2944
3148
  s0 = peg$currPos;
2945
- if (input.substr(peg$currPos, 7) === peg$c23) {
2946
- s1 = peg$c23;
3149
+ if (input.substr(peg$currPos, 7) === peg$c24) {
3150
+ s1 = peg$c24;
2947
3151
  peg$currPos += 7;
2948
3152
  } else {
2949
3153
  s1 = peg$FAILED;
2950
3154
  if (peg$silentFails === 0) {
2951
- peg$fail(peg$e26);
3155
+ peg$fail(peg$e27);
2952
3156
  }
2953
3157
  }
2954
3158
  if (s1 !== peg$FAILED) {
@@ -2983,7 +3187,7 @@ function peg$parse(input, options) {
2983
3187
  }
2984
3188
  if (s9 !== peg$FAILED) {
2985
3189
  peg$savedPos = s0;
2986
- s0 = peg$f22(s3, s7);
3190
+ s0 = peg$f23(s3, s7);
2987
3191
  } else {
2988
3192
  peg$currPos = s0;
2989
3193
  s0 = peg$FAILED;
@@ -3005,13 +3209,13 @@ function peg$parse(input, options) {
3005
3209
  function peg$parseRow() {
3006
3210
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3007
3211
  s0 = peg$currPos;
3008
- if (input.substr(peg$currPos, 3) === peg$c24) {
3009
- s1 = peg$c24;
3212
+ if (input.substr(peg$currPos, 3) === peg$c25) {
3213
+ s1 = peg$c25;
3010
3214
  peg$currPos += 3;
3011
3215
  } else {
3012
3216
  s1 = peg$FAILED;
3013
3217
  if (peg$silentFails === 0) {
3014
- peg$fail(peg$e27);
3218
+ peg$fail(peg$e28);
3015
3219
  }
3016
3220
  }
3017
3221
  if (s1 !== peg$FAILED) {
@@ -3046,7 +3250,7 @@ function peg$parse(input, options) {
3046
3250
  }
3047
3251
  if (s9 !== peg$FAILED) {
3048
3252
  peg$savedPos = s0;
3049
- s0 = peg$f23(s3, s7);
3253
+ s0 = peg$f24(s3, s7);
3050
3254
  } else {
3051
3255
  peg$currPos = s0;
3052
3256
  s0 = peg$FAILED;
@@ -3068,13 +3272,13 @@ function peg$parse(input, options) {
3068
3272
  function peg$parseCol() {
3069
3273
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3070
3274
  s0 = peg$currPos;
3071
- if (input.substr(peg$currPos, 3) === peg$c25) {
3072
- s1 = peg$c25;
3275
+ if (input.substr(peg$currPos, 3) === peg$c26) {
3276
+ s1 = peg$c26;
3073
3277
  peg$currPos += 3;
3074
3278
  } else {
3075
3279
  s1 = peg$FAILED;
3076
3280
  if (peg$silentFails === 0) {
3077
- peg$fail(peg$e28);
3281
+ peg$fail(peg$e29);
3078
3282
  }
3079
3283
  }
3080
3284
  if (s1 !== peg$FAILED) {
@@ -3109,7 +3313,7 @@ function peg$parse(input, options) {
3109
3313
  }
3110
3314
  if (s9 !== peg$FAILED) {
3111
3315
  peg$savedPos = s0;
3112
- s0 = peg$f24(s3, s7);
3316
+ s0 = peg$f25(s3, s7);
3113
3317
  } else {
3114
3318
  peg$currPos = s0;
3115
3319
  s0 = peg$FAILED;
@@ -3131,13 +3335,13 @@ function peg$parse(input, options) {
3131
3335
  function peg$parseStack() {
3132
3336
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3133
3337
  s0 = peg$currPos;
3134
- if (input.substr(peg$currPos, 5) === peg$c26) {
3135
- s1 = peg$c26;
3338
+ if (input.substr(peg$currPos, 5) === peg$c27) {
3339
+ s1 = peg$c27;
3136
3340
  peg$currPos += 5;
3137
3341
  } else {
3138
3342
  s1 = peg$FAILED;
3139
3343
  if (peg$silentFails === 0) {
3140
- peg$fail(peg$e29);
3344
+ peg$fail(peg$e30);
3141
3345
  }
3142
3346
  }
3143
3347
  if (s1 !== peg$FAILED) {
@@ -3172,7 +3376,7 @@ function peg$parse(input, options) {
3172
3376
  }
3173
3377
  if (s9 !== peg$FAILED) {
3174
3378
  peg$savedPos = s0;
3175
- s0 = peg$f25(s3, s7);
3379
+ s0 = peg$f26(s3, s7);
3176
3380
  } else {
3177
3381
  peg$currPos = s0;
3178
3382
  s0 = peg$FAILED;
@@ -3194,13 +3398,13 @@ function peg$parse(input, options) {
3194
3398
  function peg$parseRelative() {
3195
3399
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3196
3400
  s0 = peg$currPos;
3197
- if (input.substr(peg$currPos, 8) === peg$c27) {
3198
- s1 = peg$c27;
3401
+ if (input.substr(peg$currPos, 8) === peg$c28) {
3402
+ s1 = peg$c28;
3199
3403
  peg$currPos += 8;
3200
3404
  } else {
3201
3405
  s1 = peg$FAILED;
3202
3406
  if (peg$silentFails === 0) {
3203
- peg$fail(peg$e30);
3407
+ peg$fail(peg$e31);
3204
3408
  }
3205
3409
  }
3206
3410
  if (s1 !== peg$FAILED) {
@@ -3235,7 +3439,7 @@ function peg$parse(input, options) {
3235
3439
  }
3236
3440
  if (s9 !== peg$FAILED) {
3237
3441
  peg$savedPos = s0;
3238
- s0 = peg$f26(s3, s7);
3442
+ s0 = peg$f27(s3, s7);
3239
3443
  } else {
3240
3444
  peg$currPos = s0;
3241
3445
  s0 = peg$FAILED;
@@ -3274,13 +3478,13 @@ function peg$parse(input, options) {
3274
3478
  function peg$parseCard() {
3275
3479
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3276
3480
  s0 = peg$currPos;
3277
- if (input.substr(peg$currPos, 4) === peg$c28) {
3278
- s1 = peg$c28;
3481
+ if (input.substr(peg$currPos, 4) === peg$c29) {
3482
+ s1 = peg$c29;
3279
3483
  peg$currPos += 4;
3280
3484
  } else {
3281
3485
  s1 = peg$FAILED;
3282
3486
  if (peg$silentFails === 0) {
3283
- peg$fail(peg$e31);
3487
+ peg$fail(peg$e32);
3284
3488
  }
3285
3489
  }
3286
3490
  if (s1 !== peg$FAILED) {
@@ -3320,7 +3524,7 @@ function peg$parse(input, options) {
3320
3524
  }
3321
3525
  if (s11 !== peg$FAILED) {
3322
3526
  peg$savedPos = s0;
3323
- s0 = peg$f27(s3, s5, s9);
3527
+ s0 = peg$f28(s3, s5, s9);
3324
3528
  } else {
3325
3529
  peg$currPos = s0;
3326
3530
  s0 = peg$FAILED;
@@ -3342,13 +3546,13 @@ function peg$parse(input, options) {
3342
3546
  function peg$parseModal() {
3343
3547
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3344
3548
  s0 = peg$currPos;
3345
- if (input.substr(peg$currPos, 5) === peg$c29) {
3346
- s1 = peg$c29;
3549
+ if (input.substr(peg$currPos, 5) === peg$c30) {
3550
+ s1 = peg$c30;
3347
3551
  peg$currPos += 5;
3348
3552
  } else {
3349
3553
  s1 = peg$FAILED;
3350
3554
  if (peg$silentFails === 0) {
3351
- peg$fail(peg$e32);
3555
+ peg$fail(peg$e33);
3352
3556
  }
3353
3557
  }
3354
3558
  if (s1 !== peg$FAILED) {
@@ -3388,7 +3592,7 @@ function peg$parse(input, options) {
3388
3592
  }
3389
3593
  if (s11 !== peg$FAILED) {
3390
3594
  peg$savedPos = s0;
3391
- s0 = peg$f28(s3, s5, s9);
3595
+ s0 = peg$f29(s3, s5, s9);
3392
3596
  } else {
3393
3597
  peg$currPos = s0;
3394
3598
  s0 = peg$FAILED;
@@ -3410,13 +3614,13 @@ function peg$parse(input, options) {
3410
3614
  function peg$parseDrawer() {
3411
3615
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3412
3616
  s0 = peg$currPos;
3413
- if (input.substr(peg$currPos, 6) === peg$c30) {
3414
- s1 = peg$c30;
3617
+ if (input.substr(peg$currPos, 6) === peg$c31) {
3618
+ s1 = peg$c31;
3415
3619
  peg$currPos += 6;
3416
3620
  } else {
3417
3621
  s1 = peg$FAILED;
3418
3622
  if (peg$silentFails === 0) {
3419
- peg$fail(peg$e33);
3623
+ peg$fail(peg$e34);
3420
3624
  }
3421
3625
  }
3422
3626
  if (s1 !== peg$FAILED) {
@@ -3456,7 +3660,7 @@ function peg$parse(input, options) {
3456
3660
  }
3457
3661
  if (s11 !== peg$FAILED) {
3458
3662
  peg$savedPos = s0;
3459
- s0 = peg$f29(s3, s5, s9);
3663
+ s0 = peg$f30(s3, s5, s9);
3460
3664
  } else {
3461
3665
  peg$currPos = s0;
3462
3666
  s0 = peg$FAILED;
@@ -3478,13 +3682,13 @@ function peg$parse(input, options) {
3478
3682
  function peg$parseAccordion() {
3479
3683
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3480
3684
  s0 = peg$currPos;
3481
- if (input.substr(peg$currPos, 9) === peg$c31) {
3482
- s1 = peg$c31;
3685
+ if (input.substr(peg$currPos, 9) === peg$c32) {
3686
+ s1 = peg$c32;
3483
3687
  peg$currPos += 9;
3484
3688
  } else {
3485
3689
  s1 = peg$FAILED;
3486
3690
  if (peg$silentFails === 0) {
3487
- peg$fail(peg$e34);
3691
+ peg$fail(peg$e35);
3488
3692
  }
3489
3693
  }
3490
3694
  if (s1 !== peg$FAILED) {
@@ -3524,7 +3728,7 @@ function peg$parse(input, options) {
3524
3728
  }
3525
3729
  if (s11 !== peg$FAILED) {
3526
3730
  peg$savedPos = s0;
3527
- s0 = peg$f30(s3, s5, s9);
3731
+ s0 = peg$f31(s3, s5, s9);
3528
3732
  } else {
3529
3733
  peg$currPos = s0;
3530
3734
  s0 = peg$FAILED;
@@ -3546,13 +3750,13 @@ function peg$parse(input, options) {
3546
3750
  function peg$parseSection() {
3547
3751
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3548
3752
  s0 = peg$currPos;
3549
- if (input.substr(peg$currPos, 7) === peg$c32) {
3550
- s1 = peg$c32;
3753
+ if (input.substr(peg$currPos, 7) === peg$c33) {
3754
+ s1 = peg$c33;
3551
3755
  peg$currPos += 7;
3552
3756
  } else {
3553
3757
  s1 = peg$FAILED;
3554
3758
  if (peg$silentFails === 0) {
3555
- peg$fail(peg$e35);
3759
+ peg$fail(peg$e36);
3556
3760
  }
3557
3761
  }
3558
3762
  if (s1 !== peg$FAILED) {
@@ -3592,7 +3796,7 @@ function peg$parse(input, options) {
3592
3796
  }
3593
3797
  if (s11 !== peg$FAILED) {
3594
3798
  peg$savedPos = s0;
3595
- s0 = peg$f31(s3, s5, s9);
3799
+ s0 = peg$f32(s3, s5, s9);
3596
3800
  } else {
3597
3801
  peg$currPos = s0;
3598
3802
  s0 = peg$FAILED;
@@ -3709,13 +3913,13 @@ function peg$parse(input, options) {
3709
3913
  function peg$parseText() {
3710
3914
  let s0, s1, s2, s3, s4, s5;
3711
3915
  s0 = peg$currPos;
3712
- if (input.substr(peg$currPos, 4) === peg$c33) {
3713
- s1 = peg$c33;
3916
+ if (input.substr(peg$currPos, 4) === peg$c34) {
3917
+ s1 = peg$c34;
3714
3918
  peg$currPos += 4;
3715
3919
  } else {
3716
3920
  s1 = peg$FAILED;
3717
3921
  if (peg$silentFails === 0) {
3718
- peg$fail(peg$e36);
3922
+ peg$fail(peg$e37);
3719
3923
  }
3720
3924
  }
3721
3925
  if (s1 !== peg$FAILED) {
@@ -3728,7 +3932,7 @@ function peg$parse(input, options) {
3728
3932
  s5 = null;
3729
3933
  }
3730
3934
  peg$savedPos = s0;
3731
- s0 = peg$f32(s3, s5);
3935
+ s0 = peg$f33(s3, s5);
3732
3936
  } else {
3733
3937
  peg$currPos = s0;
3734
3938
  s0 = peg$FAILED;
@@ -3742,13 +3946,13 @@ function peg$parse(input, options) {
3742
3946
  function peg$parseTitle() {
3743
3947
  let s0, s1, s2, s3, s4, s5;
3744
3948
  s0 = peg$currPos;
3745
- if (input.substr(peg$currPos, 5) === peg$c34) {
3746
- s1 = peg$c34;
3949
+ if (input.substr(peg$currPos, 5) === peg$c35) {
3950
+ s1 = peg$c35;
3747
3951
  peg$currPos += 5;
3748
3952
  } else {
3749
3953
  s1 = peg$FAILED;
3750
3954
  if (peg$silentFails === 0) {
3751
- peg$fail(peg$e37);
3955
+ peg$fail(peg$e38);
3752
3956
  }
3753
3957
  }
3754
3958
  if (s1 !== peg$FAILED) {
@@ -3761,7 +3965,7 @@ function peg$parse(input, options) {
3761
3965
  s5 = null;
3762
3966
  }
3763
3967
  peg$savedPos = s0;
3764
- s0 = peg$f33(s3, s5);
3968
+ s0 = peg$f34(s3, s5);
3765
3969
  } else {
3766
3970
  peg$currPos = s0;
3767
3971
  s0 = peg$FAILED;
@@ -3775,13 +3979,13 @@ function peg$parse(input, options) {
3775
3979
  function peg$parseLink() {
3776
3980
  let s0, s1, s2, s3, s4, s5;
3777
3981
  s0 = peg$currPos;
3778
- if (input.substr(peg$currPos, 4) === peg$c35) {
3779
- s1 = peg$c35;
3982
+ if (input.substr(peg$currPos, 4) === peg$c36) {
3983
+ s1 = peg$c36;
3780
3984
  peg$currPos += 4;
3781
3985
  } else {
3782
3986
  s1 = peg$FAILED;
3783
3987
  if (peg$silentFails === 0) {
3784
- peg$fail(peg$e38);
3988
+ peg$fail(peg$e39);
3785
3989
  }
3786
3990
  }
3787
3991
  if (s1 !== peg$FAILED) {
@@ -3794,7 +3998,7 @@ function peg$parse(input, options) {
3794
3998
  s5 = null;
3795
3999
  }
3796
4000
  peg$savedPos = s0;
3797
- s0 = peg$f34(s3, s5);
4001
+ s0 = peg$f35(s3, s5);
3798
4002
  } else {
3799
4003
  peg$currPos = s0;
3800
4004
  s0 = peg$FAILED;
@@ -3808,13 +4012,13 @@ function peg$parse(input, options) {
3808
4012
  function peg$parseButton() {
3809
4013
  let s0, s1, s2, s3, s4, s5;
3810
4014
  s0 = peg$currPos;
3811
- if (input.substr(peg$currPos, 6) === peg$c36) {
3812
- s1 = peg$c36;
4015
+ if (input.substr(peg$currPos, 6) === peg$c37) {
4016
+ s1 = peg$c37;
3813
4017
  peg$currPos += 6;
3814
4018
  } else {
3815
4019
  s1 = peg$FAILED;
3816
4020
  if (peg$silentFails === 0) {
3817
- peg$fail(peg$e39);
4021
+ peg$fail(peg$e40);
3818
4022
  }
3819
4023
  }
3820
4024
  if (s1 !== peg$FAILED) {
@@ -3827,7 +4031,7 @@ function peg$parse(input, options) {
3827
4031
  s5 = null;
3828
4032
  }
3829
4033
  peg$savedPos = s0;
3830
- s0 = peg$f35(s3, s5);
4034
+ s0 = peg$f36(s3, s5);
3831
4035
  } else {
3832
4036
  peg$currPos = s0;
3833
4037
  s0 = peg$FAILED;
@@ -3841,13 +4045,13 @@ function peg$parse(input, options) {
3841
4045
  function peg$parseInput() {
3842
4046
  let s0, s1, s2, s3, s4, s5;
3843
4047
  s0 = peg$currPos;
3844
- if (input.substr(peg$currPos, 5) === peg$c37) {
3845
- s1 = peg$c37;
4048
+ if (input.substr(peg$currPos, 5) === peg$c38) {
4049
+ s1 = peg$c38;
3846
4050
  peg$currPos += 5;
3847
4051
  } else {
3848
4052
  s1 = peg$FAILED;
3849
4053
  if (peg$silentFails === 0) {
3850
- peg$fail(peg$e40);
4054
+ peg$fail(peg$e41);
3851
4055
  }
3852
4056
  }
3853
4057
  if (s1 !== peg$FAILED) {
@@ -3862,7 +4066,7 @@ function peg$parse(input, options) {
3862
4066
  s5 = null;
3863
4067
  }
3864
4068
  peg$savedPos = s0;
3865
- s0 = peg$f36(s3, s5);
4069
+ s0 = peg$f37(s3, s5);
3866
4070
  } else {
3867
4071
  peg$currPos = s0;
3868
4072
  s0 = peg$FAILED;
@@ -3872,13 +4076,13 @@ function peg$parse(input, options) {
3872
4076
  function peg$parseTextarea() {
3873
4077
  let s0, s1, s2, s3, s4, s5;
3874
4078
  s0 = peg$currPos;
3875
- if (input.substr(peg$currPos, 8) === peg$c38) {
3876
- s1 = peg$c38;
4079
+ if (input.substr(peg$currPos, 8) === peg$c39) {
4080
+ s1 = peg$c39;
3877
4081
  peg$currPos += 8;
3878
4082
  } else {
3879
4083
  s1 = peg$FAILED;
3880
4084
  if (peg$silentFails === 0) {
3881
- peg$fail(peg$e41);
4085
+ peg$fail(peg$e42);
3882
4086
  }
3883
4087
  }
3884
4088
  if (s1 !== peg$FAILED) {
@@ -3893,7 +4097,7 @@ function peg$parse(input, options) {
3893
4097
  s5 = null;
3894
4098
  }
3895
4099
  peg$savedPos = s0;
3896
- s0 = peg$f37(s3, s5);
4100
+ s0 = peg$f38(s3, s5);
3897
4101
  } else {
3898
4102
  peg$currPos = s0;
3899
4103
  s0 = peg$FAILED;
@@ -3903,13 +4107,13 @@ function peg$parse(input, options) {
3903
4107
  function peg$parseSelect() {
3904
4108
  let s0, s1, s2, s3, s4, s5, s6, s7;
3905
4109
  s0 = peg$currPos;
3906
- if (input.substr(peg$currPos, 6) === peg$c39) {
3907
- s1 = peg$c39;
4110
+ if (input.substr(peg$currPos, 6) === peg$c40) {
4111
+ s1 = peg$c40;
3908
4112
  peg$currPos += 6;
3909
4113
  } else {
3910
4114
  s1 = peg$FAILED;
3911
4115
  if (peg$silentFails === 0) {
3912
- peg$fail(peg$e42);
4116
+ peg$fail(peg$e43);
3913
4117
  }
3914
4118
  }
3915
4119
  if (s1 !== peg$FAILED) {
@@ -3929,7 +4133,7 @@ function peg$parse(input, options) {
3929
4133
  s7 = null;
3930
4134
  }
3931
4135
  peg$savedPos = s0;
3932
- s0 = peg$f38(s3, s5, s7);
4136
+ s0 = peg$f39(s3, s5, s7);
3933
4137
  } else {
3934
4138
  peg$currPos = s0;
3935
4139
  s0 = peg$FAILED;
@@ -3939,13 +4143,13 @@ function peg$parse(input, options) {
3939
4143
  function peg$parseCheckbox() {
3940
4144
  let s0, s1, s2, s3, s4, s5;
3941
4145
  s0 = peg$currPos;
3942
- if (input.substr(peg$currPos, 8) === peg$c40) {
3943
- s1 = peg$c40;
4146
+ if (input.substr(peg$currPos, 8) === peg$c41) {
4147
+ s1 = peg$c41;
3944
4148
  peg$currPos += 8;
3945
4149
  } else {
3946
4150
  s1 = peg$FAILED;
3947
4151
  if (peg$silentFails === 0) {
3948
- peg$fail(peg$e43);
4152
+ peg$fail(peg$e44);
3949
4153
  }
3950
4154
  }
3951
4155
  if (s1 !== peg$FAILED) {
@@ -3960,7 +4164,7 @@ function peg$parse(input, options) {
3960
4164
  s5 = null;
3961
4165
  }
3962
4166
  peg$savedPos = s0;
3963
- s0 = peg$f39(s3, s5);
4167
+ s0 = peg$f40(s3, s5);
3964
4168
  } else {
3965
4169
  peg$currPos = s0;
3966
4170
  s0 = peg$FAILED;
@@ -3970,13 +4174,13 @@ function peg$parse(input, options) {
3970
4174
  function peg$parseRadio() {
3971
4175
  let s0, s1, s2, s3, s4, s5;
3972
4176
  s0 = peg$currPos;
3973
- if (input.substr(peg$currPos, 5) === peg$c41) {
3974
- s1 = peg$c41;
4177
+ if (input.substr(peg$currPos, 5) === peg$c42) {
4178
+ s1 = peg$c42;
3975
4179
  peg$currPos += 5;
3976
4180
  } else {
3977
4181
  s1 = peg$FAILED;
3978
4182
  if (peg$silentFails === 0) {
3979
- peg$fail(peg$e44);
4183
+ peg$fail(peg$e45);
3980
4184
  }
3981
4185
  }
3982
4186
  if (s1 !== peg$FAILED) {
@@ -3991,7 +4195,7 @@ function peg$parse(input, options) {
3991
4195
  s5 = null;
3992
4196
  }
3993
4197
  peg$savedPos = s0;
3994
- s0 = peg$f40(s3, s5);
4198
+ s0 = peg$f41(s3, s5);
3995
4199
  } else {
3996
4200
  peg$currPos = s0;
3997
4201
  s0 = peg$FAILED;
@@ -4001,13 +4205,13 @@ function peg$parse(input, options) {
4001
4205
  function peg$parseSwitch() {
4002
4206
  let s0, s1, s2, s3, s4, s5;
4003
4207
  s0 = peg$currPos;
4004
- if (input.substr(peg$currPos, 6) === peg$c42) {
4005
- s1 = peg$c42;
4208
+ if (input.substr(peg$currPos, 6) === peg$c43) {
4209
+ s1 = peg$c43;
4006
4210
  peg$currPos += 6;
4007
4211
  } else {
4008
4212
  s1 = peg$FAILED;
4009
4213
  if (peg$silentFails === 0) {
4010
- peg$fail(peg$e45);
4214
+ peg$fail(peg$e46);
4011
4215
  }
4012
4216
  }
4013
4217
  if (s1 !== peg$FAILED) {
@@ -4022,7 +4226,7 @@ function peg$parse(input, options) {
4022
4226
  s5 = null;
4023
4227
  }
4024
4228
  peg$savedPos = s0;
4025
- s0 = peg$f41(s3, s5);
4229
+ s0 = peg$f42(s3, s5);
4026
4230
  } else {
4027
4231
  peg$currPos = s0;
4028
4232
  s0 = peg$FAILED;
@@ -4032,13 +4236,13 @@ function peg$parse(input, options) {
4032
4236
  function peg$parseSlider() {
4033
4237
  let s0, s1, s2, s3, s4, s5;
4034
4238
  s0 = peg$currPos;
4035
- if (input.substr(peg$currPos, 6) === peg$c43) {
4036
- s1 = peg$c43;
4239
+ if (input.substr(peg$currPos, 6) === peg$c44) {
4240
+ s1 = peg$c44;
4037
4241
  peg$currPos += 6;
4038
4242
  } else {
4039
4243
  s1 = peg$FAILED;
4040
4244
  if (peg$silentFails === 0) {
4041
- peg$fail(peg$e46);
4245
+ peg$fail(peg$e47);
4042
4246
  }
4043
4247
  }
4044
4248
  if (s1 !== peg$FAILED) {
@@ -4053,7 +4257,7 @@ function peg$parse(input, options) {
4053
4257
  s5 = null;
4054
4258
  }
4055
4259
  peg$savedPos = s0;
4056
- s0 = peg$f42(s3, s5);
4260
+ s0 = peg$f43(s3, s5);
4057
4261
  } else {
4058
4262
  peg$currPos = s0;
4059
4263
  s0 = peg$FAILED;
@@ -4063,13 +4267,13 @@ function peg$parse(input, options) {
4063
4267
  function peg$parseImage() {
4064
4268
  let s0, s1, s2, s3, s4, s5;
4065
4269
  s0 = peg$currPos;
4066
- if (input.substr(peg$currPos, 5) === peg$c44) {
4067
- s1 = peg$c44;
4270
+ if (input.substr(peg$currPos, 5) === peg$c45) {
4271
+ s1 = peg$c45;
4068
4272
  peg$currPos += 5;
4069
4273
  } else {
4070
4274
  s1 = peg$FAILED;
4071
4275
  if (peg$silentFails === 0) {
4072
- peg$fail(peg$e47);
4276
+ peg$fail(peg$e48);
4073
4277
  }
4074
4278
  }
4075
4279
  if (s1 !== peg$FAILED) {
@@ -4084,7 +4288,7 @@ function peg$parse(input, options) {
4084
4288
  s5 = null;
4085
4289
  }
4086
4290
  peg$savedPos = s0;
4087
- s0 = peg$f43(s3, s5);
4291
+ s0 = peg$f44(s3, s5);
4088
4292
  } else {
4089
4293
  peg$currPos = s0;
4090
4294
  s0 = peg$FAILED;
@@ -4094,13 +4298,13 @@ function peg$parse(input, options) {
4094
4298
  function peg$parsePlaceholder() {
4095
4299
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
4096
4300
  s0 = peg$currPos;
4097
- if (input.substr(peg$currPos, 11) === peg$c45) {
4098
- s1 = peg$c45;
4301
+ if (input.substr(peg$currPos, 11) === peg$c46) {
4302
+ s1 = peg$c46;
4099
4303
  peg$currPos += 11;
4100
4304
  } else {
4101
4305
  s1 = peg$FAILED;
4102
4306
  if (peg$silentFails === 0) {
4103
- peg$fail(peg$e48);
4307
+ peg$fail(peg$e49);
4104
4308
  }
4105
4309
  }
4106
4310
  if (s1 !== peg$FAILED) {
@@ -4158,7 +4362,7 @@ function peg$parse(input, options) {
4158
4362
  s7 = null;
4159
4363
  }
4160
4364
  peg$savedPos = s0;
4161
- s0 = peg$f44(s3, s5, s7);
4365
+ s0 = peg$f45(s3, s5, s7);
4162
4366
  } else {
4163
4367
  peg$currPos = s0;
4164
4368
  s0 = peg$FAILED;
@@ -4168,13 +4372,13 @@ function peg$parse(input, options) {
4168
4372
  function peg$parseAvatar() {
4169
4373
  let s0, s1, s2, s3, s4, s5;
4170
4374
  s0 = peg$currPos;
4171
- if (input.substr(peg$currPos, 6) === peg$c46) {
4172
- s1 = peg$c46;
4375
+ if (input.substr(peg$currPos, 6) === peg$c47) {
4376
+ s1 = peg$c47;
4173
4377
  peg$currPos += 6;
4174
4378
  } else {
4175
4379
  s1 = peg$FAILED;
4176
4380
  if (peg$silentFails === 0) {
4177
- peg$fail(peg$e49);
4381
+ peg$fail(peg$e50);
4178
4382
  }
4179
4383
  }
4180
4384
  if (s1 !== peg$FAILED) {
@@ -4189,7 +4393,7 @@ function peg$parse(input, options) {
4189
4393
  s5 = null;
4190
4394
  }
4191
4395
  peg$savedPos = s0;
4192
- s0 = peg$f45(s3, s5);
4396
+ s0 = peg$f46(s3, s5);
4193
4397
  } else {
4194
4398
  peg$currPos = s0;
4195
4399
  s0 = peg$FAILED;
@@ -4199,13 +4403,13 @@ function peg$parse(input, options) {
4199
4403
  function peg$parseBadge() {
4200
4404
  let s0, s1, s2, s3, s4, s5;
4201
4405
  s0 = peg$currPos;
4202
- if (input.substr(peg$currPos, 5) === peg$c47) {
4203
- s1 = peg$c47;
4406
+ if (input.substr(peg$currPos, 5) === peg$c48) {
4407
+ s1 = peg$c48;
4204
4408
  peg$currPos += 5;
4205
4409
  } else {
4206
4410
  s1 = peg$FAILED;
4207
4411
  if (peg$silentFails === 0) {
4208
- peg$fail(peg$e50);
4412
+ peg$fail(peg$e51);
4209
4413
  }
4210
4414
  }
4211
4415
  if (s1 !== peg$FAILED) {
@@ -4218,7 +4422,7 @@ function peg$parse(input, options) {
4218
4422
  s5 = null;
4219
4423
  }
4220
4424
  peg$savedPos = s0;
4221
- s0 = peg$f46(s3, s5);
4425
+ s0 = peg$f47(s3, s5);
4222
4426
  } else {
4223
4427
  peg$currPos = s0;
4224
4428
  s0 = peg$FAILED;
@@ -4232,13 +4436,13 @@ function peg$parse(input, options) {
4232
4436
  function peg$parseIcon() {
4233
4437
  let s0, s1, s2, s3, s4, s5;
4234
4438
  s0 = peg$currPos;
4235
- if (input.substr(peg$currPos, 4) === peg$c48) {
4236
- s1 = peg$c48;
4439
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4440
+ s1 = peg$c49;
4237
4441
  peg$currPos += 4;
4238
4442
  } else {
4239
4443
  s1 = peg$FAILED;
4240
4444
  if (peg$silentFails === 0) {
4241
- peg$fail(peg$e51);
4445
+ peg$fail(peg$e52);
4242
4446
  }
4243
4447
  }
4244
4448
  if (s1 !== peg$FAILED) {
@@ -4251,7 +4455,7 @@ function peg$parse(input, options) {
4251
4455
  s5 = null;
4252
4456
  }
4253
4457
  peg$savedPos = s0;
4254
- s0 = peg$f47(s3, s5);
4458
+ s0 = peg$f48(s3, s5);
4255
4459
  } else {
4256
4460
  peg$currPos = s0;
4257
4461
  s0 = peg$FAILED;
@@ -4265,13 +4469,13 @@ function peg$parse(input, options) {
4265
4469
  function peg$parseTable() {
4266
4470
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4267
4471
  s0 = peg$currPos;
4268
- if (input.substr(peg$currPos, 5) === peg$c49) {
4269
- s1 = peg$c49;
4472
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4473
+ s1 = peg$c50;
4270
4474
  peg$currPos += 5;
4271
4475
  } else {
4272
4476
  s1 = peg$FAILED;
4273
4477
  if (peg$silentFails === 0) {
4274
- peg$fail(peg$e52);
4478
+ peg$fail(peg$e53);
4275
4479
  }
4276
4480
  }
4277
4481
  if (s1 !== peg$FAILED) {
@@ -4284,7 +4488,7 @@ function peg$parse(input, options) {
4284
4488
  s5 = null;
4285
4489
  }
4286
4490
  peg$savedPos = s0;
4287
- s0 = peg$f48(s3, s5);
4491
+ s0 = peg$f49(s3, s5);
4288
4492
  } else {
4289
4493
  peg$currPos = s0;
4290
4494
  s0 = peg$FAILED;
@@ -4295,13 +4499,13 @@ function peg$parse(input, options) {
4295
4499
  }
4296
4500
  if (s0 === peg$FAILED) {
4297
4501
  s0 = peg$currPos;
4298
- if (input.substr(peg$currPos, 5) === peg$c49) {
4299
- s1 = peg$c49;
4502
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4503
+ s1 = peg$c50;
4300
4504
  peg$currPos += 5;
4301
4505
  } else {
4302
4506
  s1 = peg$FAILED;
4303
4507
  if (peg$silentFails === 0) {
4304
- peg$fail(peg$e52);
4508
+ peg$fail(peg$e53);
4305
4509
  }
4306
4510
  }
4307
4511
  if (s1 !== peg$FAILED) {
@@ -4335,7 +4539,7 @@ function peg$parse(input, options) {
4335
4539
  }
4336
4540
  if (s9 !== peg$FAILED) {
4337
4541
  peg$savedPos = s0;
4338
- s0 = peg$f49(s3, s7);
4542
+ s0 = peg$f50(s3, s7);
4339
4543
  } else {
4340
4544
  peg$currPos = s0;
4341
4545
  s0 = peg$FAILED;
@@ -4355,12 +4559,12 @@ function peg$parse(input, options) {
4355
4559
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
4356
4560
  s0 = peg$currPos;
4357
4561
  if (input.charCodeAt(peg$currPos) === 91) {
4358
- s1 = peg$c50;
4562
+ s1 = peg$c51;
4359
4563
  peg$currPos++;
4360
4564
  } else {
4361
4565
  s1 = peg$FAILED;
4362
4566
  if (peg$silentFails === 0) {
4363
- peg$fail(peg$e53);
4567
+ peg$fail(peg$e54);
4364
4568
  }
4365
4569
  }
4366
4570
  if (s1 !== peg$FAILED) {
@@ -4436,17 +4640,17 @@ function peg$parse(input, options) {
4436
4640
  }
4437
4641
  s7 = peg$parse_();
4438
4642
  if (input.charCodeAt(peg$currPos) === 93) {
4439
- s8 = peg$c51;
4643
+ s8 = peg$c52;
4440
4644
  peg$currPos++;
4441
4645
  } else {
4442
4646
  s8 = peg$FAILED;
4443
4647
  if (peg$silentFails === 0) {
4444
- peg$fail(peg$e54);
4648
+ peg$fail(peg$e55);
4445
4649
  }
4446
4650
  }
4447
4651
  if (s8 !== peg$FAILED) {
4448
4652
  peg$savedPos = s0;
4449
- s0 = peg$f50(s3, s5);
4653
+ s0 = peg$f51(s3, s5);
4450
4654
  } else {
4451
4655
  peg$currPos = s0;
4452
4656
  s0 = peg$FAILED;
@@ -4489,20 +4693,20 @@ function peg$parse(input, options) {
4489
4693
  }
4490
4694
  }
4491
4695
  peg$savedPos = s0;
4492
- s1 = peg$f51(s1);
4696
+ s1 = peg$f52(s1);
4493
4697
  s0 = s1;
4494
4698
  return s0;
4495
4699
  }
4496
4700
  function peg$parseTableRow() {
4497
4701
  let s0, s1, s2, s3;
4498
4702
  s0 = peg$currPos;
4499
- if (input.substr(peg$currPos, 7) === peg$c52) {
4500
- s1 = peg$c52;
4703
+ if (input.substr(peg$currPos, 7) === peg$c53) {
4704
+ s1 = peg$c53;
4501
4705
  peg$currPos += 7;
4502
4706
  } else {
4503
4707
  s1 = peg$FAILED;
4504
4708
  if (peg$silentFails === 0) {
4505
- peg$fail(peg$e55);
4709
+ peg$fail(peg$e56);
4506
4710
  }
4507
4711
  }
4508
4712
  if (s1 !== peg$FAILED) {
@@ -4510,7 +4714,7 @@ function peg$parse(input, options) {
4510
4714
  s3 = peg$parseArray();
4511
4715
  if (s3 !== peg$FAILED) {
4512
4716
  peg$savedPos = s0;
4513
- s0 = peg$f52(s3);
4717
+ s0 = peg$f53(s3);
4514
4718
  } else {
4515
4719
  peg$currPos = s0;
4516
4720
  s0 = peg$FAILED;
@@ -4521,13 +4725,13 @@ function peg$parse(input, options) {
4521
4725
  }
4522
4726
  if (s0 === peg$FAILED) {
4523
4727
  s0 = peg$currPos;
4524
- if (input.substr(peg$currPos, 3) === peg$c24) {
4525
- s1 = peg$c24;
4728
+ if (input.substr(peg$currPos, 3) === peg$c25) {
4729
+ s1 = peg$c25;
4526
4730
  peg$currPos += 3;
4527
4731
  } else {
4528
4732
  s1 = peg$FAILED;
4529
4733
  if (peg$silentFails === 0) {
4530
- peg$fail(peg$e27);
4734
+ peg$fail(peg$e28);
4531
4735
  }
4532
4736
  }
4533
4737
  if (s1 !== peg$FAILED) {
@@ -4535,7 +4739,7 @@ function peg$parse(input, options) {
4535
4739
  s3 = peg$parseArray();
4536
4740
  if (s3 !== peg$FAILED) {
4537
4741
  peg$savedPos = s0;
4538
- s0 = peg$f53(s3);
4742
+ s0 = peg$f54(s3);
4539
4743
  } else {
4540
4744
  peg$currPos = s0;
4541
4745
  s0 = peg$FAILED;
@@ -4549,7 +4753,7 @@ function peg$parse(input, options) {
4549
4753
  s1 = peg$parseComment();
4550
4754
  if (s1 !== peg$FAILED) {
4551
4755
  peg$savedPos = s0;
4552
- s1 = peg$f54();
4756
+ s1 = peg$f55();
4553
4757
  }
4554
4758
  s0 = s1;
4555
4759
  }
@@ -4559,13 +4763,13 @@ function peg$parse(input, options) {
4559
4763
  function peg$parseList() {
4560
4764
  let s0, s1, s2, s3, s4, s5, s6, s7;
4561
4765
  s0 = peg$currPos;
4562
- if (input.substr(peg$currPos, 4) === peg$c53) {
4563
- s1 = peg$c53;
4766
+ if (input.substr(peg$currPos, 4) === peg$c54) {
4767
+ s1 = peg$c54;
4564
4768
  peg$currPos += 4;
4565
4769
  } else {
4566
4770
  s1 = peg$FAILED;
4567
4771
  if (peg$silentFails === 0) {
4568
- peg$fail(peg$e56);
4772
+ peg$fail(peg$e57);
4569
4773
  }
4570
4774
  }
4571
4775
  if (s1 !== peg$FAILED) {
@@ -4585,7 +4789,7 @@ function peg$parse(input, options) {
4585
4789
  s7 = null;
4586
4790
  }
4587
4791
  peg$savedPos = s0;
4588
- s0 = peg$f55(s3, s5, s7);
4792
+ s0 = peg$f56(s3, s5, s7);
4589
4793
  } else {
4590
4794
  peg$currPos = s0;
4591
4795
  s0 = peg$FAILED;
@@ -4641,7 +4845,7 @@ function peg$parse(input, options) {
4641
4845
  }
4642
4846
  if (s4 !== peg$FAILED) {
4643
4847
  peg$savedPos = s0;
4644
- s0 = peg$f56(s3);
4848
+ s0 = peg$f57(s3);
4645
4849
  } else {
4646
4850
  peg$currPos = s0;
4647
4851
  s0 = peg$FAILED;
@@ -4655,13 +4859,13 @@ function peg$parse(input, options) {
4655
4859
  function peg$parseListItem() {
4656
4860
  let s0, s1, s2, s3, s4, s5, s6, s7;
4657
4861
  s0 = peg$currPos;
4658
- if (input.substr(peg$currPos, 4) === peg$c54) {
4659
- s1 = peg$c54;
4862
+ if (input.substr(peg$currPos, 4) === peg$c55) {
4863
+ s1 = peg$c55;
4660
4864
  peg$currPos += 4;
4661
4865
  } else {
4662
4866
  s1 = peg$FAILED;
4663
4867
  if (peg$silentFails === 0) {
4664
- peg$fail(peg$e57);
4868
+ peg$fail(peg$e58);
4665
4869
  }
4666
4870
  }
4667
4871
  if (s1 !== peg$FAILED) {
@@ -4679,7 +4883,7 @@ function peg$parse(input, options) {
4679
4883
  s7 = null;
4680
4884
  }
4681
4885
  peg$savedPos = s0;
4682
- s0 = peg$f57(s3, s5, s7);
4886
+ s0 = peg$f58(s3, s5, s7);
4683
4887
  } else {
4684
4888
  peg$currPos = s0;
4685
4889
  s0 = peg$FAILED;
@@ -4693,7 +4897,7 @@ function peg$parse(input, options) {
4693
4897
  s1 = peg$parseComment();
4694
4898
  if (s1 !== peg$FAILED) {
4695
4899
  peg$savedPos = s0;
4696
- s1 = peg$f58();
4900
+ s1 = peg$f59();
4697
4901
  }
4698
4902
  s0 = s1;
4699
4903
  }
@@ -4702,13 +4906,13 @@ function peg$parse(input, options) {
4702
4906
  function peg$parseAlert() {
4703
4907
  let s0, s1, s2, s3, s4, s5;
4704
4908
  s0 = peg$currPos;
4705
- if (input.substr(peg$currPos, 5) === peg$c55) {
4706
- s1 = peg$c55;
4909
+ if (input.substr(peg$currPos, 5) === peg$c56) {
4910
+ s1 = peg$c56;
4707
4911
  peg$currPos += 5;
4708
4912
  } else {
4709
4913
  s1 = peg$FAILED;
4710
4914
  if (peg$silentFails === 0) {
4711
- peg$fail(peg$e58);
4915
+ peg$fail(peg$e59);
4712
4916
  }
4713
4917
  }
4714
4918
  if (s1 !== peg$FAILED) {
@@ -4721,7 +4925,7 @@ function peg$parse(input, options) {
4721
4925
  s5 = null;
4722
4926
  }
4723
4927
  peg$savedPos = s0;
4724
- s0 = peg$f59(s3, s5);
4928
+ s0 = peg$f60(s3, s5);
4725
4929
  } else {
4726
4930
  peg$currPos = s0;
4727
4931
  s0 = peg$FAILED;
@@ -4735,13 +4939,13 @@ function peg$parse(input, options) {
4735
4939
  function peg$parseToast() {
4736
4940
  let s0, s1, s2, s3, s4, s5;
4737
4941
  s0 = peg$currPos;
4738
- if (input.substr(peg$currPos, 5) === peg$c56) {
4739
- s1 = peg$c56;
4942
+ if (input.substr(peg$currPos, 5) === peg$c57) {
4943
+ s1 = peg$c57;
4740
4944
  peg$currPos += 5;
4741
4945
  } else {
4742
4946
  s1 = peg$FAILED;
4743
4947
  if (peg$silentFails === 0) {
4744
- peg$fail(peg$e59);
4948
+ peg$fail(peg$e60);
4745
4949
  }
4746
4950
  }
4747
4951
  if (s1 !== peg$FAILED) {
@@ -4754,7 +4958,7 @@ function peg$parse(input, options) {
4754
4958
  s5 = null;
4755
4959
  }
4756
4960
  peg$savedPos = s0;
4757
- s0 = peg$f60(s3, s5);
4961
+ s0 = peg$f61(s3, s5);
4758
4962
  } else {
4759
4963
  peg$currPos = s0;
4760
4964
  s0 = peg$FAILED;
@@ -4768,13 +4972,13 @@ function peg$parse(input, options) {
4768
4972
  function peg$parseProgress() {
4769
4973
  let s0, s1, s2, s3;
4770
4974
  s0 = peg$currPos;
4771
- if (input.substr(peg$currPos, 8) === peg$c57) {
4772
- s1 = peg$c57;
4975
+ if (input.substr(peg$currPos, 8) === peg$c58) {
4976
+ s1 = peg$c58;
4773
4977
  peg$currPos += 8;
4774
4978
  } else {
4775
4979
  s1 = peg$FAILED;
4776
4980
  if (peg$silentFails === 0) {
4777
- peg$fail(peg$e60);
4981
+ peg$fail(peg$e61);
4778
4982
  }
4779
4983
  }
4780
4984
  if (s1 !== peg$FAILED) {
@@ -4784,7 +4988,7 @@ function peg$parse(input, options) {
4784
4988
  s3 = null;
4785
4989
  }
4786
4990
  peg$savedPos = s0;
4787
- s0 = peg$f61(s3);
4991
+ s0 = peg$f62(s3);
4788
4992
  } else {
4789
4993
  peg$currPos = s0;
4790
4994
  s0 = peg$FAILED;
@@ -4794,13 +4998,13 @@ function peg$parse(input, options) {
4794
4998
  function peg$parseSpinner() {
4795
4999
  let s0, s1, s2, s3, s4, s5;
4796
5000
  s0 = peg$currPos;
4797
- if (input.substr(peg$currPos, 7) === peg$c58) {
4798
- s1 = peg$c58;
5001
+ if (input.substr(peg$currPos, 7) === peg$c59) {
5002
+ s1 = peg$c59;
4799
5003
  peg$currPos += 7;
4800
5004
  } else {
4801
5005
  s1 = peg$FAILED;
4802
5006
  if (peg$silentFails === 0) {
4803
- peg$fail(peg$e61);
5007
+ peg$fail(peg$e62);
4804
5008
  }
4805
5009
  }
4806
5010
  if (s1 !== peg$FAILED) {
@@ -4815,7 +5019,7 @@ function peg$parse(input, options) {
4815
5019
  s5 = null;
4816
5020
  }
4817
5021
  peg$savedPos = s0;
4818
- s0 = peg$f62(s3, s5);
5022
+ s0 = peg$f63(s3, s5);
4819
5023
  } else {
4820
5024
  peg$currPos = s0;
4821
5025
  s0 = peg$FAILED;
@@ -4825,13 +5029,13 @@ function peg$parse(input, options) {
4825
5029
  function peg$parseTooltip() {
4826
5030
  let s0, s1, s2, s3, s4, s5;
4827
5031
  s0 = peg$currPos;
4828
- if (input.substr(peg$currPos, 7) === peg$c59) {
4829
- s1 = peg$c59;
5032
+ if (input.substr(peg$currPos, 7) === peg$c60) {
5033
+ s1 = peg$c60;
4830
5034
  peg$currPos += 7;
4831
5035
  } else {
4832
5036
  s1 = peg$FAILED;
4833
5037
  if (peg$silentFails === 0) {
4834
- peg$fail(peg$e62);
5038
+ peg$fail(peg$e63);
4835
5039
  }
4836
5040
  }
4837
5041
  if (s1 !== peg$FAILED) {
@@ -4844,7 +5048,7 @@ function peg$parse(input, options) {
4844
5048
  s5 = null;
4845
5049
  }
4846
5050
  peg$savedPos = s0;
4847
- s0 = peg$f63(s3, s5);
5051
+ s0 = peg$f64(s3, s5);
4848
5052
  } else {
4849
5053
  peg$currPos = s0;
4850
5054
  s0 = peg$FAILED;
@@ -4858,13 +5062,13 @@ function peg$parse(input, options) {
4858
5062
  function peg$parsePopover() {
4859
5063
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
4860
5064
  s0 = peg$currPos;
4861
- if (input.substr(peg$currPos, 7) === peg$c60) {
4862
- s1 = peg$c60;
5065
+ if (input.substr(peg$currPos, 7) === peg$c61) {
5066
+ s1 = peg$c61;
4863
5067
  peg$currPos += 7;
4864
5068
  } else {
4865
5069
  s1 = peg$FAILED;
4866
5070
  if (peg$silentFails === 0) {
4867
- peg$fail(peg$e63);
5071
+ peg$fail(peg$e64);
4868
5072
  }
4869
5073
  }
4870
5074
  if (s1 !== peg$FAILED) {
@@ -4904,7 +5108,7 @@ function peg$parse(input, options) {
4904
5108
  }
4905
5109
  if (s11 !== peg$FAILED) {
4906
5110
  peg$savedPos = s0;
4907
- s0 = peg$f64(s3, s5, s9);
5111
+ s0 = peg$f65(s3, s5, s9);
4908
5112
  } else {
4909
5113
  peg$currPos = s0;
4910
5114
  s0 = peg$FAILED;
@@ -4926,13 +5130,13 @@ function peg$parse(input, options) {
4926
5130
  function peg$parseDropdown() {
4927
5131
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4928
5132
  s0 = peg$currPos;
4929
- if (input.substr(peg$currPos, 8) === peg$c61) {
4930
- s1 = peg$c61;
5133
+ if (input.substr(peg$currPos, 8) === peg$c62) {
5134
+ s1 = peg$c62;
4931
5135
  peg$currPos += 8;
4932
5136
  } else {
4933
5137
  s1 = peg$FAILED;
4934
5138
  if (peg$silentFails === 0) {
4935
- peg$fail(peg$e64);
5139
+ peg$fail(peg$e65);
4936
5140
  }
4937
5141
  }
4938
5142
  if (s1 !== peg$FAILED) {
@@ -4945,7 +5149,7 @@ function peg$parse(input, options) {
4945
5149
  s5 = null;
4946
5150
  }
4947
5151
  peg$savedPos = s0;
4948
- s0 = peg$f65(s3, s5);
5152
+ s0 = peg$f66(s3, s5);
4949
5153
  } else {
4950
5154
  peg$currPos = s0;
4951
5155
  s0 = peg$FAILED;
@@ -4956,13 +5160,13 @@ function peg$parse(input, options) {
4956
5160
  }
4957
5161
  if (s0 === peg$FAILED) {
4958
5162
  s0 = peg$currPos;
4959
- if (input.substr(peg$currPos, 8) === peg$c61) {
4960
- s1 = peg$c61;
5163
+ if (input.substr(peg$currPos, 8) === peg$c62) {
5164
+ s1 = peg$c62;
4961
5165
  peg$currPos += 8;
4962
5166
  } else {
4963
5167
  s1 = peg$FAILED;
4964
5168
  if (peg$silentFails === 0) {
4965
- peg$fail(peg$e64);
5169
+ peg$fail(peg$e65);
4966
5170
  }
4967
5171
  }
4968
5172
  if (s1 !== peg$FAILED) {
@@ -4996,7 +5200,7 @@ function peg$parse(input, options) {
4996
5200
  }
4997
5201
  if (s9 !== peg$FAILED) {
4998
5202
  peg$savedPos = s0;
4999
- s0 = peg$f66(s3, s7);
5203
+ s0 = peg$f67(s3, s7);
5000
5204
  } else {
5001
5205
  peg$currPos = s0;
5002
5206
  s0 = peg$FAILED;
@@ -5040,20 +5244,20 @@ function peg$parse(input, options) {
5040
5244
  }
5041
5245
  }
5042
5246
  peg$savedPos = s0;
5043
- s1 = peg$f67(s1);
5247
+ s1 = peg$f68(s1);
5044
5248
  s0 = s1;
5045
5249
  return s0;
5046
5250
  }
5047
5251
  function peg$parseDropdownItem() {
5048
5252
  let s0, s1, s2, s3, s4, s5;
5049
5253
  s0 = peg$currPos;
5050
- if (input.substr(peg$currPos, 4) === peg$c54) {
5051
- s1 = peg$c54;
5254
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5255
+ s1 = peg$c55;
5052
5256
  peg$currPos += 4;
5053
5257
  } else {
5054
5258
  s1 = peg$FAILED;
5055
5259
  if (peg$silentFails === 0) {
5056
- peg$fail(peg$e57);
5260
+ peg$fail(peg$e58);
5057
5261
  }
5058
5262
  }
5059
5263
  if (s1 !== peg$FAILED) {
@@ -5066,7 +5270,7 @@ function peg$parse(input, options) {
5066
5270
  s5 = null;
5067
5271
  }
5068
5272
  peg$savedPos = s0;
5069
- s0 = peg$f68(s3, s5);
5273
+ s0 = peg$f69(s3, s5);
5070
5274
  } else {
5071
5275
  peg$currPos = s0;
5072
5276
  s0 = peg$FAILED;
@@ -5077,18 +5281,18 @@ function peg$parse(input, options) {
5077
5281
  }
5078
5282
  if (s0 === peg$FAILED) {
5079
5283
  s0 = peg$currPos;
5080
- if (input.substr(peg$currPos, 7) === peg$c62) {
5081
- s1 = peg$c62;
5284
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5285
+ s1 = peg$c63;
5082
5286
  peg$currPos += 7;
5083
5287
  } else {
5084
5288
  s1 = peg$FAILED;
5085
5289
  if (peg$silentFails === 0) {
5086
- peg$fail(peg$e65);
5290
+ peg$fail(peg$e66);
5087
5291
  }
5088
5292
  }
5089
5293
  if (s1 !== peg$FAILED) {
5090
5294
  peg$savedPos = s0;
5091
- s1 = peg$f69();
5295
+ s1 = peg$f70();
5092
5296
  }
5093
5297
  s0 = s1;
5094
5298
  if (s0 === peg$FAILED) {
@@ -5096,7 +5300,7 @@ function peg$parse(input, options) {
5096
5300
  s1 = peg$parseComment();
5097
5301
  if (s1 !== peg$FAILED) {
5098
5302
  peg$savedPos = s0;
5099
- s1 = peg$f70();
5303
+ s1 = peg$f71();
5100
5304
  }
5101
5305
  s0 = s1;
5102
5306
  }
@@ -5106,13 +5310,13 @@ function peg$parse(input, options) {
5106
5310
  function peg$parseNav() {
5107
5311
  let s0, s1, s2, s3, s4, s5, s6, s7;
5108
5312
  s0 = peg$currPos;
5109
- if (input.substr(peg$currPos, 3) === peg$c63) {
5110
- s1 = peg$c63;
5313
+ if (input.substr(peg$currPos, 3) === peg$c64) {
5314
+ s1 = peg$c64;
5111
5315
  peg$currPos += 3;
5112
5316
  } else {
5113
5317
  s1 = peg$FAILED;
5114
5318
  if (peg$silentFails === 0) {
5115
- peg$fail(peg$e66);
5319
+ peg$fail(peg$e67);
5116
5320
  }
5117
5321
  }
5118
5322
  if (s1 !== peg$FAILED) {
@@ -5132,7 +5336,7 @@ function peg$parse(input, options) {
5132
5336
  s7 = null;
5133
5337
  }
5134
5338
  peg$savedPos = s0;
5135
- s0 = peg$f71(s3, s5, s7);
5339
+ s0 = peg$f72(s3, s5, s7);
5136
5340
  } else {
5137
5341
  peg$currPos = s0;
5138
5342
  s0 = peg$FAILED;
@@ -5188,7 +5392,7 @@ function peg$parse(input, options) {
5188
5392
  }
5189
5393
  if (s4 !== peg$FAILED) {
5190
5394
  peg$savedPos = s0;
5191
- s0 = peg$f72(s3);
5395
+ s0 = peg$f73(s3);
5192
5396
  } else {
5193
5397
  peg$currPos = s0;
5194
5398
  s0 = peg$FAILED;
@@ -5206,19 +5410,19 @@ function peg$parse(input, options) {
5206
5410
  s0 = peg$parseNavItem();
5207
5411
  if (s0 === peg$FAILED) {
5208
5412
  s0 = peg$currPos;
5209
- if (input.substr(peg$currPos, 7) === peg$c62) {
5210
- s1 = peg$c62;
5413
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5414
+ s1 = peg$c63;
5211
5415
  peg$currPos += 7;
5212
5416
  } else {
5213
5417
  s1 = peg$FAILED;
5214
5418
  if (peg$silentFails === 0) {
5215
- peg$fail(peg$e65);
5419
+ peg$fail(peg$e66);
5216
5420
  }
5217
5421
  }
5218
5422
  if (s1 !== peg$FAILED) {
5219
5423
  s2 = peg$parse_();
5220
5424
  peg$savedPos = s0;
5221
- s0 = peg$f73();
5425
+ s0 = peg$f74();
5222
5426
  } else {
5223
5427
  peg$currPos = s0;
5224
5428
  s0 = peg$FAILED;
@@ -5228,7 +5432,7 @@ function peg$parse(input, options) {
5228
5432
  s1 = peg$parseComment();
5229
5433
  if (s1 !== peg$FAILED) {
5230
5434
  peg$savedPos = s0;
5231
- s1 = peg$f74();
5435
+ s1 = peg$f75();
5232
5436
  }
5233
5437
  s0 = s1;
5234
5438
  }
@@ -5239,13 +5443,13 @@ function peg$parse(input, options) {
5239
5443
  function peg$parseNavGroup() {
5240
5444
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
5241
5445
  s0 = peg$currPos;
5242
- if (input.substr(peg$currPos, 5) === peg$c64) {
5243
- s1 = peg$c64;
5446
+ if (input.substr(peg$currPos, 5) === peg$c65) {
5447
+ s1 = peg$c65;
5244
5448
  peg$currPos += 5;
5245
5449
  } else {
5246
5450
  s1 = peg$FAILED;
5247
5451
  if (peg$silentFails === 0) {
5248
- peg$fail(peg$e67);
5452
+ peg$fail(peg$e68);
5249
5453
  }
5250
5454
  }
5251
5455
  if (s1 !== peg$FAILED) {
@@ -5304,7 +5508,7 @@ function peg$parse(input, options) {
5304
5508
  }
5305
5509
  if (s10 !== peg$FAILED) {
5306
5510
  peg$savedPos = s0;
5307
- s0 = peg$f75(s3, s5, s9);
5511
+ s0 = peg$f76(s3, s5, s9);
5308
5512
  } else {
5309
5513
  peg$currPos = s0;
5310
5514
  s0 = peg$FAILED;
@@ -5328,19 +5532,19 @@ function peg$parse(input, options) {
5328
5532
  s0 = peg$parseNavItem();
5329
5533
  if (s0 === peg$FAILED) {
5330
5534
  s0 = peg$currPos;
5331
- if (input.substr(peg$currPos, 7) === peg$c62) {
5332
- s1 = peg$c62;
5535
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5536
+ s1 = peg$c63;
5333
5537
  peg$currPos += 7;
5334
5538
  } else {
5335
5539
  s1 = peg$FAILED;
5336
5540
  if (peg$silentFails === 0) {
5337
- peg$fail(peg$e65);
5541
+ peg$fail(peg$e66);
5338
5542
  }
5339
5543
  }
5340
5544
  if (s1 !== peg$FAILED) {
5341
5545
  s2 = peg$parse_();
5342
5546
  peg$savedPos = s0;
5343
- s0 = peg$f76();
5547
+ s0 = peg$f77();
5344
5548
  } else {
5345
5549
  peg$currPos = s0;
5346
5550
  s0 = peg$FAILED;
@@ -5350,7 +5554,7 @@ function peg$parse(input, options) {
5350
5554
  s1 = peg$parseComment();
5351
5555
  if (s1 !== peg$FAILED) {
5352
5556
  peg$savedPos = s0;
5353
- s1 = peg$f77();
5557
+ s1 = peg$f78();
5354
5558
  }
5355
5559
  s0 = s1;
5356
5560
  }
@@ -5360,13 +5564,13 @@ function peg$parse(input, options) {
5360
5564
  function peg$parseNavItem() {
5361
5565
  let s0, s1, s2, s3, s4, s5;
5362
5566
  s0 = peg$currPos;
5363
- if (input.substr(peg$currPos, 4) === peg$c54) {
5364
- s1 = peg$c54;
5567
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5568
+ s1 = peg$c55;
5365
5569
  peg$currPos += 4;
5366
5570
  } else {
5367
5571
  s1 = peg$FAILED;
5368
5572
  if (peg$silentFails === 0) {
5369
- peg$fail(peg$e57);
5573
+ peg$fail(peg$e58);
5370
5574
  }
5371
5575
  }
5372
5576
  if (s1 !== peg$FAILED) {
@@ -5379,7 +5583,7 @@ function peg$parse(input, options) {
5379
5583
  s5 = null;
5380
5584
  }
5381
5585
  peg$savedPos = s0;
5382
- s0 = peg$f78(s3, s5);
5586
+ s0 = peg$f79(s3, s5);
5383
5587
  } else {
5384
5588
  peg$currPos = s0;
5385
5589
  s0 = peg$FAILED;
@@ -5393,13 +5597,13 @@ function peg$parse(input, options) {
5393
5597
  function peg$parseTabs() {
5394
5598
  let s0, s1, s2, s3, s4, s5, s6, s7;
5395
5599
  s0 = peg$currPos;
5396
- if (input.substr(peg$currPos, 4) === peg$c65) {
5397
- s1 = peg$c65;
5600
+ if (input.substr(peg$currPos, 4) === peg$c66) {
5601
+ s1 = peg$c66;
5398
5602
  peg$currPos += 4;
5399
5603
  } else {
5400
5604
  s1 = peg$FAILED;
5401
5605
  if (peg$silentFails === 0) {
5402
- peg$fail(peg$e68);
5606
+ peg$fail(peg$e69);
5403
5607
  }
5404
5608
  }
5405
5609
  if (s1 !== peg$FAILED) {
@@ -5419,7 +5623,7 @@ function peg$parse(input, options) {
5419
5623
  s7 = null;
5420
5624
  }
5421
5625
  peg$savedPos = s0;
5422
- s0 = peg$f79(s3, s5, s7);
5626
+ s0 = peg$f80(s3, s5, s7);
5423
5627
  } else {
5424
5628
  peg$currPos = s0;
5425
5629
  s0 = peg$FAILED;
@@ -5475,7 +5679,7 @@ function peg$parse(input, options) {
5475
5679
  }
5476
5680
  if (s4 !== peg$FAILED) {
5477
5681
  peg$savedPos = s0;
5478
- s0 = peg$f80(s3);
5682
+ s0 = peg$f81(s3);
5479
5683
  } else {
5480
5684
  peg$currPos = s0;
5481
5685
  s0 = peg$FAILED;
@@ -5489,13 +5693,13 @@ function peg$parse(input, options) {
5489
5693
  function peg$parseTabItem() {
5490
5694
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
5491
5695
  s0 = peg$currPos;
5492
- if (input.substr(peg$currPos, 3) === peg$c66) {
5493
- s1 = peg$c66;
5696
+ if (input.substr(peg$currPos, 3) === peg$c67) {
5697
+ s1 = peg$c67;
5494
5698
  peg$currPos += 3;
5495
5699
  } else {
5496
5700
  s1 = peg$FAILED;
5497
5701
  if (peg$silentFails === 0) {
5498
- peg$fail(peg$e69);
5702
+ peg$fail(peg$e70);
5499
5703
  }
5500
5704
  }
5501
5705
  if (s1 !== peg$FAILED) {
@@ -5533,7 +5737,7 @@ function peg$parse(input, options) {
5533
5737
  }
5534
5738
  if (s11 !== peg$FAILED) {
5535
5739
  peg$savedPos = s0;
5536
- s0 = peg$f81(s3, s5, s9);
5740
+ s0 = peg$f82(s3, s5, s9);
5537
5741
  } else {
5538
5742
  peg$currPos = s0;
5539
5743
  s0 = peg$FAILED;
@@ -5559,7 +5763,7 @@ function peg$parse(input, options) {
5559
5763
  s1 = peg$parseComment();
5560
5764
  if (s1 !== peg$FAILED) {
5561
5765
  peg$savedPos = s0;
5562
- s1 = peg$f82();
5766
+ s1 = peg$f83();
5563
5767
  }
5564
5768
  s0 = s1;
5565
5769
  }
@@ -5568,13 +5772,13 @@ function peg$parse(input, options) {
5568
5772
  function peg$parseBreadcrumb() {
5569
5773
  let s0, s1, s2, s3, s4, s5;
5570
5774
  s0 = peg$currPos;
5571
- if (input.substr(peg$currPos, 10) === peg$c67) {
5572
- s1 = peg$c67;
5775
+ if (input.substr(peg$currPos, 10) === peg$c68) {
5776
+ s1 = peg$c68;
5573
5777
  peg$currPos += 10;
5574
5778
  } else {
5575
5779
  s1 = peg$FAILED;
5576
5780
  if (peg$silentFails === 0) {
5577
- peg$fail(peg$e70);
5781
+ peg$fail(peg$e71);
5578
5782
  }
5579
5783
  }
5580
5784
  if (s1 !== peg$FAILED) {
@@ -5587,7 +5791,7 @@ function peg$parse(input, options) {
5587
5791
  s5 = null;
5588
5792
  }
5589
5793
  peg$savedPos = s0;
5590
- s0 = peg$f83(s3, s5);
5794
+ s0 = peg$f84(s3, s5);
5591
5795
  } else {
5592
5796
  peg$currPos = s0;
5593
5797
  s0 = peg$FAILED;
@@ -5601,13 +5805,13 @@ function peg$parse(input, options) {
5601
5805
  function peg$parseDivider() {
5602
5806
  let s0, s1, s2, s3;
5603
5807
  s0 = peg$currPos;
5604
- if (input.substr(peg$currPos, 7) === peg$c62) {
5605
- s1 = peg$c62;
5808
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5809
+ s1 = peg$c63;
5606
5810
  peg$currPos += 7;
5607
5811
  } else {
5608
5812
  s1 = peg$FAILED;
5609
5813
  if (peg$silentFails === 0) {
5610
- peg$fail(peg$e65);
5814
+ peg$fail(peg$e66);
5611
5815
  }
5612
5816
  }
5613
5817
  if (s1 !== peg$FAILED) {
@@ -5617,7 +5821,7 @@ function peg$parse(input, options) {
5617
5821
  s3 = null;
5618
5822
  }
5619
5823
  peg$savedPos = s0;
5620
- s0 = peg$f84(s3);
5824
+ s0 = peg$f85(s3);
5621
5825
  } else {
5622
5826
  peg$currPos = s0;
5623
5827
  s0 = peg$FAILED;
@@ -5627,13 +5831,13 @@ function peg$parse(input, options) {
5627
5831
  function peg$parseMarker() {
5628
5832
  let s0, s1, s2, s3, s4, s5;
5629
5833
  s0 = peg$currPos;
5630
- if (input.substr(peg$currPos, 6) === peg$c68) {
5631
- s1 = peg$c68;
5834
+ if (input.substr(peg$currPos, 6) === peg$c69) {
5835
+ s1 = peg$c69;
5632
5836
  peg$currPos += 6;
5633
5837
  } else {
5634
5838
  s1 = peg$FAILED;
5635
5839
  if (peg$silentFails === 0) {
5636
- peg$fail(peg$e71);
5840
+ peg$fail(peg$e72);
5637
5841
  }
5638
5842
  }
5639
5843
  if (s1 !== peg$FAILED) {
@@ -5646,7 +5850,7 @@ function peg$parse(input, options) {
5646
5850
  s5 = null;
5647
5851
  }
5648
5852
  peg$savedPos = s0;
5649
- s0 = peg$f85(s3, s5);
5853
+ s0 = peg$f86(s3, s5);
5650
5854
  } else {
5651
5855
  peg$currPos = s0;
5652
5856
  s0 = peg$FAILED;
@@ -5660,13 +5864,13 @@ function peg$parse(input, options) {
5660
5864
  function peg$parseAnnotations() {
5661
5865
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
5662
5866
  s0 = peg$currPos;
5663
- if (input.substr(peg$currPos, 11) === peg$c69) {
5664
- s1 = peg$c69;
5867
+ if (input.substr(peg$currPos, 11) === peg$c70) {
5868
+ s1 = peg$c70;
5665
5869
  peg$currPos += 11;
5666
5870
  } else {
5667
5871
  s1 = peg$FAILED;
5668
5872
  if (peg$silentFails === 0) {
5669
- peg$fail(peg$e72);
5873
+ peg$fail(peg$e73);
5670
5874
  }
5671
5875
  }
5672
5876
  if (s1 !== peg$FAILED) {
@@ -5700,7 +5904,7 @@ function peg$parse(input, options) {
5700
5904
  }
5701
5905
  if (s9 !== peg$FAILED) {
5702
5906
  peg$savedPos = s0;
5703
- s0 = peg$f86(s3, s7);
5907
+ s0 = peg$f87(s3, s7);
5704
5908
  } else {
5705
5909
  peg$currPos = s0;
5706
5910
  s0 = peg$FAILED;
@@ -5743,20 +5947,20 @@ function peg$parse(input, options) {
5743
5947
  }
5744
5948
  }
5745
5949
  peg$savedPos = s0;
5746
- s1 = peg$f87(s1);
5950
+ s1 = peg$f88(s1);
5747
5951
  s0 = s1;
5748
5952
  return s0;
5749
5953
  }
5750
5954
  function peg$parseAnnotationItem() {
5751
5955
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5752
5956
  s0 = peg$currPos;
5753
- if (input.substr(peg$currPos, 4) === peg$c54) {
5754
- s1 = peg$c54;
5957
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5958
+ s1 = peg$c55;
5755
5959
  peg$currPos += 4;
5756
5960
  } else {
5757
5961
  s1 = peg$FAILED;
5758
5962
  if (peg$silentFails === 0) {
5759
- peg$fail(peg$e57);
5963
+ peg$fail(peg$e58);
5760
5964
  }
5761
5965
  }
5762
5966
  if (s1 !== peg$FAILED) {
@@ -5797,7 +6001,7 @@ function peg$parse(input, options) {
5797
6001
  }
5798
6002
  if (s13 !== peg$FAILED) {
5799
6003
  peg$savedPos = s0;
5800
- s0 = peg$f88(s3, s5, s7, s11);
6004
+ s0 = peg$f89(s3, s5, s7, s11);
5801
6005
  } else {
5802
6006
  peg$currPos = s0;
5803
6007
  s0 = peg$FAILED;
@@ -5824,13 +6028,13 @@ function peg$parse(input, options) {
5824
6028
  }
5825
6029
  if (s0 === peg$FAILED) {
5826
6030
  s0 = peg$currPos;
5827
- if (input.substr(peg$currPos, 4) === peg$c54) {
5828
- s1 = peg$c54;
6031
+ if (input.substr(peg$currPos, 4) === peg$c55) {
6032
+ s1 = peg$c55;
5829
6033
  peg$currPos += 4;
5830
6034
  } else {
5831
6035
  s1 = peg$FAILED;
5832
6036
  if (peg$silentFails === 0) {
5833
- peg$fail(peg$e57);
6037
+ peg$fail(peg$e58);
5834
6038
  }
5835
6039
  }
5836
6040
  if (s1 !== peg$FAILED) {
@@ -5846,7 +6050,7 @@ function peg$parse(input, options) {
5846
6050
  s7 = null;
5847
6051
  }
5848
6052
  peg$savedPos = s0;
5849
- s0 = peg$f89(s3, s5, s7);
6053
+ s0 = peg$f90(s3, s5, s7);
5850
6054
  } else {
5851
6055
  peg$currPos = s0;
5852
6056
  s0 = peg$FAILED;
@@ -5864,7 +6068,7 @@ function peg$parse(input, options) {
5864
6068
  s1 = peg$parseComment();
5865
6069
  if (s1 !== peg$FAILED) {
5866
6070
  peg$savedPos = s0;
5867
- s1 = peg$f90();
6071
+ s1 = peg$f91();
5868
6072
  }
5869
6073
  s0 = s1;
5870
6074
  }
@@ -5882,7 +6086,7 @@ function peg$parse(input, options) {
5882
6086
  } else {
5883
6087
  s2 = peg$FAILED;
5884
6088
  if (peg$silentFails === 0) {
5885
- peg$fail(peg$e74);
6089
+ peg$fail(peg$e75);
5886
6090
  }
5887
6091
  }
5888
6092
  if (s2 !== peg$FAILED) {
@@ -5894,7 +6098,7 @@ function peg$parse(input, options) {
5894
6098
  } else {
5895
6099
  s2 = peg$FAILED;
5896
6100
  if (peg$silentFails === 0) {
5897
- peg$fail(peg$e74);
6101
+ peg$fail(peg$e75);
5898
6102
  }
5899
6103
  }
5900
6104
  }
@@ -5903,14 +6107,14 @@ function peg$parse(input, options) {
5903
6107
  }
5904
6108
  if (s1 !== peg$FAILED) {
5905
6109
  peg$savedPos = s0;
5906
- s1 = peg$f91(s1);
6110
+ s1 = peg$f92(s1);
5907
6111
  }
5908
6112
  s0 = s1;
5909
6113
  peg$silentFails--;
5910
6114
  if (s0 === peg$FAILED) {
5911
6115
  s1 = peg$FAILED;
5912
6116
  if (peg$silentFails === 0) {
5913
- peg$fail(peg$e73);
6117
+ peg$fail(peg$e74);
5914
6118
  }
5915
6119
  }
5916
6120
  return s0;
@@ -5930,7 +6134,7 @@ function peg$parse(input, options) {
5930
6134
  }
5931
6135
  if (s1 !== peg$FAILED) {
5932
6136
  peg$savedPos = s0;
5933
- s1 = peg$f92(s1);
6137
+ s1 = peg$f93(s1);
5934
6138
  }
5935
6139
  s0 = s1;
5936
6140
  return s0;
@@ -5939,13 +6143,13 @@ function peg$parse(input, options) {
5939
6143
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5940
6144
  s0 = peg$currPos;
5941
6145
  s1 = peg$parse_();
5942
- if (input.substr(peg$currPos, 2) === peg$c70) {
5943
- s2 = peg$c70;
6146
+ if (input.substr(peg$currPos, 2) === peg$c71) {
6147
+ s2 = peg$c71;
5944
6148
  peg$currPos += 2;
5945
6149
  } else {
5946
6150
  s2 = peg$FAILED;
5947
6151
  if (peg$silentFails === 0) {
5948
- peg$fail(peg$e75);
6152
+ peg$fail(peg$e76);
5949
6153
  }
5950
6154
  }
5951
6155
  if (s2 !== peg$FAILED) {
@@ -6000,7 +6204,7 @@ function peg$parse(input, options) {
6000
6204
  }
6001
6205
  if (s13 !== peg$FAILED) {
6002
6206
  peg$savedPos = s0;
6003
- s0 = peg$f93(s7, s11);
6207
+ s0 = peg$f94(s7, s11);
6004
6208
  } else {
6005
6209
  peg$currPos = s0;
6006
6210
  s0 = peg$FAILED;
@@ -6049,7 +6253,7 @@ function peg$parse(input, options) {
6049
6253
  s6 = peg$parseAttributeValue();
6050
6254
  if (s6 !== peg$FAILED) {
6051
6255
  peg$savedPos = s0;
6052
- s0 = peg$f94(s2, s6);
6256
+ s0 = peg$f95(s2, s6);
6053
6257
  } else {
6054
6258
  peg$currPos = s0;
6055
6259
  s0 = peg$FAILED;
@@ -6081,7 +6285,7 @@ function peg$parse(input, options) {
6081
6285
  } else {
6082
6286
  s6 = peg$FAILED;
6083
6287
  if (peg$silentFails === 0) {
6084
- peg$fail(peg$e76);
6288
+ peg$fail(peg$e77);
6085
6289
  }
6086
6290
  }
6087
6291
  if (s6 === peg$FAILED) {
@@ -6144,7 +6348,7 @@ function peg$parse(input, options) {
6144
6348
  }
6145
6349
  if (s3 !== peg$FAILED) {
6146
6350
  peg$savedPos = s0;
6147
- s0 = peg$f95(s2);
6351
+ s0 = peg$f96(s2);
6148
6352
  } else {
6149
6353
  peg$currPos = s0;
6150
6354
  s0 = peg$FAILED;
@@ -6174,7 +6378,7 @@ function peg$parse(input, options) {
6174
6378
  s2 = peg$parseIdentifier();
6175
6379
  if (s2 !== peg$FAILED) {
6176
6380
  peg$savedPos = s0;
6177
- s0 = peg$f96(s2);
6381
+ s0 = peg$f97(s2);
6178
6382
  } else {
6179
6383
  peg$currPos = s0;
6180
6384
  s0 = peg$FAILED;
@@ -6198,503 +6402,514 @@ function peg$parse(input, options) {
6198
6402
  }
6199
6403
  }
6200
6404
  if (s1 === peg$FAILED) {
6201
- if (input.substr(peg$currPos, 6) === peg$c20) {
6202
- s1 = peg$c20;
6405
+ if (input.substr(peg$currPos, 6) === peg$c21) {
6406
+ s1 = peg$c21;
6203
6407
  peg$currPos += 6;
6204
6408
  } else {
6205
6409
  s1 = peg$FAILED;
6206
6410
  if (peg$silentFails === 0) {
6207
- peg$fail(peg$e23);
6411
+ peg$fail(peg$e24);
6208
6412
  }
6209
6413
  }
6210
6414
  if (s1 === peg$FAILED) {
6211
- if (input.substr(peg$currPos, 4) === peg$c21) {
6212
- s1 = peg$c21;
6415
+ if (input.substr(peg$currPos, 4) === peg$c22) {
6416
+ s1 = peg$c22;
6213
6417
  peg$currPos += 4;
6214
6418
  } else {
6215
6419
  s1 = peg$FAILED;
6216
6420
  if (peg$silentFails === 0) {
6217
- peg$fail(peg$e24);
6421
+ peg$fail(peg$e25);
6218
6422
  }
6219
6423
  }
6220
6424
  if (s1 === peg$FAILED) {
6221
- if (input.substr(peg$currPos, 6) === peg$c22) {
6222
- s1 = peg$c22;
6425
+ if (input.substr(peg$currPos, 6) === peg$c23) {
6426
+ s1 = peg$c23;
6223
6427
  peg$currPos += 6;
6224
6428
  } else {
6225
6429
  s1 = peg$FAILED;
6226
6430
  if (peg$silentFails === 0) {
6227
- peg$fail(peg$e25);
6431
+ peg$fail(peg$e26);
6228
6432
  }
6229
6433
  }
6230
6434
  if (s1 === peg$FAILED) {
6231
- if (input.substr(peg$currPos, 7) === peg$c23) {
6232
- s1 = peg$c23;
6435
+ if (input.substr(peg$currPos, 7) === peg$c24) {
6436
+ s1 = peg$c24;
6233
6437
  peg$currPos += 7;
6234
6438
  } else {
6235
6439
  s1 = peg$FAILED;
6236
6440
  if (peg$silentFails === 0) {
6237
- peg$fail(peg$e26);
6441
+ peg$fail(peg$e27);
6238
6442
  }
6239
6443
  }
6240
6444
  if (s1 === peg$FAILED) {
6241
- if (input.substr(peg$currPos, 3) === peg$c24) {
6242
- s1 = peg$c24;
6445
+ if (input.substr(peg$currPos, 3) === peg$c25) {
6446
+ s1 = peg$c25;
6243
6447
  peg$currPos += 3;
6244
6448
  } else {
6245
6449
  s1 = peg$FAILED;
6246
6450
  if (peg$silentFails === 0) {
6247
- peg$fail(peg$e27);
6451
+ peg$fail(peg$e28);
6248
6452
  }
6249
6453
  }
6250
6454
  if (s1 === peg$FAILED) {
6251
- if (input.substr(peg$currPos, 3) === peg$c25) {
6252
- s1 = peg$c25;
6455
+ if (input.substr(peg$currPos, 3) === peg$c26) {
6456
+ s1 = peg$c26;
6253
6457
  peg$currPos += 3;
6254
6458
  } else {
6255
6459
  s1 = peg$FAILED;
6256
6460
  if (peg$silentFails === 0) {
6257
- peg$fail(peg$e28);
6461
+ peg$fail(peg$e29);
6258
6462
  }
6259
6463
  }
6260
6464
  if (s1 === peg$FAILED) {
6261
- if (input.substr(peg$currPos, 5) === peg$c26) {
6262
- s1 = peg$c26;
6465
+ if (input.substr(peg$currPos, 5) === peg$c27) {
6466
+ s1 = peg$c27;
6263
6467
  peg$currPos += 5;
6264
6468
  } else {
6265
6469
  s1 = peg$FAILED;
6266
6470
  if (peg$silentFails === 0) {
6267
- peg$fail(peg$e29);
6471
+ peg$fail(peg$e30);
6268
6472
  }
6269
6473
  }
6270
6474
  if (s1 === peg$FAILED) {
6271
- if (input.substr(peg$currPos, 8) === peg$c27) {
6272
- s1 = peg$c27;
6475
+ if (input.substr(peg$currPos, 8) === peg$c28) {
6476
+ s1 = peg$c28;
6273
6477
  peg$currPos += 8;
6274
6478
  } else {
6275
6479
  s1 = peg$FAILED;
6276
6480
  if (peg$silentFails === 0) {
6277
- peg$fail(peg$e30);
6481
+ peg$fail(peg$e31);
6278
6482
  }
6279
6483
  }
6280
6484
  if (s1 === peg$FAILED) {
6281
- if (input.substr(peg$currPos, 4) === peg$c28) {
6282
- s1 = peg$c28;
6485
+ if (input.substr(peg$currPos, 4) === peg$c29) {
6486
+ s1 = peg$c29;
6283
6487
  peg$currPos += 4;
6284
6488
  } else {
6285
6489
  s1 = peg$FAILED;
6286
6490
  if (peg$silentFails === 0) {
6287
- peg$fail(peg$e31);
6491
+ peg$fail(peg$e32);
6288
6492
  }
6289
6493
  }
6290
6494
  if (s1 === peg$FAILED) {
6291
- if (input.substr(peg$currPos, 5) === peg$c29) {
6292
- s1 = peg$c29;
6495
+ if (input.substr(peg$currPos, 5) === peg$c30) {
6496
+ s1 = peg$c30;
6293
6497
  peg$currPos += 5;
6294
6498
  } else {
6295
6499
  s1 = peg$FAILED;
6296
6500
  if (peg$silentFails === 0) {
6297
- peg$fail(peg$e32);
6501
+ peg$fail(peg$e33);
6298
6502
  }
6299
6503
  }
6300
6504
  if (s1 === peg$FAILED) {
6301
- if (input.substr(peg$currPos, 6) === peg$c30) {
6302
- s1 = peg$c30;
6505
+ if (input.substr(peg$currPos, 6) === peg$c31) {
6506
+ s1 = peg$c31;
6303
6507
  peg$currPos += 6;
6304
6508
  } else {
6305
6509
  s1 = peg$FAILED;
6306
6510
  if (peg$silentFails === 0) {
6307
- peg$fail(peg$e33);
6511
+ peg$fail(peg$e34);
6308
6512
  }
6309
6513
  }
6310
6514
  if (s1 === peg$FAILED) {
6311
- if (input.substr(peg$currPos, 9) === peg$c31) {
6312
- s1 = peg$c31;
6515
+ if (input.substr(peg$currPos, 9) === peg$c32) {
6516
+ s1 = peg$c32;
6313
6517
  peg$currPos += 9;
6314
6518
  } else {
6315
6519
  s1 = peg$FAILED;
6316
6520
  if (peg$silentFails === 0) {
6317
- peg$fail(peg$e34);
6521
+ peg$fail(peg$e35);
6318
6522
  }
6319
6523
  }
6320
6524
  if (s1 === peg$FAILED) {
6321
- if (input.substr(peg$currPos, 7) === peg$c32) {
6322
- s1 = peg$c32;
6525
+ if (input.substr(peg$currPos, 7) === peg$c33) {
6526
+ s1 = peg$c33;
6323
6527
  peg$currPos += 7;
6324
6528
  } else {
6325
6529
  s1 = peg$FAILED;
6326
6530
  if (peg$silentFails === 0) {
6327
- peg$fail(peg$e35);
6531
+ peg$fail(peg$e36);
6328
6532
  }
6329
6533
  }
6330
6534
  if (s1 === peg$FAILED) {
6331
- if (input.substr(peg$currPos, 4) === peg$c33) {
6332
- s1 = peg$c33;
6535
+ if (input.substr(peg$currPos, 4) === peg$c34) {
6536
+ s1 = peg$c34;
6333
6537
  peg$currPos += 4;
6334
6538
  } else {
6335
6539
  s1 = peg$FAILED;
6336
6540
  if (peg$silentFails === 0) {
6337
- peg$fail(peg$e36);
6541
+ peg$fail(peg$e37);
6338
6542
  }
6339
6543
  }
6340
6544
  if (s1 === peg$FAILED) {
6341
- if (input.substr(peg$currPos, 4) === peg$c35) {
6342
- s1 = peg$c35;
6545
+ if (input.substr(peg$currPos, 4) === peg$c36) {
6546
+ s1 = peg$c36;
6343
6547
  peg$currPos += 4;
6344
6548
  } else {
6345
6549
  s1 = peg$FAILED;
6346
6550
  if (peg$silentFails === 0) {
6347
- peg$fail(peg$e38);
6551
+ peg$fail(peg$e39);
6348
6552
  }
6349
6553
  }
6350
6554
  if (s1 === peg$FAILED) {
6351
- if (input.substr(peg$currPos, 6) === peg$c36) {
6352
- s1 = peg$c36;
6555
+ if (input.substr(peg$currPos, 6) === peg$c37) {
6556
+ s1 = peg$c37;
6353
6557
  peg$currPos += 6;
6354
6558
  } else {
6355
6559
  s1 = peg$FAILED;
6356
6560
  if (peg$silentFails === 0) {
6357
- peg$fail(peg$e39);
6561
+ peg$fail(peg$e40);
6358
6562
  }
6359
6563
  }
6360
6564
  if (s1 === peg$FAILED) {
6361
- if (input.substr(peg$currPos, 5) === peg$c37) {
6362
- s1 = peg$c37;
6565
+ if (input.substr(peg$currPos, 5) === peg$c38) {
6566
+ s1 = peg$c38;
6363
6567
  peg$currPos += 5;
6364
6568
  } else {
6365
6569
  s1 = peg$FAILED;
6366
6570
  if (peg$silentFails === 0) {
6367
- peg$fail(peg$e40);
6571
+ peg$fail(peg$e41);
6368
6572
  }
6369
6573
  }
6370
6574
  if (s1 === peg$FAILED) {
6371
- if (input.substr(peg$currPos, 8) === peg$c38) {
6372
- s1 = peg$c38;
6575
+ if (input.substr(peg$currPos, 8) === peg$c39) {
6576
+ s1 = peg$c39;
6373
6577
  peg$currPos += 8;
6374
6578
  } else {
6375
6579
  s1 = peg$FAILED;
6376
6580
  if (peg$silentFails === 0) {
6377
- peg$fail(peg$e41);
6581
+ peg$fail(peg$e42);
6378
6582
  }
6379
6583
  }
6380
6584
  if (s1 === peg$FAILED) {
6381
- if (input.substr(peg$currPos, 6) === peg$c39) {
6382
- s1 = peg$c39;
6585
+ if (input.substr(peg$currPos, 6) === peg$c40) {
6586
+ s1 = peg$c40;
6383
6587
  peg$currPos += 6;
6384
6588
  } else {
6385
6589
  s1 = peg$FAILED;
6386
6590
  if (peg$silentFails === 0) {
6387
- peg$fail(peg$e42);
6591
+ peg$fail(peg$e43);
6388
6592
  }
6389
6593
  }
6390
6594
  if (s1 === peg$FAILED) {
6391
- if (input.substr(peg$currPos, 8) === peg$c40) {
6392
- s1 = peg$c40;
6595
+ if (input.substr(peg$currPos, 8) === peg$c41) {
6596
+ s1 = peg$c41;
6393
6597
  peg$currPos += 8;
6394
6598
  } else {
6395
6599
  s1 = peg$FAILED;
6396
6600
  if (peg$silentFails === 0) {
6397
- peg$fail(peg$e43);
6601
+ peg$fail(peg$e44);
6398
6602
  }
6399
6603
  }
6400
6604
  if (s1 === peg$FAILED) {
6401
- if (input.substr(peg$currPos, 5) === peg$c41) {
6402
- s1 = peg$c41;
6605
+ if (input.substr(peg$currPos, 5) === peg$c42) {
6606
+ s1 = peg$c42;
6403
6607
  peg$currPos += 5;
6404
6608
  } else {
6405
6609
  s1 = peg$FAILED;
6406
6610
  if (peg$silentFails === 0) {
6407
- peg$fail(peg$e44);
6611
+ peg$fail(peg$e45);
6408
6612
  }
6409
6613
  }
6410
6614
  if (s1 === peg$FAILED) {
6411
- if (input.substr(peg$currPos, 6) === peg$c42) {
6412
- s1 = peg$c42;
6615
+ if (input.substr(peg$currPos, 6) === peg$c43) {
6616
+ s1 = peg$c43;
6413
6617
  peg$currPos += 6;
6414
6618
  } else {
6415
6619
  s1 = peg$FAILED;
6416
6620
  if (peg$silentFails === 0) {
6417
- peg$fail(peg$e45);
6621
+ peg$fail(peg$e46);
6418
6622
  }
6419
6623
  }
6420
6624
  if (s1 === peg$FAILED) {
6421
- if (input.substr(peg$currPos, 6) === peg$c43) {
6422
- s1 = peg$c43;
6625
+ if (input.substr(peg$currPos, 6) === peg$c44) {
6626
+ s1 = peg$c44;
6423
6627
  peg$currPos += 6;
6424
6628
  } else {
6425
6629
  s1 = peg$FAILED;
6426
6630
  if (peg$silentFails === 0) {
6427
- peg$fail(peg$e46);
6631
+ peg$fail(peg$e47);
6428
6632
  }
6429
6633
  }
6430
6634
  if (s1 === peg$FAILED) {
6431
- if (input.substr(peg$currPos, 5) === peg$c44) {
6432
- s1 = peg$c44;
6635
+ if (input.substr(peg$currPos, 5) === peg$c45) {
6636
+ s1 = peg$c45;
6433
6637
  peg$currPos += 5;
6434
6638
  } else {
6435
6639
  s1 = peg$FAILED;
6436
6640
  if (peg$silentFails === 0) {
6437
- peg$fail(peg$e47);
6641
+ peg$fail(peg$e48);
6438
6642
  }
6439
6643
  }
6440
6644
  if (s1 === peg$FAILED) {
6441
- if (input.substr(peg$currPos, 6) === peg$c46) {
6442
- s1 = peg$c46;
6645
+ if (input.substr(peg$currPos, 6) === peg$c47) {
6646
+ s1 = peg$c47;
6443
6647
  peg$currPos += 6;
6444
6648
  } else {
6445
6649
  s1 = peg$FAILED;
6446
6650
  if (peg$silentFails === 0) {
6447
- peg$fail(peg$e49);
6651
+ peg$fail(peg$e50);
6448
6652
  }
6449
6653
  }
6450
6654
  if (s1 === peg$FAILED) {
6451
- if (input.substr(peg$currPos, 5) === peg$c47) {
6452
- s1 = peg$c47;
6655
+ if (input.substr(peg$currPos, 5) === peg$c48) {
6656
+ s1 = peg$c48;
6453
6657
  peg$currPos += 5;
6454
6658
  } else {
6455
6659
  s1 = peg$FAILED;
6456
6660
  if (peg$silentFails === 0) {
6457
- peg$fail(peg$e50);
6661
+ peg$fail(peg$e51);
6458
6662
  }
6459
6663
  }
6460
6664
  if (s1 === peg$FAILED) {
6461
- if (input.substr(peg$currPos, 5) === peg$c49) {
6462
- s1 = peg$c49;
6665
+ if (input.substr(peg$currPos, 5) === peg$c50) {
6666
+ s1 = peg$c50;
6463
6667
  peg$currPos += 5;
6464
6668
  } else {
6465
6669
  s1 = peg$FAILED;
6466
6670
  if (peg$silentFails === 0) {
6467
- peg$fail(peg$e52);
6671
+ peg$fail(peg$e53);
6468
6672
  }
6469
6673
  }
6470
6674
  if (s1 === peg$FAILED) {
6471
- if (input.substr(peg$currPos, 7) === peg$c52) {
6472
- s1 = peg$c52;
6675
+ if (input.substr(peg$currPos, 7) === peg$c53) {
6676
+ s1 = peg$c53;
6473
6677
  peg$currPos += 7;
6474
6678
  } else {
6475
6679
  s1 = peg$FAILED;
6476
6680
  if (peg$silentFails === 0) {
6477
- peg$fail(peg$e55);
6681
+ peg$fail(peg$e56);
6478
6682
  }
6479
6683
  }
6480
6684
  if (s1 === peg$FAILED) {
6481
- if (input.substr(peg$currPos, 4) === peg$c53) {
6482
- s1 = peg$c53;
6685
+ if (input.substr(peg$currPos, 4) === peg$c54) {
6686
+ s1 = peg$c54;
6483
6687
  peg$currPos += 4;
6484
6688
  } else {
6485
6689
  s1 = peg$FAILED;
6486
6690
  if (peg$silentFails === 0) {
6487
- peg$fail(peg$e56);
6691
+ peg$fail(peg$e57);
6488
6692
  }
6489
6693
  }
6490
6694
  if (s1 === peg$FAILED) {
6491
- if (input.substr(peg$currPos, 4) === peg$c54) {
6492
- s1 = peg$c54;
6695
+ if (input.substr(peg$currPos, 4) === peg$c55) {
6696
+ s1 = peg$c55;
6493
6697
  peg$currPos += 4;
6494
6698
  } else {
6495
6699
  s1 = peg$FAILED;
6496
6700
  if (peg$silentFails === 0) {
6497
- peg$fail(peg$e57);
6701
+ peg$fail(peg$e58);
6498
6702
  }
6499
6703
  }
6500
6704
  if (s1 === peg$FAILED) {
6501
- if (input.substr(peg$currPos, 5) === peg$c55) {
6502
- s1 = peg$c55;
6705
+ if (input.substr(peg$currPos, 5) === peg$c56) {
6706
+ s1 = peg$c56;
6503
6707
  peg$currPos += 5;
6504
6708
  } else {
6505
6709
  s1 = peg$FAILED;
6506
6710
  if (peg$silentFails === 0) {
6507
- peg$fail(peg$e58);
6711
+ peg$fail(peg$e59);
6508
6712
  }
6509
6713
  }
6510
6714
  if (s1 === peg$FAILED) {
6511
- if (input.substr(peg$currPos, 5) === peg$c56) {
6512
- s1 = peg$c56;
6715
+ if (input.substr(peg$currPos, 5) === peg$c57) {
6716
+ s1 = peg$c57;
6513
6717
  peg$currPos += 5;
6514
6718
  } else {
6515
6719
  s1 = peg$FAILED;
6516
6720
  if (peg$silentFails === 0) {
6517
- peg$fail(peg$e59);
6721
+ peg$fail(peg$e60);
6518
6722
  }
6519
6723
  }
6520
6724
  if (s1 === peg$FAILED) {
6521
- if (input.substr(peg$currPos, 8) === peg$c57) {
6522
- s1 = peg$c57;
6725
+ if (input.substr(peg$currPos, 8) === peg$c58) {
6726
+ s1 = peg$c58;
6523
6727
  peg$currPos += 8;
6524
6728
  } else {
6525
6729
  s1 = peg$FAILED;
6526
6730
  if (peg$silentFails === 0) {
6527
- peg$fail(peg$e60);
6731
+ peg$fail(peg$e61);
6528
6732
  }
6529
6733
  }
6530
6734
  if (s1 === peg$FAILED) {
6531
- if (input.substr(peg$currPos, 7) === peg$c58) {
6532
- s1 = peg$c58;
6735
+ if (input.substr(peg$currPos, 7) === peg$c59) {
6736
+ s1 = peg$c59;
6533
6737
  peg$currPos += 7;
6534
6738
  } else {
6535
6739
  s1 = peg$FAILED;
6536
6740
  if (peg$silentFails === 0) {
6537
- peg$fail(peg$e61);
6741
+ peg$fail(peg$e62);
6538
6742
  }
6539
6743
  }
6540
6744
  if (s1 === peg$FAILED) {
6541
- if (input.substr(peg$currPos, 7) === peg$c59) {
6542
- s1 = peg$c59;
6745
+ if (input.substr(peg$currPos, 7) === peg$c60) {
6746
+ s1 = peg$c60;
6543
6747
  peg$currPos += 7;
6544
6748
  } else {
6545
6749
  s1 = peg$FAILED;
6546
6750
  if (peg$silentFails === 0) {
6547
- peg$fail(peg$e62);
6751
+ peg$fail(peg$e63);
6548
6752
  }
6549
6753
  }
6550
6754
  if (s1 === peg$FAILED) {
6551
- if (input.substr(peg$currPos, 7) === peg$c60) {
6552
- s1 = peg$c60;
6755
+ if (input.substr(peg$currPos, 7) === peg$c61) {
6756
+ s1 = peg$c61;
6553
6757
  peg$currPos += 7;
6554
6758
  } else {
6555
6759
  s1 = peg$FAILED;
6556
6760
  if (peg$silentFails === 0) {
6557
- peg$fail(peg$e63);
6761
+ peg$fail(peg$e64);
6558
6762
  }
6559
6763
  }
6560
6764
  if (s1 === peg$FAILED) {
6561
- if (input.substr(peg$currPos, 8) === peg$c61) {
6562
- s1 = peg$c61;
6765
+ if (input.substr(peg$currPos, 8) === peg$c62) {
6766
+ s1 = peg$c62;
6563
6767
  peg$currPos += 8;
6564
6768
  } else {
6565
6769
  s1 = peg$FAILED;
6566
6770
  if (peg$silentFails === 0) {
6567
- peg$fail(peg$e64);
6771
+ peg$fail(peg$e65);
6568
6772
  }
6569
6773
  }
6570
6774
  if (s1 === peg$FAILED) {
6571
- if (input.substr(peg$currPos, 7) === peg$c62) {
6572
- s1 = peg$c62;
6775
+ if (input.substr(peg$currPos, 7) === peg$c63) {
6776
+ s1 = peg$c63;
6573
6777
  peg$currPos += 7;
6574
6778
  } else {
6575
6779
  s1 = peg$FAILED;
6576
6780
  if (peg$silentFails === 0) {
6577
- peg$fail(peg$e65);
6781
+ peg$fail(peg$e66);
6578
6782
  }
6579
6783
  }
6580
6784
  if (s1 === peg$FAILED) {
6581
- if (input.substr(peg$currPos, 3) === peg$c63) {
6582
- s1 = peg$c63;
6785
+ if (input.substr(peg$currPos, 3) === peg$c64) {
6786
+ s1 = peg$c64;
6583
6787
  peg$currPos += 3;
6584
6788
  } else {
6585
6789
  s1 = peg$FAILED;
6586
6790
  if (peg$silentFails === 0) {
6587
- peg$fail(peg$e66);
6791
+ peg$fail(peg$e67);
6588
6792
  }
6589
6793
  }
6590
6794
  if (s1 === peg$FAILED) {
6591
- if (input.substr(peg$currPos, 4) === peg$c65) {
6592
- s1 = peg$c65;
6795
+ if (input.substr(peg$currPos, 4) === peg$c66) {
6796
+ s1 = peg$c66;
6593
6797
  peg$currPos += 4;
6594
6798
  } else {
6595
6799
  s1 = peg$FAILED;
6596
6800
  if (peg$silentFails === 0) {
6597
- peg$fail(peg$e68);
6801
+ peg$fail(peg$e69);
6598
6802
  }
6599
6803
  }
6600
6804
  if (s1 === peg$FAILED) {
6601
- if (input.substr(peg$currPos, 3) === peg$c66) {
6602
- s1 = peg$c66;
6805
+ if (input.substr(peg$currPos, 3) === peg$c67) {
6806
+ s1 = peg$c67;
6603
6807
  peg$currPos += 3;
6604
6808
  } else {
6605
6809
  s1 = peg$FAILED;
6606
6810
  if (peg$silentFails === 0) {
6607
- peg$fail(peg$e69);
6811
+ peg$fail(peg$e70);
6608
6812
  }
6609
6813
  }
6610
6814
  if (s1 === peg$FAILED) {
6611
- if (input.substr(peg$currPos, 10) === peg$c67) {
6612
- s1 = peg$c67;
6815
+ if (input.substr(peg$currPos, 10) === peg$c68) {
6816
+ s1 = peg$c68;
6613
6817
  peg$currPos += 10;
6614
6818
  } else {
6615
6819
  s1 = peg$FAILED;
6616
6820
  if (peg$silentFails === 0) {
6617
- peg$fail(peg$e70);
6821
+ peg$fail(peg$e71);
6618
6822
  }
6619
6823
  }
6620
6824
  if (s1 === peg$FAILED) {
6621
- if (input.substr(peg$currPos, 5) === peg$c64) {
6622
- s1 = peg$c64;
6825
+ if (input.substr(peg$currPos, 5) === peg$c65) {
6826
+ s1 = peg$c65;
6623
6827
  peg$currPos += 5;
6624
6828
  } else {
6625
6829
  s1 = peg$FAILED;
6626
6830
  if (peg$silentFails === 0) {
6627
- peg$fail(peg$e67);
6831
+ peg$fail(peg$e68);
6628
6832
  }
6629
6833
  }
6630
6834
  if (s1 === peg$FAILED) {
6631
- if (input.substr(peg$currPos, 6) === peg$c68) {
6632
- s1 = peg$c68;
6835
+ if (input.substr(peg$currPos, 6) === peg$c69) {
6836
+ s1 = peg$c69;
6633
6837
  peg$currPos += 6;
6634
6838
  } else {
6635
6839
  s1 = peg$FAILED;
6636
6840
  if (peg$silentFails === 0) {
6637
- peg$fail(peg$e71);
6841
+ peg$fail(peg$e72);
6638
6842
  }
6639
6843
  }
6640
6844
  if (s1 === peg$FAILED) {
6641
- if (input.substr(peg$currPos, 11) === peg$c69) {
6642
- s1 = peg$c69;
6845
+ if (input.substr(peg$currPos, 11) === peg$c70) {
6846
+ s1 = peg$c70;
6643
6847
  peg$currPos += 11;
6644
6848
  } else {
6645
6849
  s1 = peg$FAILED;
6646
6850
  if (peg$silentFails === 0) {
6647
- peg$fail(peg$e72);
6851
+ peg$fail(peg$e73);
6648
6852
  }
6649
6853
  }
6650
6854
  if (s1 === peg$FAILED) {
6651
- if (input.substr(peg$currPos, 6) === peg$c3) {
6652
- s1 = peg$c3;
6855
+ if (input.substr(peg$currPos, 6) === peg$c20) {
6856
+ s1 = peg$c20;
6653
6857
  peg$currPos += 6;
6654
6858
  } else {
6655
6859
  s1 = peg$FAILED;
6656
6860
  if (peg$silentFails === 0) {
6657
- peg$fail(peg$e3);
6861
+ peg$fail(peg$e23);
6658
6862
  }
6659
6863
  }
6660
6864
  if (s1 === peg$FAILED) {
6661
- if (input.substr(peg$currPos, 9) === peg$c4) {
6662
- s1 = peg$c4;
6663
- peg$currPos += 9;
6865
+ if (input.substr(peg$currPos, 6) === peg$c3) {
6866
+ s1 = peg$c3;
6867
+ peg$currPos += 6;
6664
6868
  } else {
6665
6869
  s1 = peg$FAILED;
6666
6870
  if (peg$silentFails === 0) {
6667
- peg$fail(peg$e4);
6871
+ peg$fail(peg$e3);
6668
6872
  }
6669
6873
  }
6670
6874
  if (s1 === peg$FAILED) {
6671
- if (input.substr(peg$currPos, 3) === peg$c12) {
6672
- s1 = peg$c12;
6673
- peg$currPos += 3;
6875
+ if (input.substr(peg$currPos, 9) === peg$c4) {
6876
+ s1 = peg$c4;
6877
+ peg$currPos += 9;
6674
6878
  } else {
6675
6879
  s1 = peg$FAILED;
6676
6880
  if (peg$silentFails === 0) {
6677
- peg$fail(peg$e12);
6881
+ peg$fail(peg$e4);
6678
6882
  }
6679
6883
  }
6680
6884
  if (s1 === peg$FAILED) {
6681
- if (input.substr(peg$currPos, 4) === peg$c15) {
6682
- s1 = peg$c15;
6683
- peg$currPos += 4;
6885
+ if (input.substr(peg$currPos, 3) === peg$c12) {
6886
+ s1 = peg$c12;
6887
+ peg$currPos += 3;
6684
6888
  } else {
6685
6889
  s1 = peg$FAILED;
6686
6890
  if (peg$silentFails === 0) {
6687
- peg$fail(peg$e15);
6891
+ peg$fail(peg$e12);
6688
6892
  }
6689
6893
  }
6690
6894
  if (s1 === peg$FAILED) {
6691
- if (input.substr(peg$currPos, 4) === peg$c16) {
6692
- s1 = peg$c16;
6895
+ if (input.substr(peg$currPos, 4) === peg$c15) {
6896
+ s1 = peg$c15;
6693
6897
  peg$currPos += 4;
6694
6898
  } else {
6695
6899
  s1 = peg$FAILED;
6696
6900
  if (peg$silentFails === 0) {
6697
- peg$fail(peg$e16);
6901
+ peg$fail(peg$e15);
6902
+ }
6903
+ }
6904
+ if (s1 === peg$FAILED) {
6905
+ if (input.substr(peg$currPos, 4) === peg$c16) {
6906
+ s1 = peg$c16;
6907
+ peg$currPos += 4;
6908
+ } else {
6909
+ s1 = peg$FAILED;
6910
+ if (peg$silentFails === 0) {
6911
+ peg$fail(peg$e16);
6912
+ }
6698
6913
  }
6699
6914
  }
6700
6915
  }
@@ -6779,7 +6994,7 @@ function peg$parse(input, options) {
6779
6994
  } else {
6780
6995
  s0 = peg$FAILED;
6781
6996
  if (peg$silentFails === 0) {
6782
- peg$fail(peg$e77);
6997
+ peg$fail(peg$e78);
6783
6998
  }
6784
6999
  }
6785
7000
  return s0;
@@ -6812,12 +7027,12 @@ function peg$parse(input, options) {
6812
7027
  peg$silentFails++;
6813
7028
  s0 = peg$currPos;
6814
7029
  if (input.charCodeAt(peg$currPos) === 34) {
6815
- s1 = peg$c71;
7030
+ s1 = peg$c72;
6816
7031
  peg$currPos++;
6817
7032
  } else {
6818
7033
  s1 = peg$FAILED;
6819
7034
  if (peg$silentFails === 0) {
6820
- peg$fail(peg$e79);
7035
+ peg$fail(peg$e80);
6821
7036
  }
6822
7037
  }
6823
7038
  if (s1 !== peg$FAILED) {
@@ -6828,17 +7043,17 @@ function peg$parse(input, options) {
6828
7043
  s3 = peg$parseDoubleStringChar();
6829
7044
  }
6830
7045
  if (input.charCodeAt(peg$currPos) === 34) {
6831
- s3 = peg$c71;
7046
+ s3 = peg$c72;
6832
7047
  peg$currPos++;
6833
7048
  } else {
6834
7049
  s3 = peg$FAILED;
6835
7050
  if (peg$silentFails === 0) {
6836
- peg$fail(peg$e79);
7051
+ peg$fail(peg$e80);
6837
7052
  }
6838
7053
  }
6839
7054
  if (s3 !== peg$FAILED) {
6840
7055
  peg$savedPos = s0;
6841
- s0 = peg$f97(s2);
7056
+ s0 = peg$f98(s2);
6842
7057
  } else {
6843
7058
  peg$currPos = s0;
6844
7059
  s0 = peg$FAILED;
@@ -6850,12 +7065,12 @@ function peg$parse(input, options) {
6850
7065
  if (s0 === peg$FAILED) {
6851
7066
  s0 = peg$currPos;
6852
7067
  if (input.charCodeAt(peg$currPos) === 39) {
6853
- s1 = peg$c72;
7068
+ s1 = peg$c73;
6854
7069
  peg$currPos++;
6855
7070
  } else {
6856
7071
  s1 = peg$FAILED;
6857
7072
  if (peg$silentFails === 0) {
6858
- peg$fail(peg$e80);
7073
+ peg$fail(peg$e81);
6859
7074
  }
6860
7075
  }
6861
7076
  if (s1 !== peg$FAILED) {
@@ -6866,17 +7081,17 @@ function peg$parse(input, options) {
6866
7081
  s3 = peg$parseSingleStringChar();
6867
7082
  }
6868
7083
  if (input.charCodeAt(peg$currPos) === 39) {
6869
- s3 = peg$c72;
7084
+ s3 = peg$c73;
6870
7085
  peg$currPos++;
6871
7086
  } else {
6872
7087
  s3 = peg$FAILED;
6873
7088
  if (peg$silentFails === 0) {
6874
- peg$fail(peg$e80);
7089
+ peg$fail(peg$e81);
6875
7090
  }
6876
7091
  }
6877
7092
  if (s3 !== peg$FAILED) {
6878
7093
  peg$savedPos = s0;
6879
- s0 = peg$f98(s2);
7094
+ s0 = peg$f99(s2);
6880
7095
  } else {
6881
7096
  peg$currPos = s0;
6882
7097
  s0 = peg$FAILED;
@@ -6890,7 +7105,7 @@ function peg$parse(input, options) {
6890
7105
  if (s0 === peg$FAILED) {
6891
7106
  s1 = peg$FAILED;
6892
7107
  if (peg$silentFails === 0) {
6893
- peg$fail(peg$e78);
7108
+ peg$fail(peg$e79);
6894
7109
  }
6895
7110
  }
6896
7111
  return s0;
@@ -6901,12 +7116,12 @@ function peg$parse(input, options) {
6901
7116
  s1 = peg$currPos;
6902
7117
  peg$silentFails++;
6903
7118
  if (input.charCodeAt(peg$currPos) === 34) {
6904
- s2 = peg$c71;
7119
+ s2 = peg$c72;
6905
7120
  peg$currPos++;
6906
7121
  } else {
6907
7122
  s2 = peg$FAILED;
6908
7123
  if (peg$silentFails === 0) {
6909
- peg$fail(peg$e79);
7124
+ peg$fail(peg$e80);
6910
7125
  }
6911
7126
  }
6912
7127
  peg$silentFails--;
@@ -6920,12 +7135,12 @@ function peg$parse(input, options) {
6920
7135
  s2 = peg$currPos;
6921
7136
  peg$silentFails++;
6922
7137
  if (input.charCodeAt(peg$currPos) === 92) {
6923
- s3 = peg$c73;
7138
+ s3 = peg$c74;
6924
7139
  peg$currPos++;
6925
7140
  } else {
6926
7141
  s3 = peg$FAILED;
6927
7142
  if (peg$silentFails === 0) {
6928
- peg$fail(peg$e81);
7143
+ peg$fail(peg$e82);
6929
7144
  }
6930
7145
  }
6931
7146
  peg$silentFails--;
@@ -6947,7 +7162,7 @@ function peg$parse(input, options) {
6947
7162
  }
6948
7163
  if (s3 !== peg$FAILED) {
6949
7164
  peg$savedPos = s0;
6950
- s0 = peg$f99(s3);
7165
+ s0 = peg$f100(s3);
6951
7166
  } else {
6952
7167
  peg$currPos = s0;
6953
7168
  s0 = peg$FAILED;
@@ -6963,19 +7178,19 @@ function peg$parse(input, options) {
6963
7178
  if (s0 === peg$FAILED) {
6964
7179
  s0 = peg$currPos;
6965
7180
  if (input.charCodeAt(peg$currPos) === 92) {
6966
- s1 = peg$c73;
7181
+ s1 = peg$c74;
6967
7182
  peg$currPos++;
6968
7183
  } else {
6969
7184
  s1 = peg$FAILED;
6970
7185
  if (peg$silentFails === 0) {
6971
- peg$fail(peg$e81);
7186
+ peg$fail(peg$e82);
6972
7187
  }
6973
7188
  }
6974
7189
  if (s1 !== peg$FAILED) {
6975
7190
  s2 = peg$parseEscapeSequence();
6976
7191
  if (s2 !== peg$FAILED) {
6977
7192
  peg$savedPos = s0;
6978
- s0 = peg$f100(s2);
7193
+ s0 = peg$f101(s2);
6979
7194
  } else {
6980
7195
  peg$currPos = s0;
6981
7196
  s0 = peg$FAILED;
@@ -6993,12 +7208,12 @@ function peg$parse(input, options) {
6993
7208
  s1 = peg$currPos;
6994
7209
  peg$silentFails++;
6995
7210
  if (input.charCodeAt(peg$currPos) === 39) {
6996
- s2 = peg$c72;
7211
+ s2 = peg$c73;
6997
7212
  peg$currPos++;
6998
7213
  } else {
6999
7214
  s2 = peg$FAILED;
7000
7215
  if (peg$silentFails === 0) {
7001
- peg$fail(peg$e80);
7216
+ peg$fail(peg$e81);
7002
7217
  }
7003
7218
  }
7004
7219
  peg$silentFails--;
@@ -7012,12 +7227,12 @@ function peg$parse(input, options) {
7012
7227
  s2 = peg$currPos;
7013
7228
  peg$silentFails++;
7014
7229
  if (input.charCodeAt(peg$currPos) === 92) {
7015
- s3 = peg$c73;
7230
+ s3 = peg$c74;
7016
7231
  peg$currPos++;
7017
7232
  } else {
7018
7233
  s3 = peg$FAILED;
7019
7234
  if (peg$silentFails === 0) {
7020
- peg$fail(peg$e81);
7235
+ peg$fail(peg$e82);
7021
7236
  }
7022
7237
  }
7023
7238
  peg$silentFails--;
@@ -7039,7 +7254,7 @@ function peg$parse(input, options) {
7039
7254
  }
7040
7255
  if (s3 !== peg$FAILED) {
7041
7256
  peg$savedPos = s0;
7042
- s0 = peg$f101(s3);
7257
+ s0 = peg$f102(s3);
7043
7258
  } else {
7044
7259
  peg$currPos = s0;
7045
7260
  s0 = peg$FAILED;
@@ -7055,19 +7270,19 @@ function peg$parse(input, options) {
7055
7270
  if (s0 === peg$FAILED) {
7056
7271
  s0 = peg$currPos;
7057
7272
  if (input.charCodeAt(peg$currPos) === 92) {
7058
- s1 = peg$c73;
7273
+ s1 = peg$c74;
7059
7274
  peg$currPos++;
7060
7275
  } else {
7061
7276
  s1 = peg$FAILED;
7062
7277
  if (peg$silentFails === 0) {
7063
- peg$fail(peg$e81);
7278
+ peg$fail(peg$e82);
7064
7279
  }
7065
7280
  }
7066
7281
  if (s1 !== peg$FAILED) {
7067
7282
  s2 = peg$parseEscapeSequence();
7068
7283
  if (s2 !== peg$FAILED) {
7069
7284
  peg$savedPos = s0;
7070
- s0 = peg$f102(s2);
7285
+ s0 = peg$f103(s2);
7071
7286
  } else {
7072
7287
  peg$currPos = s0;
7073
7288
  s0 = peg$FAILED;
@@ -7083,97 +7298,97 @@ function peg$parse(input, options) {
7083
7298
  let s0, s1;
7084
7299
  s0 = peg$currPos;
7085
7300
  if (input.charCodeAt(peg$currPos) === 110) {
7086
- s1 = peg$c74;
7301
+ s1 = peg$c75;
7087
7302
  peg$currPos++;
7088
7303
  } else {
7089
7304
  s1 = peg$FAILED;
7090
7305
  if (peg$silentFails === 0) {
7091
- peg$fail(peg$e82);
7306
+ peg$fail(peg$e83);
7092
7307
  }
7093
7308
  }
7094
7309
  if (s1 !== peg$FAILED) {
7095
7310
  peg$savedPos = s0;
7096
- s1 = peg$f103();
7311
+ s1 = peg$f104();
7097
7312
  }
7098
7313
  s0 = s1;
7099
7314
  if (s0 === peg$FAILED) {
7100
7315
  s0 = peg$currPos;
7101
7316
  if (input.charCodeAt(peg$currPos) === 114) {
7102
- s1 = peg$c75;
7317
+ s1 = peg$c76;
7103
7318
  peg$currPos++;
7104
7319
  } else {
7105
7320
  s1 = peg$FAILED;
7106
7321
  if (peg$silentFails === 0) {
7107
- peg$fail(peg$e83);
7322
+ peg$fail(peg$e84);
7108
7323
  }
7109
7324
  }
7110
7325
  if (s1 !== peg$FAILED) {
7111
7326
  peg$savedPos = s0;
7112
- s1 = peg$f104();
7327
+ s1 = peg$f105();
7113
7328
  }
7114
7329
  s0 = s1;
7115
7330
  if (s0 === peg$FAILED) {
7116
7331
  s0 = peg$currPos;
7117
7332
  if (input.charCodeAt(peg$currPos) === 116) {
7118
- s1 = peg$c76;
7333
+ s1 = peg$c77;
7119
7334
  peg$currPos++;
7120
7335
  } else {
7121
7336
  s1 = peg$FAILED;
7122
7337
  if (peg$silentFails === 0) {
7123
- peg$fail(peg$e84);
7338
+ peg$fail(peg$e85);
7124
7339
  }
7125
7340
  }
7126
7341
  if (s1 !== peg$FAILED) {
7127
7342
  peg$savedPos = s0;
7128
- s1 = peg$f105();
7343
+ s1 = peg$f106();
7129
7344
  }
7130
7345
  s0 = s1;
7131
7346
  if (s0 === peg$FAILED) {
7132
7347
  s0 = peg$currPos;
7133
7348
  if (input.charCodeAt(peg$currPos) === 92) {
7134
- s1 = peg$c73;
7349
+ s1 = peg$c74;
7135
7350
  peg$currPos++;
7136
7351
  } else {
7137
7352
  s1 = peg$FAILED;
7138
7353
  if (peg$silentFails === 0) {
7139
- peg$fail(peg$e81);
7354
+ peg$fail(peg$e82);
7140
7355
  }
7141
7356
  }
7142
7357
  if (s1 !== peg$FAILED) {
7143
7358
  peg$savedPos = s0;
7144
- s1 = peg$f106();
7359
+ s1 = peg$f107();
7145
7360
  }
7146
7361
  s0 = s1;
7147
7362
  if (s0 === peg$FAILED) {
7148
7363
  s0 = peg$currPos;
7149
7364
  if (input.charCodeAt(peg$currPos) === 34) {
7150
- s1 = peg$c71;
7365
+ s1 = peg$c72;
7151
7366
  peg$currPos++;
7152
7367
  } else {
7153
7368
  s1 = peg$FAILED;
7154
7369
  if (peg$silentFails === 0) {
7155
- peg$fail(peg$e79);
7370
+ peg$fail(peg$e80);
7156
7371
  }
7157
7372
  }
7158
7373
  if (s1 !== peg$FAILED) {
7159
7374
  peg$savedPos = s0;
7160
- s1 = peg$f107();
7375
+ s1 = peg$f108();
7161
7376
  }
7162
7377
  s0 = s1;
7163
7378
  if (s0 === peg$FAILED) {
7164
7379
  s0 = peg$currPos;
7165
7380
  if (input.charCodeAt(peg$currPos) === 39) {
7166
- s1 = peg$c72;
7381
+ s1 = peg$c73;
7167
7382
  peg$currPos++;
7168
7383
  } else {
7169
7384
  s1 = peg$FAILED;
7170
7385
  if (peg$silentFails === 0) {
7171
- peg$fail(peg$e80);
7386
+ peg$fail(peg$e81);
7172
7387
  }
7173
7388
  }
7174
7389
  if (s1 !== peg$FAILED) {
7175
7390
  peg$savedPos = s0;
7176
- s1 = peg$f108();
7391
+ s1 = peg$f109();
7177
7392
  }
7178
7393
  s0 = s1;
7179
7394
  }
@@ -7188,12 +7403,12 @@ function peg$parse(input, options) {
7188
7403
  peg$silentFails++;
7189
7404
  s0 = peg$currPos;
7190
7405
  if (input.charCodeAt(peg$currPos) === 45) {
7191
- s1 = peg$c77;
7406
+ s1 = peg$c78;
7192
7407
  peg$currPos++;
7193
7408
  } else {
7194
7409
  s1 = peg$FAILED;
7195
7410
  if (peg$silentFails === 0) {
7196
- peg$fail(peg$e86);
7411
+ peg$fail(peg$e87);
7197
7412
  }
7198
7413
  }
7199
7414
  if (s1 === peg$FAILED) {
@@ -7206,7 +7421,7 @@ function peg$parse(input, options) {
7206
7421
  } else {
7207
7422
  s3 = peg$FAILED;
7208
7423
  if (peg$silentFails === 0) {
7209
- peg$fail(peg$e74);
7424
+ peg$fail(peg$e75);
7210
7425
  }
7211
7426
  }
7212
7427
  if (s3 !== peg$FAILED) {
@@ -7218,7 +7433,7 @@ function peg$parse(input, options) {
7218
7433
  } else {
7219
7434
  s3 = peg$FAILED;
7220
7435
  if (peg$silentFails === 0) {
7221
- peg$fail(peg$e74);
7436
+ peg$fail(peg$e75);
7222
7437
  }
7223
7438
  }
7224
7439
  }
@@ -7228,12 +7443,12 @@ function peg$parse(input, options) {
7228
7443
  if (s2 !== peg$FAILED) {
7229
7444
  s3 = peg$currPos;
7230
7445
  if (input.charCodeAt(peg$currPos) === 46) {
7231
- s4 = peg$c78;
7446
+ s4 = peg$c79;
7232
7447
  peg$currPos++;
7233
7448
  } else {
7234
7449
  s4 = peg$FAILED;
7235
7450
  if (peg$silentFails === 0) {
7236
- peg$fail(peg$e87);
7451
+ peg$fail(peg$e88);
7237
7452
  }
7238
7453
  }
7239
7454
  if (s4 !== peg$FAILED) {
@@ -7244,7 +7459,7 @@ function peg$parse(input, options) {
7244
7459
  } else {
7245
7460
  s6 = peg$FAILED;
7246
7461
  if (peg$silentFails === 0) {
7247
- peg$fail(peg$e74);
7462
+ peg$fail(peg$e75);
7248
7463
  }
7249
7464
  }
7250
7465
  if (s6 !== peg$FAILED) {
@@ -7256,7 +7471,7 @@ function peg$parse(input, options) {
7256
7471
  } else {
7257
7472
  s6 = peg$FAILED;
7258
7473
  if (peg$silentFails === 0) {
7259
- peg$fail(peg$e74);
7474
+ peg$fail(peg$e75);
7260
7475
  }
7261
7476
  }
7262
7477
  }
@@ -7278,7 +7493,7 @@ function peg$parse(input, options) {
7278
7493
  s3 = null;
7279
7494
  }
7280
7495
  peg$savedPos = s0;
7281
- s0 = peg$f109(s1, s2, s3);
7496
+ s0 = peg$f110(s1, s2, s3);
7282
7497
  } else {
7283
7498
  peg$currPos = s0;
7284
7499
  s0 = peg$FAILED;
@@ -7287,7 +7502,7 @@ function peg$parse(input, options) {
7287
7502
  if (s0 === peg$FAILED) {
7288
7503
  s1 = peg$FAILED;
7289
7504
  if (peg$silentFails === 0) {
7290
- peg$fail(peg$e85);
7505
+ peg$fail(peg$e86);
7291
7506
  }
7292
7507
  }
7293
7508
  return s0;
@@ -7297,12 +7512,12 @@ function peg$parse(input, options) {
7297
7512
  peg$silentFails++;
7298
7513
  s0 = peg$currPos;
7299
7514
  if (input.charCodeAt(peg$currPos) === 45) {
7300
- s1 = peg$c77;
7515
+ s1 = peg$c78;
7301
7516
  peg$currPos++;
7302
7517
  } else {
7303
7518
  s1 = peg$FAILED;
7304
7519
  if (peg$silentFails === 0) {
7305
- peg$fail(peg$e86);
7520
+ peg$fail(peg$e87);
7306
7521
  }
7307
7522
  }
7308
7523
  if (s1 === peg$FAILED) {
@@ -7315,7 +7530,7 @@ function peg$parse(input, options) {
7315
7530
  } else {
7316
7531
  s3 = peg$FAILED;
7317
7532
  if (peg$silentFails === 0) {
7318
- peg$fail(peg$e74);
7533
+ peg$fail(peg$e75);
7319
7534
  }
7320
7535
  }
7321
7536
  if (s3 !== peg$FAILED) {
@@ -7327,7 +7542,7 @@ function peg$parse(input, options) {
7327
7542
  } else {
7328
7543
  s3 = peg$FAILED;
7329
7544
  if (peg$silentFails === 0) {
7330
- peg$fail(peg$e74);
7545
+ peg$fail(peg$e75);
7331
7546
  }
7332
7547
  }
7333
7548
  }
@@ -7337,12 +7552,12 @@ function peg$parse(input, options) {
7337
7552
  if (s2 !== peg$FAILED) {
7338
7553
  s3 = peg$currPos;
7339
7554
  if (input.charCodeAt(peg$currPos) === 46) {
7340
- s4 = peg$c78;
7555
+ s4 = peg$c79;
7341
7556
  peg$currPos++;
7342
7557
  } else {
7343
7558
  s4 = peg$FAILED;
7344
7559
  if (peg$silentFails === 0) {
7345
- peg$fail(peg$e87);
7560
+ peg$fail(peg$e88);
7346
7561
  }
7347
7562
  }
7348
7563
  if (s4 !== peg$FAILED) {
@@ -7353,7 +7568,7 @@ function peg$parse(input, options) {
7353
7568
  } else {
7354
7569
  s6 = peg$FAILED;
7355
7570
  if (peg$silentFails === 0) {
7356
- peg$fail(peg$e74);
7571
+ peg$fail(peg$e75);
7357
7572
  }
7358
7573
  }
7359
7574
  if (s6 !== peg$FAILED) {
@@ -7365,7 +7580,7 @@ function peg$parse(input, options) {
7365
7580
  } else {
7366
7581
  s6 = peg$FAILED;
7367
7582
  if (peg$silentFails === 0) {
7368
- peg$fail(peg$e74);
7583
+ peg$fail(peg$e75);
7369
7584
  }
7370
7585
  }
7371
7586
  }
@@ -7386,63 +7601,63 @@ function peg$parse(input, options) {
7386
7601
  if (s3 === peg$FAILED) {
7387
7602
  s3 = null;
7388
7603
  }
7389
- if (input.substr(peg$currPos, 2) === peg$c79) {
7390
- s4 = peg$c79;
7604
+ if (input.substr(peg$currPos, 2) === peg$c80) {
7605
+ s4 = peg$c80;
7391
7606
  peg$currPos += 2;
7392
7607
  } else {
7393
7608
  s4 = peg$FAILED;
7394
7609
  if (peg$silentFails === 0) {
7395
- peg$fail(peg$e89);
7610
+ peg$fail(peg$e90);
7396
7611
  }
7397
7612
  }
7398
7613
  if (s4 === peg$FAILED) {
7399
7614
  if (input.charCodeAt(peg$currPos) === 37) {
7400
- s4 = peg$c80;
7615
+ s4 = peg$c81;
7401
7616
  peg$currPos++;
7402
7617
  } else {
7403
7618
  s4 = peg$FAILED;
7404
7619
  if (peg$silentFails === 0) {
7405
- peg$fail(peg$e90);
7620
+ peg$fail(peg$e91);
7406
7621
  }
7407
7622
  }
7408
7623
  if (s4 === peg$FAILED) {
7409
- if (input.substr(peg$currPos, 2) === peg$c81) {
7410
- s4 = peg$c81;
7624
+ if (input.substr(peg$currPos, 2) === peg$c82) {
7625
+ s4 = peg$c82;
7411
7626
  peg$currPos += 2;
7412
7627
  } else {
7413
7628
  s4 = peg$FAILED;
7414
7629
  if (peg$silentFails === 0) {
7415
- peg$fail(peg$e91);
7630
+ peg$fail(peg$e92);
7416
7631
  }
7417
7632
  }
7418
7633
  if (s4 === peg$FAILED) {
7419
- if (input.substr(peg$currPos, 3) === peg$c82) {
7420
- s4 = peg$c82;
7634
+ if (input.substr(peg$currPos, 3) === peg$c83) {
7635
+ s4 = peg$c83;
7421
7636
  peg$currPos += 3;
7422
7637
  } else {
7423
7638
  s4 = peg$FAILED;
7424
7639
  if (peg$silentFails === 0) {
7425
- peg$fail(peg$e92);
7640
+ peg$fail(peg$e93);
7426
7641
  }
7427
7642
  }
7428
7643
  if (s4 === peg$FAILED) {
7429
- if (input.substr(peg$currPos, 2) === peg$c83) {
7430
- s4 = peg$c83;
7644
+ if (input.substr(peg$currPos, 2) === peg$c84) {
7645
+ s4 = peg$c84;
7431
7646
  peg$currPos += 2;
7432
7647
  } else {
7433
7648
  s4 = peg$FAILED;
7434
7649
  if (peg$silentFails === 0) {
7435
- peg$fail(peg$e93);
7650
+ peg$fail(peg$e94);
7436
7651
  }
7437
7652
  }
7438
7653
  if (s4 === peg$FAILED) {
7439
- if (input.substr(peg$currPos, 2) === peg$c84) {
7440
- s4 = peg$c84;
7654
+ if (input.substr(peg$currPos, 2) === peg$c85) {
7655
+ s4 = peg$c85;
7441
7656
  peg$currPos += 2;
7442
7657
  } else {
7443
7658
  s4 = peg$FAILED;
7444
7659
  if (peg$silentFails === 0) {
7445
- peg$fail(peg$e94);
7660
+ peg$fail(peg$e95);
7446
7661
  }
7447
7662
  }
7448
7663
  }
@@ -7452,7 +7667,7 @@ function peg$parse(input, options) {
7452
7667
  }
7453
7668
  if (s4 !== peg$FAILED) {
7454
7669
  peg$savedPos = s0;
7455
- s0 = peg$f110(s1, s2, s3, s4);
7670
+ s0 = peg$f111(s1, s2, s3, s4);
7456
7671
  } else {
7457
7672
  peg$currPos = s0;
7458
7673
  s0 = peg$FAILED;
@@ -7465,7 +7680,7 @@ function peg$parse(input, options) {
7465
7680
  if (s0 === peg$FAILED) {
7466
7681
  s1 = peg$FAILED;
7467
7682
  if (peg$silentFails === 0) {
7468
- peg$fail(peg$e88);
7683
+ peg$fail(peg$e89);
7469
7684
  }
7470
7685
  }
7471
7686
  return s0;
@@ -7474,34 +7689,34 @@ function peg$parse(input, options) {
7474
7689
  let s0, s1;
7475
7690
  peg$silentFails++;
7476
7691
  s0 = peg$currPos;
7477
- if (input.substr(peg$currPos, 4) === peg$c85) {
7478
- s1 = peg$c85;
7692
+ if (input.substr(peg$currPos, 4) === peg$c86) {
7693
+ s1 = peg$c86;
7479
7694
  peg$currPos += 4;
7480
7695
  } else {
7481
7696
  s1 = peg$FAILED;
7482
7697
  if (peg$silentFails === 0) {
7483
- peg$fail(peg$e96);
7698
+ peg$fail(peg$e97);
7484
7699
  }
7485
7700
  }
7486
7701
  if (s1 !== peg$FAILED) {
7487
7702
  peg$savedPos = s0;
7488
- s1 = peg$f111();
7703
+ s1 = peg$f112();
7489
7704
  }
7490
7705
  s0 = s1;
7491
7706
  if (s0 === peg$FAILED) {
7492
7707
  s0 = peg$currPos;
7493
- if (input.substr(peg$currPos, 5) === peg$c86) {
7494
- s1 = peg$c86;
7708
+ if (input.substr(peg$currPos, 5) === peg$c87) {
7709
+ s1 = peg$c87;
7495
7710
  peg$currPos += 5;
7496
7711
  } else {
7497
7712
  s1 = peg$FAILED;
7498
7713
  if (peg$silentFails === 0) {
7499
- peg$fail(peg$e97);
7714
+ peg$fail(peg$e98);
7500
7715
  }
7501
7716
  }
7502
7717
  if (s1 !== peg$FAILED) {
7503
7718
  peg$savedPos = s0;
7504
- s1 = peg$f112();
7719
+ s1 = peg$f113();
7505
7720
  }
7506
7721
  s0 = s1;
7507
7722
  }
@@ -7509,7 +7724,7 @@ function peg$parse(input, options) {
7509
7724
  if (s0 === peg$FAILED) {
7510
7725
  s1 = peg$FAILED;
7511
7726
  if (peg$silentFails === 0) {
7512
- peg$fail(peg$e95);
7727
+ peg$fail(peg$e96);
7513
7728
  }
7514
7729
  }
7515
7730
  return s0;
@@ -7524,7 +7739,7 @@ function peg$parse(input, options) {
7524
7739
  } else {
7525
7740
  s1 = peg$FAILED;
7526
7741
  if (peg$silentFails === 0) {
7527
- peg$fail(peg$e99);
7742
+ peg$fail(peg$e100);
7528
7743
  }
7529
7744
  }
7530
7745
  if (s1 !== peg$FAILED) {
@@ -7535,7 +7750,7 @@ function peg$parse(input, options) {
7535
7750
  } else {
7536
7751
  s3 = peg$FAILED;
7537
7752
  if (peg$silentFails === 0) {
7538
- peg$fail(peg$e77);
7753
+ peg$fail(peg$e78);
7539
7754
  }
7540
7755
  }
7541
7756
  while (s3 !== peg$FAILED) {
@@ -7546,12 +7761,12 @@ function peg$parse(input, options) {
7546
7761
  } else {
7547
7762
  s3 = peg$FAILED;
7548
7763
  if (peg$silentFails === 0) {
7549
- peg$fail(peg$e77);
7764
+ peg$fail(peg$e78);
7550
7765
  }
7551
7766
  }
7552
7767
  }
7553
7768
  peg$savedPos = s0;
7554
- s0 = peg$f113(s1, s2);
7769
+ s0 = peg$f114(s1, s2);
7555
7770
  } else {
7556
7771
  peg$currPos = s0;
7557
7772
  s0 = peg$FAILED;
@@ -7560,7 +7775,7 @@ function peg$parse(input, options) {
7560
7775
  if (s0 === peg$FAILED) {
7561
7776
  s1 = peg$FAILED;
7562
7777
  if (peg$silentFails === 0) {
7563
- peg$fail(peg$e98);
7778
+ peg$fail(peg$e99);
7564
7779
  }
7565
7780
  }
7566
7781
  return s0;
@@ -7569,12 +7784,12 @@ function peg$parse(input, options) {
7569
7784
  let s0, s1, s2, s3, s4, s5;
7570
7785
  s0 = peg$currPos;
7571
7786
  if (input.charCodeAt(peg$currPos) === 91) {
7572
- s1 = peg$c50;
7787
+ s1 = peg$c51;
7573
7788
  peg$currPos++;
7574
7789
  } else {
7575
7790
  s1 = peg$FAILED;
7576
7791
  if (peg$silentFails === 0) {
7577
- peg$fail(peg$e53);
7792
+ peg$fail(peg$e54);
7578
7793
  }
7579
7794
  }
7580
7795
  if (s1 !== peg$FAILED) {
@@ -7585,17 +7800,17 @@ function peg$parse(input, options) {
7585
7800
  }
7586
7801
  s4 = peg$parse_();
7587
7802
  if (input.charCodeAt(peg$currPos) === 93) {
7588
- s5 = peg$c51;
7803
+ s5 = peg$c52;
7589
7804
  peg$currPos++;
7590
7805
  } else {
7591
7806
  s5 = peg$FAILED;
7592
7807
  if (peg$silentFails === 0) {
7593
- peg$fail(peg$e54);
7808
+ peg$fail(peg$e55);
7594
7809
  }
7595
7810
  }
7596
7811
  if (s5 !== peg$FAILED) {
7597
7812
  peg$savedPos = s0;
7598
- s0 = peg$f114(s3);
7813
+ s0 = peg$f115(s3);
7599
7814
  } else {
7600
7815
  peg$currPos = s0;
7601
7816
  s0 = peg$FAILED;
@@ -7683,7 +7898,7 @@ function peg$parse(input, options) {
7683
7898
  s3 = null;
7684
7899
  }
7685
7900
  peg$savedPos = s0;
7686
- s0 = peg$f115(s1, s2);
7901
+ s0 = peg$f116(s1, s2);
7687
7902
  } else {
7688
7903
  peg$currPos = s0;
7689
7904
  s0 = peg$FAILED;
@@ -7737,7 +7952,7 @@ function peg$parse(input, options) {
7737
7952
  }
7738
7953
  if (s5 !== peg$FAILED) {
7739
7954
  peg$savedPos = s0;
7740
- s0 = peg$f116(s3);
7955
+ s0 = peg$f117(s3);
7741
7956
  } else {
7742
7957
  peg$currPos = s0;
7743
7958
  s0 = peg$FAILED;
@@ -7804,7 +8019,7 @@ function peg$parse(input, options) {
7804
8019
  }
7805
8020
  }
7806
8021
  peg$savedPos = s0;
7807
- s0 = peg$f117(s1, s2);
8022
+ s0 = peg$f118(s1, s2);
7808
8023
  } else {
7809
8024
  peg$currPos = s0;
7810
8025
  s0 = peg$FAILED;
@@ -7831,7 +8046,7 @@ function peg$parse(input, options) {
7831
8046
  s5 = peg$parseAttributeValue();
7832
8047
  if (s5 !== peg$FAILED) {
7833
8048
  peg$savedPos = s0;
7834
- s0 = peg$f118(s1, s5);
8049
+ s0 = peg$f119(s1, s5);
7835
8050
  } else {
7836
8051
  peg$currPos = s0;
7837
8052
  s0 = peg$FAILED;
@@ -7849,7 +8064,7 @@ function peg$parse(input, options) {
7849
8064
  s1 = peg$parseIdentifier();
7850
8065
  if (s1 !== peg$FAILED) {
7851
8066
  peg$savedPos = s0;
7852
- s1 = peg$f119(s1);
8067
+ s1 = peg$f120(s1);
7853
8068
  }
7854
8069
  s0 = s1;
7855
8070
  }
@@ -7882,7 +8097,7 @@ function peg$parse(input, options) {
7882
8097
  } else {
7883
8098
  s1 = peg$FAILED;
7884
8099
  if (peg$silentFails === 0) {
7885
- peg$fail(peg$e100);
8100
+ peg$fail(peg$e101);
7886
8101
  }
7887
8102
  }
7888
8103
  if (s1 !== peg$FAILED) {
@@ -7894,7 +8109,7 @@ function peg$parse(input, options) {
7894
8109
  } else {
7895
8110
  s1 = peg$FAILED;
7896
8111
  if (peg$silentFails === 0) {
7897
- peg$fail(peg$e100);
8112
+ peg$fail(peg$e101);
7898
8113
  }
7899
8114
  }
7900
8115
  }
@@ -7914,7 +8129,7 @@ function peg$parse(input, options) {
7914
8129
  if (s0 === peg$FAILED) {
7915
8130
  s1 = peg$FAILED;
7916
8131
  if (peg$silentFails === 0) {
7917
- peg$fail(peg$e101);
8132
+ peg$fail(peg$e102);
7918
8133
  }
7919
8134
  }
7920
8135
  return s0;
@@ -7939,7 +8154,7 @@ function peg$parse(input, options) {
7939
8154
  } else {
7940
8155
  s3 = peg$FAILED;
7941
8156
  if (peg$silentFails === 0) {
7942
- peg$fail(peg$e102);
8157
+ peg$fail(peg$e103);
7943
8158
  }
7944
8159
  }
7945
8160
  while (s3 !== peg$FAILED) {
@@ -7950,17 +8165,17 @@ function peg$parse(input, options) {
7950
8165
  } else {
7951
8166
  s3 = peg$FAILED;
7952
8167
  if (peg$silentFails === 0) {
7953
- peg$fail(peg$e102);
8168
+ peg$fail(peg$e103);
7954
8169
  }
7955
8170
  }
7956
8171
  }
7957
8172
  if (input.charCodeAt(peg$currPos) === 10) {
7958
- s3 = peg$c87;
8173
+ s3 = peg$c88;
7959
8174
  peg$currPos++;
7960
8175
  } else {
7961
8176
  s3 = peg$FAILED;
7962
8177
  if (peg$silentFails === 0) {
7963
- peg$fail(peg$e103);
8178
+ peg$fail(peg$e104);
7964
8179
  }
7965
8180
  }
7966
8181
  if (s3 === peg$FAILED) {
@@ -8013,13 +8228,13 @@ function peg$parse(input, options) {
8013
8228
  s3 = peg$currPos;
8014
8229
  s4 = peg$currPos;
8015
8230
  peg$silentFails++;
8016
- if (input.substr(peg$currPos, 2) === peg$c88) {
8017
- s5 = peg$c88;
8231
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8232
+ s5 = peg$c89;
8018
8233
  peg$currPos += 2;
8019
8234
  } else {
8020
8235
  s5 = peg$FAILED;
8021
8236
  if (peg$silentFails === 0) {
8022
- peg$fail(peg$e104);
8237
+ peg$fail(peg$e105);
8023
8238
  }
8024
8239
  }
8025
8240
  peg$silentFails--;
@@ -8055,13 +8270,13 @@ function peg$parse(input, options) {
8055
8270
  s3 = peg$currPos;
8056
8271
  s4 = peg$currPos;
8057
8272
  peg$silentFails++;
8058
- if (input.substr(peg$currPos, 2) === peg$c88) {
8059
- s5 = peg$c88;
8273
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8274
+ s5 = peg$c89;
8060
8275
  peg$currPos += 2;
8061
8276
  } else {
8062
8277
  s5 = peg$FAILED;
8063
8278
  if (peg$silentFails === 0) {
8064
- peg$fail(peg$e104);
8279
+ peg$fail(peg$e105);
8065
8280
  }
8066
8281
  }
8067
8282
  peg$silentFails--;
@@ -8093,13 +8308,13 @@ function peg$parse(input, options) {
8093
8308
  s3 = peg$FAILED;
8094
8309
  }
8095
8310
  }
8096
- if (input.substr(peg$currPos, 2) === peg$c88) {
8097
- s3 = peg$c88;
8311
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8312
+ s3 = peg$c89;
8098
8313
  peg$currPos += 2;
8099
8314
  } else {
8100
8315
  s3 = peg$FAILED;
8101
8316
  if (peg$silentFails === 0) {
8102
- peg$fail(peg$e104);
8317
+ peg$fail(peg$e105);
8103
8318
  }
8104
8319
  }
8105
8320
  if (s3 !== peg$FAILED) {
@@ -8274,6 +8489,7 @@ var GRAMMAR_ELEMENTS = {
8274
8489
  component: "Component",
8275
8490
  use: "ComponentUse",
8276
8491
  slot: "Slot",
8492
+ repeat: "Repeat",
8277
8493
  header: "Header",
8278
8494
  main: "Main",
8279
8495
  footer: "Footer",
@@ -8373,6 +8589,7 @@ var GRAMMAR_CHILD_KEYWORDS = [
8373
8589
  "group",
8374
8590
  "marker",
8375
8591
  "annotations",
8592
+ "repeat",
8376
8593
  "layout",
8377
8594
  "component",
8378
8595
  "use",
@@ -8764,6 +8981,16 @@ function printNodeLines(node, depth) {
8764
8981
  return componentDefinitionLines(node, depth);
8765
8982
  case "ComponentUse":
8766
8983
  return componentUseLines(node, depth);
8984
+ // `repeat 6 { … }` — the count prints bare, as the grammar's positional
8985
+ // `Integer`, which is why this cannot go through `containerLines` (that
8986
+ // helper's only pre-attribute segment is an optional *quoted* label).
8987
+ case "Repeat":
8988
+ return blockLines(
8989
+ depth,
8990
+ ["repeat", integerSegment(node, "count"), ...attrSegments(node, ["count"], node.type)],
8991
+ childrenLines(node, depth),
8992
+ "required"
8993
+ );
8767
8994
  // -- containers without a label ----------------------------------------
8768
8995
  case "Header":
8769
8996
  case "Main":
@@ -13141,6 +13368,11 @@ var ATTRIBUTE_SPECS = [
13141
13368
  type: "object[]",
13142
13369
  description: "Typed application state declarations owned by a page or shared layout"
13143
13370
  },
13371
+ {
13372
+ name: "variants",
13373
+ type: "string[]",
13374
+ description: "Named state variants of this page \u2014 each one renders the page again as a screen of its own"
13375
+ },
13144
13376
  {
13145
13377
  name: "id",
13146
13378
  type: "string",
@@ -13258,7 +13490,8 @@ var COMPONENT_METADATA = {
13258
13490
  "device",
13259
13491
  "centered",
13260
13492
  "uses",
13261
- "states"
13493
+ "states",
13494
+ "variants"
13262
13495
  ],
13263
13496
  hasChildren: true,
13264
13497
  description: "Root container for a wireframe page. Multiple pages in one .wf file lay out side-by-side on a canvas; use at(x, y) for explicit placement, or omit for auto-flow. Give it uses=<layout> to draw it inside a shared layout instead of restating the shell."
@@ -13290,6 +13523,12 @@ var COMPONENT_METADATA = {
13290
13523
  hasChildren: false,
13291
13524
  description: "Mark content insertion: bare inside a layout, or named inside a reusable component."
13292
13525
  },
13526
+ repeat: {
13527
+ category: "structure",
13528
+ attributes: [],
13529
+ hasChildren: true,
13530
+ 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."
13531
+ },
13293
13532
  header: {
13294
13533
  category: "layout",
13295
13534
  attributes: [...BOX_ATTRIBUTES, ...CONTAINER_ATTRIBUTES],
@@ -13927,6 +14166,8 @@ function pageTitle(page) {
13927
14166
  const title = page.title?.trim();
13928
14167
  return title !== void 0 && title.length > 0 ? title : void 0;
13929
14168
  }
14169
+ var VARIANT_SEPARATOR = "#";
14170
+ var variantName = (name, variant) => `${name}${VARIANT_SEPARATOR}${variant}`;
13930
14171
  function hasSlot(layout) {
13931
14172
  let found = false;
13932
14173
  for (const child of layout.children) {
@@ -13958,7 +14199,10 @@ function resolveShell(page, layouts) {
13958
14199
  function buildSiteModel(doc) {
13959
14200
  const pages = documentPages(doc);
13960
14201
  const layouts = layoutsByName(doc);
13961
- const screens = pages.map((page, index) => ({ index, page }));
14202
+ const screens = pages.map((page, index) => {
14203
+ const variant = page.variant?.trim();
14204
+ return variant !== void 0 && variant.length > 0 ? { index, page, variant } : { index, page };
14205
+ });
13962
14206
  const shells = [];
13963
14207
  const shellByName = /* @__PURE__ */ new Map();
13964
14208
  screens.forEach((screen) => {
@@ -13992,7 +14236,26 @@ function buildSiteModel(doc) {
13992
14236
  }
13993
14237
  }
13994
14238
  for (const screen of screens) {
13995
- const declared = [pageId(screen.page), pageTitle(screen.page)];
14239
+ if (screen.variant === void 0) continue;
14240
+ for (const declared of [pageId(screen.page), pageTitle(screen.page)]) {
14241
+ if (declared === void 0) continue;
14242
+ const owner = names.get(declared);
14243
+ if (owner === void 0) continue;
14244
+ const winner = screens[owner].page;
14245
+ if (pageId(winner) !== pageId(screen.page) || pageTitle(winner) !== pageTitle(screen.page)) {
14246
+ continue;
14247
+ }
14248
+ const qualified = variantName(declared, screen.variant);
14249
+ if (!names.has(qualified)) names.set(qualified, screen.index);
14250
+ }
14251
+ }
14252
+ for (const screen of screens) {
14253
+ const bare = [pageId(screen.page), pageTitle(screen.page)];
14254
+ const variant = screen.variant;
14255
+ const declared = variant === void 0 ? bare : [
14256
+ ...bare.map((name) => name === void 0 ? void 0 : variantName(name, variant)),
14257
+ ...bare
14258
+ ];
13996
14259
  screen.name = declared.find(
13997
14260
  (name) => name !== void 0 && names.get(name) === screen.index
13998
14261
  );
@@ -61863,6 +62126,7 @@ var HtmlRenderer = class extends BaseRenderer {
61863
62126
  * enabled so `renderNode` / `renderPage` can inject each node's path.
61864
62127
  */
61865
62128
  render(document) {
62129
+ document = expandRepeats(document);
61866
62130
  if (this.context.options.sourceAnchors) {
61867
62131
  this.pathMap = buildAnchorPathMap(document, this.pageIndexBase);
61868
62132
  }
@@ -62543,7 +62807,8 @@ function wrapBoard(pageHtml, placed, prefix) {
62543
62807
  const { x, y, w, h, page } = placed;
62544
62808
  const positionStyle = `position: absolute; left: ${x}px; top: ${y}px; width: ${w}px; height: ${h}px;`;
62545
62809
  const titleAttr = page.title ? ` data-page-title="${escapeAttr(page.title)}"` : "";
62546
- const dataAttrs = ` data-page-x="${x}" data-page-y="${y}" data-page-w="${w}" data-page-h="${h}"${titleAttr}`;
62810
+ const variantAttr = page.variant ? ` data-wf-variant="${escapeAttr(page.variant)}"` : "";
62811
+ const dataAttrs = ` data-page-x="${x}" data-page-y="${y}" data-page-w="${w}" data-page-h="${h}"${titleAttr}${variantAttr}`;
62547
62812
  return `<div class="${prefix}-canvas-board" style="${positionStyle}"${dataAttrs}>
62548
62813
  ${pageHtml}
62549
62814
  </div>`;
@@ -63130,6 +63395,7 @@ function renderHostedScreen(screen, shell, make, prefix) {
63130
63395
  const marks = attrs([
63131
63396
  ["data-screen", String(screen.index)],
63132
63397
  ["data-screen-name", screen.name],
63398
+ ["data-wf-variant", screen.variant],
63133
63399
  [ID_SCOPE_ATTR, scope],
63134
63400
  ["data-wf-viewport-conflict", conflict]
63135
63401
  ]);
@@ -63143,6 +63409,7 @@ function renderStandaloneScreen(screen, make, prefix) {
63143
63409
  const marks = attrs([
63144
63410
  ["data-screen", String(screen.index)],
63145
63411
  ["data-screen-name", screen.name],
63412
+ ["data-wf-variant", screen.variant],
63146
63413
  [ID_SCOPE_ATTR, scope],
63147
63414
  ["data-wf-uses-unresolved", screen.miss?.uses],
63148
63415
  ["data-wf-uses-reason", screen.miss?.reason]
@@ -63211,6 +63478,7 @@ function compactRuntimeInteractions(model, interactions) {
63211
63478
  }
63212
63479
  function renderSite(document, options = {}) {
63213
63480
  const prefix = options.classPrefix ?? DEFAULT_PREFIX2;
63481
+ document = expandRepeats(expandVariants(document));
63214
63482
  const model = buildSiteModel(document);
63215
63483
  const interactionModel = collectInteractions(document);
63216
63484
  const make = (idScope) => new HtmlRenderer({
@@ -63279,6 +63547,7 @@ ${runtime}
63279
63547
 
63280
63548
  // src/renderer/index.ts
63281
63549
  function render(document, options = {}) {
63550
+ document = expandVariants(document);
63282
63551
  const isMultiPage = documentPages(document).length > 1;
63283
63552
  if (isMultiPage) {
63284
63553
  const result = renderCanvas(document, options);
@@ -63288,6 +63557,7 @@ function render(document, options = {}) {
63288
63557
  return renderer.render(document);
63289
63558
  }
63290
63559
  function renderToHtml(document, options = {}) {
63560
+ document = expandVariants(document);
63291
63561
  const { html, css } = render(document, options);
63292
63562
  const prefix = options.classPrefix ?? "wf";
63293
63563
  const isMultiPage = documentPages(document).length > 1;
@@ -63329,6 +63599,7 @@ ${html}
63329
63599
  </html>`;
63330
63600
  }
63331
63601
  function renderToSvg(document, options = {}) {
63602
+ document = expandVariants(document);
63332
63603
  const isMultiPage = documentPages(document).length > 1;
63333
63604
  let width = options.width ?? 800;
63334
63605
  let height = options.height ?? 600;
@@ -63401,7 +63672,8 @@ var POSITIONAL_PROPS = {
63401
63672
  Layout: ["name"],
63402
63673
  Component: ["name"],
63403
63674
  ComponentUse: ["name", "namespace"],
63404
- Slot: ["name"]
63675
+ Slot: ["name"],
63676
+ Repeat: ["count"]
63405
63677
  };
63406
63678
  function declaredName(value) {
63407
63679
  const name = value?.trim();
@@ -65713,6 +65985,8 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65713
65985
  INTERACTIVE_ATTR_NAMES,
65714
65986
  LUCIDE_ICON_NAMES,
65715
65987
  NODE_TYPE_MAP,
65988
+ REPEAT_EXPANSION_BUDGET,
65989
+ RepeatBudgetError,
65716
65990
  TYPED_INTERACTION_ATTR,
65717
65991
  VALID_ATTRIBUTE_NAMES,
65718
65992
  VALID_COMPONENT_NAMES,
@@ -65739,6 +66013,8 @@ function linkAndCompileApp(manifest, modules, options = {}) {
65739
66013
  diff,
65740
66014
  documentDefinitions,
65741
66015
  documentPages,
66016
+ expandRepeats,
66017
+ expandVariants,
65742
66018
  exportToFigma,
65743
66019
  exportToFigmaString,
65744
66020
  exportToJson,