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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -4,6 +4,7 @@ var CONTAINER_TYPES = [
4
4
  "Layout",
5
5
  "Component",
6
6
  "ComponentUse",
7
+ "Repeat",
7
8
  "Header",
8
9
  "Main",
9
10
  "Footer",
@@ -355,6 +356,129 @@ function collectParameterReferences(children) {
355
356
  return found;
356
357
  }
357
358
 
359
+ // src/ast/expand-repeats.ts
360
+ var REPEAT_EXPANSION_BUDGET = 500;
361
+ var RepeatBudgetError = class extends Error {
362
+ constructor(budget) {
363
+ super(
364
+ `repeat expansion exceeds ${budget} nodes \u2014 nesting multiplies, so check the nested counts rather than the outermost one`
365
+ );
366
+ this.name = "RepeatBudgetError";
367
+ }
368
+ };
369
+ function cloneNode2(value) {
370
+ if (Array.isArray(value)) return value.map(cloneNode2);
371
+ if (value === null || typeof value !== "object") return value;
372
+ const source = value;
373
+ const result = {};
374
+ for (const [key, item] of Object.entries(source)) {
375
+ result[key] = key === "loc" ? item : cloneNode2(item);
376
+ }
377
+ return result;
378
+ }
379
+ function containsRepeat(node) {
380
+ if (node.type === "Repeat") return true;
381
+ const children = node.children;
382
+ if (Array.isArray(children)) {
383
+ for (const child of children) if (containsRepeat(child)) return true;
384
+ }
385
+ const fills = node.fills;
386
+ if (Array.isArray(fills)) {
387
+ for (const fill of fills) {
388
+ for (const child of fill.children ?? []) if (containsRepeat(child)) return true;
389
+ }
390
+ }
391
+ return false;
392
+ }
393
+ function expandOne(node, budget) {
394
+ if (node.type === "Repeat") {
395
+ const repeat = node;
396
+ const count = Number.isInteger(repeat.count) && repeat.count > 0 ? repeat.count : 0;
397
+ const result = [];
398
+ for (let i = 0; i < count; i++) {
399
+ for (const child of repeat.children) {
400
+ for (const expanded of expandOne(child, budget)) {
401
+ budget.remaining -= 1;
402
+ if (budget.remaining < 0) throw new RepeatBudgetError(REPEAT_EXPANSION_BUDGET);
403
+ result.push(cloneNode2(expanded));
404
+ }
405
+ }
406
+ }
407
+ return result;
408
+ }
409
+ if (!containsRepeat(node)) return [node];
410
+ const clone = { ...node };
411
+ const children = clone.children;
412
+ if (Array.isArray(children)) {
413
+ clone.children = children.flatMap((child) => expandOne(child, budget));
414
+ }
415
+ const fills = clone.fills;
416
+ if (Array.isArray(fills)) {
417
+ clone.fills = fills.map((fill) => ({
418
+ ...fill,
419
+ children: (fill.children ?? []).flatMap((child) => expandOne(child, budget))
420
+ }));
421
+ }
422
+ return [clone];
423
+ }
424
+ function expandRepeats(document) {
425
+ if (!document.children.some((child) => containsRepeat(child))) return document;
426
+ const budget = { remaining: REPEAT_EXPANSION_BUDGET };
427
+ return {
428
+ ...document,
429
+ children: document.children.flatMap(
430
+ (child) => expandOne(child, budget)
431
+ )
432
+ };
433
+ }
434
+
435
+ // src/ast/expand-variants.ts
436
+ function cloneNode3(value) {
437
+ if (Array.isArray(value)) return value.map(cloneNode3);
438
+ if (value === null || typeof value !== "object") return value;
439
+ const source = value;
440
+ const result = {};
441
+ for (const [key, item] of Object.entries(source)) {
442
+ result[key] = key === "loc" ? item : cloneNode3(item);
443
+ }
444
+ return result;
445
+ }
446
+ function variantNames(page) {
447
+ const declared = page.variants;
448
+ if (!Array.isArray(declared)) return [];
449
+ const seen = /* @__PURE__ */ new Set();
450
+ const names = [];
451
+ for (const raw of declared) {
452
+ if (typeof raw !== "string") continue;
453
+ const name = raw.trim();
454
+ if (name.length === 0 || seen.has(name)) continue;
455
+ seen.add(name);
456
+ names.push(name);
457
+ }
458
+ return names;
459
+ }
460
+ function hasVariants(document) {
461
+ return document.children.some((child) => child.type === "Page" && variantNames(child).length > 0);
462
+ }
463
+ function expandVariants(document) {
464
+ if (!hasVariants(document)) return document;
465
+ return {
466
+ ...document,
467
+ children: document.children.flatMap((child) => {
468
+ if (child.type !== "Page") return [child];
469
+ const names = variantNames(child);
470
+ if (names.length === 0) return [child];
471
+ return names.map((variant, position) => {
472
+ const clone = cloneNode3(child);
473
+ delete clone.variants;
474
+ clone.variant = variant;
475
+ if (position > 0) delete clone.states;
476
+ return clone;
477
+ });
478
+ })
479
+ };
480
+ }
481
+
358
482
  // src/parser/generated-parser.js
359
483
  var peg$SyntaxError = class extends SyntaxError {
360
484
  constructor(message, expected, found, location) {
@@ -484,75 +608,76 @@ function peg$parse(input, options) {
484
608
  const peg$c17 = "\r\n";
485
609
  const peg$c18 = "//";
486
610
  const peg$c19 = "/*";
487
- const peg$c20 = "header";
488
- const peg$c21 = "main";
489
- const peg$c22 = "footer";
490
- const peg$c23 = "sidebar";
491
- const peg$c24 = "row";
492
- const peg$c25 = "col";
493
- const peg$c26 = "stack";
494
- const peg$c27 = "relative";
495
- const peg$c28 = "card";
496
- const peg$c29 = "modal";
497
- const peg$c30 = "drawer";
498
- const peg$c31 = "accordion";
499
- const peg$c32 = "section";
500
- const peg$c33 = "text";
501
- const peg$c34 = "title";
502
- const peg$c35 = "link";
503
- const peg$c36 = "button";
504
- const peg$c37 = "input";
505
- const peg$c38 = "textarea";
506
- const peg$c39 = "select";
507
- const peg$c40 = "checkbox";
508
- const peg$c41 = "radio";
509
- const peg$c42 = "switch";
510
- const peg$c43 = "slider";
511
- const peg$c44 = "image";
512
- const peg$c45 = "placeholder";
513
- const peg$c46 = "avatar";
514
- const peg$c47 = "badge";
515
- const peg$c48 = "icon";
516
- const peg$c49 = "table";
517
- const peg$c50 = "[";
518
- const peg$c51 = "]";
519
- const peg$c52 = "columns";
520
- const peg$c53 = "list";
521
- const peg$c54 = "item";
522
- const peg$c55 = "alert";
523
- const peg$c56 = "toast";
524
- const peg$c57 = "progress";
525
- const peg$c58 = "spinner";
526
- const peg$c59 = "tooltip";
527
- const peg$c60 = "popover";
528
- const peg$c61 = "dropdown";
529
- const peg$c62 = "divider";
530
- const peg$c63 = "nav";
531
- const peg$c64 = "group";
532
- const peg$c65 = "tabs";
533
- const peg$c66 = "tab";
534
- const peg$c67 = "breadcrumb";
535
- const peg$c68 = "marker";
536
- const peg$c69 = "annotations";
537
- const peg$c70 = "at";
538
- const peg$c71 = '"';
539
- const peg$c72 = "'";
540
- const peg$c73 = "\\";
541
- const peg$c74 = "n";
542
- const peg$c75 = "r";
543
- const peg$c76 = "t";
544
- const peg$c77 = "-";
545
- const peg$c78 = ".";
546
- const peg$c79 = "px";
547
- const peg$c80 = "%";
548
- const peg$c81 = "em";
549
- const peg$c82 = "rem";
550
- const peg$c83 = "vh";
551
- const peg$c84 = "vw";
552
- const peg$c85 = "true";
553
- const peg$c86 = "false";
554
- const peg$c87 = "\n";
555
- const peg$c88 = "*/";
611
+ const peg$c20 = "repeat";
612
+ const peg$c21 = "header";
613
+ const peg$c22 = "main";
614
+ const peg$c23 = "footer";
615
+ const peg$c24 = "sidebar";
616
+ const peg$c25 = "row";
617
+ const peg$c26 = "col";
618
+ const peg$c27 = "stack";
619
+ const peg$c28 = "relative";
620
+ const peg$c29 = "card";
621
+ const peg$c30 = "modal";
622
+ const peg$c31 = "drawer";
623
+ const peg$c32 = "accordion";
624
+ const peg$c33 = "section";
625
+ const peg$c34 = "text";
626
+ const peg$c35 = "title";
627
+ const peg$c36 = "link";
628
+ const peg$c37 = "button";
629
+ const peg$c38 = "input";
630
+ const peg$c39 = "textarea";
631
+ const peg$c40 = "select";
632
+ const peg$c41 = "checkbox";
633
+ const peg$c42 = "radio";
634
+ const peg$c43 = "switch";
635
+ const peg$c44 = "slider";
636
+ const peg$c45 = "image";
637
+ const peg$c46 = "placeholder";
638
+ const peg$c47 = "avatar";
639
+ const peg$c48 = "badge";
640
+ const peg$c49 = "icon";
641
+ const peg$c50 = "table";
642
+ const peg$c51 = "[";
643
+ const peg$c52 = "]";
644
+ const peg$c53 = "columns";
645
+ const peg$c54 = "list";
646
+ const peg$c55 = "item";
647
+ const peg$c56 = "alert";
648
+ const peg$c57 = "toast";
649
+ const peg$c58 = "progress";
650
+ const peg$c59 = "spinner";
651
+ const peg$c60 = "tooltip";
652
+ const peg$c61 = "popover";
653
+ const peg$c62 = "dropdown";
654
+ const peg$c63 = "divider";
655
+ const peg$c64 = "nav";
656
+ const peg$c65 = "group";
657
+ const peg$c66 = "tabs";
658
+ const peg$c67 = "tab";
659
+ const peg$c68 = "breadcrumb";
660
+ const peg$c69 = "marker";
661
+ const peg$c70 = "annotations";
662
+ const peg$c71 = "at";
663
+ const peg$c72 = '"';
664
+ const peg$c73 = "'";
665
+ const peg$c74 = "\\";
666
+ const peg$c75 = "n";
667
+ const peg$c76 = "r";
668
+ const peg$c77 = "t";
669
+ const peg$c78 = "-";
670
+ const peg$c79 = ".";
671
+ const peg$c80 = "px";
672
+ const peg$c81 = "%";
673
+ const peg$c82 = "em";
674
+ const peg$c83 = "rem";
675
+ const peg$c84 = "vh";
676
+ const peg$c85 = "vw";
677
+ const peg$c86 = "true";
678
+ const peg$c87 = "false";
679
+ const peg$c88 = "\n";
680
+ const peg$c89 = "*/";
556
681
  const peg$r0 = /^[ \t]/;
557
682
  const peg$r1 = /^[\n\r}]/;
558
683
  const peg$r2 = /^[0-9]/;
@@ -584,88 +709,89 @@ function peg$parse(input, options) {
584
709
  const peg$e20 = peg$literalExpectation("//", false);
585
710
  const peg$e21 = peg$literalExpectation("/*", false);
586
711
  const peg$e22 = peg$anyExpectation();
587
- const peg$e23 = peg$literalExpectation("header", false);
588
- const peg$e24 = peg$literalExpectation("main", false);
589
- const peg$e25 = peg$literalExpectation("footer", false);
590
- const peg$e26 = peg$literalExpectation("sidebar", false);
591
- const peg$e27 = peg$literalExpectation("row", false);
592
- const peg$e28 = peg$literalExpectation("col", false);
593
- const peg$e29 = peg$literalExpectation("stack", false);
594
- const peg$e30 = peg$literalExpectation("relative", false);
595
- const peg$e31 = peg$literalExpectation("card", false);
596
- const peg$e32 = peg$literalExpectation("modal", false);
597
- const peg$e33 = peg$literalExpectation("drawer", false);
598
- const peg$e34 = peg$literalExpectation("accordion", false);
599
- const peg$e35 = peg$literalExpectation("section", false);
600
- const peg$e36 = peg$literalExpectation("text", false);
601
- const peg$e37 = peg$literalExpectation("title", false);
602
- const peg$e38 = peg$literalExpectation("link", false);
603
- const peg$e39 = peg$literalExpectation("button", false);
604
- const peg$e40 = peg$literalExpectation("input", false);
605
- const peg$e41 = peg$literalExpectation("textarea", false);
606
- const peg$e42 = peg$literalExpectation("select", false);
607
- const peg$e43 = peg$literalExpectation("checkbox", false);
608
- const peg$e44 = peg$literalExpectation("radio", false);
609
- const peg$e45 = peg$literalExpectation("switch", false);
610
- const peg$e46 = peg$literalExpectation("slider", false);
611
- const peg$e47 = peg$literalExpectation("image", false);
612
- const peg$e48 = peg$literalExpectation("placeholder", false);
613
- const peg$e49 = peg$literalExpectation("avatar", false);
614
- const peg$e50 = peg$literalExpectation("badge", false);
615
- const peg$e51 = peg$literalExpectation("icon", false);
616
- const peg$e52 = peg$literalExpectation("table", false);
617
- const peg$e53 = peg$literalExpectation("[", false);
618
- const peg$e54 = peg$literalExpectation("]", false);
619
- const peg$e55 = peg$literalExpectation("columns", false);
620
- const peg$e56 = peg$literalExpectation("list", false);
621
- const peg$e57 = peg$literalExpectation("item", false);
622
- const peg$e58 = peg$literalExpectation("alert", false);
623
- const peg$e59 = peg$literalExpectation("toast", false);
624
- const peg$e60 = peg$literalExpectation("progress", false);
625
- const peg$e61 = peg$literalExpectation("spinner", false);
626
- const peg$e62 = peg$literalExpectation("tooltip", false);
627
- const peg$e63 = peg$literalExpectation("popover", false);
628
- const peg$e64 = peg$literalExpectation("dropdown", false);
629
- const peg$e65 = peg$literalExpectation("divider", false);
630
- const peg$e66 = peg$literalExpectation("nav", false);
631
- const peg$e67 = peg$literalExpectation("group", false);
632
- const peg$e68 = peg$literalExpectation("tabs", false);
633
- const peg$e69 = peg$literalExpectation("tab", false);
634
- const peg$e70 = peg$literalExpectation("breadcrumb", false);
635
- const peg$e71 = peg$literalExpectation("marker", false);
636
- const peg$e72 = peg$literalExpectation("annotations", false);
637
- const peg$e73 = peg$otherExpectation("integer");
638
- const peg$e74 = peg$classExpectation([["0", "9"]], false, false, false);
639
- const peg$e75 = peg$literalExpectation("at", false);
640
- const peg$e76 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
641
- const peg$e77 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
642
- const peg$e78 = peg$otherExpectation("string");
643
- const peg$e79 = peg$literalExpectation('"', false);
644
- const peg$e80 = peg$literalExpectation("'", false);
645
- const peg$e81 = peg$literalExpectation("\\", false);
646
- const peg$e82 = peg$literalExpectation("n", false);
647
- const peg$e83 = peg$literalExpectation("r", false);
648
- const peg$e84 = peg$literalExpectation("t", false);
649
- const peg$e85 = peg$otherExpectation("number");
650
- const peg$e86 = peg$literalExpectation("-", false);
651
- const peg$e87 = peg$literalExpectation(".", false);
652
- const peg$e88 = peg$otherExpectation("value with unit");
653
- const peg$e89 = peg$literalExpectation("px", false);
654
- const peg$e90 = peg$literalExpectation("%", false);
655
- const peg$e91 = peg$literalExpectation("em", false);
656
- const peg$e92 = peg$literalExpectation("rem", false);
657
- const peg$e93 = peg$literalExpectation("vh", false);
658
- const peg$e94 = peg$literalExpectation("vw", false);
659
- const peg$e95 = peg$otherExpectation("boolean");
660
- const peg$e96 = peg$literalExpectation("true", false);
661
- const peg$e97 = peg$literalExpectation("false", false);
662
- const peg$e98 = peg$otherExpectation("identifier");
663
- const peg$e99 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
664
- const peg$e100 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
665
- const peg$e101 = peg$otherExpectation("comment");
666
- const peg$e102 = peg$classExpectation(["\n"], true, false, false);
667
- const peg$e103 = peg$literalExpectation("\n", false);
668
- const peg$e104 = peg$literalExpectation("*/", false);
712
+ const peg$e23 = peg$literalExpectation("repeat", false);
713
+ const peg$e24 = peg$literalExpectation("header", false);
714
+ const peg$e25 = peg$literalExpectation("main", false);
715
+ const peg$e26 = peg$literalExpectation("footer", false);
716
+ const peg$e27 = peg$literalExpectation("sidebar", false);
717
+ const peg$e28 = peg$literalExpectation("row", false);
718
+ const peg$e29 = peg$literalExpectation("col", false);
719
+ const peg$e30 = peg$literalExpectation("stack", false);
720
+ const peg$e31 = peg$literalExpectation("relative", false);
721
+ const peg$e32 = peg$literalExpectation("card", false);
722
+ const peg$e33 = peg$literalExpectation("modal", false);
723
+ const peg$e34 = peg$literalExpectation("drawer", false);
724
+ const peg$e35 = peg$literalExpectation("accordion", false);
725
+ const peg$e36 = peg$literalExpectation("section", false);
726
+ const peg$e37 = peg$literalExpectation("text", false);
727
+ const peg$e38 = peg$literalExpectation("title", false);
728
+ const peg$e39 = peg$literalExpectation("link", false);
729
+ const peg$e40 = peg$literalExpectation("button", false);
730
+ const peg$e41 = peg$literalExpectation("input", false);
731
+ const peg$e42 = peg$literalExpectation("textarea", false);
732
+ const peg$e43 = peg$literalExpectation("select", false);
733
+ const peg$e44 = peg$literalExpectation("checkbox", false);
734
+ const peg$e45 = peg$literalExpectation("radio", false);
735
+ const peg$e46 = peg$literalExpectation("switch", false);
736
+ const peg$e47 = peg$literalExpectation("slider", false);
737
+ const peg$e48 = peg$literalExpectation("image", false);
738
+ const peg$e49 = peg$literalExpectation("placeholder", false);
739
+ const peg$e50 = peg$literalExpectation("avatar", false);
740
+ const peg$e51 = peg$literalExpectation("badge", false);
741
+ const peg$e52 = peg$literalExpectation("icon", false);
742
+ const peg$e53 = peg$literalExpectation("table", false);
743
+ const peg$e54 = peg$literalExpectation("[", false);
744
+ const peg$e55 = peg$literalExpectation("]", false);
745
+ const peg$e56 = peg$literalExpectation("columns", false);
746
+ const peg$e57 = peg$literalExpectation("list", false);
747
+ const peg$e58 = peg$literalExpectation("item", false);
748
+ const peg$e59 = peg$literalExpectation("alert", false);
749
+ const peg$e60 = peg$literalExpectation("toast", false);
750
+ const peg$e61 = peg$literalExpectation("progress", false);
751
+ const peg$e62 = peg$literalExpectation("spinner", false);
752
+ const peg$e63 = peg$literalExpectation("tooltip", false);
753
+ const peg$e64 = peg$literalExpectation("popover", false);
754
+ const peg$e65 = peg$literalExpectation("dropdown", false);
755
+ const peg$e66 = peg$literalExpectation("divider", false);
756
+ const peg$e67 = peg$literalExpectation("nav", false);
757
+ const peg$e68 = peg$literalExpectation("group", false);
758
+ const peg$e69 = peg$literalExpectation("tabs", false);
759
+ const peg$e70 = peg$literalExpectation("tab", false);
760
+ const peg$e71 = peg$literalExpectation("breadcrumb", false);
761
+ const peg$e72 = peg$literalExpectation("marker", false);
762
+ const peg$e73 = peg$literalExpectation("annotations", false);
763
+ const peg$e74 = peg$otherExpectation("integer");
764
+ const peg$e75 = peg$classExpectation([["0", "9"]], false, false, false);
765
+ const peg$e76 = peg$literalExpectation("at", false);
766
+ const peg$e77 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
767
+ const peg$e78 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
768
+ const peg$e79 = peg$otherExpectation("string");
769
+ const peg$e80 = peg$literalExpectation('"', false);
770
+ const peg$e81 = peg$literalExpectation("'", false);
771
+ const peg$e82 = peg$literalExpectation("\\", false);
772
+ const peg$e83 = peg$literalExpectation("n", false);
773
+ const peg$e84 = peg$literalExpectation("r", false);
774
+ const peg$e85 = peg$literalExpectation("t", false);
775
+ const peg$e86 = peg$otherExpectation("number");
776
+ const peg$e87 = peg$literalExpectation("-", false);
777
+ const peg$e88 = peg$literalExpectation(".", false);
778
+ const peg$e89 = peg$otherExpectation("value with unit");
779
+ const peg$e90 = peg$literalExpectation("px", false);
780
+ const peg$e91 = peg$literalExpectation("%", false);
781
+ const peg$e92 = peg$literalExpectation("em", false);
782
+ const peg$e93 = peg$literalExpectation("rem", false);
783
+ const peg$e94 = peg$literalExpectation("vh", false);
784
+ const peg$e95 = peg$literalExpectation("vw", false);
785
+ const peg$e96 = peg$otherExpectation("boolean");
786
+ const peg$e97 = peg$literalExpectation("true", false);
787
+ const peg$e98 = peg$literalExpectation("false", false);
788
+ const peg$e99 = peg$otherExpectation("identifier");
789
+ const peg$e100 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
790
+ const peg$e101 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
791
+ const peg$e102 = peg$otherExpectation("comment");
792
+ const peg$e103 = peg$classExpectation(["\n"], true, false, false);
793
+ const peg$e104 = peg$literalExpectation("\n", false);
794
+ const peg$e105 = peg$literalExpectation("*/", false);
669
795
  function peg$f0(children) {
670
796
  return createNode("Document", {
671
797
  children: children.map((c) => c[0]).filter((c) => c !== null)
@@ -746,114 +872,120 @@ function peg$parse(input, options) {
746
872
  function peg$f18() {
747
873
  return null;
748
874
  }
749
- function peg$f19(attrs2, children) {
875
+ function peg$f19(count, children) {
876
+ return createNode("Repeat", {
877
+ count,
878
+ children
879
+ });
880
+ }
881
+ function peg$f20(attrs2, children) {
750
882
  return createNode("Header", {
751
883
  ...attrsToObject(attrs2),
752
884
  children
753
885
  });
754
886
  }
755
- function peg$f20(attrs2, children) {
887
+ function peg$f21(attrs2, children) {
756
888
  return createNode("Main", {
757
889
  ...attrsToObject(attrs2),
758
890
  children
759
891
  });
760
892
  }
761
- function peg$f21(attrs2, children) {
893
+ function peg$f22(attrs2, children) {
762
894
  return createNode("Footer", {
763
895
  ...attrsToObject(attrs2),
764
896
  children
765
897
  });
766
898
  }
767
- function peg$f22(attrs2, children) {
899
+ function peg$f23(attrs2, children) {
768
900
  return createNode("Sidebar", {
769
901
  ...attrsToObject(attrs2),
770
902
  children
771
903
  });
772
904
  }
773
- function peg$f23(attrs2, children) {
905
+ function peg$f24(attrs2, children) {
774
906
  return createNode("Row", {
775
907
  ...attrsToObject(attrs2),
776
908
  children
777
909
  });
778
910
  }
779
- function peg$f24(attrs2, children) {
911
+ function peg$f25(attrs2, children) {
780
912
  return createNode("Col", {
781
913
  ...attrsToObject(attrs2),
782
914
  children
783
915
  });
784
916
  }
785
- function peg$f25(attrs2, children) {
917
+ function peg$f26(attrs2, children) {
786
918
  return createNode("Stack", {
787
919
  ...attrsToObject(attrs2),
788
920
  children
789
921
  });
790
922
  }
791
- function peg$f26(attrs2, children) {
923
+ function peg$f27(attrs2, children) {
792
924
  return createNode("Relative", {
793
925
  ...attrsToObject(attrs2),
794
926
  children
795
927
  });
796
928
  }
797
- function peg$f27(label, attrs2, children) {
929
+ function peg$f28(label, attrs2, children) {
798
930
  return createNode("Card", {
799
931
  title: label || null,
800
932
  ...attrsToObject(attrs2),
801
933
  children
802
934
  });
803
935
  }
804
- function peg$f28(label, attrs2, children) {
936
+ function peg$f29(label, attrs2, children) {
805
937
  return createNode("Modal", {
806
938
  title: label || null,
807
939
  ...attrsToObject(attrs2),
808
940
  children
809
941
  });
810
942
  }
811
- function peg$f29(label, attrs2, children) {
943
+ function peg$f30(label, attrs2, children) {
812
944
  return createNode("Drawer", {
813
945
  title: label || null,
814
946
  ...attrsToObject(attrs2),
815
947
  children
816
948
  });
817
949
  }
818
- function peg$f30(label, attrs2, children) {
950
+ function peg$f31(label, attrs2, children) {
819
951
  return createNode("Accordion", {
820
952
  title: label || null,
821
953
  ...attrsToObject(attrs2),
822
954
  children
823
955
  });
824
956
  }
825
- function peg$f31(label, attrs2, children) {
957
+ function peg$f32(label, attrs2, children) {
826
958
  return createNode("Section", {
827
959
  title: label || null,
828
960
  ...attrsToObject(attrs2),
829
961
  children
830
962
  });
831
963
  }
832
- function peg$f32(label, attrs2) {
964
+ function peg$f33(label, attrs2) {
833
965
  return createNode("Text", {
834
966
  content: label,
835
967
  ...attrsToObject(attrs2)
836
968
  });
837
969
  }
838
- function peg$f33(label, attrs2) {
970
+ function peg$f34(label, attrs2) {
839
971
  return createNode("Title", {
840
972
  content: label,
841
973
  ...attrsToObject(attrs2)
842
974
  });
843
975
  }
844
- function peg$f34(label, attrs2) {
976
+ function peg$f35(label, attrs2) {
845
977
  return createNode("Link", {
846
978
  content: label,
847
979
  ...attrsToObject(attrs2)
848
980
  });
849
981
  }
850
- function peg$f35(label, attrs2) {
982
+ function peg$f36(label, attrs2) {
851
983
  return createNode("Button", {
852
984
  content: label,
853
985
  ...attrsToObject(attrs2)
854
986
  });
855
987
  }
856
- function peg$f36(label, attrs2) {
988
+ function peg$f37(label, attrs2) {
857
989
  const obj = attrsToObject(attrs2);
858
990
  const inputType = obj.type;
859
991
  delete obj.type;
@@ -863,75 +995,75 @@ function peg$parse(input, options) {
863
995
  ...obj
864
996
  });
865
997
  }
866
- function peg$f37(label, attrs2) {
998
+ function peg$f38(label, attrs2) {
867
999
  return createNode("Textarea", {
868
1000
  label: label || null,
869
1001
  ...attrsToObject(attrs2)
870
1002
  });
871
1003
  }
872
- function peg$f38(label, options2, attrs2) {
1004
+ function peg$f39(label, options2, attrs2) {
873
1005
  return createNode("Select", {
874
1006
  label: label || null,
875
1007
  options: options2 || [],
876
1008
  ...attrsToObject(attrs2)
877
1009
  });
878
1010
  }
879
- function peg$f39(label, attrs2) {
1011
+ function peg$f40(label, attrs2) {
880
1012
  return createNode("Checkbox", {
881
1013
  label: label || null,
882
1014
  ...attrsToObject(attrs2)
883
1015
  });
884
1016
  }
885
- function peg$f40(label, attrs2) {
1017
+ function peg$f41(label, attrs2) {
886
1018
  return createNode("Radio", {
887
1019
  label: label || null,
888
1020
  ...attrsToObject(attrs2)
889
1021
  });
890
1022
  }
891
- function peg$f41(label, attrs2) {
1023
+ function peg$f42(label, attrs2) {
892
1024
  return createNode("Switch", {
893
1025
  label: label || null,
894
1026
  ...attrsToObject(attrs2)
895
1027
  });
896
1028
  }
897
- function peg$f42(label, attrs2) {
1029
+ function peg$f43(label, attrs2) {
898
1030
  return createNode("Slider", {
899
1031
  label: label || null,
900
1032
  ...attrsToObject(attrs2)
901
1033
  });
902
1034
  }
903
- function peg$f43(src, attrs2) {
1035
+ function peg$f44(src, attrs2) {
904
1036
  return createNode("Image", {
905
1037
  src: src || null,
906
1038
  ...attrsToObject(attrs2)
907
1039
  });
908
1040
  }
909
- function peg$f44(label, attrs2, block) {
1041
+ function peg$f45(label, attrs2, block) {
910
1042
  return createNode("Placeholder", {
911
1043
  label: label || null,
912
1044
  ...attrsToObject(attrs2),
913
1045
  children: block ? block[2] : []
914
1046
  });
915
1047
  }
916
- function peg$f45(label, attrs2) {
1048
+ function peg$f46(label, attrs2) {
917
1049
  return createNode("Avatar", {
918
1050
  name: label || null,
919
1051
  ...attrsToObject(attrs2)
920
1052
  });
921
1053
  }
922
- function peg$f46(label, attrs2) {
1054
+ function peg$f47(label, attrs2) {
923
1055
  return createNode("Badge", {
924
1056
  content: label,
925
1057
  ...attrsToObject(attrs2)
926
1058
  });
927
1059
  }
928
- function peg$f47(name, attrs2) {
1060
+ function peg$f48(name, attrs2) {
929
1061
  return createNode("Icon", {
930
1062
  name,
931
1063
  ...attrsToObject(attrs2)
932
1064
  });
933
1065
  }
934
- function peg$f48(data, attrs2) {
1066
+ function peg$f49(data, attrs2) {
935
1067
  const columns = data.length > 0 ? data[0] : [];
936
1068
  const rows = data.slice(1);
937
1069
  return createNode("Table", {
@@ -940,16 +1072,16 @@ function peg$parse(input, options) {
940
1072
  ...attrsToObject(attrs2)
941
1073
  });
942
1074
  }
943
- function peg$f49(attrs2, rows) {
1075
+ function peg$f50(attrs2, rows) {
944
1076
  return createNode("Table", {
945
1077
  ...attrsToObject(attrs2),
946
1078
  ...rows
947
1079
  });
948
1080
  }
949
- function peg$f50(first, rest) {
1081
+ function peg$f51(first, rest) {
950
1082
  return [first, ...rest.map((r) => r[2])];
951
1083
  }
952
- function peg$f51(items) {
1084
+ function peg$f52(items) {
953
1085
  const columns = [];
954
1086
  const rows = [];
955
1087
  for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
@@ -958,72 +1090,72 @@ function peg$parse(input, options) {
958
1090
  }
959
1091
  return { columns, rows };
960
1092
  }
961
- function peg$f52(values) {
1093
+ function peg$f53(values) {
962
1094
  return { kind: "columns", values };
963
1095
  }
964
- function peg$f53(values) {
1096
+ function peg$f54(values) {
965
1097
  return { kind: "row", values };
966
1098
  }
967
- function peg$f54() {
1099
+ function peg$f55() {
968
1100
  return null;
969
1101
  }
970
- function peg$f55(items, attrs2, block) {
1102
+ function peg$f56(items, attrs2, block) {
971
1103
  return createNode("List", {
972
1104
  items: items || (block ? block : []),
973
1105
  ...attrsToObject(attrs2)
974
1106
  });
975
1107
  }
976
- function peg$f56(items) {
1108
+ function peg$f57(items) {
977
1109
  return items.map((i) => i[0]).filter((i) => i !== null);
978
1110
  }
979
- function peg$f57(label, attrs2, nested) {
1111
+ function peg$f58(label, attrs2, nested) {
980
1112
  return createBlockNode("ListItem", {
981
1113
  content: label,
982
1114
  ...attrsToObject(attrs2),
983
1115
  children: nested || []
984
1116
  });
985
1117
  }
986
- function peg$f58() {
1118
+ function peg$f59() {
987
1119
  return null;
988
1120
  }
989
- function peg$f59(label, attrs2) {
1121
+ function peg$f60(label, attrs2) {
990
1122
  return createNode("Alert", {
991
1123
  content: label,
992
1124
  ...attrsToObject(attrs2)
993
1125
  });
994
1126
  }
995
- function peg$f60(label, attrs2) {
1127
+ function peg$f61(label, attrs2) {
996
1128
  return createNode("Toast", {
997
1129
  content: label,
998
1130
  ...attrsToObject(attrs2)
999
1131
  });
1000
1132
  }
1001
- function peg$f61(attrs2) {
1133
+ function peg$f62(attrs2) {
1002
1134
  return createNode("Progress", {
1003
1135
  ...attrsToObject(attrs2)
1004
1136
  });
1005
1137
  }
1006
- function peg$f62(label, attrs2) {
1138
+ function peg$f63(label, attrs2) {
1007
1139
  return createNode("Spinner", {
1008
1140
  label: label || null,
1009
1141
  ...attrsToObject(attrs2)
1010
1142
  });
1011
1143
  }
1012
- function peg$f63(label, attrs2) {
1144
+ function peg$f64(label, attrs2) {
1013
1145
  return createNode("Tooltip", {
1014
1146
  content: label,
1015
1147
  ...attrsToObject(attrs2),
1016
1148
  children: []
1017
1149
  });
1018
1150
  }
1019
- function peg$f64(label, attrs2, children) {
1151
+ function peg$f65(label, attrs2, children) {
1020
1152
  return createNode("Popover", {
1021
1153
  title: label || null,
1022
1154
  ...attrsToObject(attrs2),
1023
1155
  children
1024
1156
  });
1025
1157
  }
1026
- function peg$f65(items, attrs2) {
1158
+ function peg$f66(items, attrs2) {
1027
1159
  const processedItems = items.map((item) => {
1028
1160
  if (typeof item === "string") {
1029
1161
  if (item === "---" || item === "-" || item === "divider") {
@@ -1038,106 +1170,106 @@ function peg$parse(input, options) {
1038
1170
  items: processedItems
1039
1171
  });
1040
1172
  }
1041
- function peg$f66(attrs2, items) {
1173
+ function peg$f67(attrs2, items) {
1042
1174
  return createNode("Dropdown", {
1043
1175
  ...attrsToObject(attrs2),
1044
1176
  items
1045
1177
  });
1046
1178
  }
1047
- function peg$f67(items) {
1179
+ function peg$f68(items) {
1048
1180
  return items.map((i) => i[0]).filter((i) => i !== null);
1049
1181
  }
1050
- function peg$f68(label, attrs2) {
1182
+ function peg$f69(label, attrs2) {
1051
1183
  return createBlockNode("DropdownItem", { label, ...attrsToObject(attrs2) });
1052
1184
  }
1053
- function peg$f69() {
1185
+ function peg$f70() {
1054
1186
  return createBlockNode("Divider", {});
1055
1187
  }
1056
- function peg$f70() {
1188
+ function peg$f71() {
1057
1189
  return null;
1058
1190
  }
1059
- function peg$f71(items, attrs2, block) {
1191
+ function peg$f72(items, attrs2, block) {
1060
1192
  return createNode("Nav", {
1061
1193
  items: items || [],
1062
1194
  ...attrsToObject(attrs2),
1063
1195
  children: block || []
1064
1196
  });
1065
1197
  }
1066
- function peg$f72(content) {
1198
+ function peg$f73(content) {
1067
1199
  return content.map((c) => c[0]).filter((c) => c !== null);
1068
1200
  }
1069
- function peg$f73() {
1201
+ function peg$f74() {
1070
1202
  return createBlockNode("Divider", {});
1071
1203
  }
1072
- function peg$f74() {
1204
+ function peg$f75() {
1073
1205
  return null;
1074
1206
  }
1075
- function peg$f75(label, attrs2, items) {
1207
+ function peg$f76(label, attrs2, items) {
1076
1208
  return createBlockNode("NavGroup", {
1077
1209
  label,
1078
1210
  ...attrsToObject(attrs2),
1079
1211
  items: items.map((i) => i[0]).filter((i) => i !== null)
1080
1212
  });
1081
1213
  }
1082
- function peg$f76() {
1214
+ function peg$f77() {
1083
1215
  return createBlockNode("Divider", {});
1084
1216
  }
1085
- function peg$f77() {
1217
+ function peg$f78() {
1086
1218
  return null;
1087
1219
  }
1088
- function peg$f78(label, attrs2) {
1220
+ function peg$f79(label, attrs2) {
1089
1221
  return createBlockNode("NavItem", {
1090
1222
  label,
1091
1223
  ...attrsToObject(attrs2)
1092
1224
  });
1093
1225
  }
1094
- function peg$f79(items, attrs2, block) {
1226
+ function peg$f80(items, attrs2, block) {
1095
1227
  return createNode("Tabs", {
1096
1228
  items: items || [],
1097
1229
  ...attrsToObject(attrs2),
1098
1230
  children: block || []
1099
1231
  });
1100
1232
  }
1101
- function peg$f80(tabs) {
1233
+ function peg$f81(tabs) {
1102
1234
  return tabs.map((t) => t[0]).filter((t) => t !== null);
1103
1235
  }
1104
- function peg$f81(label, attrs2, children) {
1236
+ function peg$f82(label, attrs2, children) {
1105
1237
  return {
1106
1238
  label,
1107
1239
  ...attrsToObject(attrs2),
1108
1240
  children
1109
1241
  };
1110
1242
  }
1111
- function peg$f82() {
1243
+ function peg$f83() {
1112
1244
  return null;
1113
1245
  }
1114
- function peg$f83(items, attrs2) {
1246
+ function peg$f84(items, attrs2) {
1115
1247
  return createNode("Breadcrumb", {
1116
1248
  items,
1117
1249
  ...attrsToObject(attrs2)
1118
1250
  });
1119
1251
  }
1120
- function peg$f84(attrs2) {
1252
+ function peg$f85(attrs2) {
1121
1253
  return createNode("Divider", {
1122
1254
  ...attrsToObject(attrs2)
1123
1255
  });
1124
1256
  }
1125
- function peg$f85(num, attrs2) {
1257
+ function peg$f86(num, attrs2) {
1126
1258
  return createNode("Marker", {
1127
1259
  number: num,
1128
1260
  ...attrsToObject(attrs2)
1129
1261
  });
1130
1262
  }
1131
- function peg$f86(attrs2, items) {
1263
+ function peg$f87(attrs2, items) {
1132
1264
  return createNode("Annotations", {
1133
1265
  ...attrsToObject(attrs2),
1134
1266
  children: items
1135
1267
  });
1136
1268
  }
1137
- function peg$f87(items) {
1269
+ function peg$f88(items) {
1138
1270
  return items.map((i) => i[0]).filter((i) => i !== null);
1139
1271
  }
1140
- function peg$f88(num, title, attrs2, children) {
1272
+ function peg$f89(num, title, attrs2, children) {
1141
1273
  return createNode("AnnotationItem", {
1142
1274
  number: num,
1143
1275
  title,
@@ -1145,7 +1277,7 @@ function peg$parse(input, options) {
1145
1277
  children
1146
1278
  });
1147
1279
  }
1148
- function peg$f89(num, title, attrs2) {
1280
+ function peg$f90(num, title, attrs2) {
1149
1281
  return createNode("AnnotationItem", {
1150
1282
  number: num,
1151
1283
  title,
@@ -1153,90 +1285,90 @@ function peg$parse(input, options) {
1153
1285
  children: []
1154
1286
  });
1155
1287
  }
1156
- function peg$f90() {
1288
+ function peg$f91() {
1157
1289
  return null;
1158
1290
  }
1159
- function peg$f91(digits) {
1291
+ function peg$f92(digits) {
1160
1292
  return parseInt(digits.join(""), 10);
1161
1293
  }
1162
- function peg$f92(attrs2) {
1294
+ function peg$f93(attrs2) {
1163
1295
  return attrs2;
1164
1296
  }
1165
- function peg$f93(x, y) {
1297
+ function peg$f94(x, y) {
1166
1298
  return [
1167
1299
  { name: "x", value: x },
1168
1300
  { name: "y", value: y }
1169
1301
  ];
1170
1302
  }
1171
- function peg$f94(name, value) {
1303
+ function peg$f95(name, value) {
1172
1304
  return { name, value };
1173
1305
  }
1174
- function peg$f95(flag) {
1306
+ function peg$f96(flag) {
1175
1307
  return { name: flag, value: true };
1176
1308
  }
1177
- function peg$f96(name) {
1309
+ function peg$f97(name) {
1178
1310
  return name;
1179
1311
  }
1180
- function peg$f97(chars) {
1312
+ function peg$f98(chars) {
1181
1313
  return chars.join("");
1182
1314
  }
1183
- function peg$f98(chars) {
1315
+ function peg$f99(chars) {
1184
1316
  return chars.join("");
1185
1317
  }
1186
- function peg$f99(char) {
1318
+ function peg$f100(char) {
1187
1319
  return char;
1188
1320
  }
1189
- function peg$f100(seq) {
1321
+ function peg$f101(seq) {
1190
1322
  return seq;
1191
1323
  }
1192
- function peg$f101(char) {
1324
+ function peg$f102(char) {
1193
1325
  return char;
1194
1326
  }
1195
- function peg$f102(seq) {
1327
+ function peg$f103(seq) {
1196
1328
  return seq;
1197
1329
  }
1198
- function peg$f103() {
1330
+ function peg$f104() {
1199
1331
  return "\n";
1200
1332
  }
1201
- function peg$f104() {
1333
+ function peg$f105() {
1202
1334
  return "\r";
1203
1335
  }
1204
- function peg$f105() {
1336
+ function peg$f106() {
1205
1337
  return " ";
1206
1338
  }
1207
- function peg$f106() {
1339
+ function peg$f107() {
1208
1340
  return "\\";
1209
1341
  }
1210
- function peg$f107() {
1342
+ function peg$f108() {
1211
1343
  return '"';
1212
1344
  }
1213
- function peg$f108() {
1345
+ function peg$f109() {
1214
1346
  return "'";
1215
1347
  }
1216
- function peg$f109(sign, digits, decimal) {
1348
+ function peg$f110(sign, digits, decimal) {
1217
1349
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1218
1350
  return parseFloat(num);
1219
1351
  }
1220
- function peg$f110(sign, digits, decimal, unit) {
1352
+ function peg$f111(sign, digits, decimal, unit) {
1221
1353
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1222
1354
  return { value: parseFloat(num), unit };
1223
1355
  }
1224
- function peg$f111() {
1356
+ function peg$f112() {
1225
1357
  return true;
1226
1358
  }
1227
- function peg$f112() {
1359
+ function peg$f113() {
1228
1360
  return false;
1229
1361
  }
1230
- function peg$f113(head, tail) {
1362
+ function peg$f114(head, tail) {
1231
1363
  return head + tail.join("");
1232
1364
  }
1233
- function peg$f114(items) {
1365
+ function peg$f115(items) {
1234
1366
  return items || [];
1235
1367
  }
1236
- function peg$f115(head, tail) {
1368
+ function peg$f116(head, tail) {
1237
1369
  return [head, ...tail.map((t) => t[3])];
1238
1370
  }
1239
- function peg$f116(props) {
1371
+ function peg$f117(props) {
1240
1372
  const result = {};
1241
1373
  if (props) {
1242
1374
  for (const p of props) {
@@ -1245,13 +1377,13 @@ function peg$parse(input, options) {
1245
1377
  }
1246
1378
  return result;
1247
1379
  }
1248
- function peg$f117(head, tail) {
1380
+ function peg$f118(head, tail) {
1249
1381
  return [head, ...tail.map((t) => t[3])];
1250
1382
  }
1251
- function peg$f118(name, value) {
1383
+ function peg$f119(name, value) {
1252
1384
  return { name, value };
1253
1385
  }
1254
- function peg$f119(name) {
1386
+ function peg$f120(name) {
1255
1387
  return { name, value: true };
1256
1388
  }
1257
1389
  let peg$currPos = options.peg$currPos | 0;
@@ -2503,21 +2635,24 @@ function peg$parse(input, options) {
2503
2635
  let s0, s1;
2504
2636
  s0 = peg$parseComponentUse();
2505
2637
  if (s0 === peg$FAILED) {
2506
- s0 = peg$parseLayoutElement();
2638
+ s0 = peg$parseRepeat();
2507
2639
  if (s0 === peg$FAILED) {
2508
- s0 = peg$parseContainerElement();
2640
+ s0 = peg$parseLayoutElement();
2509
2641
  if (s0 === peg$FAILED) {
2510
- s0 = peg$parseUIElement();
2642
+ s0 = peg$parseContainerElement();
2511
2643
  if (s0 === peg$FAILED) {
2512
- s0 = peg$parseSlot();
2644
+ s0 = peg$parseUIElement();
2513
2645
  if (s0 === peg$FAILED) {
2514
- s0 = peg$currPos;
2515
- s1 = peg$parseComment();
2516
- if (s1 !== peg$FAILED) {
2517
- peg$savedPos = s0;
2518
- s1 = peg$f18();
2646
+ s0 = peg$parseSlot();
2647
+ if (s0 === peg$FAILED) {
2648
+ s0 = peg$currPos;
2649
+ s1 = peg$parseComment();
2650
+ if (s1 !== peg$FAILED) {
2651
+ peg$savedPos = s0;
2652
+ s1 = peg$f18();
2653
+ }
2654
+ s0 = s1;
2519
2655
  }
2520
- s0 = s1;
2521
2656
  }
2522
2657
  }
2523
2658
  }
@@ -2525,6 +2660,71 @@ function peg$parse(input, options) {
2525
2660
  }
2526
2661
  return s0;
2527
2662
  }
2663
+ function peg$parseRepeat() {
2664
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2665
+ s0 = peg$currPos;
2666
+ if (input.substr(peg$currPos, 6) === peg$c20) {
2667
+ s1 = peg$c20;
2668
+ peg$currPos += 6;
2669
+ } else {
2670
+ s1 = peg$FAILED;
2671
+ if (peg$silentFails === 0) {
2672
+ peg$fail(peg$e23);
2673
+ }
2674
+ }
2675
+ if (s1 !== peg$FAILED) {
2676
+ s2 = peg$parse_();
2677
+ s3 = peg$parseInteger();
2678
+ if (s3 !== peg$FAILED) {
2679
+ s4 = peg$parse_();
2680
+ if (input.charCodeAt(peg$currPos) === 123) {
2681
+ s5 = peg$c1;
2682
+ peg$currPos++;
2683
+ } else {
2684
+ s5 = peg$FAILED;
2685
+ if (peg$silentFails === 0) {
2686
+ peg$fail(peg$e1);
2687
+ }
2688
+ }
2689
+ if (s5 !== peg$FAILED) {
2690
+ s6 = peg$parse_();
2691
+ s7 = peg$parseChildren();
2692
+ if (s7 !== peg$FAILED) {
2693
+ s8 = peg$parse_();
2694
+ if (input.charCodeAt(peg$currPos) === 125) {
2695
+ s9 = peg$c2;
2696
+ peg$currPos++;
2697
+ } else {
2698
+ s9 = peg$FAILED;
2699
+ if (peg$silentFails === 0) {
2700
+ peg$fail(peg$e2);
2701
+ }
2702
+ }
2703
+ if (s9 !== peg$FAILED) {
2704
+ peg$savedPos = s0;
2705
+ s0 = peg$f19(s3, s7);
2706
+ } else {
2707
+ peg$currPos = s0;
2708
+ s0 = peg$FAILED;
2709
+ }
2710
+ } else {
2711
+ peg$currPos = s0;
2712
+ s0 = peg$FAILED;
2713
+ }
2714
+ } else {
2715
+ peg$currPos = s0;
2716
+ s0 = peg$FAILED;
2717
+ }
2718
+ } else {
2719
+ peg$currPos = s0;
2720
+ s0 = peg$FAILED;
2721
+ }
2722
+ } else {
2723
+ peg$currPos = s0;
2724
+ s0 = peg$FAILED;
2725
+ }
2726
+ return s0;
2727
+ }
2528
2728
  function peg$parseLayoutElement() {
2529
2729
  let s0;
2530
2730
  s0 = peg$parseHeader();
@@ -2554,13 +2754,13 @@ function peg$parse(input, options) {
2554
2754
  function peg$parseHeader() {
2555
2755
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2556
2756
  s0 = peg$currPos;
2557
- if (input.substr(peg$currPos, 6) === peg$c20) {
2558
- s1 = peg$c20;
2757
+ if (input.substr(peg$currPos, 6) === peg$c21) {
2758
+ s1 = peg$c21;
2559
2759
  peg$currPos += 6;
2560
2760
  } else {
2561
2761
  s1 = peg$FAILED;
2562
2762
  if (peg$silentFails === 0) {
2563
- peg$fail(peg$e23);
2763
+ peg$fail(peg$e24);
2564
2764
  }
2565
2765
  }
2566
2766
  if (s1 !== peg$FAILED) {
@@ -2595,7 +2795,7 @@ function peg$parse(input, options) {
2595
2795
  }
2596
2796
  if (s9 !== peg$FAILED) {
2597
2797
  peg$savedPos = s0;
2598
- s0 = peg$f19(s3, s7);
2798
+ s0 = peg$f20(s3, s7);
2599
2799
  } else {
2600
2800
  peg$currPos = s0;
2601
2801
  s0 = peg$FAILED;
@@ -2617,13 +2817,13 @@ function peg$parse(input, options) {
2617
2817
  function peg$parseMain() {
2618
2818
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2619
2819
  s0 = peg$currPos;
2620
- if (input.substr(peg$currPos, 4) === peg$c21) {
2621
- s1 = peg$c21;
2820
+ if (input.substr(peg$currPos, 4) === peg$c22) {
2821
+ s1 = peg$c22;
2622
2822
  peg$currPos += 4;
2623
2823
  } else {
2624
2824
  s1 = peg$FAILED;
2625
2825
  if (peg$silentFails === 0) {
2626
- peg$fail(peg$e24);
2826
+ peg$fail(peg$e25);
2627
2827
  }
2628
2828
  }
2629
2829
  if (s1 !== peg$FAILED) {
@@ -2658,7 +2858,7 @@ function peg$parse(input, options) {
2658
2858
  }
2659
2859
  if (s9 !== peg$FAILED) {
2660
2860
  peg$savedPos = s0;
2661
- s0 = peg$f20(s3, s7);
2861
+ s0 = peg$f21(s3, s7);
2662
2862
  } else {
2663
2863
  peg$currPos = s0;
2664
2864
  s0 = peg$FAILED;
@@ -2680,13 +2880,13 @@ function peg$parse(input, options) {
2680
2880
  function peg$parseFooter() {
2681
2881
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2682
2882
  s0 = peg$currPos;
2683
- if (input.substr(peg$currPos, 6) === peg$c22) {
2684
- s1 = peg$c22;
2883
+ if (input.substr(peg$currPos, 6) === peg$c23) {
2884
+ s1 = peg$c23;
2685
2885
  peg$currPos += 6;
2686
2886
  } else {
2687
2887
  s1 = peg$FAILED;
2688
2888
  if (peg$silentFails === 0) {
2689
- peg$fail(peg$e25);
2889
+ peg$fail(peg$e26);
2690
2890
  }
2691
2891
  }
2692
2892
  if (s1 !== peg$FAILED) {
@@ -2721,7 +2921,7 @@ function peg$parse(input, options) {
2721
2921
  }
2722
2922
  if (s9 !== peg$FAILED) {
2723
2923
  peg$savedPos = s0;
2724
- s0 = peg$f21(s3, s7);
2924
+ s0 = peg$f22(s3, s7);
2725
2925
  } else {
2726
2926
  peg$currPos = s0;
2727
2927
  s0 = peg$FAILED;
@@ -2743,13 +2943,13 @@ function peg$parse(input, options) {
2743
2943
  function peg$parseSidebar() {
2744
2944
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2745
2945
  s0 = peg$currPos;
2746
- if (input.substr(peg$currPos, 7) === peg$c23) {
2747
- s1 = peg$c23;
2946
+ if (input.substr(peg$currPos, 7) === peg$c24) {
2947
+ s1 = peg$c24;
2748
2948
  peg$currPos += 7;
2749
2949
  } else {
2750
2950
  s1 = peg$FAILED;
2751
2951
  if (peg$silentFails === 0) {
2752
- peg$fail(peg$e26);
2952
+ peg$fail(peg$e27);
2753
2953
  }
2754
2954
  }
2755
2955
  if (s1 !== peg$FAILED) {
@@ -2784,7 +2984,7 @@ function peg$parse(input, options) {
2784
2984
  }
2785
2985
  if (s9 !== peg$FAILED) {
2786
2986
  peg$savedPos = s0;
2787
- s0 = peg$f22(s3, s7);
2987
+ s0 = peg$f23(s3, s7);
2788
2988
  } else {
2789
2989
  peg$currPos = s0;
2790
2990
  s0 = peg$FAILED;
@@ -2806,13 +3006,13 @@ function peg$parse(input, options) {
2806
3006
  function peg$parseRow() {
2807
3007
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2808
3008
  s0 = peg$currPos;
2809
- if (input.substr(peg$currPos, 3) === peg$c24) {
2810
- s1 = peg$c24;
3009
+ if (input.substr(peg$currPos, 3) === peg$c25) {
3010
+ s1 = peg$c25;
2811
3011
  peg$currPos += 3;
2812
3012
  } else {
2813
3013
  s1 = peg$FAILED;
2814
3014
  if (peg$silentFails === 0) {
2815
- peg$fail(peg$e27);
3015
+ peg$fail(peg$e28);
2816
3016
  }
2817
3017
  }
2818
3018
  if (s1 !== peg$FAILED) {
@@ -2847,7 +3047,7 @@ function peg$parse(input, options) {
2847
3047
  }
2848
3048
  if (s9 !== peg$FAILED) {
2849
3049
  peg$savedPos = s0;
2850
- s0 = peg$f23(s3, s7);
3050
+ s0 = peg$f24(s3, s7);
2851
3051
  } else {
2852
3052
  peg$currPos = s0;
2853
3053
  s0 = peg$FAILED;
@@ -2869,13 +3069,13 @@ function peg$parse(input, options) {
2869
3069
  function peg$parseCol() {
2870
3070
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2871
3071
  s0 = peg$currPos;
2872
- if (input.substr(peg$currPos, 3) === peg$c25) {
2873
- s1 = peg$c25;
3072
+ if (input.substr(peg$currPos, 3) === peg$c26) {
3073
+ s1 = peg$c26;
2874
3074
  peg$currPos += 3;
2875
3075
  } else {
2876
3076
  s1 = peg$FAILED;
2877
3077
  if (peg$silentFails === 0) {
2878
- peg$fail(peg$e28);
3078
+ peg$fail(peg$e29);
2879
3079
  }
2880
3080
  }
2881
3081
  if (s1 !== peg$FAILED) {
@@ -2910,7 +3110,7 @@ function peg$parse(input, options) {
2910
3110
  }
2911
3111
  if (s9 !== peg$FAILED) {
2912
3112
  peg$savedPos = s0;
2913
- s0 = peg$f24(s3, s7);
3113
+ s0 = peg$f25(s3, s7);
2914
3114
  } else {
2915
3115
  peg$currPos = s0;
2916
3116
  s0 = peg$FAILED;
@@ -2932,13 +3132,13 @@ function peg$parse(input, options) {
2932
3132
  function peg$parseStack() {
2933
3133
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2934
3134
  s0 = peg$currPos;
2935
- if (input.substr(peg$currPos, 5) === peg$c26) {
2936
- s1 = peg$c26;
3135
+ if (input.substr(peg$currPos, 5) === peg$c27) {
3136
+ s1 = peg$c27;
2937
3137
  peg$currPos += 5;
2938
3138
  } else {
2939
3139
  s1 = peg$FAILED;
2940
3140
  if (peg$silentFails === 0) {
2941
- peg$fail(peg$e29);
3141
+ peg$fail(peg$e30);
2942
3142
  }
2943
3143
  }
2944
3144
  if (s1 !== peg$FAILED) {
@@ -2973,7 +3173,7 @@ function peg$parse(input, options) {
2973
3173
  }
2974
3174
  if (s9 !== peg$FAILED) {
2975
3175
  peg$savedPos = s0;
2976
- s0 = peg$f25(s3, s7);
3176
+ s0 = peg$f26(s3, s7);
2977
3177
  } else {
2978
3178
  peg$currPos = s0;
2979
3179
  s0 = peg$FAILED;
@@ -2995,13 +3195,13 @@ function peg$parse(input, options) {
2995
3195
  function peg$parseRelative() {
2996
3196
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2997
3197
  s0 = peg$currPos;
2998
- if (input.substr(peg$currPos, 8) === peg$c27) {
2999
- s1 = peg$c27;
3198
+ if (input.substr(peg$currPos, 8) === peg$c28) {
3199
+ s1 = peg$c28;
3000
3200
  peg$currPos += 8;
3001
3201
  } else {
3002
3202
  s1 = peg$FAILED;
3003
3203
  if (peg$silentFails === 0) {
3004
- peg$fail(peg$e30);
3204
+ peg$fail(peg$e31);
3005
3205
  }
3006
3206
  }
3007
3207
  if (s1 !== peg$FAILED) {
@@ -3036,7 +3236,7 @@ function peg$parse(input, options) {
3036
3236
  }
3037
3237
  if (s9 !== peg$FAILED) {
3038
3238
  peg$savedPos = s0;
3039
- s0 = peg$f26(s3, s7);
3239
+ s0 = peg$f27(s3, s7);
3040
3240
  } else {
3041
3241
  peg$currPos = s0;
3042
3242
  s0 = peg$FAILED;
@@ -3075,13 +3275,13 @@ function peg$parse(input, options) {
3075
3275
  function peg$parseCard() {
3076
3276
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3077
3277
  s0 = peg$currPos;
3078
- if (input.substr(peg$currPos, 4) === peg$c28) {
3079
- s1 = peg$c28;
3278
+ if (input.substr(peg$currPos, 4) === peg$c29) {
3279
+ s1 = peg$c29;
3080
3280
  peg$currPos += 4;
3081
3281
  } else {
3082
3282
  s1 = peg$FAILED;
3083
3283
  if (peg$silentFails === 0) {
3084
- peg$fail(peg$e31);
3284
+ peg$fail(peg$e32);
3085
3285
  }
3086
3286
  }
3087
3287
  if (s1 !== peg$FAILED) {
@@ -3121,7 +3321,7 @@ function peg$parse(input, options) {
3121
3321
  }
3122
3322
  if (s11 !== peg$FAILED) {
3123
3323
  peg$savedPos = s0;
3124
- s0 = peg$f27(s3, s5, s9);
3324
+ s0 = peg$f28(s3, s5, s9);
3125
3325
  } else {
3126
3326
  peg$currPos = s0;
3127
3327
  s0 = peg$FAILED;
@@ -3143,13 +3343,13 @@ function peg$parse(input, options) {
3143
3343
  function peg$parseModal() {
3144
3344
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3145
3345
  s0 = peg$currPos;
3146
- if (input.substr(peg$currPos, 5) === peg$c29) {
3147
- s1 = peg$c29;
3346
+ if (input.substr(peg$currPos, 5) === peg$c30) {
3347
+ s1 = peg$c30;
3148
3348
  peg$currPos += 5;
3149
3349
  } else {
3150
3350
  s1 = peg$FAILED;
3151
3351
  if (peg$silentFails === 0) {
3152
- peg$fail(peg$e32);
3352
+ peg$fail(peg$e33);
3153
3353
  }
3154
3354
  }
3155
3355
  if (s1 !== peg$FAILED) {
@@ -3189,7 +3389,7 @@ function peg$parse(input, options) {
3189
3389
  }
3190
3390
  if (s11 !== peg$FAILED) {
3191
3391
  peg$savedPos = s0;
3192
- s0 = peg$f28(s3, s5, s9);
3392
+ s0 = peg$f29(s3, s5, s9);
3193
3393
  } else {
3194
3394
  peg$currPos = s0;
3195
3395
  s0 = peg$FAILED;
@@ -3211,13 +3411,13 @@ function peg$parse(input, options) {
3211
3411
  function peg$parseDrawer() {
3212
3412
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3213
3413
  s0 = peg$currPos;
3214
- if (input.substr(peg$currPos, 6) === peg$c30) {
3215
- s1 = peg$c30;
3414
+ if (input.substr(peg$currPos, 6) === peg$c31) {
3415
+ s1 = peg$c31;
3216
3416
  peg$currPos += 6;
3217
3417
  } else {
3218
3418
  s1 = peg$FAILED;
3219
3419
  if (peg$silentFails === 0) {
3220
- peg$fail(peg$e33);
3420
+ peg$fail(peg$e34);
3221
3421
  }
3222
3422
  }
3223
3423
  if (s1 !== peg$FAILED) {
@@ -3257,7 +3457,7 @@ function peg$parse(input, options) {
3257
3457
  }
3258
3458
  if (s11 !== peg$FAILED) {
3259
3459
  peg$savedPos = s0;
3260
- s0 = peg$f29(s3, s5, s9);
3460
+ s0 = peg$f30(s3, s5, s9);
3261
3461
  } else {
3262
3462
  peg$currPos = s0;
3263
3463
  s0 = peg$FAILED;
@@ -3279,13 +3479,13 @@ function peg$parse(input, options) {
3279
3479
  function peg$parseAccordion() {
3280
3480
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3281
3481
  s0 = peg$currPos;
3282
- if (input.substr(peg$currPos, 9) === peg$c31) {
3283
- s1 = peg$c31;
3482
+ if (input.substr(peg$currPos, 9) === peg$c32) {
3483
+ s1 = peg$c32;
3284
3484
  peg$currPos += 9;
3285
3485
  } else {
3286
3486
  s1 = peg$FAILED;
3287
3487
  if (peg$silentFails === 0) {
3288
- peg$fail(peg$e34);
3488
+ peg$fail(peg$e35);
3289
3489
  }
3290
3490
  }
3291
3491
  if (s1 !== peg$FAILED) {
@@ -3325,7 +3525,7 @@ function peg$parse(input, options) {
3325
3525
  }
3326
3526
  if (s11 !== peg$FAILED) {
3327
3527
  peg$savedPos = s0;
3328
- s0 = peg$f30(s3, s5, s9);
3528
+ s0 = peg$f31(s3, s5, s9);
3329
3529
  } else {
3330
3530
  peg$currPos = s0;
3331
3531
  s0 = peg$FAILED;
@@ -3347,13 +3547,13 @@ function peg$parse(input, options) {
3347
3547
  function peg$parseSection() {
3348
3548
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3349
3549
  s0 = peg$currPos;
3350
- if (input.substr(peg$currPos, 7) === peg$c32) {
3351
- s1 = peg$c32;
3550
+ if (input.substr(peg$currPos, 7) === peg$c33) {
3551
+ s1 = peg$c33;
3352
3552
  peg$currPos += 7;
3353
3553
  } else {
3354
3554
  s1 = peg$FAILED;
3355
3555
  if (peg$silentFails === 0) {
3356
- peg$fail(peg$e35);
3556
+ peg$fail(peg$e36);
3357
3557
  }
3358
3558
  }
3359
3559
  if (s1 !== peg$FAILED) {
@@ -3393,7 +3593,7 @@ function peg$parse(input, options) {
3393
3593
  }
3394
3594
  if (s11 !== peg$FAILED) {
3395
3595
  peg$savedPos = s0;
3396
- s0 = peg$f31(s3, s5, s9);
3596
+ s0 = peg$f32(s3, s5, s9);
3397
3597
  } else {
3398
3598
  peg$currPos = s0;
3399
3599
  s0 = peg$FAILED;
@@ -3510,13 +3710,13 @@ function peg$parse(input, options) {
3510
3710
  function peg$parseText() {
3511
3711
  let s0, s1, s2, s3, s4, s5;
3512
3712
  s0 = peg$currPos;
3513
- if (input.substr(peg$currPos, 4) === peg$c33) {
3514
- s1 = peg$c33;
3713
+ if (input.substr(peg$currPos, 4) === peg$c34) {
3714
+ s1 = peg$c34;
3515
3715
  peg$currPos += 4;
3516
3716
  } else {
3517
3717
  s1 = peg$FAILED;
3518
3718
  if (peg$silentFails === 0) {
3519
- peg$fail(peg$e36);
3719
+ peg$fail(peg$e37);
3520
3720
  }
3521
3721
  }
3522
3722
  if (s1 !== peg$FAILED) {
@@ -3529,7 +3729,7 @@ function peg$parse(input, options) {
3529
3729
  s5 = null;
3530
3730
  }
3531
3731
  peg$savedPos = s0;
3532
- s0 = peg$f32(s3, s5);
3732
+ s0 = peg$f33(s3, s5);
3533
3733
  } else {
3534
3734
  peg$currPos = s0;
3535
3735
  s0 = peg$FAILED;
@@ -3543,13 +3743,13 @@ function peg$parse(input, options) {
3543
3743
  function peg$parseTitle() {
3544
3744
  let s0, s1, s2, s3, s4, s5;
3545
3745
  s0 = peg$currPos;
3546
- if (input.substr(peg$currPos, 5) === peg$c34) {
3547
- s1 = peg$c34;
3746
+ if (input.substr(peg$currPos, 5) === peg$c35) {
3747
+ s1 = peg$c35;
3548
3748
  peg$currPos += 5;
3549
3749
  } else {
3550
3750
  s1 = peg$FAILED;
3551
3751
  if (peg$silentFails === 0) {
3552
- peg$fail(peg$e37);
3752
+ peg$fail(peg$e38);
3553
3753
  }
3554
3754
  }
3555
3755
  if (s1 !== peg$FAILED) {
@@ -3562,7 +3762,7 @@ function peg$parse(input, options) {
3562
3762
  s5 = null;
3563
3763
  }
3564
3764
  peg$savedPos = s0;
3565
- s0 = peg$f33(s3, s5);
3765
+ s0 = peg$f34(s3, s5);
3566
3766
  } else {
3567
3767
  peg$currPos = s0;
3568
3768
  s0 = peg$FAILED;
@@ -3576,13 +3776,13 @@ function peg$parse(input, options) {
3576
3776
  function peg$parseLink() {
3577
3777
  let s0, s1, s2, s3, s4, s5;
3578
3778
  s0 = peg$currPos;
3579
- if (input.substr(peg$currPos, 4) === peg$c35) {
3580
- s1 = peg$c35;
3779
+ if (input.substr(peg$currPos, 4) === peg$c36) {
3780
+ s1 = peg$c36;
3581
3781
  peg$currPos += 4;
3582
3782
  } else {
3583
3783
  s1 = peg$FAILED;
3584
3784
  if (peg$silentFails === 0) {
3585
- peg$fail(peg$e38);
3785
+ peg$fail(peg$e39);
3586
3786
  }
3587
3787
  }
3588
3788
  if (s1 !== peg$FAILED) {
@@ -3595,7 +3795,7 @@ function peg$parse(input, options) {
3595
3795
  s5 = null;
3596
3796
  }
3597
3797
  peg$savedPos = s0;
3598
- s0 = peg$f34(s3, s5);
3798
+ s0 = peg$f35(s3, s5);
3599
3799
  } else {
3600
3800
  peg$currPos = s0;
3601
3801
  s0 = peg$FAILED;
@@ -3609,13 +3809,13 @@ function peg$parse(input, options) {
3609
3809
  function peg$parseButton() {
3610
3810
  let s0, s1, s2, s3, s4, s5;
3611
3811
  s0 = peg$currPos;
3612
- if (input.substr(peg$currPos, 6) === peg$c36) {
3613
- s1 = peg$c36;
3812
+ if (input.substr(peg$currPos, 6) === peg$c37) {
3813
+ s1 = peg$c37;
3614
3814
  peg$currPos += 6;
3615
3815
  } else {
3616
3816
  s1 = peg$FAILED;
3617
3817
  if (peg$silentFails === 0) {
3618
- peg$fail(peg$e39);
3818
+ peg$fail(peg$e40);
3619
3819
  }
3620
3820
  }
3621
3821
  if (s1 !== peg$FAILED) {
@@ -3628,7 +3828,7 @@ function peg$parse(input, options) {
3628
3828
  s5 = null;
3629
3829
  }
3630
3830
  peg$savedPos = s0;
3631
- s0 = peg$f35(s3, s5);
3831
+ s0 = peg$f36(s3, s5);
3632
3832
  } else {
3633
3833
  peg$currPos = s0;
3634
3834
  s0 = peg$FAILED;
@@ -3642,13 +3842,13 @@ function peg$parse(input, options) {
3642
3842
  function peg$parseInput() {
3643
3843
  let s0, s1, s2, s3, s4, s5;
3644
3844
  s0 = peg$currPos;
3645
- if (input.substr(peg$currPos, 5) === peg$c37) {
3646
- s1 = peg$c37;
3845
+ if (input.substr(peg$currPos, 5) === peg$c38) {
3846
+ s1 = peg$c38;
3647
3847
  peg$currPos += 5;
3648
3848
  } else {
3649
3849
  s1 = peg$FAILED;
3650
3850
  if (peg$silentFails === 0) {
3651
- peg$fail(peg$e40);
3851
+ peg$fail(peg$e41);
3652
3852
  }
3653
3853
  }
3654
3854
  if (s1 !== peg$FAILED) {
@@ -3663,7 +3863,7 @@ function peg$parse(input, options) {
3663
3863
  s5 = null;
3664
3864
  }
3665
3865
  peg$savedPos = s0;
3666
- s0 = peg$f36(s3, s5);
3866
+ s0 = peg$f37(s3, s5);
3667
3867
  } else {
3668
3868
  peg$currPos = s0;
3669
3869
  s0 = peg$FAILED;
@@ -3673,13 +3873,13 @@ function peg$parse(input, options) {
3673
3873
  function peg$parseTextarea() {
3674
3874
  let s0, s1, s2, s3, s4, s5;
3675
3875
  s0 = peg$currPos;
3676
- if (input.substr(peg$currPos, 8) === peg$c38) {
3677
- s1 = peg$c38;
3876
+ if (input.substr(peg$currPos, 8) === peg$c39) {
3877
+ s1 = peg$c39;
3678
3878
  peg$currPos += 8;
3679
3879
  } else {
3680
3880
  s1 = peg$FAILED;
3681
3881
  if (peg$silentFails === 0) {
3682
- peg$fail(peg$e41);
3882
+ peg$fail(peg$e42);
3683
3883
  }
3684
3884
  }
3685
3885
  if (s1 !== peg$FAILED) {
@@ -3694,7 +3894,7 @@ function peg$parse(input, options) {
3694
3894
  s5 = null;
3695
3895
  }
3696
3896
  peg$savedPos = s0;
3697
- s0 = peg$f37(s3, s5);
3897
+ s0 = peg$f38(s3, s5);
3698
3898
  } else {
3699
3899
  peg$currPos = s0;
3700
3900
  s0 = peg$FAILED;
@@ -3704,13 +3904,13 @@ function peg$parse(input, options) {
3704
3904
  function peg$parseSelect() {
3705
3905
  let s0, s1, s2, s3, s4, s5, s6, s7;
3706
3906
  s0 = peg$currPos;
3707
- if (input.substr(peg$currPos, 6) === peg$c39) {
3708
- s1 = peg$c39;
3907
+ if (input.substr(peg$currPos, 6) === peg$c40) {
3908
+ s1 = peg$c40;
3709
3909
  peg$currPos += 6;
3710
3910
  } else {
3711
3911
  s1 = peg$FAILED;
3712
3912
  if (peg$silentFails === 0) {
3713
- peg$fail(peg$e42);
3913
+ peg$fail(peg$e43);
3714
3914
  }
3715
3915
  }
3716
3916
  if (s1 !== peg$FAILED) {
@@ -3730,7 +3930,7 @@ function peg$parse(input, options) {
3730
3930
  s7 = null;
3731
3931
  }
3732
3932
  peg$savedPos = s0;
3733
- s0 = peg$f38(s3, s5, s7);
3933
+ s0 = peg$f39(s3, s5, s7);
3734
3934
  } else {
3735
3935
  peg$currPos = s0;
3736
3936
  s0 = peg$FAILED;
@@ -3740,13 +3940,13 @@ function peg$parse(input, options) {
3740
3940
  function peg$parseCheckbox() {
3741
3941
  let s0, s1, s2, s3, s4, s5;
3742
3942
  s0 = peg$currPos;
3743
- if (input.substr(peg$currPos, 8) === peg$c40) {
3744
- s1 = peg$c40;
3943
+ if (input.substr(peg$currPos, 8) === peg$c41) {
3944
+ s1 = peg$c41;
3745
3945
  peg$currPos += 8;
3746
3946
  } else {
3747
3947
  s1 = peg$FAILED;
3748
3948
  if (peg$silentFails === 0) {
3749
- peg$fail(peg$e43);
3949
+ peg$fail(peg$e44);
3750
3950
  }
3751
3951
  }
3752
3952
  if (s1 !== peg$FAILED) {
@@ -3761,7 +3961,7 @@ function peg$parse(input, options) {
3761
3961
  s5 = null;
3762
3962
  }
3763
3963
  peg$savedPos = s0;
3764
- s0 = peg$f39(s3, s5);
3964
+ s0 = peg$f40(s3, s5);
3765
3965
  } else {
3766
3966
  peg$currPos = s0;
3767
3967
  s0 = peg$FAILED;
@@ -3771,13 +3971,13 @@ function peg$parse(input, options) {
3771
3971
  function peg$parseRadio() {
3772
3972
  let s0, s1, s2, s3, s4, s5;
3773
3973
  s0 = peg$currPos;
3774
- if (input.substr(peg$currPos, 5) === peg$c41) {
3775
- s1 = peg$c41;
3974
+ if (input.substr(peg$currPos, 5) === peg$c42) {
3975
+ s1 = peg$c42;
3776
3976
  peg$currPos += 5;
3777
3977
  } else {
3778
3978
  s1 = peg$FAILED;
3779
3979
  if (peg$silentFails === 0) {
3780
- peg$fail(peg$e44);
3980
+ peg$fail(peg$e45);
3781
3981
  }
3782
3982
  }
3783
3983
  if (s1 !== peg$FAILED) {
@@ -3792,7 +3992,7 @@ function peg$parse(input, options) {
3792
3992
  s5 = null;
3793
3993
  }
3794
3994
  peg$savedPos = s0;
3795
- s0 = peg$f40(s3, s5);
3995
+ s0 = peg$f41(s3, s5);
3796
3996
  } else {
3797
3997
  peg$currPos = s0;
3798
3998
  s0 = peg$FAILED;
@@ -3802,13 +4002,13 @@ function peg$parse(input, options) {
3802
4002
  function peg$parseSwitch() {
3803
4003
  let s0, s1, s2, s3, s4, s5;
3804
4004
  s0 = peg$currPos;
3805
- if (input.substr(peg$currPos, 6) === peg$c42) {
3806
- s1 = peg$c42;
4005
+ if (input.substr(peg$currPos, 6) === peg$c43) {
4006
+ s1 = peg$c43;
3807
4007
  peg$currPos += 6;
3808
4008
  } else {
3809
4009
  s1 = peg$FAILED;
3810
4010
  if (peg$silentFails === 0) {
3811
- peg$fail(peg$e45);
4011
+ peg$fail(peg$e46);
3812
4012
  }
3813
4013
  }
3814
4014
  if (s1 !== peg$FAILED) {
@@ -3823,7 +4023,7 @@ function peg$parse(input, options) {
3823
4023
  s5 = null;
3824
4024
  }
3825
4025
  peg$savedPos = s0;
3826
- s0 = peg$f41(s3, s5);
4026
+ s0 = peg$f42(s3, s5);
3827
4027
  } else {
3828
4028
  peg$currPos = s0;
3829
4029
  s0 = peg$FAILED;
@@ -3833,13 +4033,13 @@ function peg$parse(input, options) {
3833
4033
  function peg$parseSlider() {
3834
4034
  let s0, s1, s2, s3, s4, s5;
3835
4035
  s0 = peg$currPos;
3836
- if (input.substr(peg$currPos, 6) === peg$c43) {
3837
- s1 = peg$c43;
4036
+ if (input.substr(peg$currPos, 6) === peg$c44) {
4037
+ s1 = peg$c44;
3838
4038
  peg$currPos += 6;
3839
4039
  } else {
3840
4040
  s1 = peg$FAILED;
3841
4041
  if (peg$silentFails === 0) {
3842
- peg$fail(peg$e46);
4042
+ peg$fail(peg$e47);
3843
4043
  }
3844
4044
  }
3845
4045
  if (s1 !== peg$FAILED) {
@@ -3854,7 +4054,7 @@ function peg$parse(input, options) {
3854
4054
  s5 = null;
3855
4055
  }
3856
4056
  peg$savedPos = s0;
3857
- s0 = peg$f42(s3, s5);
4057
+ s0 = peg$f43(s3, s5);
3858
4058
  } else {
3859
4059
  peg$currPos = s0;
3860
4060
  s0 = peg$FAILED;
@@ -3864,13 +4064,13 @@ function peg$parse(input, options) {
3864
4064
  function peg$parseImage() {
3865
4065
  let s0, s1, s2, s3, s4, s5;
3866
4066
  s0 = peg$currPos;
3867
- if (input.substr(peg$currPos, 5) === peg$c44) {
3868
- s1 = peg$c44;
4067
+ if (input.substr(peg$currPos, 5) === peg$c45) {
4068
+ s1 = peg$c45;
3869
4069
  peg$currPos += 5;
3870
4070
  } else {
3871
4071
  s1 = peg$FAILED;
3872
4072
  if (peg$silentFails === 0) {
3873
- peg$fail(peg$e47);
4073
+ peg$fail(peg$e48);
3874
4074
  }
3875
4075
  }
3876
4076
  if (s1 !== peg$FAILED) {
@@ -3885,7 +4085,7 @@ function peg$parse(input, options) {
3885
4085
  s5 = null;
3886
4086
  }
3887
4087
  peg$savedPos = s0;
3888
- s0 = peg$f43(s3, s5);
4088
+ s0 = peg$f44(s3, s5);
3889
4089
  } else {
3890
4090
  peg$currPos = s0;
3891
4091
  s0 = peg$FAILED;
@@ -3895,13 +4095,13 @@ function peg$parse(input, options) {
3895
4095
  function peg$parsePlaceholder() {
3896
4096
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
3897
4097
  s0 = peg$currPos;
3898
- if (input.substr(peg$currPos, 11) === peg$c45) {
3899
- s1 = peg$c45;
4098
+ if (input.substr(peg$currPos, 11) === peg$c46) {
4099
+ s1 = peg$c46;
3900
4100
  peg$currPos += 11;
3901
4101
  } else {
3902
4102
  s1 = peg$FAILED;
3903
4103
  if (peg$silentFails === 0) {
3904
- peg$fail(peg$e48);
4104
+ peg$fail(peg$e49);
3905
4105
  }
3906
4106
  }
3907
4107
  if (s1 !== peg$FAILED) {
@@ -3959,7 +4159,7 @@ function peg$parse(input, options) {
3959
4159
  s7 = null;
3960
4160
  }
3961
4161
  peg$savedPos = s0;
3962
- s0 = peg$f44(s3, s5, s7);
4162
+ s0 = peg$f45(s3, s5, s7);
3963
4163
  } else {
3964
4164
  peg$currPos = s0;
3965
4165
  s0 = peg$FAILED;
@@ -3969,13 +4169,13 @@ function peg$parse(input, options) {
3969
4169
  function peg$parseAvatar() {
3970
4170
  let s0, s1, s2, s3, s4, s5;
3971
4171
  s0 = peg$currPos;
3972
- if (input.substr(peg$currPos, 6) === peg$c46) {
3973
- s1 = peg$c46;
4172
+ if (input.substr(peg$currPos, 6) === peg$c47) {
4173
+ s1 = peg$c47;
3974
4174
  peg$currPos += 6;
3975
4175
  } else {
3976
4176
  s1 = peg$FAILED;
3977
4177
  if (peg$silentFails === 0) {
3978
- peg$fail(peg$e49);
4178
+ peg$fail(peg$e50);
3979
4179
  }
3980
4180
  }
3981
4181
  if (s1 !== peg$FAILED) {
@@ -3990,7 +4190,7 @@ function peg$parse(input, options) {
3990
4190
  s5 = null;
3991
4191
  }
3992
4192
  peg$savedPos = s0;
3993
- s0 = peg$f45(s3, s5);
4193
+ s0 = peg$f46(s3, s5);
3994
4194
  } else {
3995
4195
  peg$currPos = s0;
3996
4196
  s0 = peg$FAILED;
@@ -4000,13 +4200,13 @@ function peg$parse(input, options) {
4000
4200
  function peg$parseBadge() {
4001
4201
  let s0, s1, s2, s3, s4, s5;
4002
4202
  s0 = peg$currPos;
4003
- if (input.substr(peg$currPos, 5) === peg$c47) {
4004
- s1 = peg$c47;
4203
+ if (input.substr(peg$currPos, 5) === peg$c48) {
4204
+ s1 = peg$c48;
4005
4205
  peg$currPos += 5;
4006
4206
  } else {
4007
4207
  s1 = peg$FAILED;
4008
4208
  if (peg$silentFails === 0) {
4009
- peg$fail(peg$e50);
4209
+ peg$fail(peg$e51);
4010
4210
  }
4011
4211
  }
4012
4212
  if (s1 !== peg$FAILED) {
@@ -4019,7 +4219,7 @@ function peg$parse(input, options) {
4019
4219
  s5 = null;
4020
4220
  }
4021
4221
  peg$savedPos = s0;
4022
- s0 = peg$f46(s3, s5);
4222
+ s0 = peg$f47(s3, s5);
4023
4223
  } else {
4024
4224
  peg$currPos = s0;
4025
4225
  s0 = peg$FAILED;
@@ -4033,13 +4233,13 @@ function peg$parse(input, options) {
4033
4233
  function peg$parseIcon() {
4034
4234
  let s0, s1, s2, s3, s4, s5;
4035
4235
  s0 = peg$currPos;
4036
- if (input.substr(peg$currPos, 4) === peg$c48) {
4037
- s1 = peg$c48;
4236
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4237
+ s1 = peg$c49;
4038
4238
  peg$currPos += 4;
4039
4239
  } else {
4040
4240
  s1 = peg$FAILED;
4041
4241
  if (peg$silentFails === 0) {
4042
- peg$fail(peg$e51);
4242
+ peg$fail(peg$e52);
4043
4243
  }
4044
4244
  }
4045
4245
  if (s1 !== peg$FAILED) {
@@ -4052,7 +4252,7 @@ function peg$parse(input, options) {
4052
4252
  s5 = null;
4053
4253
  }
4054
4254
  peg$savedPos = s0;
4055
- s0 = peg$f47(s3, s5);
4255
+ s0 = peg$f48(s3, s5);
4056
4256
  } else {
4057
4257
  peg$currPos = s0;
4058
4258
  s0 = peg$FAILED;
@@ -4066,13 +4266,13 @@ function peg$parse(input, options) {
4066
4266
  function peg$parseTable() {
4067
4267
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4068
4268
  s0 = peg$currPos;
4069
- if (input.substr(peg$currPos, 5) === peg$c49) {
4070
- s1 = peg$c49;
4269
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4270
+ s1 = peg$c50;
4071
4271
  peg$currPos += 5;
4072
4272
  } else {
4073
4273
  s1 = peg$FAILED;
4074
4274
  if (peg$silentFails === 0) {
4075
- peg$fail(peg$e52);
4275
+ peg$fail(peg$e53);
4076
4276
  }
4077
4277
  }
4078
4278
  if (s1 !== peg$FAILED) {
@@ -4085,7 +4285,7 @@ function peg$parse(input, options) {
4085
4285
  s5 = null;
4086
4286
  }
4087
4287
  peg$savedPos = s0;
4088
- s0 = peg$f48(s3, s5);
4288
+ s0 = peg$f49(s3, s5);
4089
4289
  } else {
4090
4290
  peg$currPos = s0;
4091
4291
  s0 = peg$FAILED;
@@ -4096,13 +4296,13 @@ function peg$parse(input, options) {
4096
4296
  }
4097
4297
  if (s0 === peg$FAILED) {
4098
4298
  s0 = peg$currPos;
4099
- if (input.substr(peg$currPos, 5) === peg$c49) {
4100
- s1 = peg$c49;
4299
+ if (input.substr(peg$currPos, 5) === peg$c50) {
4300
+ s1 = peg$c50;
4101
4301
  peg$currPos += 5;
4102
4302
  } else {
4103
4303
  s1 = peg$FAILED;
4104
4304
  if (peg$silentFails === 0) {
4105
- peg$fail(peg$e52);
4305
+ peg$fail(peg$e53);
4106
4306
  }
4107
4307
  }
4108
4308
  if (s1 !== peg$FAILED) {
@@ -4136,7 +4336,7 @@ function peg$parse(input, options) {
4136
4336
  }
4137
4337
  if (s9 !== peg$FAILED) {
4138
4338
  peg$savedPos = s0;
4139
- s0 = peg$f49(s3, s7);
4339
+ s0 = peg$f50(s3, s7);
4140
4340
  } else {
4141
4341
  peg$currPos = s0;
4142
4342
  s0 = peg$FAILED;
@@ -4156,12 +4356,12 @@ function peg$parse(input, options) {
4156
4356
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
4157
4357
  s0 = peg$currPos;
4158
4358
  if (input.charCodeAt(peg$currPos) === 91) {
4159
- s1 = peg$c50;
4359
+ s1 = peg$c51;
4160
4360
  peg$currPos++;
4161
4361
  } else {
4162
4362
  s1 = peg$FAILED;
4163
4363
  if (peg$silentFails === 0) {
4164
- peg$fail(peg$e53);
4364
+ peg$fail(peg$e54);
4165
4365
  }
4166
4366
  }
4167
4367
  if (s1 !== peg$FAILED) {
@@ -4237,17 +4437,17 @@ function peg$parse(input, options) {
4237
4437
  }
4238
4438
  s7 = peg$parse_();
4239
4439
  if (input.charCodeAt(peg$currPos) === 93) {
4240
- s8 = peg$c51;
4440
+ s8 = peg$c52;
4241
4441
  peg$currPos++;
4242
4442
  } else {
4243
4443
  s8 = peg$FAILED;
4244
4444
  if (peg$silentFails === 0) {
4245
- peg$fail(peg$e54);
4445
+ peg$fail(peg$e55);
4246
4446
  }
4247
4447
  }
4248
4448
  if (s8 !== peg$FAILED) {
4249
4449
  peg$savedPos = s0;
4250
- s0 = peg$f50(s3, s5);
4450
+ s0 = peg$f51(s3, s5);
4251
4451
  } else {
4252
4452
  peg$currPos = s0;
4253
4453
  s0 = peg$FAILED;
@@ -4290,20 +4490,20 @@ function peg$parse(input, options) {
4290
4490
  }
4291
4491
  }
4292
4492
  peg$savedPos = s0;
4293
- s1 = peg$f51(s1);
4493
+ s1 = peg$f52(s1);
4294
4494
  s0 = s1;
4295
4495
  return s0;
4296
4496
  }
4297
4497
  function peg$parseTableRow() {
4298
4498
  let s0, s1, s2, s3;
4299
4499
  s0 = peg$currPos;
4300
- if (input.substr(peg$currPos, 7) === peg$c52) {
4301
- s1 = peg$c52;
4500
+ if (input.substr(peg$currPos, 7) === peg$c53) {
4501
+ s1 = peg$c53;
4302
4502
  peg$currPos += 7;
4303
4503
  } else {
4304
4504
  s1 = peg$FAILED;
4305
4505
  if (peg$silentFails === 0) {
4306
- peg$fail(peg$e55);
4506
+ peg$fail(peg$e56);
4307
4507
  }
4308
4508
  }
4309
4509
  if (s1 !== peg$FAILED) {
@@ -4311,7 +4511,7 @@ function peg$parse(input, options) {
4311
4511
  s3 = peg$parseArray();
4312
4512
  if (s3 !== peg$FAILED) {
4313
4513
  peg$savedPos = s0;
4314
- s0 = peg$f52(s3);
4514
+ s0 = peg$f53(s3);
4315
4515
  } else {
4316
4516
  peg$currPos = s0;
4317
4517
  s0 = peg$FAILED;
@@ -4322,13 +4522,13 @@ function peg$parse(input, options) {
4322
4522
  }
4323
4523
  if (s0 === peg$FAILED) {
4324
4524
  s0 = peg$currPos;
4325
- if (input.substr(peg$currPos, 3) === peg$c24) {
4326
- s1 = peg$c24;
4525
+ if (input.substr(peg$currPos, 3) === peg$c25) {
4526
+ s1 = peg$c25;
4327
4527
  peg$currPos += 3;
4328
4528
  } else {
4329
4529
  s1 = peg$FAILED;
4330
4530
  if (peg$silentFails === 0) {
4331
- peg$fail(peg$e27);
4531
+ peg$fail(peg$e28);
4332
4532
  }
4333
4533
  }
4334
4534
  if (s1 !== peg$FAILED) {
@@ -4336,7 +4536,7 @@ function peg$parse(input, options) {
4336
4536
  s3 = peg$parseArray();
4337
4537
  if (s3 !== peg$FAILED) {
4338
4538
  peg$savedPos = s0;
4339
- s0 = peg$f53(s3);
4539
+ s0 = peg$f54(s3);
4340
4540
  } else {
4341
4541
  peg$currPos = s0;
4342
4542
  s0 = peg$FAILED;
@@ -4350,7 +4550,7 @@ function peg$parse(input, options) {
4350
4550
  s1 = peg$parseComment();
4351
4551
  if (s1 !== peg$FAILED) {
4352
4552
  peg$savedPos = s0;
4353
- s1 = peg$f54();
4553
+ s1 = peg$f55();
4354
4554
  }
4355
4555
  s0 = s1;
4356
4556
  }
@@ -4360,13 +4560,13 @@ function peg$parse(input, options) {
4360
4560
  function peg$parseList() {
4361
4561
  let s0, s1, s2, s3, s4, s5, s6, s7;
4362
4562
  s0 = peg$currPos;
4363
- if (input.substr(peg$currPos, 4) === peg$c53) {
4364
- s1 = peg$c53;
4563
+ if (input.substr(peg$currPos, 4) === peg$c54) {
4564
+ s1 = peg$c54;
4365
4565
  peg$currPos += 4;
4366
4566
  } else {
4367
4567
  s1 = peg$FAILED;
4368
4568
  if (peg$silentFails === 0) {
4369
- peg$fail(peg$e56);
4569
+ peg$fail(peg$e57);
4370
4570
  }
4371
4571
  }
4372
4572
  if (s1 !== peg$FAILED) {
@@ -4386,7 +4586,7 @@ function peg$parse(input, options) {
4386
4586
  s7 = null;
4387
4587
  }
4388
4588
  peg$savedPos = s0;
4389
- s0 = peg$f55(s3, s5, s7);
4589
+ s0 = peg$f56(s3, s5, s7);
4390
4590
  } else {
4391
4591
  peg$currPos = s0;
4392
4592
  s0 = peg$FAILED;
@@ -4442,7 +4642,7 @@ function peg$parse(input, options) {
4442
4642
  }
4443
4643
  if (s4 !== peg$FAILED) {
4444
4644
  peg$savedPos = s0;
4445
- s0 = peg$f56(s3);
4645
+ s0 = peg$f57(s3);
4446
4646
  } else {
4447
4647
  peg$currPos = s0;
4448
4648
  s0 = peg$FAILED;
@@ -4456,13 +4656,13 @@ function peg$parse(input, options) {
4456
4656
  function peg$parseListItem() {
4457
4657
  let s0, s1, s2, s3, s4, s5, s6, s7;
4458
4658
  s0 = peg$currPos;
4459
- if (input.substr(peg$currPos, 4) === peg$c54) {
4460
- s1 = peg$c54;
4659
+ if (input.substr(peg$currPos, 4) === peg$c55) {
4660
+ s1 = peg$c55;
4461
4661
  peg$currPos += 4;
4462
4662
  } else {
4463
4663
  s1 = peg$FAILED;
4464
4664
  if (peg$silentFails === 0) {
4465
- peg$fail(peg$e57);
4665
+ peg$fail(peg$e58);
4466
4666
  }
4467
4667
  }
4468
4668
  if (s1 !== peg$FAILED) {
@@ -4480,7 +4680,7 @@ function peg$parse(input, options) {
4480
4680
  s7 = null;
4481
4681
  }
4482
4682
  peg$savedPos = s0;
4483
- s0 = peg$f57(s3, s5, s7);
4683
+ s0 = peg$f58(s3, s5, s7);
4484
4684
  } else {
4485
4685
  peg$currPos = s0;
4486
4686
  s0 = peg$FAILED;
@@ -4494,7 +4694,7 @@ function peg$parse(input, options) {
4494
4694
  s1 = peg$parseComment();
4495
4695
  if (s1 !== peg$FAILED) {
4496
4696
  peg$savedPos = s0;
4497
- s1 = peg$f58();
4697
+ s1 = peg$f59();
4498
4698
  }
4499
4699
  s0 = s1;
4500
4700
  }
@@ -4503,13 +4703,13 @@ function peg$parse(input, options) {
4503
4703
  function peg$parseAlert() {
4504
4704
  let s0, s1, s2, s3, s4, s5;
4505
4705
  s0 = peg$currPos;
4506
- if (input.substr(peg$currPos, 5) === peg$c55) {
4507
- s1 = peg$c55;
4706
+ if (input.substr(peg$currPos, 5) === peg$c56) {
4707
+ s1 = peg$c56;
4508
4708
  peg$currPos += 5;
4509
4709
  } else {
4510
4710
  s1 = peg$FAILED;
4511
4711
  if (peg$silentFails === 0) {
4512
- peg$fail(peg$e58);
4712
+ peg$fail(peg$e59);
4513
4713
  }
4514
4714
  }
4515
4715
  if (s1 !== peg$FAILED) {
@@ -4522,7 +4722,7 @@ function peg$parse(input, options) {
4522
4722
  s5 = null;
4523
4723
  }
4524
4724
  peg$savedPos = s0;
4525
- s0 = peg$f59(s3, s5);
4725
+ s0 = peg$f60(s3, s5);
4526
4726
  } else {
4527
4727
  peg$currPos = s0;
4528
4728
  s0 = peg$FAILED;
@@ -4536,13 +4736,13 @@ function peg$parse(input, options) {
4536
4736
  function peg$parseToast() {
4537
4737
  let s0, s1, s2, s3, s4, s5;
4538
4738
  s0 = peg$currPos;
4539
- if (input.substr(peg$currPos, 5) === peg$c56) {
4540
- s1 = peg$c56;
4739
+ if (input.substr(peg$currPos, 5) === peg$c57) {
4740
+ s1 = peg$c57;
4541
4741
  peg$currPos += 5;
4542
4742
  } else {
4543
4743
  s1 = peg$FAILED;
4544
4744
  if (peg$silentFails === 0) {
4545
- peg$fail(peg$e59);
4745
+ peg$fail(peg$e60);
4546
4746
  }
4547
4747
  }
4548
4748
  if (s1 !== peg$FAILED) {
@@ -4555,7 +4755,7 @@ function peg$parse(input, options) {
4555
4755
  s5 = null;
4556
4756
  }
4557
4757
  peg$savedPos = s0;
4558
- s0 = peg$f60(s3, s5);
4758
+ s0 = peg$f61(s3, s5);
4559
4759
  } else {
4560
4760
  peg$currPos = s0;
4561
4761
  s0 = peg$FAILED;
@@ -4569,13 +4769,13 @@ function peg$parse(input, options) {
4569
4769
  function peg$parseProgress() {
4570
4770
  let s0, s1, s2, s3;
4571
4771
  s0 = peg$currPos;
4572
- if (input.substr(peg$currPos, 8) === peg$c57) {
4573
- s1 = peg$c57;
4772
+ if (input.substr(peg$currPos, 8) === peg$c58) {
4773
+ s1 = peg$c58;
4574
4774
  peg$currPos += 8;
4575
4775
  } else {
4576
4776
  s1 = peg$FAILED;
4577
4777
  if (peg$silentFails === 0) {
4578
- peg$fail(peg$e60);
4778
+ peg$fail(peg$e61);
4579
4779
  }
4580
4780
  }
4581
4781
  if (s1 !== peg$FAILED) {
@@ -4585,7 +4785,7 @@ function peg$parse(input, options) {
4585
4785
  s3 = null;
4586
4786
  }
4587
4787
  peg$savedPos = s0;
4588
- s0 = peg$f61(s3);
4788
+ s0 = peg$f62(s3);
4589
4789
  } else {
4590
4790
  peg$currPos = s0;
4591
4791
  s0 = peg$FAILED;
@@ -4595,13 +4795,13 @@ function peg$parse(input, options) {
4595
4795
  function peg$parseSpinner() {
4596
4796
  let s0, s1, s2, s3, s4, s5;
4597
4797
  s0 = peg$currPos;
4598
- if (input.substr(peg$currPos, 7) === peg$c58) {
4599
- s1 = peg$c58;
4798
+ if (input.substr(peg$currPos, 7) === peg$c59) {
4799
+ s1 = peg$c59;
4600
4800
  peg$currPos += 7;
4601
4801
  } else {
4602
4802
  s1 = peg$FAILED;
4603
4803
  if (peg$silentFails === 0) {
4604
- peg$fail(peg$e61);
4804
+ peg$fail(peg$e62);
4605
4805
  }
4606
4806
  }
4607
4807
  if (s1 !== peg$FAILED) {
@@ -4616,7 +4816,7 @@ function peg$parse(input, options) {
4616
4816
  s5 = null;
4617
4817
  }
4618
4818
  peg$savedPos = s0;
4619
- s0 = peg$f62(s3, s5);
4819
+ s0 = peg$f63(s3, s5);
4620
4820
  } else {
4621
4821
  peg$currPos = s0;
4622
4822
  s0 = peg$FAILED;
@@ -4626,13 +4826,13 @@ function peg$parse(input, options) {
4626
4826
  function peg$parseTooltip() {
4627
4827
  let s0, s1, s2, s3, s4, s5;
4628
4828
  s0 = peg$currPos;
4629
- if (input.substr(peg$currPos, 7) === peg$c59) {
4630
- s1 = peg$c59;
4829
+ if (input.substr(peg$currPos, 7) === peg$c60) {
4830
+ s1 = peg$c60;
4631
4831
  peg$currPos += 7;
4632
4832
  } else {
4633
4833
  s1 = peg$FAILED;
4634
4834
  if (peg$silentFails === 0) {
4635
- peg$fail(peg$e62);
4835
+ peg$fail(peg$e63);
4636
4836
  }
4637
4837
  }
4638
4838
  if (s1 !== peg$FAILED) {
@@ -4645,7 +4845,7 @@ function peg$parse(input, options) {
4645
4845
  s5 = null;
4646
4846
  }
4647
4847
  peg$savedPos = s0;
4648
- s0 = peg$f63(s3, s5);
4848
+ s0 = peg$f64(s3, s5);
4649
4849
  } else {
4650
4850
  peg$currPos = s0;
4651
4851
  s0 = peg$FAILED;
@@ -4659,13 +4859,13 @@ function peg$parse(input, options) {
4659
4859
  function peg$parsePopover() {
4660
4860
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
4661
4861
  s0 = peg$currPos;
4662
- if (input.substr(peg$currPos, 7) === peg$c60) {
4663
- s1 = peg$c60;
4862
+ if (input.substr(peg$currPos, 7) === peg$c61) {
4863
+ s1 = peg$c61;
4664
4864
  peg$currPos += 7;
4665
4865
  } else {
4666
4866
  s1 = peg$FAILED;
4667
4867
  if (peg$silentFails === 0) {
4668
- peg$fail(peg$e63);
4868
+ peg$fail(peg$e64);
4669
4869
  }
4670
4870
  }
4671
4871
  if (s1 !== peg$FAILED) {
@@ -4705,7 +4905,7 @@ function peg$parse(input, options) {
4705
4905
  }
4706
4906
  if (s11 !== peg$FAILED) {
4707
4907
  peg$savedPos = s0;
4708
- s0 = peg$f64(s3, s5, s9);
4908
+ s0 = peg$f65(s3, s5, s9);
4709
4909
  } else {
4710
4910
  peg$currPos = s0;
4711
4911
  s0 = peg$FAILED;
@@ -4727,13 +4927,13 @@ function peg$parse(input, options) {
4727
4927
  function peg$parseDropdown() {
4728
4928
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
4729
4929
  s0 = peg$currPos;
4730
- if (input.substr(peg$currPos, 8) === peg$c61) {
4731
- s1 = peg$c61;
4930
+ if (input.substr(peg$currPos, 8) === peg$c62) {
4931
+ s1 = peg$c62;
4732
4932
  peg$currPos += 8;
4733
4933
  } else {
4734
4934
  s1 = peg$FAILED;
4735
4935
  if (peg$silentFails === 0) {
4736
- peg$fail(peg$e64);
4936
+ peg$fail(peg$e65);
4737
4937
  }
4738
4938
  }
4739
4939
  if (s1 !== peg$FAILED) {
@@ -4746,7 +4946,7 @@ function peg$parse(input, options) {
4746
4946
  s5 = null;
4747
4947
  }
4748
4948
  peg$savedPos = s0;
4749
- s0 = peg$f65(s3, s5);
4949
+ s0 = peg$f66(s3, s5);
4750
4950
  } else {
4751
4951
  peg$currPos = s0;
4752
4952
  s0 = peg$FAILED;
@@ -4757,13 +4957,13 @@ function peg$parse(input, options) {
4757
4957
  }
4758
4958
  if (s0 === peg$FAILED) {
4759
4959
  s0 = peg$currPos;
4760
- if (input.substr(peg$currPos, 8) === peg$c61) {
4761
- s1 = peg$c61;
4960
+ if (input.substr(peg$currPos, 8) === peg$c62) {
4961
+ s1 = peg$c62;
4762
4962
  peg$currPos += 8;
4763
4963
  } else {
4764
4964
  s1 = peg$FAILED;
4765
4965
  if (peg$silentFails === 0) {
4766
- peg$fail(peg$e64);
4966
+ peg$fail(peg$e65);
4767
4967
  }
4768
4968
  }
4769
4969
  if (s1 !== peg$FAILED) {
@@ -4797,7 +4997,7 @@ function peg$parse(input, options) {
4797
4997
  }
4798
4998
  if (s9 !== peg$FAILED) {
4799
4999
  peg$savedPos = s0;
4800
- s0 = peg$f66(s3, s7);
5000
+ s0 = peg$f67(s3, s7);
4801
5001
  } else {
4802
5002
  peg$currPos = s0;
4803
5003
  s0 = peg$FAILED;
@@ -4841,20 +5041,20 @@ function peg$parse(input, options) {
4841
5041
  }
4842
5042
  }
4843
5043
  peg$savedPos = s0;
4844
- s1 = peg$f67(s1);
5044
+ s1 = peg$f68(s1);
4845
5045
  s0 = s1;
4846
5046
  return s0;
4847
5047
  }
4848
5048
  function peg$parseDropdownItem() {
4849
5049
  let s0, s1, s2, s3, s4, s5;
4850
5050
  s0 = peg$currPos;
4851
- if (input.substr(peg$currPos, 4) === peg$c54) {
4852
- s1 = peg$c54;
5051
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5052
+ s1 = peg$c55;
4853
5053
  peg$currPos += 4;
4854
5054
  } else {
4855
5055
  s1 = peg$FAILED;
4856
5056
  if (peg$silentFails === 0) {
4857
- peg$fail(peg$e57);
5057
+ peg$fail(peg$e58);
4858
5058
  }
4859
5059
  }
4860
5060
  if (s1 !== peg$FAILED) {
@@ -4867,7 +5067,7 @@ function peg$parse(input, options) {
4867
5067
  s5 = null;
4868
5068
  }
4869
5069
  peg$savedPos = s0;
4870
- s0 = peg$f68(s3, s5);
5070
+ s0 = peg$f69(s3, s5);
4871
5071
  } else {
4872
5072
  peg$currPos = s0;
4873
5073
  s0 = peg$FAILED;
@@ -4878,18 +5078,18 @@ function peg$parse(input, options) {
4878
5078
  }
4879
5079
  if (s0 === peg$FAILED) {
4880
5080
  s0 = peg$currPos;
4881
- if (input.substr(peg$currPos, 7) === peg$c62) {
4882
- s1 = peg$c62;
5081
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5082
+ s1 = peg$c63;
4883
5083
  peg$currPos += 7;
4884
5084
  } else {
4885
5085
  s1 = peg$FAILED;
4886
5086
  if (peg$silentFails === 0) {
4887
- peg$fail(peg$e65);
5087
+ peg$fail(peg$e66);
4888
5088
  }
4889
5089
  }
4890
5090
  if (s1 !== peg$FAILED) {
4891
5091
  peg$savedPos = s0;
4892
- s1 = peg$f69();
5092
+ s1 = peg$f70();
4893
5093
  }
4894
5094
  s0 = s1;
4895
5095
  if (s0 === peg$FAILED) {
@@ -4897,7 +5097,7 @@ function peg$parse(input, options) {
4897
5097
  s1 = peg$parseComment();
4898
5098
  if (s1 !== peg$FAILED) {
4899
5099
  peg$savedPos = s0;
4900
- s1 = peg$f70();
5100
+ s1 = peg$f71();
4901
5101
  }
4902
5102
  s0 = s1;
4903
5103
  }
@@ -4907,13 +5107,13 @@ function peg$parse(input, options) {
4907
5107
  function peg$parseNav() {
4908
5108
  let s0, s1, s2, s3, s4, s5, s6, s7;
4909
5109
  s0 = peg$currPos;
4910
- if (input.substr(peg$currPos, 3) === peg$c63) {
4911
- s1 = peg$c63;
5110
+ if (input.substr(peg$currPos, 3) === peg$c64) {
5111
+ s1 = peg$c64;
4912
5112
  peg$currPos += 3;
4913
5113
  } else {
4914
5114
  s1 = peg$FAILED;
4915
5115
  if (peg$silentFails === 0) {
4916
- peg$fail(peg$e66);
5116
+ peg$fail(peg$e67);
4917
5117
  }
4918
5118
  }
4919
5119
  if (s1 !== peg$FAILED) {
@@ -4933,7 +5133,7 @@ function peg$parse(input, options) {
4933
5133
  s7 = null;
4934
5134
  }
4935
5135
  peg$savedPos = s0;
4936
- s0 = peg$f71(s3, s5, s7);
5136
+ s0 = peg$f72(s3, s5, s7);
4937
5137
  } else {
4938
5138
  peg$currPos = s0;
4939
5139
  s0 = peg$FAILED;
@@ -4989,7 +5189,7 @@ function peg$parse(input, options) {
4989
5189
  }
4990
5190
  if (s4 !== peg$FAILED) {
4991
5191
  peg$savedPos = s0;
4992
- s0 = peg$f72(s3);
5192
+ s0 = peg$f73(s3);
4993
5193
  } else {
4994
5194
  peg$currPos = s0;
4995
5195
  s0 = peg$FAILED;
@@ -5007,19 +5207,19 @@ function peg$parse(input, options) {
5007
5207
  s0 = peg$parseNavItem();
5008
5208
  if (s0 === peg$FAILED) {
5009
5209
  s0 = peg$currPos;
5010
- if (input.substr(peg$currPos, 7) === peg$c62) {
5011
- s1 = peg$c62;
5210
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5211
+ s1 = peg$c63;
5012
5212
  peg$currPos += 7;
5013
5213
  } else {
5014
5214
  s1 = peg$FAILED;
5015
5215
  if (peg$silentFails === 0) {
5016
- peg$fail(peg$e65);
5216
+ peg$fail(peg$e66);
5017
5217
  }
5018
5218
  }
5019
5219
  if (s1 !== peg$FAILED) {
5020
5220
  s2 = peg$parse_();
5021
5221
  peg$savedPos = s0;
5022
- s0 = peg$f73();
5222
+ s0 = peg$f74();
5023
5223
  } else {
5024
5224
  peg$currPos = s0;
5025
5225
  s0 = peg$FAILED;
@@ -5029,7 +5229,7 @@ function peg$parse(input, options) {
5029
5229
  s1 = peg$parseComment();
5030
5230
  if (s1 !== peg$FAILED) {
5031
5231
  peg$savedPos = s0;
5032
- s1 = peg$f74();
5232
+ s1 = peg$f75();
5033
5233
  }
5034
5234
  s0 = s1;
5035
5235
  }
@@ -5040,13 +5240,13 @@ function peg$parse(input, options) {
5040
5240
  function peg$parseNavGroup() {
5041
5241
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
5042
5242
  s0 = peg$currPos;
5043
- if (input.substr(peg$currPos, 5) === peg$c64) {
5044
- s1 = peg$c64;
5243
+ if (input.substr(peg$currPos, 5) === peg$c65) {
5244
+ s1 = peg$c65;
5045
5245
  peg$currPos += 5;
5046
5246
  } else {
5047
5247
  s1 = peg$FAILED;
5048
5248
  if (peg$silentFails === 0) {
5049
- peg$fail(peg$e67);
5249
+ peg$fail(peg$e68);
5050
5250
  }
5051
5251
  }
5052
5252
  if (s1 !== peg$FAILED) {
@@ -5105,7 +5305,7 @@ function peg$parse(input, options) {
5105
5305
  }
5106
5306
  if (s10 !== peg$FAILED) {
5107
5307
  peg$savedPos = s0;
5108
- s0 = peg$f75(s3, s5, s9);
5308
+ s0 = peg$f76(s3, s5, s9);
5109
5309
  } else {
5110
5310
  peg$currPos = s0;
5111
5311
  s0 = peg$FAILED;
@@ -5129,19 +5329,19 @@ function peg$parse(input, options) {
5129
5329
  s0 = peg$parseNavItem();
5130
5330
  if (s0 === peg$FAILED) {
5131
5331
  s0 = peg$currPos;
5132
- if (input.substr(peg$currPos, 7) === peg$c62) {
5133
- s1 = peg$c62;
5332
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5333
+ s1 = peg$c63;
5134
5334
  peg$currPos += 7;
5135
5335
  } else {
5136
5336
  s1 = peg$FAILED;
5137
5337
  if (peg$silentFails === 0) {
5138
- peg$fail(peg$e65);
5338
+ peg$fail(peg$e66);
5139
5339
  }
5140
5340
  }
5141
5341
  if (s1 !== peg$FAILED) {
5142
5342
  s2 = peg$parse_();
5143
5343
  peg$savedPos = s0;
5144
- s0 = peg$f76();
5344
+ s0 = peg$f77();
5145
5345
  } else {
5146
5346
  peg$currPos = s0;
5147
5347
  s0 = peg$FAILED;
@@ -5151,7 +5351,7 @@ function peg$parse(input, options) {
5151
5351
  s1 = peg$parseComment();
5152
5352
  if (s1 !== peg$FAILED) {
5153
5353
  peg$savedPos = s0;
5154
- s1 = peg$f77();
5354
+ s1 = peg$f78();
5155
5355
  }
5156
5356
  s0 = s1;
5157
5357
  }
@@ -5161,13 +5361,13 @@ function peg$parse(input, options) {
5161
5361
  function peg$parseNavItem() {
5162
5362
  let s0, s1, s2, s3, s4, s5;
5163
5363
  s0 = peg$currPos;
5164
- if (input.substr(peg$currPos, 4) === peg$c54) {
5165
- s1 = peg$c54;
5364
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5365
+ s1 = peg$c55;
5166
5366
  peg$currPos += 4;
5167
5367
  } else {
5168
5368
  s1 = peg$FAILED;
5169
5369
  if (peg$silentFails === 0) {
5170
- peg$fail(peg$e57);
5370
+ peg$fail(peg$e58);
5171
5371
  }
5172
5372
  }
5173
5373
  if (s1 !== peg$FAILED) {
@@ -5180,7 +5380,7 @@ function peg$parse(input, options) {
5180
5380
  s5 = null;
5181
5381
  }
5182
5382
  peg$savedPos = s0;
5183
- s0 = peg$f78(s3, s5);
5383
+ s0 = peg$f79(s3, s5);
5184
5384
  } else {
5185
5385
  peg$currPos = s0;
5186
5386
  s0 = peg$FAILED;
@@ -5194,13 +5394,13 @@ function peg$parse(input, options) {
5194
5394
  function peg$parseTabs() {
5195
5395
  let s0, s1, s2, s3, s4, s5, s6, s7;
5196
5396
  s0 = peg$currPos;
5197
- if (input.substr(peg$currPos, 4) === peg$c65) {
5198
- s1 = peg$c65;
5397
+ if (input.substr(peg$currPos, 4) === peg$c66) {
5398
+ s1 = peg$c66;
5199
5399
  peg$currPos += 4;
5200
5400
  } else {
5201
5401
  s1 = peg$FAILED;
5202
5402
  if (peg$silentFails === 0) {
5203
- peg$fail(peg$e68);
5403
+ peg$fail(peg$e69);
5204
5404
  }
5205
5405
  }
5206
5406
  if (s1 !== peg$FAILED) {
@@ -5220,7 +5420,7 @@ function peg$parse(input, options) {
5220
5420
  s7 = null;
5221
5421
  }
5222
5422
  peg$savedPos = s0;
5223
- s0 = peg$f79(s3, s5, s7);
5423
+ s0 = peg$f80(s3, s5, s7);
5224
5424
  } else {
5225
5425
  peg$currPos = s0;
5226
5426
  s0 = peg$FAILED;
@@ -5276,7 +5476,7 @@ function peg$parse(input, options) {
5276
5476
  }
5277
5477
  if (s4 !== peg$FAILED) {
5278
5478
  peg$savedPos = s0;
5279
- s0 = peg$f80(s3);
5479
+ s0 = peg$f81(s3);
5280
5480
  } else {
5281
5481
  peg$currPos = s0;
5282
5482
  s0 = peg$FAILED;
@@ -5290,13 +5490,13 @@ function peg$parse(input, options) {
5290
5490
  function peg$parseTabItem() {
5291
5491
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
5292
5492
  s0 = peg$currPos;
5293
- if (input.substr(peg$currPos, 3) === peg$c66) {
5294
- s1 = peg$c66;
5493
+ if (input.substr(peg$currPos, 3) === peg$c67) {
5494
+ s1 = peg$c67;
5295
5495
  peg$currPos += 3;
5296
5496
  } else {
5297
5497
  s1 = peg$FAILED;
5298
5498
  if (peg$silentFails === 0) {
5299
- peg$fail(peg$e69);
5499
+ peg$fail(peg$e70);
5300
5500
  }
5301
5501
  }
5302
5502
  if (s1 !== peg$FAILED) {
@@ -5334,7 +5534,7 @@ function peg$parse(input, options) {
5334
5534
  }
5335
5535
  if (s11 !== peg$FAILED) {
5336
5536
  peg$savedPos = s0;
5337
- s0 = peg$f81(s3, s5, s9);
5537
+ s0 = peg$f82(s3, s5, s9);
5338
5538
  } else {
5339
5539
  peg$currPos = s0;
5340
5540
  s0 = peg$FAILED;
@@ -5360,7 +5560,7 @@ function peg$parse(input, options) {
5360
5560
  s1 = peg$parseComment();
5361
5561
  if (s1 !== peg$FAILED) {
5362
5562
  peg$savedPos = s0;
5363
- s1 = peg$f82();
5563
+ s1 = peg$f83();
5364
5564
  }
5365
5565
  s0 = s1;
5366
5566
  }
@@ -5369,13 +5569,13 @@ function peg$parse(input, options) {
5369
5569
  function peg$parseBreadcrumb() {
5370
5570
  let s0, s1, s2, s3, s4, s5;
5371
5571
  s0 = peg$currPos;
5372
- if (input.substr(peg$currPos, 10) === peg$c67) {
5373
- s1 = peg$c67;
5572
+ if (input.substr(peg$currPos, 10) === peg$c68) {
5573
+ s1 = peg$c68;
5374
5574
  peg$currPos += 10;
5375
5575
  } else {
5376
5576
  s1 = peg$FAILED;
5377
5577
  if (peg$silentFails === 0) {
5378
- peg$fail(peg$e70);
5578
+ peg$fail(peg$e71);
5379
5579
  }
5380
5580
  }
5381
5581
  if (s1 !== peg$FAILED) {
@@ -5388,7 +5588,7 @@ function peg$parse(input, options) {
5388
5588
  s5 = null;
5389
5589
  }
5390
5590
  peg$savedPos = s0;
5391
- s0 = peg$f83(s3, s5);
5591
+ s0 = peg$f84(s3, s5);
5392
5592
  } else {
5393
5593
  peg$currPos = s0;
5394
5594
  s0 = peg$FAILED;
@@ -5402,13 +5602,13 @@ function peg$parse(input, options) {
5402
5602
  function peg$parseDivider() {
5403
5603
  let s0, s1, s2, s3;
5404
5604
  s0 = peg$currPos;
5405
- if (input.substr(peg$currPos, 7) === peg$c62) {
5406
- s1 = peg$c62;
5605
+ if (input.substr(peg$currPos, 7) === peg$c63) {
5606
+ s1 = peg$c63;
5407
5607
  peg$currPos += 7;
5408
5608
  } else {
5409
5609
  s1 = peg$FAILED;
5410
5610
  if (peg$silentFails === 0) {
5411
- peg$fail(peg$e65);
5611
+ peg$fail(peg$e66);
5412
5612
  }
5413
5613
  }
5414
5614
  if (s1 !== peg$FAILED) {
@@ -5418,7 +5618,7 @@ function peg$parse(input, options) {
5418
5618
  s3 = null;
5419
5619
  }
5420
5620
  peg$savedPos = s0;
5421
- s0 = peg$f84(s3);
5621
+ s0 = peg$f85(s3);
5422
5622
  } else {
5423
5623
  peg$currPos = s0;
5424
5624
  s0 = peg$FAILED;
@@ -5428,13 +5628,13 @@ function peg$parse(input, options) {
5428
5628
  function peg$parseMarker() {
5429
5629
  let s0, s1, s2, s3, s4, s5;
5430
5630
  s0 = peg$currPos;
5431
- if (input.substr(peg$currPos, 6) === peg$c68) {
5432
- s1 = peg$c68;
5631
+ if (input.substr(peg$currPos, 6) === peg$c69) {
5632
+ s1 = peg$c69;
5433
5633
  peg$currPos += 6;
5434
5634
  } else {
5435
5635
  s1 = peg$FAILED;
5436
5636
  if (peg$silentFails === 0) {
5437
- peg$fail(peg$e71);
5637
+ peg$fail(peg$e72);
5438
5638
  }
5439
5639
  }
5440
5640
  if (s1 !== peg$FAILED) {
@@ -5447,7 +5647,7 @@ function peg$parse(input, options) {
5447
5647
  s5 = null;
5448
5648
  }
5449
5649
  peg$savedPos = s0;
5450
- s0 = peg$f85(s3, s5);
5650
+ s0 = peg$f86(s3, s5);
5451
5651
  } else {
5452
5652
  peg$currPos = s0;
5453
5653
  s0 = peg$FAILED;
@@ -5461,13 +5661,13 @@ function peg$parse(input, options) {
5461
5661
  function peg$parseAnnotations() {
5462
5662
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
5463
5663
  s0 = peg$currPos;
5464
- if (input.substr(peg$currPos, 11) === peg$c69) {
5465
- s1 = peg$c69;
5664
+ if (input.substr(peg$currPos, 11) === peg$c70) {
5665
+ s1 = peg$c70;
5466
5666
  peg$currPos += 11;
5467
5667
  } else {
5468
5668
  s1 = peg$FAILED;
5469
5669
  if (peg$silentFails === 0) {
5470
- peg$fail(peg$e72);
5670
+ peg$fail(peg$e73);
5471
5671
  }
5472
5672
  }
5473
5673
  if (s1 !== peg$FAILED) {
@@ -5501,7 +5701,7 @@ function peg$parse(input, options) {
5501
5701
  }
5502
5702
  if (s9 !== peg$FAILED) {
5503
5703
  peg$savedPos = s0;
5504
- s0 = peg$f86(s3, s7);
5704
+ s0 = peg$f87(s3, s7);
5505
5705
  } else {
5506
5706
  peg$currPos = s0;
5507
5707
  s0 = peg$FAILED;
@@ -5544,20 +5744,20 @@ function peg$parse(input, options) {
5544
5744
  }
5545
5745
  }
5546
5746
  peg$savedPos = s0;
5547
- s1 = peg$f87(s1);
5747
+ s1 = peg$f88(s1);
5548
5748
  s0 = s1;
5549
5749
  return s0;
5550
5750
  }
5551
5751
  function peg$parseAnnotationItem() {
5552
5752
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5553
5753
  s0 = peg$currPos;
5554
- if (input.substr(peg$currPos, 4) === peg$c54) {
5555
- s1 = peg$c54;
5754
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5755
+ s1 = peg$c55;
5556
5756
  peg$currPos += 4;
5557
5757
  } else {
5558
5758
  s1 = peg$FAILED;
5559
5759
  if (peg$silentFails === 0) {
5560
- peg$fail(peg$e57);
5760
+ peg$fail(peg$e58);
5561
5761
  }
5562
5762
  }
5563
5763
  if (s1 !== peg$FAILED) {
@@ -5598,7 +5798,7 @@ function peg$parse(input, options) {
5598
5798
  }
5599
5799
  if (s13 !== peg$FAILED) {
5600
5800
  peg$savedPos = s0;
5601
- s0 = peg$f88(s3, s5, s7, s11);
5801
+ s0 = peg$f89(s3, s5, s7, s11);
5602
5802
  } else {
5603
5803
  peg$currPos = s0;
5604
5804
  s0 = peg$FAILED;
@@ -5625,13 +5825,13 @@ function peg$parse(input, options) {
5625
5825
  }
5626
5826
  if (s0 === peg$FAILED) {
5627
5827
  s0 = peg$currPos;
5628
- if (input.substr(peg$currPos, 4) === peg$c54) {
5629
- s1 = peg$c54;
5828
+ if (input.substr(peg$currPos, 4) === peg$c55) {
5829
+ s1 = peg$c55;
5630
5830
  peg$currPos += 4;
5631
5831
  } else {
5632
5832
  s1 = peg$FAILED;
5633
5833
  if (peg$silentFails === 0) {
5634
- peg$fail(peg$e57);
5834
+ peg$fail(peg$e58);
5635
5835
  }
5636
5836
  }
5637
5837
  if (s1 !== peg$FAILED) {
@@ -5647,7 +5847,7 @@ function peg$parse(input, options) {
5647
5847
  s7 = null;
5648
5848
  }
5649
5849
  peg$savedPos = s0;
5650
- s0 = peg$f89(s3, s5, s7);
5850
+ s0 = peg$f90(s3, s5, s7);
5651
5851
  } else {
5652
5852
  peg$currPos = s0;
5653
5853
  s0 = peg$FAILED;
@@ -5665,7 +5865,7 @@ function peg$parse(input, options) {
5665
5865
  s1 = peg$parseComment();
5666
5866
  if (s1 !== peg$FAILED) {
5667
5867
  peg$savedPos = s0;
5668
- s1 = peg$f90();
5868
+ s1 = peg$f91();
5669
5869
  }
5670
5870
  s0 = s1;
5671
5871
  }
@@ -5683,7 +5883,7 @@ function peg$parse(input, options) {
5683
5883
  } else {
5684
5884
  s2 = peg$FAILED;
5685
5885
  if (peg$silentFails === 0) {
5686
- peg$fail(peg$e74);
5886
+ peg$fail(peg$e75);
5687
5887
  }
5688
5888
  }
5689
5889
  if (s2 !== peg$FAILED) {
@@ -5695,7 +5895,7 @@ function peg$parse(input, options) {
5695
5895
  } else {
5696
5896
  s2 = peg$FAILED;
5697
5897
  if (peg$silentFails === 0) {
5698
- peg$fail(peg$e74);
5898
+ peg$fail(peg$e75);
5699
5899
  }
5700
5900
  }
5701
5901
  }
@@ -5704,14 +5904,14 @@ function peg$parse(input, options) {
5704
5904
  }
5705
5905
  if (s1 !== peg$FAILED) {
5706
5906
  peg$savedPos = s0;
5707
- s1 = peg$f91(s1);
5907
+ s1 = peg$f92(s1);
5708
5908
  }
5709
5909
  s0 = s1;
5710
5910
  peg$silentFails--;
5711
5911
  if (s0 === peg$FAILED) {
5712
5912
  s1 = peg$FAILED;
5713
5913
  if (peg$silentFails === 0) {
5714
- peg$fail(peg$e73);
5914
+ peg$fail(peg$e74);
5715
5915
  }
5716
5916
  }
5717
5917
  return s0;
@@ -5731,7 +5931,7 @@ function peg$parse(input, options) {
5731
5931
  }
5732
5932
  if (s1 !== peg$FAILED) {
5733
5933
  peg$savedPos = s0;
5734
- s1 = peg$f92(s1);
5934
+ s1 = peg$f93(s1);
5735
5935
  }
5736
5936
  s0 = s1;
5737
5937
  return s0;
@@ -5740,13 +5940,13 @@ function peg$parse(input, options) {
5740
5940
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
5741
5941
  s0 = peg$currPos;
5742
5942
  s1 = peg$parse_();
5743
- if (input.substr(peg$currPos, 2) === peg$c70) {
5744
- s2 = peg$c70;
5943
+ if (input.substr(peg$currPos, 2) === peg$c71) {
5944
+ s2 = peg$c71;
5745
5945
  peg$currPos += 2;
5746
5946
  } else {
5747
5947
  s2 = peg$FAILED;
5748
5948
  if (peg$silentFails === 0) {
5749
- peg$fail(peg$e75);
5949
+ peg$fail(peg$e76);
5750
5950
  }
5751
5951
  }
5752
5952
  if (s2 !== peg$FAILED) {
@@ -5801,7 +6001,7 @@ function peg$parse(input, options) {
5801
6001
  }
5802
6002
  if (s13 !== peg$FAILED) {
5803
6003
  peg$savedPos = s0;
5804
- s0 = peg$f93(s7, s11);
6004
+ s0 = peg$f94(s7, s11);
5805
6005
  } else {
5806
6006
  peg$currPos = s0;
5807
6007
  s0 = peg$FAILED;
@@ -5850,7 +6050,7 @@ function peg$parse(input, options) {
5850
6050
  s6 = peg$parseAttributeValue();
5851
6051
  if (s6 !== peg$FAILED) {
5852
6052
  peg$savedPos = s0;
5853
- s0 = peg$f94(s2, s6);
6053
+ s0 = peg$f95(s2, s6);
5854
6054
  } else {
5855
6055
  peg$currPos = s0;
5856
6056
  s0 = peg$FAILED;
@@ -5882,7 +6082,7 @@ function peg$parse(input, options) {
5882
6082
  } else {
5883
6083
  s6 = peg$FAILED;
5884
6084
  if (peg$silentFails === 0) {
5885
- peg$fail(peg$e76);
6085
+ peg$fail(peg$e77);
5886
6086
  }
5887
6087
  }
5888
6088
  if (s6 === peg$FAILED) {
@@ -5945,7 +6145,7 @@ function peg$parse(input, options) {
5945
6145
  }
5946
6146
  if (s3 !== peg$FAILED) {
5947
6147
  peg$savedPos = s0;
5948
- s0 = peg$f95(s2);
6148
+ s0 = peg$f96(s2);
5949
6149
  } else {
5950
6150
  peg$currPos = s0;
5951
6151
  s0 = peg$FAILED;
@@ -5975,7 +6175,7 @@ function peg$parse(input, options) {
5975
6175
  s2 = peg$parseIdentifier();
5976
6176
  if (s2 !== peg$FAILED) {
5977
6177
  peg$savedPos = s0;
5978
- s0 = peg$f96(s2);
6178
+ s0 = peg$f97(s2);
5979
6179
  } else {
5980
6180
  peg$currPos = s0;
5981
6181
  s0 = peg$FAILED;
@@ -5999,503 +6199,514 @@ function peg$parse(input, options) {
5999
6199
  }
6000
6200
  }
6001
6201
  if (s1 === peg$FAILED) {
6002
- if (input.substr(peg$currPos, 6) === peg$c20) {
6003
- s1 = peg$c20;
6202
+ if (input.substr(peg$currPos, 6) === peg$c21) {
6203
+ s1 = peg$c21;
6004
6204
  peg$currPos += 6;
6005
6205
  } else {
6006
6206
  s1 = peg$FAILED;
6007
6207
  if (peg$silentFails === 0) {
6008
- peg$fail(peg$e23);
6208
+ peg$fail(peg$e24);
6009
6209
  }
6010
6210
  }
6011
6211
  if (s1 === peg$FAILED) {
6012
- if (input.substr(peg$currPos, 4) === peg$c21) {
6013
- s1 = peg$c21;
6212
+ if (input.substr(peg$currPos, 4) === peg$c22) {
6213
+ s1 = peg$c22;
6014
6214
  peg$currPos += 4;
6015
6215
  } else {
6016
6216
  s1 = peg$FAILED;
6017
6217
  if (peg$silentFails === 0) {
6018
- peg$fail(peg$e24);
6218
+ peg$fail(peg$e25);
6019
6219
  }
6020
6220
  }
6021
6221
  if (s1 === peg$FAILED) {
6022
- if (input.substr(peg$currPos, 6) === peg$c22) {
6023
- s1 = peg$c22;
6222
+ if (input.substr(peg$currPos, 6) === peg$c23) {
6223
+ s1 = peg$c23;
6024
6224
  peg$currPos += 6;
6025
6225
  } else {
6026
6226
  s1 = peg$FAILED;
6027
6227
  if (peg$silentFails === 0) {
6028
- peg$fail(peg$e25);
6228
+ peg$fail(peg$e26);
6029
6229
  }
6030
6230
  }
6031
6231
  if (s1 === peg$FAILED) {
6032
- if (input.substr(peg$currPos, 7) === peg$c23) {
6033
- s1 = peg$c23;
6232
+ if (input.substr(peg$currPos, 7) === peg$c24) {
6233
+ s1 = peg$c24;
6034
6234
  peg$currPos += 7;
6035
6235
  } else {
6036
6236
  s1 = peg$FAILED;
6037
6237
  if (peg$silentFails === 0) {
6038
- peg$fail(peg$e26);
6238
+ peg$fail(peg$e27);
6039
6239
  }
6040
6240
  }
6041
6241
  if (s1 === peg$FAILED) {
6042
- if (input.substr(peg$currPos, 3) === peg$c24) {
6043
- s1 = peg$c24;
6242
+ if (input.substr(peg$currPos, 3) === peg$c25) {
6243
+ s1 = peg$c25;
6044
6244
  peg$currPos += 3;
6045
6245
  } else {
6046
6246
  s1 = peg$FAILED;
6047
6247
  if (peg$silentFails === 0) {
6048
- peg$fail(peg$e27);
6248
+ peg$fail(peg$e28);
6049
6249
  }
6050
6250
  }
6051
6251
  if (s1 === peg$FAILED) {
6052
- if (input.substr(peg$currPos, 3) === peg$c25) {
6053
- s1 = peg$c25;
6252
+ if (input.substr(peg$currPos, 3) === peg$c26) {
6253
+ s1 = peg$c26;
6054
6254
  peg$currPos += 3;
6055
6255
  } else {
6056
6256
  s1 = peg$FAILED;
6057
6257
  if (peg$silentFails === 0) {
6058
- peg$fail(peg$e28);
6258
+ peg$fail(peg$e29);
6059
6259
  }
6060
6260
  }
6061
6261
  if (s1 === peg$FAILED) {
6062
- if (input.substr(peg$currPos, 5) === peg$c26) {
6063
- s1 = peg$c26;
6262
+ if (input.substr(peg$currPos, 5) === peg$c27) {
6263
+ s1 = peg$c27;
6064
6264
  peg$currPos += 5;
6065
6265
  } else {
6066
6266
  s1 = peg$FAILED;
6067
6267
  if (peg$silentFails === 0) {
6068
- peg$fail(peg$e29);
6268
+ peg$fail(peg$e30);
6069
6269
  }
6070
6270
  }
6071
6271
  if (s1 === peg$FAILED) {
6072
- if (input.substr(peg$currPos, 8) === peg$c27) {
6073
- s1 = peg$c27;
6272
+ if (input.substr(peg$currPos, 8) === peg$c28) {
6273
+ s1 = peg$c28;
6074
6274
  peg$currPos += 8;
6075
6275
  } else {
6076
6276
  s1 = peg$FAILED;
6077
6277
  if (peg$silentFails === 0) {
6078
- peg$fail(peg$e30);
6278
+ peg$fail(peg$e31);
6079
6279
  }
6080
6280
  }
6081
6281
  if (s1 === peg$FAILED) {
6082
- if (input.substr(peg$currPos, 4) === peg$c28) {
6083
- s1 = peg$c28;
6282
+ if (input.substr(peg$currPos, 4) === peg$c29) {
6283
+ s1 = peg$c29;
6084
6284
  peg$currPos += 4;
6085
6285
  } else {
6086
6286
  s1 = peg$FAILED;
6087
6287
  if (peg$silentFails === 0) {
6088
- peg$fail(peg$e31);
6288
+ peg$fail(peg$e32);
6089
6289
  }
6090
6290
  }
6091
6291
  if (s1 === peg$FAILED) {
6092
- if (input.substr(peg$currPos, 5) === peg$c29) {
6093
- s1 = peg$c29;
6292
+ if (input.substr(peg$currPos, 5) === peg$c30) {
6293
+ s1 = peg$c30;
6094
6294
  peg$currPos += 5;
6095
6295
  } else {
6096
6296
  s1 = peg$FAILED;
6097
6297
  if (peg$silentFails === 0) {
6098
- peg$fail(peg$e32);
6298
+ peg$fail(peg$e33);
6099
6299
  }
6100
6300
  }
6101
6301
  if (s1 === peg$FAILED) {
6102
- if (input.substr(peg$currPos, 6) === peg$c30) {
6103
- s1 = peg$c30;
6302
+ if (input.substr(peg$currPos, 6) === peg$c31) {
6303
+ s1 = peg$c31;
6104
6304
  peg$currPos += 6;
6105
6305
  } else {
6106
6306
  s1 = peg$FAILED;
6107
6307
  if (peg$silentFails === 0) {
6108
- peg$fail(peg$e33);
6308
+ peg$fail(peg$e34);
6109
6309
  }
6110
6310
  }
6111
6311
  if (s1 === peg$FAILED) {
6112
- if (input.substr(peg$currPos, 9) === peg$c31) {
6113
- s1 = peg$c31;
6312
+ if (input.substr(peg$currPos, 9) === peg$c32) {
6313
+ s1 = peg$c32;
6114
6314
  peg$currPos += 9;
6115
6315
  } else {
6116
6316
  s1 = peg$FAILED;
6117
6317
  if (peg$silentFails === 0) {
6118
- peg$fail(peg$e34);
6318
+ peg$fail(peg$e35);
6119
6319
  }
6120
6320
  }
6121
6321
  if (s1 === peg$FAILED) {
6122
- if (input.substr(peg$currPos, 7) === peg$c32) {
6123
- s1 = peg$c32;
6322
+ if (input.substr(peg$currPos, 7) === peg$c33) {
6323
+ s1 = peg$c33;
6124
6324
  peg$currPos += 7;
6125
6325
  } else {
6126
6326
  s1 = peg$FAILED;
6127
6327
  if (peg$silentFails === 0) {
6128
- peg$fail(peg$e35);
6328
+ peg$fail(peg$e36);
6129
6329
  }
6130
6330
  }
6131
6331
  if (s1 === peg$FAILED) {
6132
- if (input.substr(peg$currPos, 4) === peg$c33) {
6133
- s1 = peg$c33;
6332
+ if (input.substr(peg$currPos, 4) === peg$c34) {
6333
+ s1 = peg$c34;
6134
6334
  peg$currPos += 4;
6135
6335
  } else {
6136
6336
  s1 = peg$FAILED;
6137
6337
  if (peg$silentFails === 0) {
6138
- peg$fail(peg$e36);
6338
+ peg$fail(peg$e37);
6139
6339
  }
6140
6340
  }
6141
6341
  if (s1 === peg$FAILED) {
6142
- if (input.substr(peg$currPos, 4) === peg$c35) {
6143
- s1 = peg$c35;
6342
+ if (input.substr(peg$currPos, 4) === peg$c36) {
6343
+ s1 = peg$c36;
6144
6344
  peg$currPos += 4;
6145
6345
  } else {
6146
6346
  s1 = peg$FAILED;
6147
6347
  if (peg$silentFails === 0) {
6148
- peg$fail(peg$e38);
6348
+ peg$fail(peg$e39);
6149
6349
  }
6150
6350
  }
6151
6351
  if (s1 === peg$FAILED) {
6152
- if (input.substr(peg$currPos, 6) === peg$c36) {
6153
- s1 = peg$c36;
6352
+ if (input.substr(peg$currPos, 6) === peg$c37) {
6353
+ s1 = peg$c37;
6154
6354
  peg$currPos += 6;
6155
6355
  } else {
6156
6356
  s1 = peg$FAILED;
6157
6357
  if (peg$silentFails === 0) {
6158
- peg$fail(peg$e39);
6358
+ peg$fail(peg$e40);
6159
6359
  }
6160
6360
  }
6161
6361
  if (s1 === peg$FAILED) {
6162
- if (input.substr(peg$currPos, 5) === peg$c37) {
6163
- s1 = peg$c37;
6362
+ if (input.substr(peg$currPos, 5) === peg$c38) {
6363
+ s1 = peg$c38;
6164
6364
  peg$currPos += 5;
6165
6365
  } else {
6166
6366
  s1 = peg$FAILED;
6167
6367
  if (peg$silentFails === 0) {
6168
- peg$fail(peg$e40);
6368
+ peg$fail(peg$e41);
6169
6369
  }
6170
6370
  }
6171
6371
  if (s1 === peg$FAILED) {
6172
- if (input.substr(peg$currPos, 8) === peg$c38) {
6173
- s1 = peg$c38;
6372
+ if (input.substr(peg$currPos, 8) === peg$c39) {
6373
+ s1 = peg$c39;
6174
6374
  peg$currPos += 8;
6175
6375
  } else {
6176
6376
  s1 = peg$FAILED;
6177
6377
  if (peg$silentFails === 0) {
6178
- peg$fail(peg$e41);
6378
+ peg$fail(peg$e42);
6179
6379
  }
6180
6380
  }
6181
6381
  if (s1 === peg$FAILED) {
6182
- if (input.substr(peg$currPos, 6) === peg$c39) {
6183
- s1 = peg$c39;
6382
+ if (input.substr(peg$currPos, 6) === peg$c40) {
6383
+ s1 = peg$c40;
6184
6384
  peg$currPos += 6;
6185
6385
  } else {
6186
6386
  s1 = peg$FAILED;
6187
6387
  if (peg$silentFails === 0) {
6188
- peg$fail(peg$e42);
6388
+ peg$fail(peg$e43);
6189
6389
  }
6190
6390
  }
6191
6391
  if (s1 === peg$FAILED) {
6192
- if (input.substr(peg$currPos, 8) === peg$c40) {
6193
- s1 = peg$c40;
6392
+ if (input.substr(peg$currPos, 8) === peg$c41) {
6393
+ s1 = peg$c41;
6194
6394
  peg$currPos += 8;
6195
6395
  } else {
6196
6396
  s1 = peg$FAILED;
6197
6397
  if (peg$silentFails === 0) {
6198
- peg$fail(peg$e43);
6398
+ peg$fail(peg$e44);
6199
6399
  }
6200
6400
  }
6201
6401
  if (s1 === peg$FAILED) {
6202
- if (input.substr(peg$currPos, 5) === peg$c41) {
6203
- s1 = peg$c41;
6402
+ if (input.substr(peg$currPos, 5) === peg$c42) {
6403
+ s1 = peg$c42;
6204
6404
  peg$currPos += 5;
6205
6405
  } else {
6206
6406
  s1 = peg$FAILED;
6207
6407
  if (peg$silentFails === 0) {
6208
- peg$fail(peg$e44);
6408
+ peg$fail(peg$e45);
6209
6409
  }
6210
6410
  }
6211
6411
  if (s1 === peg$FAILED) {
6212
- if (input.substr(peg$currPos, 6) === peg$c42) {
6213
- s1 = peg$c42;
6412
+ if (input.substr(peg$currPos, 6) === peg$c43) {
6413
+ s1 = peg$c43;
6214
6414
  peg$currPos += 6;
6215
6415
  } else {
6216
6416
  s1 = peg$FAILED;
6217
6417
  if (peg$silentFails === 0) {
6218
- peg$fail(peg$e45);
6418
+ peg$fail(peg$e46);
6219
6419
  }
6220
6420
  }
6221
6421
  if (s1 === peg$FAILED) {
6222
- if (input.substr(peg$currPos, 6) === peg$c43) {
6223
- s1 = peg$c43;
6422
+ if (input.substr(peg$currPos, 6) === peg$c44) {
6423
+ s1 = peg$c44;
6224
6424
  peg$currPos += 6;
6225
6425
  } else {
6226
6426
  s1 = peg$FAILED;
6227
6427
  if (peg$silentFails === 0) {
6228
- peg$fail(peg$e46);
6428
+ peg$fail(peg$e47);
6229
6429
  }
6230
6430
  }
6231
6431
  if (s1 === peg$FAILED) {
6232
- if (input.substr(peg$currPos, 5) === peg$c44) {
6233
- s1 = peg$c44;
6432
+ if (input.substr(peg$currPos, 5) === peg$c45) {
6433
+ s1 = peg$c45;
6234
6434
  peg$currPos += 5;
6235
6435
  } else {
6236
6436
  s1 = peg$FAILED;
6237
6437
  if (peg$silentFails === 0) {
6238
- peg$fail(peg$e47);
6438
+ peg$fail(peg$e48);
6239
6439
  }
6240
6440
  }
6241
6441
  if (s1 === peg$FAILED) {
6242
- if (input.substr(peg$currPos, 6) === peg$c46) {
6243
- s1 = peg$c46;
6442
+ if (input.substr(peg$currPos, 6) === peg$c47) {
6443
+ s1 = peg$c47;
6244
6444
  peg$currPos += 6;
6245
6445
  } else {
6246
6446
  s1 = peg$FAILED;
6247
6447
  if (peg$silentFails === 0) {
6248
- peg$fail(peg$e49);
6448
+ peg$fail(peg$e50);
6249
6449
  }
6250
6450
  }
6251
6451
  if (s1 === peg$FAILED) {
6252
- if (input.substr(peg$currPos, 5) === peg$c47) {
6253
- s1 = peg$c47;
6452
+ if (input.substr(peg$currPos, 5) === peg$c48) {
6453
+ s1 = peg$c48;
6254
6454
  peg$currPos += 5;
6255
6455
  } else {
6256
6456
  s1 = peg$FAILED;
6257
6457
  if (peg$silentFails === 0) {
6258
- peg$fail(peg$e50);
6458
+ peg$fail(peg$e51);
6259
6459
  }
6260
6460
  }
6261
6461
  if (s1 === peg$FAILED) {
6262
- if (input.substr(peg$currPos, 5) === peg$c49) {
6263
- s1 = peg$c49;
6462
+ if (input.substr(peg$currPos, 5) === peg$c50) {
6463
+ s1 = peg$c50;
6264
6464
  peg$currPos += 5;
6265
6465
  } else {
6266
6466
  s1 = peg$FAILED;
6267
6467
  if (peg$silentFails === 0) {
6268
- peg$fail(peg$e52);
6468
+ peg$fail(peg$e53);
6269
6469
  }
6270
6470
  }
6271
6471
  if (s1 === peg$FAILED) {
6272
- if (input.substr(peg$currPos, 7) === peg$c52) {
6273
- s1 = peg$c52;
6472
+ if (input.substr(peg$currPos, 7) === peg$c53) {
6473
+ s1 = peg$c53;
6274
6474
  peg$currPos += 7;
6275
6475
  } else {
6276
6476
  s1 = peg$FAILED;
6277
6477
  if (peg$silentFails === 0) {
6278
- peg$fail(peg$e55);
6478
+ peg$fail(peg$e56);
6279
6479
  }
6280
6480
  }
6281
6481
  if (s1 === peg$FAILED) {
6282
- if (input.substr(peg$currPos, 4) === peg$c53) {
6283
- s1 = peg$c53;
6482
+ if (input.substr(peg$currPos, 4) === peg$c54) {
6483
+ s1 = peg$c54;
6284
6484
  peg$currPos += 4;
6285
6485
  } else {
6286
6486
  s1 = peg$FAILED;
6287
6487
  if (peg$silentFails === 0) {
6288
- peg$fail(peg$e56);
6488
+ peg$fail(peg$e57);
6289
6489
  }
6290
6490
  }
6291
6491
  if (s1 === peg$FAILED) {
6292
- if (input.substr(peg$currPos, 4) === peg$c54) {
6293
- s1 = peg$c54;
6492
+ if (input.substr(peg$currPos, 4) === peg$c55) {
6493
+ s1 = peg$c55;
6294
6494
  peg$currPos += 4;
6295
6495
  } else {
6296
6496
  s1 = peg$FAILED;
6297
6497
  if (peg$silentFails === 0) {
6298
- peg$fail(peg$e57);
6498
+ peg$fail(peg$e58);
6299
6499
  }
6300
6500
  }
6301
6501
  if (s1 === peg$FAILED) {
6302
- if (input.substr(peg$currPos, 5) === peg$c55) {
6303
- s1 = peg$c55;
6502
+ if (input.substr(peg$currPos, 5) === peg$c56) {
6503
+ s1 = peg$c56;
6304
6504
  peg$currPos += 5;
6305
6505
  } else {
6306
6506
  s1 = peg$FAILED;
6307
6507
  if (peg$silentFails === 0) {
6308
- peg$fail(peg$e58);
6508
+ peg$fail(peg$e59);
6309
6509
  }
6310
6510
  }
6311
6511
  if (s1 === peg$FAILED) {
6312
- if (input.substr(peg$currPos, 5) === peg$c56) {
6313
- s1 = peg$c56;
6512
+ if (input.substr(peg$currPos, 5) === peg$c57) {
6513
+ s1 = peg$c57;
6314
6514
  peg$currPos += 5;
6315
6515
  } else {
6316
6516
  s1 = peg$FAILED;
6317
6517
  if (peg$silentFails === 0) {
6318
- peg$fail(peg$e59);
6518
+ peg$fail(peg$e60);
6319
6519
  }
6320
6520
  }
6321
6521
  if (s1 === peg$FAILED) {
6322
- if (input.substr(peg$currPos, 8) === peg$c57) {
6323
- s1 = peg$c57;
6522
+ if (input.substr(peg$currPos, 8) === peg$c58) {
6523
+ s1 = peg$c58;
6324
6524
  peg$currPos += 8;
6325
6525
  } else {
6326
6526
  s1 = peg$FAILED;
6327
6527
  if (peg$silentFails === 0) {
6328
- peg$fail(peg$e60);
6528
+ peg$fail(peg$e61);
6329
6529
  }
6330
6530
  }
6331
6531
  if (s1 === peg$FAILED) {
6332
- if (input.substr(peg$currPos, 7) === peg$c58) {
6333
- s1 = peg$c58;
6532
+ if (input.substr(peg$currPos, 7) === peg$c59) {
6533
+ s1 = peg$c59;
6334
6534
  peg$currPos += 7;
6335
6535
  } else {
6336
6536
  s1 = peg$FAILED;
6337
6537
  if (peg$silentFails === 0) {
6338
- peg$fail(peg$e61);
6538
+ peg$fail(peg$e62);
6339
6539
  }
6340
6540
  }
6341
6541
  if (s1 === peg$FAILED) {
6342
- if (input.substr(peg$currPos, 7) === peg$c59) {
6343
- s1 = peg$c59;
6542
+ if (input.substr(peg$currPos, 7) === peg$c60) {
6543
+ s1 = peg$c60;
6344
6544
  peg$currPos += 7;
6345
6545
  } else {
6346
6546
  s1 = peg$FAILED;
6347
6547
  if (peg$silentFails === 0) {
6348
- peg$fail(peg$e62);
6548
+ peg$fail(peg$e63);
6349
6549
  }
6350
6550
  }
6351
6551
  if (s1 === peg$FAILED) {
6352
- if (input.substr(peg$currPos, 7) === peg$c60) {
6353
- s1 = peg$c60;
6552
+ if (input.substr(peg$currPos, 7) === peg$c61) {
6553
+ s1 = peg$c61;
6354
6554
  peg$currPos += 7;
6355
6555
  } else {
6356
6556
  s1 = peg$FAILED;
6357
6557
  if (peg$silentFails === 0) {
6358
- peg$fail(peg$e63);
6558
+ peg$fail(peg$e64);
6359
6559
  }
6360
6560
  }
6361
6561
  if (s1 === peg$FAILED) {
6362
- if (input.substr(peg$currPos, 8) === peg$c61) {
6363
- s1 = peg$c61;
6562
+ if (input.substr(peg$currPos, 8) === peg$c62) {
6563
+ s1 = peg$c62;
6364
6564
  peg$currPos += 8;
6365
6565
  } else {
6366
6566
  s1 = peg$FAILED;
6367
6567
  if (peg$silentFails === 0) {
6368
- peg$fail(peg$e64);
6568
+ peg$fail(peg$e65);
6369
6569
  }
6370
6570
  }
6371
6571
  if (s1 === peg$FAILED) {
6372
- if (input.substr(peg$currPos, 7) === peg$c62) {
6373
- s1 = peg$c62;
6572
+ if (input.substr(peg$currPos, 7) === peg$c63) {
6573
+ s1 = peg$c63;
6374
6574
  peg$currPos += 7;
6375
6575
  } else {
6376
6576
  s1 = peg$FAILED;
6377
6577
  if (peg$silentFails === 0) {
6378
- peg$fail(peg$e65);
6578
+ peg$fail(peg$e66);
6379
6579
  }
6380
6580
  }
6381
6581
  if (s1 === peg$FAILED) {
6382
- if (input.substr(peg$currPos, 3) === peg$c63) {
6383
- s1 = peg$c63;
6582
+ if (input.substr(peg$currPos, 3) === peg$c64) {
6583
+ s1 = peg$c64;
6384
6584
  peg$currPos += 3;
6385
6585
  } else {
6386
6586
  s1 = peg$FAILED;
6387
6587
  if (peg$silentFails === 0) {
6388
- peg$fail(peg$e66);
6588
+ peg$fail(peg$e67);
6389
6589
  }
6390
6590
  }
6391
6591
  if (s1 === peg$FAILED) {
6392
- if (input.substr(peg$currPos, 4) === peg$c65) {
6393
- s1 = peg$c65;
6592
+ if (input.substr(peg$currPos, 4) === peg$c66) {
6593
+ s1 = peg$c66;
6394
6594
  peg$currPos += 4;
6395
6595
  } else {
6396
6596
  s1 = peg$FAILED;
6397
6597
  if (peg$silentFails === 0) {
6398
- peg$fail(peg$e68);
6598
+ peg$fail(peg$e69);
6399
6599
  }
6400
6600
  }
6401
6601
  if (s1 === peg$FAILED) {
6402
- if (input.substr(peg$currPos, 3) === peg$c66) {
6403
- s1 = peg$c66;
6602
+ if (input.substr(peg$currPos, 3) === peg$c67) {
6603
+ s1 = peg$c67;
6404
6604
  peg$currPos += 3;
6405
6605
  } else {
6406
6606
  s1 = peg$FAILED;
6407
6607
  if (peg$silentFails === 0) {
6408
- peg$fail(peg$e69);
6608
+ peg$fail(peg$e70);
6409
6609
  }
6410
6610
  }
6411
6611
  if (s1 === peg$FAILED) {
6412
- if (input.substr(peg$currPos, 10) === peg$c67) {
6413
- s1 = peg$c67;
6612
+ if (input.substr(peg$currPos, 10) === peg$c68) {
6613
+ s1 = peg$c68;
6414
6614
  peg$currPos += 10;
6415
6615
  } else {
6416
6616
  s1 = peg$FAILED;
6417
6617
  if (peg$silentFails === 0) {
6418
- peg$fail(peg$e70);
6618
+ peg$fail(peg$e71);
6419
6619
  }
6420
6620
  }
6421
6621
  if (s1 === peg$FAILED) {
6422
- if (input.substr(peg$currPos, 5) === peg$c64) {
6423
- s1 = peg$c64;
6622
+ if (input.substr(peg$currPos, 5) === peg$c65) {
6623
+ s1 = peg$c65;
6424
6624
  peg$currPos += 5;
6425
6625
  } else {
6426
6626
  s1 = peg$FAILED;
6427
6627
  if (peg$silentFails === 0) {
6428
- peg$fail(peg$e67);
6628
+ peg$fail(peg$e68);
6429
6629
  }
6430
6630
  }
6431
6631
  if (s1 === peg$FAILED) {
6432
- if (input.substr(peg$currPos, 6) === peg$c68) {
6433
- s1 = peg$c68;
6632
+ if (input.substr(peg$currPos, 6) === peg$c69) {
6633
+ s1 = peg$c69;
6434
6634
  peg$currPos += 6;
6435
6635
  } else {
6436
6636
  s1 = peg$FAILED;
6437
6637
  if (peg$silentFails === 0) {
6438
- peg$fail(peg$e71);
6638
+ peg$fail(peg$e72);
6439
6639
  }
6440
6640
  }
6441
6641
  if (s1 === peg$FAILED) {
6442
- if (input.substr(peg$currPos, 11) === peg$c69) {
6443
- s1 = peg$c69;
6642
+ if (input.substr(peg$currPos, 11) === peg$c70) {
6643
+ s1 = peg$c70;
6444
6644
  peg$currPos += 11;
6445
6645
  } else {
6446
6646
  s1 = peg$FAILED;
6447
6647
  if (peg$silentFails === 0) {
6448
- peg$fail(peg$e72);
6648
+ peg$fail(peg$e73);
6449
6649
  }
6450
6650
  }
6451
6651
  if (s1 === peg$FAILED) {
6452
- if (input.substr(peg$currPos, 6) === peg$c3) {
6453
- s1 = peg$c3;
6652
+ if (input.substr(peg$currPos, 6) === peg$c20) {
6653
+ s1 = peg$c20;
6454
6654
  peg$currPos += 6;
6455
6655
  } else {
6456
6656
  s1 = peg$FAILED;
6457
6657
  if (peg$silentFails === 0) {
6458
- peg$fail(peg$e3);
6658
+ peg$fail(peg$e23);
6459
6659
  }
6460
6660
  }
6461
6661
  if (s1 === peg$FAILED) {
6462
- if (input.substr(peg$currPos, 9) === peg$c4) {
6463
- s1 = peg$c4;
6464
- peg$currPos += 9;
6662
+ if (input.substr(peg$currPos, 6) === peg$c3) {
6663
+ s1 = peg$c3;
6664
+ peg$currPos += 6;
6465
6665
  } else {
6466
6666
  s1 = peg$FAILED;
6467
6667
  if (peg$silentFails === 0) {
6468
- peg$fail(peg$e4);
6668
+ peg$fail(peg$e3);
6469
6669
  }
6470
6670
  }
6471
6671
  if (s1 === peg$FAILED) {
6472
- if (input.substr(peg$currPos, 3) === peg$c12) {
6473
- s1 = peg$c12;
6474
- peg$currPos += 3;
6672
+ if (input.substr(peg$currPos, 9) === peg$c4) {
6673
+ s1 = peg$c4;
6674
+ peg$currPos += 9;
6475
6675
  } else {
6476
6676
  s1 = peg$FAILED;
6477
6677
  if (peg$silentFails === 0) {
6478
- peg$fail(peg$e12);
6678
+ peg$fail(peg$e4);
6479
6679
  }
6480
6680
  }
6481
6681
  if (s1 === peg$FAILED) {
6482
- if (input.substr(peg$currPos, 4) === peg$c15) {
6483
- s1 = peg$c15;
6484
- peg$currPos += 4;
6682
+ if (input.substr(peg$currPos, 3) === peg$c12) {
6683
+ s1 = peg$c12;
6684
+ peg$currPos += 3;
6485
6685
  } else {
6486
6686
  s1 = peg$FAILED;
6487
6687
  if (peg$silentFails === 0) {
6488
- peg$fail(peg$e15);
6688
+ peg$fail(peg$e12);
6489
6689
  }
6490
6690
  }
6491
6691
  if (s1 === peg$FAILED) {
6492
- if (input.substr(peg$currPos, 4) === peg$c16) {
6493
- s1 = peg$c16;
6692
+ if (input.substr(peg$currPos, 4) === peg$c15) {
6693
+ s1 = peg$c15;
6494
6694
  peg$currPos += 4;
6495
6695
  } else {
6496
6696
  s1 = peg$FAILED;
6497
6697
  if (peg$silentFails === 0) {
6498
- peg$fail(peg$e16);
6698
+ peg$fail(peg$e15);
6699
+ }
6700
+ }
6701
+ if (s1 === peg$FAILED) {
6702
+ if (input.substr(peg$currPos, 4) === peg$c16) {
6703
+ s1 = peg$c16;
6704
+ peg$currPos += 4;
6705
+ } else {
6706
+ s1 = peg$FAILED;
6707
+ if (peg$silentFails === 0) {
6708
+ peg$fail(peg$e16);
6709
+ }
6499
6710
  }
6500
6711
  }
6501
6712
  }
@@ -6580,7 +6791,7 @@ function peg$parse(input, options) {
6580
6791
  } else {
6581
6792
  s0 = peg$FAILED;
6582
6793
  if (peg$silentFails === 0) {
6583
- peg$fail(peg$e77);
6794
+ peg$fail(peg$e78);
6584
6795
  }
6585
6796
  }
6586
6797
  return s0;
@@ -6613,12 +6824,12 @@ function peg$parse(input, options) {
6613
6824
  peg$silentFails++;
6614
6825
  s0 = peg$currPos;
6615
6826
  if (input.charCodeAt(peg$currPos) === 34) {
6616
- s1 = peg$c71;
6827
+ s1 = peg$c72;
6617
6828
  peg$currPos++;
6618
6829
  } else {
6619
6830
  s1 = peg$FAILED;
6620
6831
  if (peg$silentFails === 0) {
6621
- peg$fail(peg$e79);
6832
+ peg$fail(peg$e80);
6622
6833
  }
6623
6834
  }
6624
6835
  if (s1 !== peg$FAILED) {
@@ -6629,17 +6840,17 @@ function peg$parse(input, options) {
6629
6840
  s3 = peg$parseDoubleStringChar();
6630
6841
  }
6631
6842
  if (input.charCodeAt(peg$currPos) === 34) {
6632
- s3 = peg$c71;
6843
+ s3 = peg$c72;
6633
6844
  peg$currPos++;
6634
6845
  } else {
6635
6846
  s3 = peg$FAILED;
6636
6847
  if (peg$silentFails === 0) {
6637
- peg$fail(peg$e79);
6848
+ peg$fail(peg$e80);
6638
6849
  }
6639
6850
  }
6640
6851
  if (s3 !== peg$FAILED) {
6641
6852
  peg$savedPos = s0;
6642
- s0 = peg$f97(s2);
6853
+ s0 = peg$f98(s2);
6643
6854
  } else {
6644
6855
  peg$currPos = s0;
6645
6856
  s0 = peg$FAILED;
@@ -6651,12 +6862,12 @@ function peg$parse(input, options) {
6651
6862
  if (s0 === peg$FAILED) {
6652
6863
  s0 = peg$currPos;
6653
6864
  if (input.charCodeAt(peg$currPos) === 39) {
6654
- s1 = peg$c72;
6865
+ s1 = peg$c73;
6655
6866
  peg$currPos++;
6656
6867
  } else {
6657
6868
  s1 = peg$FAILED;
6658
6869
  if (peg$silentFails === 0) {
6659
- peg$fail(peg$e80);
6870
+ peg$fail(peg$e81);
6660
6871
  }
6661
6872
  }
6662
6873
  if (s1 !== peg$FAILED) {
@@ -6667,17 +6878,17 @@ function peg$parse(input, options) {
6667
6878
  s3 = peg$parseSingleStringChar();
6668
6879
  }
6669
6880
  if (input.charCodeAt(peg$currPos) === 39) {
6670
- s3 = peg$c72;
6881
+ s3 = peg$c73;
6671
6882
  peg$currPos++;
6672
6883
  } else {
6673
6884
  s3 = peg$FAILED;
6674
6885
  if (peg$silentFails === 0) {
6675
- peg$fail(peg$e80);
6886
+ peg$fail(peg$e81);
6676
6887
  }
6677
6888
  }
6678
6889
  if (s3 !== peg$FAILED) {
6679
6890
  peg$savedPos = s0;
6680
- s0 = peg$f98(s2);
6891
+ s0 = peg$f99(s2);
6681
6892
  } else {
6682
6893
  peg$currPos = s0;
6683
6894
  s0 = peg$FAILED;
@@ -6691,7 +6902,7 @@ function peg$parse(input, options) {
6691
6902
  if (s0 === peg$FAILED) {
6692
6903
  s1 = peg$FAILED;
6693
6904
  if (peg$silentFails === 0) {
6694
- peg$fail(peg$e78);
6905
+ peg$fail(peg$e79);
6695
6906
  }
6696
6907
  }
6697
6908
  return s0;
@@ -6702,12 +6913,12 @@ function peg$parse(input, options) {
6702
6913
  s1 = peg$currPos;
6703
6914
  peg$silentFails++;
6704
6915
  if (input.charCodeAt(peg$currPos) === 34) {
6705
- s2 = peg$c71;
6916
+ s2 = peg$c72;
6706
6917
  peg$currPos++;
6707
6918
  } else {
6708
6919
  s2 = peg$FAILED;
6709
6920
  if (peg$silentFails === 0) {
6710
- peg$fail(peg$e79);
6921
+ peg$fail(peg$e80);
6711
6922
  }
6712
6923
  }
6713
6924
  peg$silentFails--;
@@ -6721,12 +6932,12 @@ function peg$parse(input, options) {
6721
6932
  s2 = peg$currPos;
6722
6933
  peg$silentFails++;
6723
6934
  if (input.charCodeAt(peg$currPos) === 92) {
6724
- s3 = peg$c73;
6935
+ s3 = peg$c74;
6725
6936
  peg$currPos++;
6726
6937
  } else {
6727
6938
  s3 = peg$FAILED;
6728
6939
  if (peg$silentFails === 0) {
6729
- peg$fail(peg$e81);
6940
+ peg$fail(peg$e82);
6730
6941
  }
6731
6942
  }
6732
6943
  peg$silentFails--;
@@ -6748,7 +6959,7 @@ function peg$parse(input, options) {
6748
6959
  }
6749
6960
  if (s3 !== peg$FAILED) {
6750
6961
  peg$savedPos = s0;
6751
- s0 = peg$f99(s3);
6962
+ s0 = peg$f100(s3);
6752
6963
  } else {
6753
6964
  peg$currPos = s0;
6754
6965
  s0 = peg$FAILED;
@@ -6764,19 +6975,19 @@ function peg$parse(input, options) {
6764
6975
  if (s0 === peg$FAILED) {
6765
6976
  s0 = peg$currPos;
6766
6977
  if (input.charCodeAt(peg$currPos) === 92) {
6767
- s1 = peg$c73;
6978
+ s1 = peg$c74;
6768
6979
  peg$currPos++;
6769
6980
  } else {
6770
6981
  s1 = peg$FAILED;
6771
6982
  if (peg$silentFails === 0) {
6772
- peg$fail(peg$e81);
6983
+ peg$fail(peg$e82);
6773
6984
  }
6774
6985
  }
6775
6986
  if (s1 !== peg$FAILED) {
6776
6987
  s2 = peg$parseEscapeSequence();
6777
6988
  if (s2 !== peg$FAILED) {
6778
6989
  peg$savedPos = s0;
6779
- s0 = peg$f100(s2);
6990
+ s0 = peg$f101(s2);
6780
6991
  } else {
6781
6992
  peg$currPos = s0;
6782
6993
  s0 = peg$FAILED;
@@ -6794,12 +7005,12 @@ function peg$parse(input, options) {
6794
7005
  s1 = peg$currPos;
6795
7006
  peg$silentFails++;
6796
7007
  if (input.charCodeAt(peg$currPos) === 39) {
6797
- s2 = peg$c72;
7008
+ s2 = peg$c73;
6798
7009
  peg$currPos++;
6799
7010
  } else {
6800
7011
  s2 = peg$FAILED;
6801
7012
  if (peg$silentFails === 0) {
6802
- peg$fail(peg$e80);
7013
+ peg$fail(peg$e81);
6803
7014
  }
6804
7015
  }
6805
7016
  peg$silentFails--;
@@ -6813,12 +7024,12 @@ function peg$parse(input, options) {
6813
7024
  s2 = peg$currPos;
6814
7025
  peg$silentFails++;
6815
7026
  if (input.charCodeAt(peg$currPos) === 92) {
6816
- s3 = peg$c73;
7027
+ s3 = peg$c74;
6817
7028
  peg$currPos++;
6818
7029
  } else {
6819
7030
  s3 = peg$FAILED;
6820
7031
  if (peg$silentFails === 0) {
6821
- peg$fail(peg$e81);
7032
+ peg$fail(peg$e82);
6822
7033
  }
6823
7034
  }
6824
7035
  peg$silentFails--;
@@ -6840,7 +7051,7 @@ function peg$parse(input, options) {
6840
7051
  }
6841
7052
  if (s3 !== peg$FAILED) {
6842
7053
  peg$savedPos = s0;
6843
- s0 = peg$f101(s3);
7054
+ s0 = peg$f102(s3);
6844
7055
  } else {
6845
7056
  peg$currPos = s0;
6846
7057
  s0 = peg$FAILED;
@@ -6856,19 +7067,19 @@ function peg$parse(input, options) {
6856
7067
  if (s0 === peg$FAILED) {
6857
7068
  s0 = peg$currPos;
6858
7069
  if (input.charCodeAt(peg$currPos) === 92) {
6859
- s1 = peg$c73;
7070
+ s1 = peg$c74;
6860
7071
  peg$currPos++;
6861
7072
  } else {
6862
7073
  s1 = peg$FAILED;
6863
7074
  if (peg$silentFails === 0) {
6864
- peg$fail(peg$e81);
7075
+ peg$fail(peg$e82);
6865
7076
  }
6866
7077
  }
6867
7078
  if (s1 !== peg$FAILED) {
6868
7079
  s2 = peg$parseEscapeSequence();
6869
7080
  if (s2 !== peg$FAILED) {
6870
7081
  peg$savedPos = s0;
6871
- s0 = peg$f102(s2);
7082
+ s0 = peg$f103(s2);
6872
7083
  } else {
6873
7084
  peg$currPos = s0;
6874
7085
  s0 = peg$FAILED;
@@ -6884,97 +7095,97 @@ function peg$parse(input, options) {
6884
7095
  let s0, s1;
6885
7096
  s0 = peg$currPos;
6886
7097
  if (input.charCodeAt(peg$currPos) === 110) {
6887
- s1 = peg$c74;
7098
+ s1 = peg$c75;
6888
7099
  peg$currPos++;
6889
7100
  } else {
6890
7101
  s1 = peg$FAILED;
6891
7102
  if (peg$silentFails === 0) {
6892
- peg$fail(peg$e82);
7103
+ peg$fail(peg$e83);
6893
7104
  }
6894
7105
  }
6895
7106
  if (s1 !== peg$FAILED) {
6896
7107
  peg$savedPos = s0;
6897
- s1 = peg$f103();
7108
+ s1 = peg$f104();
6898
7109
  }
6899
7110
  s0 = s1;
6900
7111
  if (s0 === peg$FAILED) {
6901
7112
  s0 = peg$currPos;
6902
7113
  if (input.charCodeAt(peg$currPos) === 114) {
6903
- s1 = peg$c75;
7114
+ s1 = peg$c76;
6904
7115
  peg$currPos++;
6905
7116
  } else {
6906
7117
  s1 = peg$FAILED;
6907
7118
  if (peg$silentFails === 0) {
6908
- peg$fail(peg$e83);
7119
+ peg$fail(peg$e84);
6909
7120
  }
6910
7121
  }
6911
7122
  if (s1 !== peg$FAILED) {
6912
7123
  peg$savedPos = s0;
6913
- s1 = peg$f104();
7124
+ s1 = peg$f105();
6914
7125
  }
6915
7126
  s0 = s1;
6916
7127
  if (s0 === peg$FAILED) {
6917
7128
  s0 = peg$currPos;
6918
7129
  if (input.charCodeAt(peg$currPos) === 116) {
6919
- s1 = peg$c76;
7130
+ s1 = peg$c77;
6920
7131
  peg$currPos++;
6921
7132
  } else {
6922
7133
  s1 = peg$FAILED;
6923
7134
  if (peg$silentFails === 0) {
6924
- peg$fail(peg$e84);
7135
+ peg$fail(peg$e85);
6925
7136
  }
6926
7137
  }
6927
7138
  if (s1 !== peg$FAILED) {
6928
7139
  peg$savedPos = s0;
6929
- s1 = peg$f105();
7140
+ s1 = peg$f106();
6930
7141
  }
6931
7142
  s0 = s1;
6932
7143
  if (s0 === peg$FAILED) {
6933
7144
  s0 = peg$currPos;
6934
7145
  if (input.charCodeAt(peg$currPos) === 92) {
6935
- s1 = peg$c73;
7146
+ s1 = peg$c74;
6936
7147
  peg$currPos++;
6937
7148
  } else {
6938
7149
  s1 = peg$FAILED;
6939
7150
  if (peg$silentFails === 0) {
6940
- peg$fail(peg$e81);
7151
+ peg$fail(peg$e82);
6941
7152
  }
6942
7153
  }
6943
7154
  if (s1 !== peg$FAILED) {
6944
7155
  peg$savedPos = s0;
6945
- s1 = peg$f106();
7156
+ s1 = peg$f107();
6946
7157
  }
6947
7158
  s0 = s1;
6948
7159
  if (s0 === peg$FAILED) {
6949
7160
  s0 = peg$currPos;
6950
7161
  if (input.charCodeAt(peg$currPos) === 34) {
6951
- s1 = peg$c71;
7162
+ s1 = peg$c72;
6952
7163
  peg$currPos++;
6953
7164
  } else {
6954
7165
  s1 = peg$FAILED;
6955
7166
  if (peg$silentFails === 0) {
6956
- peg$fail(peg$e79);
7167
+ peg$fail(peg$e80);
6957
7168
  }
6958
7169
  }
6959
7170
  if (s1 !== peg$FAILED) {
6960
7171
  peg$savedPos = s0;
6961
- s1 = peg$f107();
7172
+ s1 = peg$f108();
6962
7173
  }
6963
7174
  s0 = s1;
6964
7175
  if (s0 === peg$FAILED) {
6965
7176
  s0 = peg$currPos;
6966
7177
  if (input.charCodeAt(peg$currPos) === 39) {
6967
- s1 = peg$c72;
7178
+ s1 = peg$c73;
6968
7179
  peg$currPos++;
6969
7180
  } else {
6970
7181
  s1 = peg$FAILED;
6971
7182
  if (peg$silentFails === 0) {
6972
- peg$fail(peg$e80);
7183
+ peg$fail(peg$e81);
6973
7184
  }
6974
7185
  }
6975
7186
  if (s1 !== peg$FAILED) {
6976
7187
  peg$savedPos = s0;
6977
- s1 = peg$f108();
7188
+ s1 = peg$f109();
6978
7189
  }
6979
7190
  s0 = s1;
6980
7191
  }
@@ -6989,12 +7200,12 @@ function peg$parse(input, options) {
6989
7200
  peg$silentFails++;
6990
7201
  s0 = peg$currPos;
6991
7202
  if (input.charCodeAt(peg$currPos) === 45) {
6992
- s1 = peg$c77;
7203
+ s1 = peg$c78;
6993
7204
  peg$currPos++;
6994
7205
  } else {
6995
7206
  s1 = peg$FAILED;
6996
7207
  if (peg$silentFails === 0) {
6997
- peg$fail(peg$e86);
7208
+ peg$fail(peg$e87);
6998
7209
  }
6999
7210
  }
7000
7211
  if (s1 === peg$FAILED) {
@@ -7007,7 +7218,7 @@ function peg$parse(input, options) {
7007
7218
  } else {
7008
7219
  s3 = peg$FAILED;
7009
7220
  if (peg$silentFails === 0) {
7010
- peg$fail(peg$e74);
7221
+ peg$fail(peg$e75);
7011
7222
  }
7012
7223
  }
7013
7224
  if (s3 !== peg$FAILED) {
@@ -7019,7 +7230,7 @@ function peg$parse(input, options) {
7019
7230
  } else {
7020
7231
  s3 = peg$FAILED;
7021
7232
  if (peg$silentFails === 0) {
7022
- peg$fail(peg$e74);
7233
+ peg$fail(peg$e75);
7023
7234
  }
7024
7235
  }
7025
7236
  }
@@ -7029,12 +7240,12 @@ function peg$parse(input, options) {
7029
7240
  if (s2 !== peg$FAILED) {
7030
7241
  s3 = peg$currPos;
7031
7242
  if (input.charCodeAt(peg$currPos) === 46) {
7032
- s4 = peg$c78;
7243
+ s4 = peg$c79;
7033
7244
  peg$currPos++;
7034
7245
  } else {
7035
7246
  s4 = peg$FAILED;
7036
7247
  if (peg$silentFails === 0) {
7037
- peg$fail(peg$e87);
7248
+ peg$fail(peg$e88);
7038
7249
  }
7039
7250
  }
7040
7251
  if (s4 !== peg$FAILED) {
@@ -7045,7 +7256,7 @@ function peg$parse(input, options) {
7045
7256
  } else {
7046
7257
  s6 = peg$FAILED;
7047
7258
  if (peg$silentFails === 0) {
7048
- peg$fail(peg$e74);
7259
+ peg$fail(peg$e75);
7049
7260
  }
7050
7261
  }
7051
7262
  if (s6 !== peg$FAILED) {
@@ -7057,7 +7268,7 @@ function peg$parse(input, options) {
7057
7268
  } else {
7058
7269
  s6 = peg$FAILED;
7059
7270
  if (peg$silentFails === 0) {
7060
- peg$fail(peg$e74);
7271
+ peg$fail(peg$e75);
7061
7272
  }
7062
7273
  }
7063
7274
  }
@@ -7079,7 +7290,7 @@ function peg$parse(input, options) {
7079
7290
  s3 = null;
7080
7291
  }
7081
7292
  peg$savedPos = s0;
7082
- s0 = peg$f109(s1, s2, s3);
7293
+ s0 = peg$f110(s1, s2, s3);
7083
7294
  } else {
7084
7295
  peg$currPos = s0;
7085
7296
  s0 = peg$FAILED;
@@ -7088,7 +7299,7 @@ function peg$parse(input, options) {
7088
7299
  if (s0 === peg$FAILED) {
7089
7300
  s1 = peg$FAILED;
7090
7301
  if (peg$silentFails === 0) {
7091
- peg$fail(peg$e85);
7302
+ peg$fail(peg$e86);
7092
7303
  }
7093
7304
  }
7094
7305
  return s0;
@@ -7098,12 +7309,12 @@ function peg$parse(input, options) {
7098
7309
  peg$silentFails++;
7099
7310
  s0 = peg$currPos;
7100
7311
  if (input.charCodeAt(peg$currPos) === 45) {
7101
- s1 = peg$c77;
7312
+ s1 = peg$c78;
7102
7313
  peg$currPos++;
7103
7314
  } else {
7104
7315
  s1 = peg$FAILED;
7105
7316
  if (peg$silentFails === 0) {
7106
- peg$fail(peg$e86);
7317
+ peg$fail(peg$e87);
7107
7318
  }
7108
7319
  }
7109
7320
  if (s1 === peg$FAILED) {
@@ -7116,7 +7327,7 @@ function peg$parse(input, options) {
7116
7327
  } else {
7117
7328
  s3 = peg$FAILED;
7118
7329
  if (peg$silentFails === 0) {
7119
- peg$fail(peg$e74);
7330
+ peg$fail(peg$e75);
7120
7331
  }
7121
7332
  }
7122
7333
  if (s3 !== peg$FAILED) {
@@ -7128,7 +7339,7 @@ function peg$parse(input, options) {
7128
7339
  } else {
7129
7340
  s3 = peg$FAILED;
7130
7341
  if (peg$silentFails === 0) {
7131
- peg$fail(peg$e74);
7342
+ peg$fail(peg$e75);
7132
7343
  }
7133
7344
  }
7134
7345
  }
@@ -7138,12 +7349,12 @@ function peg$parse(input, options) {
7138
7349
  if (s2 !== peg$FAILED) {
7139
7350
  s3 = peg$currPos;
7140
7351
  if (input.charCodeAt(peg$currPos) === 46) {
7141
- s4 = peg$c78;
7352
+ s4 = peg$c79;
7142
7353
  peg$currPos++;
7143
7354
  } else {
7144
7355
  s4 = peg$FAILED;
7145
7356
  if (peg$silentFails === 0) {
7146
- peg$fail(peg$e87);
7357
+ peg$fail(peg$e88);
7147
7358
  }
7148
7359
  }
7149
7360
  if (s4 !== peg$FAILED) {
@@ -7154,7 +7365,7 @@ function peg$parse(input, options) {
7154
7365
  } else {
7155
7366
  s6 = peg$FAILED;
7156
7367
  if (peg$silentFails === 0) {
7157
- peg$fail(peg$e74);
7368
+ peg$fail(peg$e75);
7158
7369
  }
7159
7370
  }
7160
7371
  if (s6 !== peg$FAILED) {
@@ -7166,7 +7377,7 @@ function peg$parse(input, options) {
7166
7377
  } else {
7167
7378
  s6 = peg$FAILED;
7168
7379
  if (peg$silentFails === 0) {
7169
- peg$fail(peg$e74);
7380
+ peg$fail(peg$e75);
7170
7381
  }
7171
7382
  }
7172
7383
  }
@@ -7187,63 +7398,63 @@ function peg$parse(input, options) {
7187
7398
  if (s3 === peg$FAILED) {
7188
7399
  s3 = null;
7189
7400
  }
7190
- if (input.substr(peg$currPos, 2) === peg$c79) {
7191
- s4 = peg$c79;
7401
+ if (input.substr(peg$currPos, 2) === peg$c80) {
7402
+ s4 = peg$c80;
7192
7403
  peg$currPos += 2;
7193
7404
  } else {
7194
7405
  s4 = peg$FAILED;
7195
7406
  if (peg$silentFails === 0) {
7196
- peg$fail(peg$e89);
7407
+ peg$fail(peg$e90);
7197
7408
  }
7198
7409
  }
7199
7410
  if (s4 === peg$FAILED) {
7200
7411
  if (input.charCodeAt(peg$currPos) === 37) {
7201
- s4 = peg$c80;
7412
+ s4 = peg$c81;
7202
7413
  peg$currPos++;
7203
7414
  } else {
7204
7415
  s4 = peg$FAILED;
7205
7416
  if (peg$silentFails === 0) {
7206
- peg$fail(peg$e90);
7417
+ peg$fail(peg$e91);
7207
7418
  }
7208
7419
  }
7209
7420
  if (s4 === peg$FAILED) {
7210
- if (input.substr(peg$currPos, 2) === peg$c81) {
7211
- s4 = peg$c81;
7421
+ if (input.substr(peg$currPos, 2) === peg$c82) {
7422
+ s4 = peg$c82;
7212
7423
  peg$currPos += 2;
7213
7424
  } else {
7214
7425
  s4 = peg$FAILED;
7215
7426
  if (peg$silentFails === 0) {
7216
- peg$fail(peg$e91);
7427
+ peg$fail(peg$e92);
7217
7428
  }
7218
7429
  }
7219
7430
  if (s4 === peg$FAILED) {
7220
- if (input.substr(peg$currPos, 3) === peg$c82) {
7221
- s4 = peg$c82;
7431
+ if (input.substr(peg$currPos, 3) === peg$c83) {
7432
+ s4 = peg$c83;
7222
7433
  peg$currPos += 3;
7223
7434
  } else {
7224
7435
  s4 = peg$FAILED;
7225
7436
  if (peg$silentFails === 0) {
7226
- peg$fail(peg$e92);
7437
+ peg$fail(peg$e93);
7227
7438
  }
7228
7439
  }
7229
7440
  if (s4 === peg$FAILED) {
7230
- if (input.substr(peg$currPos, 2) === peg$c83) {
7231
- s4 = peg$c83;
7441
+ if (input.substr(peg$currPos, 2) === peg$c84) {
7442
+ s4 = peg$c84;
7232
7443
  peg$currPos += 2;
7233
7444
  } else {
7234
7445
  s4 = peg$FAILED;
7235
7446
  if (peg$silentFails === 0) {
7236
- peg$fail(peg$e93);
7447
+ peg$fail(peg$e94);
7237
7448
  }
7238
7449
  }
7239
7450
  if (s4 === peg$FAILED) {
7240
- if (input.substr(peg$currPos, 2) === peg$c84) {
7241
- s4 = peg$c84;
7451
+ if (input.substr(peg$currPos, 2) === peg$c85) {
7452
+ s4 = peg$c85;
7242
7453
  peg$currPos += 2;
7243
7454
  } else {
7244
7455
  s4 = peg$FAILED;
7245
7456
  if (peg$silentFails === 0) {
7246
- peg$fail(peg$e94);
7457
+ peg$fail(peg$e95);
7247
7458
  }
7248
7459
  }
7249
7460
  }
@@ -7253,7 +7464,7 @@ function peg$parse(input, options) {
7253
7464
  }
7254
7465
  if (s4 !== peg$FAILED) {
7255
7466
  peg$savedPos = s0;
7256
- s0 = peg$f110(s1, s2, s3, s4);
7467
+ s0 = peg$f111(s1, s2, s3, s4);
7257
7468
  } else {
7258
7469
  peg$currPos = s0;
7259
7470
  s0 = peg$FAILED;
@@ -7266,7 +7477,7 @@ function peg$parse(input, options) {
7266
7477
  if (s0 === peg$FAILED) {
7267
7478
  s1 = peg$FAILED;
7268
7479
  if (peg$silentFails === 0) {
7269
- peg$fail(peg$e88);
7480
+ peg$fail(peg$e89);
7270
7481
  }
7271
7482
  }
7272
7483
  return s0;
@@ -7275,34 +7486,34 @@ function peg$parse(input, options) {
7275
7486
  let s0, s1;
7276
7487
  peg$silentFails++;
7277
7488
  s0 = peg$currPos;
7278
- if (input.substr(peg$currPos, 4) === peg$c85) {
7279
- s1 = peg$c85;
7489
+ if (input.substr(peg$currPos, 4) === peg$c86) {
7490
+ s1 = peg$c86;
7280
7491
  peg$currPos += 4;
7281
7492
  } else {
7282
7493
  s1 = peg$FAILED;
7283
7494
  if (peg$silentFails === 0) {
7284
- peg$fail(peg$e96);
7495
+ peg$fail(peg$e97);
7285
7496
  }
7286
7497
  }
7287
7498
  if (s1 !== peg$FAILED) {
7288
7499
  peg$savedPos = s0;
7289
- s1 = peg$f111();
7500
+ s1 = peg$f112();
7290
7501
  }
7291
7502
  s0 = s1;
7292
7503
  if (s0 === peg$FAILED) {
7293
7504
  s0 = peg$currPos;
7294
- if (input.substr(peg$currPos, 5) === peg$c86) {
7295
- s1 = peg$c86;
7505
+ if (input.substr(peg$currPos, 5) === peg$c87) {
7506
+ s1 = peg$c87;
7296
7507
  peg$currPos += 5;
7297
7508
  } else {
7298
7509
  s1 = peg$FAILED;
7299
7510
  if (peg$silentFails === 0) {
7300
- peg$fail(peg$e97);
7511
+ peg$fail(peg$e98);
7301
7512
  }
7302
7513
  }
7303
7514
  if (s1 !== peg$FAILED) {
7304
7515
  peg$savedPos = s0;
7305
- s1 = peg$f112();
7516
+ s1 = peg$f113();
7306
7517
  }
7307
7518
  s0 = s1;
7308
7519
  }
@@ -7310,7 +7521,7 @@ function peg$parse(input, options) {
7310
7521
  if (s0 === peg$FAILED) {
7311
7522
  s1 = peg$FAILED;
7312
7523
  if (peg$silentFails === 0) {
7313
- peg$fail(peg$e95);
7524
+ peg$fail(peg$e96);
7314
7525
  }
7315
7526
  }
7316
7527
  return s0;
@@ -7325,7 +7536,7 @@ function peg$parse(input, options) {
7325
7536
  } else {
7326
7537
  s1 = peg$FAILED;
7327
7538
  if (peg$silentFails === 0) {
7328
- peg$fail(peg$e99);
7539
+ peg$fail(peg$e100);
7329
7540
  }
7330
7541
  }
7331
7542
  if (s1 !== peg$FAILED) {
@@ -7336,7 +7547,7 @@ function peg$parse(input, options) {
7336
7547
  } else {
7337
7548
  s3 = peg$FAILED;
7338
7549
  if (peg$silentFails === 0) {
7339
- peg$fail(peg$e77);
7550
+ peg$fail(peg$e78);
7340
7551
  }
7341
7552
  }
7342
7553
  while (s3 !== peg$FAILED) {
@@ -7347,12 +7558,12 @@ function peg$parse(input, options) {
7347
7558
  } else {
7348
7559
  s3 = peg$FAILED;
7349
7560
  if (peg$silentFails === 0) {
7350
- peg$fail(peg$e77);
7561
+ peg$fail(peg$e78);
7351
7562
  }
7352
7563
  }
7353
7564
  }
7354
7565
  peg$savedPos = s0;
7355
- s0 = peg$f113(s1, s2);
7566
+ s0 = peg$f114(s1, s2);
7356
7567
  } else {
7357
7568
  peg$currPos = s0;
7358
7569
  s0 = peg$FAILED;
@@ -7361,7 +7572,7 @@ function peg$parse(input, options) {
7361
7572
  if (s0 === peg$FAILED) {
7362
7573
  s1 = peg$FAILED;
7363
7574
  if (peg$silentFails === 0) {
7364
- peg$fail(peg$e98);
7575
+ peg$fail(peg$e99);
7365
7576
  }
7366
7577
  }
7367
7578
  return s0;
@@ -7370,12 +7581,12 @@ function peg$parse(input, options) {
7370
7581
  let s0, s1, s2, s3, s4, s5;
7371
7582
  s0 = peg$currPos;
7372
7583
  if (input.charCodeAt(peg$currPos) === 91) {
7373
- s1 = peg$c50;
7584
+ s1 = peg$c51;
7374
7585
  peg$currPos++;
7375
7586
  } else {
7376
7587
  s1 = peg$FAILED;
7377
7588
  if (peg$silentFails === 0) {
7378
- peg$fail(peg$e53);
7589
+ peg$fail(peg$e54);
7379
7590
  }
7380
7591
  }
7381
7592
  if (s1 !== peg$FAILED) {
@@ -7386,17 +7597,17 @@ function peg$parse(input, options) {
7386
7597
  }
7387
7598
  s4 = peg$parse_();
7388
7599
  if (input.charCodeAt(peg$currPos) === 93) {
7389
- s5 = peg$c51;
7600
+ s5 = peg$c52;
7390
7601
  peg$currPos++;
7391
7602
  } else {
7392
7603
  s5 = peg$FAILED;
7393
7604
  if (peg$silentFails === 0) {
7394
- peg$fail(peg$e54);
7605
+ peg$fail(peg$e55);
7395
7606
  }
7396
7607
  }
7397
7608
  if (s5 !== peg$FAILED) {
7398
7609
  peg$savedPos = s0;
7399
- s0 = peg$f114(s3);
7610
+ s0 = peg$f115(s3);
7400
7611
  } else {
7401
7612
  peg$currPos = s0;
7402
7613
  s0 = peg$FAILED;
@@ -7484,7 +7695,7 @@ function peg$parse(input, options) {
7484
7695
  s3 = null;
7485
7696
  }
7486
7697
  peg$savedPos = s0;
7487
- s0 = peg$f115(s1, s2);
7698
+ s0 = peg$f116(s1, s2);
7488
7699
  } else {
7489
7700
  peg$currPos = s0;
7490
7701
  s0 = peg$FAILED;
@@ -7538,7 +7749,7 @@ function peg$parse(input, options) {
7538
7749
  }
7539
7750
  if (s5 !== peg$FAILED) {
7540
7751
  peg$savedPos = s0;
7541
- s0 = peg$f116(s3);
7752
+ s0 = peg$f117(s3);
7542
7753
  } else {
7543
7754
  peg$currPos = s0;
7544
7755
  s0 = peg$FAILED;
@@ -7605,7 +7816,7 @@ function peg$parse(input, options) {
7605
7816
  }
7606
7817
  }
7607
7818
  peg$savedPos = s0;
7608
- s0 = peg$f117(s1, s2);
7819
+ s0 = peg$f118(s1, s2);
7609
7820
  } else {
7610
7821
  peg$currPos = s0;
7611
7822
  s0 = peg$FAILED;
@@ -7632,7 +7843,7 @@ function peg$parse(input, options) {
7632
7843
  s5 = peg$parseAttributeValue();
7633
7844
  if (s5 !== peg$FAILED) {
7634
7845
  peg$savedPos = s0;
7635
- s0 = peg$f118(s1, s5);
7846
+ s0 = peg$f119(s1, s5);
7636
7847
  } else {
7637
7848
  peg$currPos = s0;
7638
7849
  s0 = peg$FAILED;
@@ -7650,7 +7861,7 @@ function peg$parse(input, options) {
7650
7861
  s1 = peg$parseIdentifier();
7651
7862
  if (s1 !== peg$FAILED) {
7652
7863
  peg$savedPos = s0;
7653
- s1 = peg$f119(s1);
7864
+ s1 = peg$f120(s1);
7654
7865
  }
7655
7866
  s0 = s1;
7656
7867
  }
@@ -7683,7 +7894,7 @@ function peg$parse(input, options) {
7683
7894
  } else {
7684
7895
  s1 = peg$FAILED;
7685
7896
  if (peg$silentFails === 0) {
7686
- peg$fail(peg$e100);
7897
+ peg$fail(peg$e101);
7687
7898
  }
7688
7899
  }
7689
7900
  if (s1 !== peg$FAILED) {
@@ -7695,7 +7906,7 @@ function peg$parse(input, options) {
7695
7906
  } else {
7696
7907
  s1 = peg$FAILED;
7697
7908
  if (peg$silentFails === 0) {
7698
- peg$fail(peg$e100);
7909
+ peg$fail(peg$e101);
7699
7910
  }
7700
7911
  }
7701
7912
  }
@@ -7715,7 +7926,7 @@ function peg$parse(input, options) {
7715
7926
  if (s0 === peg$FAILED) {
7716
7927
  s1 = peg$FAILED;
7717
7928
  if (peg$silentFails === 0) {
7718
- peg$fail(peg$e101);
7929
+ peg$fail(peg$e102);
7719
7930
  }
7720
7931
  }
7721
7932
  return s0;
@@ -7740,7 +7951,7 @@ function peg$parse(input, options) {
7740
7951
  } else {
7741
7952
  s3 = peg$FAILED;
7742
7953
  if (peg$silentFails === 0) {
7743
- peg$fail(peg$e102);
7954
+ peg$fail(peg$e103);
7744
7955
  }
7745
7956
  }
7746
7957
  while (s3 !== peg$FAILED) {
@@ -7751,17 +7962,17 @@ function peg$parse(input, options) {
7751
7962
  } else {
7752
7963
  s3 = peg$FAILED;
7753
7964
  if (peg$silentFails === 0) {
7754
- peg$fail(peg$e102);
7965
+ peg$fail(peg$e103);
7755
7966
  }
7756
7967
  }
7757
7968
  }
7758
7969
  if (input.charCodeAt(peg$currPos) === 10) {
7759
- s3 = peg$c87;
7970
+ s3 = peg$c88;
7760
7971
  peg$currPos++;
7761
7972
  } else {
7762
7973
  s3 = peg$FAILED;
7763
7974
  if (peg$silentFails === 0) {
7764
- peg$fail(peg$e103);
7975
+ peg$fail(peg$e104);
7765
7976
  }
7766
7977
  }
7767
7978
  if (s3 === peg$FAILED) {
@@ -7814,13 +8025,13 @@ function peg$parse(input, options) {
7814
8025
  s3 = peg$currPos;
7815
8026
  s4 = peg$currPos;
7816
8027
  peg$silentFails++;
7817
- if (input.substr(peg$currPos, 2) === peg$c88) {
7818
- s5 = peg$c88;
8028
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8029
+ s5 = peg$c89;
7819
8030
  peg$currPos += 2;
7820
8031
  } else {
7821
8032
  s5 = peg$FAILED;
7822
8033
  if (peg$silentFails === 0) {
7823
- peg$fail(peg$e104);
8034
+ peg$fail(peg$e105);
7824
8035
  }
7825
8036
  }
7826
8037
  peg$silentFails--;
@@ -7856,13 +8067,13 @@ function peg$parse(input, options) {
7856
8067
  s3 = peg$currPos;
7857
8068
  s4 = peg$currPos;
7858
8069
  peg$silentFails++;
7859
- if (input.substr(peg$currPos, 2) === peg$c88) {
7860
- s5 = peg$c88;
8070
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8071
+ s5 = peg$c89;
7861
8072
  peg$currPos += 2;
7862
8073
  } else {
7863
8074
  s5 = peg$FAILED;
7864
8075
  if (peg$silentFails === 0) {
7865
- peg$fail(peg$e104);
8076
+ peg$fail(peg$e105);
7866
8077
  }
7867
8078
  }
7868
8079
  peg$silentFails--;
@@ -7894,13 +8105,13 @@ function peg$parse(input, options) {
7894
8105
  s3 = peg$FAILED;
7895
8106
  }
7896
8107
  }
7897
- if (input.substr(peg$currPos, 2) === peg$c88) {
7898
- s3 = peg$c88;
8108
+ if (input.substr(peg$currPos, 2) === peg$c89) {
8109
+ s3 = peg$c89;
7899
8110
  peg$currPos += 2;
7900
8111
  } else {
7901
8112
  s3 = peg$FAILED;
7902
8113
  if (peg$silentFails === 0) {
7903
- peg$fail(peg$e104);
8114
+ peg$fail(peg$e105);
7904
8115
  }
7905
8116
  }
7906
8117
  if (s3 !== peg$FAILED) {
@@ -8075,6 +8286,7 @@ var GRAMMAR_ELEMENTS = {
8075
8286
  component: "Component",
8076
8287
  use: "ComponentUse",
8077
8288
  slot: "Slot",
8289
+ repeat: "Repeat",
8078
8290
  header: "Header",
8079
8291
  main: "Main",
8080
8292
  footer: "Footer",
@@ -8174,6 +8386,7 @@ var GRAMMAR_CHILD_KEYWORDS = [
8174
8386
  "group",
8175
8387
  "marker",
8176
8388
  "annotations",
8389
+ "repeat",
8177
8390
  "layout",
8178
8391
  "component",
8179
8392
  "use",
@@ -8565,6 +8778,16 @@ function printNodeLines(node, depth) {
8565
8778
  return componentDefinitionLines(node, depth);
8566
8779
  case "ComponentUse":
8567
8780
  return componentUseLines(node, depth);
8781
+ // `repeat 6 { … }` — the count prints bare, as the grammar's positional
8782
+ // `Integer`, which is why this cannot go through `containerLines` (that
8783
+ // helper's only pre-attribute segment is an optional *quoted* label).
8784
+ case "Repeat":
8785
+ return blockLines(
8786
+ depth,
8787
+ ["repeat", integerSegment(node, "count"), ...attrSegments(node, ["count"], node.type)],
8788
+ childrenLines(node, depth),
8789
+ "required"
8790
+ );
8568
8791
  // -- containers without a label ----------------------------------------
8569
8792
  case "Header":
8570
8793
  case "Main":
@@ -12942,6 +13165,11 @@ var ATTRIBUTE_SPECS = [
12942
13165
  type: "object[]",
12943
13166
  description: "Typed application state declarations owned by a page or shared layout"
12944
13167
  },
13168
+ {
13169
+ name: "variants",
13170
+ type: "string[]",
13171
+ description: "Named state variants of this page \u2014 each one renders the page again as a screen of its own"
13172
+ },
12945
13173
  {
12946
13174
  name: "id",
12947
13175
  type: "string",
@@ -13059,7 +13287,8 @@ var COMPONENT_METADATA = {
13059
13287
  "device",
13060
13288
  "centered",
13061
13289
  "uses",
13062
- "states"
13290
+ "states",
13291
+ "variants"
13063
13292
  ],
13064
13293
  hasChildren: true,
13065
13294
  description: "Root container for a wireframe page. Multiple pages in one .wf file lay out side-by-side on a canvas; use at(x, y) for explicit placement, or omit for auto-flow. Give it uses=<layout> to draw it inside a shared layout instead of restating the shell."
@@ -13091,6 +13320,12 @@ var COMPONENT_METADATA = {
13091
13320
  hasChildren: false,
13092
13321
  description: "Mark content insertion: bare inside a layout, or named inside a reusable component."
13093
13322
  },
13323
+ repeat: {
13324
+ category: "structure",
13325
+ attributes: [],
13326
+ hasChildren: true,
13327
+ 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."
13328
+ },
13094
13329
  header: {
13095
13330
  category: "layout",
13096
13331
  attributes: [...BOX_ATTRIBUTES, ...CONTAINER_ATTRIBUTES],
@@ -13728,6 +13963,8 @@ function pageTitle(page) {
13728
13963
  const title = page.title?.trim();
13729
13964
  return title !== void 0 && title.length > 0 ? title : void 0;
13730
13965
  }
13966
+ var VARIANT_SEPARATOR = "#";
13967
+ var variantName = (name, variant) => `${name}${VARIANT_SEPARATOR}${variant}`;
13731
13968
  function hasSlot(layout) {
13732
13969
  let found = false;
13733
13970
  for (const child of layout.children) {
@@ -13759,7 +13996,10 @@ function resolveShell(page, layouts) {
13759
13996
  function buildSiteModel(doc) {
13760
13997
  const pages = documentPages(doc);
13761
13998
  const layouts = layoutsByName(doc);
13762
- const screens = pages.map((page, index) => ({ index, page }));
13999
+ const screens = pages.map((page, index) => {
14000
+ const variant = page.variant?.trim();
14001
+ return variant !== void 0 && variant.length > 0 ? { index, page, variant } : { index, page };
14002
+ });
13763
14003
  const shells = [];
13764
14004
  const shellByName = /* @__PURE__ */ new Map();
13765
14005
  screens.forEach((screen) => {
@@ -13793,7 +14033,26 @@ function buildSiteModel(doc) {
13793
14033
  }
13794
14034
  }
13795
14035
  for (const screen of screens) {
13796
- const declared = [pageId(screen.page), pageTitle(screen.page)];
14036
+ if (screen.variant === void 0) continue;
14037
+ for (const declared of [pageId(screen.page), pageTitle(screen.page)]) {
14038
+ if (declared === void 0) continue;
14039
+ const owner = names.get(declared);
14040
+ if (owner === void 0) continue;
14041
+ const winner = screens[owner].page;
14042
+ if (pageId(winner) !== pageId(screen.page) || pageTitle(winner) !== pageTitle(screen.page)) {
14043
+ continue;
14044
+ }
14045
+ const qualified = variantName(declared, screen.variant);
14046
+ if (!names.has(qualified)) names.set(qualified, screen.index);
14047
+ }
14048
+ }
14049
+ for (const screen of screens) {
14050
+ const bare = [pageId(screen.page), pageTitle(screen.page)];
14051
+ const variant = screen.variant;
14052
+ const declared = variant === void 0 ? bare : [
14053
+ ...bare.map((name) => name === void 0 ? void 0 : variantName(name, variant)),
14054
+ ...bare
14055
+ ];
13797
14056
  screen.name = declared.find(
13798
14057
  (name) => name !== void 0 && names.get(name) === screen.index
13799
14058
  );
@@ -61664,6 +61923,7 @@ var HtmlRenderer = class extends BaseRenderer {
61664
61923
  * enabled so `renderNode` / `renderPage` can inject each node's path.
61665
61924
  */
61666
61925
  render(document) {
61926
+ document = expandRepeats(document);
61667
61927
  if (this.context.options.sourceAnchors) {
61668
61928
  this.pathMap = buildAnchorPathMap(document, this.pageIndexBase);
61669
61929
  }
@@ -62344,7 +62604,8 @@ function wrapBoard(pageHtml, placed, prefix) {
62344
62604
  const { x, y, w, h, page } = placed;
62345
62605
  const positionStyle = `position: absolute; left: ${x}px; top: ${y}px; width: ${w}px; height: ${h}px;`;
62346
62606
  const titleAttr = page.title ? ` data-page-title="${escapeAttr(page.title)}"` : "";
62347
- const dataAttrs = ` data-page-x="${x}" data-page-y="${y}" data-page-w="${w}" data-page-h="${h}"${titleAttr}`;
62607
+ const variantAttr = page.variant ? ` data-wf-variant="${escapeAttr(page.variant)}"` : "";
62608
+ const dataAttrs = ` data-page-x="${x}" data-page-y="${y}" data-page-w="${w}" data-page-h="${h}"${titleAttr}${variantAttr}`;
62348
62609
  return `<div class="${prefix}-canvas-board" style="${positionStyle}"${dataAttrs}>
62349
62610
  ${pageHtml}
62350
62611
  </div>`;
@@ -62931,6 +63192,7 @@ function renderHostedScreen(screen, shell, make, prefix) {
62931
63192
  const marks = attrs([
62932
63193
  ["data-screen", String(screen.index)],
62933
63194
  ["data-screen-name", screen.name],
63195
+ ["data-wf-variant", screen.variant],
62934
63196
  [ID_SCOPE_ATTR, scope],
62935
63197
  ["data-wf-viewport-conflict", conflict]
62936
63198
  ]);
@@ -62944,6 +63206,7 @@ function renderStandaloneScreen(screen, make, prefix) {
62944
63206
  const marks = attrs([
62945
63207
  ["data-screen", String(screen.index)],
62946
63208
  ["data-screen-name", screen.name],
63209
+ ["data-wf-variant", screen.variant],
62947
63210
  [ID_SCOPE_ATTR, scope],
62948
63211
  ["data-wf-uses-unresolved", screen.miss?.uses],
62949
63212
  ["data-wf-uses-reason", screen.miss?.reason]
@@ -63012,6 +63275,7 @@ function compactRuntimeInteractions(model, interactions) {
63012
63275
  }
63013
63276
  function renderSite(document, options = {}) {
63014
63277
  const prefix = options.classPrefix ?? DEFAULT_PREFIX2;
63278
+ document = expandRepeats(expandVariants(document));
63015
63279
  const model = buildSiteModel(document);
63016
63280
  const interactionModel = collectInteractions(document);
63017
63281
  const make = (idScope) => new HtmlRenderer({
@@ -63080,6 +63344,7 @@ ${runtime}
63080
63344
 
63081
63345
  // src/renderer/index.ts
63082
63346
  function render(document, options = {}) {
63347
+ document = expandVariants(document);
63083
63348
  const isMultiPage = documentPages(document).length > 1;
63084
63349
  if (isMultiPage) {
63085
63350
  const result = renderCanvas(document, options);
@@ -63089,6 +63354,7 @@ function render(document, options = {}) {
63089
63354
  return renderer.render(document);
63090
63355
  }
63091
63356
  function renderToHtml(document, options = {}) {
63357
+ document = expandVariants(document);
63092
63358
  const { html, css } = render(document, options);
63093
63359
  const prefix = options.classPrefix ?? "wf";
63094
63360
  const isMultiPage = documentPages(document).length > 1;
@@ -63130,6 +63396,7 @@ ${html}
63130
63396
  </html>`;
63131
63397
  }
63132
63398
  function renderToSvg(document, options = {}) {
63399
+ document = expandVariants(document);
63133
63400
  const isMultiPage = documentPages(document).length > 1;
63134
63401
  let width = options.width ?? 800;
63135
63402
  let height = options.height ?? 600;
@@ -63202,7 +63469,8 @@ var POSITIONAL_PROPS = {
63202
63469
  Layout: ["name"],
63203
63470
  Component: ["name"],
63204
63471
  ComponentUse: ["name", "namespace"],
63205
- Slot: ["name"]
63472
+ Slot: ["name"],
63473
+ Repeat: ["count"]
63206
63474
  };
63207
63475
  function declaredName(value) {
63208
63476
  const name = value?.trim();
@@ -65513,6 +65781,8 @@ export {
65513
65781
  INTERACTIVE_ATTR_NAMES,
65514
65782
  LUCIDE_ICON_NAMES,
65515
65783
  NODE_TYPE_MAP,
65784
+ REPEAT_EXPANSION_BUDGET,
65785
+ RepeatBudgetError,
65516
65786
  TYPED_INTERACTION_ATTR,
65517
65787
  VALID_ATTRIBUTE_NAMES,
65518
65788
  VALID_COMPONENT_NAMES,
@@ -65539,6 +65809,8 @@ export {
65539
65809
  diff,
65540
65810
  documentDefinitions,
65541
65811
  documentPages,
65812
+ expandRepeats,
65813
+ expandVariants,
65542
65814
  exportToFigma,
65543
65815
  exportToFigmaString,
65544
65816
  exportToJson,