1 | "use strict";
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 |
|
18 | Object.defineProperty(exports, "__esModule", { value: true });
|
19 | exports.SyntaxWalker = void 0;
|
20 | var ts = require("typescript");
|
21 | var SyntaxWalker = (function () {
|
22 | function SyntaxWalker() {
|
23 | }
|
24 | SyntaxWalker.prototype.walk = function (node) {
|
25 | this.visitNode(node);
|
26 | };
|
27 | SyntaxWalker.prototype.visitAnyKeyword = function (node) {
|
28 | this.walkChildren(node);
|
29 | };
|
30 | SyntaxWalker.prototype.visitArrayLiteralExpression = function (node) {
|
31 | this.walkChildren(node);
|
32 | };
|
33 | SyntaxWalker.prototype.visitArrayType = function (node) {
|
34 | this.walkChildren(node);
|
35 | };
|
36 | SyntaxWalker.prototype.visitArrowFunction = function (node) {
|
37 | this.walkChildren(node);
|
38 | };
|
39 | SyntaxWalker.prototype.visitBinaryExpression = function (node) {
|
40 | this.walkChildren(node);
|
41 | };
|
42 | SyntaxWalker.prototype.visitBindingElement = function (node) {
|
43 | this.walkChildren(node);
|
44 | };
|
45 | SyntaxWalker.prototype.visitBindingPattern = function (node) {
|
46 | this.walkChildren(node);
|
47 | };
|
48 | SyntaxWalker.prototype.visitBlock = function (node) {
|
49 | this.walkChildren(node);
|
50 | };
|
51 | SyntaxWalker.prototype.visitBreakStatement = function (node) {
|
52 | this.walkChildren(node);
|
53 | };
|
54 | SyntaxWalker.prototype.visitCallExpression = function (node) {
|
55 | this.walkChildren(node);
|
56 | };
|
57 | SyntaxWalker.prototype.visitCallSignature = function (node) {
|
58 | this.walkChildren(node);
|
59 | };
|
60 | SyntaxWalker.prototype.visitCaseClause = function (node) {
|
61 | this.walkChildren(node);
|
62 | };
|
63 | SyntaxWalker.prototype.visitClassDeclaration = function (node) {
|
64 | this.walkChildren(node);
|
65 | };
|
66 | SyntaxWalker.prototype.visitClassExpression = function (node) {
|
67 | this.walkChildren(node);
|
68 | };
|
69 | SyntaxWalker.prototype.visitCatchClause = function (node) {
|
70 | this.walkChildren(node);
|
71 | };
|
72 | SyntaxWalker.prototype.visitConditionalExpression = function (node) {
|
73 | this.walkChildren(node);
|
74 | };
|
75 | SyntaxWalker.prototype.visitConstructSignature = function (node) {
|
76 | this.walkChildren(node);
|
77 | };
|
78 | SyntaxWalker.prototype.visitConstructorDeclaration = function (node) {
|
79 | this.walkChildren(node);
|
80 | };
|
81 | SyntaxWalker.prototype.visitConstructorType = function (node) {
|
82 | this.walkChildren(node);
|
83 | };
|
84 | SyntaxWalker.prototype.visitContinueStatement = function (node) {
|
85 | this.walkChildren(node);
|
86 | };
|
87 | SyntaxWalker.prototype.visitDebuggerStatement = function (node) {
|
88 | this.walkChildren(node);
|
89 | };
|
90 | SyntaxWalker.prototype.visitDefaultClause = function (node) {
|
91 | this.walkChildren(node);
|
92 | };
|
93 | SyntaxWalker.prototype.visitDoStatement = function (node) {
|
94 | this.walkChildren(node);
|
95 | };
|
96 | SyntaxWalker.prototype.visitElementAccessExpression = function (node) {
|
97 | this.walkChildren(node);
|
98 | };
|
99 | SyntaxWalker.prototype.visitEndOfFileToken = function (node) {
|
100 | this.walkChildren(node);
|
101 | };
|
102 | SyntaxWalker.prototype.visitEnumDeclaration = function (node) {
|
103 | this.walkChildren(node);
|
104 | };
|
105 | SyntaxWalker.prototype.visitEnumMember = function (node) {
|
106 | this.walkChildren(node);
|
107 | };
|
108 | SyntaxWalker.prototype.visitExportAssignment = function (node) {
|
109 | this.walkChildren(node);
|
110 | };
|
111 | SyntaxWalker.prototype.visitExpressionStatement = function (node) {
|
112 | this.walkChildren(node);
|
113 | };
|
114 | SyntaxWalker.prototype.visitForStatement = function (node) {
|
115 | this.walkChildren(node);
|
116 | };
|
117 | SyntaxWalker.prototype.visitForInStatement = function (node) {
|
118 | this.walkChildren(node);
|
119 | };
|
120 | SyntaxWalker.prototype.visitForOfStatement = function (node) {
|
121 | this.walkChildren(node);
|
122 | };
|
123 | SyntaxWalker.prototype.visitFunctionDeclaration = function (node) {
|
124 | this.walkChildren(node);
|
125 | };
|
126 | SyntaxWalker.prototype.visitFunctionExpression = function (node) {
|
127 | this.walkChildren(node);
|
128 | };
|
129 | SyntaxWalker.prototype.visitFunctionType = function (node) {
|
130 | this.walkChildren(node);
|
131 | };
|
132 | SyntaxWalker.prototype.visitGetAccessor = function (node) {
|
133 | this.walkChildren(node);
|
134 | };
|
135 | SyntaxWalker.prototype.visitIdentifier = function (node) {
|
136 | this.walkChildren(node);
|
137 | };
|
138 | SyntaxWalker.prototype.visitIfStatement = function (node) {
|
139 | this.walkChildren(node);
|
140 | };
|
141 | SyntaxWalker.prototype.visitImportDeclaration = function (node) {
|
142 | this.walkChildren(node);
|
143 | };
|
144 | SyntaxWalker.prototype.visitImportEqualsDeclaration = function (node) {
|
145 | this.walkChildren(node);
|
146 | };
|
147 | SyntaxWalker.prototype.visitIndexSignatureDeclaration = function (node) {
|
148 | this.walkChildren(node);
|
149 | };
|
150 | SyntaxWalker.prototype.visitInterfaceDeclaration = function (node) {
|
151 | this.walkChildren(node);
|
152 | };
|
153 | SyntaxWalker.prototype.visitJsxAttribute = function (node) {
|
154 | this.walkChildren(node);
|
155 | };
|
156 | SyntaxWalker.prototype.visitJsxElement = function (node) {
|
157 | this.walkChildren(node);
|
158 | };
|
159 | SyntaxWalker.prototype.visitJsxExpression = function (node) {
|
160 | this.walkChildren(node);
|
161 | };
|
162 | SyntaxWalker.prototype.visitJsxSelfClosingElement = function (node) {
|
163 | this.walkChildren(node);
|
164 | };
|
165 | SyntaxWalker.prototype.visitJsxSpreadAttribute = function (node) {
|
166 | this.walkChildren(node);
|
167 | };
|
168 | SyntaxWalker.prototype.visitLabeledStatement = function (node) {
|
169 | this.walkChildren(node);
|
170 | };
|
171 | SyntaxWalker.prototype.visitMethodDeclaration = function (node) {
|
172 | this.walkChildren(node);
|
173 | };
|
174 | SyntaxWalker.prototype.visitMethodSignature = function (node) {
|
175 | this.walkChildren(node);
|
176 | };
|
177 | SyntaxWalker.prototype.visitModuleDeclaration = function (node) {
|
178 | this.walkChildren(node);
|
179 | };
|
180 | SyntaxWalker.prototype.visitNamedImports = function (node) {
|
181 | this.walkChildren(node);
|
182 | };
|
183 | SyntaxWalker.prototype.visitNamespaceImport = function (node) {
|
184 | this.walkChildren(node);
|
185 | };
|
186 | SyntaxWalker.prototype.visitNewExpression = function (node) {
|
187 | this.walkChildren(node);
|
188 | };
|
189 | SyntaxWalker.prototype.visitNonNullExpression = function (node) {
|
190 | this.walkChildren(node);
|
191 | };
|
192 | SyntaxWalker.prototype.visitNumericLiteral = function (node) {
|
193 | this.walkChildren(node);
|
194 | };
|
195 | SyntaxWalker.prototype.visitObjectLiteralExpression = function (node) {
|
196 | this.walkChildren(node);
|
197 | };
|
198 | SyntaxWalker.prototype.visitParameterDeclaration = function (node) {
|
199 | this.walkChildren(node);
|
200 | };
|
201 | SyntaxWalker.prototype.visitPostfixUnaryExpression = function (node) {
|
202 | this.walkChildren(node);
|
203 | };
|
204 | SyntaxWalker.prototype.visitPrefixUnaryExpression = function (node) {
|
205 | this.walkChildren(node);
|
206 | };
|
207 | SyntaxWalker.prototype.visitPropertyAccessExpression = function (node) {
|
208 | this.walkChildren(node);
|
209 | };
|
210 | SyntaxWalker.prototype.visitPropertyAssignment = function (node) {
|
211 | this.walkChildren(node);
|
212 | };
|
213 | SyntaxWalker.prototype.visitPropertyDeclaration = function (node) {
|
214 | this.walkChildren(node);
|
215 | };
|
216 | SyntaxWalker.prototype.visitPropertySignature = function (node) {
|
217 | this.walkChildren(node);
|
218 | };
|
219 | SyntaxWalker.prototype.visitRegularExpressionLiteral = function (node) {
|
220 | this.walkChildren(node);
|
221 | };
|
222 | SyntaxWalker.prototype.visitReturnStatement = function (node) {
|
223 | this.walkChildren(node);
|
224 | };
|
225 | SyntaxWalker.prototype.visitSetAccessor = function (node) {
|
226 | this.walkChildren(node);
|
227 | };
|
228 | SyntaxWalker.prototype.visitSourceFile = function (node) {
|
229 | this.walkChildren(node);
|
230 | };
|
231 | SyntaxWalker.prototype.visitStringLiteral = function (node) {
|
232 | this.walkChildren(node);
|
233 | };
|
234 | SyntaxWalker.prototype.visitSwitchStatement = function (node) {
|
235 | this.walkChildren(node);
|
236 | };
|
237 | SyntaxWalker.prototype.visitTemplateExpression = function (node) {
|
238 | this.walkChildren(node);
|
239 | };
|
240 | SyntaxWalker.prototype.visitThrowStatement = function (node) {
|
241 | this.walkChildren(node);
|
242 | };
|
243 | SyntaxWalker.prototype.visitTryStatement = function (node) {
|
244 | this.walkChildren(node);
|
245 | };
|
246 | SyntaxWalker.prototype.visitTupleType = function (node) {
|
247 | this.walkChildren(node);
|
248 | };
|
249 | SyntaxWalker.prototype.visitTypeAliasDeclaration = function (node) {
|
250 | this.walkChildren(node);
|
251 | };
|
252 | SyntaxWalker.prototype.visitTypeAssertionExpression = function (node) {
|
253 | this.walkChildren(node);
|
254 | };
|
255 | SyntaxWalker.prototype.visitTypeLiteral = function (node) {
|
256 | this.walkChildren(node);
|
257 | };
|
258 | SyntaxWalker.prototype.visitTypeReference = function (node) {
|
259 | this.walkChildren(node);
|
260 | };
|
261 | SyntaxWalker.prototype.visitVariableDeclaration = function (node) {
|
262 | this.walkChildren(node);
|
263 | };
|
264 | SyntaxWalker.prototype.visitVariableDeclarationList = function (node) {
|
265 | this.walkChildren(node);
|
266 | };
|
267 | SyntaxWalker.prototype.visitVariableStatement = function (node) {
|
268 | this.walkChildren(node);
|
269 | };
|
270 | SyntaxWalker.prototype.visitWhileStatement = function (node) {
|
271 | this.walkChildren(node);
|
272 | };
|
273 | SyntaxWalker.prototype.visitWithStatement = function (node) {
|
274 | this.walkChildren(node);
|
275 | };
|
276 | SyntaxWalker.prototype.visitNode = function (node) {
|
277 | switch (node.kind) {
|
278 | case ts.SyntaxKind.AnyKeyword:
|
279 | this.visitAnyKeyword(node);
|
280 | break;
|
281 | case ts.SyntaxKind.ArrayBindingPattern:
|
282 | this.visitBindingPattern(node);
|
283 | break;
|
284 | case ts.SyntaxKind.ArrayLiteralExpression:
|
285 | this.visitArrayLiteralExpression(node);
|
286 | break;
|
287 | case ts.SyntaxKind.ArrayType:
|
288 | this.visitArrayType(node);
|
289 | break;
|
290 | case ts.SyntaxKind.ArrowFunction:
|
291 | this.visitArrowFunction(node);
|
292 | break;
|
293 | case ts.SyntaxKind.BinaryExpression:
|
294 | this.visitBinaryExpression(node);
|
295 | break;
|
296 | case ts.SyntaxKind.BindingElement:
|
297 | this.visitBindingElement(node);
|
298 | break;
|
299 | case ts.SyntaxKind.Block:
|
300 | this.visitBlock(node);
|
301 | break;
|
302 | case ts.SyntaxKind.BreakStatement:
|
303 | this.visitBreakStatement(node);
|
304 | break;
|
305 | case ts.SyntaxKind.CallExpression:
|
306 | this.visitCallExpression(node);
|
307 | break;
|
308 | case ts.SyntaxKind.CallSignature:
|
309 | this.visitCallSignature(node);
|
310 | break;
|
311 | case ts.SyntaxKind.CaseClause:
|
312 | this.visitCaseClause(node);
|
313 | break;
|
314 | case ts.SyntaxKind.ClassDeclaration:
|
315 | this.visitClassDeclaration(node);
|
316 | break;
|
317 | case ts.SyntaxKind.ClassExpression:
|
318 | this.visitClassExpression(node);
|
319 | break;
|
320 | case ts.SyntaxKind.CatchClause:
|
321 | this.visitCatchClause(node);
|
322 | break;
|
323 | case ts.SyntaxKind.ConditionalExpression:
|
324 | this.visitConditionalExpression(node);
|
325 | break;
|
326 | case ts.SyntaxKind.ConstructSignature:
|
327 | this.visitConstructSignature(node);
|
328 | break;
|
329 | case ts.SyntaxKind.Constructor:
|
330 | this.visitConstructorDeclaration(node);
|
331 | break;
|
332 | case ts.SyntaxKind.ConstructorType:
|
333 | this.visitConstructorType(node);
|
334 | break;
|
335 | case ts.SyntaxKind.ContinueStatement:
|
336 | this.visitContinueStatement(node);
|
337 | break;
|
338 | case ts.SyntaxKind.DebuggerStatement:
|
339 | this.visitDebuggerStatement(node);
|
340 | break;
|
341 | case ts.SyntaxKind.DefaultClause:
|
342 | this.visitDefaultClause(node);
|
343 | break;
|
344 | case ts.SyntaxKind.DoStatement:
|
345 | this.visitDoStatement(node);
|
346 | break;
|
347 | case ts.SyntaxKind.ElementAccessExpression:
|
348 | this.visitElementAccessExpression(node);
|
349 | break;
|
350 | case ts.SyntaxKind.EndOfFileToken:
|
351 | this.visitEndOfFileToken(node);
|
352 | break;
|
353 | case ts.SyntaxKind.EnumDeclaration:
|
354 | this.visitEnumDeclaration(node);
|
355 | break;
|
356 | case ts.SyntaxKind.EnumMember:
|
357 | this.visitEnumMember(node);
|
358 | break;
|
359 | case ts.SyntaxKind.ExportAssignment:
|
360 | this.visitExportAssignment(node);
|
361 | break;
|
362 | case ts.SyntaxKind.ExpressionStatement:
|
363 | this.visitExpressionStatement(node);
|
364 | break;
|
365 | case ts.SyntaxKind.ForStatement:
|
366 | this.visitForStatement(node);
|
367 | break;
|
368 | case ts.SyntaxKind.ForInStatement:
|
369 | this.visitForInStatement(node);
|
370 | break;
|
371 | case ts.SyntaxKind.ForOfStatement:
|
372 | this.visitForOfStatement(node);
|
373 | break;
|
374 | case ts.SyntaxKind.FunctionDeclaration:
|
375 | this.visitFunctionDeclaration(node);
|
376 | break;
|
377 | case ts.SyntaxKind.FunctionExpression:
|
378 | this.visitFunctionExpression(node);
|
379 | break;
|
380 | case ts.SyntaxKind.FunctionType:
|
381 | this.visitFunctionType(node);
|
382 | break;
|
383 | case ts.SyntaxKind.GetAccessor:
|
384 | this.visitGetAccessor(node);
|
385 | break;
|
386 | case ts.SyntaxKind.Identifier:
|
387 | this.visitIdentifier(node);
|
388 | break;
|
389 | case ts.SyntaxKind.IfStatement:
|
390 | this.visitIfStatement(node);
|
391 | break;
|
392 | case ts.SyntaxKind.ImportDeclaration:
|
393 | this.visitImportDeclaration(node);
|
394 | break;
|
395 | case ts.SyntaxKind.ImportEqualsDeclaration:
|
396 | this.visitImportEqualsDeclaration(node);
|
397 | break;
|
398 | case ts.SyntaxKind.IndexSignature:
|
399 | this.visitIndexSignatureDeclaration(node);
|
400 | break;
|
401 | case ts.SyntaxKind.InterfaceDeclaration:
|
402 | this.visitInterfaceDeclaration(node);
|
403 | break;
|
404 | case ts.SyntaxKind.JsxAttribute:
|
405 | this.visitJsxAttribute(node);
|
406 | break;
|
407 | case ts.SyntaxKind.JsxElement:
|
408 | this.visitJsxElement(node);
|
409 | break;
|
410 | case ts.SyntaxKind.JsxExpression:
|
411 | this.visitJsxExpression(node);
|
412 | break;
|
413 | case ts.SyntaxKind.JsxSelfClosingElement:
|
414 | this.visitJsxSelfClosingElement(node);
|
415 | break;
|
416 | case ts.SyntaxKind.JsxSpreadAttribute:
|
417 | this.visitJsxSpreadAttribute(node);
|
418 | break;
|
419 | case ts.SyntaxKind.LabeledStatement:
|
420 | this.visitLabeledStatement(node);
|
421 | break;
|
422 | case ts.SyntaxKind.MethodDeclaration:
|
423 | this.visitMethodDeclaration(node);
|
424 | break;
|
425 | case ts.SyntaxKind.MethodSignature:
|
426 | this.visitMethodSignature(node);
|
427 | break;
|
428 | case ts.SyntaxKind.ModuleDeclaration:
|
429 | this.visitModuleDeclaration(node);
|
430 | break;
|
431 | case ts.SyntaxKind.NamedImports:
|
432 | this.visitNamedImports(node);
|
433 | break;
|
434 | case ts.SyntaxKind.NamespaceImport:
|
435 | this.visitNamespaceImport(node);
|
436 | break;
|
437 | case ts.SyntaxKind.NewExpression:
|
438 | this.visitNewExpression(node);
|
439 | break;
|
440 | case ts.SyntaxKind.NonNullExpression:
|
441 | this.visitNonNullExpression(node);
|
442 | break;
|
443 | case ts.SyntaxKind.NumericLiteral:
|
444 | this.visitNumericLiteral(node);
|
445 | break;
|
446 | case ts.SyntaxKind.ObjectBindingPattern:
|
447 | this.visitBindingPattern(node);
|
448 | break;
|
449 | case ts.SyntaxKind.ObjectLiteralExpression:
|
450 | this.visitObjectLiteralExpression(node);
|
451 | break;
|
452 | case ts.SyntaxKind.Parameter:
|
453 | this.visitParameterDeclaration(node);
|
454 | break;
|
455 | case ts.SyntaxKind.PostfixUnaryExpression:
|
456 | this.visitPostfixUnaryExpression(node);
|
457 | break;
|
458 | case ts.SyntaxKind.PrefixUnaryExpression:
|
459 | this.visitPrefixUnaryExpression(node);
|
460 | break;
|
461 | case ts.SyntaxKind.PropertyAccessExpression:
|
462 | this.visitPropertyAccessExpression(node);
|
463 | break;
|
464 | case ts.SyntaxKind.PropertyAssignment:
|
465 | this.visitPropertyAssignment(node);
|
466 | break;
|
467 | case ts.SyntaxKind.PropertyDeclaration:
|
468 | this.visitPropertyDeclaration(node);
|
469 | break;
|
470 | case ts.SyntaxKind.PropertySignature:
|
471 | this.visitPropertySignature(node);
|
472 | break;
|
473 | case ts.SyntaxKind.RegularExpressionLiteral:
|
474 | this.visitRegularExpressionLiteral(node);
|
475 | break;
|
476 | case ts.SyntaxKind.ReturnStatement:
|
477 | this.visitReturnStatement(node);
|
478 | break;
|
479 | case ts.SyntaxKind.SetAccessor:
|
480 | this.visitSetAccessor(node);
|
481 | break;
|
482 | case ts.SyntaxKind.SourceFile:
|
483 | this.visitSourceFile(node);
|
484 | break;
|
485 | case ts.SyntaxKind.StringLiteral:
|
486 | this.visitStringLiteral(node);
|
487 | break;
|
488 | case ts.SyntaxKind.SwitchStatement:
|
489 | this.visitSwitchStatement(node);
|
490 | break;
|
491 | case ts.SyntaxKind.TemplateExpression:
|
492 | this.visitTemplateExpression(node);
|
493 | break;
|
494 | case ts.SyntaxKind.ThrowStatement:
|
495 | this.visitThrowStatement(node);
|
496 | break;
|
497 | case ts.SyntaxKind.TryStatement:
|
498 | this.visitTryStatement(node);
|
499 | break;
|
500 | case ts.SyntaxKind.TupleType:
|
501 | this.visitTupleType(node);
|
502 | break;
|
503 | case ts.SyntaxKind.TypeAliasDeclaration:
|
504 | this.visitTypeAliasDeclaration(node);
|
505 | break;
|
506 | case ts.SyntaxKind.TypeAssertionExpression:
|
507 | this.visitTypeAssertionExpression(node);
|
508 | break;
|
509 | case ts.SyntaxKind.TypeLiteral:
|
510 | this.visitTypeLiteral(node);
|
511 | break;
|
512 | case ts.SyntaxKind.TypeReference:
|
513 | this.visitTypeReference(node);
|
514 | break;
|
515 | case ts.SyntaxKind.VariableDeclaration:
|
516 | this.visitVariableDeclaration(node);
|
517 | break;
|
518 | case ts.SyntaxKind.VariableDeclarationList:
|
519 | this.visitVariableDeclarationList(node);
|
520 | break;
|
521 | case ts.SyntaxKind.VariableStatement:
|
522 | this.visitVariableStatement(node);
|
523 | break;
|
524 | case ts.SyntaxKind.WhileStatement:
|
525 | this.visitWhileStatement(node);
|
526 | break;
|
527 | case ts.SyntaxKind.WithStatement:
|
528 | this.visitWithStatement(node);
|
529 | break;
|
530 | default:
|
531 | this.walkChildren(node);
|
532 | }
|
533 | };
|
534 | SyntaxWalker.prototype.walkChildren = function (node) {
|
535 | var _this = this;
|
536 | ts.forEachChild(node, function (child) { return _this.visitNode(child); });
|
537 | };
|
538 | return SyntaxWalker;
|
539 | }());
|
540 | exports.SyntaxWalker = SyntaxWalker;
|