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