1#![allow(clippy::all)]
4#![allow(bad_style, missing_docs, unreachable_pub)]
5#[doc = r" The kind of syntax node, e.g. `IDENT`, `FUNCTION_KW`, or `FOR_STMT`."]
6#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
7#[repr(u16)]
8pub enum SyntaxKind {
9 #[doc(hidden)]
10 TOMBSTONE,
11 #[doc(hidden)]
12 EOF,
13 SEMICOLON,
14 COMMA,
15 L_PAREN,
16 R_PAREN,
17 L_CURLY,
18 R_CURLY,
19 L_BRACK,
20 R_BRACK,
21 L_ANGLE,
22 R_ANGLE,
23 TILDE,
24 QUESTION,
25 QUESTION2,
26 QUESTIONDOT,
27 AMP,
28 PIPE,
29 PLUS,
30 PLUS2,
31 STAR,
32 STAR2,
33 SLASH,
34 CARET,
35 PERCENT,
36 DOT,
37 DOT2,
38 COLON,
39 EQ,
40 EQ2,
41 EQ3,
42 FAT_ARROW,
43 BANG,
44 NEQ,
45 NEQ2,
46 MINUS,
47 MINUS2,
48 LTEQ,
49 GTEQ,
50 PLUSEQ,
51 MINUSEQ,
52 PIPEEQ,
53 AMPEQ,
54 CARETEQ,
55 SLASHEQ,
56 STAREQ,
57 PERCENTEQ,
58 AMP2,
59 PIPE2,
60 SHL,
61 SHR,
62 USHR,
63 SHLEQ,
64 SHREQ,
65 USHREQ,
66 AMP2EQ,
67 PIPE2EQ,
68 STAR2EQ,
69 QUESTION2EQ,
70 AT,
71 AWAIT_KW,
72 BREAK_KW,
73 CASE_KW,
74 CATCH_KW,
75 CLASS_KW,
76 CONST_KW,
77 CONTINUE_KW,
78 DEBUGGER_KW,
79 DEFAULT_KW,
80 DELETE_KW,
81 DO_KW,
82 ELSE_KW,
83 ENUM_KW,
84 EXPORT_KW,
85 EXTENDS_KW,
86 FALSE_KW,
87 FINALLY_KW,
88 FOR_KW,
89 FUNCTION_KW,
90 IF_KW,
91 IN_KW,
92 INSTANCEOF_KW,
93 INTERFACE_KW,
94 IMPORT_KW,
95 IMPLEMENTS_KW,
96 NEW_KW,
97 NULL_KW,
98 PACKAGE_KW,
99 PRIVATE_KW,
100 PROTECTED_KW,
101 PUBLIC_KW,
102 RETURN_KW,
103 SUPER_KW,
104 SWITCH_KW,
105 THIS_KW,
106 THROW_KW,
107 TRY_KW,
108 TRUE_KW,
109 TYPEOF_KW,
110 VAR_KW,
111 VOID_KW,
112 WHILE_KW,
113 WITH_KW,
114 YIELD_KW,
115 READONLY_KW,
116 KEYOF_KW,
117 UNIQUE_KW,
118 DECLARE_KW,
119 ABSTRACT_KW,
120 STATIC_KW,
121 ASYNC_KW,
122 TYPE_KW,
123 FROM_KW,
124 AS_KW,
125 REQUIRE_KW,
126 NAMESPACE_KW,
127 ASSERT_KW,
128 MODULE_KW,
129 GLOBAL_KW,
130 INFER_KW,
131 GET_KW,
132 SET_KW,
133 NUMBER,
134 STRING,
135 REGEX,
136 HASH,
137 TEMPLATE_CHUNK,
138 DOLLARCURLY,
139 BACKTICK,
140 ERROR_TOKEN,
141 IDENT,
142 WHITESPACE,
143 COMMENT,
144 SHEBANG,
145 SCRIPT,
146 MODULE,
147 ERROR,
148 BLOCK_STMT,
149 VAR_DECL,
150 DECLARATOR,
151 EMPTY_STMT,
152 EXPR_STMT,
153 IF_STMT,
154 DO_WHILE_STMT,
155 WHILE_STMT,
156 FOR_STMT,
157 FOR_IN_STMT,
158 CONTINUE_STMT,
159 BREAK_STMT,
160 RETURN_STMT,
161 WITH_STMT,
162 SWITCH_STMT,
163 CASE_CLAUSE,
164 DEFAULT_CLAUSE,
165 LABELLED_STMT,
166 THROW_STMT,
167 TRY_STMT,
168 CATCH_CLAUSE,
169 FINALIZER,
170 DEBUGGER_STMT,
171 FN_DECL,
172 NAME,
173 NAME_REF,
174 PARAMETER_LIST,
175 THIS_EXPR,
176 ARRAY_EXPR,
177 OBJECT_EXPR,
178 LITERAL_PROP,
179 GETTER,
180 SETTER,
181 GROUPING_EXPR,
182 NEW_EXPR,
183 FN_EXPR,
184 BRACKET_EXPR,
185 DOT_EXPR,
186 CALL_EXPR,
187 UNARY_EXPR,
188 BIN_EXPR,
189 COND_EXPR,
190 ASSIGN_EXPR,
191 SEQUENCE_EXPR,
192 ARG_LIST,
193 LITERAL,
194 TEMPLATE,
195 TEMPLATE_ELEMENT,
196 CONDITION,
197 SPREAD_ELEMENT,
198 SUPER_CALL,
199 IMPORT_CALL,
200 NEW_TARGET,
201 IMPORT_META,
202 IDENT_PROP,
203 SPREAD_PROP,
204 INITIALIZED_PROP,
205 OBJECT_PATTERN,
206 ARRAY_PATTERN,
207 ASSIGN_PATTERN,
208 REST_PATTERN,
209 KEY_VALUE_PATTERN,
210 COMPUTED_PROPERTY_NAME,
211 FOR_OF_STMT,
212 SINGLE_PATTERN,
213 ARROW_EXPR,
214 YIELD_EXPR,
215 CLASS_DECL,
216 CLASS_EXPR,
217 CLASS_BODY,
218 METHOD,
219 IMPORT_DECL,
220 EXPORT_DECL,
221 EXPORT_NAMED,
222 EXPORT_DEFAULT_DECL,
223 EXPORT_DEFAULT_EXPR,
224 EXPORT_WILDCARD,
225 WILDCARD_IMPORT,
226 NAMED_IMPORTS,
227 SPECIFIER,
228 AWAIT_EXPR,
229 FOR_STMT_TEST,
230 FOR_STMT_UPDATE,
231 FOR_STMT_INIT,
232 PRIVATE_NAME,
233 CLASS_PROP,
234 PRIVATE_PROP,
235 CONSTRUCTOR,
236 CONSTRUCTOR_PARAMETERS,
237 PRIVATE_PROP_ACCESS,
238 IMPORT_STRING_SPECIFIER,
239 EXPR_PATTERN,
240 TS_ANY,
241 TS_UNKNOWN,
242 TS_NUMBER,
243 TS_OBJECT,
244 TS_BOOLEAN,
245 TS_BIGINT,
246 TS_STRING,
247 TS_SYMBOL,
248 TS_VOID,
249 TS_UNDEFINED,
250 TS_NULL,
251 TS_NEVER,
252 TS_THIS,
253 TS_LITERAL,
254 TS_PREDICATE,
255 TS_TUPLE,
256 TS_TUPLE_ELEMENT,
257 TS_PAREN,
258 TS_TYPE_REF,
259 TS_QUALIFIED_PATH,
260 TS_TYPE_NAME,
261 TS_TEMPLATE,
262 TS_TEMPLATE_ELEMENT,
263 TS_MAPPED_TYPE,
264 TS_MAPPED_TYPE_PARAM,
265 TS_MAPPED_TYPE_READONLY,
266 TS_TYPE_QUERY,
267 TS_TYPE_QUERY_EXPR,
268 TS_IMPORT,
269 TS_TYPE_ARGS,
270 TS_ARRAY,
271 TS_INDEXED_ARRAY,
272 TS_TYPE_OPERATOR,
273 TS_INTERSECTION,
274 TS_UNION,
275 TS_TYPE_PARAMS,
276 TS_FN_TYPE,
277 TS_CONSTRUCTOR_TYPE,
278 TS_EXTENDS,
279 TS_CONDITIONAL_TYPE,
280 TS_CONSTRAINT,
281 TS_DEFAULT,
282 TS_TYPE_PARAM,
283 TS_NON_NULL,
284 TS_ASSERTION,
285 TS_CONST_ASSERTION,
286 TS_ENUM,
287 TS_ENUM_MEMBER,
288 TS_TYPE_ALIAS_DECL,
289 TS_NAMESPACE_DECL,
290 TS_MODULE_BLOCK,
291 TS_MODULE_DECL,
292 TS_CONSTRUCTOR_PARAM,
293 TS_CALL_SIGNATURE_DECL,
294 TS_CONSTRUCT_SIGNATURE_DECL,
295 TS_INDEX_SIGNATURE,
296 TS_METHOD_SIGNATURE,
297 TS_PROPERTY_SIGNATURE,
298 TS_INTERFACE_DECL,
299 TS_ACCESSIBILITY,
300 TS_OBJECT_TYPE,
301 TS_EXPR_WITH_TYPE_ARGS,
302 TS_IMPORT_EQUALS_DECL,
303 TS_MODULE_REF,
304 TS_EXTERNAL_MODULE_REF,
305 TS_EXPORT_ASSIGNMENT,
306 TS_NAMESPACE_EXPORT_DECL,
307 TS_DECORATOR,
308 TS_INFER,
309 #[doc(hidden)]
310 __LAST,
311}
312use self::SyntaxKind::*;
313impl SyntaxKind {
314 pub fn is_keyword(self) -> bool {
315 match self {
316 AWAIT_KW | BREAK_KW | CASE_KW | CATCH_KW | CLASS_KW | CONST_KW | CONTINUE_KW
317 | DEBUGGER_KW | DEFAULT_KW | DELETE_KW | DO_KW | ELSE_KW | ENUM_KW | EXPORT_KW
318 | EXTENDS_KW | FALSE_KW | FINALLY_KW | FOR_KW | FUNCTION_KW | IF_KW | IN_KW
319 | INSTANCEOF_KW | INTERFACE_KW | IMPORT_KW | IMPLEMENTS_KW | NEW_KW | NULL_KW
320 | PACKAGE_KW | PRIVATE_KW | PROTECTED_KW | PUBLIC_KW | RETURN_KW | SUPER_KW
321 | SWITCH_KW | THIS_KW | THROW_KW | TRY_KW | TRUE_KW | TYPEOF_KW | VAR_KW | VOID_KW
322 | WHILE_KW | WITH_KW | YIELD_KW | READONLY_KW | KEYOF_KW | UNIQUE_KW | DECLARE_KW
323 | ABSTRACT_KW | STATIC_KW | ASYNC_KW | TYPE_KW | FROM_KW | AS_KW | REQUIRE_KW
324 | NAMESPACE_KW | ASSERT_KW | MODULE_KW | GLOBAL_KW | INFER_KW | GET_KW | SET_KW => true,
325 _ => false,
326 }
327 }
328 pub fn is_punct(self) -> bool {
329 match self {
330 SEMICOLON | COMMA | L_PAREN | R_PAREN | L_CURLY | R_CURLY | L_BRACK | R_BRACK
331 | L_ANGLE | R_ANGLE | TILDE | QUESTION | QUESTION2 | QUESTIONDOT | AMP | PIPE
332 | PLUS | PLUS2 | STAR | STAR2 | SLASH | CARET | PERCENT | DOT | DOT2 | COLON | EQ
333 | EQ2 | EQ3 | FAT_ARROW | BANG | NEQ | NEQ2 | MINUS | MINUS2 | LTEQ | GTEQ | PLUSEQ
334 | MINUSEQ | PIPEEQ | AMPEQ | CARETEQ | SLASHEQ | STAREQ | PERCENTEQ | AMP2 | PIPE2
335 | SHL | SHR | USHR | SHLEQ | SHREQ | USHREQ | AMP2EQ | PIPE2EQ | STAR2EQ
336 | QUESTION2EQ | AT => true,
337 _ => false,
338 }
339 }
340 pub fn is_literal(self) -> bool {
341 match self {
342 NUMBER | STRING | REGEX => true,
343 _ => false,
344 }
345 }
346 pub fn is_before_expr(self) -> bool {
347 match self {
348 BANG | L_PAREN | L_BRACK | L_CURLY | SEMICOLON | COMMA | COLON | QUESTION | PLUS2
349 | MINUS2 | TILDE | CASE_KW | DEFAULT_KW | DO_KW | ELSE_KW | RETURN_KW | THROW_KW
350 | NEW_KW | EXTENDS_KW | YIELD_KW | IN_KW | TYPEOF_KW | VOID_KW | DELETE_KW | PLUSEQ
351 | MINUSEQ | PIPEEQ | AMPEQ | CARETEQ | SLASHEQ | STAREQ | PERCENTEQ | AMP2 | PIPE2
352 | SHLEQ | SHREQ | USHREQ | EQ | FAT_ARROW | MINUS | PLUS => true,
353 _ => false,
354 }
355 }
356 pub fn from_keyword(ident: &str) -> Option<SyntaxKind> {
357 let kw = match ident {
358 "await" => AWAIT_KW,
359 "break" => BREAK_KW,
360 "case" => CASE_KW,
361 "catch" => CATCH_KW,
362 "class" => CLASS_KW,
363 "const" => CONST_KW,
364 "continue" => CONTINUE_KW,
365 "debugger" => DEBUGGER_KW,
366 "default" => DEFAULT_KW,
367 "delete" => DELETE_KW,
368 "do" => DO_KW,
369 "else" => ELSE_KW,
370 "enum" => ENUM_KW,
371 "export" => EXPORT_KW,
372 "extends" => EXTENDS_KW,
373 "false" => FALSE_KW,
374 "finally" => FINALLY_KW,
375 "for" => FOR_KW,
376 "function" => FUNCTION_KW,
377 "if" => IF_KW,
378 "in" => IN_KW,
379 "instanceof" => INSTANCEOF_KW,
380 "interface" => INTERFACE_KW,
381 "import" => IMPORT_KW,
382 "implements" => IMPLEMENTS_KW,
383 "new" => NEW_KW,
384 "null" => NULL_KW,
385 "package" => PACKAGE_KW,
386 "private" => PRIVATE_KW,
387 "protected" => PROTECTED_KW,
388 "public" => PUBLIC_KW,
389 "return" => RETURN_KW,
390 "super" => SUPER_KW,
391 "switch" => SWITCH_KW,
392 "this" => THIS_KW,
393 "throw" => THROW_KW,
394 "try" => TRY_KW,
395 "true" => TRUE_KW,
396 "typeof" => TYPEOF_KW,
397 "var" => VAR_KW,
398 "void" => VOID_KW,
399 "while" => WHILE_KW,
400 "with" => WITH_KW,
401 "yield" => YIELD_KW,
402 "readonly" => READONLY_KW,
403 "keyof" => KEYOF_KW,
404 "unique" => UNIQUE_KW,
405 "declare" => DECLARE_KW,
406 "abstract" => ABSTRACT_KW,
407 "static" => STATIC_KW,
408 "async" => ASYNC_KW,
409 "type" => TYPE_KW,
410 "from" => FROM_KW,
411 "as" => AS_KW,
412 "require" => REQUIRE_KW,
413 "namespace" => NAMESPACE_KW,
414 "assert" => ASSERT_KW,
415 "module" => MODULE_KW,
416 "global" => GLOBAL_KW,
417 "infer" => INFER_KW,
418 "get" => GET_KW,
419 "set" => SET_KW,
420 _ => return None,
421 };
422 Some(kw)
423 }
424 pub fn from_char(c: char) -> Option<SyntaxKind> {
425 let tok = match c {
426 ';' => SEMICOLON,
427 ',' => COMMA,
428 '(' => L_PAREN,
429 ')' => R_PAREN,
430 '{' => L_CURLY,
431 '}' => R_CURLY,
432 '[' => L_BRACK,
433 ']' => R_BRACK,
434 '<' => L_ANGLE,
435 '>' => R_ANGLE,
436 '~' => TILDE,
437 '?' => QUESTION,
438 '&' => AMP,
439 '|' => PIPE,
440 '+' => PLUS,
441 '*' => STAR,
442 '/' => SLASH,
443 '^' => CARET,
444 '%' => PERCENT,
445 '.' => DOT,
446 ':' => COLON,
447 '=' => EQ,
448 '!' => BANG,
449 '-' => MINUS,
450 '@' => AT,
451 _ => return None,
452 };
453 Some(tok)
454 }
455 pub fn to_string(&self) -> Option<&str> {
456 let tok = match self {
457 SEMICOLON => ";",
458 COMMA => ",",
459 L_PAREN => "'('",
460 R_PAREN => "')'",
461 L_CURLY => "'{'",
462 R_CURLY => "'}'",
463 L_BRACK => "'['",
464 R_BRACK => "']'",
465 L_ANGLE => "<",
466 R_ANGLE => ">",
467 TILDE => "~",
468 QUESTION => "?",
469 QUESTION2 => "??",
470 QUESTIONDOT => "?.",
471 AMP => "&",
472 PIPE => "|",
473 PLUS => "+",
474 PLUS2 => "++",
475 STAR => "*",
476 STAR2 => "**",
477 SLASH => "/",
478 CARET => "^",
479 PERCENT => "%",
480 DOT => ".",
481 DOT2 => "...",
482 COLON => ":",
483 EQ => "=",
484 EQ2 => "==",
485 EQ3 => "===",
486 FAT_ARROW => "=>",
487 BANG => "!",
488 NEQ => "!=",
489 NEQ2 => "!==",
490 MINUS => "-",
491 MINUS2 => "--",
492 LTEQ => "<=",
493 GTEQ => ">=",
494 PLUSEQ => "+=",
495 MINUSEQ => "-=",
496 PIPEEQ => "|=",
497 AMPEQ => "&=",
498 CARETEQ => "^=",
499 SLASHEQ => "/=",
500 STAREQ => "*=",
501 PERCENTEQ => "%=",
502 AMP2 => "&&",
503 PIPE2 => "||",
504 SHL => "<<",
505 SHR => ">>",
506 USHR => ">>>",
507 SHLEQ => "<<=",
508 SHREQ => ">>=",
509 USHREQ => ">>>=",
510 AMP2EQ => "&&=",
511 PIPE2EQ => "||=",
512 STAR2EQ => "**=",
513 QUESTION2EQ => "??=",
514 AT => "@",
515 _ => return None,
516 };
517 Some(tok)
518 }
519}
520#[doc = r" Utility macro for creating a SyntaxKind through simple macro syntax"]
521#[macro_export]
522macro_rules ! T { [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [??] => { $ crate :: SyntaxKind :: QUESTION2 } ; [?.] => { $ crate :: SyntaxKind :: QUESTIONDOT } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [++] => { $ crate :: SyntaxKind :: PLUS2 } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [**] => { $ crate :: SyntaxKind :: STAR2 } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [...] => { $ crate :: SyntaxKind :: DOT2 } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [===] => { $ crate :: SyntaxKind :: EQ3 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [!==] => { $ crate :: SyntaxKind :: NEQ2 } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [--] => { $ crate :: SyntaxKind :: MINUS2 } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [>>>] => { $ crate :: SyntaxKind :: USHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [>>>=] => { $ crate :: SyntaxKind :: USHREQ } ; [&&=] => { $ crate :: SyntaxKind :: AMP2EQ } ; [||=] => { $ crate :: SyntaxKind :: PIPE2EQ } ; [**=] => { $ crate :: SyntaxKind :: STAR2EQ } ; [??=] => { $ crate :: SyntaxKind :: QUESTION2EQ } ; [@] => { $ crate :: SyntaxKind :: AT } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [case] => { $ crate :: SyntaxKind :: CASE_KW } ; [catch] => { $ crate :: SyntaxKind :: CATCH_KW } ; [class] => { $ crate :: SyntaxKind :: CLASS_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [debugger] => { $ crate :: SyntaxKind :: DEBUGGER_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [delete] => { $ crate :: SyntaxKind :: DELETE_KW } ; [do] => { $ crate :: SyntaxKind :: DO_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [export] => { $ crate :: SyntaxKind :: EXPORT_KW } ; [extends] => { $ crate :: SyntaxKind :: EXTENDS_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [finally] => { $ crate :: SyntaxKind :: FINALLY_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [function] => { $ crate :: SyntaxKind :: FUNCTION_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [instanceof] => { $ crate :: SyntaxKind :: INSTANCEOF_KW } ; [interface] => { $ crate :: SyntaxKind :: INTERFACE_KW } ; [import] => { $ crate :: SyntaxKind :: IMPORT_KW } ; [implements] => { $ crate :: SyntaxKind :: IMPLEMENTS_KW } ; [new] => { $ crate :: SyntaxKind :: NEW_KW } ; [null] => { $ crate :: SyntaxKind :: NULL_KW } ; [package] => { $ crate :: SyntaxKind :: PACKAGE_KW } ; [private] => { $ crate :: SyntaxKind :: PRIVATE_KW } ; [protected] => { $ crate :: SyntaxKind :: PROTECTED_KW } ; [public] => { $ crate :: SyntaxKind :: PUBLIC_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [switch] => { $ crate :: SyntaxKind :: SWITCH_KW } ; [this] => { $ crate :: SyntaxKind :: THIS_KW } ; [throw] => { $ crate :: SyntaxKind :: THROW_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [typeof] => { $ crate :: SyntaxKind :: TYPEOF_KW } ; [var] => { $ crate :: SyntaxKind :: VAR_KW } ; [void] => { $ crate :: SyntaxKind :: VOID_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [with] => { $ crate :: SyntaxKind :: WITH_KW } ; [yield] => { $ crate :: SyntaxKind :: YIELD_KW } ; [readonly] => { $ crate :: SyntaxKind :: READONLY_KW } ; [keyof] => { $ crate :: SyntaxKind :: KEYOF_KW } ; [unique] => { $ crate :: SyntaxKind :: UNIQUE_KW } ; [declare] => { $ crate :: SyntaxKind :: DECLARE_KW } ; [abstract] => { $ crate :: SyntaxKind :: ABSTRACT_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [from] => { $ crate :: SyntaxKind :: FROM_KW } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [require] => { $ crate :: SyntaxKind :: REQUIRE_KW } ; [namespace] => { $ crate :: SyntaxKind :: NAMESPACE_KW } ; [assert] => { $ crate :: SyntaxKind :: ASSERT_KW } ; [module] => { $ crate :: SyntaxKind :: MODULE_KW } ; [global] => { $ crate :: SyntaxKind :: GLOBAL_KW } ; [infer] => { $ crate :: SyntaxKind :: INFER_KW } ; [get] => { $ crate :: SyntaxKind :: GET_KW } ; [set] => { $ crate :: SyntaxKind :: SET_KW } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; [#] => { $ crate :: SyntaxKind :: HASH } ; }