@danielx/civet 0.6.72 → 0.6.74
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 +487 -432
- package/dist/civet +0 -0
- package/dist/main.js +487 -432
- package/dist/main.mjs +487 -432
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -1251,15 +1251,15 @@ var Civet = (() => {
|
|
|
1251
1251
|
}
|
|
1252
1252
|
function insertHoistDec(block, node, dec) {
|
|
1253
1253
|
const { expressions } = block;
|
|
1254
|
-
const index = expressions.findIndex((exp) =>
|
|
1255
|
-
|
|
1254
|
+
const index = expressions.findIndex((exp) => {
|
|
1255
|
+
return exp === node || Array.isArray(exp) && exp[1] === node;
|
|
1256
|
+
});
|
|
1257
|
+
if (index < 0) {
|
|
1256
1258
|
throw new Error("Couldn't find expression in block for hoistable declaration.");
|
|
1257
|
-
if (expressions[index] === node) {
|
|
1258
|
-
expressions.splice(index, 0, ["", dec, ";"]);
|
|
1259
|
-
} else {
|
|
1260
|
-
const indent = expressions[index][0];
|
|
1261
|
-
expressions.splice(index, 0, [indent, dec, ";"]);
|
|
1262
1259
|
}
|
|
1260
|
+
const statement = [expressions[index][0], dec, ";"];
|
|
1261
|
+
expressions[index][0] = "";
|
|
1262
|
+
expressions.splice(index, 0, statement);
|
|
1263
1263
|
addParentPointers(dec, block);
|
|
1264
1264
|
}
|
|
1265
1265
|
function patternAsValue(pattern) {
|
|
@@ -1425,6 +1425,9 @@ var Civet = (() => {
|
|
|
1425
1425
|
function isGeneratorVoidType(t) {
|
|
1426
1426
|
return t?.type === "IdentifierType" && (t.raw === "Iterator" || t.raw === "Generator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
|
|
1427
1427
|
}
|
|
1428
|
+
function isAsyncGeneratorVoidType(t) {
|
|
1429
|
+
return t?.type === "IdentifierType" && (t.raw === "AsyncIterator" || t.raw === "AsyncGenerator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
|
|
1430
|
+
}
|
|
1428
1431
|
function isWhitespaceOrEmpty(node) {
|
|
1429
1432
|
if (!node)
|
|
1430
1433
|
return true;
|
|
@@ -1827,6 +1830,7 @@ var Civet = (() => {
|
|
|
1827
1830
|
case "IterationExpression":
|
|
1828
1831
|
case "CallExpression":
|
|
1829
1832
|
case "MemberExpression":
|
|
1833
|
+
case "NewExpression":
|
|
1830
1834
|
case "ParenthesizedExpression":
|
|
1831
1835
|
case "IfExpression":
|
|
1832
1836
|
case "DebuggerExpression":
|
|
@@ -1874,6 +1878,9 @@ var Civet = (() => {
|
|
|
1874
1878
|
}
|
|
1875
1879
|
}
|
|
1876
1880
|
function lastAccessInCallExpression(exp) {
|
|
1881
|
+
if (exp.type === "Identifier") {
|
|
1882
|
+
return exp;
|
|
1883
|
+
}
|
|
1877
1884
|
let children, i;
|
|
1878
1885
|
do {
|
|
1879
1886
|
({ children } = exp);
|
|
@@ -2261,10 +2268,18 @@ var Civet = (() => {
|
|
|
2261
2268
|
const { async, generator, set } = modifier;
|
|
2262
2269
|
const isMethod = f.type === "MethodDefinition";
|
|
2263
2270
|
const isConstructor = isMethod && name === "constructor";
|
|
2264
|
-
const isVoid = isVoidType(returnType2?.t) || async && isPromiseVoidType(returnType2?.t) || !async && generator && isGeneratorVoidType(returnType2?.t);
|
|
2265
|
-
|
|
2266
|
-
|
|
2267
|
-
|
|
2271
|
+
const isVoid = isVoidType(returnType2?.t) || async && (isPromiseVoidType(returnType2?.t) || generator && isAsyncGeneratorVoidType(returnType2?.t)) || !async && generator && isGeneratorVoidType(returnType2?.t);
|
|
2272
|
+
if (block?.type === "BlockStatement") {
|
|
2273
|
+
if (isVoid || set || isConstructor) {
|
|
2274
|
+
if (block.bare && block.implicitlyReturned) {
|
|
2275
|
+
block.children = [" {", ...block.children, " }"];
|
|
2276
|
+
block.bare = block.implicitlyReturned = false;
|
|
2277
|
+
}
|
|
2278
|
+
} else {
|
|
2279
|
+
if (!block.implicitlyReturned) {
|
|
2280
|
+
insertReturn(block);
|
|
2281
|
+
}
|
|
2282
|
+
}
|
|
2268
2283
|
}
|
|
2269
2284
|
}
|
|
2270
2285
|
}
|
|
@@ -2671,8 +2686,8 @@ var Civet = (() => {
|
|
|
2671
2686
|
}
|
|
2672
2687
|
}
|
|
2673
2688
|
function aggregateDuplicateBindings(bindings, ReservedWord) {
|
|
2674
|
-
const props = gatherRecursiveAll(bindings, (
|
|
2675
|
-
const arrayBindings = gatherRecursiveAll(bindings, (
|
|
2689
|
+
const props = gatherRecursiveAll(bindings, ($3) => $3.type === "BindingProperty");
|
|
2690
|
+
const arrayBindings = gatherRecursiveAll(bindings, ($4) => $4.type === "ArrayBindingPattern");
|
|
2676
2691
|
arrayBindings.forEach((a) => {
|
|
2677
2692
|
const { elements } = a;
|
|
2678
2693
|
return elements.forEach((element) => {
|
|
@@ -2702,20 +2717,22 @@ var Civet = (() => {
|
|
|
2702
2717
|
}
|
|
2703
2718
|
}
|
|
2704
2719
|
propsGroupedByName.forEach((shared, key) => {
|
|
2705
|
-
if (!key)
|
|
2720
|
+
if (!key) {
|
|
2706
2721
|
return;
|
|
2722
|
+
}
|
|
2707
2723
|
if (ReservedWord({ fail() {
|
|
2708
2724
|
} }, {
|
|
2709
2725
|
pos: 0,
|
|
2710
2726
|
input: key
|
|
2711
2727
|
})) {
|
|
2712
|
-
shared.forEach((p) =>
|
|
2713
|
-
|
|
2714
|
-
})
|
|
2728
|
+
shared.forEach((p) => {
|
|
2729
|
+
return aliasBinding(p, makeRef(`_${key}`, key));
|
|
2730
|
+
});
|
|
2715
2731
|
return;
|
|
2716
2732
|
}
|
|
2717
|
-
if (shared.length === 1)
|
|
2733
|
+
if (shared.length === 1) {
|
|
2718
2734
|
return;
|
|
2735
|
+
}
|
|
2719
2736
|
const refs = shared.map((p) => {
|
|
2720
2737
|
const ref = makeRef(key);
|
|
2721
2738
|
aliasBinding(p, ref);
|
|
@@ -2728,7 +2745,7 @@ var Civet = (() => {
|
|
|
2728
2745
|
return declarations;
|
|
2729
2746
|
}
|
|
2730
2747
|
function processPatternMatching(statements, ReservedWord) {
|
|
2731
|
-
gatherRecursiveAll(statements, (
|
|
2748
|
+
gatherRecursiveAll(statements, ($5) => $5.type === "SwitchStatement").forEach((s) => {
|
|
2732
2749
|
const { caseBlock } = s;
|
|
2733
2750
|
const { clauses } = caseBlock;
|
|
2734
2751
|
for (const c of clauses) {
|
|
@@ -2742,7 +2759,7 @@ var Civet = (() => {
|
|
|
2742
2759
|
}
|
|
2743
2760
|
let errors = false;
|
|
2744
2761
|
let isPattern = false;
|
|
2745
|
-
if (clauses.some((
|
|
2762
|
+
if (clauses.some(($6) => $6.type === "PatternClause")) {
|
|
2746
2763
|
isPattern = true;
|
|
2747
2764
|
clauses.forEach((c) => {
|
|
2748
2765
|
if (!(c.type === "PatternClause" || c.type === "DefaultClause")) {
|
|
@@ -2756,8 +2773,9 @@ var Civet = (() => {
|
|
|
2756
2773
|
return;
|
|
2757
2774
|
});
|
|
2758
2775
|
}
|
|
2759
|
-
if (errors || !isPattern)
|
|
2776
|
+
if (errors || !isPattern) {
|
|
2760
2777
|
return;
|
|
2778
|
+
}
|
|
2761
2779
|
let { condition } = s;
|
|
2762
2780
|
if (condition.type === "ParenthesizedExpression") {
|
|
2763
2781
|
condition = condition.expression;
|
|
@@ -2969,7 +2987,7 @@ var Civet = (() => {
|
|
|
2969
2987
|
};
|
|
2970
2988
|
}
|
|
2971
2989
|
children.push(arg);
|
|
2972
|
-
if (!children.some(($
|
|
2990
|
+
if (!children.some(($7) => $7?.type === "ReturnStatement") && children.some(($8) => $8 === ",")) {
|
|
2973
2991
|
const { parent } = s;
|
|
2974
2992
|
const parenthesizedExpression = makeLeftHandSideExpression({ ...s });
|
|
2975
2993
|
Object.assign(s, parenthesizedExpression, {
|
|
@@ -3092,7 +3110,7 @@ var Civet = (() => {
|
|
|
3092
3110
|
scopes.push(decs);
|
|
3093
3111
|
const varIds = [];
|
|
3094
3112
|
const assignmentStatements = findAssignments(statements, scopes);
|
|
3095
|
-
const undeclaredIdentifiers = assignmentStatements.flatMap((
|
|
3113
|
+
const undeclaredIdentifiers = assignmentStatements.flatMap(($9) => $9?.names || []);
|
|
3096
3114
|
undeclaredIdentifiers.filter((x, i, a) => {
|
|
3097
3115
|
if (!hasDec(x))
|
|
3098
3116
|
return a.indexOf(x) === i;
|
|
@@ -3398,7 +3416,8 @@ var Civet = (() => {
|
|
|
3398
3416
|
];
|
|
3399
3417
|
}
|
|
3400
3418
|
if (Array.isArray(rest.delim) && rest.delim.at(-1)?.token === ",") {
|
|
3401
|
-
rest.delim.
|
|
3419
|
+
rest.delim = rest.delim.slice(0, -1);
|
|
3420
|
+
rest.children = [...rest.children.slice(0, -1), rest.delim];
|
|
3402
3421
|
}
|
|
3403
3422
|
const children = [...props, ...after, rest];
|
|
3404
3423
|
return {
|
|
@@ -4143,6 +4162,7 @@ ${input.slice(result.pos)}
|
|
|
4143
4162
|
ArrowFunction,
|
|
4144
4163
|
FatArrow,
|
|
4145
4164
|
TrailingDeclaration,
|
|
4165
|
+
TrailingPipe,
|
|
4146
4166
|
FatArrowBody,
|
|
4147
4167
|
ConditionalExpression,
|
|
4148
4168
|
TernaryRest,
|
|
@@ -4468,6 +4488,7 @@ ${input.slice(result.pos)}
|
|
|
4468
4488
|
LexicalDeclaration,
|
|
4469
4489
|
ConstAssignment,
|
|
4470
4490
|
LetAssignment,
|
|
4491
|
+
TypeAssignment,
|
|
4471
4492
|
LexicalBinding,
|
|
4472
4493
|
Initializer,
|
|
4473
4494
|
VariableStatement,
|
|
@@ -4743,7 +4764,7 @@ ${input.slice(result.pos)}
|
|
|
4743
4764
|
InlineBasicInterfaceProperty,
|
|
4744
4765
|
InlineInterfacePropertyDelimiter,
|
|
4745
4766
|
TypeBinaryOp,
|
|
4746
|
-
|
|
4767
|
+
TypeFunction,
|
|
4747
4768
|
TypeArrowFunction,
|
|
4748
4769
|
TypeArguments,
|
|
4749
4770
|
TypeArgument,
|
|
@@ -4785,6 +4806,7 @@ ${input.slice(result.pos)}
|
|
|
4785
4806
|
InsertDot,
|
|
4786
4807
|
InsertBreak,
|
|
4787
4808
|
InsertVar,
|
|
4809
|
+
InsertType,
|
|
4788
4810
|
CoffeeBinaryExistentialEnabled,
|
|
4789
4811
|
CoffeeBooleansEnabled,
|
|
4790
4812
|
CoffeeClassesEnabled,
|
|
@@ -4925,108 +4947,109 @@ ${input.slice(result.pos)}
|
|
|
4925
4947
|
var $L111 = $L(":=");
|
|
4926
4948
|
var $L112 = $L("\u2254");
|
|
4927
4949
|
var $L113 = $L(".=");
|
|
4928
|
-
var $L114 = $L("
|
|
4929
|
-
var $L115 = $L("
|
|
4930
|
-
var $L116 = $L("
|
|
4931
|
-
var $L117 = $L("
|
|
4932
|
-
var $L118 = $L("
|
|
4933
|
-
var $L119 = $L("
|
|
4934
|
-
var $L120 = $L("
|
|
4935
|
-
var $L121 = $L("
|
|
4936
|
-
var $L122 = $L("
|
|
4937
|
-
var $L123 = $L("
|
|
4938
|
-
var $L124 = $L("
|
|
4939
|
-
var $L125 = $L("
|
|
4940
|
-
var $L126 = $L("
|
|
4941
|
-
var $L127 = $L("
|
|
4942
|
-
var $L128 = $L("
|
|
4943
|
-
var $L129 = $L("
|
|
4944
|
-
var $L130 = $L("
|
|
4945
|
-
var $L131 = $L("
|
|
4946
|
-
var $L132 = $L("
|
|
4947
|
-
var $L133 = $L("
|
|
4948
|
-
var $L134 = $L("
|
|
4949
|
-
var $L135 = $L("
|
|
4950
|
-
var $L136 = $L("
|
|
4951
|
-
var $L137 = $L("
|
|
4952
|
-
var $L138 = $L("
|
|
4953
|
-
var $L139 = $L(
|
|
4954
|
-
var $L140 = $L("
|
|
4955
|
-
var $L141 = $L("
|
|
4956
|
-
var $L142 = $L("
|
|
4957
|
-
var $L143 = $L("
|
|
4958
|
-
var $L144 = $L("
|
|
4959
|
-
var $L145 = $L("
|
|
4960
|
-
var $L146 = $L("
|
|
4961
|
-
var $L147 = $L("
|
|
4962
|
-
var $L148 = $L("
|
|
4963
|
-
var $L149 = $L("
|
|
4964
|
-
var $L150 = $L("
|
|
4965
|
-
var $L151 = $L("
|
|
4966
|
-
var $L152 = $L("
|
|
4967
|
-
var $L153 = $L("
|
|
4968
|
-
var $L154 = $L("
|
|
4969
|
-
var $L155 = $L("
|
|
4970
|
-
var $L156 = $L("
|
|
4971
|
-
var $L157 = $L("
|
|
4972
|
-
var $L158 = $L("
|
|
4973
|
-
var $L159 = $L("
|
|
4974
|
-
var $L160 = $L("
|
|
4975
|
-
var $L161 = $L("
|
|
4976
|
-
var $L162 = $L("
|
|
4977
|
-
var $L163 = $L("
|
|
4978
|
-
var $L164 = $L("
|
|
4979
|
-
var $L165 = $L("
|
|
4980
|
-
var $L166 = $L("
|
|
4981
|
-
var $L167 = $L("
|
|
4982
|
-
var $L168 = $L("
|
|
4983
|
-
var $L169 = $L("
|
|
4984
|
-
var $L170 = $L("
|
|
4985
|
-
var $L171 = $L("
|
|
4986
|
-
var $L172 = $L("
|
|
4987
|
-
var $L173 = $L("
|
|
4988
|
-
var $L174 = $L("
|
|
4989
|
-
var $L175 = $L("
|
|
4990
|
-
var $L176 = $L("
|
|
4991
|
-
var $L177 = $L("
|
|
4992
|
-
var $L178 = $L("
|
|
4993
|
-
var $L179 = $L("
|
|
4994
|
-
var $L180 = $L("
|
|
4995
|
-
var $L181 = $L("
|
|
4996
|
-
var $L182 = $L("
|
|
4997
|
-
var $L183 = $L("
|
|
4998
|
-
var $L184 = $L("
|
|
4999
|
-
var $L185 = $L(
|
|
5000
|
-
var $L186 = $L("'
|
|
5001
|
-
var $L187 = $L("
|
|
5002
|
-
var $L188 = $L("
|
|
5003
|
-
var $L189 = $L("
|
|
5004
|
-
var $L190 = $L("
|
|
5005
|
-
var $L191 = $L("
|
|
5006
|
-
var $L192 = $L("
|
|
5007
|
-
var $L193 = $L("
|
|
5008
|
-
var $L194 = $L("
|
|
5009
|
-
var $L195 = $L("
|
|
5010
|
-
var $L196 = $L("
|
|
5011
|
-
var $L197 = $L("
|
|
5012
|
-
var $L198 = $L("
|
|
5013
|
-
var $L199 = $L("
|
|
5014
|
-
var $L200 = $L("
|
|
5015
|
-
var $L201 = $L("
|
|
5016
|
-
var $L202 = $L("
|
|
5017
|
-
var $L203 = $L("
|
|
5018
|
-
var $L204 = $L("
|
|
5019
|
-
var $L205 = $L("
|
|
5020
|
-
var $L206 = $L("
|
|
5021
|
-
var $L207 = $L("
|
|
5022
|
-
var $L208 = $L("
|
|
5023
|
-
var $L209 = $L("
|
|
5024
|
-
var $L210 = $L("
|
|
5025
|
-
var $L211 = $L("
|
|
5026
|
-
var $L212 = $L("
|
|
5027
|
-
var $L213 = $L("
|
|
5028
|
-
var $L214 = $L("
|
|
5029
|
-
var $L215 = $L("
|
|
4950
|
+
var $L114 = $L("::=");
|
|
4951
|
+
var $L115 = $L("/*");
|
|
4952
|
+
var $L116 = $L("*/");
|
|
4953
|
+
var $L117 = $L("\\");
|
|
4954
|
+
var $L118 = $L(")");
|
|
4955
|
+
var $L119 = $L("abstract");
|
|
4956
|
+
var $L120 = $L("as");
|
|
4957
|
+
var $L121 = $L("@");
|
|
4958
|
+
var $L122 = $L("@@");
|
|
4959
|
+
var $L123 = $L("async");
|
|
4960
|
+
var $L124 = $L("await");
|
|
4961
|
+
var $L125 = $L("`");
|
|
4962
|
+
var $L126 = $L("by");
|
|
4963
|
+
var $L127 = $L("case");
|
|
4964
|
+
var $L128 = $L("catch");
|
|
4965
|
+
var $L129 = $L("class");
|
|
4966
|
+
var $L130 = $L("#{");
|
|
4967
|
+
var $L131 = $L("declare");
|
|
4968
|
+
var $L132 = $L("default");
|
|
4969
|
+
var $L133 = $L("delete");
|
|
4970
|
+
var $L134 = $L("do");
|
|
4971
|
+
var $L135 = $L("..");
|
|
4972
|
+
var $L136 = $L("\u2025");
|
|
4973
|
+
var $L137 = $L("...");
|
|
4974
|
+
var $L138 = $L("\u2026");
|
|
4975
|
+
var $L139 = $L("::");
|
|
4976
|
+
var $L140 = $L('"');
|
|
4977
|
+
var $L141 = $L("each");
|
|
4978
|
+
var $L142 = $L("else");
|
|
4979
|
+
var $L143 = $L("export");
|
|
4980
|
+
var $L144 = $L("extends");
|
|
4981
|
+
var $L145 = $L("finally");
|
|
4982
|
+
var $L146 = $L("for");
|
|
4983
|
+
var $L147 = $L("from");
|
|
4984
|
+
var $L148 = $L("function");
|
|
4985
|
+
var $L149 = $L("get");
|
|
4986
|
+
var $L150 = $L("set");
|
|
4987
|
+
var $L151 = $L("#");
|
|
4988
|
+
var $L152 = $L("if");
|
|
4989
|
+
var $L153 = $L("in");
|
|
4990
|
+
var $L154 = $L("infer");
|
|
4991
|
+
var $L155 = $L("let");
|
|
4992
|
+
var $L156 = $L("const");
|
|
4993
|
+
var $L157 = $L("is");
|
|
4994
|
+
var $L158 = $L("loop");
|
|
4995
|
+
var $L159 = $L("new");
|
|
4996
|
+
var $L160 = $L("not");
|
|
4997
|
+
var $L161 = $L("of");
|
|
4998
|
+
var $L162 = $L("[");
|
|
4999
|
+
var $L163 = $L("operator");
|
|
5000
|
+
var $L164 = $L("own");
|
|
5001
|
+
var $L165 = $L("public");
|
|
5002
|
+
var $L166 = $L("private");
|
|
5003
|
+
var $L167 = $L("protected");
|
|
5004
|
+
var $L168 = $L("||>");
|
|
5005
|
+
var $L169 = $L("|\u25B7");
|
|
5006
|
+
var $L170 = $L("|>=");
|
|
5007
|
+
var $L171 = $L("\u25B7=");
|
|
5008
|
+
var $L172 = $L("|>");
|
|
5009
|
+
var $L173 = $L("\u25B7");
|
|
5010
|
+
var $L174 = $L("readonly");
|
|
5011
|
+
var $L175 = $L("return");
|
|
5012
|
+
var $L176 = $L("satisfies");
|
|
5013
|
+
var $L177 = $L("'");
|
|
5014
|
+
var $L178 = $L("static");
|
|
5015
|
+
var $L179 = $L("${");
|
|
5016
|
+
var $L180 = $L("super");
|
|
5017
|
+
var $L181 = $L("switch");
|
|
5018
|
+
var $L182 = $L("target");
|
|
5019
|
+
var $L183 = $L("then");
|
|
5020
|
+
var $L184 = $L("this");
|
|
5021
|
+
var $L185 = $L("throw");
|
|
5022
|
+
var $L186 = $L('"""');
|
|
5023
|
+
var $L187 = $L("'''");
|
|
5024
|
+
var $L188 = $L("///");
|
|
5025
|
+
var $L189 = $L("```");
|
|
5026
|
+
var $L190 = $L("try");
|
|
5027
|
+
var $L191 = $L("typeof");
|
|
5028
|
+
var $L192 = $L("unless");
|
|
5029
|
+
var $L193 = $L("until");
|
|
5030
|
+
var $L194 = $L("using");
|
|
5031
|
+
var $L195 = $L("var");
|
|
5032
|
+
var $L196 = $L("void");
|
|
5033
|
+
var $L197 = $L("when");
|
|
5034
|
+
var $L198 = $L("while");
|
|
5035
|
+
var $L199 = $L("yield");
|
|
5036
|
+
var $L200 = $L("/>");
|
|
5037
|
+
var $L201 = $L("</");
|
|
5038
|
+
var $L202 = $L("<>");
|
|
5039
|
+
var $L203 = $L("</>");
|
|
5040
|
+
var $L204 = $L("<!--");
|
|
5041
|
+
var $L205 = $L("-->");
|
|
5042
|
+
var $L206 = $L("type");
|
|
5043
|
+
var $L207 = $L("enum");
|
|
5044
|
+
var $L208 = $L("interface");
|
|
5045
|
+
var $L209 = $L("global");
|
|
5046
|
+
var $L210 = $L("module");
|
|
5047
|
+
var $L211 = $L("namespace");
|
|
5048
|
+
var $L212 = $L("asserts");
|
|
5049
|
+
var $L213 = $L("keyof");
|
|
5050
|
+
var $L214 = $L("???");
|
|
5051
|
+
var $L215 = $L("[]");
|
|
5052
|
+
var $L216 = $L("civet");
|
|
5030
5053
|
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
5031
5054
|
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
5032
5055
|
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
@@ -5044,70 +5067,70 @@ ${input.slice(result.pos)}
|
|
|
5044
5067
|
var $R14 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
5045
5068
|
var $R15 = $R(new RegExp("(?=\\[)", "suy"));
|
|
5046
5069
|
var $R16 = $R(new RegExp("[!+-]", "suy"));
|
|
5047
|
-
var $R17 = $R(new RegExp("
|
|
5048
|
-
var $R18 = $R(new RegExp("
|
|
5049
|
-
var $R19 = $R(new RegExp("
|
|
5050
|
-
var $R20 = $R(new RegExp("[
|
|
5051
|
-
var $R21 = $R(new RegExp("
|
|
5052
|
-
var $R22 = $R(new RegExp("(?=loop|
|
|
5053
|
-
var $R23 = $R(new RegExp("(?=
|
|
5054
|
-
var $R24 = $R(new RegExp(
|
|
5055
|
-
var $R25 = $R(new RegExp("
|
|
5056
|
-
var $R26 = $R(new RegExp("(
|
|
5057
|
-
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
5058
|
-
var $R28 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
5059
|
-
var $R29 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5060
|
-
var $R30 = $R(new RegExp("(
|
|
5061
|
-
var $R31 = $R(new RegExp("
|
|
5062
|
-
var $R32 = $R(new RegExp("0[
|
|
5063
|
-
var $R33 = $R(new RegExp("0[
|
|
5064
|
-
var $R34 = $R(new RegExp("(
|
|
5065
|
-
var $R35 = $R(new RegExp("(
|
|
5066
|
-
var $R36 = $R(new RegExp(
|
|
5067
|
-
var $R37 = $R(new RegExp(
|
|
5068
|
-
var $R38 = $R(new RegExp(
|
|
5069
|
-
var $R39 = $R(new RegExp(
|
|
5070
|
-
var $R40 = $R(new RegExp('(
|
|
5071
|
-
var $R41 = $R(new RegExp(
|
|
5072
|
-
var $R42 = $R(new RegExp("(
|
|
5073
|
-
var $R43 = $R(new RegExp("
|
|
5074
|
-
var $R44 = $R(new RegExp("
|
|
5075
|
-
var $R45 = $R(new RegExp("
|
|
5076
|
-
var $R46 = $R(new RegExp("[
|
|
5077
|
-
var $R47 = $R(new RegExp("
|
|
5078
|
-
var $R48 = $R(new RegExp("(
|
|
5079
|
-
var $R49 = $R(new RegExp("(
|
|
5080
|
-
var $R50 = $R(new RegExp("(
|
|
5081
|
-
var $R51 = $R(new RegExp("(?:\\$(?!\\{)
|
|
5082
|
-
var $R52 = $R(new RegExp("(
|
|
5083
|
-
var $R53 = $R(new RegExp("(?:
|
|
5084
|
-
var $R54 = $R(new RegExp("(?:
|
|
5085
|
-
var $R55 = $R(new RegExp("(?:
|
|
5086
|
-
var $R56 = $R(new RegExp("(?:
|
|
5087
|
-
var $R57 = $R(new RegExp("(
|
|
5088
|
-
var $R58 = $R(new RegExp("
|
|
5089
|
-
var $R59 = $R(new RegExp("
|
|
5090
|
-
var $R60 = $R(new RegExp("
|
|
5091
|
-
var $R61 = $R(new RegExp("[
|
|
5092
|
-
var $R62 = $R(new RegExp("
|
|
5093
|
-
var $R63 = $R(new RegExp("
|
|
5094
|
-
var $R64 = $R(new RegExp("(
|
|
5095
|
-
var $R65 = $R(new RegExp("[ \\t]
|
|
5096
|
-
var $R66 = $R(new RegExp("
|
|
5097
|
-
var $R67 = $R(new RegExp("(
|
|
5098
|
-
var $R68 = $R(new RegExp("
|
|
5099
|
-
var $R69 = $R(new RegExp("
|
|
5100
|
-
var $R70 = $R(new RegExp("
|
|
5101
|
-
var $R71 = $R(new RegExp("(
|
|
5102
|
-
var $R72 = $R(new RegExp("[\\
|
|
5103
|
-
var $R73 = $R(new RegExp("
|
|
5104
|
-
var $R74 = $R(new RegExp(
|
|
5105
|
-
var $R75 = $R(new RegExp("[
|
|
5106
|
-
var $R76 = $R(new RegExp("[
|
|
5107
|
-
var $R77 = $R(new RegExp("
|
|
5108
|
-
var $R78 = $R(new RegExp("[
|
|
5109
|
-
var $R79 = $R(new RegExp("[
|
|
5110
|
-
var $R80 = $R(new RegExp("[+-]", "suy"));
|
|
5070
|
+
var $R17 = $R(new RegExp("[+-]", "suy"));
|
|
5071
|
+
var $R18 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])", "suy"));
|
|
5072
|
+
var $R19 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
5073
|
+
var $R20 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s)", "suy"));
|
|
5074
|
+
var $R21 = $R(new RegExp("[:.]", "suy"));
|
|
5075
|
+
var $R22 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
5076
|
+
var $R23 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
5077
|
+
var $R24 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
5078
|
+
var $R25 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
5079
|
+
var $R26 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
5080
|
+
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
5081
|
+
var $R28 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
5082
|
+
var $R29 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
5083
|
+
var $R30 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5084
|
+
var $R31 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
5085
|
+
var $R32 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
5086
|
+
var $R33 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
5087
|
+
var $R34 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
5088
|
+
var $R35 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
5089
|
+
var $R36 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5090
|
+
var $R37 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
5091
|
+
var $R38 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
5092
|
+
var $R39 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
5093
|
+
var $R40 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
5094
|
+
var $R41 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
5095
|
+
var $R42 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
5096
|
+
var $R43 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
5097
|
+
var $R44 = $R(new RegExp("[\\s]+", "suy"));
|
|
5098
|
+
var $R45 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
5099
|
+
var $R46 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
5100
|
+
var $R47 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
5101
|
+
var $R48 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
5102
|
+
var $R49 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
5103
|
+
var $R50 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
5104
|
+
var $R51 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
5105
|
+
var $R52 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
5106
|
+
var $R53 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
5107
|
+
var $R54 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
5108
|
+
var $R55 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
5109
|
+
var $R56 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
5110
|
+
var $R57 = $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"));
|
|
5111
|
+
var $R58 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
5112
|
+
var $R59 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
5113
|
+
var $R60 = $R(new RegExp(".", "suy"));
|
|
5114
|
+
var $R61 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
5115
|
+
var $R62 = $R(new RegExp("[^]*?###", "suy"));
|
|
5116
|
+
var $R63 = $R(new RegExp("###(?!#)", "suy"));
|
|
5117
|
+
var $R64 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
5118
|
+
var $R65 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
5119
|
+
var $R66 = $R(new RegExp("[ \\t]+", "suy"));
|
|
5120
|
+
var $R67 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
5121
|
+
var $R68 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
5122
|
+
var $R69 = $R(new RegExp("['\u2019]s", "suy"));
|
|
5123
|
+
var $R70 = $R(new RegExp("\\s", "suy"));
|
|
5124
|
+
var $R71 = $R(new RegExp("(?=[<])", "suy"));
|
|
5125
|
+
var $R72 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
5126
|
+
var $R73 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
5127
|
+
var $R74 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
5128
|
+
var $R75 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
5129
|
+
var $R76 = $R(new RegExp("[<>]", "suy"));
|
|
5130
|
+
var $R77 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
5131
|
+
var $R78 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
5132
|
+
var $R79 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
5133
|
+
var $R80 = $R(new RegExp("[+-]?", "suy"));
|
|
5111
5134
|
var $R81 = $R(new RegExp("(?=if|unless)", "suy"));
|
|
5112
5135
|
var $R82 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
5113
5136
|
var $R83 = $R(new RegExp("[\\t ]*", "suy"));
|
|
@@ -5760,12 +5783,23 @@ ${input.slice(result.pos)}
|
|
|
5760
5783
|
function TrailingDeclaration(ctx, state) {
|
|
5761
5784
|
return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
|
|
5762
5785
|
}
|
|
5763
|
-
var
|
|
5786
|
+
var TrailingPipe$0 = $S($E(_), Pipe);
|
|
5787
|
+
function TrailingPipe(ctx, state) {
|
|
5788
|
+
return $EVENT(ctx, state, "TrailingPipe", TrailingPipe$0);
|
|
5789
|
+
}
|
|
5790
|
+
var FatArrowBody$0 = $TS($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(TrailingPipe), $N(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5764
5791
|
var exp = $2;
|
|
5765
5792
|
if (exp.type === "ObjectExpression") {
|
|
5766
|
-
|
|
5793
|
+
exp = makeLeftHandSideExpression(exp);
|
|
5767
5794
|
}
|
|
5768
|
-
|
|
5795
|
+
const expressions = [exp];
|
|
5796
|
+
return {
|
|
5797
|
+
type: "BlockStatement",
|
|
5798
|
+
bare: true,
|
|
5799
|
+
expressions,
|
|
5800
|
+
children: [expressions],
|
|
5801
|
+
implicitlyReturned: true
|
|
5802
|
+
};
|
|
5769
5803
|
});
|
|
5770
5804
|
var FatArrowBody$1 = NoCommaBracedOrEmptyBlock;
|
|
5771
5805
|
var FatArrowBody$$ = [FatArrowBody$0, FatArrowBody$1];
|
|
@@ -6245,7 +6279,14 @@ ${input.slice(result.pos)}
|
|
|
6245
6279
|
function AtThis(ctx, state) {
|
|
6246
6280
|
return $EVENT(ctx, state, "AtThis", AtThis$0);
|
|
6247
6281
|
}
|
|
6248
|
-
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L7, 'LeftHandSideExpression "."'), $EXPECT($L14, 'LeftHandSideExpression ":"'))), __)), CallExpression)
|
|
6282
|
+
var LeftHandSideExpression$0 = $TS($S($P($S(New, $N($C($EXPECT($L7, 'LeftHandSideExpression "."'), $EXPECT($L14, 'LeftHandSideExpression ":"'))), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
6283
|
+
var expression = $2;
|
|
6284
|
+
return {
|
|
6285
|
+
type: "NewExpression",
|
|
6286
|
+
children: $0,
|
|
6287
|
+
expression
|
|
6288
|
+
};
|
|
6289
|
+
});
|
|
6249
6290
|
var LeftHandSideExpression$1 = CallExpression;
|
|
6250
6291
|
var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
|
|
6251
6292
|
function LeftHandSideExpression(ctx, state) {
|
|
@@ -7338,22 +7379,7 @@ ${input.slice(result.pos)}
|
|
|
7338
7379
|
};
|
|
7339
7380
|
});
|
|
7340
7381
|
var FunctionExpression$5 = AmpersandFunctionExpression;
|
|
7341
|
-
var FunctionExpression
|
|
7342
|
-
var id = $1;
|
|
7343
|
-
var ws = $4;
|
|
7344
|
-
var fn = $5;
|
|
7345
|
-
return {
|
|
7346
|
-
...fn,
|
|
7347
|
-
id,
|
|
7348
|
-
children: [
|
|
7349
|
-
...fn.children.slice(0, 3),
|
|
7350
|
-
insertTrimmingSpace(ws, " "),
|
|
7351
|
-
id,
|
|
7352
|
-
...fn.children.slice(3)
|
|
7353
|
-
]
|
|
7354
|
-
};
|
|
7355
|
-
});
|
|
7356
|
-
var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3, FunctionExpression$4, FunctionExpression$5, FunctionExpression$6];
|
|
7382
|
+
var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3, FunctionExpression$4, FunctionExpression$5];
|
|
7357
7383
|
function FunctionExpression(ctx, state) {
|
|
7358
7384
|
return $EVENT_C(ctx, state, "FunctionExpression", FunctionExpression$$);
|
|
7359
7385
|
}
|
|
@@ -8332,14 +8358,17 @@ ${input.slice(result.pos)}
|
|
|
8332
8358
|
function NestedImplicitPropertyDefinitions(ctx, state) {
|
|
8333
8359
|
return $EVENT(ctx, state, "NestedImplicitPropertyDefinitions", NestedImplicitPropertyDefinitions$0);
|
|
8334
8360
|
}
|
|
8335
|
-
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, NamedProperty, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2
|
|
8336
|
-
var
|
|
8337
|
-
var
|
|
8338
|
-
|
|
8339
|
-
return {
|
|
8361
|
+
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, $P($S($E(_), NamedProperty, ObjectPropertyDelimiter))), function($skip, $loc, $0, $1, $2) {
|
|
8362
|
+
var indent = $1;
|
|
8363
|
+
var props = $2;
|
|
8364
|
+
return props.map(([ws, prop, delimiter], i) => ({
|
|
8340
8365
|
...prop,
|
|
8341
|
-
children: [
|
|
8342
|
-
|
|
8366
|
+
children: [
|
|
8367
|
+
...i === 0 ? [indent, ws] : [ws],
|
|
8368
|
+
...prop.children,
|
|
8369
|
+
delimiter
|
|
8370
|
+
]
|
|
8371
|
+
}));
|
|
8343
8372
|
});
|
|
8344
8373
|
function NestedImplicitPropertyDefinition(ctx, state) {
|
|
8345
8374
|
return $EVENT(ctx, state, "NestedImplicitPropertyDefinition", NestedImplicitPropertyDefinition$0);
|
|
@@ -8475,22 +8504,26 @@ ${input.slice(result.pos)}
|
|
|
8475
8504
|
value: exp
|
|
8476
8505
|
};
|
|
8477
8506
|
});
|
|
8478
|
-
var PropertyDefinition$4 = $TS($S($E(_), $N(EOS), CallExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
8507
|
+
var PropertyDefinition$4 = $TS($S($E(_), $N(EOS), $Q(UnaryOp), CallExpression, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
8479
8508
|
var ws = $1;
|
|
8480
|
-
var
|
|
8481
|
-
|
|
8482
|
-
|
|
8483
|
-
|
|
8484
|
-
|
|
8485
|
-
|
|
8486
|
-
|
|
8487
|
-
|
|
8488
|
-
|
|
8489
|
-
|
|
8490
|
-
|
|
8491
|
-
|
|
8492
|
-
|
|
8493
|
-
|
|
8509
|
+
var pre = $3;
|
|
8510
|
+
var value = $4;
|
|
8511
|
+
var post = $5;
|
|
8512
|
+
if (!pre.length && !post) {
|
|
8513
|
+
switch (value.type) {
|
|
8514
|
+
case "Identifier":
|
|
8515
|
+
return { ...value, children: [ws, ...value.children] };
|
|
8516
|
+
case "ObjectExpression":
|
|
8517
|
+
let first = value.properties[0];
|
|
8518
|
+
if (first) {
|
|
8519
|
+
first = {
|
|
8520
|
+
...first,
|
|
8521
|
+
children: [ws, ...first.children],
|
|
8522
|
+
hoistDec: value.hoistDec
|
|
8523
|
+
};
|
|
8524
|
+
}
|
|
8525
|
+
return [first, ...value.properties.slice(1)];
|
|
8526
|
+
}
|
|
8494
8527
|
}
|
|
8495
8528
|
const last = lastAccessInCallExpression(value);
|
|
8496
8529
|
if (!last)
|
|
@@ -8538,7 +8571,7 @@ ${input.slice(result.pos)}
|
|
|
8538
8571
|
name = name.slice(1);
|
|
8539
8572
|
return {
|
|
8540
8573
|
type: "Property",
|
|
8541
|
-
children: [ws, name, ": ", value],
|
|
8574
|
+
children: [ws, name, ": ", processUnaryExpression(pre, value, post)],
|
|
8542
8575
|
name,
|
|
8543
8576
|
names: [],
|
|
8544
8577
|
value,
|
|
@@ -8607,7 +8640,7 @@ ${input.slice(result.pos)}
|
|
|
8607
8640
|
implicit: true
|
|
8608
8641
|
};
|
|
8609
8642
|
});
|
|
8610
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
8643
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($R17, "ComputedPropertyName /[+-]/"), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8611
8644
|
const expression = [$2, $3];
|
|
8612
8645
|
return {
|
|
8613
8646
|
type: "ComputedPropertyName",
|
|
@@ -8645,7 +8678,7 @@ ${input.slice(result.pos)}
|
|
|
8645
8678
|
ts: true
|
|
8646
8679
|
};
|
|
8647
8680
|
});
|
|
8648
|
-
var MethodDefinition$1 = $TS($S(MethodSignature, $N(PropertyAccess), $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8681
|
+
var MethodDefinition$1 = $TS($S(MethodSignature, $N($C(PropertyAccess, UnaryPostfix)), $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8649
8682
|
var signature = $1;
|
|
8650
8683
|
var block = $3;
|
|
8651
8684
|
let children = $0;
|
|
@@ -8985,7 +9018,7 @@ ${input.slice(result.pos)}
|
|
|
8985
9018
|
function IdentifierBinaryOp(ctx, state) {
|
|
8986
9019
|
return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
|
|
8987
9020
|
}
|
|
8988
|
-
var BinaryOp$0 = $T($S($EXPECT($
|
|
9021
|
+
var BinaryOp$0 = $T($S($EXPECT($R18, "BinaryOp /(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])/"), _BinaryOp), function(value) {
|
|
8989
9022
|
var op = value[1];
|
|
8990
9023
|
return op;
|
|
8991
9024
|
});
|
|
@@ -9117,7 +9150,7 @@ ${input.slice(result.pos)}
|
|
|
9117
9150
|
special: true
|
|
9118
9151
|
};
|
|
9119
9152
|
});
|
|
9120
|
-
var BinaryOpSymbol$35 = $TV($C($EXPECT($
|
|
9153
|
+
var BinaryOpSymbol$35 = $TV($C($EXPECT($R19, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L93, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
9121
9154
|
return {
|
|
9122
9155
|
call: module.getRef("xnor"),
|
|
9123
9156
|
special: true
|
|
@@ -9270,18 +9303,18 @@ ${input.slice(result.pos)}
|
|
|
9270
9303
|
function Xor(ctx, state) {
|
|
9271
9304
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
9272
9305
|
}
|
|
9273
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
9306
|
+
var Xnor$0 = $R$0($EXPECT($R19, "Xnor /!\\^\\^?/"));
|
|
9274
9307
|
var Xnor$1 = $EXPECT($L93, 'Xnor "xnor"');
|
|
9275
9308
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
9276
9309
|
function Xnor(ctx, state) {
|
|
9277
9310
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
9278
9311
|
}
|
|
9279
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
9312
|
+
var UnaryOp$0 = $TR($EXPECT($R20, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9280
9313
|
return { $loc, token: $0 };
|
|
9281
9314
|
});
|
|
9282
9315
|
var UnaryOp$1 = AwaitOp;
|
|
9283
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($
|
|
9284
|
-
var UnaryOp$3 = $T($S(Not, $N($EXPECT($
|
|
9316
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($R21, "UnaryOp /[:.]/"))), $E(_));
|
|
9317
|
+
var UnaryOp$3 = $T($S(Not, $N($EXPECT($R21, "UnaryOp /[:.]/")), $E($EXPECT($L15, 'UnaryOp " "')), $E(_)), function(value) {
|
|
9285
9318
|
return [value[0], value[3]];
|
|
9286
9319
|
});
|
|
9287
9320
|
var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
|
|
@@ -9379,7 +9412,7 @@ ${input.slice(result.pos)}
|
|
|
9379
9412
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
9380
9413
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
9381
9414
|
}
|
|
9382
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
9415
|
+
var PostfixStatement$0 = $T($S($EXPECT($R22, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
9383
9416
|
return value[1];
|
|
9384
9417
|
});
|
|
9385
9418
|
function PostfixStatement(ctx, state) {
|
|
@@ -9626,7 +9659,7 @@ ${input.slice(result.pos)}
|
|
|
9626
9659
|
function BlockExpressionPart(ctx, state) {
|
|
9627
9660
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
9628
9661
|
}
|
|
9629
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
9662
|
+
var IterationStatement$0 = $T($S($EXPECT($R23, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
9630
9663
|
return value[1];
|
|
9631
9664
|
});
|
|
9632
9665
|
function IterationStatement(ctx, state) {
|
|
@@ -9979,7 +10012,7 @@ ${input.slice(result.pos)}
|
|
|
9979
10012
|
names: binding.names
|
|
9980
10013
|
};
|
|
9981
10014
|
});
|
|
9982
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
10015
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R24, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9983
10016
|
var c = $1;
|
|
9984
10017
|
var binding = $2;
|
|
9985
10018
|
return {
|
|
@@ -10800,7 +10833,7 @@ ${input.slice(result.pos)}
|
|
|
10800
10833
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
10801
10834
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
10802
10835
|
}
|
|
10803
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10836
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R25, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10804
10837
|
var spec = $0;
|
|
10805
10838
|
return { $loc, token: `"${spec}"` };
|
|
10806
10839
|
});
|
|
@@ -10953,16 +10986,10 @@ ${input.slice(result.pos)}
|
|
|
10953
10986
|
thisAssignments: bindings.flatMap((b) => b.thisAssignments)
|
|
10954
10987
|
};
|
|
10955
10988
|
});
|
|
10956
|
-
var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment,
|
|
10989
|
+
var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, PostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10957
10990
|
return processAssignmentDeclaration(...$0);
|
|
10958
10991
|
});
|
|
10959
|
-
var LexicalDeclaration$2 = $TS($S(InsertLet, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, LetAssignment,
|
|
10960
|
-
var l = $1;
|
|
10961
|
-
var id = $2;
|
|
10962
|
-
var suffix = $3;
|
|
10963
|
-
var ws = $4;
|
|
10964
|
-
var la = $5;
|
|
10965
|
-
var e = $6;
|
|
10992
|
+
var LexicalDeclaration$2 = $TS($S(InsertLet, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, LetAssignment, PostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10966
10993
|
return processAssignmentDeclaration(...$0);
|
|
10967
10994
|
});
|
|
10968
10995
|
var LexicalDeclaration$$ = [LexicalDeclaration$0, LexicalDeclaration$1, LexicalDeclaration$2];
|
|
@@ -10981,6 +11008,12 @@ ${input.slice(result.pos)}
|
|
|
10981
11008
|
function LetAssignment(ctx, state) {
|
|
10982
11009
|
return $EVENT(ctx, state, "LetAssignment", LetAssignment$0);
|
|
10983
11010
|
}
|
|
11011
|
+
var TypeAssignment$0 = $TV($EXPECT($L114, 'TypeAssignment "::="'), function($skip, $loc, $0, $1) {
|
|
11012
|
+
return { $loc, token: "=" };
|
|
11013
|
+
});
|
|
11014
|
+
function TypeAssignment(ctx, state) {
|
|
11015
|
+
return $EVENT(ctx, state, "TypeAssignment", TypeAssignment$0);
|
|
11016
|
+
}
|
|
10984
11017
|
var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
|
|
10985
11018
|
var pattern = $1;
|
|
10986
11019
|
var suffix = $2;
|
|
@@ -11044,7 +11077,7 @@ ${input.slice(result.pos)}
|
|
|
11044
11077
|
function VariableDeclarationList(ctx, state) {
|
|
11045
11078
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
11046
11079
|
}
|
|
11047
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
11080
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R26, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
11048
11081
|
var token = $2;
|
|
11049
11082
|
return { type: "NumericLiteral", $loc, token };
|
|
11050
11083
|
});
|
|
@@ -11060,36 +11093,36 @@ ${input.slice(result.pos)}
|
|
|
11060
11093
|
function NumericLiteralKind(ctx, state) {
|
|
11061
11094
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
11062
11095
|
}
|
|
11063
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
11096
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R27, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
11064
11097
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
11065
11098
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
11066
11099
|
}
|
|
11067
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
11100
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R28, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
11068
11101
|
return $1 + ".";
|
|
11069
11102
|
});
|
|
11070
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
11071
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
11103
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R29, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
11104
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R30, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
11072
11105
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
11073
11106
|
function DecimalLiteral(ctx, state) {
|
|
11074
11107
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
11075
11108
|
}
|
|
11076
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
11109
|
+
var ExponentPart$0 = $R$0($EXPECT($R31, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
11077
11110
|
function ExponentPart(ctx, state) {
|
|
11078
11111
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
11079
11112
|
}
|
|
11080
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
11113
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R32, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
11081
11114
|
function BinaryIntegerLiteral(ctx, state) {
|
|
11082
11115
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
11083
11116
|
}
|
|
11084
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11117
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R33, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
11085
11118
|
function OctalIntegerLiteral(ctx, state) {
|
|
11086
11119
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
11087
11120
|
}
|
|
11088
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
11121
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R34, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
11089
11122
|
function HexIntegerLiteral(ctx, state) {
|
|
11090
11123
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
11091
11124
|
}
|
|
11092
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
11125
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R35, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
11093
11126
|
var token = $2;
|
|
11094
11127
|
return { $loc, token };
|
|
11095
11128
|
});
|
|
@@ -11105,7 +11138,7 @@ ${input.slice(result.pos)}
|
|
|
11105
11138
|
function IntegerLiteralKind(ctx, state) {
|
|
11106
11139
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
11107
11140
|
}
|
|
11108
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11141
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R36, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
11109
11142
|
function DecimalIntegerLiteral(ctx, state) {
|
|
11110
11143
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
11111
11144
|
}
|
|
@@ -11129,25 +11162,25 @@ ${input.slice(result.pos)}
|
|
|
11129
11162
|
function StringLiteral(ctx, state) {
|
|
11130
11163
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
11131
11164
|
}
|
|
11132
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11165
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R37, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11133
11166
|
return { $loc, token: $0 };
|
|
11134
11167
|
});
|
|
11135
11168
|
function DoubleStringCharacters(ctx, state) {
|
|
11136
11169
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
11137
11170
|
}
|
|
11138
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11171
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R38, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11139
11172
|
return { $loc, token: $0 };
|
|
11140
11173
|
});
|
|
11141
11174
|
function SingleStringCharacters(ctx, state) {
|
|
11142
11175
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
11143
11176
|
}
|
|
11144
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11177
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R39, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11145
11178
|
return { $loc, token: $0 };
|
|
11146
11179
|
});
|
|
11147
11180
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
11148
11181
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
11149
11182
|
}
|
|
11150
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11183
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R40, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11151
11184
|
return { $loc, token: $0 };
|
|
11152
11185
|
});
|
|
11153
11186
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -11166,7 +11199,7 @@ ${input.slice(result.pos)}
|
|
|
11166
11199
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
11167
11200
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
11168
11201
|
}
|
|
11169
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11202
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R41, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11170
11203
|
return { $loc, token: $0 };
|
|
11171
11204
|
});
|
|
11172
11205
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
@@ -11186,7 +11219,7 @@ ${input.slice(result.pos)}
|
|
|
11186
11219
|
function RegularExpressionClass(ctx, state) {
|
|
11187
11220
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
11188
11221
|
}
|
|
11189
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11222
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R42, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11190
11223
|
return { $loc, token: $0 };
|
|
11191
11224
|
});
|
|
11192
11225
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -11199,7 +11232,7 @@ ${input.slice(result.pos)}
|
|
|
11199
11232
|
var flags = $4;
|
|
11200
11233
|
let hasSubstitutions = body.some((part) => part.type === "Substitution");
|
|
11201
11234
|
if (hasSubstitutions) {
|
|
11202
|
-
const
|
|
11235
|
+
const children = [
|
|
11203
11236
|
{ ...open, token: "RegExp(`" },
|
|
11204
11237
|
// Escape backticks, backslashes, and '$' in the body text
|
|
11205
11238
|
body.map(
|
|
@@ -11211,13 +11244,16 @@ ${input.slice(result.pos)}
|
|
|
11211
11244
|
"`"
|
|
11212
11245
|
];
|
|
11213
11246
|
if (flags.length) {
|
|
11214
|
-
|
|
11247
|
+
children.push(
|
|
11215
11248
|
", ",
|
|
11216
11249
|
JSON.stringify(flags)
|
|
11217
11250
|
);
|
|
11218
11251
|
}
|
|
11219
|
-
|
|
11220
|
-
return
|
|
11252
|
+
children.push({ ...close, token: ")" });
|
|
11253
|
+
return {
|
|
11254
|
+
type: "RegularExpressionLiteral",
|
|
11255
|
+
children
|
|
11256
|
+
};
|
|
11221
11257
|
}
|
|
11222
11258
|
return {
|
|
11223
11259
|
type: "RegularExpressionLiteral",
|
|
@@ -11240,7 +11276,7 @@ ${input.slice(result.pos)}
|
|
|
11240
11276
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
11241
11277
|
return { "type": "Substitution", "children": value[0] };
|
|
11242
11278
|
});
|
|
11243
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11279
|
+
var HeregexPart$3 = $TR($EXPECT($R43, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11244
11280
|
let token = $0;
|
|
11245
11281
|
switch ($0[1]) {
|
|
11246
11282
|
case "\n":
|
|
@@ -11258,13 +11294,13 @@ ${input.slice(result.pos)}
|
|
|
11258
11294
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
11259
11295
|
return { $loc, token: "" };
|
|
11260
11296
|
});
|
|
11261
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11297
|
+
var HeregexPart$5 = $TR($EXPECT($R44, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11262
11298
|
return { $loc, token: "" };
|
|
11263
11299
|
});
|
|
11264
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11300
|
+
var HeregexPart$6 = $TR($EXPECT($R45, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11265
11301
|
return { $loc, token: "\\/" };
|
|
11266
11302
|
});
|
|
11267
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11303
|
+
var HeregexPart$7 = $TR($EXPECT($R46, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11268
11304
|
return { $loc, token: $0 };
|
|
11269
11305
|
});
|
|
11270
11306
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -11277,7 +11313,7 @@ ${input.slice(result.pos)}
|
|
|
11277
11313
|
function HeregexComment(ctx, state) {
|
|
11278
11314
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
11279
11315
|
}
|
|
11280
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11316
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R47, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11281
11317
|
function RegularExpressionBody(ctx, state) {
|
|
11282
11318
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
11283
11319
|
}
|
|
@@ -11287,15 +11323,15 @@ ${input.slice(result.pos)}
|
|
|
11287
11323
|
function RegExpPart(ctx, state) {
|
|
11288
11324
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
11289
11325
|
}
|
|
11290
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
11326
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R48, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11291
11327
|
function RegExpCharacter(ctx, state) {
|
|
11292
11328
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
11293
11329
|
}
|
|
11294
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11330
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R49, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11295
11331
|
function RegularExpressionFlags(ctx, state) {
|
|
11296
11332
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
11297
11333
|
}
|
|
11298
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
11334
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R50, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
11299
11335
|
return value[1];
|
|
11300
11336
|
});
|
|
11301
11337
|
function TemplateLiteral(ctx, state) {
|
|
@@ -11331,28 +11367,28 @@ ${input.slice(result.pos)}
|
|
|
11331
11367
|
function TemplateSubstitution(ctx, state) {
|
|
11332
11368
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
11333
11369
|
}
|
|
11334
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11370
|
+
var TemplateCharacters$0 = $TR($EXPECT($R51, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11335
11371
|
return { $loc, token: $0 };
|
|
11336
11372
|
});
|
|
11337
11373
|
function TemplateCharacters(ctx, state) {
|
|
11338
11374
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
11339
11375
|
}
|
|
11340
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
11376
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R52, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11341
11377
|
return { $loc, token: $0 };
|
|
11342
11378
|
});
|
|
11343
11379
|
function TemplateBlockCharacters(ctx, state) {
|
|
11344
11380
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
11345
11381
|
}
|
|
11346
|
-
var ReservedWord$0 = $S($R$0($EXPECT($
|
|
11347
|
-
var ReservedWord$1 = $S($R$0($EXPECT($
|
|
11348
|
-
var ReservedWord$2 = $S($R$0($EXPECT($
|
|
11349
|
-
var ReservedWord$3 = $S($R$0($EXPECT($
|
|
11350
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
11382
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R53, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
11383
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R54, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
11384
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R55, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
11385
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R56, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
11386
|
+
var ReservedWord$4 = $R$0($EXPECT($R57, "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})/"));
|
|
11351
11387
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
11352
11388
|
function ReservedWord(ctx, state) {
|
|
11353
11389
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
11354
11390
|
}
|
|
11355
|
-
var Comment$0 = $T($S($EXPECT($
|
|
11391
|
+
var Comment$0 = $T($S($EXPECT($R58, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
11356
11392
|
return value[1];
|
|
11357
11393
|
});
|
|
11358
11394
|
function Comment(ctx, state) {
|
|
@@ -11370,7 +11406,7 @@ ${input.slice(result.pos)}
|
|
|
11370
11406
|
function SingleLineComment(ctx, state) {
|
|
11371
11407
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
11372
11408
|
}
|
|
11373
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
11409
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R59, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11374
11410
|
return { type: "Comment", $loc, token: $0 };
|
|
11375
11411
|
});
|
|
11376
11412
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -11382,30 +11418,30 @@ ${input.slice(result.pos)}
|
|
|
11382
11418
|
function MultiLineComment(ctx, state) {
|
|
11383
11419
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
11384
11420
|
}
|
|
11385
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
11421
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L115, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L116, 'JSMultiLineComment "*/"')), $EXPECT($R60, "JSMultiLineComment /./"))), $EXPECT($L116, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
11386
11422
|
return { type: "Comment", $loc, token: $1 };
|
|
11387
11423
|
});
|
|
11388
11424
|
function JSMultiLineComment(ctx, state) {
|
|
11389
11425
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
11390
11426
|
}
|
|
11391
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
11427
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R61, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11392
11428
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
11393
11429
|
});
|
|
11394
11430
|
function CoffeeSingleLineComment(ctx, state) {
|
|
11395
11431
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
11396
11432
|
}
|
|
11397
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
11433
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R62, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
11398
11434
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
11399
11435
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
11400
11436
|
});
|
|
11401
11437
|
function CoffeeMultiLineComment(ctx, state) {
|
|
11402
11438
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
11403
11439
|
}
|
|
11404
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
11440
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R63, "CoffeeHereCommentStart /###(?!#)/"));
|
|
11405
11441
|
function CoffeeHereCommentStart(ctx, state) {
|
|
11406
11442
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
11407
11443
|
}
|
|
11408
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
11444
|
+
var InlineComment$0 = $TR($EXPECT($R64, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11409
11445
|
return { $loc, token: $0 };
|
|
11410
11446
|
});
|
|
11411
11447
|
function InlineComment(ctx, state) {
|
|
@@ -11419,16 +11455,16 @@ ${input.slice(result.pos)}
|
|
|
11419
11455
|
function TrailingComment(ctx, state) {
|
|
11420
11456
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
11421
11457
|
}
|
|
11422
|
-
var _$0 = $T($S($EXPECT($
|
|
11458
|
+
var _$0 = $T($S($EXPECT($R65, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
11423
11459
|
return value[1];
|
|
11424
11460
|
});
|
|
11425
11461
|
function _(ctx, state) {
|
|
11426
11462
|
return $EVENT(ctx, state, "_", _$0);
|
|
11427
11463
|
}
|
|
11428
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
11464
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R66, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11429
11465
|
return { $loc, token: $0 };
|
|
11430
11466
|
});
|
|
11431
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
11467
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L117, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
11432
11468
|
return " ";
|
|
11433
11469
|
});
|
|
11434
11470
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -11442,7 +11478,7 @@ ${input.slice(result.pos)}
|
|
|
11442
11478
|
function Trimmed_(ctx, state) {
|
|
11443
11479
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
11444
11480
|
}
|
|
11445
|
-
var __$0 = $T($S($EXPECT($
|
|
11481
|
+
var __$0 = $T($S($EXPECT($R67, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
11446
11482
|
return value[1];
|
|
11447
11483
|
});
|
|
11448
11484
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -11450,7 +11486,7 @@ ${input.slice(result.pos)}
|
|
|
11450
11486
|
function __(ctx, state) {
|
|
11451
11487
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
11452
11488
|
}
|
|
11453
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
11489
|
+
var Whitespace$0 = $TR($EXPECT($R44, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11454
11490
|
return { $loc, token: $0 };
|
|
11455
11491
|
});
|
|
11456
11492
|
function Whitespace(ctx, state) {
|
|
@@ -11474,7 +11510,7 @@ ${input.slice(result.pos)}
|
|
|
11474
11510
|
}
|
|
11475
11511
|
var StatementDelimiter$0 = $Y(EOS);
|
|
11476
11512
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
11477
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L29, 'StatementDelimiter "}"'), $EXPECT($
|
|
11513
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L29, 'StatementDelimiter "}"'), $EXPECT($L118, 'StatementDelimiter ")"'), $EXPECT($L38, 'StatementDelimiter "]"'))));
|
|
11478
11514
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
11479
11515
|
function StatementDelimiter(ctx, state) {
|
|
11480
11516
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -11488,7 +11524,7 @@ ${input.slice(result.pos)}
|
|
|
11488
11524
|
function SemicolonDelimiter(ctx, state) {
|
|
11489
11525
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
11490
11526
|
}
|
|
11491
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
11527
|
+
var NonIdContinue$0 = $R$0($EXPECT($R68, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
11492
11528
|
function NonIdContinue(ctx, state) {
|
|
11493
11529
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
11494
11530
|
}
|
|
@@ -11498,7 +11534,7 @@ ${input.slice(result.pos)}
|
|
|
11498
11534
|
function Loc(ctx, state) {
|
|
11499
11535
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
11500
11536
|
}
|
|
11501
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
11537
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L119, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L15, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
11502
11538
|
return { $loc, token: $1, ts: true };
|
|
11503
11539
|
});
|
|
11504
11540
|
function Abstract(ctx, state) {
|
|
@@ -11510,43 +11546,43 @@ ${input.slice(result.pos)}
|
|
|
11510
11546
|
function Ampersand(ctx, state) {
|
|
11511
11547
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
11512
11548
|
}
|
|
11513
|
-
var As$0 = $TS($S($EXPECT($
|
|
11549
|
+
var As$0 = $TS($S($EXPECT($L120, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11514
11550
|
return { $loc, token: $1 };
|
|
11515
11551
|
});
|
|
11516
11552
|
function As(ctx, state) {
|
|
11517
11553
|
return $EVENT(ctx, state, "As", As$0);
|
|
11518
11554
|
}
|
|
11519
|
-
var At$0 = $TV($EXPECT($
|
|
11555
|
+
var At$0 = $TV($EXPECT($L121, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
11520
11556
|
return { $loc, token: $1 };
|
|
11521
11557
|
});
|
|
11522
11558
|
function At(ctx, state) {
|
|
11523
11559
|
return $EVENT(ctx, state, "At", At$0);
|
|
11524
11560
|
}
|
|
11525
|
-
var AtAt$0 = $TV($EXPECT($
|
|
11561
|
+
var AtAt$0 = $TV($EXPECT($L122, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
11526
11562
|
return { $loc, token: "@" };
|
|
11527
11563
|
});
|
|
11528
11564
|
function AtAt(ctx, state) {
|
|
11529
11565
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
11530
11566
|
}
|
|
11531
|
-
var Async$0 = $TS($S($EXPECT($
|
|
11567
|
+
var Async$0 = $TS($S($EXPECT($L123, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11532
11568
|
return { $loc, token: $1, type: "Async" };
|
|
11533
11569
|
});
|
|
11534
11570
|
function Async(ctx, state) {
|
|
11535
11571
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
11536
11572
|
}
|
|
11537
|
-
var Await$0 = $TS($S($EXPECT($
|
|
11573
|
+
var Await$0 = $TS($S($EXPECT($L124, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11538
11574
|
return { $loc, token: $1, type: "Await" };
|
|
11539
11575
|
});
|
|
11540
11576
|
function Await(ctx, state) {
|
|
11541
11577
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
11542
11578
|
}
|
|
11543
|
-
var Backtick$0 = $TV($EXPECT($
|
|
11579
|
+
var Backtick$0 = $TV($EXPECT($L125, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
11544
11580
|
return { $loc, token: $1 };
|
|
11545
11581
|
});
|
|
11546
11582
|
function Backtick(ctx, state) {
|
|
11547
11583
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
11548
11584
|
}
|
|
11549
|
-
var By$0 = $TS($S($EXPECT($
|
|
11585
|
+
var By$0 = $TS($S($EXPECT($L126, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11550
11586
|
return { $loc, token: $1 };
|
|
11551
11587
|
});
|
|
11552
11588
|
function By(ctx, state) {
|
|
@@ -11558,19 +11594,19 @@ ${input.slice(result.pos)}
|
|
|
11558
11594
|
function Caret(ctx, state) {
|
|
11559
11595
|
return $EVENT(ctx, state, "Caret", Caret$0);
|
|
11560
11596
|
}
|
|
11561
|
-
var Case$0 = $TS($S($EXPECT($
|
|
11597
|
+
var Case$0 = $TS($S($EXPECT($L127, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11562
11598
|
return { $loc, token: $1 };
|
|
11563
11599
|
});
|
|
11564
11600
|
function Case(ctx, state) {
|
|
11565
11601
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
11566
11602
|
}
|
|
11567
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
11603
|
+
var Catch$0 = $TS($S($EXPECT($L128, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11568
11604
|
return { $loc, token: $1 };
|
|
11569
11605
|
});
|
|
11570
11606
|
function Catch(ctx, state) {
|
|
11571
11607
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
11572
11608
|
}
|
|
11573
|
-
var Class$0 = $TS($S($EXPECT($
|
|
11609
|
+
var Class$0 = $TS($S($EXPECT($L129, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11574
11610
|
return { $loc, token: $1 };
|
|
11575
11611
|
});
|
|
11576
11612
|
function Class(ctx, state) {
|
|
@@ -11594,13 +11630,13 @@ ${input.slice(result.pos)}
|
|
|
11594
11630
|
function CloseBracket(ctx, state) {
|
|
11595
11631
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
11596
11632
|
}
|
|
11597
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
11633
|
+
var CloseParen$0 = $TV($EXPECT($L118, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
11598
11634
|
return { $loc, token: $1 };
|
|
11599
11635
|
});
|
|
11600
11636
|
function CloseParen(ctx, state) {
|
|
11601
11637
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
11602
11638
|
}
|
|
11603
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
11639
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L130, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
11604
11640
|
return { $loc, token: "${" };
|
|
11605
11641
|
});
|
|
11606
11642
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -11618,31 +11654,31 @@ ${input.slice(result.pos)}
|
|
|
11618
11654
|
function Comma(ctx, state) {
|
|
11619
11655
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
11620
11656
|
}
|
|
11621
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
11657
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L121, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
11622
11658
|
return { $loc, token: "constructor" };
|
|
11623
11659
|
});
|
|
11624
11660
|
function ConstructorShorthand(ctx, state) {
|
|
11625
11661
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
11626
11662
|
}
|
|
11627
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
11663
|
+
var Declare$0 = $TS($S($EXPECT($L131, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11628
11664
|
return { $loc, token: $1 };
|
|
11629
11665
|
});
|
|
11630
11666
|
function Declare(ctx, state) {
|
|
11631
11667
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
11632
11668
|
}
|
|
11633
|
-
var Default$0 = $TS($S($EXPECT($
|
|
11669
|
+
var Default$0 = $TS($S($EXPECT($L132, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11634
11670
|
return { $loc, token: $1 };
|
|
11635
11671
|
});
|
|
11636
11672
|
function Default(ctx, state) {
|
|
11637
11673
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
11638
11674
|
}
|
|
11639
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
11675
|
+
var Delete$0 = $TS($S($EXPECT($L133, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11640
11676
|
return { $loc, token: $1 };
|
|
11641
11677
|
});
|
|
11642
11678
|
function Delete(ctx, state) {
|
|
11643
11679
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
11644
11680
|
}
|
|
11645
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11681
|
+
var Do$0 = $TS($S($EXPECT($L134, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11646
11682
|
return { $loc, token: $1 };
|
|
11647
11683
|
});
|
|
11648
11684
|
function Do(ctx, state) {
|
|
@@ -11651,7 +11687,7 @@ ${input.slice(result.pos)}
|
|
|
11651
11687
|
var Dot$0 = $TV($EXPECT($L7, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
11652
11688
|
return { $loc, token: $1 };
|
|
11653
11689
|
});
|
|
11654
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
11690
|
+
var Dot$1 = $TS($S($EXPECT($R69, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
11655
11691
|
var ws = $2;
|
|
11656
11692
|
return [
|
|
11657
11693
|
{ $loc, token: "." },
|
|
@@ -11662,45 +11698,45 @@ ${input.slice(result.pos)}
|
|
|
11662
11698
|
function Dot(ctx, state) {
|
|
11663
11699
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
11664
11700
|
}
|
|
11665
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
11701
|
+
var DotDot$0 = $TS($S($EXPECT($L135, 'DotDot ".."'), $N($EXPECT($L7, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
11666
11702
|
return { $loc, token: $1 };
|
|
11667
11703
|
});
|
|
11668
|
-
var DotDot$1 = $TV($EXPECT($
|
|
11704
|
+
var DotDot$1 = $TV($EXPECT($L136, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
11669
11705
|
return { $loc, token: ".." };
|
|
11670
11706
|
});
|
|
11671
11707
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
11672
11708
|
function DotDot(ctx, state) {
|
|
11673
11709
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
11674
11710
|
}
|
|
11675
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11711
|
+
var DotDotDot$0 = $TV($EXPECT($L137, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
11676
11712
|
return { $loc, token: $1 };
|
|
11677
11713
|
});
|
|
11678
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
11714
|
+
var DotDotDot$1 = $TV($EXPECT($L138, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
11679
11715
|
return { $loc, token: "..." };
|
|
11680
11716
|
});
|
|
11681
11717
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
11682
11718
|
function DotDotDot(ctx, state) {
|
|
11683
11719
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
11684
11720
|
}
|
|
11685
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11721
|
+
var DoubleColon$0 = $TV($EXPECT($L139, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
11686
11722
|
return { $loc, token: $1 };
|
|
11687
11723
|
});
|
|
11688
11724
|
function DoubleColon(ctx, state) {
|
|
11689
11725
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
11690
11726
|
}
|
|
11691
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11727
|
+
var DoubleQuote$0 = $TV($EXPECT($L140, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11692
11728
|
return { $loc, token: $1 };
|
|
11693
11729
|
});
|
|
11694
11730
|
function DoubleQuote(ctx, state) {
|
|
11695
11731
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
11696
11732
|
}
|
|
11697
|
-
var Each$0 = $TS($S($EXPECT($
|
|
11733
|
+
var Each$0 = $TS($S($EXPECT($L141, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11698
11734
|
return { $loc, token: $1 };
|
|
11699
11735
|
});
|
|
11700
11736
|
function Each(ctx, state) {
|
|
11701
11737
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
11702
11738
|
}
|
|
11703
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11739
|
+
var Else$0 = $TS($S($EXPECT($L142, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11704
11740
|
return { $loc, token: $1 };
|
|
11705
11741
|
});
|
|
11706
11742
|
function Else(ctx, state) {
|
|
@@ -11718,91 +11754,91 @@ ${input.slice(result.pos)}
|
|
|
11718
11754
|
function ExclamationPoint(ctx, state) {
|
|
11719
11755
|
return $EVENT(ctx, state, "ExclamationPoint", ExclamationPoint$0);
|
|
11720
11756
|
}
|
|
11721
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11757
|
+
var Export$0 = $TS($S($EXPECT($L143, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11722
11758
|
return { $loc, token: $1 };
|
|
11723
11759
|
});
|
|
11724
11760
|
function Export(ctx, state) {
|
|
11725
11761
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
11726
11762
|
}
|
|
11727
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11763
|
+
var Extends$0 = $TS($S($EXPECT($L144, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11728
11764
|
return { $loc, token: $1 };
|
|
11729
11765
|
});
|
|
11730
11766
|
function Extends(ctx, state) {
|
|
11731
11767
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
11732
11768
|
}
|
|
11733
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
11769
|
+
var Finally$0 = $TS($S($EXPECT($L145, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11734
11770
|
return { $loc, token: $1 };
|
|
11735
11771
|
});
|
|
11736
11772
|
function Finally(ctx, state) {
|
|
11737
11773
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
11738
11774
|
}
|
|
11739
|
-
var For$0 = $TS($S($EXPECT($
|
|
11775
|
+
var For$0 = $TS($S($EXPECT($L146, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11740
11776
|
return { $loc, token: $1 };
|
|
11741
11777
|
});
|
|
11742
11778
|
function For(ctx, state) {
|
|
11743
11779
|
return $EVENT(ctx, state, "For", For$0);
|
|
11744
11780
|
}
|
|
11745
|
-
var From$0 = $TS($S($EXPECT($
|
|
11781
|
+
var From$0 = $TS($S($EXPECT($L147, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11746
11782
|
return { $loc, token: $1 };
|
|
11747
11783
|
});
|
|
11748
11784
|
function From(ctx, state) {
|
|
11749
11785
|
return $EVENT(ctx, state, "From", From$0);
|
|
11750
11786
|
}
|
|
11751
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11787
|
+
var Function$0 = $TS($S($EXPECT($L148, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11752
11788
|
return { $loc, token: $1 };
|
|
11753
11789
|
});
|
|
11754
11790
|
function Function(ctx, state) {
|
|
11755
11791
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
11756
11792
|
}
|
|
11757
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11793
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L149, 'GetOrSet "get"'), $EXPECT($L150, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11758
11794
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11759
11795
|
});
|
|
11760
11796
|
function GetOrSet(ctx, state) {
|
|
11761
11797
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
11762
11798
|
}
|
|
11763
|
-
var Hash$0 = $TV($EXPECT($
|
|
11799
|
+
var Hash$0 = $TV($EXPECT($L151, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
11764
11800
|
return { $loc, token: $1 };
|
|
11765
11801
|
});
|
|
11766
11802
|
function Hash(ctx, state) {
|
|
11767
11803
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11768
11804
|
}
|
|
11769
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11805
|
+
var If$0 = $TV($TEXT($S($EXPECT($L152, 'If "if"'), NonIdContinue, $E($EXPECT($L15, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11770
11806
|
return { $loc, token: $1 };
|
|
11771
11807
|
});
|
|
11772
11808
|
function If(ctx, state) {
|
|
11773
11809
|
return $EVENT(ctx, state, "If", If$0);
|
|
11774
11810
|
}
|
|
11775
|
-
var Import$0 = $TS($S($EXPECT($L19, 'Import "import"'), $Y($EXPECT($
|
|
11811
|
+
var Import$0 = $TS($S($EXPECT($L19, 'Import "import"'), $Y($EXPECT($R70, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11776
11812
|
return { $loc, token: $1 };
|
|
11777
11813
|
});
|
|
11778
11814
|
function Import(ctx, state) {
|
|
11779
11815
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11780
11816
|
}
|
|
11781
|
-
var In$0 = $TS($S($EXPECT($
|
|
11817
|
+
var In$0 = $TS($S($EXPECT($L153, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11782
11818
|
return { $loc, token: $1 };
|
|
11783
11819
|
});
|
|
11784
11820
|
function In(ctx, state) {
|
|
11785
11821
|
return $EVENT(ctx, state, "In", In$0);
|
|
11786
11822
|
}
|
|
11787
|
-
var Infer$0 = $TS($S($EXPECT($
|
|
11823
|
+
var Infer$0 = $TS($S($EXPECT($L154, 'Infer "infer"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11788
11824
|
return { $loc, token: $1 };
|
|
11789
11825
|
});
|
|
11790
11826
|
function Infer(ctx, state) {
|
|
11791
11827
|
return $EVENT(ctx, state, "Infer", Infer$0);
|
|
11792
11828
|
}
|
|
11793
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11829
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L155, 'LetOrConst "let"'), $EXPECT($L156, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11794
11830
|
return { $loc, token: $1 };
|
|
11795
11831
|
});
|
|
11796
11832
|
function LetOrConst(ctx, state) {
|
|
11797
11833
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11798
11834
|
}
|
|
11799
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11835
|
+
var Const$0 = $TS($S($EXPECT($L156, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11800
11836
|
return { $loc, token: $1 };
|
|
11801
11837
|
});
|
|
11802
11838
|
function Const(ctx, state) {
|
|
11803
11839
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11804
11840
|
}
|
|
11805
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11841
|
+
var Is$0 = $TS($S($EXPECT($L157, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11806
11842
|
return { $loc, token: $1 };
|
|
11807
11843
|
});
|
|
11808
11844
|
function Is(ctx, state) {
|
|
@@ -11814,25 +11850,25 @@ ${input.slice(result.pos)}
|
|
|
11814
11850
|
function LetOrConstOrVar(ctx, state) {
|
|
11815
11851
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11816
11852
|
}
|
|
11817
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11853
|
+
var Loop$0 = $TS($S($EXPECT($L158, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11818
11854
|
return { $loc, token: "while(true)" };
|
|
11819
11855
|
});
|
|
11820
11856
|
function Loop(ctx, state) {
|
|
11821
11857
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11822
11858
|
}
|
|
11823
|
-
var New$0 = $TS($S($EXPECT($
|
|
11859
|
+
var New$0 = $TS($S($EXPECT($L159, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11824
11860
|
return { $loc, token: $1 };
|
|
11825
11861
|
});
|
|
11826
11862
|
function New(ctx, state) {
|
|
11827
11863
|
return $EVENT(ctx, state, "New", New$0);
|
|
11828
11864
|
}
|
|
11829
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11865
|
+
var Not$0 = $TS($S($EXPECT($L160, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L14, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11830
11866
|
return { $loc, token: "!" };
|
|
11831
11867
|
});
|
|
11832
11868
|
function Not(ctx, state) {
|
|
11833
11869
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11834
11870
|
}
|
|
11835
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11871
|
+
var Of$0 = $TS($S($EXPECT($L161, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11836
11872
|
return { $loc, token: $1 };
|
|
11837
11873
|
});
|
|
11838
11874
|
function Of(ctx, state) {
|
|
@@ -11850,7 +11886,7 @@ ${input.slice(result.pos)}
|
|
|
11850
11886
|
function OpenBrace(ctx, state) {
|
|
11851
11887
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
11852
11888
|
}
|
|
11853
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
11889
|
+
var OpenBracket$0 = $TV($EXPECT($L162, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
11854
11890
|
return { $loc, token: $1 };
|
|
11855
11891
|
});
|
|
11856
11892
|
function OpenBracket(ctx, state) {
|
|
@@ -11862,43 +11898,43 @@ ${input.slice(result.pos)}
|
|
|
11862
11898
|
function OpenParen(ctx, state) {
|
|
11863
11899
|
return $EVENT(ctx, state, "OpenParen", OpenParen$0);
|
|
11864
11900
|
}
|
|
11865
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
11901
|
+
var Operator$0 = $TS($S($EXPECT($L163, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11866
11902
|
return { $loc, token: $1 };
|
|
11867
11903
|
});
|
|
11868
11904
|
function Operator(ctx, state) {
|
|
11869
11905
|
return $EVENT(ctx, state, "Operator", Operator$0);
|
|
11870
11906
|
}
|
|
11871
|
-
var Own$0 = $TS($S($EXPECT($
|
|
11907
|
+
var Own$0 = $TS($S($EXPECT($L164, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11872
11908
|
return { $loc, token: $1 };
|
|
11873
11909
|
});
|
|
11874
11910
|
function Own(ctx, state) {
|
|
11875
11911
|
return $EVENT(ctx, state, "Own", Own$0);
|
|
11876
11912
|
}
|
|
11877
|
-
var Public$0 = $TS($S($EXPECT($
|
|
11913
|
+
var Public$0 = $TS($S($EXPECT($L165, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11878
11914
|
return { $loc, token: $1 };
|
|
11879
11915
|
});
|
|
11880
11916
|
function Public(ctx, state) {
|
|
11881
11917
|
return $EVENT(ctx, state, "Public", Public$0);
|
|
11882
11918
|
}
|
|
11883
|
-
var Private$0 = $TS($S($EXPECT($
|
|
11919
|
+
var Private$0 = $TS($S($EXPECT($L166, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11884
11920
|
return { $loc, token: $1 };
|
|
11885
11921
|
});
|
|
11886
11922
|
function Private(ctx, state) {
|
|
11887
11923
|
return $EVENT(ctx, state, "Private", Private$0);
|
|
11888
11924
|
}
|
|
11889
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
11925
|
+
var Protected$0 = $TS($S($EXPECT($L167, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11890
11926
|
return { $loc, token: $1 };
|
|
11891
11927
|
});
|
|
11892
11928
|
function Protected(ctx, state) {
|
|
11893
11929
|
return $EVENT(ctx, state, "Protected", Protected$0);
|
|
11894
11930
|
}
|
|
11895
|
-
var Pipe$0 = $TV($C($EXPECT($
|
|
11931
|
+
var Pipe$0 = $TV($C($EXPECT($L168, 'Pipe "||>"'), $EXPECT($L169, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11896
11932
|
return { $loc, token: "||>" };
|
|
11897
11933
|
});
|
|
11898
|
-
var Pipe$1 = $TV($C($EXPECT($
|
|
11934
|
+
var Pipe$1 = $TV($C($EXPECT($L170, 'Pipe "|>="'), $EXPECT($L171, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
|
|
11899
11935
|
return { $loc, token: "|>=" };
|
|
11900
11936
|
});
|
|
11901
|
-
var Pipe$2 = $TV($C($EXPECT($
|
|
11937
|
+
var Pipe$2 = $TV($C($EXPECT($L172, 'Pipe "|>"'), $EXPECT($L173, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11902
11938
|
return { $loc, token: "|>" };
|
|
11903
11939
|
});
|
|
11904
11940
|
var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
|
|
@@ -11911,19 +11947,19 @@ ${input.slice(result.pos)}
|
|
|
11911
11947
|
function QuestionMark(ctx, state) {
|
|
11912
11948
|
return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
|
|
11913
11949
|
}
|
|
11914
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
11950
|
+
var Readonly$0 = $TS($S($EXPECT($L174, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11915
11951
|
return { $loc, token: $1, ts: true };
|
|
11916
11952
|
});
|
|
11917
11953
|
function Readonly(ctx, state) {
|
|
11918
11954
|
return $EVENT(ctx, state, "Readonly", Readonly$0);
|
|
11919
11955
|
}
|
|
11920
|
-
var Return$0 = $TS($S($EXPECT($
|
|
11956
|
+
var Return$0 = $TS($S($EXPECT($L175, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11921
11957
|
return { $loc, token: $1 };
|
|
11922
11958
|
});
|
|
11923
11959
|
function Return(ctx, state) {
|
|
11924
11960
|
return $EVENT(ctx, state, "Return", Return$0);
|
|
11925
11961
|
}
|
|
11926
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
11962
|
+
var Satisfies$0 = $TS($S($EXPECT($L176, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11927
11963
|
return { $loc, token: $1 };
|
|
11928
11964
|
});
|
|
11929
11965
|
function Satisfies(ctx, state) {
|
|
@@ -11935,7 +11971,7 @@ ${input.slice(result.pos)}
|
|
|
11935
11971
|
function Semicolon(ctx, state) {
|
|
11936
11972
|
return $EVENT(ctx, state, "Semicolon", Semicolon$0);
|
|
11937
11973
|
}
|
|
11938
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
11974
|
+
var SingleQuote$0 = $TV($EXPECT($L177, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
11939
11975
|
return { $loc, token: $1 };
|
|
11940
11976
|
});
|
|
11941
11977
|
function SingleQuote(ctx, state) {
|
|
@@ -11947,137 +11983,137 @@ ${input.slice(result.pos)}
|
|
|
11947
11983
|
function Star(ctx, state) {
|
|
11948
11984
|
return $EVENT(ctx, state, "Star", Star$0);
|
|
11949
11985
|
}
|
|
11950
|
-
var Static$0 = $TS($S($EXPECT($
|
|
11986
|
+
var Static$0 = $TS($S($EXPECT($L178, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11951
11987
|
return { $loc, token: $1 };
|
|
11952
11988
|
});
|
|
11953
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11989
|
+
var Static$1 = $TS($S($EXPECT($L121, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L121, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11954
11990
|
return { $loc, token: "static " };
|
|
11955
11991
|
});
|
|
11956
11992
|
var Static$$ = [Static$0, Static$1];
|
|
11957
11993
|
function Static(ctx, state) {
|
|
11958
11994
|
return $EVENT_C(ctx, state, "Static", Static$$);
|
|
11959
11995
|
}
|
|
11960
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
11996
|
+
var SubstitutionStart$0 = $TV($EXPECT($L179, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
11961
11997
|
return { $loc, token: $1 };
|
|
11962
11998
|
});
|
|
11963
11999
|
function SubstitutionStart(ctx, state) {
|
|
11964
12000
|
return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
|
|
11965
12001
|
}
|
|
11966
|
-
var Super$0 = $TS($S($EXPECT($
|
|
12002
|
+
var Super$0 = $TS($S($EXPECT($L180, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11967
12003
|
return { $loc, token: $1 };
|
|
11968
12004
|
});
|
|
11969
12005
|
function Super(ctx, state) {
|
|
11970
12006
|
return $EVENT(ctx, state, "Super", Super$0);
|
|
11971
12007
|
}
|
|
11972
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
12008
|
+
var Switch$0 = $TS($S($EXPECT($L181, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11973
12009
|
return { $loc, token: $1 };
|
|
11974
12010
|
});
|
|
11975
12011
|
function Switch(ctx, state) {
|
|
11976
12012
|
return $EVENT(ctx, state, "Switch", Switch$0);
|
|
11977
12013
|
}
|
|
11978
|
-
var Target$0 = $TS($S($EXPECT($
|
|
12014
|
+
var Target$0 = $TS($S($EXPECT($L182, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11979
12015
|
return { $loc, token: $1 };
|
|
11980
12016
|
});
|
|
11981
12017
|
function Target(ctx, state) {
|
|
11982
12018
|
return $EVENT(ctx, state, "Target", Target$0);
|
|
11983
12019
|
}
|
|
11984
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
12020
|
+
var Then$0 = $TS($S(__, $EXPECT($L183, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
11985
12021
|
return { $loc, token: "" };
|
|
11986
12022
|
});
|
|
11987
12023
|
function Then(ctx, state) {
|
|
11988
12024
|
return $EVENT(ctx, state, "Then", Then$0);
|
|
11989
12025
|
}
|
|
11990
|
-
var This$0 = $TS($S($EXPECT($
|
|
12026
|
+
var This$0 = $TS($S($EXPECT($L184, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11991
12027
|
return { $loc, token: $1 };
|
|
11992
12028
|
});
|
|
11993
12029
|
function This(ctx, state) {
|
|
11994
12030
|
return $EVENT(ctx, state, "This", This$0);
|
|
11995
12031
|
}
|
|
11996
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
12032
|
+
var Throw$0 = $TS($S($EXPECT($L185, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11997
12033
|
return { $loc, token: $1 };
|
|
11998
12034
|
});
|
|
11999
12035
|
function Throw(ctx, state) {
|
|
12000
12036
|
return $EVENT(ctx, state, "Throw", Throw$0);
|
|
12001
12037
|
}
|
|
12002
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
12038
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L186, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
12003
12039
|
return { $loc, token: "`" };
|
|
12004
12040
|
});
|
|
12005
12041
|
function TripleDoubleQuote(ctx, state) {
|
|
12006
12042
|
return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
|
|
12007
12043
|
}
|
|
12008
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
12044
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L187, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
12009
12045
|
return { $loc, token: "`" };
|
|
12010
12046
|
});
|
|
12011
12047
|
function TripleSingleQuote(ctx, state) {
|
|
12012
12048
|
return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
|
|
12013
12049
|
}
|
|
12014
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
12050
|
+
var TripleSlash$0 = $TV($EXPECT($L188, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
12015
12051
|
return { $loc, token: "/" };
|
|
12016
12052
|
});
|
|
12017
12053
|
function TripleSlash(ctx, state) {
|
|
12018
12054
|
return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
|
|
12019
12055
|
}
|
|
12020
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
12056
|
+
var TripleTick$0 = $TV($EXPECT($L189, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
12021
12057
|
return { $loc, token: "`" };
|
|
12022
12058
|
});
|
|
12023
12059
|
function TripleTick(ctx, state) {
|
|
12024
12060
|
return $EVENT(ctx, state, "TripleTick", TripleTick$0);
|
|
12025
12061
|
}
|
|
12026
|
-
var Try$0 = $TS($S($EXPECT($
|
|
12062
|
+
var Try$0 = $TS($S($EXPECT($L190, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12027
12063
|
return { $loc, token: $1 };
|
|
12028
12064
|
});
|
|
12029
12065
|
function Try(ctx, state) {
|
|
12030
12066
|
return $EVENT(ctx, state, "Try", Try$0);
|
|
12031
12067
|
}
|
|
12032
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
12068
|
+
var Typeof$0 = $TS($S($EXPECT($L191, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12033
12069
|
return { $loc, token: $1 };
|
|
12034
12070
|
});
|
|
12035
12071
|
function Typeof(ctx, state) {
|
|
12036
12072
|
return $EVENT(ctx, state, "Typeof", Typeof$0);
|
|
12037
12073
|
}
|
|
12038
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
12074
|
+
var Unless$0 = $TS($S($EXPECT($L192, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12039
12075
|
return { $loc, token: $1, negated: true };
|
|
12040
12076
|
});
|
|
12041
12077
|
function Unless(ctx, state) {
|
|
12042
12078
|
return $EVENT(ctx, state, "Unless", Unless$0);
|
|
12043
12079
|
}
|
|
12044
|
-
var Until$0 = $TS($S($EXPECT($
|
|
12080
|
+
var Until$0 = $TS($S($EXPECT($L193, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12045
12081
|
return { $loc, token: $1 };
|
|
12046
12082
|
});
|
|
12047
12083
|
function Until(ctx, state) {
|
|
12048
12084
|
return $EVENT(ctx, state, "Until", Until$0);
|
|
12049
12085
|
}
|
|
12050
|
-
var Using$0 = $TS($S($EXPECT($
|
|
12086
|
+
var Using$0 = $TS($S($EXPECT($L194, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12051
12087
|
return { $loc, token: $1 };
|
|
12052
12088
|
});
|
|
12053
12089
|
function Using(ctx, state) {
|
|
12054
12090
|
return $EVENT(ctx, state, "Using", Using$0);
|
|
12055
12091
|
}
|
|
12056
|
-
var Var$0 = $TS($S($EXPECT($
|
|
12092
|
+
var Var$0 = $TS($S($EXPECT($L195, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12057
12093
|
return { $loc, token: $1 };
|
|
12058
12094
|
});
|
|
12059
12095
|
function Var(ctx, state) {
|
|
12060
12096
|
return $EVENT(ctx, state, "Var", Var$0);
|
|
12061
12097
|
}
|
|
12062
|
-
var Void$0 = $TS($S($EXPECT($
|
|
12098
|
+
var Void$0 = $TS($S($EXPECT($L196, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12063
12099
|
return { $loc, token: $1 };
|
|
12064
12100
|
});
|
|
12065
12101
|
function Void(ctx, state) {
|
|
12066
12102
|
return $EVENT(ctx, state, "Void", Void$0);
|
|
12067
12103
|
}
|
|
12068
|
-
var When$0 = $TS($S($EXPECT($
|
|
12104
|
+
var When$0 = $TS($S($EXPECT($L197, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12069
12105
|
return { $loc, token: "case" };
|
|
12070
12106
|
});
|
|
12071
12107
|
function When(ctx, state) {
|
|
12072
12108
|
return $EVENT(ctx, state, "When", When$0);
|
|
12073
12109
|
}
|
|
12074
|
-
var While$0 = $TS($S($EXPECT($
|
|
12110
|
+
var While$0 = $TS($S($EXPECT($L198, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12075
12111
|
return { $loc, token: $1 };
|
|
12076
12112
|
});
|
|
12077
12113
|
function While(ctx, state) {
|
|
12078
12114
|
return $EVENT(ctx, state, "While", While$0);
|
|
12079
12115
|
}
|
|
12080
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
12116
|
+
var Yield$0 = $TS($S($EXPECT($L199, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12081
12117
|
return { $loc, token: $1, type: "Yield" };
|
|
12082
12118
|
});
|
|
12083
12119
|
function Yield(ctx, state) {
|
|
@@ -12106,7 +12142,7 @@ ${input.slice(result.pos)}
|
|
|
12106
12142
|
function JSXImplicitFragment(ctx, state) {
|
|
12107
12143
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
12108
12144
|
}
|
|
12109
|
-
var JSXTag$0 = $T($S($EXPECT($
|
|
12145
|
+
var JSXTag$0 = $T($S($EXPECT($R71, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
12110
12146
|
return value[1];
|
|
12111
12147
|
});
|
|
12112
12148
|
function JSXTag(ctx, state) {
|
|
@@ -12156,7 +12192,7 @@ ${input.slice(result.pos)}
|
|
|
12156
12192
|
function JSXElement(ctx, state) {
|
|
12157
12193
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
12158
12194
|
}
|
|
12159
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($
|
|
12195
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L200, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12160
12196
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
12161
12197
|
});
|
|
12162
12198
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -12190,7 +12226,7 @@ ${input.slice(result.pos)}
|
|
|
12190
12226
|
function JSXOptionalClosingElement(ctx, state) {
|
|
12191
12227
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
12192
12228
|
}
|
|
12193
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
12229
|
+
var JSXClosingElement$0 = $S($EXPECT($L201, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L37, 'JSXClosingElement ">"'));
|
|
12194
12230
|
function JSXClosingElement(ctx, state) {
|
|
12195
12231
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
12196
12232
|
}
|
|
@@ -12211,7 +12247,7 @@ ${input.slice(result.pos)}
|
|
|
12211
12247
|
];
|
|
12212
12248
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
12213
12249
|
});
|
|
12214
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
12250
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L202, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12215
12251
|
var children = $3;
|
|
12216
12252
|
$0 = $0.slice(1);
|
|
12217
12253
|
return {
|
|
@@ -12224,7 +12260,7 @@ ${input.slice(result.pos)}
|
|
|
12224
12260
|
function JSXFragment(ctx, state) {
|
|
12225
12261
|
return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
|
|
12226
12262
|
}
|
|
12227
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
12263
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L202, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
12228
12264
|
module.JSXTagStack.push("");
|
|
12229
12265
|
return $1;
|
|
12230
12266
|
});
|
|
@@ -12241,11 +12277,11 @@ ${input.slice(result.pos)}
|
|
|
12241
12277
|
function JSXOptionalClosingFragment(ctx, state) {
|
|
12242
12278
|
return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
|
|
12243
12279
|
}
|
|
12244
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
12280
|
+
var JSXClosingFragment$0 = $EXPECT($L203, 'JSXClosingFragment "</>"');
|
|
12245
12281
|
function JSXClosingFragment(ctx, state) {
|
|
12246
12282
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
12247
12283
|
}
|
|
12248
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
12284
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L151, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
12249
12285
|
return module.config.defaultElement;
|
|
12250
12286
|
});
|
|
12251
12287
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -12253,7 +12289,7 @@ ${input.slice(result.pos)}
|
|
|
12253
12289
|
function JSXElementName(ctx, state) {
|
|
12254
12290
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
12255
12291
|
}
|
|
12256
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
12292
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R72, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
12257
12293
|
function JSXIdentifierName(ctx, state) {
|
|
12258
12294
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
12259
12295
|
}
|
|
@@ -12423,7 +12459,7 @@ ${input.slice(result.pos)}
|
|
|
12423
12459
|
}
|
|
12424
12460
|
return $skip;
|
|
12425
12461
|
});
|
|
12426
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
12462
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L151, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
12427
12463
|
return [" ", "id=", $2];
|
|
12428
12464
|
});
|
|
12429
12465
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -12442,11 +12478,11 @@ ${input.slice(result.pos)}
|
|
|
12442
12478
|
function JSXAttribute(ctx, state) {
|
|
12443
12479
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
12444
12480
|
}
|
|
12445
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
12481
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R73, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
12446
12482
|
function JSXAttributeSpace(ctx, state) {
|
|
12447
12483
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
12448
12484
|
}
|
|
12449
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
12485
|
+
var JSXShorthandString$0 = $TR($EXPECT($R74, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12450
12486
|
return quoteString($0);
|
|
12451
12487
|
});
|
|
12452
12488
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -12480,7 +12516,7 @@ ${input.slice(result.pos)}
|
|
|
12480
12516
|
}
|
|
12481
12517
|
return [open, value, close];
|
|
12482
12518
|
});
|
|
12483
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
12519
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R75, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
12484
12520
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
12485
12521
|
function JSXAttributeValue(ctx, state) {
|
|
12486
12522
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -12493,7 +12529,7 @@ ${input.slice(result.pos)}
|
|
|
12493
12529
|
function InlineJSXAttributeValue(ctx, state) {
|
|
12494
12530
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
12495
12531
|
}
|
|
12496
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
12532
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R76, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
12497
12533
|
var op = $2;
|
|
12498
12534
|
var rhs = $3;
|
|
12499
12535
|
return [[], op, [], rhs];
|
|
@@ -12510,7 +12546,7 @@ ${input.slice(result.pos)}
|
|
|
12510
12546
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
12511
12547
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
12512
12548
|
}
|
|
12513
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
12549
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R77, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12514
12550
|
return { $loc, token: $0 };
|
|
12515
12551
|
});
|
|
12516
12552
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -12715,19 +12751,19 @@ ${input.slice(result.pos)}
|
|
|
12715
12751
|
function JSXChild(ctx, state) {
|
|
12716
12752
|
return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
|
|
12717
12753
|
}
|
|
12718
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
12754
|
+
var JSXComment$0 = $TS($S($EXPECT($L204, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L205, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
12719
12755
|
return ["{/*", $2, "*/}"];
|
|
12720
12756
|
});
|
|
12721
12757
|
function JSXComment(ctx, state) {
|
|
12722
12758
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
12723
12759
|
}
|
|
12724
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
12760
|
+
var JSXCommentContent$0 = $TR($EXPECT($R78, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12725
12761
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
12726
12762
|
});
|
|
12727
12763
|
function JSXCommentContent(ctx, state) {
|
|
12728
12764
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
12729
12765
|
}
|
|
12730
|
-
var JSXText$0 = $TR($EXPECT($
|
|
12766
|
+
var JSXText$0 = $TR($EXPECT($R79, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12731
12767
|
return {
|
|
12732
12768
|
type: "JSXText",
|
|
12733
12769
|
token: $0,
|
|
@@ -12826,7 +12862,7 @@ ${input.slice(result.pos)}
|
|
|
12826
12862
|
function TypeDeclarationRest(ctx, state) {
|
|
12827
12863
|
return $EVENT_C(ctx, state, "TypeDeclarationRest", TypeDeclarationRest$$);
|
|
12828
12864
|
}
|
|
12829
|
-
var TypeAliasDeclaration$0 = $TS($S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), OptionalEquals, $C(
|
|
12865
|
+
var TypeAliasDeclaration$0 = $TS($S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), OptionalEquals, $C(MaybeIndentedType, $S(__, Type))), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12830
12866
|
var id = $3;
|
|
12831
12867
|
return {
|
|
12832
12868
|
type: "TypeDeclaration",
|
|
@@ -12835,8 +12871,18 @@ ${input.slice(result.pos)}
|
|
|
12835
12871
|
ts: true
|
|
12836
12872
|
};
|
|
12837
12873
|
});
|
|
12874
|
+
var TypeAliasDeclaration$1 = $TS($S(InsertType, IdentifierName, $E(TypeParameters), __, TypeAssignment, $C(MaybeIndentedType, $S(__, Type))), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12875
|
+
var id = $2;
|
|
12876
|
+
return {
|
|
12877
|
+
type: "TypeDeclaration",
|
|
12878
|
+
id,
|
|
12879
|
+
children: $0,
|
|
12880
|
+
ts: true
|
|
12881
|
+
};
|
|
12882
|
+
});
|
|
12883
|
+
var TypeAliasDeclaration$$ = [TypeAliasDeclaration$0, TypeAliasDeclaration$1];
|
|
12838
12884
|
function TypeAliasDeclaration(ctx, state) {
|
|
12839
|
-
return $
|
|
12885
|
+
return $EVENT_C(ctx, state, "TypeAliasDeclaration", TypeAliasDeclaration$$);
|
|
12840
12886
|
}
|
|
12841
12887
|
var InterfaceDeclaration$0 = $TS($S(Interface, $E(_), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12842
12888
|
var id = $3;
|
|
@@ -12892,37 +12938,37 @@ ${input.slice(result.pos)}
|
|
|
12892
12938
|
function InterfaceExtendsTarget(ctx, state) {
|
|
12893
12939
|
return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
|
|
12894
12940
|
}
|
|
12895
|
-
var TypeKeyword$0 = $TS($S($EXPECT($
|
|
12941
|
+
var TypeKeyword$0 = $TS($S($EXPECT($L206, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12896
12942
|
return { $loc, token: $1 };
|
|
12897
12943
|
});
|
|
12898
12944
|
function TypeKeyword(ctx, state) {
|
|
12899
12945
|
return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
|
|
12900
12946
|
}
|
|
12901
|
-
var Enum$0 = $TS($S($EXPECT($
|
|
12947
|
+
var Enum$0 = $TS($S($EXPECT($L207, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12902
12948
|
return { $loc, token: $1 };
|
|
12903
12949
|
});
|
|
12904
12950
|
function Enum(ctx, state) {
|
|
12905
12951
|
return $EVENT(ctx, state, "Enum", Enum$0);
|
|
12906
12952
|
}
|
|
12907
|
-
var Interface$0 = $TS($S($EXPECT($
|
|
12953
|
+
var Interface$0 = $TS($S($EXPECT($L208, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12908
12954
|
return { $loc, token: $1 };
|
|
12909
12955
|
});
|
|
12910
12956
|
function Interface(ctx, state) {
|
|
12911
12957
|
return $EVENT(ctx, state, "Interface", Interface$0);
|
|
12912
12958
|
}
|
|
12913
|
-
var Global$0 = $TS($S($EXPECT($
|
|
12959
|
+
var Global$0 = $TS($S($EXPECT($L209, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12914
12960
|
return { $loc, token: $1 };
|
|
12915
12961
|
});
|
|
12916
12962
|
function Global(ctx, state) {
|
|
12917
12963
|
return $EVENT(ctx, state, "Global", Global$0);
|
|
12918
12964
|
}
|
|
12919
|
-
var Module$0 = $TS($S($EXPECT($
|
|
12965
|
+
var Module$0 = $TS($S($EXPECT($L210, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12920
12966
|
return { $loc, token: $1 };
|
|
12921
12967
|
});
|
|
12922
12968
|
function Module(ctx, state) {
|
|
12923
12969
|
return $EVENT(ctx, state, "Module", Module$0);
|
|
12924
12970
|
}
|
|
12925
|
-
var Namespace$0 = $TS($S($EXPECT($
|
|
12971
|
+
var Namespace$0 = $TS($S($EXPECT($L211, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12926
12972
|
return { $loc, token: $1 };
|
|
12927
12973
|
});
|
|
12928
12974
|
function Namespace(ctx, state) {
|
|
@@ -13138,7 +13184,7 @@ ${input.slice(result.pos)}
|
|
|
13138
13184
|
function TypeProperty(ctx, state) {
|
|
13139
13185
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
13140
13186
|
}
|
|
13141
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
13187
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R80, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R17, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
13142
13188
|
function TypeIndexSignature(ctx, state) {
|
|
13143
13189
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
13144
13190
|
}
|
|
@@ -13196,7 +13242,7 @@ ${input.slice(result.pos)}
|
|
|
13196
13242
|
function ReturnTypeSuffix(ctx, state) {
|
|
13197
13243
|
return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
|
|
13198
13244
|
}
|
|
13199
|
-
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($
|
|
13245
|
+
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L212, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
|
|
13200
13246
|
var asserts = $1;
|
|
13201
13247
|
var t = $2;
|
|
13202
13248
|
if (asserts) {
|
|
@@ -13217,7 +13263,7 @@ ${input.slice(result.pos)}
|
|
|
13217
13263
|
function ReturnType(ctx, state) {
|
|
13218
13264
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
13219
13265
|
}
|
|
13220
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
13266
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L157, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
13221
13267
|
var lhs = $1;
|
|
13222
13268
|
var rhs = $2;
|
|
13223
13269
|
if (!rhs)
|
|
@@ -13275,8 +13321,8 @@ ${input.slice(result.pos)}
|
|
|
13275
13321
|
function TypeUnarySuffix(ctx, state) {
|
|
13276
13322
|
return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
|
|
13277
13323
|
}
|
|
13278
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
13279
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
13324
|
+
var TypeUnaryOp$0 = $S($EXPECT($L213, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
13325
|
+
var TypeUnaryOp$1 = $S($EXPECT($L174, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
13280
13326
|
var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1];
|
|
13281
13327
|
function TypeUnaryOp(ctx, state) {
|
|
13282
13328
|
return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
|
|
@@ -13306,7 +13352,7 @@ ${input.slice(result.pos)}
|
|
|
13306
13352
|
function TypeIndexedAccess(ctx, state) {
|
|
13307
13353
|
return $EVENT_C(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$$);
|
|
13308
13354
|
}
|
|
13309
|
-
var UnknownAlias$0 = $TV($EXPECT($
|
|
13355
|
+
var UnknownAlias$0 = $TV($EXPECT($L214, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
|
|
13310
13356
|
return { $loc, token: "unknown" };
|
|
13311
13357
|
});
|
|
13312
13358
|
function UnknownAlias(ctx, state) {
|
|
@@ -13323,7 +13369,7 @@ ${input.slice(result.pos)}
|
|
|
13323
13369
|
return { ...$2, children: [$1, ...$2.children] };
|
|
13324
13370
|
});
|
|
13325
13371
|
var TypePrimary$3 = InterfaceBlock;
|
|
13326
|
-
var TypePrimary$4 = $S($E(_),
|
|
13372
|
+
var TypePrimary$4 = $S($E(_), TypeFunction);
|
|
13327
13373
|
var TypePrimary$5 = $S($E(_), InlineInterfaceLiteral);
|
|
13328
13374
|
var TypePrimary$6 = $TS($S($E(_), ImportType), function($skip, $loc, $0, $1, $2) {
|
|
13329
13375
|
var t = $2;
|
|
@@ -13512,10 +13558,10 @@ ${input.slice(result.pos)}
|
|
|
13512
13558
|
}
|
|
13513
13559
|
var TypeLiteral$0 = TypeTemplateLiteral;
|
|
13514
13560
|
var TypeLiteral$1 = Literal;
|
|
13515
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
13561
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L196, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13516
13562
|
return { type: "VoidType", $loc, token: $1 };
|
|
13517
13563
|
});
|
|
13518
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
13564
|
+
var TypeLiteral$3 = $TV($EXPECT($L215, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
13519
13565
|
return { $loc, token: "[]" };
|
|
13520
13566
|
});
|
|
13521
13567
|
var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
|
|
@@ -13534,7 +13580,7 @@ ${input.slice(result.pos)}
|
|
|
13534
13580
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
13535
13581
|
return value[1];
|
|
13536
13582
|
});
|
|
13537
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L14, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
13583
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L14, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L118, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L38, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L29, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
13538
13584
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
13539
13585
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
13540
13586
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
@@ -13550,15 +13596,15 @@ ${input.slice(result.pos)}
|
|
|
13550
13596
|
function TypeBinaryOp(ctx, state) {
|
|
13551
13597
|
return $EVENT_C(ctx, state, "TypeBinaryOp", TypeBinaryOp$$);
|
|
13552
13598
|
}
|
|
13553
|
-
var
|
|
13599
|
+
var TypeFunction$0 = $TS($S($E($S($E($S(Abstract, $E(_))), New, $E(_))), Parameters, __, TypeArrowFunction, $E(ReturnType)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
13554
13600
|
var type = $5;
|
|
13555
13601
|
if (type) {
|
|
13556
13602
|
return $0;
|
|
13557
13603
|
}
|
|
13558
13604
|
return [...$0, "void"];
|
|
13559
13605
|
});
|
|
13560
|
-
function
|
|
13561
|
-
return $EVENT(ctx, state, "
|
|
13606
|
+
function TypeFunction(ctx, state) {
|
|
13607
|
+
return $EVENT(ctx, state, "TypeFunction", TypeFunction$0);
|
|
13562
13608
|
}
|
|
13563
13609
|
var TypeArrowFunction$0 = $TV($C($EXPECT($L12, 'TypeArrowFunction "=>"'), $EXPECT($L13, 'TypeArrowFunction "\u21D2"'), $EXPECT($L27, 'TypeArrowFunction "->"'), $EXPECT($L28, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
13564
13610
|
return { $loc, token: "=>" };
|
|
@@ -13586,8 +13632,8 @@ ${input.slice(result.pos)}
|
|
|
13586
13632
|
function TypeArgumentDelimiter(ctx, state) {
|
|
13587
13633
|
return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
|
|
13588
13634
|
}
|
|
13589
|
-
var TypeParameters$0 = $TS($S(
|
|
13590
|
-
var parameters = $
|
|
13635
|
+
var TypeParameters$0 = $TS($S(OpenAngleBracket, $P(TypeParameter), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13636
|
+
var parameters = $2;
|
|
13591
13637
|
return {
|
|
13592
13638
|
type: "TypeParameters",
|
|
13593
13639
|
parameters,
|
|
@@ -13598,11 +13644,11 @@ ${input.slice(result.pos)}
|
|
|
13598
13644
|
function TypeParameters(ctx, state) {
|
|
13599
13645
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
13600
13646
|
}
|
|
13601
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
13647
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L156, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
13602
13648
|
function TypeParameter(ctx, state) {
|
|
13603
13649
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
13604
13650
|
}
|
|
13605
|
-
var TypeConstraint$0 = $S(__,
|
|
13651
|
+
var TypeConstraint$0 = $S(__, ExtendsToken, Type);
|
|
13606
13652
|
function TypeConstraint(ctx, state) {
|
|
13607
13653
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
13608
13654
|
}
|
|
@@ -13641,7 +13687,7 @@ ${input.slice(result.pos)}
|
|
|
13641
13687
|
function CivetPrologue(ctx, state) {
|
|
13642
13688
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
13643
13689
|
}
|
|
13644
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
13690
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L216, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R85, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13645
13691
|
var options = $3;
|
|
13646
13692
|
return {
|
|
13647
13693
|
type: "CivetPrologue",
|
|
@@ -13825,6 +13871,12 @@ ${input.slice(result.pos)}
|
|
|
13825
13871
|
function InsertVar(ctx, state) {
|
|
13826
13872
|
return $EVENT(ctx, state, "InsertVar", InsertVar$0);
|
|
13827
13873
|
}
|
|
13874
|
+
var InsertType$0 = $TV($EXPECT($L0, 'InsertType ""'), function($skip, $loc, $0, $1) {
|
|
13875
|
+
return { $loc, token: "type " };
|
|
13876
|
+
});
|
|
13877
|
+
function InsertType(ctx, state) {
|
|
13878
|
+
return $EVENT(ctx, state, "InsertType", InsertType$0);
|
|
13879
|
+
}
|
|
13828
13880
|
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L0, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
13829
13881
|
if (module.config.coffeeBinaryExistential)
|
|
13830
13882
|
return;
|
|
@@ -14044,9 +14096,9 @@ ${input.slice(result.pos)}
|
|
|
14044
14096
|
hasProp(hasPropRef) {
|
|
14045
14097
|
const typeSuffix = {
|
|
14046
14098
|
ts: true,
|
|
14047
|
-
children: [": <T>(object: T, prop:
|
|
14099
|
+
children: [": <T>(object: T, prop: PropertyKey) => boolean"]
|
|
14048
14100
|
};
|
|
14049
|
-
module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.constructor
|
|
14101
|
+
module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = ({}.constructor", asAny, ").hasOwn;\n"]]);
|
|
14050
14102
|
},
|
|
14051
14103
|
is(isRef) {
|
|
14052
14104
|
const typeSuffix = {
|
|
@@ -14410,6 +14462,7 @@ ${input.slice(result.pos)}
|
|
|
14410
14462
|
exports.ArrowFunction = ArrowFunction;
|
|
14411
14463
|
exports.FatArrow = FatArrow;
|
|
14412
14464
|
exports.TrailingDeclaration = TrailingDeclaration;
|
|
14465
|
+
exports.TrailingPipe = TrailingPipe;
|
|
14413
14466
|
exports.FatArrowBody = FatArrowBody;
|
|
14414
14467
|
exports.ConditionalExpression = ConditionalExpression;
|
|
14415
14468
|
exports.TernaryRest = TernaryRest;
|
|
@@ -14735,6 +14788,7 @@ ${input.slice(result.pos)}
|
|
|
14735
14788
|
exports.LexicalDeclaration = LexicalDeclaration;
|
|
14736
14789
|
exports.ConstAssignment = ConstAssignment;
|
|
14737
14790
|
exports.LetAssignment = LetAssignment;
|
|
14791
|
+
exports.TypeAssignment = TypeAssignment;
|
|
14738
14792
|
exports.LexicalBinding = LexicalBinding;
|
|
14739
14793
|
exports.Initializer = Initializer;
|
|
14740
14794
|
exports.VariableStatement = VariableStatement;
|
|
@@ -15010,7 +15064,7 @@ ${input.slice(result.pos)}
|
|
|
15010
15064
|
exports.InlineBasicInterfaceProperty = InlineBasicInterfaceProperty;
|
|
15011
15065
|
exports.InlineInterfacePropertyDelimiter = InlineInterfacePropertyDelimiter;
|
|
15012
15066
|
exports.TypeBinaryOp = TypeBinaryOp;
|
|
15013
|
-
exports.
|
|
15067
|
+
exports.TypeFunction = TypeFunction;
|
|
15014
15068
|
exports.TypeArrowFunction = TypeArrowFunction;
|
|
15015
15069
|
exports.TypeArguments = TypeArguments;
|
|
15016
15070
|
exports.TypeArgument = TypeArgument;
|
|
@@ -15052,6 +15106,7 @@ ${input.slice(result.pos)}
|
|
|
15052
15106
|
exports.InsertDot = InsertDot;
|
|
15053
15107
|
exports.InsertBreak = InsertBreak;
|
|
15054
15108
|
exports.InsertVar = InsertVar;
|
|
15109
|
+
exports.InsertType = InsertType;
|
|
15055
15110
|
exports.CoffeeBinaryExistentialEnabled = CoffeeBinaryExistentialEnabled;
|
|
15056
15111
|
exports.CoffeeBooleansEnabled = CoffeeBooleansEnabled;
|
|
15057
15112
|
exports.CoffeeClassesEnabled = CoffeeClassesEnabled;
|