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