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