@danielx/civet 0.4.21 → 0.4.23
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/README.md +5 -4
- package/dist/browser.js +433 -191
- package/dist/main.js +433 -191
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -400,6 +400,7 @@ ${input.slice(result.pos)}
|
|
|
400
400
|
Expression,
|
|
401
401
|
Arguments,
|
|
402
402
|
ApplicationStart,
|
|
403
|
+
IndentedApplicationAllowed,
|
|
403
404
|
ArgumentsWithTrailingCallExpressions,
|
|
404
405
|
ArgumentList,
|
|
405
406
|
NestedArgumentList,
|
|
@@ -458,6 +459,7 @@ ${input.slice(result.pos)}
|
|
|
458
459
|
ParameterElement,
|
|
459
460
|
ParameterElementDelimiter,
|
|
460
461
|
BindingIdentifier,
|
|
462
|
+
AtIdentifierRef,
|
|
461
463
|
BindingPattern,
|
|
462
464
|
ObjectBindingPattern,
|
|
463
465
|
ObjectBindingPatternContent,
|
|
@@ -587,6 +589,8 @@ ${input.slice(result.pos)}
|
|
|
587
589
|
Finally,
|
|
588
590
|
CatchParameter,
|
|
589
591
|
Condition,
|
|
592
|
+
ExpressionWithIndentedApplicationSuppressed,
|
|
593
|
+
SuppressIndentedApplication,
|
|
590
594
|
ExpressionStatement,
|
|
591
595
|
KeywordStatement,
|
|
592
596
|
DebuggerExpression,
|
|
@@ -605,9 +609,11 @@ ${input.slice(result.pos)}
|
|
|
605
609
|
UnquotedSpecifier,
|
|
606
610
|
ImportedBinding,
|
|
607
611
|
ExportDeclaration,
|
|
612
|
+
ExportVarDec,
|
|
608
613
|
ExportFromClause,
|
|
609
614
|
NamedExports,
|
|
610
615
|
ExportSpecifier,
|
|
616
|
+
ImplicitExportSpecifier,
|
|
611
617
|
Declaration,
|
|
612
618
|
HoistableDeclaration,
|
|
613
619
|
LexicalDeclaration,
|
|
@@ -802,6 +808,7 @@ ${input.slice(result.pos)}
|
|
|
802
808
|
InsertOpenParen,
|
|
803
809
|
InsertCloseParen,
|
|
804
810
|
InsertOpenBrace,
|
|
811
|
+
InsertInlineOpenBrace,
|
|
805
812
|
InsertCloseBrace,
|
|
806
813
|
InsertConst,
|
|
807
814
|
InsertReadonly,
|
|
@@ -810,6 +817,7 @@ ${input.slice(result.pos)}
|
|
|
810
817
|
InsertSpace,
|
|
811
818
|
InsertDot,
|
|
812
819
|
InsertBreak,
|
|
820
|
+
InsertVar,
|
|
813
821
|
CoffeeBinaryExistentialEnabled,
|
|
814
822
|
CoffeeBooleansEnabled,
|
|
815
823
|
CoffeeClassesEnabled,
|
|
@@ -831,20 +839,20 @@ ${input.slice(result.pos)}
|
|
|
831
839
|
PopIndent,
|
|
832
840
|
Nested
|
|
833
841
|
});
|
|
834
|
-
var $L0 = $L("
|
|
835
|
-
var $L1 = $L("
|
|
836
|
-
var $L2 = $L("
|
|
837
|
-
var $L3 = $L("
|
|
838
|
-
var $L4 = $L("
|
|
839
|
-
var $L5 = $L("
|
|
840
|
-
var $L6 = $L("
|
|
841
|
-
var $L7 = $L("
|
|
842
|
-
var $L8 = $L("
|
|
843
|
-
var $L9 = $L("
|
|
844
|
-
var $L10 = $L("
|
|
845
|
-
var $L11 = $L("
|
|
846
|
-
var $L12 = $L("
|
|
847
|
-
var $L13 = $L("");
|
|
842
|
+
var $L0 = $L("");
|
|
843
|
+
var $L1 = $L("++");
|
|
844
|
+
var $L2 = $L("--");
|
|
845
|
+
var $L3 = $L("=>");
|
|
846
|
+
var $L4 = $L(" ");
|
|
847
|
+
var $L5 = $L("<");
|
|
848
|
+
var $L6 = $L("extends");
|
|
849
|
+
var $L7 = $L("#");
|
|
850
|
+
var $L8 = $L(".");
|
|
851
|
+
var $L9 = $L("super");
|
|
852
|
+
var $L10 = $L("import");
|
|
853
|
+
var $L11 = $L("!");
|
|
854
|
+
var $L12 = $L("super[");
|
|
855
|
+
var $L13 = $L("import.meta");
|
|
848
856
|
var $L14 = $L(")");
|
|
849
857
|
var $L15 = $L("->");
|
|
850
858
|
var $L16 = $L("null");
|
|
@@ -1022,26 +1030,27 @@ ${input.slice(result.pos)}
|
|
|
1022
1030
|
var $R30 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1023
1031
|
var $R31 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1024
1032
|
var $R32 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1025
|
-
var $R33 = $R(new RegExp("(?:
|
|
1026
|
-
var $R34 = $R(new RegExp("
|
|
1027
|
-
var $R35 = $R(new RegExp("
|
|
1028
|
-
var $R36 = $R(new RegExp("
|
|
1029
|
-
var $R37 = $R(new RegExp("
|
|
1030
|
-
var $R38 = $R(new RegExp("
|
|
1031
|
-
var $R39 = $R(new RegExp("[
|
|
1032
|
-
var $R40 = $R(new RegExp("
|
|
1033
|
-
var $R41 = $R(new RegExp("
|
|
1034
|
-
var $R42 = $R(new RegExp("
|
|
1035
|
-
var $R43 = $R(new RegExp(
|
|
1036
|
-
var $R44 = $R(new RegExp("
|
|
1037
|
-
var $R45 = $R(new RegExp("[^
|
|
1038
|
-
var $R46 = $R(new RegExp("[
|
|
1039
|
-
var $R47 = $R(new RegExp("[+-]", "suy"));
|
|
1040
|
-
var $R48 = $R(new RegExp("
|
|
1041
|
-
var $R49 = $R(new RegExp("[\\
|
|
1042
|
-
var $R50 = $R(new RegExp("[\\
|
|
1043
|
-
var $R51 = $R(new RegExp("\\s
|
|
1044
|
-
var $R52 = $R(new RegExp("\\
|
|
1033
|
+
var $R33 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1034
|
+
var $R34 = $R(new RegExp("(?:and|as|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|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
1035
|
+
var $R35 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1036
|
+
var $R36 = $R(new RegExp(".", "suy"));
|
|
1037
|
+
var $R37 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
1038
|
+
var $R38 = $R(new RegExp("###(?!#)", "suy"));
|
|
1039
|
+
var $R39 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
1040
|
+
var $R40 = $R(new RegExp("[ \\t]+", "suy"));
|
|
1041
|
+
var $R41 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
1042
|
+
var $R42 = $R(new RegExp("\\s", "suy"));
|
|
1043
|
+
var $R43 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1044
|
+
var $R44 = $R(new RegExp('"[^"]*"', "suy"));
|
|
1045
|
+
var $R45 = $R(new RegExp("'[^']*'", "suy"));
|
|
1046
|
+
var $R46 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
1047
|
+
var $R47 = $R(new RegExp("[+-]?", "suy"));
|
|
1048
|
+
var $R48 = $R(new RegExp("[+-]", "suy"));
|
|
1049
|
+
var $R49 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1050
|
+
var $R50 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1051
|
+
var $R51 = $R(new RegExp("[\\s]*", "suy"));
|
|
1052
|
+
var $R52 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
|
|
1053
|
+
var $R53 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1045
1054
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1046
1055
|
var statements = $4;
|
|
1047
1056
|
module2.processProgram(statements);
|
|
@@ -1188,7 +1197,7 @@ ${input.slice(result.pos)}
|
|
|
1188
1197
|
return result;
|
|
1189
1198
|
}
|
|
1190
1199
|
}
|
|
1191
|
-
var ApplicationStart$0 = $Y(NestedImplicitObjectLiteral);
|
|
1200
|
+
var ApplicationStart$0 = $S(IndentedApplicationAllowed, $Y(NestedImplicitObjectLiteral));
|
|
1192
1201
|
var ApplicationStart$1 = $S($N(EOS), $Y($S($P(_), $N(AdditionalReservedWords))));
|
|
1193
1202
|
function ApplicationStart(state) {
|
|
1194
1203
|
if (state.events) {
|
|
@@ -1208,6 +1217,29 @@ ${input.slice(result.pos)}
|
|
|
1208
1217
|
return result;
|
|
1209
1218
|
}
|
|
1210
1219
|
}
|
|
1220
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L0, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
1221
|
+
if (module2.suppressIndentedApplication)
|
|
1222
|
+
return $skip;
|
|
1223
|
+
return;
|
|
1224
|
+
});
|
|
1225
|
+
function IndentedApplicationAllowed(state) {
|
|
1226
|
+
if (state.events) {
|
|
1227
|
+
const result = state.events.enter?.("IndentedApplicationAllowed", state);
|
|
1228
|
+
if (result)
|
|
1229
|
+
return result.cache;
|
|
1230
|
+
}
|
|
1231
|
+
if (state.tokenize) {
|
|
1232
|
+
const result = $TOKEN("IndentedApplicationAllowed", state, IndentedApplicationAllowed$0(state));
|
|
1233
|
+
if (state.events)
|
|
1234
|
+
state.events.exit?.("IndentedApplicationAllowed", state, result);
|
|
1235
|
+
return result;
|
|
1236
|
+
} else {
|
|
1237
|
+
const result = IndentedApplicationAllowed$0(state);
|
|
1238
|
+
if (state.events)
|
|
1239
|
+
state.events.exit?.("IndentedApplicationAllowed", state, result);
|
|
1240
|
+
return result;
|
|
1241
|
+
}
|
|
1242
|
+
}
|
|
1211
1243
|
var ArgumentsWithTrailingCallExpressions$0 = $S(Arguments, $Q($S(Samedent, $N(Backtick), CallExpressionRest)));
|
|
1212
1244
|
function ArgumentsWithTrailingCallExpressions(state) {
|
|
1213
1245
|
if (state.events) {
|
|
@@ -1540,7 +1572,7 @@ ${input.slice(result.pos)}
|
|
|
1540
1572
|
return result;
|
|
1541
1573
|
}
|
|
1542
1574
|
}
|
|
1543
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
1575
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L1, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L2, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
1544
1576
|
return { $loc, token: $1 };
|
|
1545
1577
|
});
|
|
1546
1578
|
function UpdateExpressionSymbol(state) {
|
|
@@ -1739,7 +1771,7 @@ ${input.slice(result.pos)}
|
|
|
1739
1771
|
return result;
|
|
1740
1772
|
}
|
|
1741
1773
|
}
|
|
1742
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1774
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L3, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1743
1775
|
var ws = $1;
|
|
1744
1776
|
if (!ws.length)
|
|
1745
1777
|
return " =>";
|
|
@@ -1810,7 +1842,7 @@ ${input.slice(result.pos)}
|
|
|
1810
1842
|
}
|
|
1811
1843
|
}
|
|
1812
1844
|
var TernaryRest$0 = NestedTernaryRest;
|
|
1813
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
1845
|
+
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($L4, fail, 'TernaryRest " "')), $Q(TrailingComment), QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
1814
1846
|
return $0.slice(2);
|
|
1815
1847
|
});
|
|
1816
1848
|
function TernaryRest(state) {
|
|
@@ -1990,10 +2022,10 @@ ${input.slice(result.pos)}
|
|
|
1990
2022
|
return result;
|
|
1991
2023
|
}
|
|
1992
2024
|
}
|
|
1993
|
-
var ExtendsToken$0 = $TV($EXPECT($
|
|
2025
|
+
var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1994
2026
|
return { $loc, token: "extends" };
|
|
1995
2027
|
});
|
|
1996
|
-
var ExtendsToken$1 = $TV($EXPECT($
|
|
2028
|
+
var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1997
2029
|
return { $loc, token: $1 };
|
|
1998
2030
|
});
|
|
1999
2031
|
function ExtendsToken(state) {
|
|
@@ -2015,7 +2047,7 @@ ${input.slice(result.pos)}
|
|
|
2015
2047
|
}
|
|
2016
2048
|
}
|
|
2017
2049
|
var ClassBody$0 = $S(__, OpenBrace, $E(NestedClassElements), __, CloseBrace);
|
|
2018
|
-
var ClassBody$1 = $S(InsertOpenBrace, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
2050
|
+
var ClassBody$1 = $S(InsertOpenBrace, $E(NestedClassElements), InsertNewline, InsertIndent, InsertCloseBrace);
|
|
2019
2051
|
function ClassBody(state) {
|
|
2020
2052
|
if (state.events) {
|
|
2021
2053
|
const result = state.events.enter?.("ClassBody", state);
|
|
@@ -2139,7 +2171,7 @@ ${input.slice(result.pos)}
|
|
|
2139
2171
|
}
|
|
2140
2172
|
}
|
|
2141
2173
|
var ThisLiteral$0 = This;
|
|
2142
|
-
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($
|
|
2174
|
+
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($L7, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
|
|
2143
2175
|
var t = $1;
|
|
2144
2176
|
var id = $2;
|
|
2145
2177
|
return [{ ...t, token: "this." }, id];
|
|
@@ -2166,7 +2198,7 @@ ${input.slice(result.pos)}
|
|
|
2166
2198
|
return result;
|
|
2167
2199
|
}
|
|
2168
2200
|
}
|
|
2169
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($
|
|
2201
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L8, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
2170
2202
|
if ($1.length)
|
|
2171
2203
|
return $0;
|
|
2172
2204
|
return $2;
|
|
@@ -2189,8 +2221,8 @@ ${input.slice(result.pos)}
|
|
|
2189
2221
|
return result;
|
|
2190
2222
|
}
|
|
2191
2223
|
}
|
|
2192
|
-
var CallExpression$0 = $S($EXPECT($
|
|
2193
|
-
var CallExpression$1 = $S($EXPECT($
|
|
2224
|
+
var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
2225
|
+
var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
|
|
2194
2226
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
2195
2227
|
if ($2.length)
|
|
2196
2228
|
return $0;
|
|
@@ -2254,7 +2286,7 @@ ${input.slice(result.pos)}
|
|
|
2254
2286
|
return result;
|
|
2255
2287
|
}
|
|
2256
2288
|
}
|
|
2257
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
2289
|
+
var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
|
|
2258
2290
|
return { "ts": true, "children": value };
|
|
2259
2291
|
});
|
|
2260
2292
|
function NonNullAssertion(state) {
|
|
@@ -2494,7 +2526,7 @@ ${input.slice(result.pos)}
|
|
|
2494
2526
|
return result;
|
|
2495
2527
|
}
|
|
2496
2528
|
}
|
|
2497
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
2529
|
+
var SuperProperty$0 = $S($EXPECT($L12, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
2498
2530
|
function SuperProperty(state) {
|
|
2499
2531
|
if (state.events) {
|
|
2500
2532
|
const result = state.events.enter?.("SuperProperty", state);
|
|
@@ -2514,7 +2546,7 @@ ${input.slice(result.pos)}
|
|
|
2514
2546
|
}
|
|
2515
2547
|
}
|
|
2516
2548
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
2517
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
2549
|
+
var MetaProperty$1 = $TV($EXPECT($L13, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
2518
2550
|
return { $loc, token: $1 };
|
|
2519
2551
|
});
|
|
2520
2552
|
function MetaProperty(state) {
|
|
@@ -2536,7 +2568,7 @@ ${input.slice(result.pos)}
|
|
|
2536
2568
|
}
|
|
2537
2569
|
}
|
|
2538
2570
|
var Parameters$0 = NonEmptyParameters;
|
|
2539
|
-
var Parameters$1 = $TV($EXPECT($
|
|
2571
|
+
var Parameters$1 = $TV($EXPECT($L0, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
2540
2572
|
return {
|
|
2541
2573
|
type: "Parameters",
|
|
2542
2574
|
children: [{ $loc, token: "()" }],
|
|
@@ -2697,21 +2729,18 @@ ${input.slice(result.pos)}
|
|
|
2697
2729
|
return result;
|
|
2698
2730
|
}
|
|
2699
2731
|
}
|
|
2700
|
-
var BindingIdentifier$0 = $TS($S(__,
|
|
2732
|
+
var BindingIdentifier$0 = $TS($S(__, At, AtIdentifierRef), function($skip, $loc, $0, $1, $2, $3) {
|
|
2701
2733
|
var ws = $1;
|
|
2702
|
-
var
|
|
2703
|
-
|
|
2704
|
-
|
|
2705
|
-
|
|
2706
|
-
|
|
2707
|
-
|
|
2708
|
-
|
|
2709
|
-
|
|
2710
|
-
|
|
2711
|
-
|
|
2712
|
-
ref
|
|
2713
|
-
};
|
|
2714
|
-
}
|
|
2734
|
+
var ref = $3;
|
|
2735
|
+
return {
|
|
2736
|
+
type: "AtBinding",
|
|
2737
|
+
children: [...ws, ref],
|
|
2738
|
+
ref
|
|
2739
|
+
};
|
|
2740
|
+
});
|
|
2741
|
+
var BindingIdentifier$1 = $TS($S(__, Identifier), function($skip, $loc, $0, $1, $2) {
|
|
2742
|
+
var ws = $1;
|
|
2743
|
+
var id = $2;
|
|
2715
2744
|
return {
|
|
2716
2745
|
...id,
|
|
2717
2746
|
children: [...ws, ...id.children]
|
|
@@ -2724,17 +2753,51 @@ ${input.slice(result.pos)}
|
|
|
2724
2753
|
return result.cache;
|
|
2725
2754
|
}
|
|
2726
2755
|
if (state.tokenize) {
|
|
2727
|
-
const result = $TOKEN("BindingIdentifier", state, BindingIdentifier$0(state));
|
|
2756
|
+
const result = $TOKEN("BindingIdentifier", state, BindingIdentifier$0(state) || BindingIdentifier$1(state));
|
|
2728
2757
|
if (state.events)
|
|
2729
2758
|
state.events.exit?.("BindingIdentifier", state, result);
|
|
2730
2759
|
return result;
|
|
2731
2760
|
} else {
|
|
2732
|
-
const result = BindingIdentifier$0(state);
|
|
2761
|
+
const result = BindingIdentifier$0(state) || BindingIdentifier$1(state);
|
|
2733
2762
|
if (state.events)
|
|
2734
2763
|
state.events.exit?.("BindingIdentifier", state, result);
|
|
2735
2764
|
return result;
|
|
2736
2765
|
}
|
|
2737
2766
|
}
|
|
2767
|
+
var AtIdentifierRef$0 = $TV(ReservedWord, function($skip, $loc, $0, $1) {
|
|
2768
|
+
var r = $0;
|
|
2769
|
+
return {
|
|
2770
|
+
type: "Ref",
|
|
2771
|
+
base: `_${r}`,
|
|
2772
|
+
id: r
|
|
2773
|
+
};
|
|
2774
|
+
});
|
|
2775
|
+
var AtIdentifierRef$1 = $TV(IdentifierName, function($skip, $loc, $0, $1) {
|
|
2776
|
+
var id = $0;
|
|
2777
|
+
return {
|
|
2778
|
+
type: "Ref",
|
|
2779
|
+
base: id.name,
|
|
2780
|
+
id: id.name
|
|
2781
|
+
};
|
|
2782
|
+
});
|
|
2783
|
+
function AtIdentifierRef(state) {
|
|
2784
|
+
if (state.events) {
|
|
2785
|
+
const result = state.events.enter?.("AtIdentifierRef", state);
|
|
2786
|
+
if (result)
|
|
2787
|
+
return result.cache;
|
|
2788
|
+
}
|
|
2789
|
+
if (state.tokenize) {
|
|
2790
|
+
const result = $TOKEN("AtIdentifierRef", state, AtIdentifierRef$0(state) || AtIdentifierRef$1(state));
|
|
2791
|
+
if (state.events)
|
|
2792
|
+
state.events.exit?.("AtIdentifierRef", state, result);
|
|
2793
|
+
return result;
|
|
2794
|
+
} else {
|
|
2795
|
+
const result = AtIdentifierRef$0(state) || AtIdentifierRef$1(state);
|
|
2796
|
+
if (state.events)
|
|
2797
|
+
state.events.exit?.("AtIdentifierRef", state, result);
|
|
2798
|
+
return result;
|
|
2799
|
+
}
|
|
2800
|
+
}
|
|
2738
2801
|
var BindingPattern$0 = $TS($S(__, ObjectBindingPattern), function($skip, $loc, $0, $1, $2) {
|
|
2739
2802
|
var p = $2;
|
|
2740
2803
|
return {
|
|
@@ -3226,8 +3289,12 @@ ${input.slice(result.pos)}
|
|
|
3226
3289
|
return result;
|
|
3227
3290
|
}
|
|
3228
3291
|
}
|
|
3229
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
3230
|
-
const ref = {
|
|
3292
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L0, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
3293
|
+
const ref = {
|
|
3294
|
+
type: "Ref",
|
|
3295
|
+
base: "ref",
|
|
3296
|
+
id: "ref"
|
|
3297
|
+
};
|
|
3231
3298
|
return {
|
|
3232
3299
|
type: "EmptyBinding",
|
|
3233
3300
|
children: [ref],
|
|
@@ -4172,7 +4239,7 @@ ${input.slice(result.pos)}
|
|
|
4172
4239
|
return result;
|
|
4173
4240
|
}
|
|
4174
4241
|
}
|
|
4175
|
-
var ArrayElementDelimiter$0 = $S(
|
|
4242
|
+
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
4176
4243
|
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
4177
4244
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
4178
4245
|
return { $loc, token: "," };
|
|
@@ -4230,7 +4297,7 @@ ${input.slice(result.pos)}
|
|
|
4230
4297
|
return result;
|
|
4231
4298
|
}
|
|
4232
4299
|
}
|
|
4233
|
-
var ElementListRest$0 = $S($S(__, Comma
|
|
4300
|
+
var ElementListRest$0 = $S($S(__, Comma), ArrayElementExpression);
|
|
4234
4301
|
function ElementListRest(state) {
|
|
4235
4302
|
if (state.events) {
|
|
4236
4303
|
const result = state.events.enter?.("ElementListRest", state);
|
|
@@ -4257,6 +4324,7 @@ ${input.slice(result.pos)}
|
|
|
4257
4324
|
exp = {
|
|
4258
4325
|
type: "Ref",
|
|
4259
4326
|
base: "ref",
|
|
4327
|
+
id: "ref",
|
|
4260
4328
|
names: []
|
|
4261
4329
|
};
|
|
4262
4330
|
}
|
|
@@ -4514,10 +4582,10 @@ ${input.slice(result.pos)}
|
|
|
4514
4582
|
return result;
|
|
4515
4583
|
}
|
|
4516
4584
|
}
|
|
4517
|
-
var InlineObjectLiteral$0 = $TS($S(
|
|
4585
|
+
var InlineObjectLiteral$0 = $TS($S(InsertInlineOpenBrace, SnugNamedProperty, ImplicitInlineObjectPropertyDelimiter, $Q($S(NamedProperty, ImplicitInlineObjectPropertyDelimiter)), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4518
4586
|
var open = $1;
|
|
4519
4587
|
var close = $5;
|
|
4520
|
-
return [open
|
|
4588
|
+
return [open, $2, $3, ...$4, close];
|
|
4521
4589
|
});
|
|
4522
4590
|
function InlineObjectLiteral(state) {
|
|
4523
4591
|
if (state.events) {
|
|
@@ -4843,7 +4911,7 @@ ${input.slice(result.pos)}
|
|
|
4843
4911
|
return result;
|
|
4844
4912
|
}
|
|
4845
4913
|
}
|
|
4846
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
4914
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L7, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
4847
4915
|
return {
|
|
4848
4916
|
type: "Identifier",
|
|
4849
4917
|
name: $0,
|
|
@@ -4995,7 +5063,7 @@ ${input.slice(result.pos)}
|
|
|
4995
5063
|
var BinaryOpSymbol$6 = $EXPECT($L53, fail, 'BinaryOpSymbol "<="');
|
|
4996
5064
|
var BinaryOpSymbol$7 = $EXPECT($L54, fail, 'BinaryOpSymbol ">="');
|
|
4997
5065
|
var BinaryOpSymbol$8 = $EXPECT($L55, fail, 'BinaryOpSymbol "<<"');
|
|
4998
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
5066
|
+
var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
|
|
4999
5067
|
var BinaryOpSymbol$10 = $EXPECT($L56, fail, 'BinaryOpSymbol ">>>"');
|
|
5000
5068
|
var BinaryOpSymbol$11 = $EXPECT($L57, fail, 'BinaryOpSymbol ">>"');
|
|
5001
5069
|
var BinaryOpSymbol$12 = $EXPECT($L25, fail, 'BinaryOpSymbol ">"');
|
|
@@ -5044,26 +5112,33 @@ ${input.slice(result.pos)}
|
|
|
5044
5112
|
special: true
|
|
5045
5113
|
};
|
|
5046
5114
|
});
|
|
5047
|
-
var BinaryOpSymbol$28 = $TS($S(
|
|
5115
|
+
var BinaryOpSymbol$28 = $TS($S(CoffeeNotEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L66, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5116
|
+
return {
|
|
5117
|
+
$loc,
|
|
5118
|
+
token: "in",
|
|
5119
|
+
special: true
|
|
5120
|
+
};
|
|
5121
|
+
});
|
|
5122
|
+
var BinaryOpSymbol$29 = $TS($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5048
5123
|
return {
|
|
5049
5124
|
ref: module2.getIndexOfRef(),
|
|
5050
5125
|
suffix: " >= 0",
|
|
5051
5126
|
special: true
|
|
5052
5127
|
};
|
|
5053
5128
|
});
|
|
5054
|
-
var BinaryOpSymbol$
|
|
5129
|
+
var BinaryOpSymbol$30 = $TS($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5055
5130
|
return {
|
|
5056
5131
|
ref: module2.getIndexOfRef(),
|
|
5057
5132
|
suffix: " < 0",
|
|
5058
5133
|
special: true
|
|
5059
5134
|
};
|
|
5060
5135
|
});
|
|
5061
|
-
var BinaryOpSymbol$
|
|
5136
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5062
5137
|
return $1;
|
|
5063
5138
|
});
|
|
5064
|
-
var BinaryOpSymbol$
|
|
5065
|
-
var BinaryOpSymbol$
|
|
5066
|
-
var BinaryOpSymbol$
|
|
5139
|
+
var BinaryOpSymbol$32 = $EXPECT($L74, fail, 'BinaryOpSymbol "&"');
|
|
5140
|
+
var BinaryOpSymbol$33 = $EXPECT($L75, fail, 'BinaryOpSymbol "^"');
|
|
5141
|
+
var BinaryOpSymbol$34 = $EXPECT($L76, fail, 'BinaryOpSymbol "|"');
|
|
5067
5142
|
function BinaryOpSymbol(state) {
|
|
5068
5143
|
if (state.events) {
|
|
5069
5144
|
const result = state.events.enter?.("BinaryOpSymbol", state);
|
|
@@ -5071,12 +5146,12 @@ ${input.slice(result.pos)}
|
|
|
5071
5146
|
return result.cache;
|
|
5072
5147
|
}
|
|
5073
5148
|
if (state.tokenize) {
|
|
5074
|
-
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state));
|
|
5149
|
+
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state));
|
|
5075
5150
|
if (state.events)
|
|
5076
5151
|
state.events.exit?.("BinaryOpSymbol", state, result);
|
|
5077
5152
|
return result;
|
|
5078
5153
|
} else {
|
|
5079
|
-
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state);
|
|
5154
|
+
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state);
|
|
5080
5155
|
if (state.events)
|
|
5081
5156
|
state.events.exit?.("BinaryOpSymbol", state, result);
|
|
5082
5157
|
return result;
|
|
@@ -5871,11 +5946,13 @@ ${input.slice(result.pos)}
|
|
|
5871
5946
|
} else if (kind.token === "in") {
|
|
5872
5947
|
const counterRef = {
|
|
5873
5948
|
type: "Ref",
|
|
5874
|
-
base: "i"
|
|
5949
|
+
base: "i",
|
|
5950
|
+
id: "i"
|
|
5875
5951
|
};
|
|
5876
5952
|
const lenRef = {
|
|
5877
5953
|
type: "Ref",
|
|
5878
|
-
base: "len"
|
|
5954
|
+
base: "len",
|
|
5955
|
+
id: "len"
|
|
5879
5956
|
};
|
|
5880
5957
|
let expRef;
|
|
5881
5958
|
switch (exp.type) {
|
|
@@ -5893,7 +5970,8 @@ ${input.slice(result.pos)}
|
|
|
5893
5970
|
} else {
|
|
5894
5971
|
stepRef = {
|
|
5895
5972
|
type: "Ref",
|
|
5896
|
-
base: "step"
|
|
5973
|
+
base: "step",
|
|
5974
|
+
id: "step"
|
|
5897
5975
|
};
|
|
5898
5976
|
}
|
|
5899
5977
|
}
|
|
@@ -5905,7 +5983,8 @@ ${input.slice(result.pos)}
|
|
|
5905
5983
|
} else {
|
|
5906
5984
|
startRef = {
|
|
5907
5985
|
type: "Ref",
|
|
5908
|
-
base: "ref"
|
|
5986
|
+
base: "ref",
|
|
5987
|
+
id: "ref"
|
|
5909
5988
|
};
|
|
5910
5989
|
}
|
|
5911
5990
|
if (end.type === "Literal") {
|
|
@@ -5915,7 +5994,8 @@ ${input.slice(result.pos)}
|
|
|
5915
5994
|
} else {
|
|
5916
5995
|
endRef = {
|
|
5917
5996
|
type: "Ref",
|
|
5918
|
-
base: "ref"
|
|
5997
|
+
base: "ref",
|
|
5998
|
+
id: "ref"
|
|
5919
5999
|
};
|
|
5920
6000
|
}
|
|
5921
6001
|
const startRefDec = startRef !== start ? [startRef, " = ", start, ", "] : [];
|
|
@@ -5933,45 +6013,65 @@ ${input.slice(result.pos)}
|
|
|
5933
6013
|
names: varRef2.names
|
|
5934
6014
|
}]);
|
|
5935
6015
|
const counterPart = inclusive ? [counterRef, " <= ", endRef, " : ", counterRef, " >= ", endRef] : [counterRef, " < ", endRef, " : ", counterRef, " > ", endRef];
|
|
5936
|
-
const
|
|
5937
|
-
const
|
|
6016
|
+
const condition2 = stepRef ? [stepRef, " !== 0 && (", stepRef, " > 0 ? ", ...counterPart, ")"] : ["asc ? ", ...counterPart];
|
|
6017
|
+
const increment2 = stepRef ? [varRef2, " = ", counterRef, " += ", stepRef] : [varRef2, " = asc ? ++", counterRef, " : --", counterRef];
|
|
5938
6018
|
return {
|
|
5939
6019
|
declaration,
|
|
5940
|
-
children: [$1, open, declaration, "; ", ...
|
|
6020
|
+
children: [$1, open, declaration, "; ", ...condition2, "; ", ...increment2, close],
|
|
5941
6021
|
blockPrefix
|
|
5942
6022
|
};
|
|
5943
6023
|
}
|
|
5944
6024
|
default:
|
|
5945
6025
|
expRef = {
|
|
5946
6026
|
type: "Ref",
|
|
5947
|
-
base: "ref"
|
|
6027
|
+
base: "ref",
|
|
6028
|
+
id: "ref"
|
|
5948
6029
|
};
|
|
5949
6030
|
}
|
|
5950
|
-
if (step) {
|
|
5951
|
-
throw new Error("by clause not yet implement in non-range for in loops");
|
|
5952
|
-
}
|
|
5953
6031
|
const varRef = declaration;
|
|
5954
|
-
|
|
5955
|
-
declaration = {
|
|
5956
|
-
type: "Declaration",
|
|
5957
|
-
children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
|
|
5958
|
-
names: []
|
|
5959
|
-
};
|
|
5960
|
-
let indexAssignment;
|
|
5961
|
-
let assignmentNames = [...varRef.names];
|
|
6032
|
+
let increment = "++", indexAssignment, assignmentNames = [...varRef.names];
|
|
5962
6033
|
if (index) {
|
|
5963
6034
|
index = module2.insertTrimmingSpace(index, "");
|
|
5964
6035
|
indexAssignment = [index, "="];
|
|
5965
6036
|
assignmentNames.push(...index.names);
|
|
5966
6037
|
}
|
|
6038
|
+
const expRefDec = expRef !== exp ? [expRef, " = ", module2.insertTrimmingSpace(exp, ""), ", "] : [];
|
|
5967
6039
|
blockPrefix.push([indent, {
|
|
5968
6040
|
type: "AssignmentExpression",
|
|
5969
6041
|
children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
|
|
5970
6042
|
names: assignmentNames
|
|
5971
6043
|
}]);
|
|
6044
|
+
declaration = {
|
|
6045
|
+
type: "Declaration",
|
|
6046
|
+
children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
|
|
6047
|
+
names: []
|
|
6048
|
+
};
|
|
6049
|
+
let condition = [counterRef, " < ", lenRef, "; "];
|
|
6050
|
+
if (step) {
|
|
6051
|
+
let [stepWs, , stepExp] = step;
|
|
6052
|
+
stepWs = module2.insertTrimmingSpace(stepWs, "");
|
|
6053
|
+
if (stepExp.type === "Literal") {
|
|
6054
|
+
increment = [" +=", ...stepWs, stepExp];
|
|
6055
|
+
if (stepExp.raw[0] === "-") {
|
|
6056
|
+
declaration = {
|
|
6057
|
+
type: "Declaration",
|
|
6058
|
+
children: ["let ", ...expRefDec, counterRef, " = ", expRef, ".length - 1"],
|
|
6059
|
+
names: []
|
|
6060
|
+
};
|
|
6061
|
+
condition = [counterRef, " >= 0; "];
|
|
6062
|
+
}
|
|
6063
|
+
} else {
|
|
6064
|
+
throw new Error("TODO: Support non-literal step in CoffeeScript for loops");
|
|
6065
|
+
}
|
|
6066
|
+
return {
|
|
6067
|
+
declaration,
|
|
6068
|
+
children: [$1, open, declaration, "; ", ...condition, counterRef, increment, close],
|
|
6069
|
+
blockPrefix
|
|
6070
|
+
};
|
|
6071
|
+
}
|
|
5972
6072
|
return {
|
|
5973
6073
|
declaration,
|
|
5974
|
-
children: [$1, open, declaration, "; ",
|
|
6074
|
+
children: [$1, open, declaration, "; ", ...condition, counterRef, increment, close],
|
|
5975
6075
|
blockPrefix
|
|
5976
6076
|
};
|
|
5977
6077
|
}
|
|
@@ -6066,14 +6166,14 @@ ${input.slice(result.pos)}
|
|
|
6066
6166
|
children: $0
|
|
6067
6167
|
};
|
|
6068
6168
|
});
|
|
6069
|
-
var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of),
|
|
6169
|
+
var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationSuppressed, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6070
6170
|
var declaration = $4;
|
|
6071
6171
|
return {
|
|
6072
6172
|
declaration,
|
|
6073
6173
|
children: $0
|
|
6074
6174
|
};
|
|
6075
6175
|
});
|
|
6076
|
-
var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of),
|
|
6176
|
+
var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
6077
6177
|
var declaration = $3;
|
|
6078
6178
|
return {
|
|
6079
6179
|
declaration,
|
|
@@ -6418,7 +6518,7 @@ ${input.slice(result.pos)}
|
|
|
6418
6518
|
return result;
|
|
6419
6519
|
}
|
|
6420
6520
|
}
|
|
6421
|
-
var CaseExpressionList$0 = $TS($S($S($Q(_),
|
|
6521
|
+
var CaseExpressionList$0 = $TS($S($S($Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon), $Q($S(__, Comma, ExpressionWithIndentedApplicationSuppressed, ImpliedColon))), function($skip, $loc, $0, $1, $2) {
|
|
6422
6522
|
const result = $2.map(([ws, _comma, exp, col]) => {
|
|
6423
6523
|
exp = module2.insertTrimmingSpace(exp, "");
|
|
6424
6524
|
if (ws.length)
|
|
@@ -6446,7 +6546,7 @@ ${input.slice(result.pos)}
|
|
|
6446
6546
|
return result;
|
|
6447
6547
|
}
|
|
6448
6548
|
}
|
|
6449
|
-
var NoExpressions$0 = $T($EXPECT($
|
|
6549
|
+
var NoExpressions$0 = $T($EXPECT($L0, fail, 'NoExpressions ""'), function(value) {
|
|
6450
6550
|
return [];
|
|
6451
6551
|
});
|
|
6452
6552
|
function NoExpressions(state) {
|
|
@@ -6468,7 +6568,7 @@ ${input.slice(result.pos)}
|
|
|
6468
6568
|
}
|
|
6469
6569
|
}
|
|
6470
6570
|
var ImpliedColon$0 = $S(__, Colon);
|
|
6471
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
6571
|
+
var ImpliedColon$1 = $TV($EXPECT($L0, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
6472
6572
|
return { $loc, token: ":" };
|
|
6473
6573
|
});
|
|
6474
6574
|
function ImpliedColon(state) {
|
|
@@ -6604,7 +6704,7 @@ ${input.slice(result.pos)}
|
|
|
6604
6704
|
var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp, Dot, QuestionMark)))), function(value) {
|
|
6605
6705
|
return value[0];
|
|
6606
6706
|
});
|
|
6607
|
-
var Condition$1 = $TS($S(InsertOpenParen,
|
|
6707
|
+
var Condition$1 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
|
|
6608
6708
|
var open = $1;
|
|
6609
6709
|
var exp = $2;
|
|
6610
6710
|
var close = $3;
|
|
@@ -6633,6 +6733,52 @@ ${input.slice(result.pos)}
|
|
|
6633
6733
|
return result;
|
|
6634
6734
|
}
|
|
6635
6735
|
}
|
|
6736
|
+
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(ExtendedExpression)), function($skip, $loc, $0, $1, $2) {
|
|
6737
|
+
var exp = $2;
|
|
6738
|
+
module2.suppressIndentedApplication = false;
|
|
6739
|
+
if (exp)
|
|
6740
|
+
return exp;
|
|
6741
|
+
return $skip;
|
|
6742
|
+
});
|
|
6743
|
+
function ExpressionWithIndentedApplicationSuppressed(state) {
|
|
6744
|
+
if (state.events) {
|
|
6745
|
+
const result = state.events.enter?.("ExpressionWithIndentedApplicationSuppressed", state);
|
|
6746
|
+
if (result)
|
|
6747
|
+
return result.cache;
|
|
6748
|
+
}
|
|
6749
|
+
if (state.tokenize) {
|
|
6750
|
+
const result = $TOKEN("ExpressionWithIndentedApplicationSuppressed", state, ExpressionWithIndentedApplicationSuppressed$0(state));
|
|
6751
|
+
if (state.events)
|
|
6752
|
+
state.events.exit?.("ExpressionWithIndentedApplicationSuppressed", state, result);
|
|
6753
|
+
return result;
|
|
6754
|
+
} else {
|
|
6755
|
+
const result = ExpressionWithIndentedApplicationSuppressed$0(state);
|
|
6756
|
+
if (state.events)
|
|
6757
|
+
state.events.exit?.("ExpressionWithIndentedApplicationSuppressed", state, result);
|
|
6758
|
+
return result;
|
|
6759
|
+
}
|
|
6760
|
+
}
|
|
6761
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L0, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
6762
|
+
module2.suppressIndentedApplication = true;
|
|
6763
|
+
});
|
|
6764
|
+
function SuppressIndentedApplication(state) {
|
|
6765
|
+
if (state.events) {
|
|
6766
|
+
const result = state.events.enter?.("SuppressIndentedApplication", state);
|
|
6767
|
+
if (result)
|
|
6768
|
+
return result.cache;
|
|
6769
|
+
}
|
|
6770
|
+
if (state.tokenize) {
|
|
6771
|
+
const result = $TOKEN("SuppressIndentedApplication", state, SuppressIndentedApplication$0(state));
|
|
6772
|
+
if (state.events)
|
|
6773
|
+
state.events.exit?.("SuppressIndentedApplication", state, result);
|
|
6774
|
+
return result;
|
|
6775
|
+
} else {
|
|
6776
|
+
const result = SuppressIndentedApplication$0(state);
|
|
6777
|
+
if (state.events)
|
|
6778
|
+
state.events.exit?.("SuppressIndentedApplication", state, result);
|
|
6779
|
+
return result;
|
|
6780
|
+
}
|
|
6781
|
+
}
|
|
6636
6782
|
var ExpressionStatement$0 = Expression;
|
|
6637
6783
|
function ExpressionStatement(state) {
|
|
6638
6784
|
if (state.events) {
|
|
@@ -6733,7 +6879,7 @@ ${input.slice(result.pos)}
|
|
|
6733
6879
|
return result;
|
|
6734
6880
|
}
|
|
6735
6881
|
}
|
|
6736
|
-
var MaybeNestedExpression$0 = $TS($S($N(EOS),
|
|
6882
|
+
var MaybeNestedExpression$0 = $TS($S($N(EOS), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
6737
6883
|
return $2;
|
|
6738
6884
|
});
|
|
6739
6885
|
var MaybeNestedExpression$1 = $T($S($Y(EOS), ObjectLiteral), function(value) {
|
|
@@ -6791,7 +6937,7 @@ ${input.slice(result.pos)}
|
|
|
6791
6937
|
return result;
|
|
6792
6938
|
}
|
|
6793
6939
|
}
|
|
6794
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
6940
|
+
var ImpliedImport$0 = $TV($EXPECT($L0, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
6795
6941
|
return { $loc, token: "import " };
|
|
6796
6942
|
});
|
|
6797
6943
|
function ImpliedImport(state) {
|
|
@@ -7059,7 +7205,7 @@ ${input.slice(result.pos)}
|
|
|
7059
7205
|
}
|
|
7060
7206
|
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
7061
7207
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
7062
|
-
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement,
|
|
7208
|
+
var ExportDeclaration$2 = $S(Export, __, $C(Declaration, NamedExports, VariableStatement, ExportVarDec));
|
|
7063
7209
|
function ExportDeclaration(state) {
|
|
7064
7210
|
if (state.events) {
|
|
7065
7211
|
const result = state.events.enter?.("ExportDeclaration", state);
|
|
@@ -7078,6 +7224,25 @@ ${input.slice(result.pos)}
|
|
|
7078
7224
|
return result;
|
|
7079
7225
|
}
|
|
7080
7226
|
}
|
|
7227
|
+
var ExportVarDec$0 = $S(InsertVar, VariableDeclarationList);
|
|
7228
|
+
function ExportVarDec(state) {
|
|
7229
|
+
if (state.events) {
|
|
7230
|
+
const result = state.events.enter?.("ExportVarDec", state);
|
|
7231
|
+
if (result)
|
|
7232
|
+
return result.cache;
|
|
7233
|
+
}
|
|
7234
|
+
if (state.tokenize) {
|
|
7235
|
+
const result = $TOKEN("ExportVarDec", state, ExportVarDec$0(state));
|
|
7236
|
+
if (state.events)
|
|
7237
|
+
state.events.exit?.("ExportVarDec", state, result);
|
|
7238
|
+
return result;
|
|
7239
|
+
} else {
|
|
7240
|
+
const result = ExportVarDec$0(state);
|
|
7241
|
+
if (state.events)
|
|
7242
|
+
state.events.exit?.("ExportVarDec", state, result);
|
|
7243
|
+
return result;
|
|
7244
|
+
}
|
|
7245
|
+
}
|
|
7081
7246
|
var ExportFromClause$0 = $S(Star, $E($S(__, As, __, ModuleExportName)));
|
|
7082
7247
|
var ExportFromClause$1 = NamedExports;
|
|
7083
7248
|
function ExportFromClause(state) {
|
|
@@ -7099,6 +7264,11 @@ ${input.slice(result.pos)}
|
|
|
7099
7264
|
}
|
|
7100
7265
|
}
|
|
7101
7266
|
var NamedExports$0 = $S(OpenBrace, $Q(ExportSpecifier), $E($S(__, Comma)), __, CloseBrace);
|
|
7267
|
+
var NamedExports$1 = $TS($S(InsertInlineOpenBrace, ImplicitExportSpecifier, $Q($S(_, ImplicitExportSpecifier)), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7268
|
+
var open = $1;
|
|
7269
|
+
var close = $4;
|
|
7270
|
+
return [open, $2, ...$3, close];
|
|
7271
|
+
});
|
|
7102
7272
|
function NamedExports(state) {
|
|
7103
7273
|
if (state.events) {
|
|
7104
7274
|
const result = state.events.enter?.("NamedExports", state);
|
|
@@ -7106,12 +7276,12 @@ ${input.slice(result.pos)}
|
|
|
7106
7276
|
return result.cache;
|
|
7107
7277
|
}
|
|
7108
7278
|
if (state.tokenize) {
|
|
7109
|
-
const result = $TOKEN("NamedExports", state, NamedExports$0(state));
|
|
7279
|
+
const result = $TOKEN("NamedExports", state, NamedExports$0(state) || NamedExports$1(state));
|
|
7110
7280
|
if (state.events)
|
|
7111
7281
|
state.events.exit?.("NamedExports", state, result);
|
|
7112
7282
|
return result;
|
|
7113
7283
|
} else {
|
|
7114
|
-
const result = NamedExports$0(state);
|
|
7284
|
+
const result = NamedExports$0(state) || NamedExports$1(state);
|
|
7115
7285
|
if (state.events)
|
|
7116
7286
|
state.events.exit?.("NamedExports", state, result);
|
|
7117
7287
|
return result;
|
|
@@ -7136,6 +7306,25 @@ ${input.slice(result.pos)}
|
|
|
7136
7306
|
return result;
|
|
7137
7307
|
}
|
|
7138
7308
|
}
|
|
7309
|
+
var ImplicitExportSpecifier$0 = $S($N($EXPECT($L84, fail, 'ImplicitExportSpecifier "default"')), ModuleExportName, $E($S(__, As, __, ModuleExportName)), $C($Y($S(__, From)), ImplicitInlineObjectPropertyDelimiter));
|
|
7310
|
+
function ImplicitExportSpecifier(state) {
|
|
7311
|
+
if (state.events) {
|
|
7312
|
+
const result = state.events.enter?.("ImplicitExportSpecifier", state);
|
|
7313
|
+
if (result)
|
|
7314
|
+
return result.cache;
|
|
7315
|
+
}
|
|
7316
|
+
if (state.tokenize) {
|
|
7317
|
+
const result = $TOKEN("ImplicitExportSpecifier", state, ImplicitExportSpecifier$0(state));
|
|
7318
|
+
if (state.events)
|
|
7319
|
+
state.events.exit?.("ImplicitExportSpecifier", state, result);
|
|
7320
|
+
return result;
|
|
7321
|
+
} else {
|
|
7322
|
+
const result = ImplicitExportSpecifier$0(state);
|
|
7323
|
+
if (state.events)
|
|
7324
|
+
state.events.exit?.("ImplicitExportSpecifier", state, result);
|
|
7325
|
+
return result;
|
|
7326
|
+
}
|
|
7327
|
+
}
|
|
7139
7328
|
var Declaration$0 = HoistableDeclaration;
|
|
7140
7329
|
var Declaration$1 = ClassDeclaration;
|
|
7141
7330
|
var Declaration$2 = LexicalDeclaration;
|
|
@@ -8152,7 +8341,8 @@ ${input.slice(result.pos)}
|
|
|
8152
8341
|
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R30, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
8153
8342
|
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R31, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
8154
8343
|
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R32, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
8155
|
-
var ReservedWord$3 = $R$0($EXPECT($R33, fail, "ReservedWord /(?:
|
|
8344
|
+
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R33, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
8345
|
+
var ReservedWord$4 = $R$0($EXPECT($R34, fail, "ReservedWord /(?:and|as|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|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
8156
8346
|
function ReservedWord(state) {
|
|
8157
8347
|
if (state.events) {
|
|
8158
8348
|
const result = state.events.enter?.("ReservedWord", state);
|
|
@@ -8160,12 +8350,12 @@ ${input.slice(result.pos)}
|
|
|
8160
8350
|
return result.cache;
|
|
8161
8351
|
}
|
|
8162
8352
|
if (state.tokenize) {
|
|
8163
|
-
const result = $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state) || ReservedWord$3(state));
|
|
8353
|
+
const result = $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state) || ReservedWord$3(state) || ReservedWord$4(state));
|
|
8164
8354
|
if (state.events)
|
|
8165
8355
|
state.events.exit?.("ReservedWord", state, result);
|
|
8166
8356
|
return result;
|
|
8167
8357
|
} else {
|
|
8168
|
-
const result = ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state) || ReservedWord$3(state);
|
|
8358
|
+
const result = ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state) || ReservedWord$3(state) || ReservedWord$4(state);
|
|
8169
8359
|
if (state.events)
|
|
8170
8360
|
state.events.exit?.("ReservedWord", state, result);
|
|
8171
8361
|
return result;
|
|
@@ -8211,7 +8401,7 @@ ${input.slice(result.pos)}
|
|
|
8211
8401
|
return result;
|
|
8212
8402
|
}
|
|
8213
8403
|
}
|
|
8214
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
8404
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R35, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8215
8405
|
return { $loc, token: $0 };
|
|
8216
8406
|
});
|
|
8217
8407
|
function JSSingleLineComment(state) {
|
|
@@ -8252,7 +8442,7 @@ ${input.slice(result.pos)}
|
|
|
8252
8442
|
return result;
|
|
8253
8443
|
}
|
|
8254
8444
|
}
|
|
8255
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L87, fail, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
8445
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L87, fail, 'JSMultiLineComment "*/"')), $EXPECT($R36, fail, "JSMultiLineComment /./"))), $EXPECT($L87, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
8256
8446
|
return { $loc, token: $1 };
|
|
8257
8447
|
});
|
|
8258
8448
|
function JSMultiLineComment(state) {
|
|
@@ -8273,7 +8463,7 @@ ${input.slice(result.pos)}
|
|
|
8273
8463
|
return result;
|
|
8274
8464
|
}
|
|
8275
8465
|
}
|
|
8276
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
8466
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R37, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8277
8467
|
return { $loc, token: `//${$1}` };
|
|
8278
8468
|
});
|
|
8279
8469
|
function CoffeeSingleLineComment(state) {
|
|
@@ -8294,7 +8484,7 @@ ${input.slice(result.pos)}
|
|
|
8294
8484
|
return result;
|
|
8295
8485
|
}
|
|
8296
8486
|
}
|
|
8297
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($L87, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($
|
|
8487
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($L87, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R36, fail, "CoffeeMultiLineComment /./")))), CoffeeHereCommentStart), function($skip, $loc, $0, $1, $2, $3) {
|
|
8298
8488
|
return { $loc, token: `/*${$2}*/` };
|
|
8299
8489
|
});
|
|
8300
8490
|
function CoffeeMultiLineComment(state) {
|
|
@@ -8315,7 +8505,7 @@ ${input.slice(result.pos)}
|
|
|
8315
8505
|
return result;
|
|
8316
8506
|
}
|
|
8317
8507
|
}
|
|
8318
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
8508
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R38, fail, "CoffeeHereCommentStart /###(?!#)/"));
|
|
8319
8509
|
function CoffeeHereCommentStart(state) {
|
|
8320
8510
|
if (state.events) {
|
|
8321
8511
|
const result = state.events.enter?.("CoffeeHereCommentStart", state);
|
|
@@ -8334,7 +8524,7 @@ ${input.slice(result.pos)}
|
|
|
8334
8524
|
return result;
|
|
8335
8525
|
}
|
|
8336
8526
|
}
|
|
8337
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L87, fail, 'InlineComment "*/"')), $EXPECT($
|
|
8527
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L87, fail, 'InlineComment "*/"')), $EXPECT($R39, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L87, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
8338
8528
|
return { $loc, token: $1 };
|
|
8339
8529
|
});
|
|
8340
8530
|
function InlineComment(state) {
|
|
@@ -8414,7 +8604,7 @@ ${input.slice(result.pos)}
|
|
|
8414
8604
|
return result;
|
|
8415
8605
|
}
|
|
8416
8606
|
}
|
|
8417
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
8607
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R40, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8418
8608
|
return { $loc, token: $0 };
|
|
8419
8609
|
});
|
|
8420
8610
|
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L88, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
@@ -8523,7 +8713,7 @@ ${input.slice(result.pos)}
|
|
|
8523
8713
|
return result;
|
|
8524
8714
|
}
|
|
8525
8715
|
}
|
|
8526
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
8716
|
+
var NonIdContinue$0 = $R$0($EXPECT($R41, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
8527
8717
|
function NonIdContinue(state) {
|
|
8528
8718
|
if (state.events) {
|
|
8529
8719
|
const result = state.events.enter?.("NonIdContinue", state);
|
|
@@ -8542,7 +8732,7 @@ ${input.slice(result.pos)}
|
|
|
8542
8732
|
return result;
|
|
8543
8733
|
}
|
|
8544
8734
|
}
|
|
8545
|
-
var Loc$0 = $TV($EXPECT($
|
|
8735
|
+
var Loc$0 = $TV($EXPECT($L0, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
8546
8736
|
return { $loc, token: "" };
|
|
8547
8737
|
});
|
|
8548
8738
|
function Loc(state) {
|
|
@@ -8962,7 +9152,7 @@ ${input.slice(result.pos)}
|
|
|
8962
9152
|
return result;
|
|
8963
9153
|
}
|
|
8964
9154
|
}
|
|
8965
|
-
var Dot$0 = $TV($EXPECT($
|
|
9155
|
+
var Dot$0 = $TV($EXPECT($L8, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
8966
9156
|
return { $loc, token: $1 };
|
|
8967
9157
|
});
|
|
8968
9158
|
function Dot(state) {
|
|
@@ -9214,7 +9404,7 @@ ${input.slice(result.pos)}
|
|
|
9214
9404
|
return result;
|
|
9215
9405
|
}
|
|
9216
9406
|
}
|
|
9217
|
-
var If$0 = $TV($TEXT($S($EXPECT($L112, fail, 'If "if"'), $E($EXPECT($
|
|
9407
|
+
var If$0 = $TV($TEXT($S($EXPECT($L112, fail, 'If "if"'), $E($EXPECT($L4, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
9218
9408
|
return { $loc, token: $1 };
|
|
9219
9409
|
});
|
|
9220
9410
|
function If(state) {
|
|
@@ -9235,7 +9425,7 @@ ${input.slice(result.pos)}
|
|
|
9235
9425
|
return result;
|
|
9236
9426
|
}
|
|
9237
9427
|
}
|
|
9238
|
-
var Import$0 = $TS($S($EXPECT($
|
|
9428
|
+
var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R42, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
9239
9429
|
return { $loc, token: $1 };
|
|
9240
9430
|
});
|
|
9241
9431
|
function Import(state) {
|
|
@@ -9277,7 +9467,7 @@ ${input.slice(result.pos)}
|
|
|
9277
9467
|
return result;
|
|
9278
9468
|
}
|
|
9279
9469
|
}
|
|
9280
|
-
var LetOrConst$0 = $
|
|
9470
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L113, fail, 'LetOrConst "let"'), $EXPECT($L114, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9281
9471
|
return { $loc, token: $1 };
|
|
9282
9472
|
});
|
|
9283
9473
|
function LetOrConst(state) {
|
|
@@ -9319,7 +9509,7 @@ ${input.slice(result.pos)}
|
|
|
9319
9509
|
return result;
|
|
9320
9510
|
}
|
|
9321
9511
|
}
|
|
9322
|
-
var New$0 = $
|
|
9512
|
+
var New$0 = $TS($S($EXPECT($L116, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9323
9513
|
return { $loc, token: $1 };
|
|
9324
9514
|
});
|
|
9325
9515
|
function New(state) {
|
|
@@ -9340,7 +9530,7 @@ ${input.slice(result.pos)}
|
|
|
9340
9530
|
return result;
|
|
9341
9531
|
}
|
|
9342
9532
|
}
|
|
9343
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L72, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($
|
|
9533
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L72, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L4, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
9344
9534
|
return { $loc, token: "!" };
|
|
9345
9535
|
});
|
|
9346
9536
|
function Not(state) {
|
|
@@ -9616,7 +9806,7 @@ ${input.slice(result.pos)}
|
|
|
9616
9806
|
return result;
|
|
9617
9807
|
}
|
|
9618
9808
|
}
|
|
9619
|
-
var Target$0 = $
|
|
9809
|
+
var Target$0 = $TS($S($EXPECT($L125, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9620
9810
|
return { $loc, token: $1 };
|
|
9621
9811
|
});
|
|
9622
9812
|
function Target(state) {
|
|
@@ -9784,7 +9974,7 @@ ${input.slice(result.pos)}
|
|
|
9784
9974
|
return result;
|
|
9785
9975
|
}
|
|
9786
9976
|
}
|
|
9787
|
-
var Try$0 = $
|
|
9977
|
+
var Try$0 = $TS($S($EXPECT($L133, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9788
9978
|
return { $loc, token: $1 };
|
|
9789
9979
|
});
|
|
9790
9980
|
function Try(state) {
|
|
@@ -9826,7 +10016,7 @@ ${input.slice(result.pos)}
|
|
|
9826
10016
|
return result;
|
|
9827
10017
|
}
|
|
9828
10018
|
}
|
|
9829
|
-
var Unless$0 = $
|
|
10019
|
+
var Unless$0 = $TS($S($EXPECT($L135, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9830
10020
|
return { $loc, token: $1 };
|
|
9831
10021
|
});
|
|
9832
10022
|
function Unless(state) {
|
|
@@ -9868,7 +10058,7 @@ ${input.slice(result.pos)}
|
|
|
9868
10058
|
return result;
|
|
9869
10059
|
}
|
|
9870
10060
|
}
|
|
9871
|
-
var Var$0 = $
|
|
10061
|
+
var Var$0 = $TS($S($EXPECT($L137, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9872
10062
|
return { $loc, token: $1 };
|
|
9873
10063
|
});
|
|
9874
10064
|
function Var(state) {
|
|
@@ -9998,7 +10188,7 @@ ${input.slice(result.pos)}
|
|
|
9998
10188
|
return result;
|
|
9999
10189
|
}
|
|
10000
10190
|
}
|
|
10001
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
10191
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L142, fail, 'JSXSelfClosingElement "/>"'));
|
|
10002
10192
|
function JSXSelfClosingElement(state) {
|
|
10003
10193
|
if (state.events) {
|
|
10004
10194
|
const result = state.events.enter?.("JSXSelfClosingElement", state);
|
|
@@ -10017,7 +10207,7 @@ ${input.slice(result.pos)}
|
|
|
10017
10207
|
return result;
|
|
10018
10208
|
}
|
|
10019
10209
|
}
|
|
10020
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
10210
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L25, fail, 'JSXOpeningElement ">"'));
|
|
10021
10211
|
function JSXOpeningElement(state) {
|
|
10022
10212
|
if (state.events) {
|
|
10023
10213
|
const result = state.events.enter?.("JSXOpeningElement", state);
|
|
@@ -10093,7 +10283,7 @@ ${input.slice(result.pos)}
|
|
|
10093
10283
|
return result;
|
|
10094
10284
|
}
|
|
10095
10285
|
}
|
|
10096
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
10286
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R43, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
10097
10287
|
function JSXIdentifierName(state) {
|
|
10098
10288
|
if (state.events) {
|
|
10099
10289
|
const result = state.events.enter?.("JSXIdentifierName", state);
|
|
@@ -10189,8 +10379,8 @@ ${input.slice(result.pos)}
|
|
|
10189
10379
|
return result;
|
|
10190
10380
|
}
|
|
10191
10381
|
}
|
|
10192
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
10193
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
10382
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R44, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
10383
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R45, fail, "JSXAttributeValue /'[^']*'/"));
|
|
10194
10384
|
var JSXAttributeValue$2 = $S(OpenBrace, ExtendedExpression, __, CloseBrace);
|
|
10195
10385
|
var JSXAttributeValue$3 = JSXElement;
|
|
10196
10386
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -10253,7 +10443,7 @@ ${input.slice(result.pos)}
|
|
|
10253
10443
|
return result;
|
|
10254
10444
|
}
|
|
10255
10445
|
}
|
|
10256
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
10446
|
+
var JSXText$0 = $R$0($EXPECT($R46, fail, "JSXText /[^{}<>]+/"));
|
|
10257
10447
|
function JSXText(state) {
|
|
10258
10448
|
if (state.events) {
|
|
10259
10449
|
const result = state.events.enter?.("JSXText", state);
|
|
@@ -10581,7 +10771,7 @@ ${input.slice(result.pos)}
|
|
|
10581
10771
|
return result;
|
|
10582
10772
|
}
|
|
10583
10773
|
}
|
|
10584
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
10774
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R47, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L150, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R48, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
10585
10775
|
function TypeIndexSignature(state) {
|
|
10586
10776
|
if (state.events) {
|
|
10587
10777
|
const result = state.events.enter?.("TypeIndexSignature", state);
|
|
@@ -10922,7 +11112,7 @@ ${input.slice(result.pos)}
|
|
|
10922
11112
|
return result;
|
|
10923
11113
|
}
|
|
10924
11114
|
}
|
|
10925
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
11115
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
10926
11116
|
if ($2)
|
|
10927
11117
|
return $0;
|
|
10928
11118
|
return $1;
|
|
@@ -10994,7 +11184,7 @@ ${input.slice(result.pos)}
|
|
|
10994
11184
|
return result;
|
|
10995
11185
|
}
|
|
10996
11186
|
}
|
|
10997
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
11187
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L3, fail, 'FunctionType "=>"'), Type);
|
|
10998
11188
|
function FunctionType(state) {
|
|
10999
11189
|
if (state.events) {
|
|
11000
11190
|
const result = state.events.enter?.("FunctionType", state);
|
|
@@ -11013,7 +11203,7 @@ ${input.slice(result.pos)}
|
|
|
11013
11203
|
return result;
|
|
11014
11204
|
}
|
|
11015
11205
|
}
|
|
11016
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
11206
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L25, fail, 'TypeArguments ">"'));
|
|
11017
11207
|
function TypeArguments(state) {
|
|
11018
11208
|
if (state.events) {
|
|
11019
11209
|
const result = state.events.enter?.("TypeArguments", state);
|
|
@@ -11032,7 +11222,7 @@ ${input.slice(result.pos)}
|
|
|
11032
11222
|
return result;
|
|
11033
11223
|
}
|
|
11034
11224
|
}
|
|
11035
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
11225
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L25, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
11036
11226
|
return { ts: true, children: $0 };
|
|
11037
11227
|
});
|
|
11038
11228
|
function TypeParameters(state) {
|
|
@@ -11072,7 +11262,7 @@ ${input.slice(result.pos)}
|
|
|
11072
11262
|
return result;
|
|
11073
11263
|
}
|
|
11074
11264
|
}
|
|
11075
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
11265
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
|
|
11076
11266
|
function TypeConstraint(state) {
|
|
11077
11267
|
if (state.events) {
|
|
11078
11268
|
const result = state.events.enter?.("TypeConstraint", state);
|
|
@@ -11117,7 +11307,7 @@ ${input.slice(result.pos)}
|
|
|
11117
11307
|
return result;
|
|
11118
11308
|
}
|
|
11119
11309
|
}
|
|
11120
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
11310
|
+
var Shebang$0 = $S($R$0($EXPECT($R49, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
11121
11311
|
function Shebang(state) {
|
|
11122
11312
|
if (state.events) {
|
|
11123
11313
|
const result = state.events.enter?.("Shebang", state);
|
|
@@ -11136,11 +11326,11 @@ ${input.slice(result.pos)}
|
|
|
11136
11326
|
return result;
|
|
11137
11327
|
}
|
|
11138
11328
|
}
|
|
11139
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
11329
|
+
var CivetPrologue$0 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
11140
11330
|
var content = value[2];
|
|
11141
11331
|
return content;
|
|
11142
11332
|
});
|
|
11143
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
11333
|
+
var CivetPrologue$1 = $T($S($EXPECT($R50, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
11144
11334
|
var content = value[2];
|
|
11145
11335
|
return content;
|
|
11146
11336
|
});
|
|
@@ -11162,7 +11352,7 @@ ${input.slice(result.pos)}
|
|
|
11162
11352
|
return result;
|
|
11163
11353
|
}
|
|
11164
11354
|
}
|
|
11165
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L155, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($
|
|
11355
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L155, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R51, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
11166
11356
|
var options = $2;
|
|
11167
11357
|
return {
|
|
11168
11358
|
type: "CivetPrologue",
|
|
@@ -11188,7 +11378,7 @@ ${input.slice(result.pos)}
|
|
|
11188
11378
|
return result;
|
|
11189
11379
|
}
|
|
11190
11380
|
}
|
|
11191
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
11381
|
+
var CivetOption$0 = $TR($EXPECT($R52, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11192
11382
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
11193
11383
|
if (l)
|
|
11194
11384
|
return l.toUpperCase();
|
|
@@ -11215,7 +11405,7 @@ ${input.slice(result.pos)}
|
|
|
11215
11405
|
return result;
|
|
11216
11406
|
}
|
|
11217
11407
|
}
|
|
11218
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
11408
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R50, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
11219
11409
|
function UnknownPrologue(state) {
|
|
11220
11410
|
if (state.events) {
|
|
11221
11411
|
const result = state.events.enter?.("UnknownPrologue", state);
|
|
@@ -11273,7 +11463,7 @@ ${input.slice(result.pos)}
|
|
|
11273
11463
|
return result;
|
|
11274
11464
|
}
|
|
11275
11465
|
}
|
|
11276
|
-
var EOL$0 = $TR($EXPECT($
|
|
11466
|
+
var EOL$0 = $TR($EXPECT($R53, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11277
11467
|
return { $loc, token: $0 };
|
|
11278
11468
|
});
|
|
11279
11469
|
function EOL(state) {
|
|
@@ -11294,7 +11484,7 @@ ${input.slice(result.pos)}
|
|
|
11294
11484
|
return result;
|
|
11295
11485
|
}
|
|
11296
11486
|
}
|
|
11297
|
-
var Debugger$0 = $TV($EXPECT($
|
|
11487
|
+
var Debugger$0 = $TV($EXPECT($L0, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
11298
11488
|
debugger;
|
|
11299
11489
|
});
|
|
11300
11490
|
function Debugger(state) {
|
|
@@ -11315,7 +11505,7 @@ ${input.slice(result.pos)}
|
|
|
11315
11505
|
return result;
|
|
11316
11506
|
}
|
|
11317
11507
|
}
|
|
11318
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
11508
|
+
var InsertOpenParen$0 = $TV($EXPECT($L0, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
11319
11509
|
return { $loc, token: "(" };
|
|
11320
11510
|
});
|
|
11321
11511
|
function InsertOpenParen(state) {
|
|
@@ -11336,7 +11526,7 @@ ${input.slice(result.pos)}
|
|
|
11336
11526
|
return result;
|
|
11337
11527
|
}
|
|
11338
11528
|
}
|
|
11339
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
11529
|
+
var InsertCloseParen$0 = $TV($EXPECT($L0, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
11340
11530
|
return { $loc, token: ")" };
|
|
11341
11531
|
});
|
|
11342
11532
|
function InsertCloseParen(state) {
|
|
@@ -11357,7 +11547,7 @@ ${input.slice(result.pos)}
|
|
|
11357
11547
|
return result;
|
|
11358
11548
|
}
|
|
11359
11549
|
}
|
|
11360
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
11550
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L0, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
11361
11551
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
11362
11552
|
});
|
|
11363
11553
|
function InsertOpenBrace(state) {
|
|
@@ -11378,7 +11568,28 @@ ${input.slice(result.pos)}
|
|
|
11378
11568
|
return result;
|
|
11379
11569
|
}
|
|
11380
11570
|
}
|
|
11381
|
-
var
|
|
11571
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L0, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
11572
|
+
return [{ $loc, token: "{" }];
|
|
11573
|
+
});
|
|
11574
|
+
function InsertInlineOpenBrace(state) {
|
|
11575
|
+
if (state.events) {
|
|
11576
|
+
const result = state.events.enter?.("InsertInlineOpenBrace", state);
|
|
11577
|
+
if (result)
|
|
11578
|
+
return result.cache;
|
|
11579
|
+
}
|
|
11580
|
+
if (state.tokenize) {
|
|
11581
|
+
const result = $TOKEN("InsertInlineOpenBrace", state, InsertInlineOpenBrace$0(state));
|
|
11582
|
+
if (state.events)
|
|
11583
|
+
state.events.exit?.("InsertInlineOpenBrace", state, result);
|
|
11584
|
+
return result;
|
|
11585
|
+
} else {
|
|
11586
|
+
const result = InsertInlineOpenBrace$0(state);
|
|
11587
|
+
if (state.events)
|
|
11588
|
+
state.events.exit?.("InsertInlineOpenBrace", state, result);
|
|
11589
|
+
return result;
|
|
11590
|
+
}
|
|
11591
|
+
}
|
|
11592
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L0, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
11382
11593
|
return { $loc, token: "}" };
|
|
11383
11594
|
});
|
|
11384
11595
|
function InsertCloseBrace(state) {
|
|
@@ -11399,7 +11610,7 @@ ${input.slice(result.pos)}
|
|
|
11399
11610
|
return result;
|
|
11400
11611
|
}
|
|
11401
11612
|
}
|
|
11402
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
11613
|
+
var InsertConst$0 = $TV($EXPECT($L0, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
11403
11614
|
return { $loc, token: "const " };
|
|
11404
11615
|
});
|
|
11405
11616
|
function InsertConst(state) {
|
|
@@ -11420,7 +11631,7 @@ ${input.slice(result.pos)}
|
|
|
11420
11631
|
return result;
|
|
11421
11632
|
}
|
|
11422
11633
|
}
|
|
11423
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
11634
|
+
var InsertReadonly$0 = $TV($EXPECT($L0, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
11424
11635
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
11425
11636
|
});
|
|
11426
11637
|
function InsertReadonly(state) {
|
|
@@ -11441,7 +11652,7 @@ ${input.slice(result.pos)}
|
|
|
11441
11652
|
return result;
|
|
11442
11653
|
}
|
|
11443
11654
|
}
|
|
11444
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
11655
|
+
var InsertNewline$0 = $TV($EXPECT($L0, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
11445
11656
|
return "\n";
|
|
11446
11657
|
});
|
|
11447
11658
|
function InsertNewline(state) {
|
|
@@ -11462,7 +11673,7 @@ ${input.slice(result.pos)}
|
|
|
11462
11673
|
return result;
|
|
11463
11674
|
}
|
|
11464
11675
|
}
|
|
11465
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
11676
|
+
var InsertIndent$0 = $TV($EXPECT($L0, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
11466
11677
|
return module2.currentIndent.token;
|
|
11467
11678
|
});
|
|
11468
11679
|
function InsertIndent(state) {
|
|
@@ -11483,7 +11694,7 @@ ${input.slice(result.pos)}
|
|
|
11483
11694
|
return result;
|
|
11484
11695
|
}
|
|
11485
11696
|
}
|
|
11486
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
11697
|
+
var InsertSpace$0 = $TV($EXPECT($L0, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
11487
11698
|
return { $loc, token: " " };
|
|
11488
11699
|
});
|
|
11489
11700
|
function InsertSpace(state) {
|
|
@@ -11504,7 +11715,7 @@ ${input.slice(result.pos)}
|
|
|
11504
11715
|
return result;
|
|
11505
11716
|
}
|
|
11506
11717
|
}
|
|
11507
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
11718
|
+
var InsertDot$0 = $TV($EXPECT($L0, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
11508
11719
|
return { $loc, token: "." };
|
|
11509
11720
|
});
|
|
11510
11721
|
function InsertDot(state) {
|
|
@@ -11525,7 +11736,7 @@ ${input.slice(result.pos)}
|
|
|
11525
11736
|
return result;
|
|
11526
11737
|
}
|
|
11527
11738
|
}
|
|
11528
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
11739
|
+
var InsertBreak$0 = $TV($EXPECT($L0, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
11529
11740
|
return { $loc, token: ";break;" };
|
|
11530
11741
|
});
|
|
11531
11742
|
function InsertBreak(state) {
|
|
@@ -11546,7 +11757,28 @@ ${input.slice(result.pos)}
|
|
|
11546
11757
|
return result;
|
|
11547
11758
|
}
|
|
11548
11759
|
}
|
|
11549
|
-
var
|
|
11760
|
+
var InsertVar$0 = $TV($EXPECT($L0, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
11761
|
+
return { $loc, token: "var " };
|
|
11762
|
+
});
|
|
11763
|
+
function InsertVar(state) {
|
|
11764
|
+
if (state.events) {
|
|
11765
|
+
const result = state.events.enter?.("InsertVar", state);
|
|
11766
|
+
if (result)
|
|
11767
|
+
return result.cache;
|
|
11768
|
+
}
|
|
11769
|
+
if (state.tokenize) {
|
|
11770
|
+
const result = $TOKEN("InsertVar", state, InsertVar$0(state));
|
|
11771
|
+
if (state.events)
|
|
11772
|
+
state.events.exit?.("InsertVar", state, result);
|
|
11773
|
+
return result;
|
|
11774
|
+
} else {
|
|
11775
|
+
const result = InsertVar$0(state);
|
|
11776
|
+
if (state.events)
|
|
11777
|
+
state.events.exit?.("InsertVar", state, result);
|
|
11778
|
+
return result;
|
|
11779
|
+
}
|
|
11780
|
+
}
|
|
11781
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11550
11782
|
if (module2.config.coffeeBinaryExistential)
|
|
11551
11783
|
return;
|
|
11552
11784
|
return $skip;
|
|
@@ -11569,7 +11801,7 @@ ${input.slice(result.pos)}
|
|
|
11569
11801
|
return result;
|
|
11570
11802
|
}
|
|
11571
11803
|
}
|
|
11572
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
11804
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11573
11805
|
if (module2.config.coffeeBooleans)
|
|
11574
11806
|
return;
|
|
11575
11807
|
return $skip;
|
|
@@ -11592,7 +11824,7 @@ ${input.slice(result.pos)}
|
|
|
11592
11824
|
return result;
|
|
11593
11825
|
}
|
|
11594
11826
|
}
|
|
11595
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
11827
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11596
11828
|
if (module2.config.coffeeClasses)
|
|
11597
11829
|
return;
|
|
11598
11830
|
return $skip;
|
|
@@ -11615,7 +11847,7 @@ ${input.slice(result.pos)}
|
|
|
11615
11847
|
return result;
|
|
11616
11848
|
}
|
|
11617
11849
|
}
|
|
11618
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
11850
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11619
11851
|
if (module2.config.coffeeComment)
|
|
11620
11852
|
return;
|
|
11621
11853
|
return $skip;
|
|
@@ -11638,7 +11870,7 @@ ${input.slice(result.pos)}
|
|
|
11638
11870
|
return result;
|
|
11639
11871
|
}
|
|
11640
11872
|
}
|
|
11641
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
11873
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11642
11874
|
if (module2.config.coffeeDo)
|
|
11643
11875
|
return;
|
|
11644
11876
|
return $skip;
|
|
@@ -11661,7 +11893,7 @@ ${input.slice(result.pos)}
|
|
|
11661
11893
|
return result;
|
|
11662
11894
|
}
|
|
11663
11895
|
}
|
|
11664
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
11896
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11665
11897
|
if (module2.config.coffeeForLoops)
|
|
11666
11898
|
return;
|
|
11667
11899
|
return $skip;
|
|
@@ -11684,7 +11916,7 @@ ${input.slice(result.pos)}
|
|
|
11684
11916
|
return result;
|
|
11685
11917
|
}
|
|
11686
11918
|
}
|
|
11687
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
11919
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11688
11920
|
if (module2.config.coffeeInterpolation)
|
|
11689
11921
|
return;
|
|
11690
11922
|
return $skip;
|
|
@@ -11707,7 +11939,7 @@ ${input.slice(result.pos)}
|
|
|
11707
11939
|
return result;
|
|
11708
11940
|
}
|
|
11709
11941
|
}
|
|
11710
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
11942
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11711
11943
|
if (module2.config.coffeeIsnt)
|
|
11712
11944
|
return;
|
|
11713
11945
|
return $skip;
|
|
@@ -11730,7 +11962,7 @@ ${input.slice(result.pos)}
|
|
|
11730
11962
|
return result;
|
|
11731
11963
|
}
|
|
11732
11964
|
}
|
|
11733
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
11965
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11734
11966
|
if (module2.config.coffeeLineContinuation)
|
|
11735
11967
|
return;
|
|
11736
11968
|
return $skip;
|
|
@@ -11753,7 +11985,7 @@ ${input.slice(result.pos)}
|
|
|
11753
11985
|
return result;
|
|
11754
11986
|
}
|
|
11755
11987
|
}
|
|
11756
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
11988
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11757
11989
|
if (module2.config.coffeeNot)
|
|
11758
11990
|
return;
|
|
11759
11991
|
return $skip;
|
|
@@ -11776,7 +12008,7 @@ ${input.slice(result.pos)}
|
|
|
11776
12008
|
return result;
|
|
11777
12009
|
}
|
|
11778
12010
|
}
|
|
11779
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
12011
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
11780
12012
|
if (module2.config.coffeeOf)
|
|
11781
12013
|
return;
|
|
11782
12014
|
return $skip;
|
|
@@ -11799,7 +12031,7 @@ ${input.slice(result.pos)}
|
|
|
11799
12031
|
return result;
|
|
11800
12032
|
}
|
|
11801
12033
|
}
|
|
11802
|
-
var Reset$0 = $TV($EXPECT($
|
|
12034
|
+
var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
11803
12035
|
module2.indentLevels = [{
|
|
11804
12036
|
level: 0,
|
|
11805
12037
|
token: ""
|
|
@@ -11842,7 +12074,8 @@ ${input.slice(result.pos)}
|
|
|
11842
12074
|
return spliceRef;
|
|
11843
12075
|
spliceRef = {
|
|
11844
12076
|
type: "Ref",
|
|
11845
|
-
base: "splice"
|
|
12077
|
+
base: "splice",
|
|
12078
|
+
id: "splice"
|
|
11846
12079
|
};
|
|
11847
12080
|
return spliceRef;
|
|
11848
12081
|
};
|
|
@@ -11851,7 +12084,8 @@ ${input.slice(result.pos)}
|
|
|
11851
12084
|
return indexOfRef;
|
|
11852
12085
|
indexOfRef = {
|
|
11853
12086
|
type: "Ref",
|
|
11854
|
-
base: "indexOf"
|
|
12087
|
+
base: "indexOf",
|
|
12088
|
+
id: "indexOf"
|
|
11855
12089
|
};
|
|
11856
12090
|
const typeSuffix = {
|
|
11857
12091
|
ts: true,
|
|
@@ -11865,7 +12099,8 @@ ${input.slice(result.pos)}
|
|
|
11865
12099
|
return hasPropRef;
|
|
11866
12100
|
hasPropRef = {
|
|
11867
12101
|
type: "Ref",
|
|
11868
|
-
base: "hasProp"
|
|
12102
|
+
base: "hasProp",
|
|
12103
|
+
id: "hasProp"
|
|
11869
12104
|
};
|
|
11870
12105
|
const typeSuffix = {
|
|
11871
12106
|
ts: true,
|
|
@@ -11929,7 +12164,7 @@ ${input.slice(result.pos)}
|
|
|
11929
12164
|
return result;
|
|
11930
12165
|
}
|
|
11931
12166
|
}
|
|
11932
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
12167
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L0, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
11933
12168
|
var directives = $2;
|
|
11934
12169
|
directives.forEach((directive) => {
|
|
11935
12170
|
if (directive.type === "CivetPrologue") {
|
|
@@ -11976,7 +12211,8 @@ ${input.slice(result.pos)}
|
|
|
11976
12211
|
function expressionizeIteration(exp) {
|
|
11977
12212
|
const resultsRef = {
|
|
11978
12213
|
type: "Ref",
|
|
11979
|
-
base: "results"
|
|
12214
|
+
base: "results",
|
|
12215
|
+
id: "results"
|
|
11980
12216
|
};
|
|
11981
12217
|
insertPush(exp.block, resultsRef);
|
|
11982
12218
|
exp.children = ["(", resultsRef, "=>{", ...exp.children, "; return ", resultsRef, "})([])"];
|
|
@@ -11984,7 +12220,8 @@ ${input.slice(result.pos)}
|
|
|
11984
12220
|
function wrapIterationReturningResults(statement, outerRef) {
|
|
11985
12221
|
const resultsRef = {
|
|
11986
12222
|
type: "Ref",
|
|
11987
|
-
base: "results"
|
|
12223
|
+
base: "results",
|
|
12224
|
+
id: "results"
|
|
11988
12225
|
};
|
|
11989
12226
|
const declaration = {
|
|
11990
12227
|
type: "Declaration",
|
|
@@ -12069,7 +12306,8 @@ ${input.slice(result.pos)}
|
|
|
12069
12306
|
return;
|
|
12070
12307
|
case "TryStatement":
|
|
12071
12308
|
insertPush(exp.children[1], ref);
|
|
12072
|
-
|
|
12309
|
+
if (exp.children[2])
|
|
12310
|
+
insertPush(exp.children[2][2], ref);
|
|
12073
12311
|
return;
|
|
12074
12312
|
}
|
|
12075
12313
|
node.splice(1, 0, ref, ".push(");
|
|
@@ -12144,7 +12382,8 @@ ${input.slice(result.pos)}
|
|
|
12144
12382
|
return;
|
|
12145
12383
|
case "TryStatement":
|
|
12146
12384
|
insertReturn(exp.children[1]);
|
|
12147
|
-
|
|
12385
|
+
if (exp.children[2])
|
|
12386
|
+
insertReturn(exp.children[2][3]);
|
|
12148
12387
|
return;
|
|
12149
12388
|
}
|
|
12150
12389
|
node.splice(1, 0, "return ");
|
|
@@ -12171,7 +12410,7 @@ ${input.slice(result.pos)}
|
|
|
12171
12410
|
wsOp = module2.insertTrimmingSpace(wsOp, "");
|
|
12172
12411
|
wsB = module2.insertTrimmingSpace(wsB, "");
|
|
12173
12412
|
children = [wsOp, op2.ref, ".call(", wsB, b, ", ", a, ")", op2.suffix];
|
|
12174
|
-
} else if (op2.token === "instanceof") {
|
|
12413
|
+
} else if (op2.token === "instanceof" || op2.token === "in") {
|
|
12175
12414
|
children = ["!(", a, wsOp, op2, wsB, b, ")"];
|
|
12176
12415
|
} else {
|
|
12177
12416
|
throw new Error("Unknown operator: " + JSON.stringify(op2));
|
|
@@ -12408,7 +12647,7 @@ ${input.slice(result.pos)}
|
|
|
12408
12647
|
const atBinding = binding.children[0];
|
|
12409
12648
|
atBinding.children.pop();
|
|
12410
12649
|
atBinding.type = void 0;
|
|
12411
|
-
binding.children.unshift(ref.
|
|
12650
|
+
binding.children.unshift(ref.id, ": this.", ref.base);
|
|
12412
12651
|
binding.type = "Property";
|
|
12413
12652
|
binding.ref = void 0;
|
|
12414
12653
|
return;
|
|
@@ -12662,8 +12901,8 @@ ${input.slice(result.pos)}
|
|
|
12662
12901
|
function insertRestSplices(s, p, thisAssignments2) {
|
|
12663
12902
|
gatherRecursiveAll(s, (n) => n.blockPrefix || n.type === "AtBinding").forEach((n) => {
|
|
12664
12903
|
if (n.type === "AtBinding") {
|
|
12665
|
-
const { ref } = n, {
|
|
12666
|
-
thisAssignments2.push([`this.${
|
|
12904
|
+
const { ref } = n, { id } = ref;
|
|
12905
|
+
thisAssignments2.push([`this.${id} = `, ref]);
|
|
12667
12906
|
return;
|
|
12668
12907
|
}
|
|
12669
12908
|
const { blockPrefix } = n;
|
|
@@ -12820,7 +13059,7 @@ ${input.slice(result.pos)}
|
|
|
12820
13059
|
return result;
|
|
12821
13060
|
}
|
|
12822
13061
|
}
|
|
12823
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
13062
|
+
var PopIndent$0 = $TV($EXPECT($L0, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
12824
13063
|
if (module2.verbose) {
|
|
12825
13064
|
console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
|
|
12826
13065
|
}
|
|
@@ -13382,6 +13621,9 @@ makeCache = function() {
|
|
|
13382
13621
|
case "NestedImplicitPropertyDefinitions":
|
|
13383
13622
|
case "NestedBlockStatement":
|
|
13384
13623
|
case "NestedInterfaceProperty":
|
|
13624
|
+
case "IndentedApplicationAllowed":
|
|
13625
|
+
case "ExpressionWithIndentedApplicationSuppressed":
|
|
13626
|
+
case "SuppressIndentedApplication":
|
|
13385
13627
|
case "AssignmentExpressionTail":
|
|
13386
13628
|
case "AssignmentExpression":
|
|
13387
13629
|
case "ExtendedExpression":
|