@wireweave/core 2.3.0 → 2.4.0

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.
Files changed (15) hide show
  1. package/dist/index.cjs +1179 -706
  2. package/dist/index.d.cts +117 -16
  3. package/dist/index.d.ts +117 -16
  4. package/dist/index.js +1179 -706
  5. package/dist/parser.cjs +836 -666
  6. package/dist/parser.d.cts +1 -1
  7. package/dist/parser.d.ts +1 -1
  8. package/dist/parser.js +836 -666
  9. package/dist/renderer.cjs +98 -4
  10. package/dist/renderer.d.cts +3 -1
  11. package/dist/renderer.d.ts +3 -1
  12. package/dist/renderer.js +98 -4
  13. package/dist/{types-D0t4JRY3.d.cts → types-D_1QkAXo.d.cts} +35 -3
  14. package/dist/{types-D0t4JRY3.d.ts → types-D_1QkAXo.d.ts} +35 -3
  15. package/package.json +1 -1
package/dist/index.js CHANGED
@@ -410,68 +410,70 @@ function peg$parse(input, options) {
410
410
  const peg$c6 = "sidebar";
411
411
  const peg$c7 = "row";
412
412
  const peg$c8 = "col";
413
- const peg$c9 = "card";
414
- const peg$c10 = "modal";
415
- const peg$c11 = "drawer";
416
- const peg$c12 = "accordion";
417
- const peg$c13 = "section";
418
- const peg$c14 = "text";
419
- const peg$c15 = "title";
420
- const peg$c16 = "link";
421
- const peg$c17 = "button";
422
- const peg$c18 = "input";
423
- const peg$c19 = "textarea";
424
- const peg$c20 = "select";
425
- const peg$c21 = "checkbox";
426
- const peg$c22 = "radio";
427
- const peg$c23 = "switch";
428
- const peg$c24 = "slider";
429
- const peg$c25 = "image";
430
- const peg$c26 = "placeholder";
431
- const peg$c27 = "avatar";
432
- const peg$c28 = "badge";
433
- const peg$c29 = "icon";
434
- const peg$c30 = "table";
435
- const peg$c31 = "[";
436
- const peg$c32 = ",";
437
- const peg$c33 = "]";
438
- const peg$c34 = "columns";
439
- const peg$c35 = "list";
440
- const peg$c36 = "item";
441
- const peg$c37 = "alert";
442
- const peg$c38 = "toast";
443
- const peg$c39 = "progress";
444
- const peg$c40 = "spinner";
445
- const peg$c41 = "tooltip";
446
- const peg$c42 = "popover";
447
- const peg$c43 = "dropdown";
448
- const peg$c44 = "divider";
449
- const peg$c45 = "nav";
450
- const peg$c46 = "group";
451
- const peg$c47 = "tabs";
452
- const peg$c48 = "tab";
453
- const peg$c49 = "breadcrumb";
454
- const peg$c50 = "=";
455
- const peg$c51 = "//";
456
- const peg$c52 = "/*";
457
- const peg$c53 = '"';
458
- const peg$c54 = "'";
459
- const peg$c55 = "\\";
460
- const peg$c56 = "n";
461
- const peg$c57 = "r";
462
- const peg$c58 = "t";
463
- const peg$c59 = "-";
464
- const peg$c60 = ".";
465
- const peg$c61 = "px";
466
- const peg$c62 = "%";
467
- const peg$c63 = "em";
468
- const peg$c64 = "rem";
469
- const peg$c65 = "vh";
470
- const peg$c66 = "vw";
471
- const peg$c67 = "true";
472
- const peg$c68 = "false";
473
- const peg$c69 = "\n";
474
- const peg$c70 = "*/";
413
+ const peg$c9 = "stack";
414
+ const peg$c10 = "relative";
415
+ const peg$c11 = "card";
416
+ const peg$c12 = "modal";
417
+ const peg$c13 = "drawer";
418
+ const peg$c14 = "accordion";
419
+ const peg$c15 = "section";
420
+ const peg$c16 = "text";
421
+ const peg$c17 = "title";
422
+ const peg$c18 = "link";
423
+ const peg$c19 = "button";
424
+ const peg$c20 = "input";
425
+ const peg$c21 = "textarea";
426
+ const peg$c22 = "select";
427
+ const peg$c23 = "checkbox";
428
+ const peg$c24 = "radio";
429
+ const peg$c25 = "switch";
430
+ const peg$c26 = "slider";
431
+ const peg$c27 = "image";
432
+ const peg$c28 = "placeholder";
433
+ const peg$c29 = "avatar";
434
+ const peg$c30 = "badge";
435
+ const peg$c31 = "icon";
436
+ const peg$c32 = "table";
437
+ const peg$c33 = "[";
438
+ const peg$c34 = ",";
439
+ const peg$c35 = "]";
440
+ const peg$c36 = "columns";
441
+ const peg$c37 = "list";
442
+ const peg$c38 = "item";
443
+ const peg$c39 = "alert";
444
+ const peg$c40 = "toast";
445
+ const peg$c41 = "progress";
446
+ const peg$c42 = "spinner";
447
+ const peg$c43 = "tooltip";
448
+ const peg$c44 = "popover";
449
+ const peg$c45 = "dropdown";
450
+ const peg$c46 = "divider";
451
+ const peg$c47 = "nav";
452
+ const peg$c48 = "group";
453
+ const peg$c49 = "tabs";
454
+ const peg$c50 = "tab";
455
+ const peg$c51 = "breadcrumb";
456
+ const peg$c52 = "=";
457
+ const peg$c53 = "//";
458
+ const peg$c54 = "/*";
459
+ const peg$c55 = '"';
460
+ const peg$c56 = "'";
461
+ const peg$c57 = "\\";
462
+ const peg$c58 = "n";
463
+ const peg$c59 = "r";
464
+ const peg$c60 = "t";
465
+ const peg$c61 = "-";
466
+ const peg$c62 = ".";
467
+ const peg$c63 = "px";
468
+ const peg$c64 = "%";
469
+ const peg$c65 = "em";
470
+ const peg$c66 = "rem";
471
+ const peg$c67 = "vh";
472
+ const peg$c68 = "vw";
473
+ const peg$c69 = "true";
474
+ const peg$c70 = "false";
475
+ const peg$c71 = "\n";
476
+ const peg$c72 = "*/";
475
477
  const peg$r0 = /^[=[{}]/;
476
478
  const peg$r1 = /^[a-zA-Z0-9_\-]/;
477
479
  const peg$r2 = /^[0-9]/;
@@ -487,81 +489,83 @@ function peg$parse(input, options) {
487
489
  const peg$e6 = peg$literalExpectation("sidebar", false);
488
490
  const peg$e7 = peg$literalExpectation("row", false);
489
491
  const peg$e8 = peg$literalExpectation("col", false);
490
- const peg$e9 = peg$literalExpectation("card", false);
491
- const peg$e10 = peg$literalExpectation("modal", false);
492
- const peg$e11 = peg$literalExpectation("drawer", false);
493
- const peg$e12 = peg$literalExpectation("accordion", false);
494
- const peg$e13 = peg$literalExpectation("section", false);
495
- const peg$e14 = peg$literalExpectation("text", false);
496
- const peg$e15 = peg$literalExpectation("title", false);
497
- const peg$e16 = peg$literalExpectation("link", false);
498
- const peg$e17 = peg$literalExpectation("button", false);
499
- const peg$e18 = peg$literalExpectation("input", false);
500
- const peg$e19 = peg$literalExpectation("textarea", false);
501
- const peg$e20 = peg$literalExpectation("select", false);
502
- const peg$e21 = peg$literalExpectation("checkbox", false);
503
- const peg$e22 = peg$literalExpectation("radio", false);
504
- const peg$e23 = peg$literalExpectation("switch", false);
505
- const peg$e24 = peg$literalExpectation("slider", false);
506
- const peg$e25 = peg$literalExpectation("image", false);
507
- const peg$e26 = peg$literalExpectation("placeholder", false);
508
- const peg$e27 = peg$literalExpectation("avatar", false);
509
- const peg$e28 = peg$literalExpectation("badge", false);
510
- const peg$e29 = peg$literalExpectation("icon", false);
511
- const peg$e30 = peg$literalExpectation("table", false);
512
- const peg$e31 = peg$literalExpectation("[", false);
513
- const peg$e32 = peg$literalExpectation(",", false);
514
- const peg$e33 = peg$literalExpectation("]", false);
515
- const peg$e34 = peg$literalExpectation("columns", false);
516
- const peg$e35 = peg$literalExpectation("list", false);
517
- const peg$e36 = peg$literalExpectation("item", false);
518
- const peg$e37 = peg$literalExpectation("alert", false);
519
- const peg$e38 = peg$literalExpectation("toast", false);
520
- const peg$e39 = peg$literalExpectation("progress", false);
521
- const peg$e40 = peg$literalExpectation("spinner", false);
522
- const peg$e41 = peg$literalExpectation("tooltip", false);
523
- const peg$e42 = peg$literalExpectation("popover", false);
524
- const peg$e43 = peg$literalExpectation("dropdown", false);
525
- const peg$e44 = peg$literalExpectation("divider", false);
526
- const peg$e45 = peg$literalExpectation("nav", false);
527
- const peg$e46 = peg$literalExpectation("group", false);
528
- const peg$e47 = peg$literalExpectation("tabs", false);
529
- const peg$e48 = peg$literalExpectation("tab", false);
530
- const peg$e49 = peg$literalExpectation("breadcrumb", false);
531
- const peg$e50 = peg$literalExpectation("=", false);
532
- const peg$e51 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
533
- const peg$e52 = peg$literalExpectation("//", false);
534
- const peg$e53 = peg$literalExpectation("/*", false);
535
- const peg$e54 = peg$anyExpectation();
536
- const peg$e55 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
537
- const peg$e56 = peg$otherExpectation("string");
538
- const peg$e57 = peg$literalExpectation('"', false);
539
- const peg$e58 = peg$literalExpectation("'", false);
540
- const peg$e59 = peg$literalExpectation("\\", false);
541
- const peg$e60 = peg$literalExpectation("n", false);
542
- const peg$e61 = peg$literalExpectation("r", false);
543
- const peg$e62 = peg$literalExpectation("t", false);
544
- const peg$e63 = peg$otherExpectation("number");
545
- const peg$e64 = peg$literalExpectation("-", false);
546
- const peg$e65 = peg$classExpectation([["0", "9"]], false, false, false);
547
- const peg$e66 = peg$literalExpectation(".", false);
548
- const peg$e67 = peg$otherExpectation("value with unit");
549
- const peg$e68 = peg$literalExpectation("px", false);
550
- const peg$e69 = peg$literalExpectation("%", false);
551
- const peg$e70 = peg$literalExpectation("em", false);
552
- const peg$e71 = peg$literalExpectation("rem", false);
553
- const peg$e72 = peg$literalExpectation("vh", false);
554
- const peg$e73 = peg$literalExpectation("vw", false);
555
- const peg$e74 = peg$otherExpectation("boolean");
556
- const peg$e75 = peg$literalExpectation("true", false);
557
- const peg$e76 = peg$literalExpectation("false", false);
558
- const peg$e77 = peg$otherExpectation("identifier");
559
- const peg$e78 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
560
- const peg$e79 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
561
- const peg$e80 = peg$otherExpectation("comment");
562
- const peg$e81 = peg$classExpectation(["\n"], true, false, false);
563
- const peg$e82 = peg$literalExpectation("\n", false);
564
- const peg$e83 = peg$literalExpectation("*/", false);
492
+ const peg$e9 = peg$literalExpectation("stack", false);
493
+ const peg$e10 = peg$literalExpectation("relative", false);
494
+ const peg$e11 = peg$literalExpectation("card", false);
495
+ const peg$e12 = peg$literalExpectation("modal", false);
496
+ const peg$e13 = peg$literalExpectation("drawer", false);
497
+ const peg$e14 = peg$literalExpectation("accordion", false);
498
+ const peg$e15 = peg$literalExpectation("section", false);
499
+ const peg$e16 = peg$literalExpectation("text", false);
500
+ const peg$e17 = peg$literalExpectation("title", false);
501
+ const peg$e18 = peg$literalExpectation("link", false);
502
+ const peg$e19 = peg$literalExpectation("button", false);
503
+ const peg$e20 = peg$literalExpectation("input", false);
504
+ const peg$e21 = peg$literalExpectation("textarea", false);
505
+ const peg$e22 = peg$literalExpectation("select", false);
506
+ const peg$e23 = peg$literalExpectation("checkbox", false);
507
+ const peg$e24 = peg$literalExpectation("radio", false);
508
+ const peg$e25 = peg$literalExpectation("switch", false);
509
+ const peg$e26 = peg$literalExpectation("slider", false);
510
+ const peg$e27 = peg$literalExpectation("image", false);
511
+ const peg$e28 = peg$literalExpectation("placeholder", false);
512
+ const peg$e29 = peg$literalExpectation("avatar", false);
513
+ const peg$e30 = peg$literalExpectation("badge", false);
514
+ const peg$e31 = peg$literalExpectation("icon", false);
515
+ const peg$e32 = peg$literalExpectation("table", false);
516
+ const peg$e33 = peg$literalExpectation("[", false);
517
+ const peg$e34 = peg$literalExpectation(",", false);
518
+ const peg$e35 = peg$literalExpectation("]", false);
519
+ const peg$e36 = peg$literalExpectation("columns", false);
520
+ const peg$e37 = peg$literalExpectation("list", false);
521
+ const peg$e38 = peg$literalExpectation("item", false);
522
+ const peg$e39 = peg$literalExpectation("alert", false);
523
+ const peg$e40 = peg$literalExpectation("toast", false);
524
+ const peg$e41 = peg$literalExpectation("progress", false);
525
+ const peg$e42 = peg$literalExpectation("spinner", false);
526
+ const peg$e43 = peg$literalExpectation("tooltip", false);
527
+ const peg$e44 = peg$literalExpectation("popover", false);
528
+ const peg$e45 = peg$literalExpectation("dropdown", false);
529
+ const peg$e46 = peg$literalExpectation("divider", false);
530
+ const peg$e47 = peg$literalExpectation("nav", false);
531
+ const peg$e48 = peg$literalExpectation("group", false);
532
+ const peg$e49 = peg$literalExpectation("tabs", false);
533
+ const peg$e50 = peg$literalExpectation("tab", false);
534
+ const peg$e51 = peg$literalExpectation("breadcrumb", false);
535
+ const peg$e52 = peg$literalExpectation("=", false);
536
+ const peg$e53 = peg$classExpectation(["=", "[", "{", "}"], false, false, false);
537
+ const peg$e54 = peg$literalExpectation("//", false);
538
+ const peg$e55 = peg$literalExpectation("/*", false);
539
+ const peg$e56 = peg$anyExpectation();
540
+ const peg$e57 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false, false);
541
+ const peg$e58 = peg$otherExpectation("string");
542
+ const peg$e59 = peg$literalExpectation('"', false);
543
+ const peg$e60 = peg$literalExpectation("'", false);
544
+ const peg$e61 = peg$literalExpectation("\\", false);
545
+ const peg$e62 = peg$literalExpectation("n", false);
546
+ const peg$e63 = peg$literalExpectation("r", false);
547
+ const peg$e64 = peg$literalExpectation("t", false);
548
+ const peg$e65 = peg$otherExpectation("number");
549
+ const peg$e66 = peg$literalExpectation("-", false);
550
+ const peg$e67 = peg$classExpectation([["0", "9"]], false, false, false);
551
+ const peg$e68 = peg$literalExpectation(".", false);
552
+ const peg$e69 = peg$otherExpectation("value with unit");
553
+ const peg$e70 = peg$literalExpectation("px", false);
554
+ const peg$e71 = peg$literalExpectation("%", false);
555
+ const peg$e72 = peg$literalExpectation("em", false);
556
+ const peg$e73 = peg$literalExpectation("rem", false);
557
+ const peg$e74 = peg$literalExpectation("vh", false);
558
+ const peg$e75 = peg$literalExpectation("vw", false);
559
+ const peg$e76 = peg$otherExpectation("boolean");
560
+ const peg$e77 = peg$literalExpectation("true", false);
561
+ const peg$e78 = peg$literalExpectation("false", false);
562
+ const peg$e79 = peg$otherExpectation("identifier");
563
+ const peg$e80 = peg$classExpectation([["a", "z"], ["A", "Z"], "_"], false, false, false);
564
+ const peg$e81 = peg$classExpectation([" ", " ", "\n", "\r"], false, false, false);
565
+ const peg$e82 = peg$otherExpectation("comment");
566
+ const peg$e83 = peg$classExpectation(["\n"], true, false, false);
567
+ const peg$e84 = peg$literalExpectation("\n", false);
568
+ const peg$e85 = peg$literalExpectation("*/", false);
565
569
  function peg$f0(children) {
566
570
  return createNode("Document", { children: children.filter((c) => c !== null) });
567
571
  }
@@ -617,66 +621,78 @@ function peg$parse(input, options) {
617
621
  children
618
622
  });
619
623
  }
620
- function peg$f11(label, attrs, children) {
624
+ function peg$f11(attrs, children) {
625
+ return createNode("Stack", {
626
+ ...attrsToObject(attrs),
627
+ children
628
+ });
629
+ }
630
+ function peg$f12(attrs, children) {
631
+ return createNode("Relative", {
632
+ ...attrsToObject(attrs),
633
+ children
634
+ });
635
+ }
636
+ function peg$f13(label, attrs, children) {
621
637
  return createNode("Card", {
622
638
  title: label || null,
623
639
  ...attrsToObject(attrs),
624
640
  children
625
641
  });
626
642
  }
627
- function peg$f12(label, attrs, children) {
643
+ function peg$f14(label, attrs, children) {
628
644
  return createNode("Modal", {
629
645
  title: label || null,
630
646
  ...attrsToObject(attrs),
631
647
  children
632
648
  });
633
649
  }
634
- function peg$f13(label, attrs, children) {
650
+ function peg$f15(label, attrs, children) {
635
651
  return createNode("Drawer", {
636
652
  title: label || null,
637
653
  ...attrsToObject(attrs),
638
654
  children
639
655
  });
640
656
  }
641
- function peg$f14(label, attrs, children) {
657
+ function peg$f16(label, attrs, children) {
642
658
  return createNode("Accordion", {
643
659
  title: label || null,
644
660
  ...attrsToObject(attrs),
645
661
  children
646
662
  });
647
663
  }
648
- function peg$f15(label, attrs, children) {
664
+ function peg$f17(label, attrs, children) {
649
665
  return createNode("Section", {
650
666
  title: label || null,
651
667
  ...attrsToObject(attrs),
652
668
  children
653
669
  });
654
670
  }
655
- function peg$f16(label, attrs) {
671
+ function peg$f18(label, attrs) {
656
672
  return createNode("Text", {
657
673
  content: label,
658
674
  ...attrsToObject(attrs)
659
675
  });
660
676
  }
661
- function peg$f17(label, attrs) {
677
+ function peg$f19(label, attrs) {
662
678
  return createNode("Title", {
663
679
  content: label,
664
680
  ...attrsToObject(attrs)
665
681
  });
666
682
  }
667
- function peg$f18(label, attrs) {
683
+ function peg$f20(label, attrs) {
668
684
  return createNode("Link", {
669
685
  content: label,
670
686
  ...attrsToObject(attrs)
671
687
  });
672
688
  }
673
- function peg$f19(label, attrs) {
689
+ function peg$f21(label, attrs) {
674
690
  return createNode("Button", {
675
691
  content: label,
676
692
  ...attrsToObject(attrs)
677
693
  });
678
694
  }
679
- function peg$f20(label, attrs) {
695
+ function peg$f22(label, attrs) {
680
696
  const obj = attrsToObject(attrs);
681
697
  const inputType = obj.type;
682
698
  delete obj.type;
@@ -686,75 +702,75 @@ function peg$parse(input, options) {
686
702
  ...obj
687
703
  });
688
704
  }
689
- function peg$f21(label, attrs) {
705
+ function peg$f23(label, attrs) {
690
706
  return createNode("Textarea", {
691
707
  label: label || null,
692
708
  ...attrsToObject(attrs)
693
709
  });
694
710
  }
695
- function peg$f22(label, options2, attrs) {
711
+ function peg$f24(label, options2, attrs) {
696
712
  return createNode("Select", {
697
713
  label: label || null,
698
714
  options: options2 || [],
699
715
  ...attrsToObject(attrs)
700
716
  });
701
717
  }
702
- function peg$f23(label, attrs) {
718
+ function peg$f25(label, attrs) {
703
719
  return createNode("Checkbox", {
704
720
  label: label || null,
705
721
  ...attrsToObject(attrs)
706
722
  });
707
723
  }
708
- function peg$f24(label, attrs) {
724
+ function peg$f26(label, attrs) {
709
725
  return createNode("Radio", {
710
726
  label: label || null,
711
727
  ...attrsToObject(attrs)
712
728
  });
713
729
  }
714
- function peg$f25(label, attrs) {
730
+ function peg$f27(label, attrs) {
715
731
  return createNode("Switch", {
716
732
  label: label || null,
717
733
  ...attrsToObject(attrs)
718
734
  });
719
735
  }
720
- function peg$f26(label, attrs) {
736
+ function peg$f28(label, attrs) {
721
737
  return createNode("Slider", {
722
738
  label: label || null,
723
739
  ...attrsToObject(attrs)
724
740
  });
725
741
  }
726
- function peg$f27(src, attrs) {
742
+ function peg$f29(src, attrs) {
727
743
  return createNode("Image", {
728
744
  src: src || null,
729
745
  ...attrsToObject(attrs)
730
746
  });
731
747
  }
732
- function peg$f28(label, attrs, block) {
748
+ function peg$f30(label, attrs, block) {
733
749
  return createNode("Placeholder", {
734
750
  label: label || null,
735
751
  ...attrsToObject(attrs),
736
752
  children: block ? block[2] : []
737
753
  });
738
754
  }
739
- function peg$f29(label, attrs) {
755
+ function peg$f31(label, attrs) {
740
756
  return createNode("Avatar", {
741
757
  name: label || null,
742
758
  ...attrsToObject(attrs)
743
759
  });
744
760
  }
745
- function peg$f30(label, attrs) {
761
+ function peg$f32(label, attrs) {
746
762
  return createNode("Badge", {
747
763
  content: label,
748
764
  ...attrsToObject(attrs)
749
765
  });
750
766
  }
751
- function peg$f31(name, attrs) {
767
+ function peg$f33(name, attrs) {
752
768
  return createNode("Icon", {
753
769
  name,
754
770
  ...attrsToObject(attrs)
755
771
  });
756
772
  }
757
- function peg$f32(data, attrs) {
773
+ function peg$f34(data, attrs) {
758
774
  const columns = data.length > 0 ? data[0] : [];
759
775
  const rows = data.slice(1);
760
776
  return createNode("Table", {
@@ -763,16 +779,16 @@ function peg$parse(input, options) {
763
779
  ...attrsToObject(attrs)
764
780
  });
765
781
  }
766
- function peg$f33(attrs, rows) {
782
+ function peg$f35(attrs, rows) {
767
783
  return createNode("Table", {
768
784
  ...attrsToObject(attrs),
769
785
  ...rows
770
786
  });
771
787
  }
772
- function peg$f34(first, rest) {
788
+ function peg$f36(first, rest) {
773
789
  return [first, ...rest.map((r) => r[2])];
774
790
  }
775
- function peg$f35(items) {
791
+ function peg$f37(items) {
776
792
  const columns = [];
777
793
  const rows = [];
778
794
  for (const item of items.map((i) => i[0]).filter((i) => i !== null)) {
@@ -781,72 +797,72 @@ function peg$parse(input, options) {
781
797
  }
782
798
  return { columns, rows };
783
799
  }
784
- function peg$f36(values) {
800
+ function peg$f38(values) {
785
801
  return { type: "columns", values };
786
802
  }
787
- function peg$f37(values) {
803
+ function peg$f39(values) {
788
804
  return { type: "row", values };
789
805
  }
790
- function peg$f38() {
806
+ function peg$f40() {
791
807
  return null;
792
808
  }
793
- function peg$f39(items, attrs, block) {
809
+ function peg$f41(items, attrs, block) {
794
810
  return createNode("List", {
795
811
  items: items || (block ? block : []),
796
812
  ...attrsToObject(attrs)
797
813
  });
798
814
  }
799
- function peg$f40(items) {
815
+ function peg$f42(items) {
800
816
  return items.map((i) => i[0]).filter((i) => i !== null);
801
817
  }
802
- function peg$f41(label, attrs, nested) {
818
+ function peg$f43(label, attrs, nested) {
803
819
  return {
804
820
  content: label,
805
821
  ...attrsToObject(attrs),
806
822
  children: nested || []
807
823
  };
808
824
  }
809
- function peg$f42() {
825
+ function peg$f44() {
810
826
  return null;
811
827
  }
812
- function peg$f43(label, attrs) {
828
+ function peg$f45(label, attrs) {
813
829
  return createNode("Alert", {
814
830
  content: label,
815
831
  ...attrsToObject(attrs)
816
832
  });
817
833
  }
818
- function peg$f44(label, attrs) {
834
+ function peg$f46(label, attrs) {
819
835
  return createNode("Toast", {
820
836
  content: label,
821
837
  ...attrsToObject(attrs)
822
838
  });
823
839
  }
824
- function peg$f45(attrs) {
840
+ function peg$f47(attrs) {
825
841
  return createNode("Progress", {
826
842
  ...attrsToObject(attrs)
827
843
  });
828
844
  }
829
- function peg$f46(label, attrs) {
845
+ function peg$f48(label, attrs) {
830
846
  return createNode("Spinner", {
831
847
  label: label || null,
832
848
  ...attrsToObject(attrs)
833
849
  });
834
850
  }
835
- function peg$f47(label, attrs) {
851
+ function peg$f49(label, attrs) {
836
852
  return createNode("Tooltip", {
837
853
  content: label,
838
854
  ...attrsToObject(attrs),
839
855
  children: []
840
856
  });
841
857
  }
842
- function peg$f48(label, attrs, children) {
858
+ function peg$f50(label, attrs, children) {
843
859
  return createNode("Popover", {
844
860
  title: label || null,
845
861
  ...attrsToObject(attrs),
846
862
  children
847
863
  });
848
864
  }
849
- function peg$f49(items, attrs) {
865
+ function peg$f51(items, attrs) {
850
866
  const processedItems = items.map((item) => {
851
867
  if (typeof item === "string") {
852
868
  if (item === "---" || item === "-" || item === "divider") {
@@ -861,41 +877,41 @@ function peg$parse(input, options) {
861
877
  items: processedItems
862
878
  });
863
879
  }
864
- function peg$f50(attrs, items) {
880
+ function peg$f52(attrs, items) {
865
881
  return createNode("Dropdown", {
866
882
  ...attrsToObject(attrs),
867
883
  items
868
884
  });
869
885
  }
870
- function peg$f51(items) {
886
+ function peg$f53(items) {
871
887
  return items.map((i) => i[0]).filter((i) => i !== null);
872
888
  }
873
- function peg$f52(label, attrs) {
889
+ function peg$f54(label, attrs) {
874
890
  return { label, ...attrsToObject(attrs) };
875
891
  }
876
- function peg$f53() {
892
+ function peg$f55() {
877
893
  return { type: "divider" };
878
894
  }
879
- function peg$f54() {
895
+ function peg$f56() {
880
896
  return null;
881
897
  }
882
- function peg$f55(items, attrs, block) {
898
+ function peg$f57(items, attrs, block) {
883
899
  return createNode("Nav", {
884
900
  items: items || [],
885
901
  ...attrsToObject(attrs),
886
902
  children: block || []
887
903
  });
888
904
  }
889
- function peg$f56(content) {
905
+ function peg$f58(content) {
890
906
  return content.map((c) => c[0]).filter((c) => c !== null);
891
907
  }
892
- function peg$f57() {
908
+ function peg$f59() {
893
909
  return { type: "divider" };
894
910
  }
895
- function peg$f58() {
911
+ function peg$f60() {
896
912
  return null;
897
913
  }
898
- function peg$f59(label, attrs, items) {
914
+ function peg$f61(label, attrs, items) {
899
915
  return {
900
916
  type: "group",
901
917
  label,
@@ -903,122 +919,122 @@ function peg$parse(input, options) {
903
919
  items: items.map((i) => i[0]).filter((i) => i !== null)
904
920
  };
905
921
  }
906
- function peg$f60() {
922
+ function peg$f62() {
907
923
  return { type: "divider" };
908
924
  }
909
- function peg$f61() {
925
+ function peg$f63() {
910
926
  return null;
911
927
  }
912
- function peg$f62(label, attrs) {
928
+ function peg$f64(label, attrs) {
913
929
  return {
914
930
  type: "item",
915
931
  label,
916
932
  ...attrsToObject(attrs)
917
933
  };
918
934
  }
919
- function peg$f63(items, attrs, block) {
935
+ function peg$f65(items, attrs, block) {
920
936
  return createNode("Tabs", {
921
937
  items: items || [],
922
938
  ...attrsToObject(attrs),
923
939
  children: block || []
924
940
  });
925
941
  }
926
- function peg$f64(tabs) {
942
+ function peg$f66(tabs) {
927
943
  return tabs.map((t) => t[0]).filter((t) => t !== null);
928
944
  }
929
- function peg$f65(label, attrs, children) {
945
+ function peg$f67(label, attrs, children) {
930
946
  return {
931
947
  label,
932
948
  ...attrsToObject(attrs),
933
949
  children
934
950
  };
935
951
  }
936
- function peg$f66() {
952
+ function peg$f68() {
937
953
  return null;
938
954
  }
939
- function peg$f67(items, attrs) {
955
+ function peg$f69(items, attrs) {
940
956
  return createNode("Breadcrumb", {
941
957
  items,
942
958
  ...attrsToObject(attrs)
943
959
  });
944
960
  }
945
- function peg$f68(attrs) {
961
+ function peg$f70(attrs) {
946
962
  return createNode("Divider", {
947
963
  ...attrsToObject(attrs)
948
964
  });
949
965
  }
950
- function peg$f69(attrs) {
966
+ function peg$f71(attrs) {
951
967
  return attrs;
952
968
  }
953
- function peg$f70(name, value) {
969
+ function peg$f72(name, value) {
954
970
  return { name, value };
955
971
  }
956
- function peg$f71(flag) {
972
+ function peg$f73(flag) {
957
973
  return { name: flag, value: true };
958
974
  }
959
- function peg$f72(name) {
975
+ function peg$f74(name) {
960
976
  return name;
961
977
  }
962
- function peg$f73(chars) {
978
+ function peg$f75(chars) {
963
979
  return chars.join("");
964
980
  }
965
- function peg$f74(chars) {
981
+ function peg$f76(chars) {
966
982
  return chars.join("");
967
983
  }
968
- function peg$f75(char) {
984
+ function peg$f77(char) {
969
985
  return char;
970
986
  }
971
- function peg$f76(seq) {
987
+ function peg$f78(seq) {
972
988
  return seq;
973
989
  }
974
- function peg$f77(char) {
990
+ function peg$f79(char) {
975
991
  return char;
976
992
  }
977
- function peg$f78(seq) {
993
+ function peg$f80(seq) {
978
994
  return seq;
979
995
  }
980
- function peg$f79() {
996
+ function peg$f81() {
981
997
  return "\n";
982
998
  }
983
- function peg$f80() {
999
+ function peg$f82() {
984
1000
  return "\r";
985
1001
  }
986
- function peg$f81() {
1002
+ function peg$f83() {
987
1003
  return " ";
988
1004
  }
989
- function peg$f82() {
1005
+ function peg$f84() {
990
1006
  return "\\";
991
1007
  }
992
- function peg$f83() {
1008
+ function peg$f85() {
993
1009
  return '"';
994
1010
  }
995
- function peg$f84() {
1011
+ function peg$f86() {
996
1012
  return "'";
997
1013
  }
998
- function peg$f85(sign, digits, decimal) {
1014
+ function peg$f87(sign, digits, decimal) {
999
1015
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1000
1016
  return parseFloat(num);
1001
1017
  }
1002
- function peg$f86(sign, digits, decimal, unit) {
1018
+ function peg$f88(sign, digits, decimal, unit) {
1003
1019
  const num = (sign || "") + digits.join("") + (decimal ? "." + decimal[1].join("") : "");
1004
1020
  return { value: parseFloat(num), unit };
1005
1021
  }
1006
- function peg$f87() {
1022
+ function peg$f89() {
1007
1023
  return true;
1008
1024
  }
1009
- function peg$f88() {
1025
+ function peg$f90() {
1010
1026
  return false;
1011
1027
  }
1012
- function peg$f89(head, tail) {
1028
+ function peg$f91(head, tail) {
1013
1029
  return head + tail.join("");
1014
1030
  }
1015
- function peg$f90(items) {
1031
+ function peg$f92(items) {
1016
1032
  return items || [];
1017
1033
  }
1018
- function peg$f91(head, tail) {
1034
+ function peg$f93(head, tail) {
1019
1035
  return [head, ...tail.map((t) => t[3])];
1020
1036
  }
1021
- function peg$f92(props) {
1037
+ function peg$f94(props) {
1022
1038
  const result = {};
1023
1039
  if (props) {
1024
1040
  for (const p of props) {
@@ -1027,13 +1043,13 @@ function peg$parse(input, options) {
1027
1043
  }
1028
1044
  return result;
1029
1045
  }
1030
- function peg$f93(head, tail) {
1046
+ function peg$f95(head, tail) {
1031
1047
  return [head, ...tail.map((t) => t[3])];
1032
1048
  }
1033
- function peg$f94(name, value) {
1049
+ function peg$f96(name, value) {
1034
1050
  return { name, value };
1035
1051
  }
1036
- function peg$f95(name) {
1052
+ function peg$f97(name) {
1037
1053
  return { name, value: true };
1038
1054
  }
1039
1055
  let peg$currPos = options.peg$currPos | 0;
@@ -1330,6 +1346,12 @@ function peg$parse(input, options) {
1330
1346
  s0 = peg$parseRow();
1331
1347
  if (s0 === peg$FAILED) {
1332
1348
  s0 = peg$parseCol();
1349
+ if (s0 === peg$FAILED) {
1350
+ s0 = peg$parseStack();
1351
+ if (s0 === peg$FAILED) {
1352
+ s0 = peg$parseRelative();
1353
+ }
1354
+ }
1333
1355
  }
1334
1356
  }
1335
1357
  }
@@ -1715,6 +1737,132 @@ function peg$parse(input, options) {
1715
1737
  }
1716
1738
  return s0;
1717
1739
  }
1740
+ function peg$parseStack() {
1741
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
1742
+ s0 = peg$currPos;
1743
+ if (input.substr(peg$currPos, 5) === peg$c9) {
1744
+ s1 = peg$c9;
1745
+ peg$currPos += 5;
1746
+ } else {
1747
+ s1 = peg$FAILED;
1748
+ if (peg$silentFails === 0) {
1749
+ peg$fail(peg$e9);
1750
+ }
1751
+ }
1752
+ if (s1 !== peg$FAILED) {
1753
+ s2 = peg$parse_();
1754
+ s3 = peg$parseAttributes();
1755
+ if (s3 === peg$FAILED) {
1756
+ s3 = null;
1757
+ }
1758
+ s4 = peg$parse_();
1759
+ if (input.charCodeAt(peg$currPos) === 123) {
1760
+ s5 = peg$c1;
1761
+ peg$currPos++;
1762
+ } else {
1763
+ s5 = peg$FAILED;
1764
+ if (peg$silentFails === 0) {
1765
+ peg$fail(peg$e1);
1766
+ }
1767
+ }
1768
+ if (s5 !== peg$FAILED) {
1769
+ s6 = peg$parse_();
1770
+ s7 = peg$parseChildren();
1771
+ if (s7 !== peg$FAILED) {
1772
+ s8 = peg$parse_();
1773
+ if (input.charCodeAt(peg$currPos) === 125) {
1774
+ s9 = peg$c2;
1775
+ peg$currPos++;
1776
+ } else {
1777
+ s9 = peg$FAILED;
1778
+ if (peg$silentFails === 0) {
1779
+ peg$fail(peg$e2);
1780
+ }
1781
+ }
1782
+ if (s9 !== peg$FAILED) {
1783
+ peg$savedPos = s0;
1784
+ s0 = peg$f11(s3, s7);
1785
+ } else {
1786
+ peg$currPos = s0;
1787
+ s0 = peg$FAILED;
1788
+ }
1789
+ } else {
1790
+ peg$currPos = s0;
1791
+ s0 = peg$FAILED;
1792
+ }
1793
+ } else {
1794
+ peg$currPos = s0;
1795
+ s0 = peg$FAILED;
1796
+ }
1797
+ } else {
1798
+ peg$currPos = s0;
1799
+ s0 = peg$FAILED;
1800
+ }
1801
+ return s0;
1802
+ }
1803
+ function peg$parseRelative() {
1804
+ let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
1805
+ s0 = peg$currPos;
1806
+ if (input.substr(peg$currPos, 8) === peg$c10) {
1807
+ s1 = peg$c10;
1808
+ peg$currPos += 8;
1809
+ } else {
1810
+ s1 = peg$FAILED;
1811
+ if (peg$silentFails === 0) {
1812
+ peg$fail(peg$e10);
1813
+ }
1814
+ }
1815
+ if (s1 !== peg$FAILED) {
1816
+ s2 = peg$parse_();
1817
+ s3 = peg$parseAttributes();
1818
+ if (s3 === peg$FAILED) {
1819
+ s3 = null;
1820
+ }
1821
+ s4 = peg$parse_();
1822
+ if (input.charCodeAt(peg$currPos) === 123) {
1823
+ s5 = peg$c1;
1824
+ peg$currPos++;
1825
+ } else {
1826
+ s5 = peg$FAILED;
1827
+ if (peg$silentFails === 0) {
1828
+ peg$fail(peg$e1);
1829
+ }
1830
+ }
1831
+ if (s5 !== peg$FAILED) {
1832
+ s6 = peg$parse_();
1833
+ s7 = peg$parseChildren();
1834
+ if (s7 !== peg$FAILED) {
1835
+ s8 = peg$parse_();
1836
+ if (input.charCodeAt(peg$currPos) === 125) {
1837
+ s9 = peg$c2;
1838
+ peg$currPos++;
1839
+ } else {
1840
+ s9 = peg$FAILED;
1841
+ if (peg$silentFails === 0) {
1842
+ peg$fail(peg$e2);
1843
+ }
1844
+ }
1845
+ if (s9 !== peg$FAILED) {
1846
+ peg$savedPos = s0;
1847
+ s0 = peg$f12(s3, s7);
1848
+ } else {
1849
+ peg$currPos = s0;
1850
+ s0 = peg$FAILED;
1851
+ }
1852
+ } else {
1853
+ peg$currPos = s0;
1854
+ s0 = peg$FAILED;
1855
+ }
1856
+ } else {
1857
+ peg$currPos = s0;
1858
+ s0 = peg$FAILED;
1859
+ }
1860
+ } else {
1861
+ peg$currPos = s0;
1862
+ s0 = peg$FAILED;
1863
+ }
1864
+ return s0;
1865
+ }
1718
1866
  function peg$parseContainerElement() {
1719
1867
  let s0;
1720
1868
  s0 = peg$parseCard();
@@ -1735,13 +1883,13 @@ function peg$parse(input, options) {
1735
1883
  function peg$parseCard() {
1736
1884
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
1737
1885
  s0 = peg$currPos;
1738
- if (input.substr(peg$currPos, 4) === peg$c9) {
1739
- s1 = peg$c9;
1886
+ if (input.substr(peg$currPos, 4) === peg$c11) {
1887
+ s1 = peg$c11;
1740
1888
  peg$currPos += 4;
1741
1889
  } else {
1742
1890
  s1 = peg$FAILED;
1743
1891
  if (peg$silentFails === 0) {
1744
- peg$fail(peg$e9);
1892
+ peg$fail(peg$e11);
1745
1893
  }
1746
1894
  }
1747
1895
  if (s1 !== peg$FAILED) {
@@ -1781,7 +1929,7 @@ function peg$parse(input, options) {
1781
1929
  }
1782
1930
  if (s11 !== peg$FAILED) {
1783
1931
  peg$savedPos = s0;
1784
- s0 = peg$f11(s3, s5, s9);
1932
+ s0 = peg$f13(s3, s5, s9);
1785
1933
  } else {
1786
1934
  peg$currPos = s0;
1787
1935
  s0 = peg$FAILED;
@@ -1803,13 +1951,13 @@ function peg$parse(input, options) {
1803
1951
  function peg$parseModal() {
1804
1952
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
1805
1953
  s0 = peg$currPos;
1806
- if (input.substr(peg$currPos, 5) === peg$c10) {
1807
- s1 = peg$c10;
1954
+ if (input.substr(peg$currPos, 5) === peg$c12) {
1955
+ s1 = peg$c12;
1808
1956
  peg$currPos += 5;
1809
1957
  } else {
1810
1958
  s1 = peg$FAILED;
1811
1959
  if (peg$silentFails === 0) {
1812
- peg$fail(peg$e10);
1960
+ peg$fail(peg$e12);
1813
1961
  }
1814
1962
  }
1815
1963
  if (s1 !== peg$FAILED) {
@@ -1849,7 +1997,7 @@ function peg$parse(input, options) {
1849
1997
  }
1850
1998
  if (s11 !== peg$FAILED) {
1851
1999
  peg$savedPos = s0;
1852
- s0 = peg$f12(s3, s5, s9);
2000
+ s0 = peg$f14(s3, s5, s9);
1853
2001
  } else {
1854
2002
  peg$currPos = s0;
1855
2003
  s0 = peg$FAILED;
@@ -1871,13 +2019,13 @@ function peg$parse(input, options) {
1871
2019
  function peg$parseDrawer() {
1872
2020
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
1873
2021
  s0 = peg$currPos;
1874
- if (input.substr(peg$currPos, 6) === peg$c11) {
1875
- s1 = peg$c11;
2022
+ if (input.substr(peg$currPos, 6) === peg$c13) {
2023
+ s1 = peg$c13;
1876
2024
  peg$currPos += 6;
1877
2025
  } else {
1878
2026
  s1 = peg$FAILED;
1879
2027
  if (peg$silentFails === 0) {
1880
- peg$fail(peg$e11);
2028
+ peg$fail(peg$e13);
1881
2029
  }
1882
2030
  }
1883
2031
  if (s1 !== peg$FAILED) {
@@ -1917,7 +2065,7 @@ function peg$parse(input, options) {
1917
2065
  }
1918
2066
  if (s11 !== peg$FAILED) {
1919
2067
  peg$savedPos = s0;
1920
- s0 = peg$f13(s3, s5, s9);
2068
+ s0 = peg$f15(s3, s5, s9);
1921
2069
  } else {
1922
2070
  peg$currPos = s0;
1923
2071
  s0 = peg$FAILED;
@@ -1939,13 +2087,13 @@ function peg$parse(input, options) {
1939
2087
  function peg$parseAccordion() {
1940
2088
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
1941
2089
  s0 = peg$currPos;
1942
- if (input.substr(peg$currPos, 9) === peg$c12) {
1943
- s1 = peg$c12;
2090
+ if (input.substr(peg$currPos, 9) === peg$c14) {
2091
+ s1 = peg$c14;
1944
2092
  peg$currPos += 9;
1945
2093
  } else {
1946
2094
  s1 = peg$FAILED;
1947
2095
  if (peg$silentFails === 0) {
1948
- peg$fail(peg$e12);
2096
+ peg$fail(peg$e14);
1949
2097
  }
1950
2098
  }
1951
2099
  if (s1 !== peg$FAILED) {
@@ -1985,7 +2133,7 @@ function peg$parse(input, options) {
1985
2133
  }
1986
2134
  if (s11 !== peg$FAILED) {
1987
2135
  peg$savedPos = s0;
1988
- s0 = peg$f14(s3, s5, s9);
2136
+ s0 = peg$f16(s3, s5, s9);
1989
2137
  } else {
1990
2138
  peg$currPos = s0;
1991
2139
  s0 = peg$FAILED;
@@ -2007,13 +2155,13 @@ function peg$parse(input, options) {
2007
2155
  function peg$parseSection() {
2008
2156
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
2009
2157
  s0 = peg$currPos;
2010
- if (input.substr(peg$currPos, 7) === peg$c13) {
2011
- s1 = peg$c13;
2158
+ if (input.substr(peg$currPos, 7) === peg$c15) {
2159
+ s1 = peg$c15;
2012
2160
  peg$currPos += 7;
2013
2161
  } else {
2014
2162
  s1 = peg$FAILED;
2015
2163
  if (peg$silentFails === 0) {
2016
- peg$fail(peg$e13);
2164
+ peg$fail(peg$e15);
2017
2165
  }
2018
2166
  }
2019
2167
  if (s1 !== peg$FAILED) {
@@ -2053,7 +2201,7 @@ function peg$parse(input, options) {
2053
2201
  }
2054
2202
  if (s11 !== peg$FAILED) {
2055
2203
  peg$savedPos = s0;
2056
- s0 = peg$f15(s3, s5, s9);
2204
+ s0 = peg$f17(s3, s5, s9);
2057
2205
  } else {
2058
2206
  peg$currPos = s0;
2059
2207
  s0 = peg$FAILED;
@@ -2164,13 +2312,13 @@ function peg$parse(input, options) {
2164
2312
  function peg$parseText() {
2165
2313
  let s0, s1, s2, s3, s4, s5;
2166
2314
  s0 = peg$currPos;
2167
- if (input.substr(peg$currPos, 4) === peg$c14) {
2168
- s1 = peg$c14;
2315
+ if (input.substr(peg$currPos, 4) === peg$c16) {
2316
+ s1 = peg$c16;
2169
2317
  peg$currPos += 4;
2170
2318
  } else {
2171
2319
  s1 = peg$FAILED;
2172
2320
  if (peg$silentFails === 0) {
2173
- peg$fail(peg$e14);
2321
+ peg$fail(peg$e16);
2174
2322
  }
2175
2323
  }
2176
2324
  if (s1 !== peg$FAILED) {
@@ -2183,7 +2331,7 @@ function peg$parse(input, options) {
2183
2331
  s5 = null;
2184
2332
  }
2185
2333
  peg$savedPos = s0;
2186
- s0 = peg$f16(s3, s5);
2334
+ s0 = peg$f18(s3, s5);
2187
2335
  } else {
2188
2336
  peg$currPos = s0;
2189
2337
  s0 = peg$FAILED;
@@ -2197,13 +2345,13 @@ function peg$parse(input, options) {
2197
2345
  function peg$parseTitle() {
2198
2346
  let s0, s1, s2, s3, s4, s5;
2199
2347
  s0 = peg$currPos;
2200
- if (input.substr(peg$currPos, 5) === peg$c15) {
2201
- s1 = peg$c15;
2348
+ if (input.substr(peg$currPos, 5) === peg$c17) {
2349
+ s1 = peg$c17;
2202
2350
  peg$currPos += 5;
2203
2351
  } else {
2204
2352
  s1 = peg$FAILED;
2205
2353
  if (peg$silentFails === 0) {
2206
- peg$fail(peg$e15);
2354
+ peg$fail(peg$e17);
2207
2355
  }
2208
2356
  }
2209
2357
  if (s1 !== peg$FAILED) {
@@ -2216,7 +2364,7 @@ function peg$parse(input, options) {
2216
2364
  s5 = null;
2217
2365
  }
2218
2366
  peg$savedPos = s0;
2219
- s0 = peg$f17(s3, s5);
2367
+ s0 = peg$f19(s3, s5);
2220
2368
  } else {
2221
2369
  peg$currPos = s0;
2222
2370
  s0 = peg$FAILED;
@@ -2230,13 +2378,13 @@ function peg$parse(input, options) {
2230
2378
  function peg$parseLink() {
2231
2379
  let s0, s1, s2, s3, s4, s5;
2232
2380
  s0 = peg$currPos;
2233
- if (input.substr(peg$currPos, 4) === peg$c16) {
2234
- s1 = peg$c16;
2381
+ if (input.substr(peg$currPos, 4) === peg$c18) {
2382
+ s1 = peg$c18;
2235
2383
  peg$currPos += 4;
2236
2384
  } else {
2237
2385
  s1 = peg$FAILED;
2238
2386
  if (peg$silentFails === 0) {
2239
- peg$fail(peg$e16);
2387
+ peg$fail(peg$e18);
2240
2388
  }
2241
2389
  }
2242
2390
  if (s1 !== peg$FAILED) {
@@ -2249,7 +2397,7 @@ function peg$parse(input, options) {
2249
2397
  s5 = null;
2250
2398
  }
2251
2399
  peg$savedPos = s0;
2252
- s0 = peg$f18(s3, s5);
2400
+ s0 = peg$f20(s3, s5);
2253
2401
  } else {
2254
2402
  peg$currPos = s0;
2255
2403
  s0 = peg$FAILED;
@@ -2263,13 +2411,13 @@ function peg$parse(input, options) {
2263
2411
  function peg$parseButton() {
2264
2412
  let s0, s1, s2, s3, s4, s5;
2265
2413
  s0 = peg$currPos;
2266
- if (input.substr(peg$currPos, 6) === peg$c17) {
2267
- s1 = peg$c17;
2414
+ if (input.substr(peg$currPos, 6) === peg$c19) {
2415
+ s1 = peg$c19;
2268
2416
  peg$currPos += 6;
2269
2417
  } else {
2270
2418
  s1 = peg$FAILED;
2271
2419
  if (peg$silentFails === 0) {
2272
- peg$fail(peg$e17);
2420
+ peg$fail(peg$e19);
2273
2421
  }
2274
2422
  }
2275
2423
  if (s1 !== peg$FAILED) {
@@ -2282,7 +2430,7 @@ function peg$parse(input, options) {
2282
2430
  s5 = null;
2283
2431
  }
2284
2432
  peg$savedPos = s0;
2285
- s0 = peg$f19(s3, s5);
2433
+ s0 = peg$f21(s3, s5);
2286
2434
  } else {
2287
2435
  peg$currPos = s0;
2288
2436
  s0 = peg$FAILED;
@@ -2296,13 +2444,13 @@ function peg$parse(input, options) {
2296
2444
  function peg$parseInput() {
2297
2445
  let s0, s1, s2, s3, s4, s5;
2298
2446
  s0 = peg$currPos;
2299
- if (input.substr(peg$currPos, 5) === peg$c18) {
2300
- s1 = peg$c18;
2447
+ if (input.substr(peg$currPos, 5) === peg$c20) {
2448
+ s1 = peg$c20;
2301
2449
  peg$currPos += 5;
2302
2450
  } else {
2303
2451
  s1 = peg$FAILED;
2304
2452
  if (peg$silentFails === 0) {
2305
- peg$fail(peg$e18);
2453
+ peg$fail(peg$e20);
2306
2454
  }
2307
2455
  }
2308
2456
  if (s1 !== peg$FAILED) {
@@ -2317,7 +2465,7 @@ function peg$parse(input, options) {
2317
2465
  s5 = null;
2318
2466
  }
2319
2467
  peg$savedPos = s0;
2320
- s0 = peg$f20(s3, s5);
2468
+ s0 = peg$f22(s3, s5);
2321
2469
  } else {
2322
2470
  peg$currPos = s0;
2323
2471
  s0 = peg$FAILED;
@@ -2327,13 +2475,13 @@ function peg$parse(input, options) {
2327
2475
  function peg$parseTextarea() {
2328
2476
  let s0, s1, s2, s3, s4, s5;
2329
2477
  s0 = peg$currPos;
2330
- if (input.substr(peg$currPos, 8) === peg$c19) {
2331
- s1 = peg$c19;
2478
+ if (input.substr(peg$currPos, 8) === peg$c21) {
2479
+ s1 = peg$c21;
2332
2480
  peg$currPos += 8;
2333
2481
  } else {
2334
2482
  s1 = peg$FAILED;
2335
2483
  if (peg$silentFails === 0) {
2336
- peg$fail(peg$e19);
2484
+ peg$fail(peg$e21);
2337
2485
  }
2338
2486
  }
2339
2487
  if (s1 !== peg$FAILED) {
@@ -2348,7 +2496,7 @@ function peg$parse(input, options) {
2348
2496
  s5 = null;
2349
2497
  }
2350
2498
  peg$savedPos = s0;
2351
- s0 = peg$f21(s3, s5);
2499
+ s0 = peg$f23(s3, s5);
2352
2500
  } else {
2353
2501
  peg$currPos = s0;
2354
2502
  s0 = peg$FAILED;
@@ -2358,13 +2506,13 @@ function peg$parse(input, options) {
2358
2506
  function peg$parseSelect() {
2359
2507
  let s0, s1, s2, s3, s4, s5, s6, s7;
2360
2508
  s0 = peg$currPos;
2361
- if (input.substr(peg$currPos, 6) === peg$c20) {
2362
- s1 = peg$c20;
2509
+ if (input.substr(peg$currPos, 6) === peg$c22) {
2510
+ s1 = peg$c22;
2363
2511
  peg$currPos += 6;
2364
2512
  } else {
2365
2513
  s1 = peg$FAILED;
2366
2514
  if (peg$silentFails === 0) {
2367
- peg$fail(peg$e20);
2515
+ peg$fail(peg$e22);
2368
2516
  }
2369
2517
  }
2370
2518
  if (s1 !== peg$FAILED) {
@@ -2384,7 +2532,7 @@ function peg$parse(input, options) {
2384
2532
  s7 = null;
2385
2533
  }
2386
2534
  peg$savedPos = s0;
2387
- s0 = peg$f22(s3, s5, s7);
2535
+ s0 = peg$f24(s3, s5, s7);
2388
2536
  } else {
2389
2537
  peg$currPos = s0;
2390
2538
  s0 = peg$FAILED;
@@ -2394,13 +2542,13 @@ function peg$parse(input, options) {
2394
2542
  function peg$parseCheckbox() {
2395
2543
  let s0, s1, s2, s3, s4, s5;
2396
2544
  s0 = peg$currPos;
2397
- if (input.substr(peg$currPos, 8) === peg$c21) {
2398
- s1 = peg$c21;
2545
+ if (input.substr(peg$currPos, 8) === peg$c23) {
2546
+ s1 = peg$c23;
2399
2547
  peg$currPos += 8;
2400
2548
  } else {
2401
2549
  s1 = peg$FAILED;
2402
2550
  if (peg$silentFails === 0) {
2403
- peg$fail(peg$e21);
2551
+ peg$fail(peg$e23);
2404
2552
  }
2405
2553
  }
2406
2554
  if (s1 !== peg$FAILED) {
@@ -2415,7 +2563,7 @@ function peg$parse(input, options) {
2415
2563
  s5 = null;
2416
2564
  }
2417
2565
  peg$savedPos = s0;
2418
- s0 = peg$f23(s3, s5);
2566
+ s0 = peg$f25(s3, s5);
2419
2567
  } else {
2420
2568
  peg$currPos = s0;
2421
2569
  s0 = peg$FAILED;
@@ -2425,13 +2573,13 @@ function peg$parse(input, options) {
2425
2573
  function peg$parseRadio() {
2426
2574
  let s0, s1, s2, s3, s4, s5;
2427
2575
  s0 = peg$currPos;
2428
- if (input.substr(peg$currPos, 5) === peg$c22) {
2429
- s1 = peg$c22;
2576
+ if (input.substr(peg$currPos, 5) === peg$c24) {
2577
+ s1 = peg$c24;
2430
2578
  peg$currPos += 5;
2431
2579
  } else {
2432
2580
  s1 = peg$FAILED;
2433
2581
  if (peg$silentFails === 0) {
2434
- peg$fail(peg$e22);
2582
+ peg$fail(peg$e24);
2435
2583
  }
2436
2584
  }
2437
2585
  if (s1 !== peg$FAILED) {
@@ -2446,7 +2594,7 @@ function peg$parse(input, options) {
2446
2594
  s5 = null;
2447
2595
  }
2448
2596
  peg$savedPos = s0;
2449
- s0 = peg$f24(s3, s5);
2597
+ s0 = peg$f26(s3, s5);
2450
2598
  } else {
2451
2599
  peg$currPos = s0;
2452
2600
  s0 = peg$FAILED;
@@ -2456,13 +2604,13 @@ function peg$parse(input, options) {
2456
2604
  function peg$parseSwitch() {
2457
2605
  let s0, s1, s2, s3, s4, s5;
2458
2606
  s0 = peg$currPos;
2459
- if (input.substr(peg$currPos, 6) === peg$c23) {
2460
- s1 = peg$c23;
2607
+ if (input.substr(peg$currPos, 6) === peg$c25) {
2608
+ s1 = peg$c25;
2461
2609
  peg$currPos += 6;
2462
2610
  } else {
2463
2611
  s1 = peg$FAILED;
2464
2612
  if (peg$silentFails === 0) {
2465
- peg$fail(peg$e23);
2613
+ peg$fail(peg$e25);
2466
2614
  }
2467
2615
  }
2468
2616
  if (s1 !== peg$FAILED) {
@@ -2477,7 +2625,7 @@ function peg$parse(input, options) {
2477
2625
  s5 = null;
2478
2626
  }
2479
2627
  peg$savedPos = s0;
2480
- s0 = peg$f25(s3, s5);
2628
+ s0 = peg$f27(s3, s5);
2481
2629
  } else {
2482
2630
  peg$currPos = s0;
2483
2631
  s0 = peg$FAILED;
@@ -2487,13 +2635,13 @@ function peg$parse(input, options) {
2487
2635
  function peg$parseSlider() {
2488
2636
  let s0, s1, s2, s3, s4, s5;
2489
2637
  s0 = peg$currPos;
2490
- if (input.substr(peg$currPos, 6) === peg$c24) {
2491
- s1 = peg$c24;
2638
+ if (input.substr(peg$currPos, 6) === peg$c26) {
2639
+ s1 = peg$c26;
2492
2640
  peg$currPos += 6;
2493
2641
  } else {
2494
2642
  s1 = peg$FAILED;
2495
2643
  if (peg$silentFails === 0) {
2496
- peg$fail(peg$e24);
2644
+ peg$fail(peg$e26);
2497
2645
  }
2498
2646
  }
2499
2647
  if (s1 !== peg$FAILED) {
@@ -2508,7 +2656,7 @@ function peg$parse(input, options) {
2508
2656
  s5 = null;
2509
2657
  }
2510
2658
  peg$savedPos = s0;
2511
- s0 = peg$f26(s3, s5);
2659
+ s0 = peg$f28(s3, s5);
2512
2660
  } else {
2513
2661
  peg$currPos = s0;
2514
2662
  s0 = peg$FAILED;
@@ -2518,13 +2666,13 @@ function peg$parse(input, options) {
2518
2666
  function peg$parseImage() {
2519
2667
  let s0, s1, s2, s3, s4, s5;
2520
2668
  s0 = peg$currPos;
2521
- if (input.substr(peg$currPos, 5) === peg$c25) {
2522
- s1 = peg$c25;
2669
+ if (input.substr(peg$currPos, 5) === peg$c27) {
2670
+ s1 = peg$c27;
2523
2671
  peg$currPos += 5;
2524
2672
  } else {
2525
2673
  s1 = peg$FAILED;
2526
2674
  if (peg$silentFails === 0) {
2527
- peg$fail(peg$e25);
2675
+ peg$fail(peg$e27);
2528
2676
  }
2529
2677
  }
2530
2678
  if (s1 !== peg$FAILED) {
@@ -2539,7 +2687,7 @@ function peg$parse(input, options) {
2539
2687
  s5 = null;
2540
2688
  }
2541
2689
  peg$savedPos = s0;
2542
- s0 = peg$f27(s3, s5);
2690
+ s0 = peg$f29(s3, s5);
2543
2691
  } else {
2544
2692
  peg$currPos = s0;
2545
2693
  s0 = peg$FAILED;
@@ -2549,13 +2697,13 @@ function peg$parse(input, options) {
2549
2697
  function peg$parsePlaceholder() {
2550
2698
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
2551
2699
  s0 = peg$currPos;
2552
- if (input.substr(peg$currPos, 11) === peg$c26) {
2553
- s1 = peg$c26;
2700
+ if (input.substr(peg$currPos, 11) === peg$c28) {
2701
+ s1 = peg$c28;
2554
2702
  peg$currPos += 11;
2555
2703
  } else {
2556
2704
  s1 = peg$FAILED;
2557
2705
  if (peg$silentFails === 0) {
2558
- peg$fail(peg$e26);
2706
+ peg$fail(peg$e28);
2559
2707
  }
2560
2708
  }
2561
2709
  if (s1 !== peg$FAILED) {
@@ -2613,7 +2761,7 @@ function peg$parse(input, options) {
2613
2761
  s7 = null;
2614
2762
  }
2615
2763
  peg$savedPos = s0;
2616
- s0 = peg$f28(s3, s5, s7);
2764
+ s0 = peg$f30(s3, s5, s7);
2617
2765
  } else {
2618
2766
  peg$currPos = s0;
2619
2767
  s0 = peg$FAILED;
@@ -2623,13 +2771,13 @@ function peg$parse(input, options) {
2623
2771
  function peg$parseAvatar() {
2624
2772
  let s0, s1, s2, s3, s4, s5;
2625
2773
  s0 = peg$currPos;
2626
- if (input.substr(peg$currPos, 6) === peg$c27) {
2627
- s1 = peg$c27;
2774
+ if (input.substr(peg$currPos, 6) === peg$c29) {
2775
+ s1 = peg$c29;
2628
2776
  peg$currPos += 6;
2629
2777
  } else {
2630
2778
  s1 = peg$FAILED;
2631
2779
  if (peg$silentFails === 0) {
2632
- peg$fail(peg$e27);
2780
+ peg$fail(peg$e29);
2633
2781
  }
2634
2782
  }
2635
2783
  if (s1 !== peg$FAILED) {
@@ -2644,7 +2792,7 @@ function peg$parse(input, options) {
2644
2792
  s5 = null;
2645
2793
  }
2646
2794
  peg$savedPos = s0;
2647
- s0 = peg$f29(s3, s5);
2795
+ s0 = peg$f31(s3, s5);
2648
2796
  } else {
2649
2797
  peg$currPos = s0;
2650
2798
  s0 = peg$FAILED;
@@ -2654,13 +2802,13 @@ function peg$parse(input, options) {
2654
2802
  function peg$parseBadge() {
2655
2803
  let s0, s1, s2, s3, s4, s5;
2656
2804
  s0 = peg$currPos;
2657
- if (input.substr(peg$currPos, 5) === peg$c28) {
2658
- s1 = peg$c28;
2805
+ if (input.substr(peg$currPos, 5) === peg$c30) {
2806
+ s1 = peg$c30;
2659
2807
  peg$currPos += 5;
2660
2808
  } else {
2661
2809
  s1 = peg$FAILED;
2662
2810
  if (peg$silentFails === 0) {
2663
- peg$fail(peg$e28);
2811
+ peg$fail(peg$e30);
2664
2812
  }
2665
2813
  }
2666
2814
  if (s1 !== peg$FAILED) {
@@ -2673,7 +2821,7 @@ function peg$parse(input, options) {
2673
2821
  s5 = null;
2674
2822
  }
2675
2823
  peg$savedPos = s0;
2676
- s0 = peg$f30(s3, s5);
2824
+ s0 = peg$f32(s3, s5);
2677
2825
  } else {
2678
2826
  peg$currPos = s0;
2679
2827
  s0 = peg$FAILED;
@@ -2687,13 +2835,13 @@ function peg$parse(input, options) {
2687
2835
  function peg$parseIcon() {
2688
2836
  let s0, s1, s2, s3, s4, s5;
2689
2837
  s0 = peg$currPos;
2690
- if (input.substr(peg$currPos, 4) === peg$c29) {
2691
- s1 = peg$c29;
2838
+ if (input.substr(peg$currPos, 4) === peg$c31) {
2839
+ s1 = peg$c31;
2692
2840
  peg$currPos += 4;
2693
2841
  } else {
2694
2842
  s1 = peg$FAILED;
2695
2843
  if (peg$silentFails === 0) {
2696
- peg$fail(peg$e29);
2844
+ peg$fail(peg$e31);
2697
2845
  }
2698
2846
  }
2699
2847
  if (s1 !== peg$FAILED) {
@@ -2706,7 +2854,7 @@ function peg$parse(input, options) {
2706
2854
  s5 = null;
2707
2855
  }
2708
2856
  peg$savedPos = s0;
2709
- s0 = peg$f31(s3, s5);
2857
+ s0 = peg$f33(s3, s5);
2710
2858
  } else {
2711
2859
  peg$currPos = s0;
2712
2860
  s0 = peg$FAILED;
@@ -2720,13 +2868,13 @@ function peg$parse(input, options) {
2720
2868
  function peg$parseTable() {
2721
2869
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2722
2870
  s0 = peg$currPos;
2723
- if (input.substr(peg$currPos, 5) === peg$c30) {
2724
- s1 = peg$c30;
2871
+ if (input.substr(peg$currPos, 5) === peg$c32) {
2872
+ s1 = peg$c32;
2725
2873
  peg$currPos += 5;
2726
2874
  } else {
2727
2875
  s1 = peg$FAILED;
2728
2876
  if (peg$silentFails === 0) {
2729
- peg$fail(peg$e30);
2877
+ peg$fail(peg$e32);
2730
2878
  }
2731
2879
  }
2732
2880
  if (s1 !== peg$FAILED) {
@@ -2739,7 +2887,7 @@ function peg$parse(input, options) {
2739
2887
  s5 = null;
2740
2888
  }
2741
2889
  peg$savedPos = s0;
2742
- s0 = peg$f32(s3, s5);
2890
+ s0 = peg$f34(s3, s5);
2743
2891
  } else {
2744
2892
  peg$currPos = s0;
2745
2893
  s0 = peg$FAILED;
@@ -2750,13 +2898,13 @@ function peg$parse(input, options) {
2750
2898
  }
2751
2899
  if (s0 === peg$FAILED) {
2752
2900
  s0 = peg$currPos;
2753
- if (input.substr(peg$currPos, 5) === peg$c30) {
2754
- s1 = peg$c30;
2901
+ if (input.substr(peg$currPos, 5) === peg$c32) {
2902
+ s1 = peg$c32;
2755
2903
  peg$currPos += 5;
2756
2904
  } else {
2757
2905
  s1 = peg$FAILED;
2758
2906
  if (peg$silentFails === 0) {
2759
- peg$fail(peg$e30);
2907
+ peg$fail(peg$e32);
2760
2908
  }
2761
2909
  }
2762
2910
  if (s1 !== peg$FAILED) {
@@ -2790,7 +2938,7 @@ function peg$parse(input, options) {
2790
2938
  }
2791
2939
  if (s9 !== peg$FAILED) {
2792
2940
  peg$savedPos = s0;
2793
- s0 = peg$f33(s3, s7);
2941
+ s0 = peg$f35(s3, s7);
2794
2942
  } else {
2795
2943
  peg$currPos = s0;
2796
2944
  s0 = peg$FAILED;
@@ -2810,12 +2958,12 @@ function peg$parse(input, options) {
2810
2958
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
2811
2959
  s0 = peg$currPos;
2812
2960
  if (input.charCodeAt(peg$currPos) === 91) {
2813
- s1 = peg$c31;
2961
+ s1 = peg$c33;
2814
2962
  peg$currPos++;
2815
2963
  } else {
2816
2964
  s1 = peg$FAILED;
2817
2965
  if (peg$silentFails === 0) {
2818
- peg$fail(peg$e31);
2966
+ peg$fail(peg$e33);
2819
2967
  }
2820
2968
  }
2821
2969
  if (s1 !== peg$FAILED) {
@@ -2826,12 +2974,12 @@ function peg$parse(input, options) {
2826
2974
  s5 = [];
2827
2975
  s6 = peg$currPos;
2828
2976
  if (input.charCodeAt(peg$currPos) === 44) {
2829
- s7 = peg$c32;
2977
+ s7 = peg$c34;
2830
2978
  peg$currPos++;
2831
2979
  } else {
2832
2980
  s7 = peg$FAILED;
2833
2981
  if (peg$silentFails === 0) {
2834
- peg$fail(peg$e32);
2982
+ peg$fail(peg$e34);
2835
2983
  }
2836
2984
  }
2837
2985
  if (s7 !== peg$FAILED) {
@@ -2853,12 +3001,12 @@ function peg$parse(input, options) {
2853
3001
  s5.push(s6);
2854
3002
  s6 = peg$currPos;
2855
3003
  if (input.charCodeAt(peg$currPos) === 44) {
2856
- s7 = peg$c32;
3004
+ s7 = peg$c34;
2857
3005
  peg$currPos++;
2858
3006
  } else {
2859
3007
  s7 = peg$FAILED;
2860
3008
  if (peg$silentFails === 0) {
2861
- peg$fail(peg$e32);
3009
+ peg$fail(peg$e34);
2862
3010
  }
2863
3011
  }
2864
3012
  if (s7 !== peg$FAILED) {
@@ -2878,12 +3026,12 @@ function peg$parse(input, options) {
2878
3026
  }
2879
3027
  }
2880
3028
  if (input.charCodeAt(peg$currPos) === 44) {
2881
- s6 = peg$c32;
3029
+ s6 = peg$c34;
2882
3030
  peg$currPos++;
2883
3031
  } else {
2884
3032
  s6 = peg$FAILED;
2885
3033
  if (peg$silentFails === 0) {
2886
- peg$fail(peg$e32);
3034
+ peg$fail(peg$e34);
2887
3035
  }
2888
3036
  }
2889
3037
  if (s6 === peg$FAILED) {
@@ -2891,17 +3039,17 @@ function peg$parse(input, options) {
2891
3039
  }
2892
3040
  s7 = peg$parse_();
2893
3041
  if (input.charCodeAt(peg$currPos) === 93) {
2894
- s8 = peg$c33;
3042
+ s8 = peg$c35;
2895
3043
  peg$currPos++;
2896
3044
  } else {
2897
3045
  s8 = peg$FAILED;
2898
3046
  if (peg$silentFails === 0) {
2899
- peg$fail(peg$e33);
3047
+ peg$fail(peg$e35);
2900
3048
  }
2901
3049
  }
2902
3050
  if (s8 !== peg$FAILED) {
2903
3051
  peg$savedPos = s0;
2904
- s0 = peg$f34(s3, s5);
3052
+ s0 = peg$f36(s3, s5);
2905
3053
  } else {
2906
3054
  peg$currPos = s0;
2907
3055
  s0 = peg$FAILED;
@@ -2944,20 +3092,20 @@ function peg$parse(input, options) {
2944
3092
  }
2945
3093
  }
2946
3094
  peg$savedPos = s0;
2947
- s1 = peg$f35(s1);
3095
+ s1 = peg$f37(s1);
2948
3096
  s0 = s1;
2949
3097
  return s0;
2950
3098
  }
2951
3099
  function peg$parseTableRow() {
2952
3100
  let s0, s1, s2, s3;
2953
3101
  s0 = peg$currPos;
2954
- if (input.substr(peg$currPos, 7) === peg$c34) {
2955
- s1 = peg$c34;
3102
+ if (input.substr(peg$currPos, 7) === peg$c36) {
3103
+ s1 = peg$c36;
2956
3104
  peg$currPos += 7;
2957
3105
  } else {
2958
3106
  s1 = peg$FAILED;
2959
3107
  if (peg$silentFails === 0) {
2960
- peg$fail(peg$e34);
3108
+ peg$fail(peg$e36);
2961
3109
  }
2962
3110
  }
2963
3111
  if (s1 !== peg$FAILED) {
@@ -2965,7 +3113,7 @@ function peg$parse(input, options) {
2965
3113
  s3 = peg$parseArray();
2966
3114
  if (s3 !== peg$FAILED) {
2967
3115
  peg$savedPos = s0;
2968
- s0 = peg$f36(s3);
3116
+ s0 = peg$f38(s3);
2969
3117
  } else {
2970
3118
  peg$currPos = s0;
2971
3119
  s0 = peg$FAILED;
@@ -2990,7 +3138,7 @@ function peg$parse(input, options) {
2990
3138
  s3 = peg$parseArray();
2991
3139
  if (s3 !== peg$FAILED) {
2992
3140
  peg$savedPos = s0;
2993
- s0 = peg$f37(s3);
3141
+ s0 = peg$f39(s3);
2994
3142
  } else {
2995
3143
  peg$currPos = s0;
2996
3144
  s0 = peg$FAILED;
@@ -3004,7 +3152,7 @@ function peg$parse(input, options) {
3004
3152
  s1 = peg$parseComment();
3005
3153
  if (s1 !== peg$FAILED) {
3006
3154
  peg$savedPos = s0;
3007
- s1 = peg$f38();
3155
+ s1 = peg$f40();
3008
3156
  }
3009
3157
  s0 = s1;
3010
3158
  }
@@ -3014,13 +3162,13 @@ function peg$parse(input, options) {
3014
3162
  function peg$parseList() {
3015
3163
  let s0, s1, s2, s3, s4, s5, s6, s7;
3016
3164
  s0 = peg$currPos;
3017
- if (input.substr(peg$currPos, 4) === peg$c35) {
3018
- s1 = peg$c35;
3165
+ if (input.substr(peg$currPos, 4) === peg$c37) {
3166
+ s1 = peg$c37;
3019
3167
  peg$currPos += 4;
3020
3168
  } else {
3021
3169
  s1 = peg$FAILED;
3022
3170
  if (peg$silentFails === 0) {
3023
- peg$fail(peg$e35);
3171
+ peg$fail(peg$e37);
3024
3172
  }
3025
3173
  }
3026
3174
  if (s1 !== peg$FAILED) {
@@ -3040,7 +3188,7 @@ function peg$parse(input, options) {
3040
3188
  s7 = null;
3041
3189
  }
3042
3190
  peg$savedPos = s0;
3043
- s0 = peg$f39(s3, s5, s7);
3191
+ s0 = peg$f41(s3, s5, s7);
3044
3192
  } else {
3045
3193
  peg$currPos = s0;
3046
3194
  s0 = peg$FAILED;
@@ -3096,7 +3244,7 @@ function peg$parse(input, options) {
3096
3244
  }
3097
3245
  if (s4 !== peg$FAILED) {
3098
3246
  peg$savedPos = s0;
3099
- s0 = peg$f40(s3);
3247
+ s0 = peg$f42(s3);
3100
3248
  } else {
3101
3249
  peg$currPos = s0;
3102
3250
  s0 = peg$FAILED;
@@ -3110,13 +3258,13 @@ function peg$parse(input, options) {
3110
3258
  function peg$parseListItem() {
3111
3259
  let s0, s1, s2, s3, s4, s5, s6, s7;
3112
3260
  s0 = peg$currPos;
3113
- if (input.substr(peg$currPos, 4) === peg$c36) {
3114
- s1 = peg$c36;
3261
+ if (input.substr(peg$currPos, 4) === peg$c38) {
3262
+ s1 = peg$c38;
3115
3263
  peg$currPos += 4;
3116
3264
  } else {
3117
3265
  s1 = peg$FAILED;
3118
3266
  if (peg$silentFails === 0) {
3119
- peg$fail(peg$e36);
3267
+ peg$fail(peg$e38);
3120
3268
  }
3121
3269
  }
3122
3270
  if (s1 !== peg$FAILED) {
@@ -3134,7 +3282,7 @@ function peg$parse(input, options) {
3134
3282
  s7 = null;
3135
3283
  }
3136
3284
  peg$savedPos = s0;
3137
- s0 = peg$f41(s3, s5, s7);
3285
+ s0 = peg$f43(s3, s5, s7);
3138
3286
  } else {
3139
3287
  peg$currPos = s0;
3140
3288
  s0 = peg$FAILED;
@@ -3148,7 +3296,7 @@ function peg$parse(input, options) {
3148
3296
  s1 = peg$parseComment();
3149
3297
  if (s1 !== peg$FAILED) {
3150
3298
  peg$savedPos = s0;
3151
- s1 = peg$f42();
3299
+ s1 = peg$f44();
3152
3300
  }
3153
3301
  s0 = s1;
3154
3302
  }
@@ -3157,13 +3305,13 @@ function peg$parse(input, options) {
3157
3305
  function peg$parseAlert() {
3158
3306
  let s0, s1, s2, s3, s4, s5;
3159
3307
  s0 = peg$currPos;
3160
- if (input.substr(peg$currPos, 5) === peg$c37) {
3161
- s1 = peg$c37;
3308
+ if (input.substr(peg$currPos, 5) === peg$c39) {
3309
+ s1 = peg$c39;
3162
3310
  peg$currPos += 5;
3163
3311
  } else {
3164
3312
  s1 = peg$FAILED;
3165
3313
  if (peg$silentFails === 0) {
3166
- peg$fail(peg$e37);
3314
+ peg$fail(peg$e39);
3167
3315
  }
3168
3316
  }
3169
3317
  if (s1 !== peg$FAILED) {
@@ -3176,7 +3324,7 @@ function peg$parse(input, options) {
3176
3324
  s5 = null;
3177
3325
  }
3178
3326
  peg$savedPos = s0;
3179
- s0 = peg$f43(s3, s5);
3327
+ s0 = peg$f45(s3, s5);
3180
3328
  } else {
3181
3329
  peg$currPos = s0;
3182
3330
  s0 = peg$FAILED;
@@ -3190,13 +3338,13 @@ function peg$parse(input, options) {
3190
3338
  function peg$parseToast() {
3191
3339
  let s0, s1, s2, s3, s4, s5;
3192
3340
  s0 = peg$currPos;
3193
- if (input.substr(peg$currPos, 5) === peg$c38) {
3194
- s1 = peg$c38;
3341
+ if (input.substr(peg$currPos, 5) === peg$c40) {
3342
+ s1 = peg$c40;
3195
3343
  peg$currPos += 5;
3196
3344
  } else {
3197
3345
  s1 = peg$FAILED;
3198
3346
  if (peg$silentFails === 0) {
3199
- peg$fail(peg$e38);
3347
+ peg$fail(peg$e40);
3200
3348
  }
3201
3349
  }
3202
3350
  if (s1 !== peg$FAILED) {
@@ -3209,7 +3357,7 @@ function peg$parse(input, options) {
3209
3357
  s5 = null;
3210
3358
  }
3211
3359
  peg$savedPos = s0;
3212
- s0 = peg$f44(s3, s5);
3360
+ s0 = peg$f46(s3, s5);
3213
3361
  } else {
3214
3362
  peg$currPos = s0;
3215
3363
  s0 = peg$FAILED;
@@ -3223,13 +3371,13 @@ function peg$parse(input, options) {
3223
3371
  function peg$parseProgress() {
3224
3372
  let s0, s1, s2, s3;
3225
3373
  s0 = peg$currPos;
3226
- if (input.substr(peg$currPos, 8) === peg$c39) {
3227
- s1 = peg$c39;
3374
+ if (input.substr(peg$currPos, 8) === peg$c41) {
3375
+ s1 = peg$c41;
3228
3376
  peg$currPos += 8;
3229
3377
  } else {
3230
3378
  s1 = peg$FAILED;
3231
3379
  if (peg$silentFails === 0) {
3232
- peg$fail(peg$e39);
3380
+ peg$fail(peg$e41);
3233
3381
  }
3234
3382
  }
3235
3383
  if (s1 !== peg$FAILED) {
@@ -3239,7 +3387,7 @@ function peg$parse(input, options) {
3239
3387
  s3 = null;
3240
3388
  }
3241
3389
  peg$savedPos = s0;
3242
- s0 = peg$f45(s3);
3390
+ s0 = peg$f47(s3);
3243
3391
  } else {
3244
3392
  peg$currPos = s0;
3245
3393
  s0 = peg$FAILED;
@@ -3249,13 +3397,13 @@ function peg$parse(input, options) {
3249
3397
  function peg$parseSpinner() {
3250
3398
  let s0, s1, s2, s3, s4, s5;
3251
3399
  s0 = peg$currPos;
3252
- if (input.substr(peg$currPos, 7) === peg$c40) {
3253
- s1 = peg$c40;
3400
+ if (input.substr(peg$currPos, 7) === peg$c42) {
3401
+ s1 = peg$c42;
3254
3402
  peg$currPos += 7;
3255
3403
  } else {
3256
3404
  s1 = peg$FAILED;
3257
3405
  if (peg$silentFails === 0) {
3258
- peg$fail(peg$e40);
3406
+ peg$fail(peg$e42);
3259
3407
  }
3260
3408
  }
3261
3409
  if (s1 !== peg$FAILED) {
@@ -3270,7 +3418,7 @@ function peg$parse(input, options) {
3270
3418
  s5 = null;
3271
3419
  }
3272
3420
  peg$savedPos = s0;
3273
- s0 = peg$f46(s3, s5);
3421
+ s0 = peg$f48(s3, s5);
3274
3422
  } else {
3275
3423
  peg$currPos = s0;
3276
3424
  s0 = peg$FAILED;
@@ -3280,13 +3428,13 @@ function peg$parse(input, options) {
3280
3428
  function peg$parseTooltip() {
3281
3429
  let s0, s1, s2, s3, s4, s5;
3282
3430
  s0 = peg$currPos;
3283
- if (input.substr(peg$currPos, 7) === peg$c41) {
3284
- s1 = peg$c41;
3431
+ if (input.substr(peg$currPos, 7) === peg$c43) {
3432
+ s1 = peg$c43;
3285
3433
  peg$currPos += 7;
3286
3434
  } else {
3287
3435
  s1 = peg$FAILED;
3288
3436
  if (peg$silentFails === 0) {
3289
- peg$fail(peg$e41);
3437
+ peg$fail(peg$e43);
3290
3438
  }
3291
3439
  }
3292
3440
  if (s1 !== peg$FAILED) {
@@ -3299,7 +3447,7 @@ function peg$parse(input, options) {
3299
3447
  s5 = null;
3300
3448
  }
3301
3449
  peg$savedPos = s0;
3302
- s0 = peg$f47(s3, s5);
3450
+ s0 = peg$f49(s3, s5);
3303
3451
  } else {
3304
3452
  peg$currPos = s0;
3305
3453
  s0 = peg$FAILED;
@@ -3313,13 +3461,13 @@ function peg$parse(input, options) {
3313
3461
  function peg$parsePopover() {
3314
3462
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3315
3463
  s0 = peg$currPos;
3316
- if (input.substr(peg$currPos, 7) === peg$c42) {
3317
- s1 = peg$c42;
3464
+ if (input.substr(peg$currPos, 7) === peg$c44) {
3465
+ s1 = peg$c44;
3318
3466
  peg$currPos += 7;
3319
3467
  } else {
3320
3468
  s1 = peg$FAILED;
3321
3469
  if (peg$silentFails === 0) {
3322
- peg$fail(peg$e42);
3470
+ peg$fail(peg$e44);
3323
3471
  }
3324
3472
  }
3325
3473
  if (s1 !== peg$FAILED) {
@@ -3359,7 +3507,7 @@ function peg$parse(input, options) {
3359
3507
  }
3360
3508
  if (s11 !== peg$FAILED) {
3361
3509
  peg$savedPos = s0;
3362
- s0 = peg$f48(s3, s5, s9);
3510
+ s0 = peg$f50(s3, s5, s9);
3363
3511
  } else {
3364
3512
  peg$currPos = s0;
3365
3513
  s0 = peg$FAILED;
@@ -3381,13 +3529,13 @@ function peg$parse(input, options) {
3381
3529
  function peg$parseDropdown() {
3382
3530
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
3383
3531
  s0 = peg$currPos;
3384
- if (input.substr(peg$currPos, 8) === peg$c43) {
3385
- s1 = peg$c43;
3532
+ if (input.substr(peg$currPos, 8) === peg$c45) {
3533
+ s1 = peg$c45;
3386
3534
  peg$currPos += 8;
3387
3535
  } else {
3388
3536
  s1 = peg$FAILED;
3389
3537
  if (peg$silentFails === 0) {
3390
- peg$fail(peg$e43);
3538
+ peg$fail(peg$e45);
3391
3539
  }
3392
3540
  }
3393
3541
  if (s1 !== peg$FAILED) {
@@ -3400,7 +3548,7 @@ function peg$parse(input, options) {
3400
3548
  s5 = null;
3401
3549
  }
3402
3550
  peg$savedPos = s0;
3403
- s0 = peg$f49(s3, s5);
3551
+ s0 = peg$f51(s3, s5);
3404
3552
  } else {
3405
3553
  peg$currPos = s0;
3406
3554
  s0 = peg$FAILED;
@@ -3411,13 +3559,13 @@ function peg$parse(input, options) {
3411
3559
  }
3412
3560
  if (s0 === peg$FAILED) {
3413
3561
  s0 = peg$currPos;
3414
- if (input.substr(peg$currPos, 8) === peg$c43) {
3415
- s1 = peg$c43;
3562
+ if (input.substr(peg$currPos, 8) === peg$c45) {
3563
+ s1 = peg$c45;
3416
3564
  peg$currPos += 8;
3417
3565
  } else {
3418
3566
  s1 = peg$FAILED;
3419
3567
  if (peg$silentFails === 0) {
3420
- peg$fail(peg$e43);
3568
+ peg$fail(peg$e45);
3421
3569
  }
3422
3570
  }
3423
3571
  if (s1 !== peg$FAILED) {
@@ -3451,7 +3599,7 @@ function peg$parse(input, options) {
3451
3599
  }
3452
3600
  if (s9 !== peg$FAILED) {
3453
3601
  peg$savedPos = s0;
3454
- s0 = peg$f50(s3, s7);
3602
+ s0 = peg$f52(s3, s7);
3455
3603
  } else {
3456
3604
  peg$currPos = s0;
3457
3605
  s0 = peg$FAILED;
@@ -3495,20 +3643,20 @@ function peg$parse(input, options) {
3495
3643
  }
3496
3644
  }
3497
3645
  peg$savedPos = s0;
3498
- s1 = peg$f51(s1);
3646
+ s1 = peg$f53(s1);
3499
3647
  s0 = s1;
3500
3648
  return s0;
3501
3649
  }
3502
3650
  function peg$parseDropdownItem() {
3503
3651
  let s0, s1, s2, s3, s4, s5;
3504
3652
  s0 = peg$currPos;
3505
- if (input.substr(peg$currPos, 4) === peg$c36) {
3506
- s1 = peg$c36;
3653
+ if (input.substr(peg$currPos, 4) === peg$c38) {
3654
+ s1 = peg$c38;
3507
3655
  peg$currPos += 4;
3508
3656
  } else {
3509
3657
  s1 = peg$FAILED;
3510
3658
  if (peg$silentFails === 0) {
3511
- peg$fail(peg$e36);
3659
+ peg$fail(peg$e38);
3512
3660
  }
3513
3661
  }
3514
3662
  if (s1 !== peg$FAILED) {
@@ -3521,7 +3669,7 @@ function peg$parse(input, options) {
3521
3669
  s5 = null;
3522
3670
  }
3523
3671
  peg$savedPos = s0;
3524
- s0 = peg$f52(s3, s5);
3672
+ s0 = peg$f54(s3, s5);
3525
3673
  } else {
3526
3674
  peg$currPos = s0;
3527
3675
  s0 = peg$FAILED;
@@ -3532,18 +3680,18 @@ function peg$parse(input, options) {
3532
3680
  }
3533
3681
  if (s0 === peg$FAILED) {
3534
3682
  s0 = peg$currPos;
3535
- if (input.substr(peg$currPos, 7) === peg$c44) {
3536
- s1 = peg$c44;
3683
+ if (input.substr(peg$currPos, 7) === peg$c46) {
3684
+ s1 = peg$c46;
3537
3685
  peg$currPos += 7;
3538
3686
  } else {
3539
3687
  s1 = peg$FAILED;
3540
3688
  if (peg$silentFails === 0) {
3541
- peg$fail(peg$e44);
3689
+ peg$fail(peg$e46);
3542
3690
  }
3543
3691
  }
3544
3692
  if (s1 !== peg$FAILED) {
3545
3693
  peg$savedPos = s0;
3546
- s1 = peg$f53();
3694
+ s1 = peg$f55();
3547
3695
  }
3548
3696
  s0 = s1;
3549
3697
  if (s0 === peg$FAILED) {
@@ -3551,7 +3699,7 @@ function peg$parse(input, options) {
3551
3699
  s1 = peg$parseComment();
3552
3700
  if (s1 !== peg$FAILED) {
3553
3701
  peg$savedPos = s0;
3554
- s1 = peg$f54();
3702
+ s1 = peg$f56();
3555
3703
  }
3556
3704
  s0 = s1;
3557
3705
  }
@@ -3561,13 +3709,13 @@ function peg$parse(input, options) {
3561
3709
  function peg$parseNav() {
3562
3710
  let s0, s1, s2, s3, s4, s5, s6, s7;
3563
3711
  s0 = peg$currPos;
3564
- if (input.substr(peg$currPos, 3) === peg$c45) {
3565
- s1 = peg$c45;
3712
+ if (input.substr(peg$currPos, 3) === peg$c47) {
3713
+ s1 = peg$c47;
3566
3714
  peg$currPos += 3;
3567
3715
  } else {
3568
3716
  s1 = peg$FAILED;
3569
3717
  if (peg$silentFails === 0) {
3570
- peg$fail(peg$e45);
3718
+ peg$fail(peg$e47);
3571
3719
  }
3572
3720
  }
3573
3721
  if (s1 !== peg$FAILED) {
@@ -3587,7 +3735,7 @@ function peg$parse(input, options) {
3587
3735
  s7 = null;
3588
3736
  }
3589
3737
  peg$savedPos = s0;
3590
- s0 = peg$f55(s3, s5, s7);
3738
+ s0 = peg$f57(s3, s5, s7);
3591
3739
  } else {
3592
3740
  peg$currPos = s0;
3593
3741
  s0 = peg$FAILED;
@@ -3643,7 +3791,7 @@ function peg$parse(input, options) {
3643
3791
  }
3644
3792
  if (s4 !== peg$FAILED) {
3645
3793
  peg$savedPos = s0;
3646
- s0 = peg$f56(s3);
3794
+ s0 = peg$f58(s3);
3647
3795
  } else {
3648
3796
  peg$currPos = s0;
3649
3797
  s0 = peg$FAILED;
@@ -3661,19 +3809,19 @@ function peg$parse(input, options) {
3661
3809
  s0 = peg$parseNavItem();
3662
3810
  if (s0 === peg$FAILED) {
3663
3811
  s0 = peg$currPos;
3664
- if (input.substr(peg$currPos, 7) === peg$c44) {
3665
- s1 = peg$c44;
3812
+ if (input.substr(peg$currPos, 7) === peg$c46) {
3813
+ s1 = peg$c46;
3666
3814
  peg$currPos += 7;
3667
3815
  } else {
3668
3816
  s1 = peg$FAILED;
3669
3817
  if (peg$silentFails === 0) {
3670
- peg$fail(peg$e44);
3818
+ peg$fail(peg$e46);
3671
3819
  }
3672
3820
  }
3673
3821
  if (s1 !== peg$FAILED) {
3674
3822
  s2 = peg$parse_();
3675
3823
  peg$savedPos = s0;
3676
- s0 = peg$f57();
3824
+ s0 = peg$f59();
3677
3825
  } else {
3678
3826
  peg$currPos = s0;
3679
3827
  s0 = peg$FAILED;
@@ -3683,7 +3831,7 @@ function peg$parse(input, options) {
3683
3831
  s1 = peg$parseComment();
3684
3832
  if (s1 !== peg$FAILED) {
3685
3833
  peg$savedPos = s0;
3686
- s1 = peg$f58();
3834
+ s1 = peg$f60();
3687
3835
  }
3688
3836
  s0 = s1;
3689
3837
  }
@@ -3694,13 +3842,13 @@ function peg$parse(input, options) {
3694
3842
  function peg$parseNavGroup() {
3695
3843
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
3696
3844
  s0 = peg$currPos;
3697
- if (input.substr(peg$currPos, 5) === peg$c46) {
3698
- s1 = peg$c46;
3845
+ if (input.substr(peg$currPos, 5) === peg$c48) {
3846
+ s1 = peg$c48;
3699
3847
  peg$currPos += 5;
3700
3848
  } else {
3701
3849
  s1 = peg$FAILED;
3702
3850
  if (peg$silentFails === 0) {
3703
- peg$fail(peg$e46);
3851
+ peg$fail(peg$e48);
3704
3852
  }
3705
3853
  }
3706
3854
  if (s1 !== peg$FAILED) {
@@ -3759,7 +3907,7 @@ function peg$parse(input, options) {
3759
3907
  }
3760
3908
  if (s10 !== peg$FAILED) {
3761
3909
  peg$savedPos = s0;
3762
- s0 = peg$f59(s3, s5, s9);
3910
+ s0 = peg$f61(s3, s5, s9);
3763
3911
  } else {
3764
3912
  peg$currPos = s0;
3765
3913
  s0 = peg$FAILED;
@@ -3783,19 +3931,19 @@ function peg$parse(input, options) {
3783
3931
  s0 = peg$parseNavItem();
3784
3932
  if (s0 === peg$FAILED) {
3785
3933
  s0 = peg$currPos;
3786
- if (input.substr(peg$currPos, 7) === peg$c44) {
3787
- s1 = peg$c44;
3934
+ if (input.substr(peg$currPos, 7) === peg$c46) {
3935
+ s1 = peg$c46;
3788
3936
  peg$currPos += 7;
3789
3937
  } else {
3790
3938
  s1 = peg$FAILED;
3791
3939
  if (peg$silentFails === 0) {
3792
- peg$fail(peg$e44);
3940
+ peg$fail(peg$e46);
3793
3941
  }
3794
3942
  }
3795
3943
  if (s1 !== peg$FAILED) {
3796
3944
  s2 = peg$parse_();
3797
3945
  peg$savedPos = s0;
3798
- s0 = peg$f60();
3946
+ s0 = peg$f62();
3799
3947
  } else {
3800
3948
  peg$currPos = s0;
3801
3949
  s0 = peg$FAILED;
@@ -3805,7 +3953,7 @@ function peg$parse(input, options) {
3805
3953
  s1 = peg$parseComment();
3806
3954
  if (s1 !== peg$FAILED) {
3807
3955
  peg$savedPos = s0;
3808
- s1 = peg$f61();
3956
+ s1 = peg$f63();
3809
3957
  }
3810
3958
  s0 = s1;
3811
3959
  }
@@ -3815,13 +3963,13 @@ function peg$parse(input, options) {
3815
3963
  function peg$parseNavItem() {
3816
3964
  let s0, s1, s2, s3, s4, s5;
3817
3965
  s0 = peg$currPos;
3818
- if (input.substr(peg$currPos, 4) === peg$c36) {
3819
- s1 = peg$c36;
3966
+ if (input.substr(peg$currPos, 4) === peg$c38) {
3967
+ s1 = peg$c38;
3820
3968
  peg$currPos += 4;
3821
3969
  } else {
3822
3970
  s1 = peg$FAILED;
3823
3971
  if (peg$silentFails === 0) {
3824
- peg$fail(peg$e36);
3972
+ peg$fail(peg$e38);
3825
3973
  }
3826
3974
  }
3827
3975
  if (s1 !== peg$FAILED) {
@@ -3834,7 +3982,7 @@ function peg$parse(input, options) {
3834
3982
  s5 = null;
3835
3983
  }
3836
3984
  peg$savedPos = s0;
3837
- s0 = peg$f62(s3, s5);
3985
+ s0 = peg$f64(s3, s5);
3838
3986
  } else {
3839
3987
  peg$currPos = s0;
3840
3988
  s0 = peg$FAILED;
@@ -3848,13 +3996,13 @@ function peg$parse(input, options) {
3848
3996
  function peg$parseTabs() {
3849
3997
  let s0, s1, s2, s3, s4, s5, s6, s7;
3850
3998
  s0 = peg$currPos;
3851
- if (input.substr(peg$currPos, 4) === peg$c47) {
3852
- s1 = peg$c47;
3999
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4000
+ s1 = peg$c49;
3853
4001
  peg$currPos += 4;
3854
4002
  } else {
3855
4003
  s1 = peg$FAILED;
3856
4004
  if (peg$silentFails === 0) {
3857
- peg$fail(peg$e47);
4005
+ peg$fail(peg$e49);
3858
4006
  }
3859
4007
  }
3860
4008
  if (s1 !== peg$FAILED) {
@@ -3874,7 +4022,7 @@ function peg$parse(input, options) {
3874
4022
  s7 = null;
3875
4023
  }
3876
4024
  peg$savedPos = s0;
3877
- s0 = peg$f63(s3, s5, s7);
4025
+ s0 = peg$f65(s3, s5, s7);
3878
4026
  } else {
3879
4027
  peg$currPos = s0;
3880
4028
  s0 = peg$FAILED;
@@ -3930,7 +4078,7 @@ function peg$parse(input, options) {
3930
4078
  }
3931
4079
  if (s4 !== peg$FAILED) {
3932
4080
  peg$savedPos = s0;
3933
- s0 = peg$f64(s3);
4081
+ s0 = peg$f66(s3);
3934
4082
  } else {
3935
4083
  peg$currPos = s0;
3936
4084
  s0 = peg$FAILED;
@@ -3944,13 +4092,13 @@ function peg$parse(input, options) {
3944
4092
  function peg$parseTabItem() {
3945
4093
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11;
3946
4094
  s0 = peg$currPos;
3947
- if (input.substr(peg$currPos, 3) === peg$c48) {
3948
- s1 = peg$c48;
4095
+ if (input.substr(peg$currPos, 3) === peg$c50) {
4096
+ s1 = peg$c50;
3949
4097
  peg$currPos += 3;
3950
4098
  } else {
3951
4099
  s1 = peg$FAILED;
3952
4100
  if (peg$silentFails === 0) {
3953
- peg$fail(peg$e48);
4101
+ peg$fail(peg$e50);
3954
4102
  }
3955
4103
  }
3956
4104
  if (s1 !== peg$FAILED) {
@@ -3988,7 +4136,7 @@ function peg$parse(input, options) {
3988
4136
  }
3989
4137
  if (s11 !== peg$FAILED) {
3990
4138
  peg$savedPos = s0;
3991
- s0 = peg$f65(s3, s5, s9);
4139
+ s0 = peg$f67(s3, s5, s9);
3992
4140
  } else {
3993
4141
  peg$currPos = s0;
3994
4142
  s0 = peg$FAILED;
@@ -4014,7 +4162,7 @@ function peg$parse(input, options) {
4014
4162
  s1 = peg$parseComment();
4015
4163
  if (s1 !== peg$FAILED) {
4016
4164
  peg$savedPos = s0;
4017
- s1 = peg$f66();
4165
+ s1 = peg$f68();
4018
4166
  }
4019
4167
  s0 = s1;
4020
4168
  }
@@ -4023,13 +4171,13 @@ function peg$parse(input, options) {
4023
4171
  function peg$parseBreadcrumb() {
4024
4172
  let s0, s1, s2, s3, s4, s5;
4025
4173
  s0 = peg$currPos;
4026
- if (input.substr(peg$currPos, 10) === peg$c49) {
4027
- s1 = peg$c49;
4174
+ if (input.substr(peg$currPos, 10) === peg$c51) {
4175
+ s1 = peg$c51;
4028
4176
  peg$currPos += 10;
4029
4177
  } else {
4030
4178
  s1 = peg$FAILED;
4031
4179
  if (peg$silentFails === 0) {
4032
- peg$fail(peg$e49);
4180
+ peg$fail(peg$e51);
4033
4181
  }
4034
4182
  }
4035
4183
  if (s1 !== peg$FAILED) {
@@ -4042,7 +4190,7 @@ function peg$parse(input, options) {
4042
4190
  s5 = null;
4043
4191
  }
4044
4192
  peg$savedPos = s0;
4045
- s0 = peg$f67(s3, s5);
4193
+ s0 = peg$f69(s3, s5);
4046
4194
  } else {
4047
4195
  peg$currPos = s0;
4048
4196
  s0 = peg$FAILED;
@@ -4056,13 +4204,13 @@ function peg$parse(input, options) {
4056
4204
  function peg$parseDivider() {
4057
4205
  let s0, s1, s2, s3;
4058
4206
  s0 = peg$currPos;
4059
- if (input.substr(peg$currPos, 7) === peg$c44) {
4060
- s1 = peg$c44;
4207
+ if (input.substr(peg$currPos, 7) === peg$c46) {
4208
+ s1 = peg$c46;
4061
4209
  peg$currPos += 7;
4062
4210
  } else {
4063
4211
  s1 = peg$FAILED;
4064
4212
  if (peg$silentFails === 0) {
4065
- peg$fail(peg$e44);
4213
+ peg$fail(peg$e46);
4066
4214
  }
4067
4215
  }
4068
4216
  if (s1 !== peg$FAILED) {
@@ -4072,7 +4220,7 @@ function peg$parse(input, options) {
4072
4220
  s3 = null;
4073
4221
  }
4074
4222
  peg$savedPos = s0;
4075
- s0 = peg$f68(s3);
4223
+ s0 = peg$f70(s3);
4076
4224
  } else {
4077
4225
  peg$currPos = s0;
4078
4226
  s0 = peg$FAILED;
@@ -4094,7 +4242,7 @@ function peg$parse(input, options) {
4094
4242
  }
4095
4243
  if (s1 !== peg$FAILED) {
4096
4244
  peg$savedPos = s0;
4097
- s1 = peg$f69(s1);
4245
+ s1 = peg$f71(s1);
4098
4246
  }
4099
4247
  s0 = s1;
4100
4248
  return s0;
@@ -4107,12 +4255,12 @@ function peg$parse(input, options) {
4107
4255
  if (s2 !== peg$FAILED) {
4108
4256
  s3 = peg$parse_();
4109
4257
  if (input.charCodeAt(peg$currPos) === 61) {
4110
- s4 = peg$c50;
4258
+ s4 = peg$c52;
4111
4259
  peg$currPos++;
4112
4260
  } else {
4113
4261
  s4 = peg$FAILED;
4114
4262
  if (peg$silentFails === 0) {
4115
- peg$fail(peg$e50);
4263
+ peg$fail(peg$e52);
4116
4264
  }
4117
4265
  }
4118
4266
  if (s4 !== peg$FAILED) {
@@ -4120,7 +4268,7 @@ function peg$parse(input, options) {
4120
4268
  s6 = peg$parseAttributeValue();
4121
4269
  if (s6 !== peg$FAILED) {
4122
4270
  peg$savedPos = s0;
4123
- s0 = peg$f70(s2, s6);
4271
+ s0 = peg$f72(s2, s6);
4124
4272
  } else {
4125
4273
  peg$currPos = s0;
4126
4274
  s0 = peg$FAILED;
@@ -4152,27 +4300,27 @@ function peg$parse(input, options) {
4152
4300
  } else {
4153
4301
  s6 = peg$FAILED;
4154
4302
  if (peg$silentFails === 0) {
4155
- peg$fail(peg$e51);
4303
+ peg$fail(peg$e53);
4156
4304
  }
4157
4305
  }
4158
4306
  if (s6 === peg$FAILED) {
4159
- if (input.substr(peg$currPos, 2) === peg$c51) {
4160
- s6 = peg$c51;
4307
+ if (input.substr(peg$currPos, 2) === peg$c53) {
4308
+ s6 = peg$c53;
4161
4309
  peg$currPos += 2;
4162
4310
  } else {
4163
4311
  s6 = peg$FAILED;
4164
4312
  if (peg$silentFails === 0) {
4165
- peg$fail(peg$e52);
4313
+ peg$fail(peg$e54);
4166
4314
  }
4167
4315
  }
4168
4316
  if (s6 === peg$FAILED) {
4169
- if (input.substr(peg$currPos, 2) === peg$c52) {
4170
- s6 = peg$c52;
4317
+ if (input.substr(peg$currPos, 2) === peg$c54) {
4318
+ s6 = peg$c54;
4171
4319
  peg$currPos += 2;
4172
4320
  } else {
4173
4321
  s6 = peg$FAILED;
4174
4322
  if (peg$silentFails === 0) {
4175
- peg$fail(peg$e53);
4323
+ peg$fail(peg$e55);
4176
4324
  }
4177
4325
  }
4178
4326
  if (s6 === peg$FAILED) {
@@ -4184,7 +4332,7 @@ function peg$parse(input, options) {
4184
4332
  } else {
4185
4333
  s7 = peg$FAILED;
4186
4334
  if (peg$silentFails === 0) {
4187
- peg$fail(peg$e54);
4335
+ peg$fail(peg$e56);
4188
4336
  }
4189
4337
  }
4190
4338
  peg$silentFails--;
@@ -4215,7 +4363,7 @@ function peg$parse(input, options) {
4215
4363
  }
4216
4364
  if (s3 !== peg$FAILED) {
4217
4365
  peg$savedPos = s0;
4218
- s0 = peg$f71(s2);
4366
+ s0 = peg$f73(s2);
4219
4367
  } else {
4220
4368
  peg$currPos = s0;
4221
4369
  s0 = peg$FAILED;
@@ -4244,7 +4392,7 @@ function peg$parse(input, options) {
4244
4392
  s2 = peg$parseIdentifier();
4245
4393
  if (s2 !== peg$FAILED) {
4246
4394
  peg$savedPos = s0;
4247
- s0 = peg$f72(s2);
4395
+ s0 = peg$f74(s2);
4248
4396
  } else {
4249
4397
  peg$currPos = s0;
4250
4398
  s0 = peg$FAILED;
@@ -4328,9 +4476,9 @@ function peg$parse(input, options) {
4328
4476
  }
4329
4477
  }
4330
4478
  if (s1 === peg$FAILED) {
4331
- if (input.substr(peg$currPos, 4) === peg$c9) {
4479
+ if (input.substr(peg$currPos, 5) === peg$c9) {
4332
4480
  s1 = peg$c9;
4333
- peg$currPos += 4;
4481
+ peg$currPos += 5;
4334
4482
  } else {
4335
4483
  s1 = peg$FAILED;
4336
4484
  if (peg$silentFails === 0) {
@@ -4338,9 +4486,9 @@ function peg$parse(input, options) {
4338
4486
  }
4339
4487
  }
4340
4488
  if (s1 === peg$FAILED) {
4341
- if (input.substr(peg$currPos, 5) === peg$c10) {
4489
+ if (input.substr(peg$currPos, 8) === peg$c10) {
4342
4490
  s1 = peg$c10;
4343
- peg$currPos += 5;
4491
+ peg$currPos += 8;
4344
4492
  } else {
4345
4493
  s1 = peg$FAILED;
4346
4494
  if (peg$silentFails === 0) {
@@ -4348,9 +4496,9 @@ function peg$parse(input, options) {
4348
4496
  }
4349
4497
  }
4350
4498
  if (s1 === peg$FAILED) {
4351
- if (input.substr(peg$currPos, 6) === peg$c11) {
4499
+ if (input.substr(peg$currPos, 4) === peg$c11) {
4352
4500
  s1 = peg$c11;
4353
- peg$currPos += 6;
4501
+ peg$currPos += 4;
4354
4502
  } else {
4355
4503
  s1 = peg$FAILED;
4356
4504
  if (peg$silentFails === 0) {
@@ -4358,9 +4506,9 @@ function peg$parse(input, options) {
4358
4506
  }
4359
4507
  }
4360
4508
  if (s1 === peg$FAILED) {
4361
- if (input.substr(peg$currPos, 9) === peg$c12) {
4509
+ if (input.substr(peg$currPos, 5) === peg$c12) {
4362
4510
  s1 = peg$c12;
4363
- peg$currPos += 9;
4511
+ peg$currPos += 5;
4364
4512
  } else {
4365
4513
  s1 = peg$FAILED;
4366
4514
  if (peg$silentFails === 0) {
@@ -4368,9 +4516,9 @@ function peg$parse(input, options) {
4368
4516
  }
4369
4517
  }
4370
4518
  if (s1 === peg$FAILED) {
4371
- if (input.substr(peg$currPos, 7) === peg$c13) {
4519
+ if (input.substr(peg$currPos, 6) === peg$c13) {
4372
4520
  s1 = peg$c13;
4373
- peg$currPos += 7;
4521
+ peg$currPos += 6;
4374
4522
  } else {
4375
4523
  s1 = peg$FAILED;
4376
4524
  if (peg$silentFails === 0) {
@@ -4378,9 +4526,9 @@ function peg$parse(input, options) {
4378
4526
  }
4379
4527
  }
4380
4528
  if (s1 === peg$FAILED) {
4381
- if (input.substr(peg$currPos, 4) === peg$c14) {
4529
+ if (input.substr(peg$currPos, 9) === peg$c14) {
4382
4530
  s1 = peg$c14;
4383
- peg$currPos += 4;
4531
+ peg$currPos += 9;
4384
4532
  } else {
4385
4533
  s1 = peg$FAILED;
4386
4534
  if (peg$silentFails === 0) {
@@ -4388,29 +4536,29 @@ function peg$parse(input, options) {
4388
4536
  }
4389
4537
  }
4390
4538
  if (s1 === peg$FAILED) {
4391
- if (input.substr(peg$currPos, 4) === peg$c16) {
4392
- s1 = peg$c16;
4393
- peg$currPos += 4;
4539
+ if (input.substr(peg$currPos, 7) === peg$c15) {
4540
+ s1 = peg$c15;
4541
+ peg$currPos += 7;
4394
4542
  } else {
4395
4543
  s1 = peg$FAILED;
4396
4544
  if (peg$silentFails === 0) {
4397
- peg$fail(peg$e16);
4545
+ peg$fail(peg$e15);
4398
4546
  }
4399
4547
  }
4400
4548
  if (s1 === peg$FAILED) {
4401
- if (input.substr(peg$currPos, 6) === peg$c17) {
4402
- s1 = peg$c17;
4403
- peg$currPos += 6;
4549
+ if (input.substr(peg$currPos, 4) === peg$c16) {
4550
+ s1 = peg$c16;
4551
+ peg$currPos += 4;
4404
4552
  } else {
4405
4553
  s1 = peg$FAILED;
4406
4554
  if (peg$silentFails === 0) {
4407
- peg$fail(peg$e17);
4555
+ peg$fail(peg$e16);
4408
4556
  }
4409
4557
  }
4410
4558
  if (s1 === peg$FAILED) {
4411
- if (input.substr(peg$currPos, 5) === peg$c18) {
4559
+ if (input.substr(peg$currPos, 4) === peg$c18) {
4412
4560
  s1 = peg$c18;
4413
- peg$currPos += 5;
4561
+ peg$currPos += 4;
4414
4562
  } else {
4415
4563
  s1 = peg$FAILED;
4416
4564
  if (peg$silentFails === 0) {
@@ -4418,9 +4566,9 @@ function peg$parse(input, options) {
4418
4566
  }
4419
4567
  }
4420
4568
  if (s1 === peg$FAILED) {
4421
- if (input.substr(peg$currPos, 8) === peg$c19) {
4569
+ if (input.substr(peg$currPos, 6) === peg$c19) {
4422
4570
  s1 = peg$c19;
4423
- peg$currPos += 8;
4571
+ peg$currPos += 6;
4424
4572
  } else {
4425
4573
  s1 = peg$FAILED;
4426
4574
  if (peg$silentFails === 0) {
@@ -4428,9 +4576,9 @@ function peg$parse(input, options) {
4428
4576
  }
4429
4577
  }
4430
4578
  if (s1 === peg$FAILED) {
4431
- if (input.substr(peg$currPos, 6) === peg$c20) {
4579
+ if (input.substr(peg$currPos, 5) === peg$c20) {
4432
4580
  s1 = peg$c20;
4433
- peg$currPos += 6;
4581
+ peg$currPos += 5;
4434
4582
  } else {
4435
4583
  s1 = peg$FAILED;
4436
4584
  if (peg$silentFails === 0) {
@@ -4448,9 +4596,9 @@ function peg$parse(input, options) {
4448
4596
  }
4449
4597
  }
4450
4598
  if (s1 === peg$FAILED) {
4451
- if (input.substr(peg$currPos, 5) === peg$c22) {
4599
+ if (input.substr(peg$currPos, 6) === peg$c22) {
4452
4600
  s1 = peg$c22;
4453
- peg$currPos += 5;
4601
+ peg$currPos += 6;
4454
4602
  } else {
4455
4603
  s1 = peg$FAILED;
4456
4604
  if (peg$silentFails === 0) {
@@ -4458,9 +4606,9 @@ function peg$parse(input, options) {
4458
4606
  }
4459
4607
  }
4460
4608
  if (s1 === peg$FAILED) {
4461
- if (input.substr(peg$currPos, 6) === peg$c23) {
4609
+ if (input.substr(peg$currPos, 8) === peg$c23) {
4462
4610
  s1 = peg$c23;
4463
- peg$currPos += 6;
4611
+ peg$currPos += 8;
4464
4612
  } else {
4465
4613
  s1 = peg$FAILED;
4466
4614
  if (peg$silentFails === 0) {
@@ -4468,9 +4616,9 @@ function peg$parse(input, options) {
4468
4616
  }
4469
4617
  }
4470
4618
  if (s1 === peg$FAILED) {
4471
- if (input.substr(peg$currPos, 6) === peg$c24) {
4619
+ if (input.substr(peg$currPos, 5) === peg$c24) {
4472
4620
  s1 = peg$c24;
4473
- peg$currPos += 6;
4621
+ peg$currPos += 5;
4474
4622
  } else {
4475
4623
  s1 = peg$FAILED;
4476
4624
  if (peg$silentFails === 0) {
@@ -4478,9 +4626,9 @@ function peg$parse(input, options) {
4478
4626
  }
4479
4627
  }
4480
4628
  if (s1 === peg$FAILED) {
4481
- if (input.substr(peg$currPos, 5) === peg$c25) {
4629
+ if (input.substr(peg$currPos, 6) === peg$c25) {
4482
4630
  s1 = peg$c25;
4483
- peg$currPos += 5;
4631
+ peg$currPos += 6;
4484
4632
  } else {
4485
4633
  s1 = peg$FAILED;
4486
4634
  if (peg$silentFails === 0) {
@@ -4488,59 +4636,59 @@ function peg$parse(input, options) {
4488
4636
  }
4489
4637
  }
4490
4638
  if (s1 === peg$FAILED) {
4491
- if (input.substr(peg$currPos, 6) === peg$c27) {
4492
- s1 = peg$c27;
4639
+ if (input.substr(peg$currPos, 6) === peg$c26) {
4640
+ s1 = peg$c26;
4493
4641
  peg$currPos += 6;
4494
4642
  } else {
4495
4643
  s1 = peg$FAILED;
4496
4644
  if (peg$silentFails === 0) {
4497
- peg$fail(peg$e27);
4645
+ peg$fail(peg$e26);
4498
4646
  }
4499
4647
  }
4500
4648
  if (s1 === peg$FAILED) {
4501
- if (input.substr(peg$currPos, 5) === peg$c28) {
4502
- s1 = peg$c28;
4649
+ if (input.substr(peg$currPos, 5) === peg$c27) {
4650
+ s1 = peg$c27;
4503
4651
  peg$currPos += 5;
4504
4652
  } else {
4505
4653
  s1 = peg$FAILED;
4506
4654
  if (peg$silentFails === 0) {
4507
- peg$fail(peg$e28);
4655
+ peg$fail(peg$e27);
4508
4656
  }
4509
4657
  }
4510
4658
  if (s1 === peg$FAILED) {
4511
- if (input.substr(peg$currPos, 5) === peg$c30) {
4512
- s1 = peg$c30;
4513
- peg$currPos += 5;
4659
+ if (input.substr(peg$currPos, 6) === peg$c29) {
4660
+ s1 = peg$c29;
4661
+ peg$currPos += 6;
4514
4662
  } else {
4515
4663
  s1 = peg$FAILED;
4516
4664
  if (peg$silentFails === 0) {
4517
- peg$fail(peg$e30);
4665
+ peg$fail(peg$e29);
4518
4666
  }
4519
4667
  }
4520
4668
  if (s1 === peg$FAILED) {
4521
- if (input.substr(peg$currPos, 7) === peg$c34) {
4522
- s1 = peg$c34;
4523
- peg$currPos += 7;
4669
+ if (input.substr(peg$currPos, 5) === peg$c30) {
4670
+ s1 = peg$c30;
4671
+ peg$currPos += 5;
4524
4672
  } else {
4525
4673
  s1 = peg$FAILED;
4526
4674
  if (peg$silentFails === 0) {
4527
- peg$fail(peg$e34);
4675
+ peg$fail(peg$e30);
4528
4676
  }
4529
4677
  }
4530
4678
  if (s1 === peg$FAILED) {
4531
- if (input.substr(peg$currPos, 4) === peg$c35) {
4532
- s1 = peg$c35;
4533
- peg$currPos += 4;
4679
+ if (input.substr(peg$currPos, 5) === peg$c32) {
4680
+ s1 = peg$c32;
4681
+ peg$currPos += 5;
4534
4682
  } else {
4535
4683
  s1 = peg$FAILED;
4536
4684
  if (peg$silentFails === 0) {
4537
- peg$fail(peg$e35);
4685
+ peg$fail(peg$e32);
4538
4686
  }
4539
4687
  }
4540
4688
  if (s1 === peg$FAILED) {
4541
- if (input.substr(peg$currPos, 4) === peg$c36) {
4689
+ if (input.substr(peg$currPos, 7) === peg$c36) {
4542
4690
  s1 = peg$c36;
4543
- peg$currPos += 4;
4691
+ peg$currPos += 7;
4544
4692
  } else {
4545
4693
  s1 = peg$FAILED;
4546
4694
  if (peg$silentFails === 0) {
@@ -4548,9 +4696,9 @@ function peg$parse(input, options) {
4548
4696
  }
4549
4697
  }
4550
4698
  if (s1 === peg$FAILED) {
4551
- if (input.substr(peg$currPos, 5) === peg$c37) {
4699
+ if (input.substr(peg$currPos, 4) === peg$c37) {
4552
4700
  s1 = peg$c37;
4553
- peg$currPos += 5;
4701
+ peg$currPos += 4;
4554
4702
  } else {
4555
4703
  s1 = peg$FAILED;
4556
4704
  if (peg$silentFails === 0) {
@@ -4558,9 +4706,9 @@ function peg$parse(input, options) {
4558
4706
  }
4559
4707
  }
4560
4708
  if (s1 === peg$FAILED) {
4561
- if (input.substr(peg$currPos, 5) === peg$c38) {
4709
+ if (input.substr(peg$currPos, 4) === peg$c38) {
4562
4710
  s1 = peg$c38;
4563
- peg$currPos += 5;
4711
+ peg$currPos += 4;
4564
4712
  } else {
4565
4713
  s1 = peg$FAILED;
4566
4714
  if (peg$silentFails === 0) {
@@ -4568,9 +4716,9 @@ function peg$parse(input, options) {
4568
4716
  }
4569
4717
  }
4570
4718
  if (s1 === peg$FAILED) {
4571
- if (input.substr(peg$currPos, 8) === peg$c39) {
4719
+ if (input.substr(peg$currPos, 5) === peg$c39) {
4572
4720
  s1 = peg$c39;
4573
- peg$currPos += 8;
4721
+ peg$currPos += 5;
4574
4722
  } else {
4575
4723
  s1 = peg$FAILED;
4576
4724
  if (peg$silentFails === 0) {
@@ -4578,9 +4726,9 @@ function peg$parse(input, options) {
4578
4726
  }
4579
4727
  }
4580
4728
  if (s1 === peg$FAILED) {
4581
- if (input.substr(peg$currPos, 7) === peg$c40) {
4729
+ if (input.substr(peg$currPos, 5) === peg$c40) {
4582
4730
  s1 = peg$c40;
4583
- peg$currPos += 7;
4731
+ peg$currPos += 5;
4584
4732
  } else {
4585
4733
  s1 = peg$FAILED;
4586
4734
  if (peg$silentFails === 0) {
@@ -4588,9 +4736,9 @@ function peg$parse(input, options) {
4588
4736
  }
4589
4737
  }
4590
4738
  if (s1 === peg$FAILED) {
4591
- if (input.substr(peg$currPos, 7) === peg$c41) {
4739
+ if (input.substr(peg$currPos, 8) === peg$c41) {
4592
4740
  s1 = peg$c41;
4593
- peg$currPos += 7;
4741
+ peg$currPos += 8;
4594
4742
  } else {
4595
4743
  s1 = peg$FAILED;
4596
4744
  if (peg$silentFails === 0) {
@@ -4608,9 +4756,9 @@ function peg$parse(input, options) {
4608
4756
  }
4609
4757
  }
4610
4758
  if (s1 === peg$FAILED) {
4611
- if (input.substr(peg$currPos, 8) === peg$c43) {
4759
+ if (input.substr(peg$currPos, 7) === peg$c43) {
4612
4760
  s1 = peg$c43;
4613
- peg$currPos += 8;
4761
+ peg$currPos += 7;
4614
4762
  } else {
4615
4763
  s1 = peg$FAILED;
4616
4764
  if (peg$silentFails === 0) {
@@ -4628,9 +4776,9 @@ function peg$parse(input, options) {
4628
4776
  }
4629
4777
  }
4630
4778
  if (s1 === peg$FAILED) {
4631
- if (input.substr(peg$currPos, 3) === peg$c45) {
4779
+ if (input.substr(peg$currPos, 8) === peg$c45) {
4632
4780
  s1 = peg$c45;
4633
- peg$currPos += 3;
4781
+ peg$currPos += 8;
4634
4782
  } else {
4635
4783
  s1 = peg$FAILED;
4636
4784
  if (peg$silentFails === 0) {
@@ -4638,29 +4786,29 @@ function peg$parse(input, options) {
4638
4786
  }
4639
4787
  }
4640
4788
  if (s1 === peg$FAILED) {
4641
- if (input.substr(peg$currPos, 4) === peg$c47) {
4642
- s1 = peg$c47;
4643
- peg$currPos += 4;
4789
+ if (input.substr(peg$currPos, 7) === peg$c46) {
4790
+ s1 = peg$c46;
4791
+ peg$currPos += 7;
4644
4792
  } else {
4645
4793
  s1 = peg$FAILED;
4646
4794
  if (peg$silentFails === 0) {
4647
- peg$fail(peg$e47);
4795
+ peg$fail(peg$e46);
4648
4796
  }
4649
4797
  }
4650
4798
  if (s1 === peg$FAILED) {
4651
- if (input.substr(peg$currPos, 3) === peg$c48) {
4652
- s1 = peg$c48;
4799
+ if (input.substr(peg$currPos, 3) === peg$c47) {
4800
+ s1 = peg$c47;
4653
4801
  peg$currPos += 3;
4654
4802
  } else {
4655
4803
  s1 = peg$FAILED;
4656
4804
  if (peg$silentFails === 0) {
4657
- peg$fail(peg$e48);
4805
+ peg$fail(peg$e47);
4658
4806
  }
4659
4807
  }
4660
4808
  if (s1 === peg$FAILED) {
4661
- if (input.substr(peg$currPos, 10) === peg$c49) {
4809
+ if (input.substr(peg$currPos, 4) === peg$c49) {
4662
4810
  s1 = peg$c49;
4663
- peg$currPos += 10;
4811
+ peg$currPos += 4;
4664
4812
  } else {
4665
4813
  s1 = peg$FAILED;
4666
4814
  if (peg$silentFails === 0) {
@@ -4668,13 +4816,35 @@ function peg$parse(input, options) {
4668
4816
  }
4669
4817
  }
4670
4818
  if (s1 === peg$FAILED) {
4671
- if (input.substr(peg$currPos, 5) === peg$c46) {
4672
- s1 = peg$c46;
4673
- peg$currPos += 5;
4819
+ if (input.substr(peg$currPos, 3) === peg$c50) {
4820
+ s1 = peg$c50;
4821
+ peg$currPos += 3;
4674
4822
  } else {
4675
4823
  s1 = peg$FAILED;
4676
4824
  if (peg$silentFails === 0) {
4677
- peg$fail(peg$e46);
4825
+ peg$fail(peg$e50);
4826
+ }
4827
+ }
4828
+ if (s1 === peg$FAILED) {
4829
+ if (input.substr(peg$currPos, 10) === peg$c51) {
4830
+ s1 = peg$c51;
4831
+ peg$currPos += 10;
4832
+ } else {
4833
+ s1 = peg$FAILED;
4834
+ if (peg$silentFails === 0) {
4835
+ peg$fail(peg$e51);
4836
+ }
4837
+ }
4838
+ if (s1 === peg$FAILED) {
4839
+ if (input.substr(peg$currPos, 5) === peg$c48) {
4840
+ s1 = peg$c48;
4841
+ peg$currPos += 5;
4842
+ } else {
4843
+ s1 = peg$FAILED;
4844
+ if (peg$silentFails === 0) {
4845
+ peg$fail(peg$e48);
4846
+ }
4847
+ }
4678
4848
  }
4679
4849
  }
4680
4850
  }
@@ -4750,7 +4920,7 @@ function peg$parse(input, options) {
4750
4920
  } else {
4751
4921
  s0 = peg$FAILED;
4752
4922
  if (peg$silentFails === 0) {
4753
- peg$fail(peg$e55);
4923
+ peg$fail(peg$e57);
4754
4924
  }
4755
4925
  }
4756
4926
  return s0;
@@ -4783,12 +4953,12 @@ function peg$parse(input, options) {
4783
4953
  peg$silentFails++;
4784
4954
  s0 = peg$currPos;
4785
4955
  if (input.charCodeAt(peg$currPos) === 34) {
4786
- s1 = peg$c53;
4956
+ s1 = peg$c55;
4787
4957
  peg$currPos++;
4788
4958
  } else {
4789
4959
  s1 = peg$FAILED;
4790
4960
  if (peg$silentFails === 0) {
4791
- peg$fail(peg$e57);
4961
+ peg$fail(peg$e59);
4792
4962
  }
4793
4963
  }
4794
4964
  if (s1 !== peg$FAILED) {
@@ -4799,17 +4969,17 @@ function peg$parse(input, options) {
4799
4969
  s3 = peg$parseDoubleStringChar();
4800
4970
  }
4801
4971
  if (input.charCodeAt(peg$currPos) === 34) {
4802
- s3 = peg$c53;
4972
+ s3 = peg$c55;
4803
4973
  peg$currPos++;
4804
4974
  } else {
4805
4975
  s3 = peg$FAILED;
4806
4976
  if (peg$silentFails === 0) {
4807
- peg$fail(peg$e57);
4977
+ peg$fail(peg$e59);
4808
4978
  }
4809
4979
  }
4810
4980
  if (s3 !== peg$FAILED) {
4811
4981
  peg$savedPos = s0;
4812
- s0 = peg$f73(s2);
4982
+ s0 = peg$f75(s2);
4813
4983
  } else {
4814
4984
  peg$currPos = s0;
4815
4985
  s0 = peg$FAILED;
@@ -4821,12 +4991,12 @@ function peg$parse(input, options) {
4821
4991
  if (s0 === peg$FAILED) {
4822
4992
  s0 = peg$currPos;
4823
4993
  if (input.charCodeAt(peg$currPos) === 39) {
4824
- s1 = peg$c54;
4994
+ s1 = peg$c56;
4825
4995
  peg$currPos++;
4826
4996
  } else {
4827
4997
  s1 = peg$FAILED;
4828
4998
  if (peg$silentFails === 0) {
4829
- peg$fail(peg$e58);
4999
+ peg$fail(peg$e60);
4830
5000
  }
4831
5001
  }
4832
5002
  if (s1 !== peg$FAILED) {
@@ -4837,17 +5007,17 @@ function peg$parse(input, options) {
4837
5007
  s3 = peg$parseSingleStringChar();
4838
5008
  }
4839
5009
  if (input.charCodeAt(peg$currPos) === 39) {
4840
- s3 = peg$c54;
5010
+ s3 = peg$c56;
4841
5011
  peg$currPos++;
4842
5012
  } else {
4843
5013
  s3 = peg$FAILED;
4844
5014
  if (peg$silentFails === 0) {
4845
- peg$fail(peg$e58);
5015
+ peg$fail(peg$e60);
4846
5016
  }
4847
5017
  }
4848
5018
  if (s3 !== peg$FAILED) {
4849
5019
  peg$savedPos = s0;
4850
- s0 = peg$f74(s2);
5020
+ s0 = peg$f76(s2);
4851
5021
  } else {
4852
5022
  peg$currPos = s0;
4853
5023
  s0 = peg$FAILED;
@@ -4861,7 +5031,7 @@ function peg$parse(input, options) {
4861
5031
  if (s0 === peg$FAILED) {
4862
5032
  s1 = peg$FAILED;
4863
5033
  if (peg$silentFails === 0) {
4864
- peg$fail(peg$e56);
5034
+ peg$fail(peg$e58);
4865
5035
  }
4866
5036
  }
4867
5037
  return s0;
@@ -4872,12 +5042,12 @@ function peg$parse(input, options) {
4872
5042
  s1 = peg$currPos;
4873
5043
  peg$silentFails++;
4874
5044
  if (input.charCodeAt(peg$currPos) === 34) {
4875
- s2 = peg$c53;
5045
+ s2 = peg$c55;
4876
5046
  peg$currPos++;
4877
5047
  } else {
4878
5048
  s2 = peg$FAILED;
4879
5049
  if (peg$silentFails === 0) {
4880
- peg$fail(peg$e57);
5050
+ peg$fail(peg$e59);
4881
5051
  }
4882
5052
  }
4883
5053
  peg$silentFails--;
@@ -4891,12 +5061,12 @@ function peg$parse(input, options) {
4891
5061
  s2 = peg$currPos;
4892
5062
  peg$silentFails++;
4893
5063
  if (input.charCodeAt(peg$currPos) === 92) {
4894
- s3 = peg$c55;
5064
+ s3 = peg$c57;
4895
5065
  peg$currPos++;
4896
5066
  } else {
4897
5067
  s3 = peg$FAILED;
4898
5068
  if (peg$silentFails === 0) {
4899
- peg$fail(peg$e59);
5069
+ peg$fail(peg$e61);
4900
5070
  }
4901
5071
  }
4902
5072
  peg$silentFails--;
@@ -4913,12 +5083,12 @@ function peg$parse(input, options) {
4913
5083
  } else {
4914
5084
  s3 = peg$FAILED;
4915
5085
  if (peg$silentFails === 0) {
4916
- peg$fail(peg$e54);
5086
+ peg$fail(peg$e56);
4917
5087
  }
4918
5088
  }
4919
5089
  if (s3 !== peg$FAILED) {
4920
5090
  peg$savedPos = s0;
4921
- s0 = peg$f75(s3);
5091
+ s0 = peg$f77(s3);
4922
5092
  } else {
4923
5093
  peg$currPos = s0;
4924
5094
  s0 = peg$FAILED;
@@ -4934,19 +5104,19 @@ function peg$parse(input, options) {
4934
5104
  if (s0 === peg$FAILED) {
4935
5105
  s0 = peg$currPos;
4936
5106
  if (input.charCodeAt(peg$currPos) === 92) {
4937
- s1 = peg$c55;
5107
+ s1 = peg$c57;
4938
5108
  peg$currPos++;
4939
5109
  } else {
4940
5110
  s1 = peg$FAILED;
4941
5111
  if (peg$silentFails === 0) {
4942
- peg$fail(peg$e59);
5112
+ peg$fail(peg$e61);
4943
5113
  }
4944
5114
  }
4945
5115
  if (s1 !== peg$FAILED) {
4946
5116
  s2 = peg$parseEscapeSequence();
4947
5117
  if (s2 !== peg$FAILED) {
4948
5118
  peg$savedPos = s0;
4949
- s0 = peg$f76(s2);
5119
+ s0 = peg$f78(s2);
4950
5120
  } else {
4951
5121
  peg$currPos = s0;
4952
5122
  s0 = peg$FAILED;
@@ -4964,12 +5134,12 @@ function peg$parse(input, options) {
4964
5134
  s1 = peg$currPos;
4965
5135
  peg$silentFails++;
4966
5136
  if (input.charCodeAt(peg$currPos) === 39) {
4967
- s2 = peg$c54;
5137
+ s2 = peg$c56;
4968
5138
  peg$currPos++;
4969
5139
  } else {
4970
5140
  s2 = peg$FAILED;
4971
5141
  if (peg$silentFails === 0) {
4972
- peg$fail(peg$e58);
5142
+ peg$fail(peg$e60);
4973
5143
  }
4974
5144
  }
4975
5145
  peg$silentFails--;
@@ -4983,12 +5153,12 @@ function peg$parse(input, options) {
4983
5153
  s2 = peg$currPos;
4984
5154
  peg$silentFails++;
4985
5155
  if (input.charCodeAt(peg$currPos) === 92) {
4986
- s3 = peg$c55;
5156
+ s3 = peg$c57;
4987
5157
  peg$currPos++;
4988
5158
  } else {
4989
5159
  s3 = peg$FAILED;
4990
5160
  if (peg$silentFails === 0) {
4991
- peg$fail(peg$e59);
5161
+ peg$fail(peg$e61);
4992
5162
  }
4993
5163
  }
4994
5164
  peg$silentFails--;
@@ -5005,12 +5175,12 @@ function peg$parse(input, options) {
5005
5175
  } else {
5006
5176
  s3 = peg$FAILED;
5007
5177
  if (peg$silentFails === 0) {
5008
- peg$fail(peg$e54);
5178
+ peg$fail(peg$e56);
5009
5179
  }
5010
5180
  }
5011
5181
  if (s3 !== peg$FAILED) {
5012
5182
  peg$savedPos = s0;
5013
- s0 = peg$f77(s3);
5183
+ s0 = peg$f79(s3);
5014
5184
  } else {
5015
5185
  peg$currPos = s0;
5016
5186
  s0 = peg$FAILED;
@@ -5026,19 +5196,19 @@ function peg$parse(input, options) {
5026
5196
  if (s0 === peg$FAILED) {
5027
5197
  s0 = peg$currPos;
5028
5198
  if (input.charCodeAt(peg$currPos) === 92) {
5029
- s1 = peg$c55;
5199
+ s1 = peg$c57;
5030
5200
  peg$currPos++;
5031
5201
  } else {
5032
5202
  s1 = peg$FAILED;
5033
5203
  if (peg$silentFails === 0) {
5034
- peg$fail(peg$e59);
5204
+ peg$fail(peg$e61);
5035
5205
  }
5036
5206
  }
5037
5207
  if (s1 !== peg$FAILED) {
5038
5208
  s2 = peg$parseEscapeSequence();
5039
5209
  if (s2 !== peg$FAILED) {
5040
5210
  peg$savedPos = s0;
5041
- s0 = peg$f78(s2);
5211
+ s0 = peg$f80(s2);
5042
5212
  } else {
5043
5213
  peg$currPos = s0;
5044
5214
  s0 = peg$FAILED;
@@ -5054,97 +5224,97 @@ function peg$parse(input, options) {
5054
5224
  let s0, s1;
5055
5225
  s0 = peg$currPos;
5056
5226
  if (input.charCodeAt(peg$currPos) === 110) {
5057
- s1 = peg$c56;
5227
+ s1 = peg$c58;
5058
5228
  peg$currPos++;
5059
5229
  } else {
5060
5230
  s1 = peg$FAILED;
5061
5231
  if (peg$silentFails === 0) {
5062
- peg$fail(peg$e60);
5232
+ peg$fail(peg$e62);
5063
5233
  }
5064
5234
  }
5065
5235
  if (s1 !== peg$FAILED) {
5066
5236
  peg$savedPos = s0;
5067
- s1 = peg$f79();
5237
+ s1 = peg$f81();
5068
5238
  }
5069
5239
  s0 = s1;
5070
5240
  if (s0 === peg$FAILED) {
5071
5241
  s0 = peg$currPos;
5072
5242
  if (input.charCodeAt(peg$currPos) === 114) {
5073
- s1 = peg$c57;
5243
+ s1 = peg$c59;
5074
5244
  peg$currPos++;
5075
5245
  } else {
5076
5246
  s1 = peg$FAILED;
5077
5247
  if (peg$silentFails === 0) {
5078
- peg$fail(peg$e61);
5248
+ peg$fail(peg$e63);
5079
5249
  }
5080
5250
  }
5081
5251
  if (s1 !== peg$FAILED) {
5082
5252
  peg$savedPos = s0;
5083
- s1 = peg$f80();
5253
+ s1 = peg$f82();
5084
5254
  }
5085
5255
  s0 = s1;
5086
5256
  if (s0 === peg$FAILED) {
5087
5257
  s0 = peg$currPos;
5088
5258
  if (input.charCodeAt(peg$currPos) === 116) {
5089
- s1 = peg$c58;
5259
+ s1 = peg$c60;
5090
5260
  peg$currPos++;
5091
5261
  } else {
5092
5262
  s1 = peg$FAILED;
5093
5263
  if (peg$silentFails === 0) {
5094
- peg$fail(peg$e62);
5264
+ peg$fail(peg$e64);
5095
5265
  }
5096
5266
  }
5097
5267
  if (s1 !== peg$FAILED) {
5098
5268
  peg$savedPos = s0;
5099
- s1 = peg$f81();
5269
+ s1 = peg$f83();
5100
5270
  }
5101
5271
  s0 = s1;
5102
5272
  if (s0 === peg$FAILED) {
5103
5273
  s0 = peg$currPos;
5104
5274
  if (input.charCodeAt(peg$currPos) === 92) {
5105
- s1 = peg$c55;
5275
+ s1 = peg$c57;
5106
5276
  peg$currPos++;
5107
5277
  } else {
5108
5278
  s1 = peg$FAILED;
5109
5279
  if (peg$silentFails === 0) {
5110
- peg$fail(peg$e59);
5280
+ peg$fail(peg$e61);
5111
5281
  }
5112
5282
  }
5113
5283
  if (s1 !== peg$FAILED) {
5114
5284
  peg$savedPos = s0;
5115
- s1 = peg$f82();
5285
+ s1 = peg$f84();
5116
5286
  }
5117
5287
  s0 = s1;
5118
5288
  if (s0 === peg$FAILED) {
5119
5289
  s0 = peg$currPos;
5120
5290
  if (input.charCodeAt(peg$currPos) === 34) {
5121
- s1 = peg$c53;
5291
+ s1 = peg$c55;
5122
5292
  peg$currPos++;
5123
5293
  } else {
5124
5294
  s1 = peg$FAILED;
5125
5295
  if (peg$silentFails === 0) {
5126
- peg$fail(peg$e57);
5296
+ peg$fail(peg$e59);
5127
5297
  }
5128
5298
  }
5129
5299
  if (s1 !== peg$FAILED) {
5130
5300
  peg$savedPos = s0;
5131
- s1 = peg$f83();
5301
+ s1 = peg$f85();
5132
5302
  }
5133
5303
  s0 = s1;
5134
5304
  if (s0 === peg$FAILED) {
5135
5305
  s0 = peg$currPos;
5136
5306
  if (input.charCodeAt(peg$currPos) === 39) {
5137
- s1 = peg$c54;
5307
+ s1 = peg$c56;
5138
5308
  peg$currPos++;
5139
5309
  } else {
5140
5310
  s1 = peg$FAILED;
5141
5311
  if (peg$silentFails === 0) {
5142
- peg$fail(peg$e58);
5312
+ peg$fail(peg$e60);
5143
5313
  }
5144
5314
  }
5145
5315
  if (s1 !== peg$FAILED) {
5146
5316
  peg$savedPos = s0;
5147
- s1 = peg$f84();
5317
+ s1 = peg$f86();
5148
5318
  }
5149
5319
  s0 = s1;
5150
5320
  }
@@ -5159,12 +5329,12 @@ function peg$parse(input, options) {
5159
5329
  peg$silentFails++;
5160
5330
  s0 = peg$currPos;
5161
5331
  if (input.charCodeAt(peg$currPos) === 45) {
5162
- s1 = peg$c59;
5332
+ s1 = peg$c61;
5163
5333
  peg$currPos++;
5164
5334
  } else {
5165
5335
  s1 = peg$FAILED;
5166
5336
  if (peg$silentFails === 0) {
5167
- peg$fail(peg$e64);
5337
+ peg$fail(peg$e66);
5168
5338
  }
5169
5339
  }
5170
5340
  if (s1 === peg$FAILED) {
@@ -5177,7 +5347,7 @@ function peg$parse(input, options) {
5177
5347
  } else {
5178
5348
  s3 = peg$FAILED;
5179
5349
  if (peg$silentFails === 0) {
5180
- peg$fail(peg$e65);
5350
+ peg$fail(peg$e67);
5181
5351
  }
5182
5352
  }
5183
5353
  if (s3 !== peg$FAILED) {
@@ -5189,7 +5359,7 @@ function peg$parse(input, options) {
5189
5359
  } else {
5190
5360
  s3 = peg$FAILED;
5191
5361
  if (peg$silentFails === 0) {
5192
- peg$fail(peg$e65);
5362
+ peg$fail(peg$e67);
5193
5363
  }
5194
5364
  }
5195
5365
  }
@@ -5199,12 +5369,12 @@ function peg$parse(input, options) {
5199
5369
  if (s2 !== peg$FAILED) {
5200
5370
  s3 = peg$currPos;
5201
5371
  if (input.charCodeAt(peg$currPos) === 46) {
5202
- s4 = peg$c60;
5372
+ s4 = peg$c62;
5203
5373
  peg$currPos++;
5204
5374
  } else {
5205
5375
  s4 = peg$FAILED;
5206
5376
  if (peg$silentFails === 0) {
5207
- peg$fail(peg$e66);
5377
+ peg$fail(peg$e68);
5208
5378
  }
5209
5379
  }
5210
5380
  if (s4 !== peg$FAILED) {
@@ -5215,7 +5385,7 @@ function peg$parse(input, options) {
5215
5385
  } else {
5216
5386
  s6 = peg$FAILED;
5217
5387
  if (peg$silentFails === 0) {
5218
- peg$fail(peg$e65);
5388
+ peg$fail(peg$e67);
5219
5389
  }
5220
5390
  }
5221
5391
  if (s6 !== peg$FAILED) {
@@ -5227,7 +5397,7 @@ function peg$parse(input, options) {
5227
5397
  } else {
5228
5398
  s6 = peg$FAILED;
5229
5399
  if (peg$silentFails === 0) {
5230
- peg$fail(peg$e65);
5400
+ peg$fail(peg$e67);
5231
5401
  }
5232
5402
  }
5233
5403
  }
@@ -5249,7 +5419,7 @@ function peg$parse(input, options) {
5249
5419
  s3 = null;
5250
5420
  }
5251
5421
  peg$savedPos = s0;
5252
- s0 = peg$f85(s1, s2, s3);
5422
+ s0 = peg$f87(s1, s2, s3);
5253
5423
  } else {
5254
5424
  peg$currPos = s0;
5255
5425
  s0 = peg$FAILED;
@@ -5258,7 +5428,7 @@ function peg$parse(input, options) {
5258
5428
  if (s0 === peg$FAILED) {
5259
5429
  s1 = peg$FAILED;
5260
5430
  if (peg$silentFails === 0) {
5261
- peg$fail(peg$e63);
5431
+ peg$fail(peg$e65);
5262
5432
  }
5263
5433
  }
5264
5434
  return s0;
@@ -5268,12 +5438,12 @@ function peg$parse(input, options) {
5268
5438
  peg$silentFails++;
5269
5439
  s0 = peg$currPos;
5270
5440
  if (input.charCodeAt(peg$currPos) === 45) {
5271
- s1 = peg$c59;
5441
+ s1 = peg$c61;
5272
5442
  peg$currPos++;
5273
5443
  } else {
5274
5444
  s1 = peg$FAILED;
5275
5445
  if (peg$silentFails === 0) {
5276
- peg$fail(peg$e64);
5446
+ peg$fail(peg$e66);
5277
5447
  }
5278
5448
  }
5279
5449
  if (s1 === peg$FAILED) {
@@ -5286,7 +5456,7 @@ function peg$parse(input, options) {
5286
5456
  } else {
5287
5457
  s3 = peg$FAILED;
5288
5458
  if (peg$silentFails === 0) {
5289
- peg$fail(peg$e65);
5459
+ peg$fail(peg$e67);
5290
5460
  }
5291
5461
  }
5292
5462
  if (s3 !== peg$FAILED) {
@@ -5298,7 +5468,7 @@ function peg$parse(input, options) {
5298
5468
  } else {
5299
5469
  s3 = peg$FAILED;
5300
5470
  if (peg$silentFails === 0) {
5301
- peg$fail(peg$e65);
5471
+ peg$fail(peg$e67);
5302
5472
  }
5303
5473
  }
5304
5474
  }
@@ -5308,12 +5478,12 @@ function peg$parse(input, options) {
5308
5478
  if (s2 !== peg$FAILED) {
5309
5479
  s3 = peg$currPos;
5310
5480
  if (input.charCodeAt(peg$currPos) === 46) {
5311
- s4 = peg$c60;
5481
+ s4 = peg$c62;
5312
5482
  peg$currPos++;
5313
5483
  } else {
5314
5484
  s4 = peg$FAILED;
5315
5485
  if (peg$silentFails === 0) {
5316
- peg$fail(peg$e66);
5486
+ peg$fail(peg$e68);
5317
5487
  }
5318
5488
  }
5319
5489
  if (s4 !== peg$FAILED) {
@@ -5324,7 +5494,7 @@ function peg$parse(input, options) {
5324
5494
  } else {
5325
5495
  s6 = peg$FAILED;
5326
5496
  if (peg$silentFails === 0) {
5327
- peg$fail(peg$e65);
5497
+ peg$fail(peg$e67);
5328
5498
  }
5329
5499
  }
5330
5500
  if (s6 !== peg$FAILED) {
@@ -5336,7 +5506,7 @@ function peg$parse(input, options) {
5336
5506
  } else {
5337
5507
  s6 = peg$FAILED;
5338
5508
  if (peg$silentFails === 0) {
5339
- peg$fail(peg$e65);
5509
+ peg$fail(peg$e67);
5340
5510
  }
5341
5511
  }
5342
5512
  }
@@ -5357,63 +5527,63 @@ function peg$parse(input, options) {
5357
5527
  if (s3 === peg$FAILED) {
5358
5528
  s3 = null;
5359
5529
  }
5360
- if (input.substr(peg$currPos, 2) === peg$c61) {
5361
- s4 = peg$c61;
5530
+ if (input.substr(peg$currPos, 2) === peg$c63) {
5531
+ s4 = peg$c63;
5362
5532
  peg$currPos += 2;
5363
5533
  } else {
5364
5534
  s4 = peg$FAILED;
5365
5535
  if (peg$silentFails === 0) {
5366
- peg$fail(peg$e68);
5536
+ peg$fail(peg$e70);
5367
5537
  }
5368
5538
  }
5369
5539
  if (s4 === peg$FAILED) {
5370
5540
  if (input.charCodeAt(peg$currPos) === 37) {
5371
- s4 = peg$c62;
5541
+ s4 = peg$c64;
5372
5542
  peg$currPos++;
5373
5543
  } else {
5374
5544
  s4 = peg$FAILED;
5375
5545
  if (peg$silentFails === 0) {
5376
- peg$fail(peg$e69);
5546
+ peg$fail(peg$e71);
5377
5547
  }
5378
5548
  }
5379
5549
  if (s4 === peg$FAILED) {
5380
- if (input.substr(peg$currPos, 2) === peg$c63) {
5381
- s4 = peg$c63;
5550
+ if (input.substr(peg$currPos, 2) === peg$c65) {
5551
+ s4 = peg$c65;
5382
5552
  peg$currPos += 2;
5383
5553
  } else {
5384
5554
  s4 = peg$FAILED;
5385
5555
  if (peg$silentFails === 0) {
5386
- peg$fail(peg$e70);
5556
+ peg$fail(peg$e72);
5387
5557
  }
5388
5558
  }
5389
5559
  if (s4 === peg$FAILED) {
5390
- if (input.substr(peg$currPos, 3) === peg$c64) {
5391
- s4 = peg$c64;
5560
+ if (input.substr(peg$currPos, 3) === peg$c66) {
5561
+ s4 = peg$c66;
5392
5562
  peg$currPos += 3;
5393
5563
  } else {
5394
5564
  s4 = peg$FAILED;
5395
5565
  if (peg$silentFails === 0) {
5396
- peg$fail(peg$e71);
5566
+ peg$fail(peg$e73);
5397
5567
  }
5398
5568
  }
5399
5569
  if (s4 === peg$FAILED) {
5400
- if (input.substr(peg$currPos, 2) === peg$c65) {
5401
- s4 = peg$c65;
5570
+ if (input.substr(peg$currPos, 2) === peg$c67) {
5571
+ s4 = peg$c67;
5402
5572
  peg$currPos += 2;
5403
5573
  } else {
5404
5574
  s4 = peg$FAILED;
5405
5575
  if (peg$silentFails === 0) {
5406
- peg$fail(peg$e72);
5576
+ peg$fail(peg$e74);
5407
5577
  }
5408
5578
  }
5409
5579
  if (s4 === peg$FAILED) {
5410
- if (input.substr(peg$currPos, 2) === peg$c66) {
5411
- s4 = peg$c66;
5580
+ if (input.substr(peg$currPos, 2) === peg$c68) {
5581
+ s4 = peg$c68;
5412
5582
  peg$currPos += 2;
5413
5583
  } else {
5414
5584
  s4 = peg$FAILED;
5415
5585
  if (peg$silentFails === 0) {
5416
- peg$fail(peg$e73);
5586
+ peg$fail(peg$e75);
5417
5587
  }
5418
5588
  }
5419
5589
  }
@@ -5423,7 +5593,7 @@ function peg$parse(input, options) {
5423
5593
  }
5424
5594
  if (s4 !== peg$FAILED) {
5425
5595
  peg$savedPos = s0;
5426
- s0 = peg$f86(s1, s2, s3, s4);
5596
+ s0 = peg$f88(s1, s2, s3, s4);
5427
5597
  } else {
5428
5598
  peg$currPos = s0;
5429
5599
  s0 = peg$FAILED;
@@ -5436,7 +5606,7 @@ function peg$parse(input, options) {
5436
5606
  if (s0 === peg$FAILED) {
5437
5607
  s1 = peg$FAILED;
5438
5608
  if (peg$silentFails === 0) {
5439
- peg$fail(peg$e67);
5609
+ peg$fail(peg$e69);
5440
5610
  }
5441
5611
  }
5442
5612
  return s0;
@@ -5445,34 +5615,34 @@ function peg$parse(input, options) {
5445
5615
  let s0, s1;
5446
5616
  peg$silentFails++;
5447
5617
  s0 = peg$currPos;
5448
- if (input.substr(peg$currPos, 4) === peg$c67) {
5449
- s1 = peg$c67;
5618
+ if (input.substr(peg$currPos, 4) === peg$c69) {
5619
+ s1 = peg$c69;
5450
5620
  peg$currPos += 4;
5451
5621
  } else {
5452
5622
  s1 = peg$FAILED;
5453
5623
  if (peg$silentFails === 0) {
5454
- peg$fail(peg$e75);
5624
+ peg$fail(peg$e77);
5455
5625
  }
5456
5626
  }
5457
5627
  if (s1 !== peg$FAILED) {
5458
5628
  peg$savedPos = s0;
5459
- s1 = peg$f87();
5629
+ s1 = peg$f89();
5460
5630
  }
5461
5631
  s0 = s1;
5462
5632
  if (s0 === peg$FAILED) {
5463
5633
  s0 = peg$currPos;
5464
- if (input.substr(peg$currPos, 5) === peg$c68) {
5465
- s1 = peg$c68;
5634
+ if (input.substr(peg$currPos, 5) === peg$c70) {
5635
+ s1 = peg$c70;
5466
5636
  peg$currPos += 5;
5467
5637
  } else {
5468
5638
  s1 = peg$FAILED;
5469
5639
  if (peg$silentFails === 0) {
5470
- peg$fail(peg$e76);
5640
+ peg$fail(peg$e78);
5471
5641
  }
5472
5642
  }
5473
5643
  if (s1 !== peg$FAILED) {
5474
5644
  peg$savedPos = s0;
5475
- s1 = peg$f88();
5645
+ s1 = peg$f90();
5476
5646
  }
5477
5647
  s0 = s1;
5478
5648
  }
@@ -5480,7 +5650,7 @@ function peg$parse(input, options) {
5480
5650
  if (s0 === peg$FAILED) {
5481
5651
  s1 = peg$FAILED;
5482
5652
  if (peg$silentFails === 0) {
5483
- peg$fail(peg$e74);
5653
+ peg$fail(peg$e76);
5484
5654
  }
5485
5655
  }
5486
5656
  return s0;
@@ -5495,7 +5665,7 @@ function peg$parse(input, options) {
5495
5665
  } else {
5496
5666
  s1 = peg$FAILED;
5497
5667
  if (peg$silentFails === 0) {
5498
- peg$fail(peg$e78);
5668
+ peg$fail(peg$e80);
5499
5669
  }
5500
5670
  }
5501
5671
  if (s1 !== peg$FAILED) {
@@ -5506,7 +5676,7 @@ function peg$parse(input, options) {
5506
5676
  } else {
5507
5677
  s3 = peg$FAILED;
5508
5678
  if (peg$silentFails === 0) {
5509
- peg$fail(peg$e55);
5679
+ peg$fail(peg$e57);
5510
5680
  }
5511
5681
  }
5512
5682
  while (s3 !== peg$FAILED) {
@@ -5517,12 +5687,12 @@ function peg$parse(input, options) {
5517
5687
  } else {
5518
5688
  s3 = peg$FAILED;
5519
5689
  if (peg$silentFails === 0) {
5520
- peg$fail(peg$e55);
5690
+ peg$fail(peg$e57);
5521
5691
  }
5522
5692
  }
5523
5693
  }
5524
5694
  peg$savedPos = s0;
5525
- s0 = peg$f89(s1, s2);
5695
+ s0 = peg$f91(s1, s2);
5526
5696
  } else {
5527
5697
  peg$currPos = s0;
5528
5698
  s0 = peg$FAILED;
@@ -5531,7 +5701,7 @@ function peg$parse(input, options) {
5531
5701
  if (s0 === peg$FAILED) {
5532
5702
  s1 = peg$FAILED;
5533
5703
  if (peg$silentFails === 0) {
5534
- peg$fail(peg$e77);
5704
+ peg$fail(peg$e79);
5535
5705
  }
5536
5706
  }
5537
5707
  return s0;
@@ -5540,12 +5710,12 @@ function peg$parse(input, options) {
5540
5710
  let s0, s1, s2, s3, s4, s5;
5541
5711
  s0 = peg$currPos;
5542
5712
  if (input.charCodeAt(peg$currPos) === 91) {
5543
- s1 = peg$c31;
5713
+ s1 = peg$c33;
5544
5714
  peg$currPos++;
5545
5715
  } else {
5546
5716
  s1 = peg$FAILED;
5547
5717
  if (peg$silentFails === 0) {
5548
- peg$fail(peg$e31);
5718
+ peg$fail(peg$e33);
5549
5719
  }
5550
5720
  }
5551
5721
  if (s1 !== peg$FAILED) {
@@ -5556,17 +5726,17 @@ function peg$parse(input, options) {
5556
5726
  }
5557
5727
  s4 = peg$parse_();
5558
5728
  if (input.charCodeAt(peg$currPos) === 93) {
5559
- s5 = peg$c33;
5729
+ s5 = peg$c35;
5560
5730
  peg$currPos++;
5561
5731
  } else {
5562
5732
  s5 = peg$FAILED;
5563
5733
  if (peg$silentFails === 0) {
5564
- peg$fail(peg$e33);
5734
+ peg$fail(peg$e35);
5565
5735
  }
5566
5736
  }
5567
5737
  if (s5 !== peg$FAILED) {
5568
5738
  peg$savedPos = s0;
5569
- s0 = peg$f90(s3);
5739
+ s0 = peg$f92(s3);
5570
5740
  } else {
5571
5741
  peg$currPos = s0;
5572
5742
  s0 = peg$FAILED;
@@ -5586,12 +5756,12 @@ function peg$parse(input, options) {
5586
5756
  s3 = peg$currPos;
5587
5757
  s4 = peg$parse_();
5588
5758
  if (input.charCodeAt(peg$currPos) === 44) {
5589
- s5 = peg$c32;
5759
+ s5 = peg$c34;
5590
5760
  peg$currPos++;
5591
5761
  } else {
5592
5762
  s5 = peg$FAILED;
5593
5763
  if (peg$silentFails === 0) {
5594
- peg$fail(peg$e32);
5764
+ peg$fail(peg$e34);
5595
5765
  }
5596
5766
  }
5597
5767
  if (s5 === peg$FAILED) {
@@ -5611,12 +5781,12 @@ function peg$parse(input, options) {
5611
5781
  s3 = peg$currPos;
5612
5782
  s4 = peg$parse_();
5613
5783
  if (input.charCodeAt(peg$currPos) === 44) {
5614
- s5 = peg$c32;
5784
+ s5 = peg$c34;
5615
5785
  peg$currPos++;
5616
5786
  } else {
5617
5787
  s5 = peg$FAILED;
5618
5788
  if (peg$silentFails === 0) {
5619
- peg$fail(peg$e32);
5789
+ peg$fail(peg$e34);
5620
5790
  }
5621
5791
  }
5622
5792
  if (s5 === peg$FAILED) {
@@ -5635,12 +5805,12 @@ function peg$parse(input, options) {
5635
5805
  s3 = peg$currPos;
5636
5806
  s4 = peg$parse_();
5637
5807
  if (input.charCodeAt(peg$currPos) === 44) {
5638
- s5 = peg$c32;
5808
+ s5 = peg$c34;
5639
5809
  peg$currPos++;
5640
5810
  } else {
5641
5811
  s5 = peg$FAILED;
5642
5812
  if (peg$silentFails === 0) {
5643
- peg$fail(peg$e32);
5813
+ peg$fail(peg$e34);
5644
5814
  }
5645
5815
  }
5646
5816
  if (s5 !== peg$FAILED) {
@@ -5654,7 +5824,7 @@ function peg$parse(input, options) {
5654
5824
  s3 = null;
5655
5825
  }
5656
5826
  peg$savedPos = s0;
5657
- s0 = peg$f91(s1, s2);
5827
+ s0 = peg$f93(s1, s2);
5658
5828
  } else {
5659
5829
  peg$currPos = s0;
5660
5830
  s0 = peg$FAILED;
@@ -5708,7 +5878,7 @@ function peg$parse(input, options) {
5708
5878
  }
5709
5879
  if (s5 !== peg$FAILED) {
5710
5880
  peg$savedPos = s0;
5711
- s0 = peg$f92(s3);
5881
+ s0 = peg$f94(s3);
5712
5882
  } else {
5713
5883
  peg$currPos = s0;
5714
5884
  s0 = peg$FAILED;
@@ -5728,12 +5898,12 @@ function peg$parse(input, options) {
5728
5898
  s3 = peg$currPos;
5729
5899
  s4 = peg$parse_();
5730
5900
  if (input.charCodeAt(peg$currPos) === 44) {
5731
- s5 = peg$c32;
5901
+ s5 = peg$c34;
5732
5902
  peg$currPos++;
5733
5903
  } else {
5734
5904
  s5 = peg$FAILED;
5735
5905
  if (peg$silentFails === 0) {
5736
- peg$fail(peg$e32);
5906
+ peg$fail(peg$e34);
5737
5907
  }
5738
5908
  }
5739
5909
  if (s5 === peg$FAILED) {
@@ -5753,12 +5923,12 @@ function peg$parse(input, options) {
5753
5923
  s3 = peg$currPos;
5754
5924
  s4 = peg$parse_();
5755
5925
  if (input.charCodeAt(peg$currPos) === 44) {
5756
- s5 = peg$c32;
5926
+ s5 = peg$c34;
5757
5927
  peg$currPos++;
5758
5928
  } else {
5759
5929
  s5 = peg$FAILED;
5760
5930
  if (peg$silentFails === 0) {
5761
- peg$fail(peg$e32);
5931
+ peg$fail(peg$e34);
5762
5932
  }
5763
5933
  }
5764
5934
  if (s5 === peg$FAILED) {
@@ -5775,7 +5945,7 @@ function peg$parse(input, options) {
5775
5945
  }
5776
5946
  }
5777
5947
  peg$savedPos = s0;
5778
- s0 = peg$f93(s1, s2);
5948
+ s0 = peg$f95(s1, s2);
5779
5949
  } else {
5780
5950
  peg$currPos = s0;
5781
5951
  s0 = peg$FAILED;
@@ -5789,12 +5959,12 @@ function peg$parse(input, options) {
5789
5959
  if (s1 !== peg$FAILED) {
5790
5960
  s2 = peg$parse_();
5791
5961
  if (input.charCodeAt(peg$currPos) === 61) {
5792
- s3 = peg$c50;
5962
+ s3 = peg$c52;
5793
5963
  peg$currPos++;
5794
5964
  } else {
5795
5965
  s3 = peg$FAILED;
5796
5966
  if (peg$silentFails === 0) {
5797
- peg$fail(peg$e50);
5967
+ peg$fail(peg$e52);
5798
5968
  }
5799
5969
  }
5800
5970
  if (s3 !== peg$FAILED) {
@@ -5802,7 +5972,7 @@ function peg$parse(input, options) {
5802
5972
  s5 = peg$parseAttributeValue();
5803
5973
  if (s5 !== peg$FAILED) {
5804
5974
  peg$savedPos = s0;
5805
- s0 = peg$f94(s1, s5);
5975
+ s0 = peg$f96(s1, s5);
5806
5976
  } else {
5807
5977
  peg$currPos = s0;
5808
5978
  s0 = peg$FAILED;
@@ -5820,7 +5990,7 @@ function peg$parse(input, options) {
5820
5990
  s1 = peg$parseIdentifier();
5821
5991
  if (s1 !== peg$FAILED) {
5822
5992
  peg$savedPos = s0;
5823
- s1 = peg$f95(s1);
5993
+ s1 = peg$f97(s1);
5824
5994
  }
5825
5995
  s0 = s1;
5826
5996
  }
@@ -5853,7 +6023,7 @@ function peg$parse(input, options) {
5853
6023
  } else {
5854
6024
  s1 = peg$FAILED;
5855
6025
  if (peg$silentFails === 0) {
5856
- peg$fail(peg$e79);
6026
+ peg$fail(peg$e81);
5857
6027
  }
5858
6028
  }
5859
6029
  if (s1 !== peg$FAILED) {
@@ -5865,7 +6035,7 @@ function peg$parse(input, options) {
5865
6035
  } else {
5866
6036
  s1 = peg$FAILED;
5867
6037
  if (peg$silentFails === 0) {
5868
- peg$fail(peg$e79);
6038
+ peg$fail(peg$e81);
5869
6039
  }
5870
6040
  }
5871
6041
  }
@@ -5885,7 +6055,7 @@ function peg$parse(input, options) {
5885
6055
  if (s0 === peg$FAILED) {
5886
6056
  s1 = peg$FAILED;
5887
6057
  if (peg$silentFails === 0) {
5888
- peg$fail(peg$e80);
6058
+ peg$fail(peg$e82);
5889
6059
  }
5890
6060
  }
5891
6061
  return s0;
@@ -5893,13 +6063,13 @@ function peg$parse(input, options) {
5893
6063
  function peg$parseLineComment() {
5894
6064
  let s0, s1, s2, s3, s4;
5895
6065
  s0 = peg$currPos;
5896
- if (input.substr(peg$currPos, 2) === peg$c51) {
5897
- s1 = peg$c51;
6066
+ if (input.substr(peg$currPos, 2) === peg$c53) {
6067
+ s1 = peg$c53;
5898
6068
  peg$currPos += 2;
5899
6069
  } else {
5900
6070
  s1 = peg$FAILED;
5901
6071
  if (peg$silentFails === 0) {
5902
- peg$fail(peg$e52);
6072
+ peg$fail(peg$e54);
5903
6073
  }
5904
6074
  }
5905
6075
  if (s1 !== peg$FAILED) {
@@ -5910,7 +6080,7 @@ function peg$parse(input, options) {
5910
6080
  } else {
5911
6081
  s3 = peg$FAILED;
5912
6082
  if (peg$silentFails === 0) {
5913
- peg$fail(peg$e81);
6083
+ peg$fail(peg$e83);
5914
6084
  }
5915
6085
  }
5916
6086
  while (s3 !== peg$FAILED) {
@@ -5921,17 +6091,17 @@ function peg$parse(input, options) {
5921
6091
  } else {
5922
6092
  s3 = peg$FAILED;
5923
6093
  if (peg$silentFails === 0) {
5924
- peg$fail(peg$e81);
6094
+ peg$fail(peg$e83);
5925
6095
  }
5926
6096
  }
5927
6097
  }
5928
6098
  if (input.charCodeAt(peg$currPos) === 10) {
5929
- s3 = peg$c69;
6099
+ s3 = peg$c71;
5930
6100
  peg$currPos++;
5931
6101
  } else {
5932
6102
  s3 = peg$FAILED;
5933
6103
  if (peg$silentFails === 0) {
5934
- peg$fail(peg$e82);
6104
+ peg$fail(peg$e84);
5935
6105
  }
5936
6106
  }
5937
6107
  if (s3 === peg$FAILED) {
@@ -5943,7 +6113,7 @@ function peg$parse(input, options) {
5943
6113
  } else {
5944
6114
  s4 = peg$FAILED;
5945
6115
  if (peg$silentFails === 0) {
5946
- peg$fail(peg$e54);
6116
+ peg$fail(peg$e56);
5947
6117
  }
5948
6118
  }
5949
6119
  peg$silentFails--;
@@ -5970,13 +6140,13 @@ function peg$parse(input, options) {
5970
6140
  function peg$parseBlockComment() {
5971
6141
  let s0, s1, s2, s3, s4, s5;
5972
6142
  s0 = peg$currPos;
5973
- if (input.substr(peg$currPos, 2) === peg$c52) {
5974
- s1 = peg$c52;
6143
+ if (input.substr(peg$currPos, 2) === peg$c54) {
6144
+ s1 = peg$c54;
5975
6145
  peg$currPos += 2;
5976
6146
  } else {
5977
6147
  s1 = peg$FAILED;
5978
6148
  if (peg$silentFails === 0) {
5979
- peg$fail(peg$e53);
6149
+ peg$fail(peg$e55);
5980
6150
  }
5981
6151
  }
5982
6152
  if (s1 !== peg$FAILED) {
@@ -5984,13 +6154,13 @@ function peg$parse(input, options) {
5984
6154
  s3 = peg$currPos;
5985
6155
  s4 = peg$currPos;
5986
6156
  peg$silentFails++;
5987
- if (input.substr(peg$currPos, 2) === peg$c70) {
5988
- s5 = peg$c70;
6157
+ if (input.substr(peg$currPos, 2) === peg$c72) {
6158
+ s5 = peg$c72;
5989
6159
  peg$currPos += 2;
5990
6160
  } else {
5991
6161
  s5 = peg$FAILED;
5992
6162
  if (peg$silentFails === 0) {
5993
- peg$fail(peg$e83);
6163
+ peg$fail(peg$e85);
5994
6164
  }
5995
6165
  }
5996
6166
  peg$silentFails--;
@@ -6007,7 +6177,7 @@ function peg$parse(input, options) {
6007
6177
  } else {
6008
6178
  s5 = peg$FAILED;
6009
6179
  if (peg$silentFails === 0) {
6010
- peg$fail(peg$e54);
6180
+ peg$fail(peg$e56);
6011
6181
  }
6012
6182
  }
6013
6183
  if (s5 !== peg$FAILED) {
@@ -6026,13 +6196,13 @@ function peg$parse(input, options) {
6026
6196
  s3 = peg$currPos;
6027
6197
  s4 = peg$currPos;
6028
6198
  peg$silentFails++;
6029
- if (input.substr(peg$currPos, 2) === peg$c70) {
6030
- s5 = peg$c70;
6199
+ if (input.substr(peg$currPos, 2) === peg$c72) {
6200
+ s5 = peg$c72;
6031
6201
  peg$currPos += 2;
6032
6202
  } else {
6033
6203
  s5 = peg$FAILED;
6034
6204
  if (peg$silentFails === 0) {
6035
- peg$fail(peg$e83);
6205
+ peg$fail(peg$e85);
6036
6206
  }
6037
6207
  }
6038
6208
  peg$silentFails--;
@@ -6049,7 +6219,7 @@ function peg$parse(input, options) {
6049
6219
  } else {
6050
6220
  s5 = peg$FAILED;
6051
6221
  if (peg$silentFails === 0) {
6052
- peg$fail(peg$e54);
6222
+ peg$fail(peg$e56);
6053
6223
  }
6054
6224
  }
6055
6225
  if (s5 !== peg$FAILED) {
@@ -6064,13 +6234,13 @@ function peg$parse(input, options) {
6064
6234
  s3 = peg$FAILED;
6065
6235
  }
6066
6236
  }
6067
- if (input.substr(peg$currPos, 2) === peg$c70) {
6068
- s3 = peg$c70;
6237
+ if (input.substr(peg$currPos, 2) === peg$c72) {
6238
+ s3 = peg$c72;
6069
6239
  peg$currPos += 2;
6070
6240
  } else {
6071
6241
  s3 = peg$FAILED;
6072
6242
  if (peg$silentFails === 0) {
6073
- peg$fail(peg$e83);
6243
+ peg$fail(peg$e85);
6074
6244
  }
6075
6245
  }
6076
6246
  if (s3 !== peg$FAILED) {
@@ -7626,11 +7796,36 @@ function generateGridClasses(_theme, prefix) {
7626
7796
  }
7627
7797
 
7628
7798
  /* When explicit width is set, don't flex-grow */
7629
- .${prefix}-row[style*="width:"],
7630
- .${prefix}-col[style*="width:"] {
7799
+ .${prefix}-row[style*="width"],
7800
+ .${prefix}-col[style*="width"] {
7801
+ flex: 0 0 auto;
7802
+ }
7803
+
7804
+ /* Stack - vertical content grouping (does not fill available space) */
7805
+ .${prefix}-stack {
7806
+ display: flex;
7807
+ flex-direction: column;
7631
7808
  flex: 0 0 auto;
7809
+ box-sizing: border-box;
7810
+ }
7811
+
7812
+ /* Relative - container for absolute positioning children */
7813
+ .${prefix}-relative {
7814
+ position: relative;
7815
+ display: inline-flex;
7632
7816
  }
7633
7817
 
7818
+ /* Anchor positioning for relative container children */
7819
+ .${prefix}-anchor-top-left { position: absolute; top: -4px; left: -4px; }
7820
+ .${prefix}-anchor-top-center { position: absolute; top: -4px; left: 50%; transform: translateX(-50%); }
7821
+ .${prefix}-anchor-top-right { position: absolute; top: -4px; right: -4px; }
7822
+ .${prefix}-anchor-center-left { position: absolute; top: 50%; left: -4px; transform: translateY(-50%); }
7823
+ .${prefix}-anchor-center { position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); }
7824
+ .${prefix}-anchor-center-right { position: absolute; top: 50%; right: -4px; transform: translateY(-50%); }
7825
+ .${prefix}-anchor-bottom-left { position: absolute; bottom: -4px; left: -4px; }
7826
+ .${prefix}-anchor-bottom-center { position: absolute; bottom: -4px; left: 50%; transform: translateX(-50%); }
7827
+ .${prefix}-anchor-bottom-right { position: absolute; bottom: -4px; right: -4px; }
7828
+
7634
7829
  `;
7635
7830
  for (let i = 1; i <= 12; i++) {
7636
7831
  css += `.${prefix}-col-${i} { flex: ${i} 0 0%; min-width: 0; }
@@ -8253,6 +8448,30 @@ function renderCol(node, ctx) {
8253
8448
  ${children}
8254
8449
  </div>`;
8255
8450
  }
8451
+ function renderStack(node, ctx) {
8452
+ const classes = ctx.buildClassString([
8453
+ `${ctx.prefix}-stack`,
8454
+ ...ctx.getCommonClasses(node)
8455
+ ]);
8456
+ const styles = ctx.buildCommonStyles(node);
8457
+ const styleAttr = styles ? ` style="${styles}"` : "";
8458
+ const children = ctx.renderChildren(node.children);
8459
+ return `<div class="${classes}"${styleAttr}>
8460
+ ${children}
8461
+ </div>`;
8462
+ }
8463
+ function renderRelative(node, ctx) {
8464
+ const classes = ctx.buildClassString([
8465
+ `${ctx.prefix}-relative`,
8466
+ ...ctx.getCommonClasses(node)
8467
+ ]);
8468
+ const styles = ctx.buildCommonStyles(node);
8469
+ const styleAttr = styles ? ` style="${styles}"` : "";
8470
+ const children = ctx.renderChildren(node.children);
8471
+ return `<div class="${classes}"${styleAttr}>
8472
+ ${children}
8473
+ </div>`;
8474
+ }
8256
8475
 
8257
8476
  // src/renderer/html/renderers/container.ts
8258
8477
  function buildInteractiveAttrs(node) {
@@ -19088,6 +19307,28 @@ var lucideIcons = {
19088
19307
  }
19089
19308
  ]
19090
19309
  ],
19310
+ "circle-help": [
19311
+ [
19312
+ "circle",
19313
+ {
19314
+ "cx": "12",
19315
+ "cy": "12",
19316
+ "r": "10"
19317
+ }
19318
+ ],
19319
+ [
19320
+ "path",
19321
+ {
19322
+ "d": "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"
19323
+ }
19324
+ ],
19325
+ [
19326
+ "path",
19327
+ {
19328
+ "d": "M12 17h.01"
19329
+ }
19330
+ ]
19331
+ ],
19091
19332
  "circle-minus": [
19092
19333
  [
19093
19334
  "circle",
@@ -55150,10 +55391,20 @@ function renderAvatar(node, ctx) {
55150
55391
  const sizeStyle = sizeResolved.style || "";
55151
55392
  const combinedStyles = baseStyles && sizeStyle ? `${baseStyles}; ${sizeStyle}` : baseStyles || sizeStyle;
55152
55393
  const styleAttr = combinedStyles ? ` style="${combinedStyles}"` : "";
55153
- const initials = node.name ? node.name.split(" ").map((n) => n[0]).join("").toUpperCase().slice(0, 2) : "?";
55394
+ let content;
55395
+ if (node.name) {
55396
+ content = node.name.split(" ").map((n) => n[0]).join("").toUpperCase().slice(0, 2);
55397
+ } else {
55398
+ const iconData = getIconData("user");
55399
+ if (iconData) {
55400
+ content = renderIconSvg(iconData, 16, 2, `${ctx.prefix}-icon`);
55401
+ } else {
55402
+ content = "?";
55403
+ }
55404
+ }
55154
55405
  const interactiveAttrs = buildInteractiveAttrs2(node);
55155
55406
  const interactiveAttrStr = ctx.buildAttrsString(interactiveAttrs);
55156
- return `<div class="${classes}"${styleAttr}${interactiveAttrStr} role="img" aria-label="${ctx.escapeHtml(node.name || "Avatar")}">${initials}</div>`;
55407
+ return `<div class="${classes}"${styleAttr}${interactiveAttrStr} role="img" aria-label="${ctx.escapeHtml(node.name || "Avatar")}">${content}</div>`;
55157
55408
  }
55158
55409
  function renderBadge(node, ctx) {
55159
55410
  const interactiveAttrs = buildInteractiveAttrs2(node);
@@ -55165,6 +55416,7 @@ function renderBadge(node, ctx) {
55165
55416
  `${ctx.prefix}-badge-icon`,
55166
55417
  sizeResolved.className,
55167
55418
  node.variant ? `${ctx.prefix}-badge-icon-${node.variant}` : void 0,
55419
+ node.anchor ? `${ctx.prefix}-anchor-${node.anchor}` : void 0,
55168
55420
  ...ctx.getCommonClasses(node)
55169
55421
  ]);
55170
55422
  const baseStyles2 = ctx.buildCommonStyles(node);
@@ -55184,6 +55436,7 @@ function renderBadge(node, ctx) {
55184
55436
  sizeResolved.className,
55185
55437
  node.variant ? `${ctx.prefix}-badge-${node.variant}` : void 0,
55186
55438
  node.pill ? `${ctx.prefix}-badge-pill` : void 0,
55439
+ node.anchor ? `${ctx.prefix}-anchor-${node.anchor}` : void 0,
55187
55440
  ...ctx.getCommonClasses(node)
55188
55441
  ]);
55189
55442
  const baseStyles = ctx.buildCommonStyles(node);
@@ -55604,6 +55857,8 @@ var HtmlRenderer = class extends BaseRenderer {
55604
55857
  // Grid nodes
55605
55858
  Row: (node) => this.renderRow(node),
55606
55859
  Col: (node) => this.renderCol(node),
55860
+ Stack: (node) => this.renderStack(node),
55861
+ Relative: (node) => this.renderRelative(node),
55607
55862
  // Container nodes
55608
55863
  Card: (node) => this.renderCard(node),
55609
55864
  Modal: (node) => this.renderModal(node),
@@ -55763,6 +56018,12 @@ ${title}${children}
55763
56018
  renderCol(node) {
55764
56019
  return renderCol(node, this.getGridRenderContext());
55765
56020
  }
56021
+ renderStack(node) {
56022
+ return renderStack(node, this.getRenderContext());
56023
+ }
56024
+ renderRelative(node) {
56025
+ return renderRelative(node, this.getRenderContext());
56026
+ }
55766
56027
  /**
55767
56028
  * Build common inline styles for all values
55768
56029
  *
@@ -55925,6 +56186,9 @@ ${title}${children}
55925
56186
  if (commonStyles) {
55926
56187
  styles.push(commonStyles);
55927
56188
  }
56189
+ if (node.w !== void 0 && node.flex === void 0) {
56190
+ styles.push("flex: none");
56191
+ }
55928
56192
  if (node.order !== void 0) {
55929
56193
  styles.push(`order: ${node.order}`);
55930
56194
  }
@@ -56390,6 +56654,22 @@ var COMPONENT_SPECS = [
56390
56654
  hasChildren: true,
56391
56655
  description: "Vertical flex container or grid column"
56392
56656
  },
56657
+ {
56658
+ name: "stack",
56659
+ nodeType: "Stack",
56660
+ category: "grid",
56661
+ attributes: [...COMMON_ATTRIBUTES, "border", "bg"],
56662
+ hasChildren: true,
56663
+ description: "Vertical stack that only takes content height"
56664
+ },
56665
+ {
56666
+ name: "relative",
56667
+ nodeType: "Relative",
56668
+ category: "grid",
56669
+ attributes: [...COMMON_ATTRIBUTES],
56670
+ hasChildren: true,
56671
+ description: "Container for overlaying elements with absolute positioning"
56672
+ },
56393
56673
  // ============================================
56394
56674
  // Container Components
56395
56675
  // ============================================
@@ -56550,7 +56830,7 @@ var COMPONENT_SPECS = [
56550
56830
  name: "badge",
56551
56831
  nodeType: "Badge",
56552
56832
  category: "display",
56553
- attributes: [...COMMON_ATTRIBUTES, "variant", "pill", "icon", "size"],
56833
+ attributes: [...COMMON_ATTRIBUTES, "variant", "pill", "icon", "size", "anchor"],
56554
56834
  hasChildren: false,
56555
56835
  description: "Status badge"
56556
56836
  },
@@ -57182,6 +57462,46 @@ function importFromJson(json) {
57182
57462
  }
57183
57463
 
57184
57464
  // src/export/figma.ts
57465
+ var SPACING_SCALE = {
57466
+ 0: 0,
57467
+ 1: 4,
57468
+ 2: 8,
57469
+ 3: 12,
57470
+ 4: 16,
57471
+ 5: 20,
57472
+ 6: 24,
57473
+ 7: 28,
57474
+ 8: 32,
57475
+ 9: 36,
57476
+ 10: 40,
57477
+ 12: 48,
57478
+ 14: 56,
57479
+ 16: 64
57480
+ };
57481
+ var TEXT_SIZE_SCALE = {
57482
+ xs: 12,
57483
+ sm: 14,
57484
+ base: 16,
57485
+ md: 16,
57486
+ lg: 18,
57487
+ xl: 20,
57488
+ "2xl": 24,
57489
+ "3xl": 30
57490
+ };
57491
+ var FONT_WEIGHT_SCALE = {
57492
+ normal: 400,
57493
+ medium: 500,
57494
+ semibold: 600,
57495
+ bold: 700
57496
+ };
57497
+ var COLORS = {
57498
+ muted: { r: 0.96, g: 0.96, b: 0.96, a: 1 },
57499
+ primary: { r: 0.22, g: 0.52, b: 0.96, a: 1 },
57500
+ secondary: { r: 0.4, g: 0.4, b: 0.45, a: 1 },
57501
+ border: { r: 0.9, g: 0.9, b: 0.9, a: 1 },
57502
+ text: { r: 0.1, g: 0.1, b: 0.1, a: 1 },
57503
+ textMuted: { r: 0.5, g: 0.5, b: 0.5, a: 1 }
57504
+ };
57185
57505
  var figmaIdCounter = 0;
57186
57506
  function generateFigmaId() {
57187
57507
  return `node-${++figmaIdCounter}`;
@@ -57189,52 +57509,178 @@ function generateFigmaId() {
57189
57509
  function resetFigmaIdCounter() {
57190
57510
  figmaIdCounter = 0;
57191
57511
  }
57512
+ function spacingToPx(value) {
57513
+ if (value === void 0) return 0;
57514
+ if (typeof value === "number") {
57515
+ return SPACING_SCALE[value] ?? value * 4;
57516
+ }
57517
+ const unit = value.unit;
57518
+ if (unit === "px") return value.value;
57519
+ if (unit === "rem") return value.value * 16;
57520
+ if (unit === "em") return value.value * 16;
57521
+ return value.value;
57522
+ }
57523
+ function textSizeToPx(size) {
57524
+ if (size === void 0) return 16;
57525
+ if (typeof size === "string") {
57526
+ return TEXT_SIZE_SCALE[size] ?? 16;
57527
+ }
57528
+ if (size.unit === "px") return size.value;
57529
+ if (size.unit === "rem") return size.value * 16;
57530
+ return size.value;
57531
+ }
57532
+ function fontWeightToNumeric(weight) {
57533
+ if (weight === void 0) return 400;
57534
+ return FONT_WEIGHT_SCALE[weight] ?? 400;
57535
+ }
57536
+ function sizeValueToPx(value, defaultValue = 0) {
57537
+ if (value === void 0) {
57538
+ return { value: defaultValue, sizing: "HUG" };
57539
+ }
57540
+ if (value === "full" || value === "screen") {
57541
+ return { value: defaultValue, sizing: "FILL" };
57542
+ }
57543
+ if (value === "auto" || value === "fit") {
57544
+ return { value: defaultValue, sizing: "HUG" };
57545
+ }
57546
+ if (typeof value === "number") {
57547
+ return { value, sizing: "FIXED" };
57548
+ }
57549
+ if (value.unit === "px") {
57550
+ return { value: value.value, sizing: "FIXED" };
57551
+ }
57552
+ if (value.unit === "%") {
57553
+ return { value: 0, sizing: "FILL" };
57554
+ }
57555
+ return { value: value.value, sizing: "FIXED" };
57556
+ }
57192
57557
  function mapToFigmaType(type) {
57193
57558
  const typeMap = {
57194
57559
  page: "CANVAS",
57195
- header: "FRAME",
57196
- main: "FRAME",
57197
- footer: "FRAME",
57198
- sidebar: "FRAME",
57199
- section: "FRAME",
57200
- row: "FRAME",
57201
- col: "FRAME",
57202
- card: "FRAME",
57203
- modal: "FRAME",
57204
- drawer: "FRAME",
57205
- accordion: "FRAME",
57206
57560
  text: "TEXT",
57207
57561
  title: "TEXT",
57208
57562
  link: "TEXT",
57209
- button: "FRAME",
57210
- input: "FRAME",
57211
- textarea: "FRAME",
57212
- select: "FRAME",
57213
- checkbox: "FRAME",
57214
- radio: "FRAME",
57215
- switch: "FRAME",
57216
- slider: "FRAME",
57217
57563
  image: "RECTANGLE",
57218
57564
  placeholder: "RECTANGLE",
57219
- avatar: "FRAME",
57220
- badge: "FRAME",
57221
- icon: "FRAME",
57222
- table: "FRAME",
57223
- list: "FRAME",
57224
- alert: "FRAME",
57225
- toast: "FRAME",
57226
- progress: "FRAME",
57227
- spinner: "FRAME",
57228
- tooltip: "FRAME",
57229
- popover: "FRAME",
57230
- dropdown: "FRAME",
57231
- nav: "FRAME",
57232
- tabs: "FRAME",
57233
- breadcrumb: "FRAME",
57234
57565
  divider: "RECTANGLE"
57235
57566
  };
57236
57567
  return typeMap[type.toLowerCase()] || "FRAME";
57237
57568
  }
57569
+ function mapJustify(justify) {
57570
+ const map = {
57571
+ start: "MIN",
57572
+ center: "CENTER",
57573
+ end: "MAX",
57574
+ between: "SPACE_BETWEEN",
57575
+ around: "SPACE_BETWEEN",
57576
+ // Figma doesn't have SPACE_AROUND
57577
+ evenly: "SPACE_BETWEEN"
57578
+ // Figma doesn't have SPACE_EVENLY
57579
+ };
57580
+ return map[justify || "start"] || "MIN";
57581
+ }
57582
+ function mapAlign(align) {
57583
+ const map = {
57584
+ start: "MIN",
57585
+ center: "CENTER",
57586
+ end: "MAX",
57587
+ stretch: "STRETCH",
57588
+ baseline: "BASELINE"
57589
+ };
57590
+ return map[align || "stretch"] || "STRETCH";
57591
+ }
57592
+ function mapTextAlign(align) {
57593
+ const map = {
57594
+ left: "LEFT",
57595
+ center: "CENTER",
57596
+ right: "RIGHT",
57597
+ justify: "JUSTIFIED"
57598
+ };
57599
+ return map[align || "left"] || "LEFT";
57600
+ }
57601
+ function getAttr(node, key) {
57602
+ return node[key];
57603
+ }
57604
+ function extractAutoLayout(node) {
57605
+ let layoutMode = "VERTICAL";
57606
+ const direction = getAttr(node, "direction");
57607
+ if (direction === "row" || direction === "row-reverse") {
57608
+ layoutMode = "HORIZONTAL";
57609
+ } else if (direction === "column" || direction === "column-reverse") {
57610
+ layoutMode = "VERTICAL";
57611
+ }
57612
+ const type = node.type.toLowerCase();
57613
+ if (type === "row") layoutMode = "HORIZONTAL";
57614
+ if (type === "col" || type === "stack") layoutMode = "VERTICAL";
57615
+ const p = spacingToPx(getAttr(node, "p"));
57616
+ const pxVal = getAttr(node, "px");
57617
+ const pyVal = getAttr(node, "py");
57618
+ const px = pxVal !== void 0 ? spacingToPx(pxVal) : p;
57619
+ const py = pyVal !== void 0 ? spacingToPx(pyVal) : p;
57620
+ const ptVal = getAttr(node, "pt");
57621
+ const prVal = getAttr(node, "pr");
57622
+ const pbVal = getAttr(node, "pb");
57623
+ const plVal = getAttr(node, "pl");
57624
+ const pt = ptVal !== void 0 ? spacingToPx(ptVal) : py;
57625
+ const pr = prVal !== void 0 ? spacingToPx(prVal) : px;
57626
+ const pb = pbVal !== void 0 ? spacingToPx(pbVal) : py;
57627
+ const pl = plVal !== void 0 ? spacingToPx(plVal) : px;
57628
+ const wResult = sizeValueToPx(getAttr(node, "w"), 0);
57629
+ const hResult = sizeValueToPx(getAttr(node, "h"), 0);
57630
+ return {
57631
+ layoutMode,
57632
+ layoutSizingHorizontal: wResult.sizing,
57633
+ layoutSizingVertical: hResult.sizing,
57634
+ primaryAxisAlignItems: mapJustify(getAttr(node, "justify")),
57635
+ counterAxisAlignItems: mapAlign(getAttr(node, "align")),
57636
+ paddingTop: pt,
57637
+ paddingRight: pr,
57638
+ paddingBottom: pb,
57639
+ paddingLeft: pl,
57640
+ itemSpacing: spacingToPx(getAttr(node, "gap")),
57641
+ layoutWrap: getAttr(node, "wrap") ? "WRAP" : "NO_WRAP"
57642
+ };
57643
+ }
57644
+ function extractSize(node, defaultWidth = 100, defaultHeight = 100) {
57645
+ const wResult = sizeValueToPx(getAttr(node, "w"), defaultWidth);
57646
+ const hResult = sizeValueToPx(getAttr(node, "h"), defaultHeight);
57647
+ const size = {
57648
+ width: wResult.value || defaultWidth,
57649
+ height: hResult.value || defaultHeight
57650
+ };
57651
+ const minW = getAttr(node, "minW");
57652
+ const maxW = getAttr(node, "maxW");
57653
+ const minH = getAttr(node, "minH");
57654
+ const maxH = getAttr(node, "maxH");
57655
+ if (minW !== void 0) size.minWidth = spacingToPx(minW);
57656
+ if (maxW !== void 0) size.maxWidth = spacingToPx(maxW);
57657
+ if (minH !== void 0) size.minHeight = spacingToPx(minH);
57658
+ if (maxH !== void 0) size.maxHeight = spacingToPx(maxH);
57659
+ return size;
57660
+ }
57661
+ function extractTextStyle(node) {
57662
+ const content = getNodeContent(node) || "";
57663
+ return {
57664
+ fontSize: textSizeToPx(getAttr(node, "size")),
57665
+ fontWeight: fontWeightToNumeric(getAttr(node, "weight")),
57666
+ textAlignHorizontal: mapTextAlign(getAttr(node, "align")),
57667
+ characters: content
57668
+ };
57669
+ }
57670
+ function extractFills(node) {
57671
+ const bg = getAttr(node, "bg");
57672
+ if (!bg) return void 0;
57673
+ const color = COLORS[bg];
57674
+ if (!color) return void 0;
57675
+ return [{ type: "SOLID", color }];
57676
+ }
57677
+ function extractStrokes(node) {
57678
+ if (!getAttr(node, "border")) return void 0;
57679
+ return {
57680
+ strokes: [{ type: "SOLID", color: COLORS.border }],
57681
+ strokeWeight: 1
57682
+ };
57683
+ }
57238
57684
  function nodeToFigma(node) {
57239
57685
  const figmaType = mapToFigmaType(node.type);
57240
57686
  const content = getNodeContent(node);
@@ -57249,6 +57695,33 @@ function nodeToFigma(node) {
57249
57695
  if (Object.keys(attrs).length > 0) {
57250
57696
  figmaNode.wireweaveAttributes = attrs;
57251
57697
  }
57698
+ if (figmaType === "FRAME") {
57699
+ figmaNode.autoLayout = extractAutoLayout(node);
57700
+ figmaNode.size = extractSize(node);
57701
+ const fills = extractFills(node);
57702
+ if (fills) figmaNode.fills = fills;
57703
+ const strokeInfo = extractStrokes(node);
57704
+ if (strokeInfo) {
57705
+ figmaNode.strokes = strokeInfo.strokes;
57706
+ figmaNode.strokeWeight = strokeInfo.strokeWeight;
57707
+ }
57708
+ if (node.type.toLowerCase() === "card") {
57709
+ figmaNode.cornerRadius = 8;
57710
+ }
57711
+ } else if (figmaType === "TEXT") {
57712
+ figmaNode.textStyle = extractTextStyle(node);
57713
+ if (getAttr(node, "muted")) {
57714
+ figmaNode.fills = [{ type: "SOLID", color: COLORS.textMuted }];
57715
+ }
57716
+ } else if (figmaType === "RECTANGLE") {
57717
+ figmaNode.size = extractSize(node, 200, 150);
57718
+ const fills = extractFills(node);
57719
+ if (fills) {
57720
+ figmaNode.fills = fills;
57721
+ } else {
57722
+ figmaNode.fills = [{ type: "SOLID", color: COLORS.muted }];
57723
+ }
57724
+ }
57252
57725
  if ("children" in node && Array.isArray(node.children)) {
57253
57726
  const children = [];
57254
57727
  for (const child of node.children) {
@@ -57282,7 +57755,7 @@ function exportToFigma(doc) {
57282
57755
  componentMappings[type] = mapToFigmaType(type);
57283
57756
  }
57284
57757
  return {
57285
- version: "1.0.0",
57758
+ version: "2.0.0",
57286
57759
  format: "figma",
57287
57760
  document: documentNode,
57288
57761
  componentMappings