@danielx/civet 0.6.54 → 0.6.56
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 +306 -246
- package/dist/esbuild.js +1 -1
- package/dist/main.js +306 -246
- package/dist/main.mjs +306 -246
- package/dist/rollup.js +1 -1
- package/dist/unplugin-shared.mjs +2 -4
- package/dist/unplugin.js +1 -1
- package/dist/vite.js +1 -1
- package/dist/webpack.js +1 -1
- package/package.json +4 -3
package/dist/browser.js
CHANGED
|
@@ -932,48 +932,64 @@ ${input.slice(result.pos)}
|
|
|
932
932
|
const expandedOps = expandChainedComparisons($0);
|
|
933
933
|
let i = 2;
|
|
934
934
|
while (i < expandedOps.length) {
|
|
935
|
-
|
|
935
|
+
let op = expandedOps[i];
|
|
936
936
|
if (op.special) {
|
|
937
|
-
let
|
|
938
|
-
if (
|
|
937
|
+
let start = i - 2, end = i + 2;
|
|
938
|
+
if (isRelationalOp(op)) {
|
|
939
|
+
while (start >= 4 && !isLowerThanRelationalOp(expandedOps[start - 2])) {
|
|
940
|
+
start -= 4;
|
|
941
|
+
}
|
|
942
|
+
while (end + 4 < expandedOps.length && !isLowerThanRelationalOp(expandedOps[end + 2])) {
|
|
943
|
+
end += 4;
|
|
944
|
+
}
|
|
945
|
+
}
|
|
946
|
+
let a = start === i - 2 ? expandedOps[start] : expandedOps.slice(start, i - 1);
|
|
947
|
+
let wsOp = expandedOps[i - 1];
|
|
948
|
+
let wsB = expandedOps[i + 1];
|
|
949
|
+
let b = end === i + 2 ? expandedOps[i + 2] : expandedOps.slice(i + 2, end + 1);
|
|
950
|
+
if (op.token === "instanceof" && b.type === "Literal" && b.children?.[0]?.type === "StringLiteral") {
|
|
939
951
|
a = ["typeof ", makeLeftHandSideExpression(a)];
|
|
940
|
-
if (
|
|
941
|
-
|
|
952
|
+
if (op.negated) {
|
|
953
|
+
op = { ...op, token: "!==", negated: false };
|
|
942
954
|
} else {
|
|
943
|
-
|
|
955
|
+
op = { ...op, token: "===" };
|
|
944
956
|
}
|
|
945
957
|
}
|
|
946
|
-
if (
|
|
958
|
+
if (op.asConst) {
|
|
947
959
|
a = makeAsConst(a);
|
|
948
960
|
b = makeAsConst(b);
|
|
949
961
|
}
|
|
950
962
|
let children;
|
|
951
|
-
if (
|
|
963
|
+
if (op.call) {
|
|
952
964
|
wsOp = insertTrimmingSpace(wsOp, "");
|
|
953
|
-
if (
|
|
965
|
+
if (op.reversed) {
|
|
954
966
|
wsB = insertTrimmingSpace(wsB, "");
|
|
955
|
-
children = [wsOp,
|
|
967
|
+
children = [wsOp, op.call, "(", wsB, b, ", ", a, ")", op.suffix];
|
|
956
968
|
} else {
|
|
957
|
-
children = [wsOp,
|
|
969
|
+
children = [wsOp, op.call, "(", a, ",", wsB, b, ")", op.suffix];
|
|
958
970
|
}
|
|
959
|
-
} else if (
|
|
971
|
+
} else if (op.method) {
|
|
960
972
|
wsOp = insertTrimmingSpace(wsOp, "");
|
|
961
973
|
wsB = insertTrimmingSpace(wsB, "");
|
|
962
|
-
if (
|
|
963
|
-
|
|
974
|
+
if (op.reversed) {
|
|
975
|
+
if (end !== i + 2)
|
|
976
|
+
b = makeLeftHandSideExpression(b);
|
|
977
|
+
children = [wsB, b, wsOp, ".", op.method, "(", a, ")"];
|
|
964
978
|
} else {
|
|
965
|
-
|
|
979
|
+
if (start !== i - 2)
|
|
980
|
+
a = makeLeftHandSideExpression(a);
|
|
981
|
+
children = [a, wsOp, ".", op.method, "(", wsB, b, ")"];
|
|
966
982
|
}
|
|
967
|
-
} else if (
|
|
968
|
-
children = [a, wsOp,
|
|
969
|
-
if (
|
|
983
|
+
} else if (op.token) {
|
|
984
|
+
children = [a, wsOp, op, wsB, b];
|
|
985
|
+
if (op.negated)
|
|
970
986
|
children = ["(", ...children, ")"];
|
|
971
987
|
} else {
|
|
972
|
-
throw new Error("Unknown operator: " + JSON.stringify(
|
|
988
|
+
throw new Error("Unknown operator: " + JSON.stringify(op));
|
|
973
989
|
}
|
|
974
|
-
if (
|
|
990
|
+
if (op.negated)
|
|
975
991
|
children.unshift("!");
|
|
976
|
-
expandedOps.splice(
|
|
992
|
+
expandedOps.splice(start, end - start + 1, {
|
|
977
993
|
children
|
|
978
994
|
});
|
|
979
995
|
} else {
|
|
@@ -1239,6 +1255,10 @@ ${input.slice(result.pos)}
|
|
|
1239
1255
|
function isRelationalOp(op) {
|
|
1240
1256
|
return relationalOps.includes(op.token) || op.relational;
|
|
1241
1257
|
}
|
|
1258
|
+
var lowerThanRelationalOps = ["&", "^", "|", "&&", "||", "??"];
|
|
1259
|
+
function isLowerThanRelationalOp(op) {
|
|
1260
|
+
return op === "&&" || lowerThanRelationalOps.includes(op.token) || isRelationalOp(op);
|
|
1261
|
+
}
|
|
1242
1262
|
function expandChainedComparisons([first, binops]) {
|
|
1243
1263
|
const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
|
|
1244
1264
|
const results = [];
|
|
@@ -1783,7 +1803,7 @@ ${input.slice(result.pos)}
|
|
|
1783
1803
|
}
|
|
1784
1804
|
const expRefDec = expRef2 !== exp ? [insertTrimmingSpace(expRef2, " "), " = ", insertTrimmingSpace(exp, ""), ", "] : [];
|
|
1785
1805
|
blockPrefix.push(["", {
|
|
1786
|
-
type: "
|
|
1806
|
+
type: "Declaration",
|
|
1787
1807
|
children: [declaration, " = ", insertTrimmingSpace(expRef2, ""), "[", counterRef, "]"],
|
|
1788
1808
|
names: assignmentNames
|
|
1789
1809
|
}, ";"]);
|
|
@@ -2011,10 +2031,14 @@ ${input.slice(result.pos)}
|
|
|
2011
2031
|
children: [" as const"]
|
|
2012
2032
|
};
|
|
2013
2033
|
function makeAsConst(node) {
|
|
2034
|
+
if (Array.isArray(node) && node.length === 1) {
|
|
2035
|
+
node = node[0];
|
|
2036
|
+
}
|
|
2014
2037
|
if (node.type === "Literal" && node.raw !== "null" || node.type === "ArrayExpression" || node.type === "ObjectExpression") {
|
|
2015
2038
|
return { ...node, children: [...node.children, asConst] };
|
|
2039
|
+
} else {
|
|
2040
|
+
return node;
|
|
2016
2041
|
}
|
|
2017
|
-
return node;
|
|
2018
2042
|
}
|
|
2019
2043
|
function makeEmptyBlock() {
|
|
2020
2044
|
const expressions = [];
|
|
@@ -2404,6 +2428,32 @@ ${input.slice(result.pos)}
|
|
|
2404
2428
|
}
|
|
2405
2429
|
}
|
|
2406
2430
|
}
|
|
2431
|
+
function processDeclarations(statements) {
|
|
2432
|
+
gatherRecursiveAll(statements, (n) => {
|
|
2433
|
+
return n.type === "Declaration";
|
|
2434
|
+
}).forEach(({ bindings }) => {
|
|
2435
|
+
return bindings?.forEach((binding) => {
|
|
2436
|
+
const { initializer } = binding;
|
|
2437
|
+
if (!initializer) {
|
|
2438
|
+
return;
|
|
2439
|
+
}
|
|
2440
|
+
const exp = initializer[2];
|
|
2441
|
+
if (exp?.type === "PipelineExpression") {
|
|
2442
|
+
if (exp.children.at(-2) === ",") {
|
|
2443
|
+
const { parent } = exp;
|
|
2444
|
+
const parenthesizedExpression = makeLeftHandSideExpression(exp);
|
|
2445
|
+
parenthesizedExpression.parent = parent;
|
|
2446
|
+
exp.parent = parenthesizedExpression;
|
|
2447
|
+
return initializer[2] = parenthesizedExpression;
|
|
2448
|
+
}
|
|
2449
|
+
;
|
|
2450
|
+
return;
|
|
2451
|
+
}
|
|
2452
|
+
;
|
|
2453
|
+
return;
|
|
2454
|
+
});
|
|
2455
|
+
});
|
|
2456
|
+
}
|
|
2407
2457
|
function implicitFunctionBlock(f) {
|
|
2408
2458
|
if (f.abstract || f.block || f.signature?.optional)
|
|
2409
2459
|
return;
|
|
@@ -3140,6 +3190,7 @@ ${input.slice(result.pos)}
|
|
|
3140
3190
|
const { expressions: statements } = root;
|
|
3141
3191
|
processDeclarationConditions(statements);
|
|
3142
3192
|
processPipelineExpressions(statements);
|
|
3193
|
+
processDeclarations(statements);
|
|
3143
3194
|
processAssignments(statements);
|
|
3144
3195
|
processPatternMatching(statements, ReservedWord);
|
|
3145
3196
|
gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
|
|
@@ -4580,112 +4631,113 @@ ${input.slice(result.pos)}
|
|
|
4580
4631
|
var $L102 = $L("break");
|
|
4581
4632
|
var $L103 = $L("continue");
|
|
4582
4633
|
var $L104 = $L("debugger");
|
|
4583
|
-
var $L105 = $L("
|
|
4584
|
-
var $L106 = $L("
|
|
4585
|
-
var $L107 = $L("
|
|
4586
|
-
var $L108 = $L("
|
|
4587
|
-
var $L109 = $L("
|
|
4588
|
-
var $L110 = $L("
|
|
4589
|
-
var $L111 = $L("
|
|
4590
|
-
var $L112 = $L("
|
|
4591
|
-
var $L113 = $L("
|
|
4592
|
-
var $L114 = $L("
|
|
4593
|
-
var $L115 = $L("
|
|
4594
|
-
var $L116 = $L("
|
|
4595
|
-
var $L117 = $L("
|
|
4596
|
-
var $L118 = $L("
|
|
4597
|
-
var $L119 = $L("
|
|
4598
|
-
var $L120 = $L("
|
|
4599
|
-
var $L121 = $L("
|
|
4600
|
-
var $L122 = $L("
|
|
4601
|
-
var $L123 = $L("
|
|
4602
|
-
var $L124 = $L("
|
|
4603
|
-
var $L125 = $L("
|
|
4604
|
-
var $L126 = $L("
|
|
4605
|
-
var $L127 = $L("
|
|
4606
|
-
var $L128 = $L("
|
|
4607
|
-
var $L129 = $L("
|
|
4608
|
-
var $L130 = $L("
|
|
4609
|
-
var $L131 = $L("
|
|
4610
|
-
var $L132 = $L("
|
|
4611
|
-
var $L133 = $L("
|
|
4612
|
-
var $L134 = $L(
|
|
4613
|
-
var $L135 = $L("
|
|
4614
|
-
var $L136 = $L("
|
|
4615
|
-
var $L137 = $L("
|
|
4616
|
-
var $L138 = $L("
|
|
4617
|
-
var $L139 = $L("
|
|
4618
|
-
var $L140 = $L("
|
|
4619
|
-
var $L141 = $L("
|
|
4620
|
-
var $L142 = $L("
|
|
4621
|
-
var $L143 = $L("
|
|
4622
|
-
var $L144 = $L("
|
|
4623
|
-
var $L145 = $L("
|
|
4624
|
-
var $L146 = $L("
|
|
4625
|
-
var $L147 = $L("
|
|
4626
|
-
var $L148 = $L("
|
|
4627
|
-
var $L149 = $L("
|
|
4628
|
-
var $L150 = $L("
|
|
4629
|
-
var $L151 = $L("
|
|
4630
|
-
var $L152 = $L("
|
|
4631
|
-
var $L153 = $L("
|
|
4632
|
-
var $L154 = $L("
|
|
4633
|
-
var $L155 = $L("
|
|
4634
|
-
var $L156 = $L("
|
|
4635
|
-
var $L157 = $L("
|
|
4636
|
-
var $L158 = $L("
|
|
4637
|
-
var $L159 = $L("
|
|
4638
|
-
var $L160 = $L("
|
|
4639
|
-
var $L161 = $L("
|
|
4640
|
-
var $L162 = $L("
|
|
4641
|
-
var $L163 = $L("
|
|
4642
|
-
var $L164 = $L("
|
|
4643
|
-
var $L165 = $L("
|
|
4644
|
-
var $L166 = $L("
|
|
4645
|
-
var $L167 = $L("
|
|
4646
|
-
var $L168 = $L("
|
|
4647
|
-
var $L169 = $L("
|
|
4648
|
-
var $L170 = $L("
|
|
4649
|
-
var $L171 = $L("
|
|
4650
|
-
var $L172 = $L("
|
|
4651
|
-
var $L173 = $L("
|
|
4652
|
-
var $L174 = $L("
|
|
4653
|
-
var $L175 = $L("
|
|
4654
|
-
var $L176 = $L("
|
|
4655
|
-
var $L177 = $L("
|
|
4656
|
-
var $L178 = $L("
|
|
4657
|
-
var $L179 = $L(
|
|
4658
|
-
var $L180 = $L("'
|
|
4659
|
-
var $L181 = $L("
|
|
4660
|
-
var $L182 = $L("
|
|
4661
|
-
var $L183 = $L("
|
|
4662
|
-
var $L184 = $L("
|
|
4663
|
-
var $L185 = $L("
|
|
4664
|
-
var $L186 = $L("
|
|
4665
|
-
var $L187 = $L("
|
|
4666
|
-
var $L188 = $L("
|
|
4667
|
-
var $L189 = $L("
|
|
4668
|
-
var $L190 = $L("
|
|
4669
|
-
var $L191 = $L("
|
|
4670
|
-
var $L192 = $L("
|
|
4671
|
-
var $L193 = $L("
|
|
4672
|
-
var $L194 = $L("
|
|
4673
|
-
var $L195 = $L("
|
|
4674
|
-
var $L196 = $L("
|
|
4675
|
-
var $L197 = $L("
|
|
4676
|
-
var $L198 = $L("
|
|
4677
|
-
var $L199 = $L("
|
|
4678
|
-
var $L200 = $L("
|
|
4679
|
-
var $L201 = $L("
|
|
4680
|
-
var $L202 = $L("
|
|
4681
|
-
var $L203 = $L("
|
|
4682
|
-
var $L204 = $L("
|
|
4683
|
-
var $L205 = $L("
|
|
4684
|
-
var $L206 = $L("
|
|
4685
|
-
var $L207 = $L("
|
|
4686
|
-
var $L208 = $L("
|
|
4687
|
-
var $L209 = $L("
|
|
4688
|
-
var $L210 = $L("
|
|
4634
|
+
var $L105 = $L("with");
|
|
4635
|
+
var $L106 = $L("assert");
|
|
4636
|
+
var $L107 = $L(":=");
|
|
4637
|
+
var $L108 = $L("\u2254");
|
|
4638
|
+
var $L109 = $L(".=");
|
|
4639
|
+
var $L110 = $L("/*");
|
|
4640
|
+
var $L111 = $L("*/");
|
|
4641
|
+
var $L112 = $L("\\");
|
|
4642
|
+
var $L113 = $L(")");
|
|
4643
|
+
var $L114 = $L("abstract");
|
|
4644
|
+
var $L115 = $L("as");
|
|
4645
|
+
var $L116 = $L("@");
|
|
4646
|
+
var $L117 = $L("@@");
|
|
4647
|
+
var $L118 = $L("async");
|
|
4648
|
+
var $L119 = $L("await");
|
|
4649
|
+
var $L120 = $L("`");
|
|
4650
|
+
var $L121 = $L("by");
|
|
4651
|
+
var $L122 = $L("case");
|
|
4652
|
+
var $L123 = $L("catch");
|
|
4653
|
+
var $L124 = $L("class");
|
|
4654
|
+
var $L125 = $L("#{");
|
|
4655
|
+
var $L126 = $L("declare");
|
|
4656
|
+
var $L127 = $L("default");
|
|
4657
|
+
var $L128 = $L("delete");
|
|
4658
|
+
var $L129 = $L("do");
|
|
4659
|
+
var $L130 = $L("..");
|
|
4660
|
+
var $L131 = $L("\u2025");
|
|
4661
|
+
var $L132 = $L("...");
|
|
4662
|
+
var $L133 = $L("\u2026");
|
|
4663
|
+
var $L134 = $L("::");
|
|
4664
|
+
var $L135 = $L('"');
|
|
4665
|
+
var $L136 = $L("each");
|
|
4666
|
+
var $L137 = $L("else");
|
|
4667
|
+
var $L138 = $L("export");
|
|
4668
|
+
var $L139 = $L("extends");
|
|
4669
|
+
var $L140 = $L("finally");
|
|
4670
|
+
var $L141 = $L("for");
|
|
4671
|
+
var $L142 = $L("from");
|
|
4672
|
+
var $L143 = $L("function");
|
|
4673
|
+
var $L144 = $L("get");
|
|
4674
|
+
var $L145 = $L("set");
|
|
4675
|
+
var $L146 = $L("#");
|
|
4676
|
+
var $L147 = $L("if");
|
|
4677
|
+
var $L148 = $L("in");
|
|
4678
|
+
var $L149 = $L("let");
|
|
4679
|
+
var $L150 = $L("const");
|
|
4680
|
+
var $L151 = $L("is");
|
|
4681
|
+
var $L152 = $L("loop");
|
|
4682
|
+
var $L153 = $L("new");
|
|
4683
|
+
var $L154 = $L("not");
|
|
4684
|
+
var $L155 = $L("of");
|
|
4685
|
+
var $L156 = $L("[");
|
|
4686
|
+
var $L157 = $L("operator");
|
|
4687
|
+
var $L158 = $L("own");
|
|
4688
|
+
var $L159 = $L("public");
|
|
4689
|
+
var $L160 = $L("private");
|
|
4690
|
+
var $L161 = $L("protected");
|
|
4691
|
+
var $L162 = $L("||>");
|
|
4692
|
+
var $L163 = $L("|\u25B7");
|
|
4693
|
+
var $L164 = $L("|>=");
|
|
4694
|
+
var $L165 = $L("\u25B7=");
|
|
4695
|
+
var $L166 = $L("|>");
|
|
4696
|
+
var $L167 = $L("\u25B7");
|
|
4697
|
+
var $L168 = $L("readonly");
|
|
4698
|
+
var $L169 = $L("return");
|
|
4699
|
+
var $L170 = $L("satisfies");
|
|
4700
|
+
var $L171 = $L("'");
|
|
4701
|
+
var $L172 = $L("static");
|
|
4702
|
+
var $L173 = $L("${");
|
|
4703
|
+
var $L174 = $L("super");
|
|
4704
|
+
var $L175 = $L("switch");
|
|
4705
|
+
var $L176 = $L("target");
|
|
4706
|
+
var $L177 = $L("then");
|
|
4707
|
+
var $L178 = $L("this");
|
|
4708
|
+
var $L179 = $L("throw");
|
|
4709
|
+
var $L180 = $L('"""');
|
|
4710
|
+
var $L181 = $L("'''");
|
|
4711
|
+
var $L182 = $L("///");
|
|
4712
|
+
var $L183 = $L("```");
|
|
4713
|
+
var $L184 = $L("try");
|
|
4714
|
+
var $L185 = $L("typeof");
|
|
4715
|
+
var $L186 = $L("unless");
|
|
4716
|
+
var $L187 = $L("until");
|
|
4717
|
+
var $L188 = $L("using");
|
|
4718
|
+
var $L189 = $L("var");
|
|
4719
|
+
var $L190 = $L("void");
|
|
4720
|
+
var $L191 = $L("when");
|
|
4721
|
+
var $L192 = $L("while");
|
|
4722
|
+
var $L193 = $L("yield");
|
|
4723
|
+
var $L194 = $L("/>");
|
|
4724
|
+
var $L195 = $L("</");
|
|
4725
|
+
var $L196 = $L("<>");
|
|
4726
|
+
var $L197 = $L("</>");
|
|
4727
|
+
var $L198 = $L("<!--");
|
|
4728
|
+
var $L199 = $L("-->");
|
|
4729
|
+
var $L200 = $L("type");
|
|
4730
|
+
var $L201 = $L("enum");
|
|
4731
|
+
var $L202 = $L("interface");
|
|
4732
|
+
var $L203 = $L("global");
|
|
4733
|
+
var $L204 = $L("module");
|
|
4734
|
+
var $L205 = $L("namespace");
|
|
4735
|
+
var $L206 = $L("asserts");
|
|
4736
|
+
var $L207 = $L("keyof");
|
|
4737
|
+
var $L208 = $L("infer");
|
|
4738
|
+
var $L209 = $L("???");
|
|
4739
|
+
var $L210 = $L("[]");
|
|
4740
|
+
var $L211 = $L("civet");
|
|
4689
4741
|
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
4690
4742
|
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4691
4743
|
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
@@ -7254,11 +7306,19 @@ ${input.slice(result.pos)}
|
|
|
7254
7306
|
const expressions = [...stmts];
|
|
7255
7307
|
if (last)
|
|
7256
7308
|
expressions.push(last);
|
|
7309
|
+
const maybeComment = expressions.at(-1)?.[2]?.children?.[2]?.at(-1);
|
|
7310
|
+
let hasTrailingComment = false;
|
|
7311
|
+
if (maybeComment?.type === "Comment" && maybeComment.token.startsWith("//")) {
|
|
7312
|
+
hasTrailingComment = true;
|
|
7313
|
+
}
|
|
7314
|
+
const children = [expressions];
|
|
7315
|
+
if (hasTrailingComment) {
|
|
7316
|
+
children.push("\n");
|
|
7317
|
+
}
|
|
7257
7318
|
return {
|
|
7258
7319
|
type: "BlockStatement",
|
|
7259
7320
|
expressions,
|
|
7260
|
-
children
|
|
7261
|
-
// avoid aliasing
|
|
7321
|
+
children,
|
|
7262
7322
|
bare: true
|
|
7263
7323
|
};
|
|
7264
7324
|
});
|
|
@@ -9491,7 +9551,7 @@ ${input.slice(result.pos)}
|
|
|
9491
9551
|
function CaseClause(ctx, state) {
|
|
9492
9552
|
return $EVENT_C(ctx, state, "CaseClause", CaseClause$$);
|
|
9493
9553
|
}
|
|
9494
|
-
var PatternExpressionList$0 = $TS($S(ConditionFragment, $Q($S($E(_), Comma, $E(_), ConditionFragment))), function($skip, $loc, $0, $1, $2) {
|
|
9554
|
+
var PatternExpressionList$0 = $TS($S(ConditionFragment, $Q($S($E(_), Comma, $E($C(Nested, _)), ConditionFragment))), function($skip, $loc, $0, $1, $2) {
|
|
9495
9555
|
var first = $1;
|
|
9496
9556
|
var rest = $2;
|
|
9497
9557
|
return [first, ...rest.map(([, , , p]) => p)];
|
|
@@ -9608,7 +9668,7 @@ ${input.slice(result.pos)}
|
|
|
9608
9668
|
return $EVENT(ctx, state, "CatchClause", CatchClause$0);
|
|
9609
9669
|
}
|
|
9610
9670
|
var CatchBind$0 = $S($E(_), OpenParen, __, CatchParameter, __, CloseParen);
|
|
9611
|
-
var CatchBind$1 = $S(_, InsertOpenParen, CatchParameter, InsertCloseParen);
|
|
9671
|
+
var CatchBind$1 = $S(_, InsertOpenParen, $N(EOS), CatchParameter, InsertCloseParen);
|
|
9612
9672
|
var CatchBind$$ = [CatchBind$0, CatchBind$1];
|
|
9613
9673
|
function CatchBind(ctx, state) {
|
|
9614
9674
|
return $EVENT_C(ctx, state, "CatchBind", CatchBind$$);
|
|
@@ -10045,7 +10105,7 @@ ${input.slice(result.pos)}
|
|
|
10045
10105
|
function FromClause(ctx, state) {
|
|
10046
10106
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
10047
10107
|
}
|
|
10048
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($L105, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10108
|
+
var ImportAssertion$0 = $S($E(_), $C($EXPECT($L105, 'ImportAssertion "with"'), $EXPECT($L106, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral);
|
|
10049
10109
|
function ImportAssertion(ctx, state) {
|
|
10050
10110
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
10051
10111
|
}
|
|
@@ -10265,13 +10325,13 @@ ${input.slice(result.pos)}
|
|
|
10265
10325
|
function LexicalDeclaration(ctx, state) {
|
|
10266
10326
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10267
10327
|
}
|
|
10268
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10328
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L107, 'ConstAssignment ":="'), $EXPECT($L108, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10269
10329
|
return { $loc, token: "=" };
|
|
10270
10330
|
});
|
|
10271
10331
|
function ConstAssignment(ctx, state) {
|
|
10272
10332
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10273
10333
|
}
|
|
10274
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10334
|
+
var LetAssignment$0 = $TV($EXPECT($L109, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10275
10335
|
return { $loc, token: "=" };
|
|
10276
10336
|
});
|
|
10277
10337
|
function LetAssignment(ctx, state) {
|
|
@@ -10677,7 +10737,7 @@ ${input.slice(result.pos)}
|
|
|
10677
10737
|
function MultiLineComment(ctx, state) {
|
|
10678
10738
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10679
10739
|
}
|
|
10680
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10740
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L110, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L111, 'JSMultiLineComment "*/"')), $EXPECT($R57, "JSMultiLineComment /./"))), $EXPECT($L111, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10681
10741
|
return { type: "Comment", $loc, token: $1 };
|
|
10682
10742
|
});
|
|
10683
10743
|
function JSMultiLineComment(ctx, state) {
|
|
@@ -10723,7 +10783,7 @@ ${input.slice(result.pos)}
|
|
|
10723
10783
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R63, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10724
10784
|
return { $loc, token: $0 };
|
|
10725
10785
|
});
|
|
10726
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
10786
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L112, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10727
10787
|
return " ";
|
|
10728
10788
|
});
|
|
10729
10789
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -10769,7 +10829,7 @@ ${input.slice(result.pos)}
|
|
|
10769
10829
|
}
|
|
10770
10830
|
var StatementDelimiter$0 = $Y(EOS);
|
|
10771
10831
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10772
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L26, 'StatementDelimiter "}"'), $EXPECT($
|
|
10832
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L26, 'StatementDelimiter "}"'), $EXPECT($L113, 'StatementDelimiter ")"'), $EXPECT($L35, 'StatementDelimiter "]"'))));
|
|
10773
10833
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10774
10834
|
function StatementDelimiter(ctx, state) {
|
|
10775
10835
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10793,7 +10853,7 @@ ${input.slice(result.pos)}
|
|
|
10793
10853
|
function Loc(ctx, state) {
|
|
10794
10854
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10795
10855
|
}
|
|
10796
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10856
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L114, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10797
10857
|
return { $loc, token: $1, ts: true };
|
|
10798
10858
|
});
|
|
10799
10859
|
function Abstract(ctx, state) {
|
|
@@ -10805,43 +10865,43 @@ ${input.slice(result.pos)}
|
|
|
10805
10865
|
function Ampersand(ctx, state) {
|
|
10806
10866
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10807
10867
|
}
|
|
10808
|
-
var As$0 = $TS($S($EXPECT($
|
|
10868
|
+
var As$0 = $TS($S($EXPECT($L115, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10809
10869
|
return { $loc, token: $1 };
|
|
10810
10870
|
});
|
|
10811
10871
|
function As(ctx, state) {
|
|
10812
10872
|
return $EVENT(ctx, state, "As", As$0);
|
|
10813
10873
|
}
|
|
10814
|
-
var At$0 = $TV($EXPECT($
|
|
10874
|
+
var At$0 = $TV($EXPECT($L116, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10815
10875
|
return { $loc, token: $1 };
|
|
10816
10876
|
});
|
|
10817
10877
|
function At(ctx, state) {
|
|
10818
10878
|
return $EVENT(ctx, state, "At", At$0);
|
|
10819
10879
|
}
|
|
10820
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10880
|
+
var AtAt$0 = $TV($EXPECT($L117, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10821
10881
|
return { $loc, token: "@" };
|
|
10822
10882
|
});
|
|
10823
10883
|
function AtAt(ctx, state) {
|
|
10824
10884
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10825
10885
|
}
|
|
10826
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10886
|
+
var Async$0 = $TS($S($EXPECT($L118, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10827
10887
|
return { $loc, token: $1, type: "Async" };
|
|
10828
10888
|
});
|
|
10829
10889
|
function Async(ctx, state) {
|
|
10830
10890
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10831
10891
|
}
|
|
10832
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10892
|
+
var Await$0 = $TS($S($EXPECT($L119, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10833
10893
|
return { $loc, token: $1, type: "Await" };
|
|
10834
10894
|
});
|
|
10835
10895
|
function Await(ctx, state) {
|
|
10836
10896
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10837
10897
|
}
|
|
10838
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10898
|
+
var Backtick$0 = $TV($EXPECT($L120, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10839
10899
|
return { $loc, token: $1 };
|
|
10840
10900
|
});
|
|
10841
10901
|
function Backtick(ctx, state) {
|
|
10842
10902
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10843
10903
|
}
|
|
10844
|
-
var By$0 = $TS($S($EXPECT($
|
|
10904
|
+
var By$0 = $TS($S($EXPECT($L121, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10845
10905
|
return { $loc, token: $1 };
|
|
10846
10906
|
});
|
|
10847
10907
|
function By(ctx, state) {
|
|
@@ -10853,19 +10913,19 @@ ${input.slice(result.pos)}
|
|
|
10853
10913
|
function Caret(ctx, state) {
|
|
10854
10914
|
return $EVENT(ctx, state, "Caret", Caret$0);
|
|
10855
10915
|
}
|
|
10856
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10916
|
+
var Case$0 = $TS($S($EXPECT($L122, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10857
10917
|
return { $loc, token: $1 };
|
|
10858
10918
|
});
|
|
10859
10919
|
function Case(ctx, state) {
|
|
10860
10920
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10861
10921
|
}
|
|
10862
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10922
|
+
var Catch$0 = $TS($S($EXPECT($L123, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10863
10923
|
return { $loc, token: $1 };
|
|
10864
10924
|
});
|
|
10865
10925
|
function Catch(ctx, state) {
|
|
10866
10926
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10867
10927
|
}
|
|
10868
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10928
|
+
var Class$0 = $TS($S($EXPECT($L124, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10869
10929
|
return { $loc, token: $1 };
|
|
10870
10930
|
});
|
|
10871
10931
|
function Class(ctx, state) {
|
|
@@ -10889,13 +10949,13 @@ ${input.slice(result.pos)}
|
|
|
10889
10949
|
function CloseBracket(ctx, state) {
|
|
10890
10950
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10891
10951
|
}
|
|
10892
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10952
|
+
var CloseParen$0 = $TV($EXPECT($L113, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10893
10953
|
return { $loc, token: $1 };
|
|
10894
10954
|
});
|
|
10895
10955
|
function CloseParen(ctx, state) {
|
|
10896
10956
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10897
10957
|
}
|
|
10898
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10958
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L125, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10899
10959
|
return { $loc, token: "${" };
|
|
10900
10960
|
});
|
|
10901
10961
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -10913,31 +10973,31 @@ ${input.slice(result.pos)}
|
|
|
10913
10973
|
function Comma(ctx, state) {
|
|
10914
10974
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10915
10975
|
}
|
|
10916
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10976
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L116, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10917
10977
|
return { $loc, token: "constructor" };
|
|
10918
10978
|
});
|
|
10919
10979
|
function ConstructorShorthand(ctx, state) {
|
|
10920
10980
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10921
10981
|
}
|
|
10922
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10982
|
+
var Declare$0 = $TS($S($EXPECT($L126, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10923
10983
|
return { $loc, token: $1 };
|
|
10924
10984
|
});
|
|
10925
10985
|
function Declare(ctx, state) {
|
|
10926
10986
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10927
10987
|
}
|
|
10928
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10988
|
+
var Default$0 = $TS($S($EXPECT($L127, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10929
10989
|
return { $loc, token: $1 };
|
|
10930
10990
|
});
|
|
10931
10991
|
function Default(ctx, state) {
|
|
10932
10992
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10933
10993
|
}
|
|
10934
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10994
|
+
var Delete$0 = $TS($S($EXPECT($L128, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10935
10995
|
return { $loc, token: $1 };
|
|
10936
10996
|
});
|
|
10937
10997
|
function Delete(ctx, state) {
|
|
10938
10998
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10939
10999
|
}
|
|
10940
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11000
|
+
var Do$0 = $TS($S($EXPECT($L129, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10941
11001
|
return { $loc, token: $1 };
|
|
10942
11002
|
});
|
|
10943
11003
|
function Do(ctx, state) {
|
|
@@ -10957,45 +11017,45 @@ ${input.slice(result.pos)}
|
|
|
10957
11017
|
function Dot(ctx, state) {
|
|
10958
11018
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10959
11019
|
}
|
|
10960
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
11020
|
+
var DotDot$0 = $TS($S($EXPECT($L130, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10961
11021
|
return { $loc, token: $1 };
|
|
10962
11022
|
});
|
|
10963
|
-
var DotDot$1 = $TV($EXPECT($
|
|
11023
|
+
var DotDot$1 = $TV($EXPECT($L131, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10964
11024
|
return { $loc, token: ".." };
|
|
10965
11025
|
});
|
|
10966
11026
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10967
11027
|
function DotDot(ctx, state) {
|
|
10968
11028
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10969
11029
|
}
|
|
10970
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11030
|
+
var DotDotDot$0 = $TV($EXPECT($L132, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10971
11031
|
return { $loc, token: $1 };
|
|
10972
11032
|
});
|
|
10973
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
11033
|
+
var DotDotDot$1 = $TV($EXPECT($L133, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10974
11034
|
return { $loc, token: "..." };
|
|
10975
11035
|
});
|
|
10976
11036
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10977
11037
|
function DotDotDot(ctx, state) {
|
|
10978
11038
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10979
11039
|
}
|
|
10980
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11040
|
+
var DoubleColon$0 = $TV($EXPECT($L134, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10981
11041
|
return { $loc, token: $1 };
|
|
10982
11042
|
});
|
|
10983
11043
|
function DoubleColon(ctx, state) {
|
|
10984
11044
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10985
11045
|
}
|
|
10986
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11046
|
+
var DoubleQuote$0 = $TV($EXPECT($L135, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10987
11047
|
return { $loc, token: $1 };
|
|
10988
11048
|
});
|
|
10989
11049
|
function DoubleQuote(ctx, state) {
|
|
10990
11050
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10991
11051
|
}
|
|
10992
|
-
var Each$0 = $TS($S($EXPECT($
|
|
11052
|
+
var Each$0 = $TS($S($EXPECT($L136, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10993
11053
|
return { $loc, token: $1 };
|
|
10994
11054
|
});
|
|
10995
11055
|
function Each(ctx, state) {
|
|
10996
11056
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10997
11057
|
}
|
|
10998
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11058
|
+
var Else$0 = $TS($S($EXPECT($L137, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10999
11059
|
return { $loc, token: $1 };
|
|
11000
11060
|
});
|
|
11001
11061
|
function Else(ctx, state) {
|
|
@@ -11007,55 +11067,55 @@ ${input.slice(result.pos)}
|
|
|
11007
11067
|
function Equals(ctx, state) {
|
|
11008
11068
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
11009
11069
|
}
|
|
11010
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11070
|
+
var Export$0 = $TS($S($EXPECT($L138, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11011
11071
|
return { $loc, token: $1 };
|
|
11012
11072
|
});
|
|
11013
11073
|
function Export(ctx, state) {
|
|
11014
11074
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
11015
11075
|
}
|
|
11016
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11076
|
+
var Extends$0 = $TS($S($EXPECT($L139, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11017
11077
|
return { $loc, token: $1 };
|
|
11018
11078
|
});
|
|
11019
11079
|
function Extends(ctx, state) {
|
|
11020
11080
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
11021
11081
|
}
|
|
11022
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
11082
|
+
var Finally$0 = $TS($S($EXPECT($L140, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11023
11083
|
return { $loc, token: $1 };
|
|
11024
11084
|
});
|
|
11025
11085
|
function Finally(ctx, state) {
|
|
11026
11086
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
11027
11087
|
}
|
|
11028
|
-
var For$0 = $TS($S($EXPECT($
|
|
11088
|
+
var For$0 = $TS($S($EXPECT($L141, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11029
11089
|
return { $loc, token: $1 };
|
|
11030
11090
|
});
|
|
11031
11091
|
function For(ctx, state) {
|
|
11032
11092
|
return $EVENT(ctx, state, "For", For$0);
|
|
11033
11093
|
}
|
|
11034
|
-
var From$0 = $TS($S($EXPECT($
|
|
11094
|
+
var From$0 = $TS($S($EXPECT($L142, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11035
11095
|
return { $loc, token: $1 };
|
|
11036
11096
|
});
|
|
11037
11097
|
function From(ctx, state) {
|
|
11038
11098
|
return $EVENT(ctx, state, "From", From$0);
|
|
11039
11099
|
}
|
|
11040
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11100
|
+
var Function$0 = $TS($S($EXPECT($L143, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11041
11101
|
return { $loc, token: $1 };
|
|
11042
11102
|
});
|
|
11043
11103
|
function Function(ctx, state) {
|
|
11044
11104
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
11045
11105
|
}
|
|
11046
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11106
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L144, 'GetOrSet "get"'), $EXPECT($L145, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11047
11107
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11048
11108
|
});
|
|
11049
11109
|
function GetOrSet(ctx, state) {
|
|
11050
11110
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
11051
11111
|
}
|
|
11052
|
-
var Hash$0 = $TV($EXPECT($
|
|
11112
|
+
var Hash$0 = $TV($EXPECT($L146, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
11053
11113
|
return { $loc, token: $1 };
|
|
11054
11114
|
});
|
|
11055
11115
|
function Hash(ctx, state) {
|
|
11056
11116
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11057
11117
|
}
|
|
11058
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11118
|
+
var If$0 = $TV($TEXT($S($EXPECT($L147, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11059
11119
|
return { $loc, token: $1 };
|
|
11060
11120
|
});
|
|
11061
11121
|
function If(ctx, state) {
|
|
@@ -11067,25 +11127,25 @@ ${input.slice(result.pos)}
|
|
|
11067
11127
|
function Import(ctx, state) {
|
|
11068
11128
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11069
11129
|
}
|
|
11070
|
-
var In$0 = $TS($S($EXPECT($
|
|
11130
|
+
var In$0 = $TS($S($EXPECT($L148, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11071
11131
|
return { $loc, token: $1 };
|
|
11072
11132
|
});
|
|
11073
11133
|
function In(ctx, state) {
|
|
11074
11134
|
return $EVENT(ctx, state, "In", In$0);
|
|
11075
11135
|
}
|
|
11076
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11136
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L149, 'LetOrConst "let"'), $EXPECT($L150, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11077
11137
|
return { $loc, token: $1 };
|
|
11078
11138
|
});
|
|
11079
11139
|
function LetOrConst(ctx, state) {
|
|
11080
11140
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11081
11141
|
}
|
|
11082
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11142
|
+
var Const$0 = $TS($S($EXPECT($L150, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11083
11143
|
return { $loc, token: $1 };
|
|
11084
11144
|
});
|
|
11085
11145
|
function Const(ctx, state) {
|
|
11086
11146
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11087
11147
|
}
|
|
11088
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11148
|
+
var Is$0 = $TS($S($EXPECT($L151, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11089
11149
|
return { $loc, token: $1 };
|
|
11090
11150
|
});
|
|
11091
11151
|
function Is(ctx, state) {
|
|
@@ -11097,25 +11157,25 @@ ${input.slice(result.pos)}
|
|
|
11097
11157
|
function LetOrConstOrVar(ctx, state) {
|
|
11098
11158
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11099
11159
|
}
|
|
11100
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11160
|
+
var Loop$0 = $TS($S($EXPECT($L152, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11101
11161
|
return { $loc, token: "while(true)" };
|
|
11102
11162
|
});
|
|
11103
11163
|
function Loop(ctx, state) {
|
|
11104
11164
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11105
11165
|
}
|
|
11106
|
-
var New$0 = $TS($S($EXPECT($
|
|
11166
|
+
var New$0 = $TS($S($EXPECT($L153, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11107
11167
|
return { $loc, token: $1 };
|
|
11108
11168
|
});
|
|
11109
11169
|
function New(ctx, state) {
|
|
11110
11170
|
return $EVENT(ctx, state, "New", New$0);
|
|
11111
11171
|
}
|
|
11112
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11172
|
+
var Not$0 = $TS($S($EXPECT($L154, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11113
11173
|
return { $loc, token: "!" };
|
|
11114
11174
|
});
|
|
11115
11175
|
function Not(ctx, state) {
|
|
11116
11176
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11117
11177
|
}
|
|
11118
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11178
|
+
var Of$0 = $TS($S($EXPECT($L155, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11119
11179
|
return { $loc, token: $1 };
|
|
11120
11180
|
});
|
|
11121
11181
|
function Of(ctx, state) {
|
|
@@ -11133,7 +11193,7 @@ ${input.slice(result.pos)}
|
|
|
11133
11193
|
function OpenBrace(ctx, state) {
|
|
11134
11194
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
11135
11195
|
}
|
|
11136
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
11196
|
+
var OpenBracket$0 = $TV($EXPECT($L156, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
11137
11197
|
return { $loc, token: $1 };
|
|
11138
11198
|
});
|
|
11139
11199
|
function OpenBracket(ctx, state) {
|
|
@@ -11145,43 +11205,43 @@ ${input.slice(result.pos)}
|
|
|
11145
11205
|
function OpenParen(ctx, state) {
|
|
11146
11206
|
return $EVENT(ctx, state, "OpenParen", OpenParen$0);
|
|
11147
11207
|
}
|
|
11148
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
11208
|
+
var Operator$0 = $TS($S($EXPECT($L157, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11149
11209
|
return { $loc, token: $1 };
|
|
11150
11210
|
});
|
|
11151
11211
|
function Operator(ctx, state) {
|
|
11152
11212
|
return $EVENT(ctx, state, "Operator", Operator$0);
|
|
11153
11213
|
}
|
|
11154
|
-
var Own$0 = $TS($S($EXPECT($
|
|
11214
|
+
var Own$0 = $TS($S($EXPECT($L158, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11155
11215
|
return { $loc, token: $1 };
|
|
11156
11216
|
});
|
|
11157
11217
|
function Own(ctx, state) {
|
|
11158
11218
|
return $EVENT(ctx, state, "Own", Own$0);
|
|
11159
11219
|
}
|
|
11160
|
-
var Public$0 = $TS($S($EXPECT($
|
|
11220
|
+
var Public$0 = $TS($S($EXPECT($L159, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11161
11221
|
return { $loc, token: $1 };
|
|
11162
11222
|
});
|
|
11163
11223
|
function Public(ctx, state) {
|
|
11164
11224
|
return $EVENT(ctx, state, "Public", Public$0);
|
|
11165
11225
|
}
|
|
11166
|
-
var Private$0 = $TS($S($EXPECT($
|
|
11226
|
+
var Private$0 = $TS($S($EXPECT($L160, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11167
11227
|
return { $loc, token: $1 };
|
|
11168
11228
|
});
|
|
11169
11229
|
function Private(ctx, state) {
|
|
11170
11230
|
return $EVENT(ctx, state, "Private", Private$0);
|
|
11171
11231
|
}
|
|
11172
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
11232
|
+
var Protected$0 = $TS($S($EXPECT($L161, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11173
11233
|
return { $loc, token: $1 };
|
|
11174
11234
|
});
|
|
11175
11235
|
function Protected(ctx, state) {
|
|
11176
11236
|
return $EVENT(ctx, state, "Protected", Protected$0);
|
|
11177
11237
|
}
|
|
11178
|
-
var Pipe$0 = $TV($C($EXPECT($
|
|
11238
|
+
var Pipe$0 = $TV($C($EXPECT($L162, 'Pipe "||>"'), $EXPECT($L163, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11179
11239
|
return { $loc, token: "||>" };
|
|
11180
11240
|
});
|
|
11181
|
-
var Pipe$1 = $TV($C($EXPECT($
|
|
11241
|
+
var Pipe$1 = $TV($C($EXPECT($L164, 'Pipe "|>="'), $EXPECT($L165, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
|
|
11182
11242
|
return { $loc, token: "|>=" };
|
|
11183
11243
|
});
|
|
11184
|
-
var Pipe$2 = $TV($C($EXPECT($
|
|
11244
|
+
var Pipe$2 = $TV($C($EXPECT($L166, 'Pipe "|>"'), $EXPECT($L167, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11185
11245
|
return { $loc, token: "|>" };
|
|
11186
11246
|
});
|
|
11187
11247
|
var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
|
|
@@ -11194,19 +11254,19 @@ ${input.slice(result.pos)}
|
|
|
11194
11254
|
function QuestionMark(ctx, state) {
|
|
11195
11255
|
return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
|
|
11196
11256
|
}
|
|
11197
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
11257
|
+
var Readonly$0 = $TS($S($EXPECT($L168, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11198
11258
|
return { $loc, token: $1, ts: true };
|
|
11199
11259
|
});
|
|
11200
11260
|
function Readonly(ctx, state) {
|
|
11201
11261
|
return $EVENT(ctx, state, "Readonly", Readonly$0);
|
|
11202
11262
|
}
|
|
11203
|
-
var Return$0 = $TS($S($EXPECT($
|
|
11263
|
+
var Return$0 = $TS($S($EXPECT($L169, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11204
11264
|
return { $loc, token: $1 };
|
|
11205
11265
|
});
|
|
11206
11266
|
function Return(ctx, state) {
|
|
11207
11267
|
return $EVENT(ctx, state, "Return", Return$0);
|
|
11208
11268
|
}
|
|
11209
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
11269
|
+
var Satisfies$0 = $TS($S($EXPECT($L170, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11210
11270
|
return { $loc, token: $1 };
|
|
11211
11271
|
});
|
|
11212
11272
|
function Satisfies(ctx, state) {
|
|
@@ -11218,7 +11278,7 @@ ${input.slice(result.pos)}
|
|
|
11218
11278
|
function Semicolon(ctx, state) {
|
|
11219
11279
|
return $EVENT(ctx, state, "Semicolon", Semicolon$0);
|
|
11220
11280
|
}
|
|
11221
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
11281
|
+
var SingleQuote$0 = $TV($EXPECT($L171, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
11222
11282
|
return { $loc, token: $1 };
|
|
11223
11283
|
});
|
|
11224
11284
|
function SingleQuote(ctx, state) {
|
|
@@ -11230,137 +11290,137 @@ ${input.slice(result.pos)}
|
|
|
11230
11290
|
function Star(ctx, state) {
|
|
11231
11291
|
return $EVENT(ctx, state, "Star", Star$0);
|
|
11232
11292
|
}
|
|
11233
|
-
var Static$0 = $TS($S($EXPECT($
|
|
11293
|
+
var Static$0 = $TS($S($EXPECT($L172, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11234
11294
|
return { $loc, token: $1 };
|
|
11235
11295
|
});
|
|
11236
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11296
|
+
var Static$1 = $TS($S($EXPECT($L116, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L116, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11237
11297
|
return { $loc, token: "static " };
|
|
11238
11298
|
});
|
|
11239
11299
|
var Static$$ = [Static$0, Static$1];
|
|
11240
11300
|
function Static(ctx, state) {
|
|
11241
11301
|
return $EVENT_C(ctx, state, "Static", Static$$);
|
|
11242
11302
|
}
|
|
11243
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
11303
|
+
var SubstitutionStart$0 = $TV($EXPECT($L173, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
11244
11304
|
return { $loc, token: $1 };
|
|
11245
11305
|
});
|
|
11246
11306
|
function SubstitutionStart(ctx, state) {
|
|
11247
11307
|
return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
|
|
11248
11308
|
}
|
|
11249
|
-
var Super$0 = $TS($S($EXPECT($
|
|
11309
|
+
var Super$0 = $TS($S($EXPECT($L174, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11250
11310
|
return { $loc, token: $1 };
|
|
11251
11311
|
});
|
|
11252
11312
|
function Super(ctx, state) {
|
|
11253
11313
|
return $EVENT(ctx, state, "Super", Super$0);
|
|
11254
11314
|
}
|
|
11255
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
11315
|
+
var Switch$0 = $TS($S($EXPECT($L175, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11256
11316
|
return { $loc, token: $1 };
|
|
11257
11317
|
});
|
|
11258
11318
|
function Switch(ctx, state) {
|
|
11259
11319
|
return $EVENT(ctx, state, "Switch", Switch$0);
|
|
11260
11320
|
}
|
|
11261
|
-
var Target$0 = $TS($S($EXPECT($
|
|
11321
|
+
var Target$0 = $TS($S($EXPECT($L176, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11262
11322
|
return { $loc, token: $1 };
|
|
11263
11323
|
});
|
|
11264
11324
|
function Target(ctx, state) {
|
|
11265
11325
|
return $EVENT(ctx, state, "Target", Target$0);
|
|
11266
11326
|
}
|
|
11267
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
11327
|
+
var Then$0 = $TS($S(__, $EXPECT($L177, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
11268
11328
|
return { $loc, token: "" };
|
|
11269
11329
|
});
|
|
11270
11330
|
function Then(ctx, state) {
|
|
11271
11331
|
return $EVENT(ctx, state, "Then", Then$0);
|
|
11272
11332
|
}
|
|
11273
|
-
var This$0 = $TS($S($EXPECT($
|
|
11333
|
+
var This$0 = $TS($S($EXPECT($L178, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11274
11334
|
return { $loc, token: $1 };
|
|
11275
11335
|
});
|
|
11276
11336
|
function This(ctx, state) {
|
|
11277
11337
|
return $EVENT(ctx, state, "This", This$0);
|
|
11278
11338
|
}
|
|
11279
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
11339
|
+
var Throw$0 = $TS($S($EXPECT($L179, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11280
11340
|
return { $loc, token: $1 };
|
|
11281
11341
|
});
|
|
11282
11342
|
function Throw(ctx, state) {
|
|
11283
11343
|
return $EVENT(ctx, state, "Throw", Throw$0);
|
|
11284
11344
|
}
|
|
11285
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
11345
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L180, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11286
11346
|
return { $loc, token: "`" };
|
|
11287
11347
|
});
|
|
11288
11348
|
function TripleDoubleQuote(ctx, state) {
|
|
11289
11349
|
return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
|
|
11290
11350
|
}
|
|
11291
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
11351
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L181, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
11292
11352
|
return { $loc, token: "`" };
|
|
11293
11353
|
});
|
|
11294
11354
|
function TripleSingleQuote(ctx, state) {
|
|
11295
11355
|
return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
|
|
11296
11356
|
}
|
|
11297
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
11357
|
+
var TripleSlash$0 = $TV($EXPECT($L182, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
11298
11358
|
return { $loc, token: "/" };
|
|
11299
11359
|
});
|
|
11300
11360
|
function TripleSlash(ctx, state) {
|
|
11301
11361
|
return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
|
|
11302
11362
|
}
|
|
11303
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
11363
|
+
var TripleTick$0 = $TV($EXPECT($L183, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
11304
11364
|
return { $loc, token: "`" };
|
|
11305
11365
|
});
|
|
11306
11366
|
function TripleTick(ctx, state) {
|
|
11307
11367
|
return $EVENT(ctx, state, "TripleTick", TripleTick$0);
|
|
11308
11368
|
}
|
|
11309
|
-
var Try$0 = $TS($S($EXPECT($
|
|
11369
|
+
var Try$0 = $TS($S($EXPECT($L184, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11310
11370
|
return { $loc, token: $1 };
|
|
11311
11371
|
});
|
|
11312
11372
|
function Try(ctx, state) {
|
|
11313
11373
|
return $EVENT(ctx, state, "Try", Try$0);
|
|
11314
11374
|
}
|
|
11315
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
11375
|
+
var Typeof$0 = $TS($S($EXPECT($L185, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11316
11376
|
return { $loc, token: $1 };
|
|
11317
11377
|
});
|
|
11318
11378
|
function Typeof(ctx, state) {
|
|
11319
11379
|
return $EVENT(ctx, state, "Typeof", Typeof$0);
|
|
11320
11380
|
}
|
|
11321
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
11381
|
+
var Unless$0 = $TS($S($EXPECT($L186, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11322
11382
|
return { $loc, token: $1 };
|
|
11323
11383
|
});
|
|
11324
11384
|
function Unless(ctx, state) {
|
|
11325
11385
|
return $EVENT(ctx, state, "Unless", Unless$0);
|
|
11326
11386
|
}
|
|
11327
|
-
var Until$0 = $TS($S($EXPECT($
|
|
11387
|
+
var Until$0 = $TS($S($EXPECT($L187, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11328
11388
|
return { $loc, token: $1 };
|
|
11329
11389
|
});
|
|
11330
11390
|
function Until(ctx, state) {
|
|
11331
11391
|
return $EVENT(ctx, state, "Until", Until$0);
|
|
11332
11392
|
}
|
|
11333
|
-
var Using$0 = $TS($S($EXPECT($
|
|
11393
|
+
var Using$0 = $TS($S($EXPECT($L188, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11334
11394
|
return { $loc, token: $1 };
|
|
11335
11395
|
});
|
|
11336
11396
|
function Using(ctx, state) {
|
|
11337
11397
|
return $EVENT(ctx, state, "Using", Using$0);
|
|
11338
11398
|
}
|
|
11339
|
-
var Var$0 = $TS($S($EXPECT($
|
|
11399
|
+
var Var$0 = $TS($S($EXPECT($L189, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11340
11400
|
return { $loc, token: $1 };
|
|
11341
11401
|
});
|
|
11342
11402
|
function Var(ctx, state) {
|
|
11343
11403
|
return $EVENT(ctx, state, "Var", Var$0);
|
|
11344
11404
|
}
|
|
11345
|
-
var Void$0 = $TS($S($EXPECT($
|
|
11405
|
+
var Void$0 = $TS($S($EXPECT($L190, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11346
11406
|
return { $loc, token: $1 };
|
|
11347
11407
|
});
|
|
11348
11408
|
function Void(ctx, state) {
|
|
11349
11409
|
return $EVENT(ctx, state, "Void", Void$0);
|
|
11350
11410
|
}
|
|
11351
|
-
var When$0 = $TS($S($EXPECT($
|
|
11411
|
+
var When$0 = $TS($S($EXPECT($L191, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11352
11412
|
return { $loc, token: "case" };
|
|
11353
11413
|
});
|
|
11354
11414
|
function When(ctx, state) {
|
|
11355
11415
|
return $EVENT(ctx, state, "When", When$0);
|
|
11356
11416
|
}
|
|
11357
|
-
var While$0 = $TS($S($EXPECT($
|
|
11417
|
+
var While$0 = $TS($S($EXPECT($L192, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11358
11418
|
return { $loc, token: $1 };
|
|
11359
11419
|
});
|
|
11360
11420
|
function While(ctx, state) {
|
|
11361
11421
|
return $EVENT(ctx, state, "While", While$0);
|
|
11362
11422
|
}
|
|
11363
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
11423
|
+
var Yield$0 = $TS($S($EXPECT($L193, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11364
11424
|
return { $loc, token: $1, type: "Yield" };
|
|
11365
11425
|
});
|
|
11366
11426
|
function Yield(ctx, state) {
|
|
@@ -11439,7 +11499,7 @@ ${input.slice(result.pos)}
|
|
|
11439
11499
|
function JSXElement(ctx, state) {
|
|
11440
11500
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
11441
11501
|
}
|
|
11442
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L13, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($
|
|
11502
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L13, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L194, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
11443
11503
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
11444
11504
|
});
|
|
11445
11505
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -11473,7 +11533,7 @@ ${input.slice(result.pos)}
|
|
|
11473
11533
|
function JSXOptionalClosingElement(ctx, state) {
|
|
11474
11534
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
11475
11535
|
}
|
|
11476
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
11536
|
+
var JSXClosingElement$0 = $S($EXPECT($L195, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L34, 'JSXClosingElement ">"'));
|
|
11477
11537
|
function JSXClosingElement(ctx, state) {
|
|
11478
11538
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
11479
11539
|
}
|
|
@@ -11494,7 +11554,7 @@ ${input.slice(result.pos)}
|
|
|
11494
11554
|
];
|
|
11495
11555
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
11496
11556
|
});
|
|
11497
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
11557
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L196, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
11498
11558
|
var children = $3;
|
|
11499
11559
|
$0 = $0.slice(1);
|
|
11500
11560
|
return {
|
|
@@ -11507,7 +11567,7 @@ ${input.slice(result.pos)}
|
|
|
11507
11567
|
function JSXFragment(ctx, state) {
|
|
11508
11568
|
return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
|
|
11509
11569
|
}
|
|
11510
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
11570
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L196, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
11511
11571
|
module.JSXTagStack.push("");
|
|
11512
11572
|
return $1;
|
|
11513
11573
|
});
|
|
@@ -11524,11 +11584,11 @@ ${input.slice(result.pos)}
|
|
|
11524
11584
|
function JSXOptionalClosingFragment(ctx, state) {
|
|
11525
11585
|
return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
|
|
11526
11586
|
}
|
|
11527
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
11587
|
+
var JSXClosingFragment$0 = $EXPECT($L197, 'JSXClosingFragment "</>"');
|
|
11528
11588
|
function JSXClosingFragment(ctx, state) {
|
|
11529
11589
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11530
11590
|
}
|
|
11531
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11591
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L146, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11532
11592
|
return module.config.defaultElement;
|
|
11533
11593
|
});
|
|
11534
11594
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11700,7 +11760,7 @@ ${input.slice(result.pos)}
|
|
|
11700
11760
|
}
|
|
11701
11761
|
return $skip;
|
|
11702
11762
|
});
|
|
11703
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11763
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L146, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11704
11764
|
return [" ", "id=", $2];
|
|
11705
11765
|
});
|
|
11706
11766
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11993,7 +12053,7 @@ ${input.slice(result.pos)}
|
|
|
11993
12053
|
function JSXChild(ctx, state) {
|
|
11994
12054
|
return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
|
|
11995
12055
|
}
|
|
11996
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
12056
|
+
var JSXComment$0 = $TS($S($EXPECT($L198, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L199, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
11997
12057
|
return ["{/*", $2, "*/}"];
|
|
11998
12058
|
});
|
|
11999
12059
|
function JSXComment(ctx, state) {
|
|
@@ -12125,37 +12185,37 @@ ${input.slice(result.pos)}
|
|
|
12125
12185
|
function InterfaceExtendsTarget(ctx, state) {
|
|
12126
12186
|
return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
|
|
12127
12187
|
}
|
|
12128
|
-
var TypeKeyword$0 = $TS($S($EXPECT($
|
|
12188
|
+
var TypeKeyword$0 = $TS($S($EXPECT($L200, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12129
12189
|
return { $loc, token: $1 };
|
|
12130
12190
|
});
|
|
12131
12191
|
function TypeKeyword(ctx, state) {
|
|
12132
12192
|
return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
|
|
12133
12193
|
}
|
|
12134
|
-
var Enum$0 = $TS($S($EXPECT($
|
|
12194
|
+
var Enum$0 = $TS($S($EXPECT($L201, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12135
12195
|
return { $loc, token: $1 };
|
|
12136
12196
|
});
|
|
12137
12197
|
function Enum(ctx, state) {
|
|
12138
12198
|
return $EVENT(ctx, state, "Enum", Enum$0);
|
|
12139
12199
|
}
|
|
12140
|
-
var Interface$0 = $TS($S($EXPECT($
|
|
12200
|
+
var Interface$0 = $TS($S($EXPECT($L202, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12141
12201
|
return { $loc, token: $1 };
|
|
12142
12202
|
});
|
|
12143
12203
|
function Interface(ctx, state) {
|
|
12144
12204
|
return $EVENT(ctx, state, "Interface", Interface$0);
|
|
12145
12205
|
}
|
|
12146
|
-
var Global$0 = $TS($S($EXPECT($
|
|
12206
|
+
var Global$0 = $TS($S($EXPECT($L203, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12147
12207
|
return { $loc, token: $1 };
|
|
12148
12208
|
});
|
|
12149
12209
|
function Global(ctx, state) {
|
|
12150
12210
|
return $EVENT(ctx, state, "Global", Global$0);
|
|
12151
12211
|
}
|
|
12152
|
-
var Module$0 = $TS($S($EXPECT($
|
|
12212
|
+
var Module$0 = $TS($S($EXPECT($L204, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12153
12213
|
return { $loc, token: $1 };
|
|
12154
12214
|
});
|
|
12155
12215
|
function Module(ctx, state) {
|
|
12156
12216
|
return $EVENT(ctx, state, "Module", Module$0);
|
|
12157
12217
|
}
|
|
12158
|
-
var Namespace$0 = $TS($S($EXPECT($
|
|
12218
|
+
var Namespace$0 = $TS($S($EXPECT($L205, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12159
12219
|
return { $loc, token: $1 };
|
|
12160
12220
|
});
|
|
12161
12221
|
function Namespace(ctx, state) {
|
|
@@ -12400,7 +12460,7 @@ ${input.slice(result.pos)}
|
|
|
12400
12460
|
function ReturnTypeSuffix(ctx, state) {
|
|
12401
12461
|
return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
|
|
12402
12462
|
}
|
|
12403
|
-
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($
|
|
12463
|
+
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L206, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
|
|
12404
12464
|
var asserts = $1;
|
|
12405
12465
|
var t = $2;
|
|
12406
12466
|
if (asserts) {
|
|
@@ -12421,7 +12481,7 @@ ${input.slice(result.pos)}
|
|
|
12421
12481
|
function ReturnType(ctx, state) {
|
|
12422
12482
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
12423
12483
|
}
|
|
12424
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12484
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L151, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
12425
12485
|
var lhs = $1;
|
|
12426
12486
|
var rhs = $2;
|
|
12427
12487
|
if (!rhs)
|
|
@@ -12469,10 +12529,10 @@ ${input.slice(result.pos)}
|
|
|
12469
12529
|
function TypeUnarySuffix(ctx, state) {
|
|
12470
12530
|
return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
|
|
12471
12531
|
}
|
|
12472
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
12473
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
12474
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
12475
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
12532
|
+
var TypeUnaryOp$0 = $S($EXPECT($L207, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
12533
|
+
var TypeUnaryOp$1 = $S($EXPECT($L185, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
12534
|
+
var TypeUnaryOp$2 = $S($EXPECT($L208, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
12535
|
+
var TypeUnaryOp$3 = $S($EXPECT($L168, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
12476
12536
|
var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1, TypeUnaryOp$2, TypeUnaryOp$3];
|
|
12477
12537
|
function TypeUnaryOp(ctx, state) {
|
|
12478
12538
|
return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
|
|
@@ -12481,7 +12541,7 @@ ${input.slice(result.pos)}
|
|
|
12481
12541
|
function TypeIndexedAccess(ctx, state) {
|
|
12482
12542
|
return $EVENT(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$0);
|
|
12483
12543
|
}
|
|
12484
|
-
var UnknownAlias$0 = $TV($EXPECT($
|
|
12544
|
+
var UnknownAlias$0 = $TV($EXPECT($L209, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
|
|
12485
12545
|
return { $loc, token: "unknown" };
|
|
12486
12546
|
});
|
|
12487
12547
|
function UnknownAlias(ctx, state) {
|
|
@@ -12583,7 +12643,7 @@ ${input.slice(result.pos)}
|
|
|
12583
12643
|
function NestedType(ctx, state) {
|
|
12584
12644
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12585
12645
|
}
|
|
12586
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12646
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L139, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
12587
12647
|
if ($2)
|
|
12588
12648
|
return $0;
|
|
12589
12649
|
return $1;
|
|
@@ -12621,10 +12681,10 @@ ${input.slice(result.pos)}
|
|
|
12621
12681
|
}
|
|
12622
12682
|
var TypeLiteral$0 = TypeTemplateLiteral;
|
|
12623
12683
|
var TypeLiteral$1 = Literal;
|
|
12624
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
12684
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L190, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12625
12685
|
return { type: "VoidType", $loc, token: $1 };
|
|
12626
12686
|
});
|
|
12627
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
12687
|
+
var TypeLiteral$3 = $TV($EXPECT($L210, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
12628
12688
|
return { $loc, token: "[]" };
|
|
12629
12689
|
});
|
|
12630
12690
|
var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
|
|
@@ -12643,7 +12703,7 @@ ${input.slice(result.pos)}
|
|
|
12643
12703
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12644
12704
|
return value[1];
|
|
12645
12705
|
});
|
|
12646
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
12706
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L113, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L35, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L26, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12647
12707
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12648
12708
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12649
12709
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
@@ -12707,11 +12767,11 @@ ${input.slice(result.pos)}
|
|
|
12707
12767
|
function TypeParameters(ctx, state) {
|
|
12708
12768
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12709
12769
|
}
|
|
12710
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12770
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L150, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12711
12771
|
function TypeParameter(ctx, state) {
|
|
12712
12772
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12713
12773
|
}
|
|
12714
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12774
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L139, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12715
12775
|
function TypeConstraint(ctx, state) {
|
|
12716
12776
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12717
12777
|
}
|
|
@@ -12750,7 +12810,7 @@ ${input.slice(result.pos)}
|
|
|
12750
12810
|
function CivetPrologue(ctx, state) {
|
|
12751
12811
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12752
12812
|
}
|
|
12753
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
12813
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L211, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R82, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12754
12814
|
var options = $3;
|
|
12755
12815
|
return {
|
|
12756
12816
|
type: "CivetPrologue",
|