@danielx/civet 0.6.68 → 0.6.69
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +808 -643
- package/dist/main.js +808 -643
- package/dist/main.mjs +808 -643
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -658,6 +658,37 @@ var Civet = (() => {
|
|
|
658
658
|
}
|
|
659
659
|
function processCallMemberExpression(node) {
|
|
660
660
|
const { children } = node;
|
|
661
|
+
if (children[0]?.parenthesizedOp?.token && children[1]?.type === "Call") {
|
|
662
|
+
const op = children[0].parenthesizedOp;
|
|
663
|
+
let call = children[1];
|
|
664
|
+
const args = [...call.args];
|
|
665
|
+
call = { ...call, args };
|
|
666
|
+
let ref2;
|
|
667
|
+
if (ref2 = isComma(args.at(-1))) {
|
|
668
|
+
const comma = ref2;
|
|
669
|
+
comma.token = "";
|
|
670
|
+
}
|
|
671
|
+
let commaCount = 0;
|
|
672
|
+
for (let i4 = 0, len4 = args.length; i4 < len4; i4++) {
|
|
673
|
+
const arg = args[i4];
|
|
674
|
+
let ref3;
|
|
675
|
+
if (ref3 = isComma(arg)) {
|
|
676
|
+
const comma = ref3;
|
|
677
|
+
comma.token = `)${op.token}(`;
|
|
678
|
+
commaCount++;
|
|
679
|
+
}
|
|
680
|
+
}
|
|
681
|
+
if (args.length) {
|
|
682
|
+
children.splice(
|
|
683
|
+
0,
|
|
684
|
+
2,
|
|
685
|
+
commaCount ? {
|
|
686
|
+
type: "ParenthesizedExpression",
|
|
687
|
+
children: ["(", call, ")"]
|
|
688
|
+
} : call
|
|
689
|
+
);
|
|
690
|
+
}
|
|
691
|
+
}
|
|
661
692
|
for (let i = 0; i < children.length; i++) {
|
|
662
693
|
const glob = children[i];
|
|
663
694
|
if (glob?.type === "PropertyGlob") {
|
|
@@ -1050,18 +1081,18 @@ var Civet = (() => {
|
|
|
1050
1081
|
}
|
|
1051
1082
|
function findChildIndex(parent, child) {
|
|
1052
1083
|
const children = Array.isArray(parent) ? parent : parent.children;
|
|
1053
|
-
for (let
|
|
1054
|
-
const i =
|
|
1055
|
-
const c = children[
|
|
1084
|
+
for (let i5 = 0, len5 = children.length; i5 < len5; i5++) {
|
|
1085
|
+
const i = i5;
|
|
1086
|
+
const c = children[i5];
|
|
1056
1087
|
if (c === child || Array.isArray(c) && arrayRecurse(c)) {
|
|
1057
1088
|
return i;
|
|
1058
1089
|
}
|
|
1059
1090
|
}
|
|
1060
1091
|
function arrayRecurse(array) {
|
|
1061
1092
|
const results2 = [];
|
|
1062
|
-
for (let
|
|
1063
|
-
const i =
|
|
1064
|
-
const c = array[
|
|
1093
|
+
for (let i6 = 0, len6 = array.length; i6 < len6; i6++) {
|
|
1094
|
+
const i = i6;
|
|
1095
|
+
const c = array[i6];
|
|
1065
1096
|
if (c === child || Array.isArray(c) && arrayRecurse(c)) {
|
|
1066
1097
|
return true;
|
|
1067
1098
|
} else {
|
|
@@ -1078,9 +1109,9 @@ var Civet = (() => {
|
|
|
1078
1109
|
throw new Error("replaceNode failed: node has no parent");
|
|
1079
1110
|
}
|
|
1080
1111
|
function recurse(children) {
|
|
1081
|
-
for (let
|
|
1082
|
-
const i =
|
|
1083
|
-
const child = children[
|
|
1112
|
+
for (let i7 = 0, len7 = children.length; i7 < len7; i7++) {
|
|
1113
|
+
const i = i7;
|
|
1114
|
+
const child = children[i7];
|
|
1084
1115
|
if (child === node) {
|
|
1085
1116
|
children[i] = newNode;
|
|
1086
1117
|
return true;
|
|
@@ -1394,6 +1425,15 @@ var Civet = (() => {
|
|
|
1394
1425
|
"ContinueStatement"
|
|
1395
1426
|
].includes(node?.type);
|
|
1396
1427
|
}
|
|
1428
|
+
function isComma(node) {
|
|
1429
|
+
if (node?.token === ",") {
|
|
1430
|
+
return node;
|
|
1431
|
+
} else if (Array.isArray(node) && node.at(-1)?.token === ",") {
|
|
1432
|
+
return node.at(-1);
|
|
1433
|
+
}
|
|
1434
|
+
;
|
|
1435
|
+
return;
|
|
1436
|
+
}
|
|
1397
1437
|
function gatherRecursiveWithinFunction(node, predicate) {
|
|
1398
1438
|
return gatherRecursive(node, predicate, isFunction);
|
|
1399
1439
|
}
|
|
@@ -1751,6 +1791,9 @@ var Civet = (() => {
|
|
|
1751
1791
|
return;
|
|
1752
1792
|
}
|
|
1753
1793
|
function makeLeftHandSideExpression(expression) {
|
|
1794
|
+
if (expression.parenthesized) {
|
|
1795
|
+
return expression;
|
|
1796
|
+
}
|
|
1754
1797
|
switch (expression.type) {
|
|
1755
1798
|
case "Ref":
|
|
1756
1799
|
case "AmpersandRef":
|
|
@@ -2350,9 +2393,9 @@ var Civet = (() => {
|
|
|
2350
2393
|
}
|
|
2351
2394
|
function insertSemicolon(statements) {
|
|
2352
2395
|
const l = statements.length;
|
|
2353
|
-
for (let
|
|
2354
|
-
const i =
|
|
2355
|
-
const s = statements[
|
|
2396
|
+
for (let i8 = 0, len8 = statements.length; i8 < len8; i8++) {
|
|
2397
|
+
const i = i8;
|
|
2398
|
+
const s = statements[i8];
|
|
2356
2399
|
if (i < l - 1) {
|
|
2357
2400
|
if (needsPrecedingSemicolon(statements[i + 1])) {
|
|
2358
2401
|
const delim = s[2];
|
|
@@ -3357,9 +3400,9 @@ var Civet = (() => {
|
|
|
3357
3400
|
return root;
|
|
3358
3401
|
}
|
|
3359
3402
|
}
|
|
3360
|
-
for (let
|
|
3361
|
-
const i =
|
|
3362
|
-
const node = array[
|
|
3403
|
+
for (let i9 = 0, len9 = array.length; i9 < len9; i9++) {
|
|
3404
|
+
const i = i9;
|
|
3405
|
+
const node = array[i9];
|
|
3363
3406
|
if (!(node != null)) {
|
|
3364
3407
|
return;
|
|
3365
3408
|
}
|
|
@@ -4746,209 +4789,210 @@ ${input.slice(result.pos)}
|
|
|
4746
4789
|
var $L8 = $L("++");
|
|
4747
4790
|
var $L9 = $L("--");
|
|
4748
4791
|
var $L10 = $L("\u29FA");
|
|
4749
|
-
var $L11 = $L("
|
|
4750
|
-
var $L12 = $L("
|
|
4751
|
-
var $L13 = $L("
|
|
4752
|
-
var $L14 = $L("
|
|
4753
|
-
var $L15 = $L("
|
|
4754
|
-
var $L16 = $L("
|
|
4755
|
-
var $L17 = $L("
|
|
4756
|
-
var $L18 = $L("
|
|
4757
|
-
var $L19 = $L("
|
|
4758
|
-
var $L20 = $L("
|
|
4759
|
-
var $L21 = $L("
|
|
4760
|
-
var $L22 = $L("
|
|
4761
|
-
var $L23 = $L("
|
|
4762
|
-
var $L24 = $L("
|
|
4763
|
-
var $L25 = $L("
|
|
4764
|
-
var $L26 = $L("
|
|
4765
|
-
var $L27 = $L("
|
|
4766
|
-
var $L28 = $L("
|
|
4767
|
-
var $L29 = $L("
|
|
4768
|
-
var $L30 = $L("
|
|
4769
|
-
var $L31 = $L("
|
|
4770
|
-
var $L32 = $L("
|
|
4771
|
-
var $L33 = $L("
|
|
4772
|
-
var $L34 = $L("
|
|
4773
|
-
var $L35 = $L("
|
|
4774
|
-
var $L36 = $L("
|
|
4775
|
-
var $L37 = $L("
|
|
4776
|
-
var $L38 = $L("
|
|
4777
|
-
var $L39 = $L("
|
|
4778
|
-
var $L40 = $L("
|
|
4779
|
-
var $L41 = $L("
|
|
4780
|
-
var $L42 = $L("
|
|
4781
|
-
var $L43 = $L("
|
|
4782
|
-
var $L44 = $L("
|
|
4783
|
-
var $L45 = $L("
|
|
4784
|
-
var $L46 = $L("
|
|
4785
|
-
var $L47 = $L("
|
|
4786
|
-
var $L48 = $L("
|
|
4787
|
-
var $L49 = $L("
|
|
4788
|
-
var $L50 = $L("
|
|
4789
|
-
var $L51 = $L("
|
|
4790
|
-
var $L52 = $L("
|
|
4791
|
-
var $L53 = $L("
|
|
4792
|
-
var $L54 = $L("
|
|
4793
|
-
var $L55 = $L("
|
|
4794
|
-
var $L56 = $L("
|
|
4795
|
-
var $L57 = $L("
|
|
4796
|
-
var $L58 = $L("
|
|
4797
|
-
var $L59 = $L("
|
|
4798
|
-
var $L60 = $L("
|
|
4799
|
-
var $L61 = $L("
|
|
4800
|
-
var $L62 = $L("
|
|
4801
|
-
var $L63 = $L("
|
|
4802
|
-
var $L64 = $L("
|
|
4803
|
-
var $L65 = $L("
|
|
4804
|
-
var $L66 = $L("
|
|
4805
|
-
var $L67 = $L("
|
|
4806
|
-
var $L68 = $L("
|
|
4807
|
-
var $L69 = $L("
|
|
4808
|
-
var $L70 = $L("
|
|
4809
|
-
var $L71 = $L("
|
|
4810
|
-
var $L72 = $L("
|
|
4811
|
-
var $L73 = $L("
|
|
4812
|
-
var $L74 = $L("
|
|
4813
|
-
var $L75 = $L("
|
|
4814
|
-
var $L76 = $L("
|
|
4815
|
-
var $L77 = $L("
|
|
4816
|
-
var $L78 = $L("
|
|
4817
|
-
var $L79 = $L("
|
|
4818
|
-
var $L80 = $L("
|
|
4819
|
-
var $L81 = $L("\
|
|
4820
|
-
var $L82 = $L("
|
|
4821
|
-
var $L83 = $L("
|
|
4822
|
-
var $L84 = $L("\
|
|
4823
|
-
var $L85 = $L("
|
|
4824
|
-
var $L86 = $L("
|
|
4825
|
-
var $L87 = $L("
|
|
4826
|
-
var $L88 = $L("
|
|
4827
|
-
var $L89 = $L("
|
|
4828
|
-
var $L90 = $L("
|
|
4829
|
-
var $L91 = $L("
|
|
4830
|
-
var $L92 = $L("
|
|
4831
|
-
var $L93 = $L("
|
|
4832
|
-
var $L94 = $L("
|
|
4833
|
-
var $L95 = $L("
|
|
4834
|
-
var $L96 = $L("
|
|
4835
|
-
var $L97 = $L("\
|
|
4836
|
-
var $L98 = $L("\
|
|
4837
|
-
var $L99 = $L("\
|
|
4838
|
-
var $L100 = $L("
|
|
4839
|
-
var $L101 = $L("
|
|
4840
|
-
var $L102 = $L("
|
|
4841
|
-
var $L103 = $L("
|
|
4842
|
-
var $L104 = $L("
|
|
4843
|
-
var $L105 = $L("
|
|
4844
|
-
var $L106 = $L("
|
|
4845
|
-
var $L107 = $L("
|
|
4846
|
-
var $L108 = $L("
|
|
4847
|
-
var $L109 = $L("
|
|
4848
|
-
var $L110 = $L("
|
|
4849
|
-
var $L111 = $L("
|
|
4850
|
-
var $L112 = $L("
|
|
4851
|
-
var $L113 = $L("
|
|
4852
|
-
var $L114 = $L("
|
|
4853
|
-
var $L115 = $L("
|
|
4854
|
-
var $L116 = $L("
|
|
4855
|
-
var $L117 = $L("
|
|
4856
|
-
var $L118 = $L("
|
|
4857
|
-
var $L119 = $L("
|
|
4858
|
-
var $L120 = $L("
|
|
4859
|
-
var $L121 = $L("
|
|
4860
|
-
var $L122 = $L("
|
|
4861
|
-
var $L123 = $L("
|
|
4862
|
-
var $L124 = $L("
|
|
4863
|
-
var $L125 = $L("
|
|
4864
|
-
var $L126 = $L("
|
|
4865
|
-
var $L127 = $L("
|
|
4866
|
-
var $L128 = $L("
|
|
4867
|
-
var $L129 = $L("
|
|
4868
|
-
var $L130 = $L("
|
|
4869
|
-
var $L131 = $L("
|
|
4870
|
-
var $L132 = $L("
|
|
4871
|
-
var $L133 = $L("
|
|
4872
|
-
var $L134 = $L("
|
|
4873
|
-
var $L135 = $L("
|
|
4874
|
-
var $L136 = $L("
|
|
4875
|
-
var $L137 = $L(
|
|
4876
|
-
var $L138 = $L("
|
|
4877
|
-
var $L139 = $L("
|
|
4878
|
-
var $L140 = $L("
|
|
4879
|
-
var $L141 = $L("
|
|
4880
|
-
var $L142 = $L("
|
|
4881
|
-
var $L143 = $L("
|
|
4882
|
-
var $L144 = $L("
|
|
4883
|
-
var $L145 = $L("
|
|
4884
|
-
var $L146 = $L("
|
|
4885
|
-
var $L147 = $L("
|
|
4886
|
-
var $L148 = $L("
|
|
4887
|
-
var $L149 = $L("
|
|
4888
|
-
var $L150 = $L("
|
|
4889
|
-
var $L151 = $L("
|
|
4890
|
-
var $L152 = $L("
|
|
4891
|
-
var $L153 = $L("
|
|
4892
|
-
var $L154 = $L("
|
|
4893
|
-
var $L155 = $L("
|
|
4894
|
-
var $L156 = $L("
|
|
4895
|
-
var $L157 = $L("
|
|
4896
|
-
var $L158 = $L("
|
|
4897
|
-
var $L159 = $L("
|
|
4898
|
-
var $L160 = $L("
|
|
4899
|
-
var $L161 = $L("
|
|
4900
|
-
var $L162 = $L("
|
|
4901
|
-
var $L163 = $L("
|
|
4902
|
-
var $L164 = $L("
|
|
4903
|
-
var $L165 = $L("
|
|
4904
|
-
var $L166 = $L("
|
|
4905
|
-
var $L167 = $L("
|
|
4906
|
-
var $L168 = $L("
|
|
4907
|
-
var $L169 = $L("
|
|
4908
|
-
var $L170 = $L("
|
|
4909
|
-
var $L171 = $L("
|
|
4910
|
-
var $L172 = $L("
|
|
4911
|
-
var $L173 = $L("
|
|
4912
|
-
var $L174 = $L("
|
|
4913
|
-
var $L175 = $L("
|
|
4914
|
-
var $L176 = $L("
|
|
4915
|
-
var $L177 = $L("
|
|
4916
|
-
var $L178 = $L("
|
|
4917
|
-
var $L179 = $L("
|
|
4918
|
-
var $L180 = $L("
|
|
4919
|
-
var $L181 = $L("
|
|
4920
|
-
var $L182 = $L(
|
|
4921
|
-
var $L183 = $L("'
|
|
4922
|
-
var $L184 = $L("
|
|
4923
|
-
var $L185 = $L("
|
|
4924
|
-
var $L186 = $L("
|
|
4925
|
-
var $L187 = $L("
|
|
4926
|
-
var $L188 = $L("
|
|
4927
|
-
var $L189 = $L("
|
|
4928
|
-
var $L190 = $L("
|
|
4929
|
-
var $L191 = $L("
|
|
4930
|
-
var $L192 = $L("
|
|
4931
|
-
var $L193 = $L("
|
|
4932
|
-
var $L194 = $L("
|
|
4933
|
-
var $L195 = $L("
|
|
4934
|
-
var $L196 = $L("
|
|
4935
|
-
var $L197 = $L("
|
|
4936
|
-
var $L198 = $L("
|
|
4937
|
-
var $L199 = $L("
|
|
4938
|
-
var $L200 = $L("
|
|
4939
|
-
var $L201 = $L("
|
|
4940
|
-
var $L202 = $L("
|
|
4941
|
-
var $L203 = $L("
|
|
4942
|
-
var $L204 = $L("
|
|
4943
|
-
var $L205 = $L("
|
|
4944
|
-
var $L206 = $L("
|
|
4945
|
-
var $L207 = $L("
|
|
4946
|
-
var $L208 = $L("
|
|
4947
|
-
var $L209 = $L("
|
|
4948
|
-
var $L210 = $L("
|
|
4949
|
-
var $L211 = $L("
|
|
4950
|
-
var $L212 = $L("
|
|
4951
|
-
var $L213 = $L("
|
|
4792
|
+
var $L11 = $L("\u2014");
|
|
4793
|
+
var $L12 = $L("=>");
|
|
4794
|
+
var $L13 = $L("\u21D2");
|
|
4795
|
+
var $L14 = $L(":");
|
|
4796
|
+
var $L15 = $L(" ");
|
|
4797
|
+
var $L16 = $L("<");
|
|
4798
|
+
var $L17 = $L("implements");
|
|
4799
|
+
var $L18 = $L("<:");
|
|
4800
|
+
var $L19 = $L("import");
|
|
4801
|
+
var $L20 = $L("!");
|
|
4802
|
+
var $L21 = $L("^");
|
|
4803
|
+
var $L22 = $L("-");
|
|
4804
|
+
var $L23 = $L("import.meta");
|
|
4805
|
+
var $L24 = $L("return.value");
|
|
4806
|
+
var $L25 = $L(",");
|
|
4807
|
+
var $L26 = $L("(&)");
|
|
4808
|
+
var $L27 = $L("->");
|
|
4809
|
+
var $L28 = $L("\u2192");
|
|
4810
|
+
var $L29 = $L("}");
|
|
4811
|
+
var $L30 = $L("null");
|
|
4812
|
+
var $L31 = $L("true");
|
|
4813
|
+
var $L32 = $L("false");
|
|
4814
|
+
var $L33 = $L("yes");
|
|
4815
|
+
var $L34 = $L("on");
|
|
4816
|
+
var $L35 = $L("no");
|
|
4817
|
+
var $L36 = $L("off");
|
|
4818
|
+
var $L37 = $L(">");
|
|
4819
|
+
var $L38 = $L("]");
|
|
4820
|
+
var $L39 = $L("**=");
|
|
4821
|
+
var $L40 = $L("*=");
|
|
4822
|
+
var $L41 = $L("/=");
|
|
4823
|
+
var $L42 = $L("%=");
|
|
4824
|
+
var $L43 = $L("+=");
|
|
4825
|
+
var $L44 = $L("-=");
|
|
4826
|
+
var $L45 = $L("<<=");
|
|
4827
|
+
var $L46 = $L(">>>=");
|
|
4828
|
+
var $L47 = $L(">>=");
|
|
4829
|
+
var $L48 = $L("&&=");
|
|
4830
|
+
var $L49 = $L("&=");
|
|
4831
|
+
var $L50 = $L("^=");
|
|
4832
|
+
var $L51 = $L("||=");
|
|
4833
|
+
var $L52 = $L("|=");
|
|
4834
|
+
var $L53 = $L("??=");
|
|
4835
|
+
var $L54 = $L("?=");
|
|
4836
|
+
var $L55 = $L("and=");
|
|
4837
|
+
var $L56 = $L("or=");
|
|
4838
|
+
var $L57 = $L("**");
|
|
4839
|
+
var $L58 = $L("*");
|
|
4840
|
+
var $L59 = $L("/");
|
|
4841
|
+
var $L60 = $L("%%");
|
|
4842
|
+
var $L61 = $L("%");
|
|
4843
|
+
var $L62 = $L("+");
|
|
4844
|
+
var $L63 = $L("<=");
|
|
4845
|
+
var $L64 = $L("\u2264");
|
|
4846
|
+
var $L65 = $L(">=");
|
|
4847
|
+
var $L66 = $L("\u2265");
|
|
4848
|
+
var $L67 = $L("<?");
|
|
4849
|
+
var $L68 = $L("!<?");
|
|
4850
|
+
var $L69 = $L("<<");
|
|
4851
|
+
var $L70 = $L("\xAB");
|
|
4852
|
+
var $L71 = $L(">>>");
|
|
4853
|
+
var $L72 = $L("\u22D9");
|
|
4854
|
+
var $L73 = $L(">>");
|
|
4855
|
+
var $L74 = $L("\xBB");
|
|
4856
|
+
var $L75 = $L("!==");
|
|
4857
|
+
var $L76 = $L("\u2262");
|
|
4858
|
+
var $L77 = $L("!=");
|
|
4859
|
+
var $L78 = $L("\u2260");
|
|
4860
|
+
var $L79 = $L("isnt");
|
|
4861
|
+
var $L80 = $L("===");
|
|
4862
|
+
var $L81 = $L("\u2263");
|
|
4863
|
+
var $L82 = $L("\u2A76");
|
|
4864
|
+
var $L83 = $L("==");
|
|
4865
|
+
var $L84 = $L("\u2261");
|
|
4866
|
+
var $L85 = $L("\u2A75");
|
|
4867
|
+
var $L86 = $L("and");
|
|
4868
|
+
var $L87 = $L("&&");
|
|
4869
|
+
var $L88 = $L("or");
|
|
4870
|
+
var $L89 = $L("||");
|
|
4871
|
+
var $L90 = $L("\u2016");
|
|
4872
|
+
var $L91 = $L("^^");
|
|
4873
|
+
var $L92 = $L("xor");
|
|
4874
|
+
var $L93 = $L("xnor");
|
|
4875
|
+
var $L94 = $L("??");
|
|
4876
|
+
var $L95 = $L("\u2047");
|
|
4877
|
+
var $L96 = $L("instanceof");
|
|
4878
|
+
var $L97 = $L("\u2208");
|
|
4879
|
+
var $L98 = $L("\u220B");
|
|
4880
|
+
var $L99 = $L("\u220C");
|
|
4881
|
+
var $L100 = $L("\u2209");
|
|
4882
|
+
var $L101 = $L("&");
|
|
4883
|
+
var $L102 = $L("|");
|
|
4884
|
+
var $L103 = $L(";");
|
|
4885
|
+
var $L104 = $L("$:");
|
|
4886
|
+
var $L105 = $L("break");
|
|
4887
|
+
var $L106 = $L("continue");
|
|
4888
|
+
var $L107 = $L("debugger");
|
|
4889
|
+
var $L108 = $L("with");
|
|
4890
|
+
var $L109 = $L("assert");
|
|
4891
|
+
var $L110 = $L(":=");
|
|
4892
|
+
var $L111 = $L("\u2254");
|
|
4893
|
+
var $L112 = $L(".=");
|
|
4894
|
+
var $L113 = $L("/*");
|
|
4895
|
+
var $L114 = $L("*/");
|
|
4896
|
+
var $L115 = $L("\\");
|
|
4897
|
+
var $L116 = $L(")");
|
|
4898
|
+
var $L117 = $L("abstract");
|
|
4899
|
+
var $L118 = $L("as");
|
|
4900
|
+
var $L119 = $L("@");
|
|
4901
|
+
var $L120 = $L("@@");
|
|
4902
|
+
var $L121 = $L("async");
|
|
4903
|
+
var $L122 = $L("await");
|
|
4904
|
+
var $L123 = $L("`");
|
|
4905
|
+
var $L124 = $L("by");
|
|
4906
|
+
var $L125 = $L("case");
|
|
4907
|
+
var $L126 = $L("catch");
|
|
4908
|
+
var $L127 = $L("class");
|
|
4909
|
+
var $L128 = $L("#{");
|
|
4910
|
+
var $L129 = $L("declare");
|
|
4911
|
+
var $L130 = $L("default");
|
|
4912
|
+
var $L131 = $L("delete");
|
|
4913
|
+
var $L132 = $L("do");
|
|
4914
|
+
var $L133 = $L("..");
|
|
4915
|
+
var $L134 = $L("\u2025");
|
|
4916
|
+
var $L135 = $L("...");
|
|
4917
|
+
var $L136 = $L("\u2026");
|
|
4918
|
+
var $L137 = $L("::");
|
|
4919
|
+
var $L138 = $L('"');
|
|
4920
|
+
var $L139 = $L("each");
|
|
4921
|
+
var $L140 = $L("else");
|
|
4922
|
+
var $L141 = $L("export");
|
|
4923
|
+
var $L142 = $L("extends");
|
|
4924
|
+
var $L143 = $L("finally");
|
|
4925
|
+
var $L144 = $L("for");
|
|
4926
|
+
var $L145 = $L("from");
|
|
4927
|
+
var $L146 = $L("function");
|
|
4928
|
+
var $L147 = $L("get");
|
|
4929
|
+
var $L148 = $L("set");
|
|
4930
|
+
var $L149 = $L("#");
|
|
4931
|
+
var $L150 = $L("if");
|
|
4932
|
+
var $L151 = $L("in");
|
|
4933
|
+
var $L152 = $L("let");
|
|
4934
|
+
var $L153 = $L("const");
|
|
4935
|
+
var $L154 = $L("is");
|
|
4936
|
+
var $L155 = $L("loop");
|
|
4937
|
+
var $L156 = $L("new");
|
|
4938
|
+
var $L157 = $L("not");
|
|
4939
|
+
var $L158 = $L("of");
|
|
4940
|
+
var $L159 = $L("[");
|
|
4941
|
+
var $L160 = $L("operator");
|
|
4942
|
+
var $L161 = $L("own");
|
|
4943
|
+
var $L162 = $L("public");
|
|
4944
|
+
var $L163 = $L("private");
|
|
4945
|
+
var $L164 = $L("protected");
|
|
4946
|
+
var $L165 = $L("||>");
|
|
4947
|
+
var $L166 = $L("|\u25B7");
|
|
4948
|
+
var $L167 = $L("|>=");
|
|
4949
|
+
var $L168 = $L("\u25B7=");
|
|
4950
|
+
var $L169 = $L("|>");
|
|
4951
|
+
var $L170 = $L("\u25B7");
|
|
4952
|
+
var $L171 = $L("readonly");
|
|
4953
|
+
var $L172 = $L("return");
|
|
4954
|
+
var $L173 = $L("satisfies");
|
|
4955
|
+
var $L174 = $L("'");
|
|
4956
|
+
var $L175 = $L("static");
|
|
4957
|
+
var $L176 = $L("${");
|
|
4958
|
+
var $L177 = $L("super");
|
|
4959
|
+
var $L178 = $L("switch");
|
|
4960
|
+
var $L179 = $L("target");
|
|
4961
|
+
var $L180 = $L("then");
|
|
4962
|
+
var $L181 = $L("this");
|
|
4963
|
+
var $L182 = $L("throw");
|
|
4964
|
+
var $L183 = $L('"""');
|
|
4965
|
+
var $L184 = $L("'''");
|
|
4966
|
+
var $L185 = $L("///");
|
|
4967
|
+
var $L186 = $L("```");
|
|
4968
|
+
var $L187 = $L("try");
|
|
4969
|
+
var $L188 = $L("typeof");
|
|
4970
|
+
var $L189 = $L("unless");
|
|
4971
|
+
var $L190 = $L("until");
|
|
4972
|
+
var $L191 = $L("using");
|
|
4973
|
+
var $L192 = $L("var");
|
|
4974
|
+
var $L193 = $L("void");
|
|
4975
|
+
var $L194 = $L("when");
|
|
4976
|
+
var $L195 = $L("while");
|
|
4977
|
+
var $L196 = $L("yield");
|
|
4978
|
+
var $L197 = $L("/>");
|
|
4979
|
+
var $L198 = $L("</");
|
|
4980
|
+
var $L199 = $L("<>");
|
|
4981
|
+
var $L200 = $L("</>");
|
|
4982
|
+
var $L201 = $L("<!--");
|
|
4983
|
+
var $L202 = $L("-->");
|
|
4984
|
+
var $L203 = $L("type");
|
|
4985
|
+
var $L204 = $L("enum");
|
|
4986
|
+
var $L205 = $L("interface");
|
|
4987
|
+
var $L206 = $L("global");
|
|
4988
|
+
var $L207 = $L("module");
|
|
4989
|
+
var $L208 = $L("namespace");
|
|
4990
|
+
var $L209 = $L("asserts");
|
|
4991
|
+
var $L210 = $L("keyof");
|
|
4992
|
+
var $L211 = $L("infer");
|
|
4993
|
+
var $L212 = $L("???");
|
|
4994
|
+
var $L213 = $L("[]");
|
|
4995
|
+
var $L214 = $L("civet");
|
|
4952
4996
|
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
4953
4997
|
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4954
4998
|
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
@@ -4958,86 +5002,87 @@ ${input.slice(result.pos)}
|
|
|
4958
5002
|
var $R6 = $R(new RegExp("(?=[\\/?])", "suy"));
|
|
4959
5003
|
var $R7 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
|
|
4960
5004
|
var $R8 = $R(new RegExp("[)}]", "suy"));
|
|
4961
|
-
var $R9 = $R(new RegExp("[
|
|
4962
|
-
var $R10 = $R(new RegExp(
|
|
4963
|
-
var $R11 = $R(new RegExp(
|
|
4964
|
-
var $R12 = $R(new RegExp("(
|
|
4965
|
-
var $R13 = $R(new RegExp("(
|
|
4966
|
-
var $R14 = $R(new RegExp("(
|
|
4967
|
-
var $R15 = $R(new RegExp("[
|
|
4968
|
-
var $R16 = $R(new RegExp("
|
|
4969
|
-
var $R17 = $R(new RegExp("
|
|
4970
|
-
var $R18 = $R(new RegExp("
|
|
4971
|
-
var $R19 = $R(new RegExp("[
|
|
4972
|
-
var $R20 = $R(new RegExp("
|
|
4973
|
-
var $R21 = $R(new RegExp("(?=loop|
|
|
4974
|
-
var $R22 = $R(new RegExp("(?=
|
|
4975
|
-
var $R23 = $R(new RegExp(
|
|
4976
|
-
var $R24 = $R(new RegExp("
|
|
4977
|
-
var $R25 = $R(new RegExp("(
|
|
4978
|
-
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
4979
|
-
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
4980
|
-
var $R28 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4981
|
-
var $R29 = $R(new RegExp("(
|
|
4982
|
-
var $R30 = $R(new RegExp("
|
|
4983
|
-
var $R31 = $R(new RegExp("0[
|
|
4984
|
-
var $R32 = $R(new RegExp("0[
|
|
4985
|
-
var $R33 = $R(new RegExp("(
|
|
4986
|
-
var $R34 = $R(new RegExp("(
|
|
4987
|
-
var $R35 = $R(new RegExp(
|
|
4988
|
-
var $R36 = $R(new RegExp(
|
|
4989
|
-
var $R37 = $R(new RegExp(
|
|
4990
|
-
var $R38 = $R(new RegExp(
|
|
4991
|
-
var $R39 = $R(new RegExp('(
|
|
4992
|
-
var $R40 = $R(new RegExp(
|
|
4993
|
-
var $R41 = $R(new RegExp("(
|
|
4994
|
-
var $R42 = $R(new RegExp("
|
|
4995
|
-
var $R43 = $R(new RegExp("
|
|
4996
|
-
var $R44 = $R(new RegExp("
|
|
4997
|
-
var $R45 = $R(new RegExp("[
|
|
4998
|
-
var $R46 = $R(new RegExp("
|
|
4999
|
-
var $R47 = $R(new RegExp("(
|
|
5000
|
-
var $R48 = $R(new RegExp("(
|
|
5001
|
-
var $R49 = $R(new RegExp("(
|
|
5002
|
-
var $R50 = $R(new RegExp("(?:\\$(?!\\{)
|
|
5003
|
-
var $R51 = $R(new RegExp("(
|
|
5004
|
-
var $R52 = $R(new RegExp("(?:
|
|
5005
|
-
var $R53 = $R(new RegExp("(?:
|
|
5006
|
-
var $R54 = $R(new RegExp("(?:
|
|
5007
|
-
var $R55 = $R(new RegExp("(?:
|
|
5008
|
-
var $R56 = $R(new RegExp("(
|
|
5009
|
-
var $R57 = $R(new RegExp("
|
|
5010
|
-
var $R58 = $R(new RegExp("
|
|
5011
|
-
var $R59 = $R(new RegExp("
|
|
5012
|
-
var $R60 = $R(new RegExp("[
|
|
5013
|
-
var $R61 = $R(new RegExp("
|
|
5014
|
-
var $R62 = $R(new RegExp("
|
|
5015
|
-
var $R63 = $R(new RegExp("(
|
|
5016
|
-
var $R64 = $R(new RegExp("[ \\t]
|
|
5017
|
-
var $R65 = $R(new RegExp("
|
|
5018
|
-
var $R66 = $R(new RegExp("(
|
|
5019
|
-
var $R67 = $R(new RegExp("
|
|
5020
|
-
var $R68 = $R(new RegExp("
|
|
5021
|
-
var $R69 = $R(new RegExp("
|
|
5022
|
-
var $R70 = $R(new RegExp("(
|
|
5023
|
-
var $R71 = $R(new RegExp("[\\
|
|
5024
|
-
var $R72 = $R(new RegExp("
|
|
5025
|
-
var $R73 = $R(new RegExp(
|
|
5026
|
-
var $R74 = $R(new RegExp("[
|
|
5027
|
-
var $R75 = $R(new RegExp("[
|
|
5028
|
-
var $R76 = $R(new RegExp("
|
|
5029
|
-
var $R77 = $R(new RegExp("[
|
|
5030
|
-
var $R78 = $R(new RegExp("[
|
|
5031
|
-
var $R79 = $R(new RegExp("[+-]", "suy"));
|
|
5032
|
-
var $R80 = $R(new RegExp("
|
|
5033
|
-
var $R81 = $R(new RegExp("
|
|
5034
|
-
var $R82 = $R(new RegExp("[\\
|
|
5035
|
-
var $R83 = $R(new RegExp("[
|
|
5036
|
-
var $R84 = $R(new RegExp("[\\
|
|
5037
|
-
var $R85 = $R(new RegExp("
|
|
5038
|
-
var $R86 = $R(new RegExp("
|
|
5039
|
-
var $R87 = $R(new RegExp("
|
|
5040
|
-
var $R88 = $R(new RegExp("\\r\\n
|
|
5005
|
+
var $R9 = $R(new RegExp("\\+\\+|--|[\\+-]\\S", "suy"));
|
|
5006
|
+
var $R10 = $R(new RegExp("[&]", "suy"));
|
|
5007
|
+
var $R11 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
|
|
5008
|
+
var $R12 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
|
|
5009
|
+
var $R13 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
|
|
5010
|
+
var $R14 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
5011
|
+
var $R15 = $R(new RegExp("(?=\\[)", "suy"));
|
|
5012
|
+
var $R16 = $R(new RegExp("[!+-]", "suy"));
|
|
5013
|
+
var $R17 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])", "suy"));
|
|
5014
|
+
var $R18 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
5015
|
+
var $R19 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s)", "suy"));
|
|
5016
|
+
var $R20 = $R(new RegExp("[:.]", "suy"));
|
|
5017
|
+
var $R21 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
5018
|
+
var $R22 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
5019
|
+
var $R23 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
5020
|
+
var $R24 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
5021
|
+
var $R25 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
5022
|
+
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
5023
|
+
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
5024
|
+
var $R28 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
5025
|
+
var $R29 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5026
|
+
var $R30 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
5027
|
+
var $R31 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
5028
|
+
var $R32 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
5029
|
+
var $R33 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
5030
|
+
var $R34 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
5031
|
+
var $R35 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5032
|
+
var $R36 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
5033
|
+
var $R37 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
5034
|
+
var $R38 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
5035
|
+
var $R39 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
5036
|
+
var $R40 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
5037
|
+
var $R41 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
5038
|
+
var $R42 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
5039
|
+
var $R43 = $R(new RegExp("[\\s]+", "suy"));
|
|
5040
|
+
var $R44 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
5041
|
+
var $R45 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
5042
|
+
var $R46 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
5043
|
+
var $R47 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
5044
|
+
var $R48 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
5045
|
+
var $R49 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
5046
|
+
var $R50 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
5047
|
+
var $R51 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
5048
|
+
var $R52 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
5049
|
+
var $R53 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
5050
|
+
var $R54 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
5051
|
+
var $R55 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
5052
|
+
var $R56 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
5053
|
+
var $R57 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
5054
|
+
var $R58 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
5055
|
+
var $R59 = $R(new RegExp(".", "suy"));
|
|
5056
|
+
var $R60 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
5057
|
+
var $R61 = $R(new RegExp("[^]*?###", "suy"));
|
|
5058
|
+
var $R62 = $R(new RegExp("###(?!#)", "suy"));
|
|
5059
|
+
var $R63 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
5060
|
+
var $R64 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
5061
|
+
var $R65 = $R(new RegExp("[ \\t]+", "suy"));
|
|
5062
|
+
var $R66 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
5063
|
+
var $R67 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
5064
|
+
var $R68 = $R(new RegExp("['\u2019]s", "suy"));
|
|
5065
|
+
var $R69 = $R(new RegExp("\\s", "suy"));
|
|
5066
|
+
var $R70 = $R(new RegExp("(?=[<])", "suy"));
|
|
5067
|
+
var $R71 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
5068
|
+
var $R72 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
5069
|
+
var $R73 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
5070
|
+
var $R74 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
5071
|
+
var $R75 = $R(new RegExp("[<>]", "suy"));
|
|
5072
|
+
var $R76 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
5073
|
+
var $R77 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
5074
|
+
var $R78 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
5075
|
+
var $R79 = $R(new RegExp("[+-]?", "suy"));
|
|
5076
|
+
var $R80 = $R(new RegExp("[+-]", "suy"));
|
|
5077
|
+
var $R81 = $R(new RegExp("(?=if|unless)", "suy"));
|
|
5078
|
+
var $R82 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
5079
|
+
var $R83 = $R(new RegExp("[\\t ]*", "suy"));
|
|
5080
|
+
var $R84 = $R(new RegExp("[ \\t]*", "suy"));
|
|
5081
|
+
var $R85 = $R(new RegExp("[\\s]*", "suy"));
|
|
5082
|
+
var $R86 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
5083
|
+
var $R87 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
5084
|
+
var $R88 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
5085
|
+
var $R89 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
5041
5086
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5042
5087
|
var statements = $4;
|
|
5043
5088
|
processProgram({
|
|
@@ -5215,15 +5260,43 @@ ${input.slice(result.pos)}
|
|
|
5215
5260
|
var ws = $3;
|
|
5216
5261
|
var args = $4;
|
|
5217
5262
|
var close = $5;
|
|
5218
|
-
if (args.length === 1
|
|
5219
|
-
|
|
5263
|
+
if (args.length === 1) {
|
|
5264
|
+
let arg0 = args[0];
|
|
5265
|
+
if (Array.isArray(arg0))
|
|
5266
|
+
arg0 = arg0[1];
|
|
5267
|
+
if (arg0.type === "IterationExpression" && arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block)) {
|
|
5268
|
+
return $skip;
|
|
5269
|
+
}
|
|
5220
5270
|
}
|
|
5221
|
-
return
|
|
5271
|
+
return {
|
|
5272
|
+
type: "Call",
|
|
5273
|
+
args,
|
|
5274
|
+
children: [open, insertTrimmingSpace(ws, ""), args, close]
|
|
5275
|
+
};
|
|
5222
5276
|
});
|
|
5223
5277
|
function ImplicitArguments(ctx, state) {
|
|
5224
5278
|
return $EVENT(ctx, state, "ImplicitArguments", ImplicitArguments$0);
|
|
5225
5279
|
}
|
|
5226
|
-
var ExplicitArguments$0 = $S(OpenParen, $E(ArgumentList
|
|
5280
|
+
var ExplicitArguments$0 = $TS($S(OpenParen, $E($S(ArgumentList, $E($S(__, Comma)))), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5281
|
+
var open = $1;
|
|
5282
|
+
var args = $2;
|
|
5283
|
+
var ws = $3;
|
|
5284
|
+
var close = $4;
|
|
5285
|
+
if (args) {
|
|
5286
|
+
if (args[1]) {
|
|
5287
|
+
args = [...args[0], args[1]];
|
|
5288
|
+
} else {
|
|
5289
|
+
args = args[0];
|
|
5290
|
+
}
|
|
5291
|
+
} else {
|
|
5292
|
+
args = [];
|
|
5293
|
+
}
|
|
5294
|
+
return {
|
|
5295
|
+
type: "Call",
|
|
5296
|
+
args,
|
|
5297
|
+
children: [open, args, ws, close]
|
|
5298
|
+
};
|
|
5299
|
+
});
|
|
5227
5300
|
function ExplicitArguments(ctx, state) {
|
|
5228
5301
|
return $EVENT(ctx, state, "ExplicitArguments", ExplicitArguments$0);
|
|
5229
5302
|
}
|
|
@@ -5257,11 +5330,7 @@ ${input.slice(result.pos)}
|
|
|
5257
5330
|
var ArgumentsWithTrailingMemberExpressions$0 = $TS($S(Arguments, AllowedTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
|
|
5258
5331
|
var args = $1;
|
|
5259
5332
|
var trailing = $2;
|
|
5260
|
-
|
|
5261
|
-
type: "Call",
|
|
5262
|
-
children: args
|
|
5263
|
-
};
|
|
5264
|
-
return [call, ...trailing];
|
|
5333
|
+
return [args, ...trailing];
|
|
5265
5334
|
});
|
|
5266
5335
|
function ArgumentsWithTrailingMemberExpressions(ctx, state) {
|
|
5267
5336
|
return $EVENT(ctx, state, "ArgumentsWithTrailingMemberExpressions", ArgumentsWithTrailingMemberExpressions$0);
|
|
@@ -5294,25 +5363,41 @@ ${input.slice(result.pos)}
|
|
|
5294
5363
|
function CommaDelimiter(ctx, state) {
|
|
5295
5364
|
return $EVENT(ctx, state, "CommaDelimiter", CommaDelimiter$0);
|
|
5296
5365
|
}
|
|
5297
|
-
var ArgumentList$0 = $S(ArgumentPart, $Q($S(CommaDelimiter, $N(EOS), ArgumentPart)), $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))))
|
|
5366
|
+
var ArgumentList$0 = $TS($S(ArgumentPart, $Q($S(CommaDelimiter, $N(EOS), ArgumentPart)), $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList)))), function($skip, $loc, $0, $1, $2, $3) {
|
|
5367
|
+
return [
|
|
5368
|
+
$1,
|
|
5369
|
+
...$2.flatMap(([comma, eos, arg]) => [comma, arg]),
|
|
5370
|
+
...$3.flatMap(
|
|
5371
|
+
([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
|
|
5372
|
+
)
|
|
5373
|
+
];
|
|
5374
|
+
});
|
|
5298
5375
|
var ArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
|
|
5299
|
-
return insertTrimmingSpace($1, "");
|
|
5376
|
+
return [insertTrimmingSpace($1, "")];
|
|
5300
5377
|
});
|
|
5301
5378
|
var ArgumentList$2 = NestedArgumentList;
|
|
5302
|
-
var ArgumentList$3 = $TS($S($E(_), ArgumentPart, $Q($S(CommaDelimiter, $E(_), ArgumentPart))), function($skip, $loc, $0, $1, $2
|
|
5303
|
-
return [
|
|
5379
|
+
var ArgumentList$3 = $TS($S($S($E(_), ArgumentPart), $Q($S(CommaDelimiter, $S($E(_), ArgumentPart)))), function($skip, $loc, $0, $1, $2) {
|
|
5380
|
+
return [$1, ...$2.flat()];
|
|
5304
5381
|
});
|
|
5305
5382
|
var ArgumentList$$ = [ArgumentList$0, ArgumentList$1, ArgumentList$2, ArgumentList$3];
|
|
5306
5383
|
function ArgumentList(ctx, state) {
|
|
5307
5384
|
return $EVENT_C(ctx, state, "ArgumentList", ArgumentList$$);
|
|
5308
5385
|
}
|
|
5309
|
-
var NonPipelineArgumentList$0 = $S(NonPipelineArgumentPart, $Q($S(CommaDelimiter, $N(EOS), NonPipelineArgumentPart)), $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))))
|
|
5386
|
+
var NonPipelineArgumentList$0 = $TS($S(NonPipelineArgumentPart, $Q($S(CommaDelimiter, $N(EOS), NonPipelineArgumentPart)), $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList)))), function($skip, $loc, $0, $1, $2, $3) {
|
|
5387
|
+
return [
|
|
5388
|
+
$1,
|
|
5389
|
+
...$2.flatMap(([comma, eos, arg]) => [comma, arg]),
|
|
5390
|
+
...$3.flatMap(
|
|
5391
|
+
([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
|
|
5392
|
+
)
|
|
5393
|
+
];
|
|
5394
|
+
});
|
|
5310
5395
|
var NonPipelineArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
|
|
5311
|
-
return insertTrimmingSpace($1, "");
|
|
5396
|
+
return [insertTrimmingSpace($1, "")];
|
|
5312
5397
|
});
|
|
5313
5398
|
var NonPipelineArgumentList$2 = NestedArgumentList;
|
|
5314
|
-
var NonPipelineArgumentList$3 = $TS($S($E(_), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $E(_), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2
|
|
5315
|
-
return [
|
|
5399
|
+
var NonPipelineArgumentList$3 = $TS($S($S($E(_), NonPipelineArgumentPart), $Q($S(CommaDelimiter, $S($E(_), NonPipelineArgumentPart)))), function($skip, $loc, $0, $1, $2) {
|
|
5400
|
+
return [$1, ...$2.flat()];
|
|
5316
5401
|
});
|
|
5317
5402
|
var NonPipelineArgumentList$$ = [NonPipelineArgumentList$0, NonPipelineArgumentList$1, NonPipelineArgumentList$2, NonPipelineArgumentList$3];
|
|
5318
5403
|
function NonPipelineArgumentList(ctx, state) {
|
|
@@ -5320,18 +5405,27 @@ ${input.slice(result.pos)}
|
|
|
5320
5405
|
}
|
|
5321
5406
|
var NestedArgumentList$0 = $TS($S(PushIndent, $Q(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
5322
5407
|
var args = $2;
|
|
5323
|
-
if (args.length)
|
|
5324
|
-
return
|
|
5325
|
-
return
|
|
5408
|
+
if (!args.length)
|
|
5409
|
+
return $skip;
|
|
5410
|
+
return args.flat();
|
|
5326
5411
|
});
|
|
5327
5412
|
function NestedArgumentList(ctx, state) {
|
|
5328
5413
|
return $EVENT(ctx, state, "NestedArgumentList", NestedArgumentList$0);
|
|
5329
5414
|
}
|
|
5330
|
-
var NestedArgument$0 = $S(Nested, SingleLineArgumentExpressions, ParameterElementDelimiter)
|
|
5415
|
+
var NestedArgument$0 = $TS($S(Nested, SingleLineArgumentExpressions, ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
5416
|
+
var indent = $1;
|
|
5417
|
+
var args = $2;
|
|
5418
|
+
var comma = $3;
|
|
5419
|
+
let [arg0, ...rest] = args;
|
|
5420
|
+
arg0 = [indent, ...arg0];
|
|
5421
|
+
return [arg0, ...rest, comma];
|
|
5422
|
+
});
|
|
5331
5423
|
function NestedArgument(ctx, state) {
|
|
5332
5424
|
return $EVENT(ctx, state, "NestedArgument", NestedArgument$0);
|
|
5333
5425
|
}
|
|
5334
|
-
var SingleLineArgumentExpressions$0 = $S($E(_), ArgumentPart, $Q($S($E(_), Comma, $E(_), ArgumentPart)))
|
|
5426
|
+
var SingleLineArgumentExpressions$0 = $TS($S($S($E(_), ArgumentPart), $Q($S($S($E(_), Comma), $S($E(_), ArgumentPart)))), function($skip, $loc, $0, $1, $2) {
|
|
5427
|
+
return [$1, ...$2.flat()];
|
|
5428
|
+
});
|
|
5335
5429
|
function SingleLineArgumentExpressions(ctx, state) {
|
|
5336
5430
|
return $EVENT(ctx, state, "SingleLineArgumentExpressions", SingleLineArgumentExpressions$0);
|
|
5337
5431
|
}
|
|
@@ -5504,7 +5598,10 @@ ${input.slice(result.pos)}
|
|
|
5504
5598
|
var UpdateExpressionSymbol$1 = $TV($EXPECT($L10, 'UpdateExpressionSymbol "\u29FA"'), function($skip, $loc, $0, $1) {
|
|
5505
5599
|
return { $loc, token: "++" };
|
|
5506
5600
|
});
|
|
5507
|
-
var UpdateExpressionSymbol
|
|
5601
|
+
var UpdateExpressionSymbol$2 = $TV($EXPECT($L11, 'UpdateExpressionSymbol "\u2014"'), function($skip, $loc, $0, $1) {
|
|
5602
|
+
return { $loc, token: "--" };
|
|
5603
|
+
});
|
|
5604
|
+
var UpdateExpressionSymbol$$ = [UpdateExpressionSymbol$0, UpdateExpressionSymbol$1, UpdateExpressionSymbol$2];
|
|
5508
5605
|
function UpdateExpressionSymbol(ctx, state) {
|
|
5509
5606
|
return $EVENT_C(ctx, state, "UpdateExpressionSymbol", UpdateExpressionSymbol$$);
|
|
5510
5607
|
}
|
|
@@ -5609,7 +5706,7 @@ ${input.slice(result.pos)}
|
|
|
5609
5706
|
function ArrowFunction(ctx, state) {
|
|
5610
5707
|
return $EVENT_C(ctx, state, "ArrowFunction", ArrowFunction$$);
|
|
5611
5708
|
}
|
|
5612
|
-
var FatArrow$0 = $TS($S($E(_), $C($EXPECT($
|
|
5709
|
+
var FatArrow$0 = $TS($S($E(_), $C($EXPECT($L12, 'FatArrow "=>"'), $EXPECT($L13, 'FatArrow "\u21D2"'))), function($skip, $loc, $0, $1, $2) {
|
|
5613
5710
|
var ws = $1;
|
|
5614
5711
|
if (!ws)
|
|
5615
5712
|
return " =>";
|
|
@@ -5776,7 +5873,7 @@ ${input.slice(result.pos)}
|
|
|
5776
5873
|
function ClassDeclaration(ctx, state) {
|
|
5777
5874
|
return $EVENT(ctx, state, "ClassDeclaration", ClassDeclaration$0);
|
|
5778
5875
|
}
|
|
5779
|
-
var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($
|
|
5876
|
+
var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($L14, 'ClassExpression ":"')), $E(ClassBinding), $E(ClassHeritage), ClassBody), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
5780
5877
|
var decorators = $1;
|
|
5781
5878
|
var abstract = $2;
|
|
5782
5879
|
var binding = $5;
|
|
@@ -5810,7 +5907,7 @@ ${input.slice(result.pos)}
|
|
|
5810
5907
|
function ExtendsClause(ctx, state) {
|
|
5811
5908
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5812
5909
|
}
|
|
5813
|
-
var ExtendsToken$0 = $TS($S(Loc, $E(_), ExtendsShorthand, $E($EXPECT($
|
|
5910
|
+
var ExtendsToken$0 = $TS($S(Loc, $E(_), ExtendsShorthand, $E($EXPECT($L15, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5814
5911
|
var l = $1;
|
|
5815
5912
|
var ws = $2;
|
|
5816
5913
|
var t = $3;
|
|
@@ -5832,13 +5929,13 @@ ${input.slice(result.pos)}
|
|
|
5832
5929
|
function ExtendsToken(ctx, state) {
|
|
5833
5930
|
return $EVENT_C(ctx, state, "ExtendsToken", ExtendsToken$$);
|
|
5834
5931
|
}
|
|
5835
|
-
var ExtendsShorthand$0 = $TV($EXPECT($
|
|
5932
|
+
var ExtendsShorthand$0 = $TV($EXPECT($L16, 'ExtendsShorthand "<"'), function($skip, $loc, $0, $1) {
|
|
5836
5933
|
return { $loc, token: "extends " };
|
|
5837
5934
|
});
|
|
5838
5935
|
function ExtendsShorthand(ctx, state) {
|
|
5839
5936
|
return $EVENT(ctx, state, "ExtendsShorthand", ExtendsShorthand$0);
|
|
5840
5937
|
}
|
|
5841
|
-
var NotExtendsToken$0 = $TS($S(Loc, $E(_), OmittedNegation, ExtendsShorthand, $E($EXPECT($
|
|
5938
|
+
var NotExtendsToken$0 = $TS($S(Loc, $E(_), OmittedNegation, ExtendsShorthand, $E($EXPECT($L15, 'NotExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5842
5939
|
var l = $1;
|
|
5843
5940
|
var ws1 = $2;
|
|
5844
5941
|
var ws2 = $3;
|
|
@@ -5864,7 +5961,7 @@ ${input.slice(result.pos)}
|
|
|
5864
5961
|
var OmittedNegation$0 = $T($S(ExclamationPoint), function(value) {
|
|
5865
5962
|
return "";
|
|
5866
5963
|
});
|
|
5867
|
-
var OmittedNegation$1 = $T($S(Not, $E($EXPECT($
|
|
5964
|
+
var OmittedNegation$1 = $T($S(Not, $E($EXPECT($L15, 'OmittedNegation " "')), $E(_)), function(value) {
|
|
5868
5965
|
return value[2];
|
|
5869
5966
|
});
|
|
5870
5967
|
var OmittedNegation$$ = [OmittedNegation$0, OmittedNegation$1];
|
|
@@ -5887,7 +5984,7 @@ ${input.slice(result.pos)}
|
|
|
5887
5984
|
function ImplementsClause(ctx, state) {
|
|
5888
5985
|
return $EVENT(ctx, state, "ImplementsClause", ImplementsClause$0);
|
|
5889
5986
|
}
|
|
5890
|
-
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($
|
|
5987
|
+
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($L15, 'ImplementsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5891
5988
|
var l = $1;
|
|
5892
5989
|
var ws = $2;
|
|
5893
5990
|
var token = $3;
|
|
@@ -5897,7 +5994,7 @@ ${input.slice(result.pos)}
|
|
|
5897
5994
|
}
|
|
5898
5995
|
return { children };
|
|
5899
5996
|
});
|
|
5900
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
5997
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L17, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5901
5998
|
$2 = { $loc, token: $2 };
|
|
5902
5999
|
return [$1, $2];
|
|
5903
6000
|
});
|
|
@@ -5905,7 +6002,7 @@ ${input.slice(result.pos)}
|
|
|
5905
6002
|
function ImplementsToken(ctx, state) {
|
|
5906
6003
|
return $EVENT_C(ctx, state, "ImplementsToken", ImplementsToken$$);
|
|
5907
6004
|
}
|
|
5908
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
6005
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L18, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
5909
6006
|
return { $loc, token: "implements " };
|
|
5910
6007
|
});
|
|
5911
6008
|
function ImplementsShorthand(ctx, state) {
|
|
@@ -6117,7 +6214,7 @@ ${input.slice(result.pos)}
|
|
|
6117
6214
|
function AtThis(ctx, state) {
|
|
6118
6215
|
return $EVENT(ctx, state, "AtThis", AtThis$0);
|
|
6119
6216
|
}
|
|
6120
|
-
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L7, 'LeftHandSideExpression "."'), $EXPECT($
|
|
6217
|
+
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L7, 'LeftHandSideExpression "."'), $EXPECT($L14, 'LeftHandSideExpression ":"'))), __)), CallExpression);
|
|
6121
6218
|
var LeftHandSideExpression$1 = CallExpression;
|
|
6122
6219
|
var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
|
|
6123
6220
|
function LeftHandSideExpression(ctx, state) {
|
|
@@ -6130,7 +6227,7 @@ ${input.slice(result.pos)}
|
|
|
6130
6227
|
children: [$1, ...$2, ...rest.flat()]
|
|
6131
6228
|
});
|
|
6132
6229
|
});
|
|
6133
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
6230
|
+
var CallExpression$1 = $TS($S($EXPECT($L19, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
6134
6231
|
var rest = $3;
|
|
6135
6232
|
return processCallMemberExpression({
|
|
6136
6233
|
type: "CallExpression",
|
|
@@ -6191,7 +6288,7 @@ ${input.slice(result.pos)}
|
|
|
6191
6288
|
function OptionalDot(ctx, state) {
|
|
6192
6289
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
6193
6290
|
}
|
|
6194
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
6291
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L20, 'NonNullAssertion "!"'), $N($EXPECT($L21, 'NonNullAssertion "^"'))), function(value) {
|
|
6195
6292
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
6196
6293
|
});
|
|
6197
6294
|
function NonNullAssertion(ctx, state) {
|
|
@@ -6386,7 +6483,7 @@ ${input.slice(result.pos)}
|
|
|
6386
6483
|
]
|
|
6387
6484
|
};
|
|
6388
6485
|
});
|
|
6389
|
-
var PropertyAccess$1 = $TS($S(AccessStart, $EXPECT($
|
|
6486
|
+
var PropertyAccess$1 = $TS($S(AccessStart, $EXPECT($L22, 'PropertyAccess "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
6390
6487
|
var dot = $1;
|
|
6391
6488
|
var neg = $2;
|
|
6392
6489
|
var num = $3;
|
|
@@ -6462,7 +6559,7 @@ ${input.slice(result.pos)}
|
|
|
6462
6559
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
6463
6560
|
}
|
|
6464
6561
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
6465
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
6562
|
+
var MetaProperty$1 = $TS($S($EXPECT($L23, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6466
6563
|
return { $loc, token: $1 };
|
|
6467
6564
|
});
|
|
6468
6565
|
var MetaProperty$2 = ReturnValue;
|
|
@@ -6470,7 +6567,7 @@ ${input.slice(result.pos)}
|
|
|
6470
6567
|
function MetaProperty(ctx, state) {
|
|
6471
6568
|
return $EVENT_C(ctx, state, "MetaProperty", MetaProperty$$);
|
|
6472
6569
|
}
|
|
6473
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($
|
|
6570
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L24, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
6474
6571
|
return { type: "ReturnValue", children: [$1[0]] };
|
|
6475
6572
|
});
|
|
6476
6573
|
function ReturnValue(ctx, state) {
|
|
@@ -6983,7 +7080,7 @@ ${input.slice(result.pos)}
|
|
|
6983
7080
|
children: [ws, binding]
|
|
6984
7081
|
};
|
|
6985
7082
|
});
|
|
6986
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
7083
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L25, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
6987
7084
|
return {
|
|
6988
7085
|
children: [{
|
|
6989
7086
|
type: "ElisionElement",
|
|
@@ -7039,6 +7136,8 @@ ${input.slice(result.pos)}
|
|
|
7039
7136
|
return $EVENT(ctx, state, "EmptyBindingPattern", EmptyBindingPattern$0);
|
|
7040
7137
|
}
|
|
7041
7138
|
var FunctionDeclaration$0 = $TS($S(FunctionExpression), function($skip, $loc, $0, $1) {
|
|
7139
|
+
if ($1.type !== "FunctionExpression")
|
|
7140
|
+
return $skip;
|
|
7042
7141
|
if ($1.id)
|
|
7043
7142
|
return $1;
|
|
7044
7143
|
return makeLeftHandSideExpression($1);
|
|
@@ -7107,7 +7206,7 @@ ${input.slice(result.pos)}
|
|
|
7107
7206
|
block
|
|
7108
7207
|
};
|
|
7109
7208
|
});
|
|
7110
|
-
var FunctionExpression$1 = $TV($EXPECT($
|
|
7209
|
+
var FunctionExpression$1 = $TV($EXPECT($L26, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
7111
7210
|
const ref = makeRef("$"), body = [ref];
|
|
7112
7211
|
const parameters = {
|
|
7113
7212
|
type: "Parameters",
|
|
@@ -7155,13 +7254,80 @@ ${input.slice(result.pos)}
|
|
|
7155
7254
|
},
|
|
7156
7255
|
children: [open, parameters, " => ", body, close],
|
|
7157
7256
|
body,
|
|
7257
|
+
parenthesized: true,
|
|
7258
|
+
parenthesizedOp: op,
|
|
7259
|
+
block,
|
|
7260
|
+
parameters
|
|
7261
|
+
};
|
|
7262
|
+
});
|
|
7263
|
+
var FunctionExpression$3 = $TS($S(OpenParen, NonPipelineAssignmentExpression, __, BinaryOp, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7264
|
+
var open = $1;
|
|
7265
|
+
var lhs = $2;
|
|
7266
|
+
var ws1 = $3;
|
|
7267
|
+
var op = $4;
|
|
7268
|
+
var ws2 = $5;
|
|
7269
|
+
var close = $6;
|
|
7270
|
+
const refB = makeRef("b"), body = processBinaryOpExpression([lhs, [
|
|
7271
|
+
[ws1, op, ws2, refB]
|
|
7272
|
+
// BinaryOpRHS
|
|
7273
|
+
]]);
|
|
7274
|
+
const parameters = {
|
|
7275
|
+
type: "Parameters",
|
|
7276
|
+
children: ["(", refB, ")"],
|
|
7277
|
+
names: []
|
|
7278
|
+
};
|
|
7279
|
+
const block = {
|
|
7280
|
+
expressions: [body]
|
|
7281
|
+
};
|
|
7282
|
+
return {
|
|
7283
|
+
type: "ArrowFunction",
|
|
7284
|
+
signature: {
|
|
7285
|
+
modifier: {}
|
|
7286
|
+
},
|
|
7287
|
+
children: [open, parameters, " => ", body, close],
|
|
7288
|
+
body,
|
|
7289
|
+
parenthesized: true,
|
|
7290
|
+
ampersandBlock: true,
|
|
7291
|
+
ref: refB,
|
|
7292
|
+
block,
|
|
7293
|
+
parameters
|
|
7294
|
+
};
|
|
7295
|
+
});
|
|
7296
|
+
var FunctionExpression$4 = $TS($S(OpenParen, __, $N($EXPECT($R9, "FunctionExpression /\\+\\+|--|[\\+-]\\S/")), BinaryOp, __, NonPipelineAssignmentExpression, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
7297
|
+
var open = $1;
|
|
7298
|
+
var ws1 = $2;
|
|
7299
|
+
var op = $4;
|
|
7300
|
+
var ws2 = $5;
|
|
7301
|
+
var rhs = $6;
|
|
7302
|
+
var close = $7;
|
|
7303
|
+
const refA = makeRef("a"), body = processBinaryOpExpression([refA, [
|
|
7304
|
+
[ws1, op, ws2, rhs]
|
|
7305
|
+
// BinaryOpRHS
|
|
7306
|
+
]]);
|
|
7307
|
+
const parameters = {
|
|
7308
|
+
type: "Parameters",
|
|
7309
|
+
children: ["(", refA, ")"],
|
|
7310
|
+
names: []
|
|
7311
|
+
};
|
|
7312
|
+
const block = {
|
|
7313
|
+
expressions: [body]
|
|
7314
|
+
};
|
|
7315
|
+
return {
|
|
7316
|
+
type: "ArrowFunction",
|
|
7317
|
+
signature: {
|
|
7318
|
+
modifier: {}
|
|
7319
|
+
},
|
|
7320
|
+
children: [open, parameters, " => ", body, close],
|
|
7321
|
+
body,
|
|
7322
|
+
parenthesized: true,
|
|
7158
7323
|
ampersandBlock: true,
|
|
7324
|
+
ref: refA,
|
|
7159
7325
|
block,
|
|
7160
7326
|
parameters
|
|
7161
7327
|
};
|
|
7162
7328
|
});
|
|
7163
|
-
var FunctionExpression$
|
|
7164
|
-
var FunctionExpression$
|
|
7329
|
+
var FunctionExpression$5 = AmpersandFunctionExpression;
|
|
7330
|
+
var FunctionExpression$6 = $TS($S(Identifier, __, ConstAssignment, $Q(_), ThinArrowFunction), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7165
7331
|
var id = $1;
|
|
7166
7332
|
var ws = $4;
|
|
7167
7333
|
var fn = $5;
|
|
@@ -7176,7 +7342,7 @@ ${input.slice(result.pos)}
|
|
|
7176
7342
|
]
|
|
7177
7343
|
};
|
|
7178
7344
|
});
|
|
7179
|
-
var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3, FunctionExpression$4];
|
|
7345
|
+
var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3, FunctionExpression$4, FunctionExpression$5, FunctionExpression$6];
|
|
7180
7346
|
function FunctionExpression(ctx, state) {
|
|
7181
7347
|
return $EVENT_C(ctx, state, "FunctionExpression", FunctionExpression$$);
|
|
7182
7348
|
}
|
|
@@ -7307,7 +7473,7 @@ ${input.slice(result.pos)}
|
|
|
7307
7473
|
function AmpersandBlockRHS(ctx, state) {
|
|
7308
7474
|
return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
|
|
7309
7475
|
}
|
|
7310
|
-
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($
|
|
7476
|
+
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($R10, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7311
7477
|
var callExpRest = $1;
|
|
7312
7478
|
var unaryPostfix = $2;
|
|
7313
7479
|
var assign = $3;
|
|
@@ -7397,7 +7563,7 @@ ${input.slice(result.pos)}
|
|
|
7397
7563
|
function ThinArrowFunction(ctx, state) {
|
|
7398
7564
|
return $EVENT(ctx, state, "ThinArrowFunction", ThinArrowFunction$0);
|
|
7399
7565
|
}
|
|
7400
|
-
var Arrow$0 = $TV($C($EXPECT($
|
|
7566
|
+
var Arrow$0 = $TV($C($EXPECT($L27, 'Arrow "->"'), $EXPECT($L28, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
|
|
7401
7567
|
return { $loc, token: "->" };
|
|
7402
7568
|
});
|
|
7403
7569
|
function Arrow(ctx, state) {
|
|
@@ -7698,7 +7864,7 @@ ${input.slice(result.pos)}
|
|
|
7698
7864
|
}
|
|
7699
7865
|
var BracedContent$0 = NestedBlockStatements;
|
|
7700
7866
|
var BracedContent$1 = SingleLineStatements;
|
|
7701
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
7867
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L29, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
7702
7868
|
const expressions = [];
|
|
7703
7869
|
return {
|
|
7704
7870
|
type: "BlockStatement",
|
|
@@ -7748,7 +7914,7 @@ ${input.slice(result.pos)}
|
|
|
7748
7914
|
function BlockStatementPart(ctx, state) {
|
|
7749
7915
|
return $EVENT(ctx, state, "BlockStatementPart", BlockStatementPart$0);
|
|
7750
7916
|
}
|
|
7751
|
-
var Literal$0 = $TS($S($EXPECT($
|
|
7917
|
+
var Literal$0 = $TS($S($EXPECT($R11, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
|
|
7752
7918
|
var literal = $2;
|
|
7753
7919
|
return {
|
|
7754
7920
|
type: "Literal",
|
|
@@ -7768,13 +7934,13 @@ ${input.slice(result.pos)}
|
|
|
7768
7934
|
function LiteralContent(ctx, state) {
|
|
7769
7935
|
return $EVENT_C(ctx, state, "LiteralContent", LiteralContent$$);
|
|
7770
7936
|
}
|
|
7771
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
7937
|
+
var NullLiteral$0 = $TS($S($EXPECT($L30, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7772
7938
|
return { $loc, token: $1 };
|
|
7773
7939
|
});
|
|
7774
7940
|
function NullLiteral(ctx, state) {
|
|
7775
7941
|
return $EVENT(ctx, state, "NullLiteral", NullLiteral$0);
|
|
7776
7942
|
}
|
|
7777
|
-
var BooleanLiteral$0 = $T($S($EXPECT($
|
|
7943
|
+
var BooleanLiteral$0 = $T($S($EXPECT($R12, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
|
|
7778
7944
|
return value[1];
|
|
7779
7945
|
});
|
|
7780
7946
|
function BooleanLiteral(ctx, state) {
|
|
@@ -7783,31 +7949,31 @@ ${input.slice(result.pos)}
|
|
|
7783
7949
|
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7784
7950
|
return value[1];
|
|
7785
7951
|
});
|
|
7786
|
-
var _BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7952
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L31, '_BooleanLiteral "true"'), $EXPECT($L32, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7787
7953
|
return { $loc, token: $1 };
|
|
7788
7954
|
});
|
|
7789
7955
|
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7790
7956
|
function _BooleanLiteral(ctx, state) {
|
|
7791
7957
|
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
7792
7958
|
}
|
|
7793
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
7959
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L33, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L34, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7794
7960
|
return { $loc, token: "true" };
|
|
7795
7961
|
});
|
|
7796
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7962
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L35, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L36, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7797
7963
|
return { $loc, token: "false" };
|
|
7798
7964
|
});
|
|
7799
7965
|
var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
|
|
7800
7966
|
function CoffeeScriptBooleanLiteral(ctx, state) {
|
|
7801
7967
|
return $EVENT_C(ctx, state, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
|
|
7802
7968
|
}
|
|
7803
|
-
var Identifier$0 = $T($S($EXPECT($
|
|
7969
|
+
var Identifier$0 = $T($S($EXPECT($R13, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
|
|
7804
7970
|
var id = value[2];
|
|
7805
7971
|
return id;
|
|
7806
7972
|
});
|
|
7807
7973
|
function Identifier(ctx, state) {
|
|
7808
7974
|
return $EVENT(ctx, state, "Identifier", Identifier$0);
|
|
7809
7975
|
}
|
|
7810
|
-
var IdentifierName$0 = $TR($EXPECT($
|
|
7976
|
+
var IdentifierName$0 = $TR($EXPECT($R14, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7811
7977
|
return {
|
|
7812
7978
|
type: "Identifier",
|
|
7813
7979
|
name: $0,
|
|
@@ -7825,11 +7991,11 @@ ${input.slice(result.pos)}
|
|
|
7825
7991
|
function IdentifierReference(ctx, state) {
|
|
7826
7992
|
return $EVENT(ctx, state, "IdentifierReference", IdentifierReference$0);
|
|
7827
7993
|
}
|
|
7828
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($
|
|
7994
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($L37, 'UpcomingAssignment ">"')))));
|
|
7829
7995
|
function UpcomingAssignment(ctx, state) {
|
|
7830
7996
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7831
7997
|
}
|
|
7832
|
-
var ArrayLiteral$0 = $T($S($EXPECT($
|
|
7998
|
+
var ArrayLiteral$0 = $T($S($EXPECT($R15, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
|
|
7833
7999
|
return value[1];
|
|
7834
8000
|
});
|
|
7835
8001
|
function ArrayLiteral(ctx, state) {
|
|
@@ -7983,7 +8149,7 @@ ${input.slice(result.pos)}
|
|
|
7983
8149
|
return $EVENT(ctx, state, "NestedElement", NestedElement$0);
|
|
7984
8150
|
}
|
|
7985
8151
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
7986
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
8152
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L38, 'ArrayElementDelimiter "]"')));
|
|
7987
8153
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7988
8154
|
return value[1];
|
|
7989
8155
|
});
|
|
@@ -8213,7 +8379,7 @@ ${input.slice(result.pos)}
|
|
|
8213
8379
|
return $EVENT_C(ctx, state, "ImplicitInlineObjectPropertyDelimiter", ImplicitInlineObjectPropertyDelimiter$$);
|
|
8214
8380
|
}
|
|
8215
8381
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
8216
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
8382
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L29, 'ObjectPropertyDelimiter "}"')));
|
|
8217
8383
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
8218
8384
|
return value[1];
|
|
8219
8385
|
});
|
|
@@ -8229,7 +8395,7 @@ ${input.slice(result.pos)}
|
|
|
8229
8395
|
children: [ws, ...prop.children]
|
|
8230
8396
|
};
|
|
8231
8397
|
});
|
|
8232
|
-
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($
|
|
8398
|
+
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R16, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
|
|
8233
8399
|
var ws = $1;
|
|
8234
8400
|
var toggle = $2;
|
|
8235
8401
|
var id = $3;
|
|
@@ -8396,7 +8562,7 @@ ${input.slice(result.pos)}
|
|
|
8396
8562
|
implicit: true
|
|
8397
8563
|
};
|
|
8398
8564
|
});
|
|
8399
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
8565
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L22, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8400
8566
|
const expression = [$2, $3];
|
|
8401
8567
|
return {
|
|
8402
8568
|
type: "ComputedPropertyName",
|
|
@@ -8696,10 +8862,10 @@ ${input.slice(result.pos)}
|
|
|
8696
8862
|
function OperatorAssignmentOp(ctx, state) {
|
|
8697
8863
|
return $EVENT_C(ctx, state, "OperatorAssignmentOp", OperatorAssignmentOp$$);
|
|
8698
8864
|
}
|
|
8699
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
8700
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
8701
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
8702
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
8865
|
+
var AssignmentOpSymbol$0 = $EXPECT($L39, 'AssignmentOpSymbol "**="');
|
|
8866
|
+
var AssignmentOpSymbol$1 = $EXPECT($L40, 'AssignmentOpSymbol "*="');
|
|
8867
|
+
var AssignmentOpSymbol$2 = $EXPECT($L41, 'AssignmentOpSymbol "/="');
|
|
8868
|
+
var AssignmentOpSymbol$3 = $EXPECT($L42, 'AssignmentOpSymbol "%="');
|
|
8703
8869
|
var AssignmentOpSymbol$4 = $TS($S($C($EXPECT($L8, 'AssignmentOpSymbol "++"'), $EXPECT($L10, 'AssignmentOpSymbol "\u29FA"')), Equals), function($skip, $loc, $0, $1, $2) {
|
|
8704
8870
|
return {
|
|
8705
8871
|
special: true,
|
|
@@ -8708,18 +8874,18 @@ ${input.slice(result.pos)}
|
|
|
8708
8874
|
children: [$2]
|
|
8709
8875
|
};
|
|
8710
8876
|
});
|
|
8711
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
8712
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
8713
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
8714
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
8715
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
8716
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
8717
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
8718
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
8719
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
8720
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
8721
|
-
var AssignmentOpSymbol$15 = $EXPECT($
|
|
8722
|
-
var AssignmentOpSymbol$16 = $T($EXPECT($
|
|
8877
|
+
var AssignmentOpSymbol$5 = $EXPECT($L43, 'AssignmentOpSymbol "+="');
|
|
8878
|
+
var AssignmentOpSymbol$6 = $EXPECT($L44, 'AssignmentOpSymbol "-="');
|
|
8879
|
+
var AssignmentOpSymbol$7 = $EXPECT($L45, 'AssignmentOpSymbol "<<="');
|
|
8880
|
+
var AssignmentOpSymbol$8 = $EXPECT($L46, 'AssignmentOpSymbol ">>>="');
|
|
8881
|
+
var AssignmentOpSymbol$9 = $EXPECT($L47, 'AssignmentOpSymbol ">>="');
|
|
8882
|
+
var AssignmentOpSymbol$10 = $EXPECT($L48, 'AssignmentOpSymbol "&&="');
|
|
8883
|
+
var AssignmentOpSymbol$11 = $EXPECT($L49, 'AssignmentOpSymbol "&="');
|
|
8884
|
+
var AssignmentOpSymbol$12 = $EXPECT($L50, 'AssignmentOpSymbol "^="');
|
|
8885
|
+
var AssignmentOpSymbol$13 = $EXPECT($L51, 'AssignmentOpSymbol "||="');
|
|
8886
|
+
var AssignmentOpSymbol$14 = $EXPECT($L52, 'AssignmentOpSymbol "|="');
|
|
8887
|
+
var AssignmentOpSymbol$15 = $EXPECT($L53, 'AssignmentOpSymbol "??="');
|
|
8888
|
+
var AssignmentOpSymbol$16 = $T($EXPECT($L54, 'AssignmentOpSymbol "?="'), function(value) {
|
|
8723
8889
|
return "??=";
|
|
8724
8890
|
});
|
|
8725
8891
|
var AssignmentOpSymbol$17 = $T($S($EXPECT($L3, 'AssignmentOpSymbol "="'), $N($EXPECT($L3, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -8732,10 +8898,10 @@ ${input.slice(result.pos)}
|
|
|
8732
8898
|
function AssignmentOpSymbol(ctx, state) {
|
|
8733
8899
|
return $EVENT_C(ctx, state, "AssignmentOpSymbol", AssignmentOpSymbol$$);
|
|
8734
8900
|
}
|
|
8735
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
8901
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L55, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
8736
8902
|
return "&&=";
|
|
8737
8903
|
});
|
|
8738
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
8904
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L56, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
8739
8905
|
return "||=";
|
|
8740
8906
|
});
|
|
8741
8907
|
var CoffeeWordAssignmentOp$$ = [CoffeeWordAssignmentOp$0, CoffeeWordAssignmentOp$1];
|
|
@@ -8769,7 +8935,7 @@ ${input.slice(result.pos)}
|
|
|
8769
8935
|
function IdentifierBinaryOp(ctx, state) {
|
|
8770
8936
|
return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
|
|
8771
8937
|
}
|
|
8772
|
-
var BinaryOp$0 = $T($S($EXPECT($
|
|
8938
|
+
var BinaryOp$0 = $T($S($EXPECT($R17, "BinaryOp /(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])/"), _BinaryOp), function(value) {
|
|
8773
8939
|
var op = value[1];
|
|
8774
8940
|
return op;
|
|
8775
8941
|
});
|
|
@@ -8804,33 +8970,33 @@ ${input.slice(result.pos)}
|
|
|
8804
8970
|
function _BinaryOp(ctx, state) {
|
|
8805
8971
|
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
8806
8972
|
}
|
|
8807
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
8808
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
8809
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
8810
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
8973
|
+
var BinaryOpSymbol$0 = $EXPECT($L57, 'BinaryOpSymbol "**"');
|
|
8974
|
+
var BinaryOpSymbol$1 = $EXPECT($L58, 'BinaryOpSymbol "*"');
|
|
8975
|
+
var BinaryOpSymbol$2 = $EXPECT($L59, 'BinaryOpSymbol "/"');
|
|
8976
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L60, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
8811
8977
|
return {
|
|
8812
8978
|
call: module.getRef("modulo"),
|
|
8813
8979
|
special: true
|
|
8814
8980
|
};
|
|
8815
8981
|
});
|
|
8816
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
8982
|
+
var BinaryOpSymbol$4 = $EXPECT($L61, 'BinaryOpSymbol "%"');
|
|
8817
8983
|
var BinaryOpSymbol$5 = $TV($C($EXPECT($L8, 'BinaryOpSymbol "++"'), $EXPECT($L10, 'BinaryOpSymbol "\u29FA"')), function($skip, $loc, $0, $1) {
|
|
8818
8984
|
return {
|
|
8819
8985
|
method: "concat",
|
|
8820
8986
|
special: true
|
|
8821
8987
|
};
|
|
8822
8988
|
});
|
|
8823
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
8824
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
8825
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
8826
|
-
var BinaryOpSymbol$9 = $T($EXPECT($
|
|
8989
|
+
var BinaryOpSymbol$6 = $EXPECT($L62, 'BinaryOpSymbol "+"');
|
|
8990
|
+
var BinaryOpSymbol$7 = $EXPECT($L22, 'BinaryOpSymbol "-"');
|
|
8991
|
+
var BinaryOpSymbol$8 = $EXPECT($L63, 'BinaryOpSymbol "<="');
|
|
8992
|
+
var BinaryOpSymbol$9 = $T($EXPECT($L64, 'BinaryOpSymbol "\u2264"'), function(value) {
|
|
8827
8993
|
return "<=";
|
|
8828
8994
|
});
|
|
8829
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
8830
|
-
var BinaryOpSymbol$11 = $T($EXPECT($
|
|
8995
|
+
var BinaryOpSymbol$10 = $EXPECT($L65, 'BinaryOpSymbol ">="');
|
|
8996
|
+
var BinaryOpSymbol$11 = $T($EXPECT($L66, 'BinaryOpSymbol "\u2265"'), function(value) {
|
|
8831
8997
|
return ">=";
|
|
8832
8998
|
});
|
|
8833
|
-
var BinaryOpSymbol$12 = $TV($EXPECT($
|
|
8999
|
+
var BinaryOpSymbol$12 = $TV($EXPECT($L67, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
8834
9000
|
return {
|
|
8835
9001
|
$loc,
|
|
8836
9002
|
token: "instanceof",
|
|
@@ -8838,7 +9004,7 @@ ${input.slice(result.pos)}
|
|
|
8838
9004
|
special: true
|
|
8839
9005
|
};
|
|
8840
9006
|
});
|
|
8841
|
-
var BinaryOpSymbol$13 = $TV($EXPECT($
|
|
9007
|
+
var BinaryOpSymbol$13 = $TV($EXPECT($L68, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
8842
9008
|
return {
|
|
8843
9009
|
$loc,
|
|
8844
9010
|
token: "instanceof",
|
|
@@ -8847,74 +9013,74 @@ ${input.slice(result.pos)}
|
|
|
8847
9013
|
negated: true
|
|
8848
9014
|
};
|
|
8849
9015
|
});
|
|
8850
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
8851
|
-
var BinaryOpSymbol$15 = $T($EXPECT($
|
|
9016
|
+
var BinaryOpSymbol$14 = $EXPECT($L69, 'BinaryOpSymbol "<<"');
|
|
9017
|
+
var BinaryOpSymbol$15 = $T($EXPECT($L70, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
8852
9018
|
return "<<";
|
|
8853
9019
|
});
|
|
8854
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
8855
|
-
var BinaryOpSymbol$17 = $EXPECT($
|
|
8856
|
-
var BinaryOpSymbol$18 = $T($EXPECT($
|
|
9020
|
+
var BinaryOpSymbol$16 = $EXPECT($L16, 'BinaryOpSymbol "<"');
|
|
9021
|
+
var BinaryOpSymbol$17 = $EXPECT($L71, 'BinaryOpSymbol ">>>"');
|
|
9022
|
+
var BinaryOpSymbol$18 = $T($EXPECT($L72, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8857
9023
|
return ">>>";
|
|
8858
9024
|
});
|
|
8859
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
8860
|
-
var BinaryOpSymbol$20 = $T($EXPECT($
|
|
9025
|
+
var BinaryOpSymbol$19 = $EXPECT($L73, 'BinaryOpSymbol ">>"');
|
|
9026
|
+
var BinaryOpSymbol$20 = $T($EXPECT($L74, 'BinaryOpSymbol "\xBB"'), function(value) {
|
|
8861
9027
|
return ">>";
|
|
8862
9028
|
});
|
|
8863
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
8864
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
8865
|
-
var BinaryOpSymbol$23 = $T($EXPECT($
|
|
9029
|
+
var BinaryOpSymbol$21 = $EXPECT($L37, 'BinaryOpSymbol ">"');
|
|
9030
|
+
var BinaryOpSymbol$22 = $EXPECT($L75, 'BinaryOpSymbol "!=="');
|
|
9031
|
+
var BinaryOpSymbol$23 = $T($EXPECT($L76, 'BinaryOpSymbol "\u2262"'), function(value) {
|
|
8866
9032
|
return "!==";
|
|
8867
9033
|
});
|
|
8868
|
-
var BinaryOpSymbol$24 = $TV($C($EXPECT($
|
|
9034
|
+
var BinaryOpSymbol$24 = $TV($C($EXPECT($L77, 'BinaryOpSymbol "!="'), $EXPECT($L78, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
|
|
8869
9035
|
if (module.config.coffeeEq)
|
|
8870
9036
|
return "!==";
|
|
8871
9037
|
return "!=";
|
|
8872
9038
|
});
|
|
8873
|
-
var BinaryOpSymbol$25 = $TS($S($EXPECT($
|
|
9039
|
+
var BinaryOpSymbol$25 = $TS($S($EXPECT($L79, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8874
9040
|
if (module.config.coffeeIsnt)
|
|
8875
9041
|
return "!==";
|
|
8876
9042
|
return $skip;
|
|
8877
9043
|
});
|
|
8878
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
8879
|
-
var BinaryOpSymbol$27 = $T($C($EXPECT($
|
|
9044
|
+
var BinaryOpSymbol$26 = $EXPECT($L80, 'BinaryOpSymbol "==="');
|
|
9045
|
+
var BinaryOpSymbol$27 = $T($C($EXPECT($L81, 'BinaryOpSymbol "\u2263"'), $EXPECT($L82, 'BinaryOpSymbol "\u2A76"')), function(value) {
|
|
8880
9046
|
return "===";
|
|
8881
9047
|
});
|
|
8882
|
-
var BinaryOpSymbol$28 = $TV($C($EXPECT($
|
|
9048
|
+
var BinaryOpSymbol$28 = $TV($C($EXPECT($L83, 'BinaryOpSymbol "=="'), $EXPECT($L84, 'BinaryOpSymbol "\u2261"'), $EXPECT($L85, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
|
|
8883
9049
|
if (module.config.coffeeEq)
|
|
8884
9050
|
return "===";
|
|
8885
9051
|
return "==";
|
|
8886
9052
|
});
|
|
8887
|
-
var BinaryOpSymbol$29 = $T($S($EXPECT($
|
|
9053
|
+
var BinaryOpSymbol$29 = $T($S($EXPECT($L86, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
8888
9054
|
return "&&";
|
|
8889
9055
|
});
|
|
8890
|
-
var BinaryOpSymbol$30 = $EXPECT($
|
|
8891
|
-
var BinaryOpSymbol$31 = $T($S($EXPECT($
|
|
9056
|
+
var BinaryOpSymbol$30 = $EXPECT($L87, 'BinaryOpSymbol "&&"');
|
|
9057
|
+
var BinaryOpSymbol$31 = $T($S($EXPECT($L88, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8892
9058
|
return "||";
|
|
8893
9059
|
});
|
|
8894
|
-
var BinaryOpSymbol$32 = $EXPECT($
|
|
8895
|
-
var BinaryOpSymbol$33 = $T($EXPECT($
|
|
9060
|
+
var BinaryOpSymbol$32 = $EXPECT($L89, 'BinaryOpSymbol "||"');
|
|
9061
|
+
var BinaryOpSymbol$33 = $T($EXPECT($L90, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8896
9062
|
return "||";
|
|
8897
9063
|
});
|
|
8898
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
9064
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($L91, 'BinaryOpSymbol "^^"'), $S($EXPECT($L92, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8899
9065
|
return {
|
|
8900
9066
|
call: module.getRef("xor"),
|
|
8901
9067
|
special: true
|
|
8902
9068
|
};
|
|
8903
9069
|
});
|
|
8904
|
-
var BinaryOpSymbol$35 = $TV($C($EXPECT($
|
|
9070
|
+
var BinaryOpSymbol$35 = $TV($C($EXPECT($R18, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L93, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8905
9071
|
return {
|
|
8906
9072
|
call: module.getRef("xnor"),
|
|
8907
9073
|
special: true
|
|
8908
9074
|
};
|
|
8909
9075
|
});
|
|
8910
|
-
var BinaryOpSymbol$36 = $EXPECT($
|
|
8911
|
-
var BinaryOpSymbol$37 = $T($EXPECT($
|
|
9076
|
+
var BinaryOpSymbol$36 = $EXPECT($L94, 'BinaryOpSymbol "??"');
|
|
9077
|
+
var BinaryOpSymbol$37 = $T($EXPECT($L95, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8912
9078
|
return "??";
|
|
8913
9079
|
});
|
|
8914
9080
|
var BinaryOpSymbol$38 = $T($S($EXPECT($L6, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8915
9081
|
return "??";
|
|
8916
9082
|
});
|
|
8917
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
9083
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L96, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8918
9084
|
return {
|
|
8919
9085
|
$loc,
|
|
8920
9086
|
token: $1,
|
|
@@ -8931,7 +9097,7 @@ ${input.slice(result.pos)}
|
|
|
8931
9097
|
var op = $3;
|
|
8932
9098
|
return { ...op, $loc };
|
|
8933
9099
|
});
|
|
8934
|
-
var BinaryOpSymbol$42 = $TV($C($S(Is, __, In), $EXPECT($
|
|
9100
|
+
var BinaryOpSymbol$42 = $TV($C($S(Is, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8935
9101
|
return {
|
|
8936
9102
|
method: "includes",
|
|
8937
9103
|
relational: true,
|
|
@@ -8939,14 +9105,14 @@ ${input.slice(result.pos)}
|
|
|
8939
9105
|
special: true
|
|
8940
9106
|
};
|
|
8941
9107
|
});
|
|
8942
|
-
var BinaryOpSymbol$43 = $TV($EXPECT($
|
|
9108
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L98, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8943
9109
|
return {
|
|
8944
9110
|
method: "includes",
|
|
8945
9111
|
relational: true,
|
|
8946
9112
|
special: true
|
|
8947
9113
|
};
|
|
8948
9114
|
});
|
|
8949
|
-
var BinaryOpSymbol$44 = $TV($EXPECT($
|
|
9115
|
+
var BinaryOpSymbol$44 = $TV($EXPECT($L99, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8950
9116
|
return {
|
|
8951
9117
|
method: "includes",
|
|
8952
9118
|
relational: true,
|
|
@@ -8954,7 +9120,7 @@ ${input.slice(result.pos)}
|
|
|
8954
9120
|
negated: true
|
|
8955
9121
|
};
|
|
8956
9122
|
});
|
|
8957
|
-
var BinaryOpSymbol$45 = $TV($C($S(Is, __, OmittedNegation, __, In), $EXPECT($
|
|
9123
|
+
var BinaryOpSymbol$45 = $TV($C($S(Is, __, OmittedNegation, __, In), $EXPECT($L100, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8958
9124
|
return {
|
|
8959
9125
|
method: "includes",
|
|
8960
9126
|
relational: true,
|
|
@@ -8987,9 +9153,9 @@ ${input.slice(result.pos)}
|
|
|
8987
9153
|
return "===";
|
|
8988
9154
|
});
|
|
8989
9155
|
var BinaryOpSymbol$48 = In;
|
|
8990
|
-
var BinaryOpSymbol$49 = $EXPECT($
|
|
8991
|
-
var BinaryOpSymbol$50 = $EXPECT($
|
|
8992
|
-
var BinaryOpSymbol$51 = $EXPECT($
|
|
9156
|
+
var BinaryOpSymbol$49 = $EXPECT($L101, 'BinaryOpSymbol "&"');
|
|
9157
|
+
var BinaryOpSymbol$50 = $EXPECT($L21, 'BinaryOpSymbol "^"');
|
|
9158
|
+
var BinaryOpSymbol$51 = $EXPECT($L102, 'BinaryOpSymbol "|"');
|
|
8993
9159
|
var BinaryOpSymbol$$ = [BinaryOpSymbol$0, BinaryOpSymbol$1, BinaryOpSymbol$2, BinaryOpSymbol$3, BinaryOpSymbol$4, BinaryOpSymbol$5, BinaryOpSymbol$6, BinaryOpSymbol$7, BinaryOpSymbol$8, BinaryOpSymbol$9, BinaryOpSymbol$10, BinaryOpSymbol$11, BinaryOpSymbol$12, BinaryOpSymbol$13, BinaryOpSymbol$14, BinaryOpSymbol$15, BinaryOpSymbol$16, BinaryOpSymbol$17, BinaryOpSymbol$18, BinaryOpSymbol$19, BinaryOpSymbol$20, BinaryOpSymbol$21, BinaryOpSymbol$22, BinaryOpSymbol$23, BinaryOpSymbol$24, BinaryOpSymbol$25, BinaryOpSymbol$26, BinaryOpSymbol$27, BinaryOpSymbol$28, BinaryOpSymbol$29, BinaryOpSymbol$30, BinaryOpSymbol$31, BinaryOpSymbol$32, BinaryOpSymbol$33, BinaryOpSymbol$34, BinaryOpSymbol$35, BinaryOpSymbol$36, BinaryOpSymbol$37, BinaryOpSymbol$38, BinaryOpSymbol$39, BinaryOpSymbol$40, BinaryOpSymbol$41, BinaryOpSymbol$42, BinaryOpSymbol$43, BinaryOpSymbol$44, BinaryOpSymbol$45, BinaryOpSymbol$46, BinaryOpSymbol$47, BinaryOpSymbol$48, BinaryOpSymbol$49, BinaryOpSymbol$50, BinaryOpSymbol$51];
|
|
8994
9160
|
function BinaryOpSymbol(ctx, state) {
|
|
8995
9161
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
@@ -9027,7 +9193,7 @@ ${input.slice(result.pos)}
|
|
|
9027
9193
|
function CoffeeOfOp(ctx, state) {
|
|
9028
9194
|
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
9029
9195
|
}
|
|
9030
|
-
var NotOp$0 = $TS($S($EXPECT($
|
|
9196
|
+
var NotOp$0 = $TS($S($EXPECT($L96, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9031
9197
|
return {
|
|
9032
9198
|
$loc,
|
|
9033
9199
|
token: "instanceof",
|
|
@@ -9048,24 +9214,24 @@ ${input.slice(result.pos)}
|
|
|
9048
9214
|
function NotOp(ctx, state) {
|
|
9049
9215
|
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
9050
9216
|
}
|
|
9051
|
-
var Xor$0 = $EXPECT($
|
|
9052
|
-
var Xor$1 = $S($EXPECT($
|
|
9217
|
+
var Xor$0 = $EXPECT($L91, 'Xor "^^"');
|
|
9218
|
+
var Xor$1 = $S($EXPECT($L92, 'Xor "xor"'), NonIdContinue);
|
|
9053
9219
|
var Xor$$ = [Xor$0, Xor$1];
|
|
9054
9220
|
function Xor(ctx, state) {
|
|
9055
9221
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
9056
9222
|
}
|
|
9057
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
9058
|
-
var Xnor$1 = $EXPECT($
|
|
9223
|
+
var Xnor$0 = $R$0($EXPECT($R18, "Xnor /!\\^\\^?/"));
|
|
9224
|
+
var Xnor$1 = $EXPECT($L93, 'Xnor "xnor"');
|
|
9059
9225
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
9060
9226
|
function Xnor(ctx, state) {
|
|
9061
9227
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
9062
9228
|
}
|
|
9063
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
9229
|
+
var UnaryOp$0 = $TR($EXPECT($R19, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9064
9230
|
return { $loc, token: $0 };
|
|
9065
9231
|
});
|
|
9066
9232
|
var UnaryOp$1 = AwaitOp;
|
|
9067
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($
|
|
9068
|
-
var UnaryOp$3 = $T($S(Not, $N($EXPECT($
|
|
9233
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($R20, "UnaryOp /[:.]/"))), $E(_));
|
|
9234
|
+
var UnaryOp$3 = $T($S(Not, $N($EXPECT($R20, "UnaryOp /[:.]/")), $E($EXPECT($L15, 'UnaryOp " "')), $E(_)), function(value) {
|
|
9069
9235
|
return [value[0], value[3]];
|
|
9070
9236
|
});
|
|
9071
9237
|
var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
|
|
@@ -9160,7 +9326,7 @@ ${input.slice(result.pos)}
|
|
|
9160
9326
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
9161
9327
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
9162
9328
|
}
|
|
9163
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
9329
|
+
var PostfixStatement$0 = $T($S($EXPECT($R21, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
9164
9330
|
return value[1];
|
|
9165
9331
|
});
|
|
9166
9332
|
function PostfixStatement(ctx, state) {
|
|
@@ -9203,7 +9369,7 @@ ${input.slice(result.pos)}
|
|
|
9203
9369
|
function NoCommaStatement(ctx, state) {
|
|
9204
9370
|
return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
|
|
9205
9371
|
}
|
|
9206
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
9372
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L103, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
9207
9373
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
9208
9374
|
});
|
|
9209
9375
|
function EmptyStatement(ctx, state) {
|
|
@@ -9234,7 +9400,7 @@ ${input.slice(result.pos)}
|
|
|
9234
9400
|
var w = $3;
|
|
9235
9401
|
return [id, colon, w];
|
|
9236
9402
|
});
|
|
9237
|
-
var Label$1 = $S($EXPECT($
|
|
9403
|
+
var Label$1 = $S($EXPECT($L104, 'Label "$:"'), Whitespace);
|
|
9238
9404
|
var Label$$ = [Label$0, Label$1];
|
|
9239
9405
|
function Label(ctx, state) {
|
|
9240
9406
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -9407,7 +9573,7 @@ ${input.slice(result.pos)}
|
|
|
9407
9573
|
function BlockExpressionPart(ctx, state) {
|
|
9408
9574
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
9409
9575
|
}
|
|
9410
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
9576
|
+
var IterationStatement$0 = $T($S($EXPECT($R22, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
9411
9577
|
return value[1];
|
|
9412
9578
|
});
|
|
9413
9579
|
function IterationStatement(ctx, state) {
|
|
@@ -9760,7 +9926,7 @@ ${input.slice(result.pos)}
|
|
|
9760
9926
|
names: binding.names
|
|
9761
9927
|
};
|
|
9762
9928
|
});
|
|
9763
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9929
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R23, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9764
9930
|
var c = $1;
|
|
9765
9931
|
var binding = $2;
|
|
9766
9932
|
return {
|
|
@@ -9986,7 +10152,7 @@ ${input.slice(result.pos)}
|
|
|
9986
10152
|
function IgnoreColon(ctx, state) {
|
|
9987
10153
|
return $EVENT(ctx, state, "IgnoreColon", IgnoreColon$0);
|
|
9988
10154
|
}
|
|
9989
|
-
var TryStatement$0 = $TS($S(Try, $N($EXPECT($
|
|
10155
|
+
var TryStatement$0 = $TS($S(Try, $N($EXPECT($L14, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9990
10156
|
var t = $1;
|
|
9991
10157
|
var b = $3;
|
|
9992
10158
|
var c = $4;
|
|
@@ -10322,7 +10488,7 @@ ${input.slice(result.pos)}
|
|
|
10322
10488
|
};
|
|
10323
10489
|
});
|
|
10324
10490
|
var KeywordStatement$2 = DebuggerStatement;
|
|
10325
|
-
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($
|
|
10491
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L14, 'KeywordStatement ":"'), $EXPECT($L7, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10326
10492
|
var expression = value[2];
|
|
10327
10493
|
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10328
10494
|
});
|
|
@@ -10343,19 +10509,19 @@ ${input.slice(result.pos)}
|
|
|
10343
10509
|
function ThrowStatement(ctx, state) {
|
|
10344
10510
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
10345
10511
|
}
|
|
10346
|
-
var Break$0 = $TS($S($EXPECT($
|
|
10512
|
+
var Break$0 = $TS($S($EXPECT($L105, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10347
10513
|
return { $loc, token: $1 };
|
|
10348
10514
|
});
|
|
10349
10515
|
function Break(ctx, state) {
|
|
10350
10516
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
10351
10517
|
}
|
|
10352
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
10518
|
+
var Continue$0 = $TS($S($EXPECT($L106, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10353
10519
|
return { $loc, token: $1 };
|
|
10354
10520
|
});
|
|
10355
10521
|
function Continue(ctx, state) {
|
|
10356
10522
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
10357
10523
|
}
|
|
10358
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
10524
|
+
var Debugger$0 = $TS($S($EXPECT($L107, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10359
10525
|
return { $loc, token: $1 };
|
|
10360
10526
|
});
|
|
10361
10527
|
function Debugger(ctx, state) {
|
|
@@ -10476,7 +10642,7 @@ ${input.slice(result.pos)}
|
|
|
10476
10642
|
function FromClause(ctx, state) {
|
|
10477
10643
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
10478
10644
|
}
|
|
10479
|
-
var ImportAssertion$0 = $S($E(_), $C($EXPECT($
|
|
10645
|
+
var ImportAssertion$0 = $S($E(_), $C($EXPECT($L108, 'ImportAssertion "with"'), $EXPECT($L109, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral);
|
|
10480
10646
|
function ImportAssertion(ctx, state) {
|
|
10481
10647
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
10482
10648
|
}
|
|
@@ -10524,7 +10690,7 @@ ${input.slice(result.pos)}
|
|
|
10524
10690
|
return $EVENT_C(ctx, state, "ImportSpecifier", ImportSpecifier$$);
|
|
10525
10691
|
}
|
|
10526
10692
|
var ImportAsToken$0 = $S(__, As);
|
|
10527
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
10693
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L15, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10528
10694
|
var l = $1;
|
|
10529
10695
|
var ws = $2;
|
|
10530
10696
|
var c = $3;
|
|
@@ -10564,7 +10730,7 @@ ${input.slice(result.pos)}
|
|
|
10564
10730
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
10565
10731
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
10566
10732
|
}
|
|
10567
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10733
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R24, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10568
10734
|
var spec = $0;
|
|
10569
10735
|
return { $loc, token: `"${spec}"` };
|
|
10570
10736
|
});
|
|
@@ -10696,13 +10862,13 @@ ${input.slice(result.pos)}
|
|
|
10696
10862
|
function LexicalDeclaration(ctx, state) {
|
|
10697
10863
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10698
10864
|
}
|
|
10699
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10865
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L110, 'ConstAssignment ":="'), $EXPECT($L111, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10700
10866
|
return { $loc, token: "=" };
|
|
10701
10867
|
});
|
|
10702
10868
|
function ConstAssignment(ctx, state) {
|
|
10703
10869
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10704
10870
|
}
|
|
10705
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10871
|
+
var LetAssignment$0 = $TV($EXPECT($L112, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10706
10872
|
return { $loc, token: "=" };
|
|
10707
10873
|
});
|
|
10708
10874
|
function LetAssignment(ctx, state) {
|
|
@@ -10770,7 +10936,7 @@ ${input.slice(result.pos)}
|
|
|
10770
10936
|
function VariableDeclarationList(ctx, state) {
|
|
10771
10937
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
10772
10938
|
}
|
|
10773
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
10939
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R25, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10774
10940
|
var token = $2;
|
|
10775
10941
|
return { type: "NumericLiteral", $loc, token };
|
|
10776
10942
|
});
|
|
@@ -10786,36 +10952,36 @@ ${input.slice(result.pos)}
|
|
|
10786
10952
|
function NumericLiteralKind(ctx, state) {
|
|
10787
10953
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
10788
10954
|
}
|
|
10789
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
10955
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R26, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
10790
10956
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
10791
10957
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
10792
10958
|
}
|
|
10793
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
10959
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R27, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
10794
10960
|
return $1 + ".";
|
|
10795
10961
|
});
|
|
10796
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
10797
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
10962
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R28, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
10963
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R29, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
10798
10964
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
10799
10965
|
function DecimalLiteral(ctx, state) {
|
|
10800
10966
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
10801
10967
|
}
|
|
10802
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
10968
|
+
var ExponentPart$0 = $R$0($EXPECT($R30, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
10803
10969
|
function ExponentPart(ctx, state) {
|
|
10804
10970
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
10805
10971
|
}
|
|
10806
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
10972
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R31, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
10807
10973
|
function BinaryIntegerLiteral(ctx, state) {
|
|
10808
10974
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
10809
10975
|
}
|
|
10810
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10976
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R32, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
10811
10977
|
function OctalIntegerLiteral(ctx, state) {
|
|
10812
10978
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
10813
10979
|
}
|
|
10814
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
10980
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R33, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
10815
10981
|
function HexIntegerLiteral(ctx, state) {
|
|
10816
10982
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
10817
10983
|
}
|
|
10818
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
10984
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R34, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10819
10985
|
var token = $2;
|
|
10820
10986
|
return { $loc, token };
|
|
10821
10987
|
});
|
|
@@ -10831,7 +10997,7 @@ ${input.slice(result.pos)}
|
|
|
10831
10997
|
function IntegerLiteralKind(ctx, state) {
|
|
10832
10998
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
10833
10999
|
}
|
|
10834
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11000
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R35, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
10835
11001
|
function DecimalIntegerLiteral(ctx, state) {
|
|
10836
11002
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
10837
11003
|
}
|
|
@@ -10855,25 +11021,25 @@ ${input.slice(result.pos)}
|
|
|
10855
11021
|
function StringLiteral(ctx, state) {
|
|
10856
11022
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
10857
11023
|
}
|
|
10858
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11024
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R36, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10859
11025
|
return { $loc, token: $0 };
|
|
10860
11026
|
});
|
|
10861
11027
|
function DoubleStringCharacters(ctx, state) {
|
|
10862
11028
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
10863
11029
|
}
|
|
10864
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11030
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R37, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10865
11031
|
return { $loc, token: $0 };
|
|
10866
11032
|
});
|
|
10867
11033
|
function SingleStringCharacters(ctx, state) {
|
|
10868
11034
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
10869
11035
|
}
|
|
10870
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11036
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R38, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10871
11037
|
return { $loc, token: $0 };
|
|
10872
11038
|
});
|
|
10873
11039
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
10874
11040
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
10875
11041
|
}
|
|
10876
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11042
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R39, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10877
11043
|
return { $loc, token: $0 };
|
|
10878
11044
|
});
|
|
10879
11045
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -10892,14 +11058,14 @@ ${input.slice(result.pos)}
|
|
|
10892
11058
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
10893
11059
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
10894
11060
|
}
|
|
10895
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11061
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R40, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10896
11062
|
return { $loc, token: $0 };
|
|
10897
11063
|
});
|
|
10898
11064
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
10899
11065
|
return $EVENT(ctx, state, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
|
|
10900
11066
|
}
|
|
10901
11067
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
10902
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
11068
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L59, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L59, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
10903
11069
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
10904
11070
|
});
|
|
10905
11071
|
var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
|
|
@@ -10912,7 +11078,7 @@ ${input.slice(result.pos)}
|
|
|
10912
11078
|
function RegularExpressionClass(ctx, state) {
|
|
10913
11079
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
10914
11080
|
}
|
|
10915
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11081
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R41, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10916
11082
|
return { $loc, token: $0 };
|
|
10917
11083
|
});
|
|
10918
11084
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -10966,7 +11132,7 @@ ${input.slice(result.pos)}
|
|
|
10966
11132
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
10967
11133
|
return { "type": "Substitution", "children": value[0] };
|
|
10968
11134
|
});
|
|
10969
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11135
|
+
var HeregexPart$3 = $TR($EXPECT($R42, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10970
11136
|
let token = $0;
|
|
10971
11137
|
switch ($0[1]) {
|
|
10972
11138
|
case "\n":
|
|
@@ -10984,13 +11150,13 @@ ${input.slice(result.pos)}
|
|
|
10984
11150
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10985
11151
|
return { $loc, token: "" };
|
|
10986
11152
|
});
|
|
10987
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11153
|
+
var HeregexPart$5 = $TR($EXPECT($R43, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10988
11154
|
return { $loc, token: "" };
|
|
10989
11155
|
});
|
|
10990
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11156
|
+
var HeregexPart$6 = $TR($EXPECT($R44, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10991
11157
|
return { $loc, token: "\\/" };
|
|
10992
11158
|
});
|
|
10993
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11159
|
+
var HeregexPart$7 = $TR($EXPECT($R45, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10994
11160
|
return { $loc, token: $0 };
|
|
10995
11161
|
});
|
|
10996
11162
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -11003,7 +11169,7 @@ ${input.slice(result.pos)}
|
|
|
11003
11169
|
function HeregexComment(ctx, state) {
|
|
11004
11170
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
11005
11171
|
}
|
|
11006
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11172
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R46, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11007
11173
|
function RegularExpressionBody(ctx, state) {
|
|
11008
11174
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
11009
11175
|
}
|
|
@@ -11013,15 +11179,15 @@ ${input.slice(result.pos)}
|
|
|
11013
11179
|
function RegExpPart(ctx, state) {
|
|
11014
11180
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
11015
11181
|
}
|
|
11016
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
11182
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R47, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11017
11183
|
function RegExpCharacter(ctx, state) {
|
|
11018
11184
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
11019
11185
|
}
|
|
11020
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11186
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R48, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11021
11187
|
function RegularExpressionFlags(ctx, state) {
|
|
11022
11188
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
11023
11189
|
}
|
|
11024
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
11190
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R49, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
11025
11191
|
return value[1];
|
|
11026
11192
|
});
|
|
11027
11193
|
function TemplateLiteral(ctx, state) {
|
|
@@ -11057,28 +11223,28 @@ ${input.slice(result.pos)}
|
|
|
11057
11223
|
function TemplateSubstitution(ctx, state) {
|
|
11058
11224
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
11059
11225
|
}
|
|
11060
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11226
|
+
var TemplateCharacters$0 = $TR($EXPECT($R50, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11061
11227
|
return { $loc, token: $0 };
|
|
11062
11228
|
});
|
|
11063
11229
|
function TemplateCharacters(ctx, state) {
|
|
11064
11230
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
11065
11231
|
}
|
|
11066
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
11232
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R51, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11067
11233
|
return { $loc, token: $0 };
|
|
11068
11234
|
});
|
|
11069
11235
|
function TemplateBlockCharacters(ctx, state) {
|
|
11070
11236
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
11071
11237
|
}
|
|
11072
|
-
var ReservedWord$0 = $S($R$0($EXPECT($
|
|
11073
|
-
var ReservedWord$1 = $S($R$0($EXPECT($
|
|
11074
|
-
var ReservedWord$2 = $S($R$0($EXPECT($
|
|
11075
|
-
var ReservedWord$3 = $S($R$0($EXPECT($
|
|
11076
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
11238
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R52, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
11239
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R53, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
11240
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R54, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
11241
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R55, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
11242
|
+
var ReservedWord$4 = $R$0($EXPECT($R56, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
11077
11243
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
11078
11244
|
function ReservedWord(ctx, state) {
|
|
11079
11245
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
11080
11246
|
}
|
|
11081
|
-
var Comment$0 = $T($S($EXPECT($
|
|
11247
|
+
var Comment$0 = $T($S($EXPECT($R57, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
11082
11248
|
return value[1];
|
|
11083
11249
|
});
|
|
11084
11250
|
function Comment(ctx, state) {
|
|
@@ -11096,7 +11262,7 @@ ${input.slice(result.pos)}
|
|
|
11096
11262
|
function SingleLineComment(ctx, state) {
|
|
11097
11263
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
11098
11264
|
}
|
|
11099
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
11265
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R58, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11100
11266
|
return { type: "Comment", $loc, token: $0 };
|
|
11101
11267
|
});
|
|
11102
11268
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -11108,30 +11274,30 @@ ${input.slice(result.pos)}
|
|
|
11108
11274
|
function MultiLineComment(ctx, state) {
|
|
11109
11275
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
11110
11276
|
}
|
|
11111
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
11277
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L113, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L114, 'JSMultiLineComment "*/"')), $EXPECT($R59, "JSMultiLineComment /./"))), $EXPECT($L114, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
11112
11278
|
return { type: "Comment", $loc, token: $1 };
|
|
11113
11279
|
});
|
|
11114
11280
|
function JSMultiLineComment(ctx, state) {
|
|
11115
11281
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
11116
11282
|
}
|
|
11117
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
11283
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R60, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11118
11284
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
11119
11285
|
});
|
|
11120
11286
|
function CoffeeSingleLineComment(ctx, state) {
|
|
11121
11287
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
11122
11288
|
}
|
|
11123
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
11289
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R61, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
11124
11290
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
11125
11291
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
11126
11292
|
});
|
|
11127
11293
|
function CoffeeMultiLineComment(ctx, state) {
|
|
11128
11294
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
11129
11295
|
}
|
|
11130
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
11296
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R62, "CoffeeHereCommentStart /###(?!#)/"));
|
|
11131
11297
|
function CoffeeHereCommentStart(ctx, state) {
|
|
11132
11298
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
11133
11299
|
}
|
|
11134
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
11300
|
+
var InlineComment$0 = $TR($EXPECT($R63, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11135
11301
|
return { $loc, token: $0 };
|
|
11136
11302
|
});
|
|
11137
11303
|
function InlineComment(ctx, state) {
|
|
@@ -11145,16 +11311,16 @@ ${input.slice(result.pos)}
|
|
|
11145
11311
|
function TrailingComment(ctx, state) {
|
|
11146
11312
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
11147
11313
|
}
|
|
11148
|
-
var _$0 = $T($S($EXPECT($
|
|
11314
|
+
var _$0 = $T($S($EXPECT($R64, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
11149
11315
|
return value[1];
|
|
11150
11316
|
});
|
|
11151
11317
|
function _(ctx, state) {
|
|
11152
11318
|
return $EVENT(ctx, state, "_", _$0);
|
|
11153
11319
|
}
|
|
11154
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
11320
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R65, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11155
11321
|
return { $loc, token: $0 };
|
|
11156
11322
|
});
|
|
11157
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
11323
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L115, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
11158
11324
|
return " ";
|
|
11159
11325
|
});
|
|
11160
11326
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -11168,7 +11334,7 @@ ${input.slice(result.pos)}
|
|
|
11168
11334
|
function Trimmed_(ctx, state) {
|
|
11169
11335
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
11170
11336
|
}
|
|
11171
|
-
var __$0 = $T($S($EXPECT($
|
|
11337
|
+
var __$0 = $T($S($EXPECT($R66, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
11172
11338
|
return value[1];
|
|
11173
11339
|
});
|
|
11174
11340
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -11176,7 +11342,7 @@ ${input.slice(result.pos)}
|
|
|
11176
11342
|
function __(ctx, state) {
|
|
11177
11343
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
11178
11344
|
}
|
|
11179
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
11345
|
+
var Whitespace$0 = $TR($EXPECT($R43, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11180
11346
|
return { $loc, token: $0 };
|
|
11181
11347
|
});
|
|
11182
11348
|
function Whitespace(ctx, state) {
|
|
@@ -11200,7 +11366,7 @@ ${input.slice(result.pos)}
|
|
|
11200
11366
|
}
|
|
11201
11367
|
var StatementDelimiter$0 = $Y(EOS);
|
|
11202
11368
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
11203
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($
|
|
11369
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L29, 'StatementDelimiter "}"'), $EXPECT($L116, 'StatementDelimiter ")"'), $EXPECT($L38, 'StatementDelimiter "]"'))));
|
|
11204
11370
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
11205
11371
|
function StatementDelimiter(ctx, state) {
|
|
11206
11372
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -11214,7 +11380,7 @@ ${input.slice(result.pos)}
|
|
|
11214
11380
|
function SemicolonDelimiter(ctx, state) {
|
|
11215
11381
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
11216
11382
|
}
|
|
11217
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
11383
|
+
var NonIdContinue$0 = $R$0($EXPECT($R67, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
11218
11384
|
function NonIdContinue(ctx, state) {
|
|
11219
11385
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
11220
11386
|
}
|
|
@@ -11224,151 +11390,151 @@ ${input.slice(result.pos)}
|
|
|
11224
11390
|
function Loc(ctx, state) {
|
|
11225
11391
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
11226
11392
|
}
|
|
11227
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
11393
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L117, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L15, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
11228
11394
|
return { $loc, token: $1, ts: true };
|
|
11229
11395
|
});
|
|
11230
11396
|
function Abstract(ctx, state) {
|
|
11231
11397
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
11232
11398
|
}
|
|
11233
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
11399
|
+
var Ampersand$0 = $TV($EXPECT($L101, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
11234
11400
|
return { $loc, token: $1 };
|
|
11235
11401
|
});
|
|
11236
11402
|
function Ampersand(ctx, state) {
|
|
11237
11403
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
11238
11404
|
}
|
|
11239
|
-
var As$0 = $TS($S($EXPECT($
|
|
11405
|
+
var As$0 = $TS($S($EXPECT($L118, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11240
11406
|
return { $loc, token: $1 };
|
|
11241
11407
|
});
|
|
11242
11408
|
function As(ctx, state) {
|
|
11243
11409
|
return $EVENT(ctx, state, "As", As$0);
|
|
11244
11410
|
}
|
|
11245
|
-
var At$0 = $TV($EXPECT($
|
|
11411
|
+
var At$0 = $TV($EXPECT($L119, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
11246
11412
|
return { $loc, token: $1 };
|
|
11247
11413
|
});
|
|
11248
11414
|
function At(ctx, state) {
|
|
11249
11415
|
return $EVENT(ctx, state, "At", At$0);
|
|
11250
11416
|
}
|
|
11251
|
-
var AtAt$0 = $TV($EXPECT($
|
|
11417
|
+
var AtAt$0 = $TV($EXPECT($L120, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
11252
11418
|
return { $loc, token: "@" };
|
|
11253
11419
|
});
|
|
11254
11420
|
function AtAt(ctx, state) {
|
|
11255
11421
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
11256
11422
|
}
|
|
11257
|
-
var Async$0 = $TS($S($EXPECT($
|
|
11423
|
+
var Async$0 = $TS($S($EXPECT($L121, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11258
11424
|
return { $loc, token: $1, type: "Async" };
|
|
11259
11425
|
});
|
|
11260
11426
|
function Async(ctx, state) {
|
|
11261
11427
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
11262
11428
|
}
|
|
11263
|
-
var Await$0 = $TS($S($EXPECT($
|
|
11429
|
+
var Await$0 = $TS($S($EXPECT($L122, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11264
11430
|
return { $loc, token: $1, type: "Await" };
|
|
11265
11431
|
});
|
|
11266
11432
|
function Await(ctx, state) {
|
|
11267
11433
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
11268
11434
|
}
|
|
11269
|
-
var Backtick$0 = $TV($EXPECT($
|
|
11435
|
+
var Backtick$0 = $TV($EXPECT($L123, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
11270
11436
|
return { $loc, token: $1 };
|
|
11271
11437
|
});
|
|
11272
11438
|
function Backtick(ctx, state) {
|
|
11273
11439
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
11274
11440
|
}
|
|
11275
|
-
var By$0 = $TS($S($EXPECT($
|
|
11441
|
+
var By$0 = $TS($S($EXPECT($L124, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11276
11442
|
return { $loc, token: $1 };
|
|
11277
11443
|
});
|
|
11278
11444
|
function By(ctx, state) {
|
|
11279
11445
|
return $EVENT(ctx, state, "By", By$0);
|
|
11280
11446
|
}
|
|
11281
|
-
var Caret$0 = $TV($EXPECT($
|
|
11447
|
+
var Caret$0 = $TV($EXPECT($L21, 'Caret "^"'), function($skip, $loc, $0, $1) {
|
|
11282
11448
|
return { $loc, token: $1 };
|
|
11283
11449
|
});
|
|
11284
11450
|
function Caret(ctx, state) {
|
|
11285
11451
|
return $EVENT(ctx, state, "Caret", Caret$0);
|
|
11286
11452
|
}
|
|
11287
|
-
var Case$0 = $TS($S($EXPECT($
|
|
11453
|
+
var Case$0 = $TS($S($EXPECT($L125, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11288
11454
|
return { $loc, token: $1 };
|
|
11289
11455
|
});
|
|
11290
11456
|
function Case(ctx, state) {
|
|
11291
11457
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
11292
11458
|
}
|
|
11293
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
11459
|
+
var Catch$0 = $TS($S($EXPECT($L126, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11294
11460
|
return { $loc, token: $1 };
|
|
11295
11461
|
});
|
|
11296
11462
|
function Catch(ctx, state) {
|
|
11297
11463
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
11298
11464
|
}
|
|
11299
|
-
var Class$0 = $TS($S($EXPECT($
|
|
11465
|
+
var Class$0 = $TS($S($EXPECT($L127, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11300
11466
|
return { $loc, token: $1 };
|
|
11301
11467
|
});
|
|
11302
11468
|
function Class(ctx, state) {
|
|
11303
11469
|
return $EVENT(ctx, state, "Class", Class$0);
|
|
11304
11470
|
}
|
|
11305
|
-
var CloseAngleBracket$0 = $TV($EXPECT($
|
|
11471
|
+
var CloseAngleBracket$0 = $TV($EXPECT($L37, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
|
|
11306
11472
|
return { $loc, token: $1 };
|
|
11307
11473
|
});
|
|
11308
11474
|
function CloseAngleBracket(ctx, state) {
|
|
11309
11475
|
return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
|
|
11310
11476
|
}
|
|
11311
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
11477
|
+
var CloseBrace$0 = $TV($EXPECT($L29, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
11312
11478
|
return { $loc, token: $1 };
|
|
11313
11479
|
});
|
|
11314
11480
|
function CloseBrace(ctx, state) {
|
|
11315
11481
|
return $EVENT(ctx, state, "CloseBrace", CloseBrace$0);
|
|
11316
11482
|
}
|
|
11317
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
11483
|
+
var CloseBracket$0 = $TV($EXPECT($L38, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
11318
11484
|
return { $loc, token: $1 };
|
|
11319
11485
|
});
|
|
11320
11486
|
function CloseBracket(ctx, state) {
|
|
11321
11487
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
11322
11488
|
}
|
|
11323
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
11489
|
+
var CloseParen$0 = $TV($EXPECT($L116, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
11324
11490
|
return { $loc, token: $1 };
|
|
11325
11491
|
});
|
|
11326
11492
|
function CloseParen(ctx, state) {
|
|
11327
11493
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
11328
11494
|
}
|
|
11329
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
11495
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L128, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
11330
11496
|
return { $loc, token: "${" };
|
|
11331
11497
|
});
|
|
11332
11498
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
11333
11499
|
return $EVENT(ctx, state, "CoffeeSubstitutionStart", CoffeeSubstitutionStart$0);
|
|
11334
11500
|
}
|
|
11335
|
-
var Colon$0 = $TS($S($EXPECT($
|
|
11501
|
+
var Colon$0 = $TS($S($EXPECT($L14, 'Colon ":"'), $N($EXPECT($L3, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
|
|
11336
11502
|
return { $loc, token: $1 };
|
|
11337
11503
|
});
|
|
11338
11504
|
function Colon(ctx, state) {
|
|
11339
11505
|
return $EVENT(ctx, state, "Colon", Colon$0);
|
|
11340
11506
|
}
|
|
11341
|
-
var Comma$0 = $TV($EXPECT($
|
|
11507
|
+
var Comma$0 = $TV($EXPECT($L25, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
11342
11508
|
return { $loc, token: $1 };
|
|
11343
11509
|
});
|
|
11344
11510
|
function Comma(ctx, state) {
|
|
11345
11511
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
11346
11512
|
}
|
|
11347
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
11513
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L119, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
11348
11514
|
return { $loc, token: "constructor" };
|
|
11349
11515
|
});
|
|
11350
11516
|
function ConstructorShorthand(ctx, state) {
|
|
11351
11517
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
11352
11518
|
}
|
|
11353
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
11519
|
+
var Declare$0 = $TS($S($EXPECT($L129, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11354
11520
|
return { $loc, token: $1 };
|
|
11355
11521
|
});
|
|
11356
11522
|
function Declare(ctx, state) {
|
|
11357
11523
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
11358
11524
|
}
|
|
11359
|
-
var Default$0 = $TS($S($EXPECT($
|
|
11525
|
+
var Default$0 = $TS($S($EXPECT($L130, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11360
11526
|
return { $loc, token: $1 };
|
|
11361
11527
|
});
|
|
11362
11528
|
function Default(ctx, state) {
|
|
11363
11529
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
11364
11530
|
}
|
|
11365
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
11531
|
+
var Delete$0 = $TS($S($EXPECT($L131, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11366
11532
|
return { $loc, token: $1 };
|
|
11367
11533
|
});
|
|
11368
11534
|
function Delete(ctx, state) {
|
|
11369
11535
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
11370
11536
|
}
|
|
11371
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11537
|
+
var Do$0 = $TS($S($EXPECT($L132, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11372
11538
|
return { $loc, token: $1 };
|
|
11373
11539
|
});
|
|
11374
11540
|
function Do(ctx, state) {
|
|
@@ -11377,7 +11543,7 @@ ${input.slice(result.pos)}
|
|
|
11377
11543
|
var Dot$0 = $TV($EXPECT($L7, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
11378
11544
|
return { $loc, token: $1 };
|
|
11379
11545
|
});
|
|
11380
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
11546
|
+
var Dot$1 = $TS($S($EXPECT($R68, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
11381
11547
|
var ws = $2;
|
|
11382
11548
|
return [
|
|
11383
11549
|
{ $loc, token: "." },
|
|
@@ -11388,45 +11554,45 @@ ${input.slice(result.pos)}
|
|
|
11388
11554
|
function Dot(ctx, state) {
|
|
11389
11555
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
11390
11556
|
}
|
|
11391
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
11557
|
+
var DotDot$0 = $TS($S($EXPECT($L133, 'DotDot ".."'), $N($EXPECT($L7, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
11392
11558
|
return { $loc, token: $1 };
|
|
11393
11559
|
});
|
|
11394
|
-
var DotDot$1 = $TV($EXPECT($
|
|
11560
|
+
var DotDot$1 = $TV($EXPECT($L134, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
11395
11561
|
return { $loc, token: ".." };
|
|
11396
11562
|
});
|
|
11397
11563
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
11398
11564
|
function DotDot(ctx, state) {
|
|
11399
11565
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
11400
11566
|
}
|
|
11401
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11567
|
+
var DotDotDot$0 = $TV($EXPECT($L135, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
11402
11568
|
return { $loc, token: $1 };
|
|
11403
11569
|
});
|
|
11404
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
11570
|
+
var DotDotDot$1 = $TV($EXPECT($L136, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
11405
11571
|
return { $loc, token: "..." };
|
|
11406
11572
|
});
|
|
11407
11573
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
11408
11574
|
function DotDotDot(ctx, state) {
|
|
11409
11575
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
11410
11576
|
}
|
|
11411
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11577
|
+
var DoubleColon$0 = $TV($EXPECT($L137, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
11412
11578
|
return { $loc, token: $1 };
|
|
11413
11579
|
});
|
|
11414
11580
|
function DoubleColon(ctx, state) {
|
|
11415
11581
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
11416
11582
|
}
|
|
11417
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11583
|
+
var DoubleQuote$0 = $TV($EXPECT($L138, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11418
11584
|
return { $loc, token: $1 };
|
|
11419
11585
|
});
|
|
11420
11586
|
function DoubleQuote(ctx, state) {
|
|
11421
11587
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
11422
11588
|
}
|
|
11423
|
-
var Each$0 = $TS($S($EXPECT($
|
|
11589
|
+
var Each$0 = $TS($S($EXPECT($L139, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11424
11590
|
return { $loc, token: $1 };
|
|
11425
11591
|
});
|
|
11426
11592
|
function Each(ctx, state) {
|
|
11427
11593
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
11428
11594
|
}
|
|
11429
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11595
|
+
var Else$0 = $TS($S($EXPECT($L140, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11430
11596
|
return { $loc, token: $1 };
|
|
11431
11597
|
});
|
|
11432
11598
|
function Else(ctx, state) {
|
|
@@ -11438,91 +11604,91 @@ ${input.slice(result.pos)}
|
|
|
11438
11604
|
function Equals(ctx, state) {
|
|
11439
11605
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
11440
11606
|
}
|
|
11441
|
-
var ExclamationPoint$0 = $TV($EXPECT($
|
|
11607
|
+
var ExclamationPoint$0 = $TV($EXPECT($L20, 'ExclamationPoint "!"'), function($skip, $loc, $0, $1) {
|
|
11442
11608
|
return { $loc, token: $1 };
|
|
11443
11609
|
});
|
|
11444
11610
|
function ExclamationPoint(ctx, state) {
|
|
11445
11611
|
return $EVENT(ctx, state, "ExclamationPoint", ExclamationPoint$0);
|
|
11446
11612
|
}
|
|
11447
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11613
|
+
var Export$0 = $TS($S($EXPECT($L141, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11448
11614
|
return { $loc, token: $1 };
|
|
11449
11615
|
});
|
|
11450
11616
|
function Export(ctx, state) {
|
|
11451
11617
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
11452
11618
|
}
|
|
11453
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11619
|
+
var Extends$0 = $TS($S($EXPECT($L142, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11454
11620
|
return { $loc, token: $1 };
|
|
11455
11621
|
});
|
|
11456
11622
|
function Extends(ctx, state) {
|
|
11457
11623
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
11458
11624
|
}
|
|
11459
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
11625
|
+
var Finally$0 = $TS($S($EXPECT($L143, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11460
11626
|
return { $loc, token: $1 };
|
|
11461
11627
|
});
|
|
11462
11628
|
function Finally(ctx, state) {
|
|
11463
11629
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
11464
11630
|
}
|
|
11465
|
-
var For$0 = $TS($S($EXPECT($
|
|
11631
|
+
var For$0 = $TS($S($EXPECT($L144, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11466
11632
|
return { $loc, token: $1 };
|
|
11467
11633
|
});
|
|
11468
11634
|
function For(ctx, state) {
|
|
11469
11635
|
return $EVENT(ctx, state, "For", For$0);
|
|
11470
11636
|
}
|
|
11471
|
-
var From$0 = $TS($S($EXPECT($
|
|
11637
|
+
var From$0 = $TS($S($EXPECT($L145, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11472
11638
|
return { $loc, token: $1 };
|
|
11473
11639
|
});
|
|
11474
11640
|
function From(ctx, state) {
|
|
11475
11641
|
return $EVENT(ctx, state, "From", From$0);
|
|
11476
11642
|
}
|
|
11477
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11643
|
+
var Function$0 = $TS($S($EXPECT($L146, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11478
11644
|
return { $loc, token: $1 };
|
|
11479
11645
|
});
|
|
11480
11646
|
function Function(ctx, state) {
|
|
11481
11647
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
11482
11648
|
}
|
|
11483
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11649
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L147, 'GetOrSet "get"'), $EXPECT($L148, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11484
11650
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11485
11651
|
});
|
|
11486
11652
|
function GetOrSet(ctx, state) {
|
|
11487
11653
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
11488
11654
|
}
|
|
11489
|
-
var Hash$0 = $TV($EXPECT($
|
|
11655
|
+
var Hash$0 = $TV($EXPECT($L149, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
11490
11656
|
return { $loc, token: $1 };
|
|
11491
11657
|
});
|
|
11492
11658
|
function Hash(ctx, state) {
|
|
11493
11659
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11494
11660
|
}
|
|
11495
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11661
|
+
var If$0 = $TV($TEXT($S($EXPECT($L150, 'If "if"'), NonIdContinue, $E($EXPECT($L15, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11496
11662
|
return { $loc, token: $1 };
|
|
11497
11663
|
});
|
|
11498
11664
|
function If(ctx, state) {
|
|
11499
11665
|
return $EVENT(ctx, state, "If", If$0);
|
|
11500
11666
|
}
|
|
11501
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11667
|
+
var Import$0 = $TS($S($EXPECT($L19, 'Import "import"'), $Y($EXPECT($R69, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11502
11668
|
return { $loc, token: $1 };
|
|
11503
11669
|
});
|
|
11504
11670
|
function Import(ctx, state) {
|
|
11505
11671
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11506
11672
|
}
|
|
11507
|
-
var In$0 = $TS($S($EXPECT($
|
|
11673
|
+
var In$0 = $TS($S($EXPECT($L151, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11508
11674
|
return { $loc, token: $1 };
|
|
11509
11675
|
});
|
|
11510
11676
|
function In(ctx, state) {
|
|
11511
11677
|
return $EVENT(ctx, state, "In", In$0);
|
|
11512
11678
|
}
|
|
11513
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11679
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L152, 'LetOrConst "let"'), $EXPECT($L153, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11514
11680
|
return { $loc, token: $1 };
|
|
11515
11681
|
});
|
|
11516
11682
|
function LetOrConst(ctx, state) {
|
|
11517
11683
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11518
11684
|
}
|
|
11519
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11685
|
+
var Const$0 = $TS($S($EXPECT($L153, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11520
11686
|
return { $loc, token: $1 };
|
|
11521
11687
|
});
|
|
11522
11688
|
function Const(ctx, state) {
|
|
11523
11689
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11524
11690
|
}
|
|
11525
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11691
|
+
var Is$0 = $TS($S($EXPECT($L154, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11526
11692
|
return { $loc, token: $1 };
|
|
11527
11693
|
});
|
|
11528
11694
|
function Is(ctx, state) {
|
|
@@ -11534,31 +11700,31 @@ ${input.slice(result.pos)}
|
|
|
11534
11700
|
function LetOrConstOrVar(ctx, state) {
|
|
11535
11701
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11536
11702
|
}
|
|
11537
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11703
|
+
var Loop$0 = $TS($S($EXPECT($L155, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11538
11704
|
return { $loc, token: "while(true)" };
|
|
11539
11705
|
});
|
|
11540
11706
|
function Loop(ctx, state) {
|
|
11541
11707
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11542
11708
|
}
|
|
11543
|
-
var New$0 = $TS($S($EXPECT($
|
|
11709
|
+
var New$0 = $TS($S($EXPECT($L156, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11544
11710
|
return { $loc, token: $1 };
|
|
11545
11711
|
});
|
|
11546
11712
|
function New(ctx, state) {
|
|
11547
11713
|
return $EVENT(ctx, state, "New", New$0);
|
|
11548
11714
|
}
|
|
11549
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11715
|
+
var Not$0 = $TS($S($EXPECT($L157, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L14, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11550
11716
|
return { $loc, token: "!" };
|
|
11551
11717
|
});
|
|
11552
11718
|
function Not(ctx, state) {
|
|
11553
11719
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11554
11720
|
}
|
|
11555
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11721
|
+
var Of$0 = $TS($S($EXPECT($L158, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11556
11722
|
return { $loc, token: $1 };
|
|
11557
11723
|
});
|
|
11558
11724
|
function Of(ctx, state) {
|
|
11559
11725
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
11560
11726
|
}
|
|
11561
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11727
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L16, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
11562
11728
|
return { $loc, token: $1 };
|
|
11563
11729
|
});
|
|
11564
11730
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -11570,7 +11736,7 @@ ${input.slice(result.pos)}
|
|
|
11570
11736
|
function OpenBrace(ctx, state) {
|
|
11571
11737
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
11572
11738
|
}
|
|
11573
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
11739
|
+
var OpenBracket$0 = $TV($EXPECT($L159, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
11574
11740
|
return { $loc, token: $1 };
|
|
11575
11741
|
});
|
|
11576
11742
|
function OpenBracket(ctx, state) {
|
|
@@ -11582,43 +11748,43 @@ ${input.slice(result.pos)}
|
|
|
11582
11748
|
function OpenParen(ctx, state) {
|
|
11583
11749
|
return $EVENT(ctx, state, "OpenParen", OpenParen$0);
|
|
11584
11750
|
}
|
|
11585
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
11751
|
+
var Operator$0 = $TS($S($EXPECT($L160, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11586
11752
|
return { $loc, token: $1 };
|
|
11587
11753
|
});
|
|
11588
11754
|
function Operator(ctx, state) {
|
|
11589
11755
|
return $EVENT(ctx, state, "Operator", Operator$0);
|
|
11590
11756
|
}
|
|
11591
|
-
var Own$0 = $TS($S($EXPECT($
|
|
11757
|
+
var Own$0 = $TS($S($EXPECT($L161, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11592
11758
|
return { $loc, token: $1 };
|
|
11593
11759
|
});
|
|
11594
11760
|
function Own(ctx, state) {
|
|
11595
11761
|
return $EVENT(ctx, state, "Own", Own$0);
|
|
11596
11762
|
}
|
|
11597
|
-
var Public$0 = $TS($S($EXPECT($
|
|
11763
|
+
var Public$0 = $TS($S($EXPECT($L162, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11598
11764
|
return { $loc, token: $1 };
|
|
11599
11765
|
});
|
|
11600
11766
|
function Public(ctx, state) {
|
|
11601
11767
|
return $EVENT(ctx, state, "Public", Public$0);
|
|
11602
11768
|
}
|
|
11603
|
-
var Private$0 = $TS($S($EXPECT($
|
|
11769
|
+
var Private$0 = $TS($S($EXPECT($L163, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11604
11770
|
return { $loc, token: $1 };
|
|
11605
11771
|
});
|
|
11606
11772
|
function Private(ctx, state) {
|
|
11607
11773
|
return $EVENT(ctx, state, "Private", Private$0);
|
|
11608
11774
|
}
|
|
11609
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
11775
|
+
var Protected$0 = $TS($S($EXPECT($L164, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11610
11776
|
return { $loc, token: $1 };
|
|
11611
11777
|
});
|
|
11612
11778
|
function Protected(ctx, state) {
|
|
11613
11779
|
return $EVENT(ctx, state, "Protected", Protected$0);
|
|
11614
11780
|
}
|
|
11615
|
-
var Pipe$0 = $TV($C($EXPECT($
|
|
11781
|
+
var Pipe$0 = $TV($C($EXPECT($L165, 'Pipe "||>"'), $EXPECT($L166, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11616
11782
|
return { $loc, token: "||>" };
|
|
11617
11783
|
});
|
|
11618
|
-
var Pipe$1 = $TV($C($EXPECT($
|
|
11784
|
+
var Pipe$1 = $TV($C($EXPECT($L167, 'Pipe "|>="'), $EXPECT($L168, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
|
|
11619
11785
|
return { $loc, token: "|>=" };
|
|
11620
11786
|
});
|
|
11621
|
-
var Pipe$2 = $TV($C($EXPECT($
|
|
11787
|
+
var Pipe$2 = $TV($C($EXPECT($L169, 'Pipe "|>"'), $EXPECT($L170, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11622
11788
|
return { $loc, token: "|>" };
|
|
11623
11789
|
});
|
|
11624
11790
|
var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
|
|
@@ -11631,173 +11797,173 @@ ${input.slice(result.pos)}
|
|
|
11631
11797
|
function QuestionMark(ctx, state) {
|
|
11632
11798
|
return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
|
|
11633
11799
|
}
|
|
11634
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
11800
|
+
var Readonly$0 = $TS($S($EXPECT($L171, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11635
11801
|
return { $loc, token: $1, ts: true };
|
|
11636
11802
|
});
|
|
11637
11803
|
function Readonly(ctx, state) {
|
|
11638
11804
|
return $EVENT(ctx, state, "Readonly", Readonly$0);
|
|
11639
11805
|
}
|
|
11640
|
-
var Return$0 = $TS($S($EXPECT($
|
|
11806
|
+
var Return$0 = $TS($S($EXPECT($L172, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11641
11807
|
return { $loc, token: $1 };
|
|
11642
11808
|
});
|
|
11643
11809
|
function Return(ctx, state) {
|
|
11644
11810
|
return $EVENT(ctx, state, "Return", Return$0);
|
|
11645
11811
|
}
|
|
11646
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
11812
|
+
var Satisfies$0 = $TS($S($EXPECT($L173, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11647
11813
|
return { $loc, token: $1 };
|
|
11648
11814
|
});
|
|
11649
11815
|
function Satisfies(ctx, state) {
|
|
11650
11816
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
11651
11817
|
}
|
|
11652
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
11818
|
+
var Semicolon$0 = $TV($EXPECT($L103, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
11653
11819
|
return { $loc, token: $1 };
|
|
11654
11820
|
});
|
|
11655
11821
|
function Semicolon(ctx, state) {
|
|
11656
11822
|
return $EVENT(ctx, state, "Semicolon", Semicolon$0);
|
|
11657
11823
|
}
|
|
11658
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
11824
|
+
var SingleQuote$0 = $TV($EXPECT($L174, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
11659
11825
|
return { $loc, token: $1 };
|
|
11660
11826
|
});
|
|
11661
11827
|
function SingleQuote(ctx, state) {
|
|
11662
11828
|
return $EVENT(ctx, state, "SingleQuote", SingleQuote$0);
|
|
11663
11829
|
}
|
|
11664
|
-
var Star$0 = $TV($EXPECT($
|
|
11830
|
+
var Star$0 = $TV($EXPECT($L58, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
11665
11831
|
return { $loc, token: $1 };
|
|
11666
11832
|
});
|
|
11667
11833
|
function Star(ctx, state) {
|
|
11668
11834
|
return $EVENT(ctx, state, "Star", Star$0);
|
|
11669
11835
|
}
|
|
11670
|
-
var Static$0 = $TS($S($EXPECT($
|
|
11836
|
+
var Static$0 = $TS($S($EXPECT($L175, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11671
11837
|
return { $loc, token: $1 };
|
|
11672
11838
|
});
|
|
11673
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11839
|
+
var Static$1 = $TS($S($EXPECT($L119, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L119, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11674
11840
|
return { $loc, token: "static " };
|
|
11675
11841
|
});
|
|
11676
11842
|
var Static$$ = [Static$0, Static$1];
|
|
11677
11843
|
function Static(ctx, state) {
|
|
11678
11844
|
return $EVENT_C(ctx, state, "Static", Static$$);
|
|
11679
11845
|
}
|
|
11680
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
11846
|
+
var SubstitutionStart$0 = $TV($EXPECT($L176, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
11681
11847
|
return { $loc, token: $1 };
|
|
11682
11848
|
});
|
|
11683
11849
|
function SubstitutionStart(ctx, state) {
|
|
11684
11850
|
return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
|
|
11685
11851
|
}
|
|
11686
|
-
var Super$0 = $TS($S($EXPECT($
|
|
11852
|
+
var Super$0 = $TS($S($EXPECT($L177, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11687
11853
|
return { $loc, token: $1 };
|
|
11688
11854
|
});
|
|
11689
11855
|
function Super(ctx, state) {
|
|
11690
11856
|
return $EVENT(ctx, state, "Super", Super$0);
|
|
11691
11857
|
}
|
|
11692
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
11858
|
+
var Switch$0 = $TS($S($EXPECT($L178, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11693
11859
|
return { $loc, token: $1 };
|
|
11694
11860
|
});
|
|
11695
11861
|
function Switch(ctx, state) {
|
|
11696
11862
|
return $EVENT(ctx, state, "Switch", Switch$0);
|
|
11697
11863
|
}
|
|
11698
|
-
var Target$0 = $TS($S($EXPECT($
|
|
11864
|
+
var Target$0 = $TS($S($EXPECT($L179, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11699
11865
|
return { $loc, token: $1 };
|
|
11700
11866
|
});
|
|
11701
11867
|
function Target(ctx, state) {
|
|
11702
11868
|
return $EVENT(ctx, state, "Target", Target$0);
|
|
11703
11869
|
}
|
|
11704
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
11870
|
+
var Then$0 = $TS($S(__, $EXPECT($L180, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
11705
11871
|
return { $loc, token: "" };
|
|
11706
11872
|
});
|
|
11707
11873
|
function Then(ctx, state) {
|
|
11708
11874
|
return $EVENT(ctx, state, "Then", Then$0);
|
|
11709
11875
|
}
|
|
11710
|
-
var This$0 = $TS($S($EXPECT($
|
|
11876
|
+
var This$0 = $TS($S($EXPECT($L181, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11711
11877
|
return { $loc, token: $1 };
|
|
11712
11878
|
});
|
|
11713
11879
|
function This(ctx, state) {
|
|
11714
11880
|
return $EVENT(ctx, state, "This", This$0);
|
|
11715
11881
|
}
|
|
11716
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
11882
|
+
var Throw$0 = $TS($S($EXPECT($L182, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11717
11883
|
return { $loc, token: $1 };
|
|
11718
11884
|
});
|
|
11719
11885
|
function Throw(ctx, state) {
|
|
11720
11886
|
return $EVENT(ctx, state, "Throw", Throw$0);
|
|
11721
11887
|
}
|
|
11722
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
11888
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L183, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11723
11889
|
return { $loc, token: "`" };
|
|
11724
11890
|
});
|
|
11725
11891
|
function TripleDoubleQuote(ctx, state) {
|
|
11726
11892
|
return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
|
|
11727
11893
|
}
|
|
11728
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
11894
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L184, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
11729
11895
|
return { $loc, token: "`" };
|
|
11730
11896
|
});
|
|
11731
11897
|
function TripleSingleQuote(ctx, state) {
|
|
11732
11898
|
return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
|
|
11733
11899
|
}
|
|
11734
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
11900
|
+
var TripleSlash$0 = $TV($EXPECT($L185, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
11735
11901
|
return { $loc, token: "/" };
|
|
11736
11902
|
});
|
|
11737
11903
|
function TripleSlash(ctx, state) {
|
|
11738
11904
|
return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
|
|
11739
11905
|
}
|
|
11740
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
11906
|
+
var TripleTick$0 = $TV($EXPECT($L186, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
11741
11907
|
return { $loc, token: "`" };
|
|
11742
11908
|
});
|
|
11743
11909
|
function TripleTick(ctx, state) {
|
|
11744
11910
|
return $EVENT(ctx, state, "TripleTick", TripleTick$0);
|
|
11745
11911
|
}
|
|
11746
|
-
var Try$0 = $TS($S($EXPECT($
|
|
11912
|
+
var Try$0 = $TS($S($EXPECT($L187, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11747
11913
|
return { $loc, token: $1 };
|
|
11748
11914
|
});
|
|
11749
11915
|
function Try(ctx, state) {
|
|
11750
11916
|
return $EVENT(ctx, state, "Try", Try$0);
|
|
11751
11917
|
}
|
|
11752
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
11918
|
+
var Typeof$0 = $TS($S($EXPECT($L188, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11753
11919
|
return { $loc, token: $1 };
|
|
11754
11920
|
});
|
|
11755
11921
|
function Typeof(ctx, state) {
|
|
11756
11922
|
return $EVENT(ctx, state, "Typeof", Typeof$0);
|
|
11757
11923
|
}
|
|
11758
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
11924
|
+
var Unless$0 = $TS($S($EXPECT($L189, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11759
11925
|
return { $loc, token: $1, negated: true };
|
|
11760
11926
|
});
|
|
11761
11927
|
function Unless(ctx, state) {
|
|
11762
11928
|
return $EVENT(ctx, state, "Unless", Unless$0);
|
|
11763
11929
|
}
|
|
11764
|
-
var Until$0 = $TS($S($EXPECT($
|
|
11930
|
+
var Until$0 = $TS($S($EXPECT($L190, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11765
11931
|
return { $loc, token: $1 };
|
|
11766
11932
|
});
|
|
11767
11933
|
function Until(ctx, state) {
|
|
11768
11934
|
return $EVENT(ctx, state, "Until", Until$0);
|
|
11769
11935
|
}
|
|
11770
|
-
var Using$0 = $TS($S($EXPECT($
|
|
11936
|
+
var Using$0 = $TS($S($EXPECT($L191, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11771
11937
|
return { $loc, token: $1 };
|
|
11772
11938
|
});
|
|
11773
11939
|
function Using(ctx, state) {
|
|
11774
11940
|
return $EVENT(ctx, state, "Using", Using$0);
|
|
11775
11941
|
}
|
|
11776
|
-
var Var$0 = $TS($S($EXPECT($
|
|
11942
|
+
var Var$0 = $TS($S($EXPECT($L192, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11777
11943
|
return { $loc, token: $1 };
|
|
11778
11944
|
});
|
|
11779
11945
|
function Var(ctx, state) {
|
|
11780
11946
|
return $EVENT(ctx, state, "Var", Var$0);
|
|
11781
11947
|
}
|
|
11782
|
-
var Void$0 = $TS($S($EXPECT($
|
|
11948
|
+
var Void$0 = $TS($S($EXPECT($L193, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11783
11949
|
return { $loc, token: $1 };
|
|
11784
11950
|
});
|
|
11785
11951
|
function Void(ctx, state) {
|
|
11786
11952
|
return $EVENT(ctx, state, "Void", Void$0);
|
|
11787
11953
|
}
|
|
11788
|
-
var When$0 = $TS($S($EXPECT($
|
|
11954
|
+
var When$0 = $TS($S($EXPECT($L194, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11789
11955
|
return { $loc, token: "case" };
|
|
11790
11956
|
});
|
|
11791
11957
|
function When(ctx, state) {
|
|
11792
11958
|
return $EVENT(ctx, state, "When", When$0);
|
|
11793
11959
|
}
|
|
11794
|
-
var While$0 = $TS($S($EXPECT($
|
|
11960
|
+
var While$0 = $TS($S($EXPECT($L195, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11795
11961
|
return { $loc, token: $1 };
|
|
11796
11962
|
});
|
|
11797
11963
|
function While(ctx, state) {
|
|
11798
11964
|
return $EVENT(ctx, state, "While", While$0);
|
|
11799
11965
|
}
|
|
11800
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
11966
|
+
var Yield$0 = $TS($S($EXPECT($L196, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11801
11967
|
return { $loc, token: $1, type: "Yield" };
|
|
11802
11968
|
});
|
|
11803
11969
|
function Yield(ctx, state) {
|
|
@@ -11826,7 +11992,7 @@ ${input.slice(result.pos)}
|
|
|
11826
11992
|
function JSXImplicitFragment(ctx, state) {
|
|
11827
11993
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
11828
11994
|
}
|
|
11829
|
-
var JSXTag$0 = $T($S($EXPECT($
|
|
11995
|
+
var JSXTag$0 = $T($S($EXPECT($R70, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
11830
11996
|
return value[1];
|
|
11831
11997
|
});
|
|
11832
11998
|
function JSXTag(ctx, state) {
|
|
@@ -11876,7 +12042,7 @@ ${input.slice(result.pos)}
|
|
|
11876
12042
|
function JSXElement(ctx, state) {
|
|
11877
12043
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
11878
12044
|
}
|
|
11879
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
12045
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L197, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
11880
12046
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
11881
12047
|
});
|
|
11882
12048
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -11895,7 +12061,7 @@ ${input.slice(result.pos)}
|
|
|
11895
12061
|
function PopJSXStack(ctx, state) {
|
|
11896
12062
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
11897
12063
|
}
|
|
11898
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
12064
|
+
var JSXOpeningElement$0 = $S($EXPECT($L16, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L37, 'JSXOpeningElement ">"'));
|
|
11899
12065
|
function JSXOpeningElement(ctx, state) {
|
|
11900
12066
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
11901
12067
|
}
|
|
@@ -11910,7 +12076,7 @@ ${input.slice(result.pos)}
|
|
|
11910
12076
|
function JSXOptionalClosingElement(ctx, state) {
|
|
11911
12077
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
11912
12078
|
}
|
|
11913
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
12079
|
+
var JSXClosingElement$0 = $S($EXPECT($L198, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L37, 'JSXClosingElement ">"'));
|
|
11914
12080
|
function JSXClosingElement(ctx, state) {
|
|
11915
12081
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
11916
12082
|
}
|
|
@@ -11931,7 +12097,7 @@ ${input.slice(result.pos)}
|
|
|
11931
12097
|
];
|
|
11932
12098
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
11933
12099
|
});
|
|
11934
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
12100
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L199, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
11935
12101
|
var children = $3;
|
|
11936
12102
|
$0 = $0.slice(1);
|
|
11937
12103
|
return {
|
|
@@ -11944,7 +12110,7 @@ ${input.slice(result.pos)}
|
|
|
11944
12110
|
function JSXFragment(ctx, state) {
|
|
11945
12111
|
return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
|
|
11946
12112
|
}
|
|
11947
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
12113
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L199, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
11948
12114
|
module.JSXTagStack.push("");
|
|
11949
12115
|
return $1;
|
|
11950
12116
|
});
|
|
@@ -11961,11 +12127,11 @@ ${input.slice(result.pos)}
|
|
|
11961
12127
|
function JSXOptionalClosingFragment(ctx, state) {
|
|
11962
12128
|
return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
|
|
11963
12129
|
}
|
|
11964
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
12130
|
+
var JSXClosingFragment$0 = $EXPECT($L200, 'JSXClosingFragment "</>"');
|
|
11965
12131
|
function JSXClosingFragment(ctx, state) {
|
|
11966
12132
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11967
12133
|
}
|
|
11968
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
12134
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L149, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11969
12135
|
return module.config.defaultElement;
|
|
11970
12136
|
});
|
|
11971
12137
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11973,7 +12139,7 @@ ${input.slice(result.pos)}
|
|
|
11973
12139
|
function JSXElementName(ctx, state) {
|
|
11974
12140
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
11975
12141
|
}
|
|
11976
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
12142
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R71, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
11977
12143
|
function JSXIdentifierName(ctx, state) {
|
|
11978
12144
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
11979
12145
|
}
|
|
@@ -12143,7 +12309,7 @@ ${input.slice(result.pos)}
|
|
|
12143
12309
|
}
|
|
12144
12310
|
return $skip;
|
|
12145
12311
|
});
|
|
12146
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
12312
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L149, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
12147
12313
|
return [" ", "id=", $2];
|
|
12148
12314
|
});
|
|
12149
12315
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -12152,7 +12318,7 @@ ${input.slice(result.pos)}
|
|
|
12152
12318
|
class: $2
|
|
12153
12319
|
};
|
|
12154
12320
|
});
|
|
12155
|
-
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($
|
|
12321
|
+
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R16, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
|
|
12156
12322
|
var toggle = $1;
|
|
12157
12323
|
var id = $2;
|
|
12158
12324
|
const value = toggle === "+" ? "true" : "false";
|
|
@@ -12162,11 +12328,11 @@ ${input.slice(result.pos)}
|
|
|
12162
12328
|
function JSXAttribute(ctx, state) {
|
|
12163
12329
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
12164
12330
|
}
|
|
12165
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
12331
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R72, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
12166
12332
|
function JSXAttributeSpace(ctx, state) {
|
|
12167
12333
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
12168
12334
|
}
|
|
12169
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
12335
|
+
var JSXShorthandString$0 = $TR($EXPECT($R73, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12170
12336
|
return quoteString($0);
|
|
12171
12337
|
});
|
|
12172
12338
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -12200,7 +12366,7 @@ ${input.slice(result.pos)}
|
|
|
12200
12366
|
}
|
|
12201
12367
|
return [open, value, close];
|
|
12202
12368
|
});
|
|
12203
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
12369
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R74, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
12204
12370
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
12205
12371
|
function JSXAttributeValue(ctx, state) {
|
|
12206
12372
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -12213,7 +12379,7 @@ ${input.slice(result.pos)}
|
|
|
12213
12379
|
function InlineJSXAttributeValue(ctx, state) {
|
|
12214
12380
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
12215
12381
|
}
|
|
12216
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
12382
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R75, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
12217
12383
|
var op = $2;
|
|
12218
12384
|
var rhs = $3;
|
|
12219
12385
|
return [[], op, [], rhs];
|
|
@@ -12230,7 +12396,7 @@ ${input.slice(result.pos)}
|
|
|
12230
12396
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
12231
12397
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
12232
12398
|
}
|
|
12233
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
12399
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R76, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12234
12400
|
return { $loc, token: $0 };
|
|
12235
12401
|
});
|
|
12236
12402
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -12257,19 +12423,19 @@ ${input.slice(result.pos)}
|
|
|
12257
12423
|
type: "CallExpression",
|
|
12258
12424
|
children: [
|
|
12259
12425
|
$1,
|
|
12260
|
-
|
|
12426
|
+
args,
|
|
12261
12427
|
...rest.flat()
|
|
12262
12428
|
]
|
|
12263
12429
|
});
|
|
12264
12430
|
});
|
|
12265
|
-
var InlineJSXCallExpression$1 = $TS($S($EXPECT($
|
|
12431
|
+
var InlineJSXCallExpression$1 = $TS($S($EXPECT($L19, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
12266
12432
|
var args = $2;
|
|
12267
12433
|
var rest = $3;
|
|
12268
12434
|
return processCallMemberExpression({
|
|
12269
12435
|
type: "CallExpression",
|
|
12270
12436
|
children: [
|
|
12271
12437
|
$1,
|
|
12272
|
-
|
|
12438
|
+
args,
|
|
12273
12439
|
...rest.flat()
|
|
12274
12440
|
]
|
|
12275
12441
|
});
|
|
@@ -12299,7 +12465,6 @@ ${input.slice(result.pos)}
|
|
|
12299
12465
|
});
|
|
12300
12466
|
var InlineJSXCallExpressionRest$2 = $TS($S($E(OptionalShorthand), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
|
|
12301
12467
|
var args = $2;
|
|
12302
|
-
args = { type: "Call", children: args };
|
|
12303
12468
|
if (!$1)
|
|
12304
12469
|
return args;
|
|
12305
12470
|
return [$1, args];
|
|
@@ -12381,7 +12546,7 @@ ${input.slice(result.pos)}
|
|
|
12381
12546
|
}
|
|
12382
12547
|
return $skip;
|
|
12383
12548
|
});
|
|
12384
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
12549
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L29, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
12385
12550
|
return { children: [], jsxChildren: [] };
|
|
12386
12551
|
});
|
|
12387
12552
|
var JSXNestedChildren$$ = [JSXNestedChildren$0, JSXNestedChildren$1];
|
|
@@ -12436,19 +12601,19 @@ ${input.slice(result.pos)}
|
|
|
12436
12601
|
function JSXChild(ctx, state) {
|
|
12437
12602
|
return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
|
|
12438
12603
|
}
|
|
12439
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
12604
|
+
var JSXComment$0 = $TS($S($EXPECT($L201, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L202, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
12440
12605
|
return ["{/*", $2, "*/}"];
|
|
12441
12606
|
});
|
|
12442
12607
|
function JSXComment(ctx, state) {
|
|
12443
12608
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
12444
12609
|
}
|
|
12445
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
12610
|
+
var JSXCommentContent$0 = $TR($EXPECT($R77, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12446
12611
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
12447
12612
|
});
|
|
12448
12613
|
function JSXCommentContent(ctx, state) {
|
|
12449
12614
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
12450
12615
|
}
|
|
12451
|
-
var JSXText$0 = $TR($EXPECT($
|
|
12616
|
+
var JSXText$0 = $TR($EXPECT($R78, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12452
12617
|
return {
|
|
12453
12618
|
type: "JSXText",
|
|
12454
12619
|
token: $0,
|
|
@@ -12568,37 +12733,37 @@ ${input.slice(result.pos)}
|
|
|
12568
12733
|
function InterfaceExtendsTarget(ctx, state) {
|
|
12569
12734
|
return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
|
|
12570
12735
|
}
|
|
12571
|
-
var TypeKeyword$0 = $TS($S($EXPECT($
|
|
12736
|
+
var TypeKeyword$0 = $TS($S($EXPECT($L203, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12572
12737
|
return { $loc, token: $1 };
|
|
12573
12738
|
});
|
|
12574
12739
|
function TypeKeyword(ctx, state) {
|
|
12575
12740
|
return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
|
|
12576
12741
|
}
|
|
12577
|
-
var Enum$0 = $TS($S($EXPECT($
|
|
12742
|
+
var Enum$0 = $TS($S($EXPECT($L204, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12578
12743
|
return { $loc, token: $1 };
|
|
12579
12744
|
});
|
|
12580
12745
|
function Enum(ctx, state) {
|
|
12581
12746
|
return $EVENT(ctx, state, "Enum", Enum$0);
|
|
12582
12747
|
}
|
|
12583
|
-
var Interface$0 = $TS($S($EXPECT($
|
|
12748
|
+
var Interface$0 = $TS($S($EXPECT($L205, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12584
12749
|
return { $loc, token: $1 };
|
|
12585
12750
|
});
|
|
12586
12751
|
function Interface(ctx, state) {
|
|
12587
12752
|
return $EVENT(ctx, state, "Interface", Interface$0);
|
|
12588
12753
|
}
|
|
12589
|
-
var Global$0 = $TS($S($EXPECT($
|
|
12754
|
+
var Global$0 = $TS($S($EXPECT($L206, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12590
12755
|
return { $loc, token: $1 };
|
|
12591
12756
|
});
|
|
12592
12757
|
function Global(ctx, state) {
|
|
12593
12758
|
return $EVENT(ctx, state, "Global", Global$0);
|
|
12594
12759
|
}
|
|
12595
|
-
var Module$0 = $TS($S($EXPECT($
|
|
12760
|
+
var Module$0 = $TS($S($EXPECT($L207, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12596
12761
|
return { $loc, token: $1 };
|
|
12597
12762
|
});
|
|
12598
12763
|
function Module(ctx, state) {
|
|
12599
12764
|
return $EVENT(ctx, state, "Module", Module$0);
|
|
12600
12765
|
}
|
|
12601
|
-
var Namespace$0 = $TS($S($EXPECT($
|
|
12766
|
+
var Namespace$0 = $TS($S($EXPECT($L208, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12602
12767
|
return { $loc, token: $1 };
|
|
12603
12768
|
});
|
|
12604
12769
|
function Namespace(ctx, state) {
|
|
@@ -12813,7 +12978,7 @@ ${input.slice(result.pos)}
|
|
|
12813
12978
|
function TypeProperty(ctx, state) {
|
|
12814
12979
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
12815
12980
|
}
|
|
12816
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
12981
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R79, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R80, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
12817
12982
|
function TypeIndexSignature(ctx, state) {
|
|
12818
12983
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
12819
12984
|
}
|
|
@@ -12871,7 +13036,7 @@ ${input.slice(result.pos)}
|
|
|
12871
13036
|
function ReturnTypeSuffix(ctx, state) {
|
|
12872
13037
|
return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
|
|
12873
13038
|
}
|
|
12874
|
-
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($
|
|
13039
|
+
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L209, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
|
|
12875
13040
|
var asserts = $1;
|
|
12876
13041
|
var t = $2;
|
|
12877
13042
|
if (asserts) {
|
|
@@ -12892,7 +13057,7 @@ ${input.slice(result.pos)}
|
|
|
12892
13057
|
function ReturnType(ctx, state) {
|
|
12893
13058
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
12894
13059
|
}
|
|
12895
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
13060
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L154, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
12896
13061
|
var lhs = $1;
|
|
12897
13062
|
var rhs = $2;
|
|
12898
13063
|
if (!rhs)
|
|
@@ -12950,9 +13115,9 @@ ${input.slice(result.pos)}
|
|
|
12950
13115
|
function TypeUnarySuffix(ctx, state) {
|
|
12951
13116
|
return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
|
|
12952
13117
|
}
|
|
12953
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
12954
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
12955
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
13118
|
+
var TypeUnaryOp$0 = $S($EXPECT($L210, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
13119
|
+
var TypeUnaryOp$1 = $S($EXPECT($L211, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
13120
|
+
var TypeUnaryOp$2 = $S($EXPECT($L171, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
12956
13121
|
var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1, TypeUnaryOp$2];
|
|
12957
13122
|
function TypeUnaryOp(ctx, state) {
|
|
12958
13123
|
return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
|
|
@@ -12982,7 +13147,7 @@ ${input.slice(result.pos)}
|
|
|
12982
13147
|
function TypeIndexedAccess(ctx, state) {
|
|
12983
13148
|
return $EVENT_C(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$$);
|
|
12984
13149
|
}
|
|
12985
|
-
var UnknownAlias$0 = $TV($EXPECT($
|
|
13150
|
+
var UnknownAlias$0 = $TV($EXPECT($L212, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
|
|
12986
13151
|
return { $loc, token: "unknown" };
|
|
12987
13152
|
});
|
|
12988
13153
|
function UnknownAlias(ctx, state) {
|
|
@@ -13043,8 +13208,8 @@ ${input.slice(result.pos)}
|
|
|
13043
13208
|
function TypePrimary(ctx, state) {
|
|
13044
13209
|
return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
|
|
13045
13210
|
}
|
|
13046
|
-
var ImportType$0 = $S($EXPECT($
|
|
13047
|
-
var ImportType$1 = $S($EXPECT($
|
|
13211
|
+
var ImportType$0 = $S($EXPECT($L19, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
13212
|
+
var ImportType$1 = $S($EXPECT($L19, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
13048
13213
|
var ImportType$$ = [ImportType$0, ImportType$1];
|
|
13049
13214
|
function ImportType(ctx, state) {
|
|
13050
13215
|
return $EVENT_C(ctx, state, "ImportType", ImportType$$);
|
|
@@ -13107,7 +13272,7 @@ ${input.slice(result.pos)}
|
|
|
13107
13272
|
function NestedType(ctx, state) {
|
|
13108
13273
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
13109
13274
|
}
|
|
13110
|
-
var TypeConditional$0 = $TS($S($E(_), $EXPECT($
|
|
13275
|
+
var TypeConditional$0 = $TS($S($E(_), $EXPECT($R81, "TypeConditional /(?=if|unless)/"), TypeIfThenElse), function($skip, $loc, $0, $1, $2, $3) {
|
|
13111
13276
|
return [$1, expressionizeTypeIf($3)];
|
|
13112
13277
|
});
|
|
13113
13278
|
var TypeConditional$1 = $TS($S(TypeCondition, NotDedented, QuestionMark, Type, __, Colon, Type), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
@@ -13191,10 +13356,10 @@ ${input.slice(result.pos)}
|
|
|
13191
13356
|
}
|
|
13192
13357
|
var TypeLiteral$0 = TypeTemplateLiteral;
|
|
13193
13358
|
var TypeLiteral$1 = Literal;
|
|
13194
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
13359
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L193, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13195
13360
|
return { type: "VoidType", $loc, token: $1 };
|
|
13196
13361
|
});
|
|
13197
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
13362
|
+
var TypeLiteral$3 = $TV($EXPECT($L213, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
13198
13363
|
return { $loc, token: "[]" };
|
|
13199
13364
|
});
|
|
13200
13365
|
var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
|
|
@@ -13213,16 +13378,16 @@ ${input.slice(result.pos)}
|
|
|
13213
13378
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
13214
13379
|
return value[1];
|
|
13215
13380
|
});
|
|
13216
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
13381
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L14, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L116, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L38, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L29, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
13217
13382
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
13218
13383
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
13219
13384
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
13220
13385
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
13221
13386
|
}
|
|
13222
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
13387
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L102, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
13223
13388
|
return { $loc, token: "|" };
|
|
13224
13389
|
});
|
|
13225
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
13390
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L101, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
13226
13391
|
return { $loc, token: "&" };
|
|
13227
13392
|
});
|
|
13228
13393
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -13239,7 +13404,7 @@ ${input.slice(result.pos)}
|
|
|
13239
13404
|
function FunctionType(ctx, state) {
|
|
13240
13405
|
return $EVENT(ctx, state, "FunctionType", FunctionType$0);
|
|
13241
13406
|
}
|
|
13242
|
-
var TypeArrowFunction$0 = $TV($C($EXPECT($
|
|
13407
|
+
var TypeArrowFunction$0 = $TV($C($EXPECT($L12, 'TypeArrowFunction "=>"'), $EXPECT($L13, 'TypeArrowFunction "\u21D2"'), $EXPECT($L27, 'TypeArrowFunction "->"'), $EXPECT($L28, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
13243
13408
|
return { $loc, token: "=>" };
|
|
13244
13409
|
});
|
|
13245
13410
|
function TypeArrowFunction(ctx, state) {
|
|
@@ -13277,11 +13442,11 @@ ${input.slice(result.pos)}
|
|
|
13277
13442
|
function TypeParameters(ctx, state) {
|
|
13278
13443
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
13279
13444
|
}
|
|
13280
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
13445
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L153, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
13281
13446
|
function TypeParameter(ctx, state) {
|
|
13282
13447
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
13283
13448
|
}
|
|
13284
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
13449
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L142, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
13285
13450
|
function TypeConstraint(ctx, state) {
|
|
13286
13451
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
13287
13452
|
}
|
|
@@ -13290,7 +13455,7 @@ ${input.slice(result.pos)}
|
|
|
13290
13455
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
13291
13456
|
}
|
|
13292
13457
|
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
13293
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
13458
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L37, 'TypeParameterDelimiter ">"')));
|
|
13294
13459
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
13295
13460
|
return value[1];
|
|
13296
13461
|
});
|
|
@@ -13304,15 +13469,15 @@ ${input.slice(result.pos)}
|
|
|
13304
13469
|
function ThisType(ctx, state) {
|
|
13305
13470
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
13306
13471
|
}
|
|
13307
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
13472
|
+
var Shebang$0 = $S($R$0($EXPECT($R82, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
13308
13473
|
function Shebang(ctx, state) {
|
|
13309
13474
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
13310
13475
|
}
|
|
13311
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
13476
|
+
var CivetPrologue$0 = $T($S($EXPECT($R83, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R84, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
13312
13477
|
var content = value[2];
|
|
13313
13478
|
return content;
|
|
13314
13479
|
});
|
|
13315
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
13480
|
+
var CivetPrologue$1 = $T($S($EXPECT($R83, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R84, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
13316
13481
|
var content = value[2];
|
|
13317
13482
|
return content;
|
|
13318
13483
|
});
|
|
@@ -13320,7 +13485,7 @@ ${input.slice(result.pos)}
|
|
|
13320
13485
|
function CivetPrologue(ctx, state) {
|
|
13321
13486
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
13322
13487
|
}
|
|
13323
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
13488
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L214, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R85, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13324
13489
|
var options = $3;
|
|
13325
13490
|
return {
|
|
13326
13491
|
type: "CivetPrologue",
|
|
@@ -13331,7 +13496,7 @@ ${input.slice(result.pos)}
|
|
|
13331
13496
|
function CivetPrologueContent(ctx, state) {
|
|
13332
13497
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
13333
13498
|
}
|
|
13334
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
13499
|
+
var CivetOption$0 = $TR($EXPECT($R86, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
13335
13500
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
13336
13501
|
if (l)
|
|
13337
13502
|
return l.toUpperCase();
|
|
@@ -13348,11 +13513,11 @@ ${input.slice(result.pos)}
|
|
|
13348
13513
|
function CivetOption(ctx, state) {
|
|
13349
13514
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
13350
13515
|
}
|
|
13351
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
13516
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R83, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
13352
13517
|
function UnknownPrologue(ctx, state) {
|
|
13353
13518
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
13354
13519
|
}
|
|
13355
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
13520
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R87, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
13356
13521
|
function TripleSlashDirective(ctx, state) {
|
|
13357
13522
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
13358
13523
|
}
|
|
@@ -13366,13 +13531,13 @@ ${input.slice(result.pos)}
|
|
|
13366
13531
|
function PrologueString(ctx, state) {
|
|
13367
13532
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
13368
13533
|
}
|
|
13369
|
-
var EOS$0 = $T($S($EXPECT($
|
|
13534
|
+
var EOS$0 = $T($S($EXPECT($R88, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
13370
13535
|
return value[1];
|
|
13371
13536
|
});
|
|
13372
13537
|
function EOS(ctx, state) {
|
|
13373
13538
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
13374
13539
|
}
|
|
13375
|
-
var EOL$0 = $TR($EXPECT($
|
|
13540
|
+
var EOL$0 = $TR($EXPECT($R89, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
13376
13541
|
return { $loc, token: $0 };
|
|
13377
13542
|
});
|
|
13378
13543
|
function EOL(ctx, state) {
|
|
@@ -13921,7 +14086,7 @@ ${input.slice(result.pos)}
|
|
|
13921
14086
|
function Init(ctx, state) {
|
|
13922
14087
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
13923
14088
|
}
|
|
13924
|
-
var Indent$0 = $TR($EXPECT($
|
|
14089
|
+
var Indent$0 = $TR($EXPECT($R84, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
13925
14090
|
const level = getIndentLevel($0, module.config.tab);
|
|
13926
14091
|
return {
|
|
13927
14092
|
$loc,
|