@optionfactory/fml 9.0.0-rc27 → 9.0.0-rc29

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 (43) hide show
  1. package/dist/client-errors.iife.js +21 -16
  2. package/dist/client-errors.iife.js.map +1 -1
  3. package/dist/client-errors.iife.min.js +1 -1
  4. package/dist/client-errors.iife.min.js.map +1 -1
  5. package/dist/custom-elements.json +16 -16
  6. package/dist/fml.css +13 -13
  7. package/dist/fml.css.map +1 -1
  8. package/dist/fml.iife.js +871 -883
  9. package/dist/fml.iife.js.map +1 -1
  10. package/dist/fml.iife.min.js +1 -1
  11. package/dist/fml.iife.min.js.map +1 -1
  12. package/dist/ftl.d.mts +3 -3
  13. package/dist/ftl.iife.js +275 -679
  14. package/dist/ftl.iife.js.map +1 -1
  15. package/dist/ftl.iife.min.js +1 -1
  16. package/dist/ftl.iife.min.js.map +1 -1
  17. package/dist/ftl.min.mjs +1 -1
  18. package/dist/ftl.min.mjs.map +1 -1
  19. package/dist/ftl.mjs +275 -679
  20. package/dist/ftl.mjs.map +1 -1
  21. package/dist/ful.css +13 -13
  22. package/dist/ful.css.map +1 -1
  23. package/dist/ful.d.mts +195 -71
  24. package/dist/ful.iife.js +564 -189
  25. package/dist/ful.iife.js.map +1 -1
  26. package/dist/ful.iife.min.js +1 -1
  27. package/dist/ful.iife.min.js.map +1 -1
  28. package/dist/ful.min.mjs +1 -1
  29. package/dist/ful.min.mjs.map +1 -1
  30. package/dist/ful.mjs +564 -189
  31. package/dist/ful.mjs.map +1 -1
  32. package/dist/httpc.d.mts +9 -7
  33. package/dist/httpc.iife.js +32 -15
  34. package/dist/httpc.iife.js.map +1 -1
  35. package/dist/httpc.iife.min.js +1 -1
  36. package/dist/httpc.iife.min.js.map +1 -1
  37. package/dist/httpc.min.mjs +1 -1
  38. package/dist/httpc.min.mjs.map +1 -1
  39. package/dist/httpc.mjs +32 -15
  40. package/dist/httpc.mjs.map +1 -1
  41. package/dist/vscode.html-custom-data.json +13 -13
  42. package/dist/web-types.json +17 -17
  43. package/package.json +2 -2
package/dist/ftl.iife.js CHANGED
@@ -71,7 +71,7 @@ var ftl = (function (exports) {
71
71
  },
72
72
  };
73
73
 
74
- // @generated by Peggy 5.1.0.
74
+ // @generated by Peggy 5.1.1.
75
75
  //
76
76
  // https://peggyjs.org/
77
77
 
@@ -137,10 +137,9 @@ var ftl = (function (exports) {
137
137
  return s;
138
138
  }
139
139
 
140
- function literalEscape(s) {
140
+ function escape(s, special) {
141
141
  return unicodeEscape(s
142
- .replace(/\\/g, "\\\\")
143
- .replace(/"/g, "\\\"")
142
+ .replace(special, "\\$&")
144
143
  .replace(/\0/g, "\\0")
145
144
  .replace(/\t/g, "\\t")
146
145
  .replace(/\n/g, "\\n")
@@ -149,18 +148,12 @@ var ftl = (function (exports) {
149
148
  .replace(/[\x10-\x1F\x7F-\x9F]/g, ch => "\\x" + hex(ch)));
150
149
  }
151
150
 
151
+ function literalEscape(s) {
152
+ return escape(s, /[\\"]/g);
153
+ }
154
+
152
155
  function classEscape(s) {
153
- return unicodeEscape(s
154
- .replace(/\\/g, "\\\\")
155
- .replace(/\]/g, "\\]")
156
- .replace(/\^/g, "\\^")
157
- .replace(/-/g, "\\-")
158
- .replace(/\0/g, "\\0")
159
- .replace(/\t/g, "\\t")
160
- .replace(/\n/g, "\\n")
161
- .replace(/\r/g, "\\r")
162
- .replace(/[\x00-\x0F]/g, ch => "\\x0" + hex(ch))
163
- .replace(/[\x10-\x1F\x7F-\x9F]/g, ch => "\\x" + hex(ch)));
156
+ return escape(s, /[\\\]^-]/g);
164
157
  }
165
158
 
166
159
  const DESCRIBE_EXPECTATION_FNS = {
@@ -278,14 +271,6 @@ var ftl = (function (exports) {
278
271
  const peg$c53 = "<=";
279
272
  const peg$c54 = "<";
280
273
 
281
- const peg$r0 = /^[^\\{]/;
282
- const peg$r1 = /^[0-9]/;
283
- const peg$r2 = /^[^']/;
284
- const peg$r3 = /^[^"]/;
285
- const peg$r4 = /^[^\\`{]/;
286
- const peg$r5 = /^[a-zA-Z$_]/;
287
- const peg$r6 = /^[a-zA-Z$_0-9]/;
288
- const peg$r7 = /^[ \t\n\r]/;
289
274
 
290
275
  const peg$e0 = peg$literalExpectation("{{{{", false);
291
276
  const peg$e1 = peg$literalExpectation("}}}}", false);
@@ -443,9 +428,10 @@ var ftl = (function (exports) {
443
428
  let peg$maxFailExpected = options.peg$maxFailExpected || [];
444
429
  let peg$silentFails = options.peg$silentFails | 0;
445
430
 
446
- let peg$resultsCache = {};
431
+ let peg$resultsCache = new Map();
447
432
 
448
433
  let peg$result;
434
+ let peg$charCode;
449
435
 
450
436
  if (options.startRule) {
451
437
  if (!(options.startRule in peg$startRuleFunctions)) {
@@ -564,7 +550,7 @@ var ftl = (function (exports) {
564
550
  let s0, s1;
565
551
 
566
552
  const key = peg$currPos * 38 + 0;
567
- const cached = peg$resultsCache[key];
553
+ const cached = peg$resultsCache.get(key);
568
554
 
569
555
  if (cached) {
570
556
  peg$currPos = cached.nextPos;
@@ -573,13 +559,13 @@ var ftl = (function (exports) {
573
559
  }
574
560
 
575
561
  s0 = [];
576
- s1 = peg$parseTemplatedExpression();
577
- while (s1 !== peg$FAILED) {
578
- s0.push(s1);
562
+ for (;;) {
579
563
  s1 = peg$parseTemplatedExpression();
564
+ if (s1 === peg$FAILED) { break; }
565
+ s0.push(s1);
580
566
  }
581
567
 
582
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
568
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
583
569
 
584
570
  return s0;
585
571
  }
@@ -588,7 +574,7 @@ var ftl = (function (exports) {
588
574
  let s0, s1, s2, s3, s4;
589
575
 
590
576
  const key = peg$currPos * 38 + 1;
591
- const cached = peg$resultsCache[key];
577
+ const cached = peg$resultsCache.get(key);
592
578
 
593
579
  if (cached) {
594
580
  peg$currPos = cached.nextPos;
@@ -684,7 +670,7 @@ var ftl = (function (exports) {
684
670
  }
685
671
  }
686
672
 
687
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
673
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
688
674
 
689
675
  return s0;
690
676
  }
@@ -693,7 +679,7 @@ var ftl = (function (exports) {
693
679
  let s0;
694
680
 
695
681
  const key = peg$currPos * 38 + 2;
696
- const cached = peg$resultsCache[key];
682
+ const cached = peg$resultsCache.get(key);
697
683
 
698
684
  if (cached) {
699
685
  peg$currPos = cached.nextPos;
@@ -709,7 +695,7 @@ var ftl = (function (exports) {
709
695
  if (peg$silentFails === 0) { peg$fail(peg$e0); }
710
696
  }
711
697
 
712
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
698
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
713
699
 
714
700
  return s0;
715
701
  }
@@ -718,7 +704,7 @@ var ftl = (function (exports) {
718
704
  let s0;
719
705
 
720
706
  const key = peg$currPos * 38 + 3;
721
- const cached = peg$resultsCache[key];
707
+ const cached = peg$resultsCache.get(key);
722
708
 
723
709
  if (cached) {
724
710
  peg$currPos = cached.nextPos;
@@ -734,7 +720,7 @@ var ftl = (function (exports) {
734
720
  if (peg$silentFails === 0) { peg$fail(peg$e1); }
735
721
  }
736
722
 
737
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
723
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
738
724
 
739
725
  return s0;
740
726
  }
@@ -743,7 +729,7 @@ var ftl = (function (exports) {
743
729
  let s0;
744
730
 
745
731
  const key = peg$currPos * 38 + 4;
746
- const cached = peg$resultsCache[key];
732
+ const cached = peg$resultsCache.get(key);
747
733
 
748
734
  if (cached) {
749
735
  peg$currPos = cached.nextPos;
@@ -759,7 +745,7 @@ var ftl = (function (exports) {
759
745
  if (peg$silentFails === 0) { peg$fail(peg$e2); }
760
746
  }
761
747
 
762
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
748
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
763
749
 
764
750
  return s0;
765
751
  }
@@ -768,7 +754,7 @@ var ftl = (function (exports) {
768
754
  let s0;
769
755
 
770
756
  const key = peg$currPos * 38 + 5;
771
- const cached = peg$resultsCache[key];
757
+ const cached = peg$resultsCache.get(key);
772
758
 
773
759
  if (cached) {
774
760
  peg$currPos = cached.nextPos;
@@ -784,7 +770,7 @@ var ftl = (function (exports) {
784
770
  if (peg$silentFails === 0) { peg$fail(peg$e3); }
785
771
  }
786
772
 
787
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
773
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
788
774
 
789
775
  return s0;
790
776
  }
@@ -793,7 +779,7 @@ var ftl = (function (exports) {
793
779
  let s0;
794
780
 
795
781
  const key = peg$currPos * 38 + 6;
796
- const cached = peg$resultsCache[key];
782
+ const cached = peg$resultsCache.get(key);
797
783
 
798
784
  if (cached) {
799
785
  peg$currPos = cached.nextPos;
@@ -809,7 +795,7 @@ var ftl = (function (exports) {
809
795
  if (peg$silentFails === 0) { peg$fail(peg$e4); }
810
796
  }
811
797
 
812
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
798
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
813
799
 
814
800
  return s0;
815
801
  }
@@ -818,7 +804,7 @@ var ftl = (function (exports) {
818
804
  let s0;
819
805
 
820
806
  const key = peg$currPos * 38 + 7;
821
- const cached = peg$resultsCache[key];
807
+ const cached = peg$resultsCache.get(key);
822
808
 
823
809
  if (cached) {
824
810
  peg$currPos = cached.nextPos;
@@ -834,7 +820,7 @@ var ftl = (function (exports) {
834
820
  if (peg$silentFails === 0) { peg$fail(peg$e5); }
835
821
  }
836
822
 
837
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
823
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
838
824
 
839
825
  return s0;
840
826
  }
@@ -843,7 +829,7 @@ var ftl = (function (exports) {
843
829
  let s0, s1, s2, s3, s4, s5, s6;
844
830
 
845
831
  const key = peg$currPos * 38 + 8;
846
- const cached = peg$resultsCache[key];
832
+ const cached = peg$resultsCache.get(key);
847
833
 
848
834
  if (cached) {
849
835
  peg$currPos = cached.nextPos;
@@ -853,211 +839,104 @@ var ftl = (function (exports) {
853
839
 
854
840
  s0 = peg$currPos;
855
841
  s1 = [];
856
- s2 = peg$currPos;
857
- s3 = [];
858
- s4 = input.charAt(peg$currPos);
859
- if (peg$r0.test(s4)) {
860
- peg$currPos++;
861
- } else {
862
- s4 = peg$FAILED;
863
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
864
- }
865
- if (s4 !== peg$FAILED) {
866
- while (s4 !== peg$FAILED) {
867
- s3.push(s4);
842
+ for (;;) {
843
+ s2 = peg$currPos;
844
+ s3 = [];
845
+ for (;;) {
868
846
  s4 = input.charAt(peg$currPos);
869
- if (peg$r0.test(s4)) {
847
+ if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 92 || peg$charCode === 123)) {
870
848
  peg$currPos++;
871
849
  } else {
872
850
  s4 = peg$FAILED;
873
851
  if (peg$silentFails === 0) { peg$fail(peg$e6); }
874
852
  }
853
+ if (s4 === peg$FAILED) { break; }
854
+ s3.push(s4);
875
855
  }
876
- } else {
877
- s3 = peg$FAILED;
878
- }
879
- if (s3 !== peg$FAILED) {
880
- s2 = input.substring(s2, peg$currPos);
881
- } else {
882
- s2 = s3;
883
- }
884
- if (s2 === peg$FAILED) {
885
- s2 = peg$currPos;
886
- if (input.charCodeAt(peg$currPos) === 92) {
887
- s3 = peg$c7;
888
- peg$currPos++;
889
- } else {
856
+ if (s3.length < 1) {
890
857
  s3 = peg$FAILED;
891
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
892
858
  }
893
859
  if (s3 !== peg$FAILED) {
894
- if (input.length > peg$currPos) {
895
- s4 = input.charAt(peg$currPos);
896
- peg$currPos++;
897
- } else {
898
- s4 = peg$FAILED;
899
- if (peg$silentFails === 0) { peg$fail(peg$e8); }
900
- }
901
- if (s4 !== peg$FAILED) {
902
- s2 = peg$f4(s4);
903
- } else {
904
- peg$currPos = s2;
905
- s2 = peg$FAILED;
906
- }
860
+ s2 = input.substring(s2, peg$currPos);
907
861
  } else {
908
- peg$currPos = s2;
909
- s2 = peg$FAILED;
862
+ s2 = s3;
910
863
  }
911
864
  if (s2 === peg$FAILED) {
912
865
  s2 = peg$currPos;
913
- s3 = peg$currPos;
914
- if (input.charCodeAt(peg$currPos) === 123) {
915
- s4 = peg$c9;
866
+ if (input.charCodeAt(peg$currPos) === 92) {
867
+ s3 = peg$c7;
916
868
  peg$currPos++;
917
869
  } else {
918
- s4 = peg$FAILED;
919
- if (peg$silentFails === 0) { peg$fail(peg$e9); }
870
+ s3 = peg$FAILED;
871
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
920
872
  }
921
- if (s4 !== peg$FAILED) {
922
- s5 = peg$currPos;
923
- peg$silentFails++;
924
- if (input.charCodeAt(peg$currPos) === 123) {
925
- s6 = peg$c9;
873
+ if (s3 !== peg$FAILED) {
874
+ if (input.length > peg$currPos) {
875
+ s4 = input.charAt(peg$currPos);
926
876
  peg$currPos++;
927
877
  } else {
928
- s6 = peg$FAILED;
929
- if (peg$silentFails === 0) { peg$fail(peg$e9); }
930
- }
931
- peg$silentFails--;
932
- if (s6 === peg$FAILED) {
933
- s5 = undefined;
934
- } else {
935
- peg$currPos = s5;
936
- s5 = peg$FAILED;
878
+ s4 = peg$FAILED;
879
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
937
880
  }
938
- if (s5 !== peg$FAILED) {
939
- s4 = [s4, s5];
940
- s3 = s4;
881
+ if (s4 !== peg$FAILED) {
882
+ s2 = peg$f4(s4);
941
883
  } else {
942
- peg$currPos = s3;
943
- s3 = peg$FAILED;
944
- }
945
- } else {
946
- peg$currPos = s3;
947
- s3 = peg$FAILED;
948
- }
949
- if (s3 !== peg$FAILED) {
950
- s2 = input.substring(s2, peg$currPos);
951
- } else {
952
- s2 = s3;
953
- }
954
- }
955
- }
956
- if (s2 !== peg$FAILED) {
957
- while (s2 !== peg$FAILED) {
958
- s1.push(s2);
959
- s2 = peg$currPos;
960
- s3 = [];
961
- s4 = input.charAt(peg$currPos);
962
- if (peg$r0.test(s4)) {
963
- peg$currPos++;
964
- } else {
965
- s4 = peg$FAILED;
966
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
967
- }
968
- if (s4 !== peg$FAILED) {
969
- while (s4 !== peg$FAILED) {
970
- s3.push(s4);
971
- s4 = input.charAt(peg$currPos);
972
- if (peg$r0.test(s4)) {
973
- peg$currPos++;
974
- } else {
975
- s4 = peg$FAILED;
976
- if (peg$silentFails === 0) { peg$fail(peg$e6); }
977
- }
884
+ peg$currPos = s2;
885
+ s2 = peg$FAILED;
978
886
  }
979
887
  } else {
980
- s3 = peg$FAILED;
981
- }
982
- if (s3 !== peg$FAILED) {
983
- s2 = input.substring(s2, peg$currPos);
984
- } else {
985
- s2 = s3;
888
+ peg$currPos = s2;
889
+ s2 = peg$FAILED;
986
890
  }
987
891
  if (s2 === peg$FAILED) {
988
892
  s2 = peg$currPos;
989
- if (input.charCodeAt(peg$currPos) === 92) {
990
- s3 = peg$c7;
893
+ s3 = peg$currPos;
894
+ if (input.charCodeAt(peg$currPos) === 123) {
895
+ s4 = peg$c9;
991
896
  peg$currPos++;
992
897
  } else {
993
- s3 = peg$FAILED;
994
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
995
- }
996
- if (s3 !== peg$FAILED) {
997
- if (input.length > peg$currPos) {
998
- s4 = input.charAt(peg$currPos);
999
- peg$currPos++;
1000
- } else {
1001
- s4 = peg$FAILED;
1002
- if (peg$silentFails === 0) { peg$fail(peg$e8); }
1003
- }
1004
- if (s4 !== peg$FAILED) {
1005
- s2 = peg$f4(s4);
1006
- } else {
1007
- peg$currPos = s2;
1008
- s2 = peg$FAILED;
1009
- }
1010
- } else {
1011
- peg$currPos = s2;
1012
- s2 = peg$FAILED;
898
+ s4 = peg$FAILED;
899
+ if (peg$silentFails === 0) { peg$fail(peg$e9); }
1013
900
  }
1014
- if (s2 === peg$FAILED) {
1015
- s2 = peg$currPos;
1016
- s3 = peg$currPos;
901
+ if (s4 !== peg$FAILED) {
902
+ s5 = peg$currPos;
903
+ peg$silentFails++;
1017
904
  if (input.charCodeAt(peg$currPos) === 123) {
1018
- s4 = peg$c9;
905
+ s6 = peg$c9;
1019
906
  peg$currPos++;
1020
907
  } else {
1021
- s4 = peg$FAILED;
908
+ s6 = peg$FAILED;
1022
909
  if (peg$silentFails === 0) { peg$fail(peg$e9); }
1023
910
  }
1024
- if (s4 !== peg$FAILED) {
1025
- s5 = peg$currPos;
1026
- peg$silentFails++;
1027
- if (input.charCodeAt(peg$currPos) === 123) {
1028
- s6 = peg$c9;
1029
- peg$currPos++;
1030
- } else {
1031
- s6 = peg$FAILED;
1032
- if (peg$silentFails === 0) { peg$fail(peg$e9); }
1033
- }
1034
- peg$silentFails--;
1035
- if (s6 === peg$FAILED) {
1036
- s5 = undefined;
1037
- } else {
1038
- peg$currPos = s5;
1039
- s5 = peg$FAILED;
1040
- }
1041
- if (s5 !== peg$FAILED) {
1042
- s4 = [s4, s5];
1043
- s3 = s4;
1044
- } else {
1045
- peg$currPos = s3;
1046
- s3 = peg$FAILED;
1047
- }
911
+ peg$silentFails--;
912
+ if (s6 === peg$FAILED) {
913
+ s5 = undefined;
1048
914
  } else {
1049
- peg$currPos = s3;
1050
- s3 = peg$FAILED;
915
+ peg$currPos = s5;
916
+ s5 = peg$FAILED;
1051
917
  }
1052
- if (s3 !== peg$FAILED) {
1053
- s2 = input.substring(s2, peg$currPos);
918
+ if (s5 !== peg$FAILED) {
919
+ s4 = [s4, s5];
920
+ s3 = s4;
1054
921
  } else {
1055
- s2 = s3;
922
+ peg$currPos = s3;
923
+ s3 = peg$FAILED;
1056
924
  }
925
+ } else {
926
+ peg$currPos = s3;
927
+ s3 = peg$FAILED;
928
+ }
929
+ if (s3 !== peg$FAILED) {
930
+ s2 = input.substring(s2, peg$currPos);
931
+ } else {
932
+ s2 = s3;
1057
933
  }
1058
934
  }
1059
935
  }
1060
- } else {
936
+ if (s2 === peg$FAILED) { break; }
937
+ s1.push(s2);
938
+ }
939
+ if (s1.length < 1) {
1061
940
  s1 = peg$FAILED;
1062
941
  }
1063
942
  if (s1 !== peg$FAILED) {
@@ -1065,7 +944,7 @@ var ftl = (function (exports) {
1065
944
  }
1066
945
  s0 = s1;
1067
946
 
1068
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
947
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1069
948
 
1070
949
  return s0;
1071
950
  }
@@ -1074,7 +953,7 @@ var ftl = (function (exports) {
1074
953
  let s0, s2;
1075
954
 
1076
955
  const key = peg$currPos * 38 + 9;
1077
- const cached = peg$resultsCache[key];
956
+ const cached = peg$resultsCache.get(key);
1078
957
 
1079
958
  if (cached) {
1080
959
  peg$currPos = cached.nextPos;
@@ -1093,7 +972,7 @@ var ftl = (function (exports) {
1093
972
  s0 = peg$FAILED;
1094
973
  }
1095
974
 
1096
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
975
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1097
976
 
1098
977
  return s0;
1099
978
  }
@@ -1102,7 +981,7 @@ var ftl = (function (exports) {
1102
981
  let s0, s1, s3, s5, s7, s9;
1103
982
 
1104
983
  const key = peg$currPos * 38 + 10;
1105
- const cached = peg$resultsCache[key];
984
+ const cached = peg$resultsCache.get(key);
1106
985
 
1107
986
  if (cached) {
1108
987
  peg$currPos = cached.nextPos;
@@ -1162,7 +1041,7 @@ var ftl = (function (exports) {
1162
1041
  s0 = peg$parseElvisExpression();
1163
1042
  }
1164
1043
 
1165
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1044
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1166
1045
 
1167
1046
  return s0;
1168
1047
  }
@@ -1171,7 +1050,7 @@ var ftl = (function (exports) {
1171
1050
  let s0, s1, s3, s5;
1172
1051
 
1173
1052
  const key = peg$currPos * 38 + 11;
1174
- const cached = peg$resultsCache[key];
1053
+ const cached = peg$resultsCache.get(key);
1175
1054
 
1176
1055
  if (cached) {
1177
1056
  peg$currPos = cached.nextPos;
@@ -1211,7 +1090,7 @@ var ftl = (function (exports) {
1211
1090
  s0 = peg$parseNullCoalescingExpression();
1212
1091
  }
1213
1092
 
1214
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1093
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1215
1094
 
1216
1095
  return s0;
1217
1096
  }
@@ -1220,7 +1099,7 @@ var ftl = (function (exports) {
1220
1099
  let s0, s1, s3, s5;
1221
1100
 
1222
1101
  const key = peg$currPos * 38 + 12;
1223
- const cached = peg$resultsCache[key];
1102
+ const cached = peg$resultsCache.get(key);
1224
1103
 
1225
1104
  if (cached) {
1226
1105
  peg$currPos = cached.nextPos;
@@ -1260,7 +1139,7 @@ var ftl = (function (exports) {
1260
1139
  s0 = peg$parseOrExpression();
1261
1140
  }
1262
1141
 
1263
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1142
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1264
1143
 
1265
1144
  return s0;
1266
1145
  }
@@ -1269,7 +1148,7 @@ var ftl = (function (exports) {
1269
1148
  let s0, s1, s2, s3, s5, s7;
1270
1149
 
1271
1150
  const key = peg$currPos * 38 + 13;
1272
- const cached = peg$resultsCache[key];
1151
+ const cached = peg$resultsCache.get(key);
1273
1152
 
1274
1153
  if (cached) {
1275
1154
  peg$currPos = cached.nextPos;
@@ -1281,30 +1160,7 @@ var ftl = (function (exports) {
1281
1160
  s1 = peg$parseAndExpression();
1282
1161
  if (s1 !== peg$FAILED) {
1283
1162
  s2 = [];
1284
- s3 = peg$currPos;
1285
- peg$parse_();
1286
- if (input.substr(peg$currPos, 2) === peg$c22) {
1287
- s5 = peg$c22;
1288
- peg$currPos += 2;
1289
- } else {
1290
- s5 = peg$FAILED;
1291
- if (peg$silentFails === 0) { peg$fail(peg$e14); }
1292
- }
1293
- if (s5 !== peg$FAILED) {
1294
- peg$parse_();
1295
- s7 = peg$parseAndExpression();
1296
- if (s7 !== peg$FAILED) {
1297
- s3 = s7;
1298
- } else {
1299
- peg$currPos = s3;
1300
- s3 = peg$FAILED;
1301
- }
1302
- } else {
1303
- peg$currPos = s3;
1304
- s3 = peg$FAILED;
1305
- }
1306
- while (s3 !== peg$FAILED) {
1307
- s2.push(s3);
1163
+ for (;;) {
1308
1164
  s3 = peg$currPos;
1309
1165
  peg$parse_();
1310
1166
  if (input.substr(peg$currPos, 2) === peg$c22) {
@@ -1327,6 +1183,8 @@ var ftl = (function (exports) {
1327
1183
  peg$currPos = s3;
1328
1184
  s3 = peg$FAILED;
1329
1185
  }
1186
+ if (s3 === peg$FAILED) { break; }
1187
+ s2.push(s3);
1330
1188
  }
1331
1189
  s0 = peg$f10(s1, s2);
1332
1190
  } else {
@@ -1334,7 +1192,7 @@ var ftl = (function (exports) {
1334
1192
  s0 = peg$FAILED;
1335
1193
  }
1336
1194
 
1337
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1195
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1338
1196
 
1339
1197
  return s0;
1340
1198
  }
@@ -1343,7 +1201,7 @@ var ftl = (function (exports) {
1343
1201
  let s0, s1, s2, s3, s5, s7;
1344
1202
 
1345
1203
  const key = peg$currPos * 38 + 14;
1346
- const cached = peg$resultsCache[key];
1204
+ const cached = peg$resultsCache.get(key);
1347
1205
 
1348
1206
  if (cached) {
1349
1207
  peg$currPos = cached.nextPos;
@@ -1355,30 +1213,7 @@ var ftl = (function (exports) {
1355
1213
  s1 = peg$parseEqExpression();
1356
1214
  if (s1 !== peg$FAILED) {
1357
1215
  s2 = [];
1358
- s3 = peg$currPos;
1359
- peg$parse_();
1360
- if (input.substr(peg$currPos, 2) === peg$c24) {
1361
- s5 = peg$c24;
1362
- peg$currPos += 2;
1363
- } else {
1364
- s5 = peg$FAILED;
1365
- if (peg$silentFails === 0) { peg$fail(peg$e15); }
1366
- }
1367
- if (s5 !== peg$FAILED) {
1368
- peg$parse_();
1369
- s7 = peg$parseEqExpression();
1370
- if (s7 !== peg$FAILED) {
1371
- s3 = s7;
1372
- } else {
1373
- peg$currPos = s3;
1374
- s3 = peg$FAILED;
1375
- }
1376
- } else {
1377
- peg$currPos = s3;
1378
- s3 = peg$FAILED;
1379
- }
1380
- while (s3 !== peg$FAILED) {
1381
- s2.push(s3);
1216
+ for (;;) {
1382
1217
  s3 = peg$currPos;
1383
1218
  peg$parse_();
1384
1219
  if (input.substr(peg$currPos, 2) === peg$c24) {
@@ -1401,6 +1236,8 @@ var ftl = (function (exports) {
1401
1236
  peg$currPos = s3;
1402
1237
  s3 = peg$FAILED;
1403
1238
  }
1239
+ if (s3 === peg$FAILED) { break; }
1240
+ s2.push(s3);
1404
1241
  }
1405
1242
  s0 = peg$f11(s1, s2);
1406
1243
  } else {
@@ -1408,7 +1245,7 @@ var ftl = (function (exports) {
1408
1245
  s0 = peg$FAILED;
1409
1246
  }
1410
1247
 
1411
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1248
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1412
1249
 
1413
1250
  return s0;
1414
1251
  }
@@ -1417,7 +1254,7 @@ var ftl = (function (exports) {
1417
1254
  let s0, s1, s2, s3, s5, s7;
1418
1255
 
1419
1256
  const key = peg$currPos * 38 + 15;
1420
- const cached = peg$resultsCache[key];
1257
+ const cached = peg$resultsCache.get(key);
1421
1258
 
1422
1259
  if (cached) {
1423
1260
  peg$currPos = cached.nextPos;
@@ -1429,24 +1266,7 @@ var ftl = (function (exports) {
1429
1266
  s1 = peg$parseRelExpression();
1430
1267
  if (s1 !== peg$FAILED) {
1431
1268
  s2 = [];
1432
- s3 = peg$currPos;
1433
- peg$parse_();
1434
- s5 = peg$parseEqualityOp();
1435
- if (s5 !== peg$FAILED) {
1436
- peg$parse_();
1437
- s7 = peg$parseRelExpression();
1438
- if (s7 !== peg$FAILED) {
1439
- s3 = peg$f12(s1, s5, s7);
1440
- } else {
1441
- peg$currPos = s3;
1442
- s3 = peg$FAILED;
1443
- }
1444
- } else {
1445
- peg$currPos = s3;
1446
- s3 = peg$FAILED;
1447
- }
1448
- while (s3 !== peg$FAILED) {
1449
- s2.push(s3);
1269
+ for (;;) {
1450
1270
  s3 = peg$currPos;
1451
1271
  peg$parse_();
1452
1272
  s5 = peg$parseEqualityOp();
@@ -1463,6 +1283,8 @@ var ftl = (function (exports) {
1463
1283
  peg$currPos = s3;
1464
1284
  s3 = peg$FAILED;
1465
1285
  }
1286
+ if (s3 === peg$FAILED) { break; }
1287
+ s2.push(s3);
1466
1288
  }
1467
1289
  s0 = peg$f13(s1, s2);
1468
1290
  } else {
@@ -1470,7 +1292,7 @@ var ftl = (function (exports) {
1470
1292
  s0 = peg$FAILED;
1471
1293
  }
1472
1294
 
1473
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1295
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1474
1296
 
1475
1297
  return s0;
1476
1298
  }
@@ -1479,7 +1301,7 @@ var ftl = (function (exports) {
1479
1301
  let s0, s1, s2, s3, s5, s7;
1480
1302
 
1481
1303
  const key = peg$currPos * 38 + 16;
1482
- const cached = peg$resultsCache[key];
1304
+ const cached = peg$resultsCache.get(key);
1483
1305
 
1484
1306
  if (cached) {
1485
1307
  peg$currPos = cached.nextPos;
@@ -1491,24 +1313,7 @@ var ftl = (function (exports) {
1491
1313
  s1 = peg$parseNotExpression();
1492
1314
  if (s1 !== peg$FAILED) {
1493
1315
  s2 = [];
1494
- s3 = peg$currPos;
1495
- peg$parse_();
1496
- s5 = peg$parseRelationalOp();
1497
- if (s5 !== peg$FAILED) {
1498
- peg$parse_();
1499
- s7 = peg$parseNotExpression();
1500
- if (s7 !== peg$FAILED) {
1501
- s3 = peg$f14(s1, s5, s7);
1502
- } else {
1503
- peg$currPos = s3;
1504
- s3 = peg$FAILED;
1505
- }
1506
- } else {
1507
- peg$currPos = s3;
1508
- s3 = peg$FAILED;
1509
- }
1510
- while (s3 !== peg$FAILED) {
1511
- s2.push(s3);
1316
+ for (;;) {
1512
1317
  s3 = peg$currPos;
1513
1318
  peg$parse_();
1514
1319
  s5 = peg$parseRelationalOp();
@@ -1525,6 +1330,8 @@ var ftl = (function (exports) {
1525
1330
  peg$currPos = s3;
1526
1331
  s3 = peg$FAILED;
1527
1332
  }
1333
+ if (s3 === peg$FAILED) { break; }
1334
+ s2.push(s3);
1528
1335
  }
1529
1336
  s0 = peg$f15(s1, s2);
1530
1337
  } else {
@@ -1532,7 +1339,7 @@ var ftl = (function (exports) {
1532
1339
  s0 = peg$FAILED;
1533
1340
  }
1534
1341
 
1535
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1342
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1536
1343
 
1537
1344
  return s0;
1538
1345
  }
@@ -1541,7 +1348,7 @@ var ftl = (function (exports) {
1541
1348
  let s0, s1, s3;
1542
1349
 
1543
1350
  const key = peg$currPos * 38 + 17;
1544
- const cached = peg$resultsCache[key];
1351
+ const cached = peg$resultsCache.get(key);
1545
1352
 
1546
1353
  if (cached) {
1547
1354
  peg$currPos = cached.nextPos;
@@ -1574,7 +1381,7 @@ var ftl = (function (exports) {
1574
1381
  s0 = peg$parseAccess();
1575
1382
  }
1576
1383
 
1577
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1384
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1578
1385
 
1579
1386
  return s0;
1580
1387
  }
@@ -1583,7 +1390,7 @@ var ftl = (function (exports) {
1583
1390
  let s0, s1, s3, s4, s5;
1584
1391
 
1585
1392
  const key = peg$currPos * 38 + 18;
1586
- const cached = peg$resultsCache[key];
1393
+ const cached = peg$resultsCache.get(key);
1587
1394
 
1588
1395
  if (cached) {
1589
1396
  peg$currPos = cached.nextPos;
@@ -1596,29 +1403,20 @@ var ftl = (function (exports) {
1596
1403
  if (s1 !== peg$FAILED) {
1597
1404
  peg$parse_();
1598
1405
  s3 = [];
1599
- s4 = peg$currPos;
1600
- s5 = peg$parseAccessExpression();
1601
- if (s5 !== peg$FAILED) {
1602
- peg$parse_();
1603
- s4 = s5;
1604
- } else {
1605
- peg$currPos = s4;
1606
- s4 = peg$FAILED;
1607
- }
1608
- if (s4 !== peg$FAILED) {
1609
- while (s4 !== peg$FAILED) {
1610
- s3.push(s4);
1611
- s4 = peg$currPos;
1612
- s5 = peg$parseAccessExpression();
1613
- if (s5 !== peg$FAILED) {
1614
- peg$parse_();
1615
- s4 = s5;
1616
- } else {
1617
- peg$currPos = s4;
1618
- s4 = peg$FAILED;
1619
- }
1406
+ for (;;) {
1407
+ s4 = peg$currPos;
1408
+ s5 = peg$parseAccessExpression();
1409
+ if (s5 !== peg$FAILED) {
1410
+ peg$parse_();
1411
+ s4 = s5;
1412
+ } else {
1413
+ peg$currPos = s4;
1414
+ s4 = peg$FAILED;
1620
1415
  }
1621
- } else {
1416
+ if (s4 === peg$FAILED) { break; }
1417
+ s3.push(s4);
1418
+ }
1419
+ if (s3.length < 1) {
1622
1420
  s3 = peg$FAILED;
1623
1421
  }
1624
1422
  if (s3 !== peg$FAILED) {
@@ -1635,7 +1433,7 @@ var ftl = (function (exports) {
1635
1433
  s0 = peg$parseGroupingExpression();
1636
1434
  }
1637
1435
 
1638
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1436
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1639
1437
 
1640
1438
  return s0;
1641
1439
  }
@@ -1644,7 +1442,7 @@ var ftl = (function (exports) {
1644
1442
  let s0;
1645
1443
 
1646
1444
  const key = peg$currPos * 38 + 19;
1647
- const cached = peg$resultsCache[key];
1445
+ const cached = peg$resultsCache.get(key);
1648
1446
 
1649
1447
  if (cached) {
1650
1448
  peg$currPos = cached.nextPos;
@@ -1660,7 +1458,7 @@ var ftl = (function (exports) {
1660
1458
  }
1661
1459
  }
1662
1460
 
1663
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1461
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1664
1462
 
1665
1463
  return s0;
1666
1464
  }
@@ -1669,7 +1467,7 @@ var ftl = (function (exports) {
1669
1467
  let s0, s1, s3;
1670
1468
 
1671
1469
  const key = peg$currPos * 38 + 20;
1672
- const cached = peg$resultsCache[key];
1470
+ const cached = peg$resultsCache.get(key);
1673
1471
 
1674
1472
  if (cached) {
1675
1473
  peg$currPos = cached.nextPos;
@@ -1714,7 +1512,7 @@ var ftl = (function (exports) {
1714
1512
  if (peg$silentFails === 0) { peg$fail(peg$e17); }
1715
1513
  }
1716
1514
 
1717
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1515
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1718
1516
 
1719
1517
  return s0;
1720
1518
  }
@@ -1723,7 +1521,7 @@ var ftl = (function (exports) {
1723
1521
  let s0, s1, s2, s4, s6;
1724
1522
 
1725
1523
  const key = peg$currPos * 38 + 21;
1726
- const cached = peg$resultsCache[key];
1524
+ const cached = peg$resultsCache.get(key);
1727
1525
 
1728
1526
  if (cached) {
1729
1527
  peg$currPos = cached.nextPos;
@@ -1782,7 +1580,7 @@ var ftl = (function (exports) {
1782
1580
  if (peg$silentFails === 0) { peg$fail(peg$e20); }
1783
1581
  }
1784
1582
 
1785
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1583
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1786
1584
 
1787
1585
  return s0;
1788
1586
  }
@@ -1791,7 +1589,7 @@ var ftl = (function (exports) {
1791
1589
  let s0, s1, s2, s4, s5, s6, s7, s9;
1792
1590
 
1793
1591
  const key = peg$currPos * 38 + 22;
1794
- const cached = peg$resultsCache[key];
1592
+ const cached = peg$resultsCache.get(key);
1795
1593
 
1796
1594
  if (cached) {
1797
1595
  peg$currPos = cached.nextPos;
@@ -1833,30 +1631,7 @@ var ftl = (function (exports) {
1833
1631
  s4 = null;
1834
1632
  }
1835
1633
  s5 = [];
1836
- s6 = peg$currPos;
1837
- if (input.charCodeAt(peg$currPos) === 44) {
1838
- s7 = peg$c34;
1839
- peg$currPos++;
1840
- } else {
1841
- s7 = peg$FAILED;
1842
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
1843
- }
1844
- if (s7 !== peg$FAILED) {
1845
- peg$parse_();
1846
- s9 = peg$parseTernaryExpression();
1847
- if (s9 !== peg$FAILED) {
1848
- peg$parse_();
1849
- s6 = s9;
1850
- } else {
1851
- peg$currPos = s6;
1852
- s6 = peg$FAILED;
1853
- }
1854
- } else {
1855
- peg$currPos = s6;
1856
- s6 = peg$FAILED;
1857
- }
1858
- while (s6 !== peg$FAILED) {
1859
- s5.push(s6);
1634
+ for (;;) {
1860
1635
  s6 = peg$currPos;
1861
1636
  if (input.charCodeAt(peg$currPos) === 44) {
1862
1637
  s7 = peg$c34;
@@ -1879,6 +1654,8 @@ var ftl = (function (exports) {
1879
1654
  peg$currPos = s6;
1880
1655
  s6 = peg$FAILED;
1881
1656
  }
1657
+ if (s6 === peg$FAILED) { break; }
1658
+ s5.push(s6);
1882
1659
  }
1883
1660
  if (input.charCodeAt(peg$currPos) === 41) {
1884
1661
  s6 = peg$c36;
@@ -1903,7 +1680,7 @@ var ftl = (function (exports) {
1903
1680
  if (peg$silentFails === 0) { peg$fail(peg$e23); }
1904
1681
  }
1905
1682
 
1906
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1683
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1907
1684
 
1908
1685
  return s0;
1909
1686
  }
@@ -1912,7 +1689,7 @@ var ftl = (function (exports) {
1912
1689
  let s0, s1, s3, s5;
1913
1690
 
1914
1691
  const key = peg$currPos * 38 + 23;
1915
- const cached = peg$resultsCache[key];
1692
+ const cached = peg$resultsCache.get(key);
1916
1693
 
1917
1694
  if (cached) {
1918
1695
  peg$currPos = cached.nextPos;
@@ -1964,7 +1741,7 @@ var ftl = (function (exports) {
1964
1741
  }
1965
1742
  }
1966
1743
 
1967
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1744
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
1968
1745
 
1969
1746
  return s0;
1970
1747
  }
@@ -1973,7 +1750,7 @@ var ftl = (function (exports) {
1973
1750
  let s0, s1, s2, s4, s5, s6, s7, s9;
1974
1751
 
1975
1752
  const key = peg$currPos * 38 + 24;
1976
- const cached = peg$resultsCache[key];
1753
+ const cached = peg$resultsCache.get(key);
1977
1754
 
1978
1755
  if (cached) {
1979
1756
  peg$currPos = cached.nextPos;
@@ -2007,30 +1784,7 @@ var ftl = (function (exports) {
2007
1784
  s4 = null;
2008
1785
  }
2009
1786
  s5 = [];
2010
- s6 = peg$currPos;
2011
- if (input.charCodeAt(peg$currPos) === 44) {
2012
- s7 = peg$c34;
2013
- peg$currPos++;
2014
- } else {
2015
- s7 = peg$FAILED;
2016
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
2017
- }
2018
- if (s7 !== peg$FAILED) {
2019
- peg$parse_();
2020
- s9 = peg$parseTernaryExpression();
2021
- if (s9 !== peg$FAILED) {
2022
- peg$parse_();
2023
- s6 = s9;
2024
- } else {
2025
- peg$currPos = s6;
2026
- s6 = peg$FAILED;
2027
- }
2028
- } else {
2029
- peg$currPos = s6;
2030
- s6 = peg$FAILED;
2031
- }
2032
- while (s6 !== peg$FAILED) {
2033
- s5.push(s6);
1787
+ for (;;) {
2034
1788
  s6 = peg$currPos;
2035
1789
  if (input.charCodeAt(peg$currPos) === 44) {
2036
1790
  s7 = peg$c34;
@@ -2053,6 +1807,8 @@ var ftl = (function (exports) {
2053
1807
  peg$currPos = s6;
2054
1808
  s6 = peg$FAILED;
2055
1809
  }
1810
+ if (s6 === peg$FAILED) { break; }
1811
+ s5.push(s6);
2056
1812
  }
2057
1813
  if (input.charCodeAt(peg$currPos) === 41) {
2058
1814
  s6 = peg$c36;
@@ -2081,7 +1837,7 @@ var ftl = (function (exports) {
2081
1837
  if (peg$silentFails === 0) { peg$fail(peg$e27); }
2082
1838
  }
2083
1839
 
2084
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1840
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2085
1841
 
2086
1842
  return s0;
2087
1843
  }
@@ -2090,7 +1846,7 @@ var ftl = (function (exports) {
2090
1846
  let s0;
2091
1847
 
2092
1848
  const key = peg$currPos * 38 + 25;
2093
- const cached = peg$resultsCache[key];
1849
+ const cached = peg$resultsCache.get(key);
2094
1850
 
2095
1851
  if (cached) {
2096
1852
  peg$currPos = cached.nextPos;
@@ -2109,7 +1865,7 @@ var ftl = (function (exports) {
2109
1865
  }
2110
1866
  }
2111
1867
 
2112
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
1868
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2113
1869
 
2114
1870
  return s0;
2115
1871
  }
@@ -2118,7 +1874,7 @@ var ftl = (function (exports) {
2118
1874
  let s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;
2119
1875
 
2120
1876
  const key = peg$currPos * 38 + 26;
2121
- const cached = peg$resultsCache[key];
1877
+ const cached = peg$resultsCache.get(key);
2122
1878
 
2123
1879
  if (cached) {
2124
1880
  peg$currPos = cached.nextPos;
@@ -2142,25 +1898,18 @@ var ftl = (function (exports) {
2142
1898
  }
2143
1899
  s4 = peg$currPos;
2144
1900
  s5 = [];
2145
- s6 = input.charAt(peg$currPos);
2146
- if (peg$r1.test(s6)) {
2147
- peg$currPos++;
2148
- } else {
2149
- s6 = peg$FAILED;
2150
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
2151
- }
2152
- if (s6 !== peg$FAILED) {
2153
- while (s6 !== peg$FAILED) {
2154
- s5.push(s6);
2155
- s6 = input.charAt(peg$currPos);
2156
- if (peg$r1.test(s6)) {
2157
- peg$currPos++;
2158
- } else {
2159
- s6 = peg$FAILED;
2160
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
2161
- }
1901
+ for (;;) {
1902
+ s6 = input.charAt(peg$currPos);
1903
+ if ((peg$charCode = s6.charCodeAt(0), (peg$charCode >= 48 && peg$charCode <= 57))) {
1904
+ peg$currPos++;
1905
+ } else {
1906
+ s6 = peg$FAILED;
1907
+ if (peg$silentFails === 0) { peg$fail(peg$e30); }
2162
1908
  }
2163
- } else {
1909
+ if (s6 === peg$FAILED) { break; }
1910
+ s5.push(s6);
1911
+ }
1912
+ if (s5.length < 1) {
2164
1913
  s5 = peg$FAILED;
2165
1914
  }
2166
1915
  if (s5 !== peg$FAILED) {
@@ -2174,22 +1923,16 @@ var ftl = (function (exports) {
2174
1923
  }
2175
1924
  if (s7 !== peg$FAILED) {
2176
1925
  s8 = [];
2177
- s9 = input.charAt(peg$currPos);
2178
- if (peg$r1.test(s9)) {
2179
- peg$currPos++;
2180
- } else {
2181
- s9 = peg$FAILED;
2182
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
2183
- }
2184
- while (s9 !== peg$FAILED) {
2185
- s8.push(s9);
1926
+ for (;;) {
2186
1927
  s9 = input.charAt(peg$currPos);
2187
- if (peg$r1.test(s9)) {
1928
+ if ((peg$charCode = s9.charCodeAt(0), (peg$charCode >= 48 && peg$charCode <= 57))) {
2188
1929
  peg$currPos++;
2189
1930
  } else {
2190
1931
  s9 = peg$FAILED;
2191
1932
  if (peg$silentFails === 0) { peg$fail(peg$e30); }
2192
1933
  }
1934
+ if (s9 === peg$FAILED) { break; }
1935
+ s8.push(s9);
2193
1936
  }
2194
1937
  s7 = [s7, s8];
2195
1938
  s6 = s7;
@@ -2217,25 +1960,18 @@ var ftl = (function (exports) {
2217
1960
  }
2218
1961
  if (s5 !== peg$FAILED) {
2219
1962
  s6 = [];
2220
- s7 = input.charAt(peg$currPos);
2221
- if (peg$r1.test(s7)) {
2222
- peg$currPos++;
2223
- } else {
2224
- s7 = peg$FAILED;
2225
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
2226
- }
2227
- if (s7 !== peg$FAILED) {
2228
- while (s7 !== peg$FAILED) {
2229
- s6.push(s7);
2230
- s7 = input.charAt(peg$currPos);
2231
- if (peg$r1.test(s7)) {
2232
- peg$currPos++;
2233
- } else {
2234
- s7 = peg$FAILED;
2235
- if (peg$silentFails === 0) { peg$fail(peg$e30); }
2236
- }
1963
+ for (;;) {
1964
+ s7 = input.charAt(peg$currPos);
1965
+ if ((peg$charCode = s7.charCodeAt(0), (peg$charCode >= 48 && peg$charCode <= 57))) {
1966
+ peg$currPos++;
1967
+ } else {
1968
+ s7 = peg$FAILED;
1969
+ if (peg$silentFails === 0) { peg$fail(peg$e30); }
2237
1970
  }
2238
- } else {
1971
+ if (s7 === peg$FAILED) { break; }
1972
+ s6.push(s7);
1973
+ }
1974
+ if (s6.length < 1) {
2239
1975
  s6 = peg$FAILED;
2240
1976
  }
2241
1977
  if (s6 !== peg$FAILED) {
@@ -2272,7 +2008,7 @@ var ftl = (function (exports) {
2272
2008
  if (peg$silentFails === 0) { peg$fail(peg$e28); }
2273
2009
  }
2274
2010
 
2275
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2011
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2276
2012
 
2277
2013
  return s0;
2278
2014
  }
@@ -2281,7 +2017,7 @@ var ftl = (function (exports) {
2281
2017
  let s0, s1, s2, s3, s4;
2282
2018
 
2283
2019
  const key = peg$currPos * 38 + 27;
2284
- const cached = peg$resultsCache[key];
2020
+ const cached = peg$resultsCache.get(key);
2285
2021
 
2286
2022
  if (cached) {
2287
2023
  peg$currPos = cached.nextPos;
@@ -2301,22 +2037,16 @@ var ftl = (function (exports) {
2301
2037
  if (s1 !== peg$FAILED) {
2302
2038
  s2 = peg$currPos;
2303
2039
  s3 = [];
2304
- s4 = input.charAt(peg$currPos);
2305
- if (peg$r2.test(s4)) {
2306
- peg$currPos++;
2307
- } else {
2308
- s4 = peg$FAILED;
2309
- if (peg$silentFails === 0) { peg$fail(peg$e33); }
2310
- }
2311
- while (s4 !== peg$FAILED) {
2312
- s3.push(s4);
2040
+ for (;;) {
2313
2041
  s4 = input.charAt(peg$currPos);
2314
- if (peg$r2.test(s4)) {
2042
+ if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 39)) {
2315
2043
  peg$currPos++;
2316
2044
  } else {
2317
2045
  s4 = peg$FAILED;
2318
2046
  if (peg$silentFails === 0) { peg$fail(peg$e33); }
2319
2047
  }
2048
+ if (s4 === peg$FAILED) { break; }
2049
+ s3.push(s4);
2320
2050
  }
2321
2051
  s2 = input.substring(s2, peg$currPos);
2322
2052
  if (input.charCodeAt(peg$currPos) === 39) {
@@ -2348,22 +2078,16 @@ var ftl = (function (exports) {
2348
2078
  if (s1 !== peg$FAILED) {
2349
2079
  s2 = peg$currPos;
2350
2080
  s3 = [];
2351
- s4 = input.charAt(peg$currPos);
2352
- if (peg$r3.test(s4)) {
2353
- peg$currPos++;
2354
- } else {
2355
- s4 = peg$FAILED;
2356
- if (peg$silentFails === 0) { peg$fail(peg$e35); }
2357
- }
2358
- while (s4 !== peg$FAILED) {
2359
- s3.push(s4);
2081
+ for (;;) {
2360
2082
  s4 = input.charAt(peg$currPos);
2361
- if (peg$r3.test(s4)) {
2083
+ if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 34)) {
2362
2084
  peg$currPos++;
2363
2085
  } else {
2364
2086
  s4 = peg$FAILED;
2365
2087
  if (peg$silentFails === 0) { peg$fail(peg$e35); }
2366
2088
  }
2089
+ if (s4 === peg$FAILED) { break; }
2090
+ s3.push(s4);
2367
2091
  }
2368
2092
  s2 = input.substring(s2, peg$currPos);
2369
2093
  if (input.charCodeAt(peg$currPos) === 34) {
@@ -2394,16 +2118,13 @@ var ftl = (function (exports) {
2394
2118
  }
2395
2119
  if (s1 !== peg$FAILED) {
2396
2120
  s2 = [];
2397
- s3 = peg$parseTemplateStringExpression();
2398
- if (s3 === peg$FAILED) {
2399
- s3 = peg$parseTemplateStringLiteral();
2400
- }
2401
- while (s3 !== peg$FAILED) {
2402
- s2.push(s3);
2121
+ for (;;) {
2403
2122
  s3 = peg$parseTemplateStringExpression();
2404
2123
  if (s3 === peg$FAILED) {
2405
2124
  s3 = peg$parseTemplateStringLiteral();
2406
2125
  }
2126
+ if (s3 === peg$FAILED) { break; }
2127
+ s2.push(s3);
2407
2128
  }
2408
2129
  if (input.charCodeAt(peg$currPos) === 96) {
2409
2130
  s3 = peg$c42;
@@ -2430,7 +2151,7 @@ var ftl = (function (exports) {
2430
2151
  if (peg$silentFails === 0) { peg$fail(peg$e31); }
2431
2152
  }
2432
2153
 
2433
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2154
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2434
2155
 
2435
2156
  return s0;
2436
2157
  }
@@ -2439,7 +2160,7 @@ var ftl = (function (exports) {
2439
2160
  let s0, s1, s3, s5;
2440
2161
 
2441
2162
  const key = peg$currPos * 38 + 28;
2442
- const cached = peg$resultsCache[key];
2163
+ const cached = peg$resultsCache.get(key);
2443
2164
 
2444
2165
  if (cached) {
2445
2166
  peg$currPos = cached.nextPos;
@@ -2488,7 +2209,7 @@ var ftl = (function (exports) {
2488
2209
  if (peg$silentFails === 0) { peg$fail(peg$e37); }
2489
2210
  }
2490
2211
 
2491
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2212
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2492
2213
 
2493
2214
  return s0;
2494
2215
  }
@@ -2497,7 +2218,7 @@ var ftl = (function (exports) {
2497
2218
  let s0, s1, s2, s3, s4;
2498
2219
 
2499
2220
  const key = peg$currPos * 38 + 29;
2500
- const cached = peg$resultsCache[key];
2221
+ const cached = peg$resultsCache.get(key);
2501
2222
 
2502
2223
  if (cached) {
2503
2224
  peg$currPos = cached.nextPos;
@@ -2508,123 +2229,60 @@ var ftl = (function (exports) {
2508
2229
  peg$silentFails++;
2509
2230
  s0 = peg$currPos;
2510
2231
  s1 = [];
2511
- s2 = peg$currPos;
2512
- s3 = [];
2513
- s4 = input.charAt(peg$currPos);
2514
- if (peg$r4.test(s4)) {
2515
- peg$currPos++;
2516
- } else {
2517
- s4 = peg$FAILED;
2518
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2519
- }
2520
- if (s4 !== peg$FAILED) {
2521
- while (s4 !== peg$FAILED) {
2522
- s3.push(s4);
2232
+ for (;;) {
2233
+ s2 = peg$currPos;
2234
+ s3 = [];
2235
+ for (;;) {
2523
2236
  s4 = input.charAt(peg$currPos);
2524
- if (peg$r4.test(s4)) {
2237
+ if (s4 !== "" && !(peg$charCode = s4.charCodeAt(0), peg$charCode === 92 || peg$charCode === 96 || peg$charCode === 123)) {
2525
2238
  peg$currPos++;
2526
2239
  } else {
2527
2240
  s4 = peg$FAILED;
2528
2241
  if (peg$silentFails === 0) { peg$fail(peg$e40); }
2529
2242
  }
2243
+ if (s4 === peg$FAILED) { break; }
2244
+ s3.push(s4);
2530
2245
  }
2531
- } else {
2532
- s3 = peg$FAILED;
2533
- }
2534
- if (s3 !== peg$FAILED) {
2535
- s2 = input.substring(s2, peg$currPos);
2536
- } else {
2537
- s2 = s3;
2538
- }
2539
- if (s2 === peg$FAILED) {
2540
- s2 = peg$currPos;
2541
- if (input.charCodeAt(peg$currPos) === 92) {
2542
- s3 = peg$c7;
2543
- peg$currPos++;
2544
- } else {
2246
+ if (s3.length < 1) {
2545
2247
  s3 = peg$FAILED;
2546
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
2547
2248
  }
2548
2249
  if (s3 !== peg$FAILED) {
2549
- if (input.length > peg$currPos) {
2550
- s4 = input.charAt(peg$currPos);
2551
- peg$currPos++;
2552
- } else {
2553
- s4 = peg$FAILED;
2554
- if (peg$silentFails === 0) { peg$fail(peg$e8); }
2555
- }
2556
- if (s4 !== peg$FAILED) {
2557
- s2 = peg$f28(s4);
2558
- } else {
2559
- peg$currPos = s2;
2560
- s2 = peg$FAILED;
2561
- }
2250
+ s2 = input.substring(s2, peg$currPos);
2562
2251
  } else {
2563
- peg$currPos = s2;
2564
- s2 = peg$FAILED;
2252
+ s2 = s3;
2565
2253
  }
2566
- }
2567
- if (s2 !== peg$FAILED) {
2568
- while (s2 !== peg$FAILED) {
2569
- s1.push(s2);
2254
+ if (s2 === peg$FAILED) {
2570
2255
  s2 = peg$currPos;
2571
- s3 = [];
2572
- s4 = input.charAt(peg$currPos);
2573
- if (peg$r4.test(s4)) {
2256
+ if (input.charCodeAt(peg$currPos) === 92) {
2257
+ s3 = peg$c7;
2574
2258
  peg$currPos++;
2575
- } else {
2576
- s4 = peg$FAILED;
2577
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2578
- }
2579
- if (s4 !== peg$FAILED) {
2580
- while (s4 !== peg$FAILED) {
2581
- s3.push(s4);
2582
- s4 = input.charAt(peg$currPos);
2583
- if (peg$r4.test(s4)) {
2584
- peg$currPos++;
2585
- } else {
2586
- s4 = peg$FAILED;
2587
- if (peg$silentFails === 0) { peg$fail(peg$e40); }
2588
- }
2589
- }
2590
2259
  } else {
2591
2260
  s3 = peg$FAILED;
2261
+ if (peg$silentFails === 0) { peg$fail(peg$e7); }
2592
2262
  }
2593
2263
  if (s3 !== peg$FAILED) {
2594
- s2 = input.substring(s2, peg$currPos);
2595
- } else {
2596
- s2 = s3;
2597
- }
2598
- if (s2 === peg$FAILED) {
2599
- s2 = peg$currPos;
2600
- if (input.charCodeAt(peg$currPos) === 92) {
2601
- s3 = peg$c7;
2264
+ if (input.length > peg$currPos) {
2265
+ s4 = input.charAt(peg$currPos);
2602
2266
  peg$currPos++;
2603
2267
  } else {
2604
- s3 = peg$FAILED;
2605
- if (peg$silentFails === 0) { peg$fail(peg$e7); }
2268
+ s4 = peg$FAILED;
2269
+ if (peg$silentFails === 0) { peg$fail(peg$e8); }
2606
2270
  }
2607
- if (s3 !== peg$FAILED) {
2608
- if (input.length > peg$currPos) {
2609
- s4 = input.charAt(peg$currPos);
2610
- peg$currPos++;
2611
- } else {
2612
- s4 = peg$FAILED;
2613
- if (peg$silentFails === 0) { peg$fail(peg$e8); }
2614
- }
2615
- if (s4 !== peg$FAILED) {
2616
- s2 = peg$f28(s4);
2617
- } else {
2618
- peg$currPos = s2;
2619
- s2 = peg$FAILED;
2620
- }
2271
+ if (s4 !== peg$FAILED) {
2272
+ s2 = peg$f28(s4);
2621
2273
  } else {
2622
2274
  peg$currPos = s2;
2623
2275
  s2 = peg$FAILED;
2624
2276
  }
2277
+ } else {
2278
+ peg$currPos = s2;
2279
+ s2 = peg$FAILED;
2625
2280
  }
2626
2281
  }
2627
- } else {
2282
+ if (s2 === peg$FAILED) { break; }
2283
+ s1.push(s2);
2284
+ }
2285
+ if (s1.length < 1) {
2628
2286
  s1 = peg$FAILED;
2629
2287
  }
2630
2288
  if (s1 !== peg$FAILED) {
@@ -2651,7 +2309,7 @@ var ftl = (function (exports) {
2651
2309
  if (peg$silentFails === 0) { peg$fail(peg$e39); }
2652
2310
  }
2653
2311
 
2654
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2312
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2655
2313
 
2656
2314
  return s0;
2657
2315
  }
@@ -2660,7 +2318,7 @@ var ftl = (function (exports) {
2660
2318
  let s0, s1, s3, s5, s6, s7, s9;
2661
2319
 
2662
2320
  const key = peg$currPos * 38 + 30;
2663
- const cached = peg$resultsCache[key];
2321
+ const cached = peg$resultsCache.get(key);
2664
2322
 
2665
2323
  if (cached) {
2666
2324
  peg$currPos = cached.nextPos;
@@ -2685,30 +2343,7 @@ var ftl = (function (exports) {
2685
2343
  }
2686
2344
  peg$parse_();
2687
2345
  s5 = [];
2688
- s6 = peg$currPos;
2689
- if (input.charCodeAt(peg$currPos) === 44) {
2690
- s7 = peg$c34;
2691
- peg$currPos++;
2692
- } else {
2693
- s7 = peg$FAILED;
2694
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
2695
- }
2696
- if (s7 !== peg$FAILED) {
2697
- peg$parse_();
2698
- s9 = peg$parseTernaryExpression();
2699
- if (s9 !== peg$FAILED) {
2700
- peg$parse_();
2701
- s6 = s9;
2702
- } else {
2703
- peg$currPos = s6;
2704
- s6 = peg$FAILED;
2705
- }
2706
- } else {
2707
- peg$currPos = s6;
2708
- s6 = peg$FAILED;
2709
- }
2710
- while (s6 !== peg$FAILED) {
2711
- s5.push(s6);
2346
+ for (;;) {
2712
2347
  s6 = peg$currPos;
2713
2348
  if (input.charCodeAt(peg$currPos) === 44) {
2714
2349
  s7 = peg$c34;
@@ -2731,6 +2366,8 @@ var ftl = (function (exports) {
2731
2366
  peg$currPos = s6;
2732
2367
  s6 = peg$FAILED;
2733
2368
  }
2369
+ if (s6 === peg$FAILED) { break; }
2370
+ s5.push(s6);
2734
2371
  }
2735
2372
  if (input.charCodeAt(peg$currPos) === 93) {
2736
2373
  s6 = peg$c31;
@@ -2755,7 +2392,7 @@ var ftl = (function (exports) {
2755
2392
  if (peg$silentFails === 0) { peg$fail(peg$e41); }
2756
2393
  }
2757
2394
 
2758
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2395
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2759
2396
 
2760
2397
  return s0;
2761
2398
  }
@@ -2764,7 +2401,7 @@ var ftl = (function (exports) {
2764
2401
  let s0, s1, s3, s4, s5, s6, s7, s8, s9, s11, s13;
2765
2402
 
2766
2403
  const key = peg$currPos * 38 + 31;
2767
- const cached = peg$resultsCache[key];
2404
+ const cached = peg$resultsCache.get(key);
2768
2405
 
2769
2406
  if (cached) {
2770
2407
  peg$currPos = cached.nextPos;
@@ -2816,50 +2453,7 @@ var ftl = (function (exports) {
2816
2453
  }
2817
2454
  s4 = peg$parse_();
2818
2455
  s5 = [];
2819
- s6 = peg$currPos;
2820
- if (input.charCodeAt(peg$currPos) === 44) {
2821
- s7 = peg$c34;
2822
- peg$currPos++;
2823
- } else {
2824
- s7 = peg$FAILED;
2825
- if (peg$silentFails === 0) { peg$fail(peg$e25); }
2826
- }
2827
- if (s7 !== peg$FAILED) {
2828
- s8 = peg$parse_();
2829
- s9 = peg$parseStringLiteral();
2830
- if (s9 !== peg$FAILED) {
2831
- peg$parse_();
2832
- if (input.charCodeAt(peg$currPos) === 58) {
2833
- s11 = peg$c15;
2834
- peg$currPos++;
2835
- } else {
2836
- s11 = peg$FAILED;
2837
- if (peg$silentFails === 0) { peg$fail(peg$e11); }
2838
- }
2839
- if (s11 !== peg$FAILED) {
2840
- peg$parse_();
2841
- s13 = peg$parseTernaryExpression();
2842
- if (s13 !== peg$FAILED) {
2843
- peg$parse_();
2844
- s6 = [ s9, s13 ];
2845
- } else {
2846
- peg$currPos = s6;
2847
- s6 = peg$FAILED;
2848
- }
2849
- } else {
2850
- peg$currPos = s6;
2851
- s6 = peg$FAILED;
2852
- }
2853
- } else {
2854
- peg$currPos = s6;
2855
- s6 = peg$FAILED;
2856
- }
2857
- } else {
2858
- peg$currPos = s6;
2859
- s6 = peg$FAILED;
2860
- }
2861
- while (s6 !== peg$FAILED) {
2862
- s5.push(s6);
2456
+ for (;;) {
2863
2457
  s6 = peg$currPos;
2864
2458
  if (input.charCodeAt(peg$currPos) === 44) {
2865
2459
  s7 = peg$c34;
@@ -2902,6 +2496,8 @@ var ftl = (function (exports) {
2902
2496
  peg$currPos = s6;
2903
2497
  s6 = peg$FAILED;
2904
2498
  }
2499
+ if (s6 === peg$FAILED) { break; }
2500
+ s5.push(s6);
2905
2501
  }
2906
2502
  if (input.charCodeAt(peg$currPos) === 125) {
2907
2503
  s6 = peg$c43;
@@ -2926,7 +2522,7 @@ var ftl = (function (exports) {
2926
2522
  if (peg$silentFails === 0) { peg$fail(peg$e42); }
2927
2523
  }
2928
2524
 
2929
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2525
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2930
2526
 
2931
2527
  return s0;
2932
2528
  }
@@ -2935,7 +2531,7 @@ var ftl = (function (exports) {
2935
2531
  let s0, s1, s2, s3, s4;
2936
2532
 
2937
2533
  const key = peg$currPos * 38 + 32;
2938
- const cached = peg$resultsCache[key];
2534
+ const cached = peg$resultsCache.get(key);
2939
2535
 
2940
2536
  if (cached) {
2941
2537
  peg$currPos = cached.nextPos;
@@ -2993,7 +2589,7 @@ var ftl = (function (exports) {
2993
2589
  if (peg$silentFails === 0) { peg$fail(peg$e43); }
2994
2590
  }
2995
2591
 
2996
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2592
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
2997
2593
 
2998
2594
  return s0;
2999
2595
  }
@@ -3002,7 +2598,7 @@ var ftl = (function (exports) {
3002
2598
  let s0, s1, s2, s3, s4;
3003
2599
 
3004
2600
  const key = peg$currPos * 38 + 33;
3005
- const cached = peg$resultsCache[key];
2601
+ const cached = peg$resultsCache.get(key);
3006
2602
 
3007
2603
  if (cached) {
3008
2604
  peg$currPos = cached.nextPos;
@@ -3013,7 +2609,7 @@ var ftl = (function (exports) {
3013
2609
  s0 = peg$currPos;
3014
2610
  s1 = peg$currPos;
3015
2611
  s2 = input.charAt(peg$currPos);
3016
- if (peg$r5.test(s2)) {
2612
+ if ((peg$charCode = s2.charCodeAt(0), (peg$charCode >= 97 && peg$charCode <= 122) || (peg$charCode >= 65 && peg$charCode <= 90) || peg$charCode === 36 || peg$charCode === 95)) {
3017
2613
  peg$currPos++;
3018
2614
  } else {
3019
2615
  s2 = peg$FAILED;
@@ -3021,22 +2617,16 @@ var ftl = (function (exports) {
3021
2617
  }
3022
2618
  if (s2 !== peg$FAILED) {
3023
2619
  s3 = [];
3024
- s4 = input.charAt(peg$currPos);
3025
- if (peg$r6.test(s4)) {
3026
- peg$currPos++;
3027
- } else {
3028
- s4 = peg$FAILED;
3029
- if (peg$silentFails === 0) { peg$fail(peg$e46); }
3030
- }
3031
- while (s4 !== peg$FAILED) {
3032
- s3.push(s4);
2620
+ for (;;) {
3033
2621
  s4 = input.charAt(peg$currPos);
3034
- if (peg$r6.test(s4)) {
2622
+ if ((peg$charCode = s4.charCodeAt(0), (peg$charCode >= 97 && peg$charCode <= 122) || (peg$charCode >= 65 && peg$charCode <= 90) || peg$charCode === 36 || peg$charCode === 95 || (peg$charCode >= 48 && peg$charCode <= 57))) {
3035
2623
  peg$currPos++;
3036
2624
  } else {
3037
2625
  s4 = peg$FAILED;
3038
2626
  if (peg$silentFails === 0) { peg$fail(peg$e46); }
3039
2627
  }
2628
+ if (s4 === peg$FAILED) { break; }
2629
+ s3.push(s4);
3040
2630
  }
3041
2631
  s2 = [s2, s3];
3042
2632
  s1 = s2;
@@ -3050,7 +2640,7 @@ var ftl = (function (exports) {
3050
2640
  s0 = s1;
3051
2641
  }
3052
2642
 
3053
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2643
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
3054
2644
 
3055
2645
  return s0;
3056
2646
  }
@@ -3059,7 +2649,7 @@ var ftl = (function (exports) {
3059
2649
  let s0, s1;
3060
2650
 
3061
2651
  const key = peg$currPos * 38 + 34;
3062
- const cached = peg$resultsCache[key];
2652
+ const cached = peg$resultsCache.get(key);
3063
2653
 
3064
2654
  if (cached) {
3065
2655
  peg$currPos = cached.nextPos;
@@ -3080,7 +2670,7 @@ var ftl = (function (exports) {
3080
2670
  if (peg$silentFails === 0) { peg$fail(peg$e47); }
3081
2671
  }
3082
2672
 
3083
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2673
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
3084
2674
 
3085
2675
  return s0;
3086
2676
  }
@@ -3089,7 +2679,7 @@ var ftl = (function (exports) {
3089
2679
  let s0;
3090
2680
 
3091
2681
  const key = peg$currPos * 38 + 35;
3092
- const cached = peg$resultsCache[key];
2682
+ const cached = peg$resultsCache.get(key);
3093
2683
 
3094
2684
  if (cached) {
3095
2685
  peg$currPos = cached.nextPos;
@@ -3114,7 +2704,7 @@ var ftl = (function (exports) {
3114
2704
  }
3115
2705
  }
3116
2706
 
3117
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2707
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
3118
2708
 
3119
2709
  return s0;
3120
2710
  }
@@ -3123,7 +2713,7 @@ var ftl = (function (exports) {
3123
2713
  let s0;
3124
2714
 
3125
2715
  const key = peg$currPos * 38 + 36;
3126
- const cached = peg$resultsCache[key];
2716
+ const cached = peg$resultsCache.get(key);
3127
2717
 
3128
2718
  if (cached) {
3129
2719
  peg$currPos = cached.nextPos;
@@ -3166,7 +2756,7 @@ var ftl = (function (exports) {
3166
2756
  }
3167
2757
  }
3168
2758
 
3169
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2759
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
3170
2760
 
3171
2761
  return s0;
3172
2762
  }
@@ -3175,7 +2765,7 @@ var ftl = (function (exports) {
3175
2765
  let s0, s1;
3176
2766
 
3177
2767
  const key = peg$currPos * 38 + 37;
3178
- const cached = peg$resultsCache[key];
2768
+ const cached = peg$resultsCache.get(key);
3179
2769
 
3180
2770
  if (cached) {
3181
2771
  peg$currPos = cached.nextPos;
@@ -3185,26 +2775,20 @@ var ftl = (function (exports) {
3185
2775
 
3186
2776
  peg$silentFails++;
3187
2777
  s0 = [];
3188
- s1 = input.charAt(peg$currPos);
3189
- if (peg$r7.test(s1)) {
3190
- peg$currPos++;
3191
- } else {
3192
- s1 = peg$FAILED;
3193
- if (peg$silentFails === 0) { peg$fail(peg$e54); }
3194
- }
3195
- while (s1 !== peg$FAILED) {
3196
- s0.push(s1);
2778
+ for (;;) {
3197
2779
  s1 = input.charAt(peg$currPos);
3198
- if (peg$r7.test(s1)) {
2780
+ if ((peg$charCode = s1.charCodeAt(0), peg$charCode === 32 || peg$charCode === 9 || peg$charCode === 10 || peg$charCode === 13)) {
3199
2781
  peg$currPos++;
3200
2782
  } else {
3201
2783
  s1 = peg$FAILED;
3202
2784
  if (peg$silentFails === 0) { peg$fail(peg$e54); }
3203
2785
  }
2786
+ if (s1 === peg$FAILED) { break; }
2787
+ s0.push(s1);
3204
2788
  }
3205
2789
  peg$silentFails--;
3206
2790
 
3207
- peg$resultsCache[key] = { nextPos: peg$currPos, result: s0 };
2791
+ peg$resultsCache.set(key, { nextPos: peg$currPos, result: s0 });
3208
2792
 
3209
2793
  return s0;
3210
2794
  }
@@ -3717,7 +3301,7 @@ var ftl = (function (exports) {
3717
3301
  el.removeAttribute('slot');
3718
3302
  return [slot, LightSlots.slotFromNode(el)];
3719
3303
  });
3720
- const slots = {};
3304
+ const slots = Object.create(null);
3721
3305
  slots.default = new DocumentFragment();
3722
3306
  slots.default.append(...el.childNodes);
3723
3307
  for (const [name, el] of namedSlots) {
@@ -3783,6 +3367,13 @@ var ftl = (function (exports) {
3783
3367
  if (win === null) {
3784
3368
  return Promise.resolve();
3785
3369
  }
3370
+ // interactive spans both the deferred scripts and the time between DOMContentLoaded and load
3371
+ const [navigation] = /** @type {PerformanceNavigationTiming[]} */ (
3372
+ win.performance?.getEntriesByType('navigation') ?? []
3373
+ );
3374
+ if (navigation?.domContentLoadedEventStart > 0) {
3375
+ return Promise.resolve();
3376
+ }
3786
3377
  return new Promise((resolve) => {
3787
3378
  const done = () => {
3788
3379
  win.removeEventListener('DOMContentLoaded', done);
@@ -3799,12 +3390,12 @@ var ftl = (function (exports) {
3799
3390
  * resolves once the element, or any of its ancestors, gains a next sibling,
3800
3391
  * which is the parser having moved past this subtree. The document's
3801
3392
  * DOMContentLoaded is the deadline. Resolves immediately for an element
3802
- * that is already parsed.
3393
+ * that is already parsed, or once the parser has finished the document.
3803
3394
  * @param {Element} el
3804
3395
  * @returns {Promise<Element>} the element
3805
3396
  */
3806
3397
  static waitParsed(el) {
3807
- if (Nodes.isParsed(el)) {
3398
+ if (Nodes.isParsed(el) || el.ownerDocument.readyState !== 'loading') {
3808
3399
  return Promise.resolve(el);
3809
3400
  }
3810
3401
  return new Promise((resolve) => {
@@ -3946,7 +3537,8 @@ var ftl = (function (exports) {
3946
3537
  const statName = ops.popData(node, 'tplStat');
3947
3538
  const template = new Template(node, evaluator);
3948
3539
  const evaluated = evaluator.evaluateExpression(expression);
3949
- const proto = evaluated === null || typeof evaluated !== 'object' ? undefined : Object.getPrototypeOf(evaluated);
3540
+ const proto =
3541
+ evaluated === null || typeof evaluated !== 'object' ? undefined : Object.getPrototypeOf(evaluated);
3950
3542
  const plain = !evaluated?.[Symbol.iterator] && (proto === Object.prototype || proto === null);
3951
3543
  const dict = plain ? Object.entries(evaluated) : null;
3952
3544
  const keyed = evaluated instanceof Map ? [...evaluated] : dict;
@@ -4026,6 +3618,9 @@ var ftl = (function (exports) {
4026
3618
  }
4027
3619
  const tuples = Array.isArray(attributesAndValues[0]) ? attributesAndValues : [attributesAndValues];
4028
3620
  tuples.forEach(([k, v]) => {
3621
+ if (v === null || v === undefined) {
3622
+ return;
3623
+ }
4029
3624
  node.setAttribute(k, v);
4030
3625
  });
4031
3626
  }
@@ -5143,7 +4738,8 @@ var ftl = (function (exports) {
5143
4738
  const PLACEHOLDER = /\{(\w+)\}/g;
5144
4739
  const POSITIONAL = /\{(\d+)\}/g;
5145
4740
  /** @param {any} v @returns {v is Record<string, string>} */
5146
- const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
4741
+ const isPlainObject = (v) =>
4742
+ typeof v === 'object' && v !== null && [Object.prototype, null].includes(Object.getPrototypeOf(v));
5147
4743
 
5148
4744
  /** @param {any} problem @returns {string|undefined} the reason, unless it is missing or blank */
5149
4745
  const reasonOf = (problem) =>
@@ -5178,8 +4774,8 @@ var ftl = (function (exports) {
5178
4774
  class Localization {
5179
4775
  /**
5180
4776
  * Resolves a message from the translations and interpolates its arguments.
5181
- * A single plain object argument interpolates named placeholders
5182
- * ({name}); anything else interpolates positional ones ({0}).
4777
+ * A single plain object argument (an object literal, or one with a null
4778
+ * prototype) interpolates named placeholders ({name}); anything else interpolates positional ones ({0}).
5183
4779
  * A plural leaf selects its form through Intl.PluralRules over the
5184
4780
  * numeric {count} named argument.
5185
4781
  *