2 Object.defineProperty(exports, "__esModule", { value: true });
3 const ts = require("typescript");
4 function isAccessorDeclaration(node) {
5 return node.kind === ts.SyntaxKind.GetAccessor ||
6 node.kind === ts.SyntaxKind.SetAccessor;
8 exports.isAccessorDeclaration = isAccessorDeclaration;
9 function isArrayBindingPattern(node) {
10 return node.kind === ts.SyntaxKind.ArrayBindingPattern;
12 exports.isArrayBindingPattern = isArrayBindingPattern;
13 function isArrayLiteralExpression(node) {
14 return node.kind === ts.SyntaxKind.ArrayLiteralExpression;
16 exports.isArrayLiteralExpression = isArrayLiteralExpression;
17 function isArrayTypeNode(node) {
18 return node.kind === ts.SyntaxKind.ArrayType;
20 exports.isArrayTypeNode = isArrayTypeNode;
21 function isArrowFunction(node) {
22 return node.kind === ts.SyntaxKind.ArrowFunction;
24 exports.isArrowFunction = isArrowFunction;
25 function isAsExpression(node) {
26 return node.kind === ts.SyntaxKind.AsExpression;
28 exports.isAsExpression = isAsExpression;
29 function isAssertionExpression(node) {
30 return node.kind === ts.SyntaxKind.AsExpression ||
31 node.kind === ts.SyntaxKind.TypeAssertionExpression;
33 exports.isAssertionExpression = isAssertionExpression;
34 function isAwaitExpression(node) {
35 return node.kind === ts.SyntaxKind.AwaitExpression;
37 exports.isAwaitExpression = isAwaitExpression;
38 function isBinaryExpression(node) {
39 return node.kind === ts.SyntaxKind.BinaryExpression;
41 exports.isBinaryExpression = isBinaryExpression;
42 function isBindingElement(node) {
43 return node.kind === ts.SyntaxKind.BindingElement;
45 exports.isBindingElement = isBindingElement;
46 function isBindingPattern(node) {
47 return node.kind === ts.SyntaxKind.ArrayBindingPattern ||
48 node.kind === ts.SyntaxKind.ObjectBindingPattern;
50 exports.isBindingPattern = isBindingPattern;
51 function isBlock(node) {
52 return node.kind === ts.SyntaxKind.Block;
54 exports.isBlock = isBlock;
55 function isBlockLike(node) {
56 return node.statements !== undefined;
58 exports.isBlockLike = isBlockLike;
59 function isBooleanLiteral(node) {
60 return node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword;
62 exports.isBooleanLiteral = isBooleanLiteral;
63 function isBreakOrContinueStatement(node) {
64 return node.kind === ts.SyntaxKind.BreakStatement ||
65 node.kind === ts.SyntaxKind.ContinueStatement;
67 exports.isBreakOrContinueStatement = isBreakOrContinueStatement;
68 function isBreakStatement(node) {
69 return node.kind === ts.SyntaxKind.BreakStatement;
71 exports.isBreakStatement = isBreakStatement;
72 function isCallExpression(node) {
73 return node.kind === ts.SyntaxKind.CallExpression;
75 exports.isCallExpression = isCallExpression;
76 function isCallLikeExpression(node) {
78 case ts.SyntaxKind.CallExpression:
79 case ts.SyntaxKind.Decorator:
80 case ts.SyntaxKind.JsxOpeningElement:
81 case ts.SyntaxKind.JsxSelfClosingElement:
82 case ts.SyntaxKind.NewExpression:
83 case ts.SyntaxKind.TaggedTemplateExpression:
89 exports.isCallLikeExpression = isCallLikeExpression;
90 function isCallSignatureDeclaration(node) {
91 return node.kind === ts.SyntaxKind.CallSignature;
93 exports.isCallSignatureDeclaration = isCallSignatureDeclaration;
94 function isCaseBlock(node) {
95 return node.kind === ts.SyntaxKind.CaseBlock;
97 exports.isCaseBlock = isCaseBlock;
98 function isCaseClause(node) {
99 return node.kind === ts.SyntaxKind.CaseClause;
101 exports.isCaseClause = isCaseClause;
102 function isCaseOrDefaultClause(node) {
103 return node.kind === ts.SyntaxKind.CaseClause ||
104 node.kind === ts.SyntaxKind.DefaultClause;
106 exports.isCaseOrDefaultClause = isCaseOrDefaultClause;
107 function isCatchClause(node) {
108 return node.kind === ts.SyntaxKind.CatchClause;
110 exports.isCatchClause = isCatchClause;
111 function isClassDeclaration(node) {
112 return node.kind === ts.SyntaxKind.ClassDeclaration;
114 exports.isClassDeclaration = isClassDeclaration;
115 function isClassExpression(node) {
116 return node.kind === ts.SyntaxKind.ClassExpression;
118 exports.isClassExpression = isClassExpression;
119 function isClassLikeDeclaration(node) {
120 return node.kind === ts.SyntaxKind.ClassDeclaration ||
121 node.kind === ts.SyntaxKind.ClassExpression;
123 exports.isClassLikeDeclaration = isClassLikeDeclaration;
124 function isCommaListExpression(node) {
125 return node.kind === ts.SyntaxKind.CommaListExpression;
127 exports.isCommaListExpression = isCommaListExpression;
128 function isConditionalExpression(node) {
129 return node.kind === ts.SyntaxKind.ConditionalExpression;
131 exports.isConditionalExpression = isConditionalExpression;
132 function isConditionalTypeNode(node) {
133 return node.kind === ts.SyntaxKind.ConditionalType;
135 exports.isConditionalTypeNode = isConditionalTypeNode;
136 function isConstructorDeclaration(node) {
137 return node.kind === ts.SyntaxKind.Constructor;
139 exports.isConstructorDeclaration = isConstructorDeclaration;
140 function isConstructorTypeNode(node) {
141 return node.kind === ts.SyntaxKind.ConstructorType;
143 exports.isConstructorTypeNode = isConstructorTypeNode;
144 function isConstructSignatureDeclaration(node) {
145 return node.kind === ts.SyntaxKind.ConstructSignature;
147 exports.isConstructSignatureDeclaration = isConstructSignatureDeclaration;
148 function isContinueStatement(node) {
149 return node.kind === ts.SyntaxKind.ContinueStatement;
151 exports.isContinueStatement = isContinueStatement;
152 function isComputedPropertyName(node) {
153 return node.kind === ts.SyntaxKind.ComputedPropertyName;
155 exports.isComputedPropertyName = isComputedPropertyName;
156 function isDebuggerStatement(node) {
157 return node.kind === ts.SyntaxKind.DebuggerStatement;
159 exports.isDebuggerStatement = isDebuggerStatement;
160 function isDecorator(node) {
161 return node.kind === ts.SyntaxKind.Decorator;
163 exports.isDecorator = isDecorator;
164 function isDefaultClause(node) {
165 return node.kind === ts.SyntaxKind.DefaultClause;
167 exports.isDefaultClause = isDefaultClause;
168 function isDeleteExpression(node) {
169 return node.kind === ts.SyntaxKind.DeleteExpression;
171 exports.isDeleteExpression = isDeleteExpression;
172 function isDoStatement(node) {
173 return node.kind === ts.SyntaxKind.DoStatement;
175 exports.isDoStatement = isDoStatement;
176 function isElementAccessExpression(node) {
177 return node.kind === ts.SyntaxKind.ElementAccessExpression;
179 exports.isElementAccessExpression = isElementAccessExpression;
180 function isEmptyStatement(node) {
181 return node.kind === ts.SyntaxKind.EmptyStatement;
183 exports.isEmptyStatement = isEmptyStatement;
184 function isEntityName(node) {
185 return node.kind === ts.SyntaxKind.Identifier || isQualifiedName(node);
187 exports.isEntityName = isEntityName;
188 function isEntityNameExpression(node) {
189 return node.kind === ts.SyntaxKind.Identifier ||
190 isPropertyAccessExpression(node) && isEntityNameExpression(node.expression);
192 exports.isEntityNameExpression = isEntityNameExpression;
193 function isEnumDeclaration(node) {
194 return node.kind === ts.SyntaxKind.EnumDeclaration;
196 exports.isEnumDeclaration = isEnumDeclaration;
197 function isEnumMember(node) {
198 return node.kind === ts.SyntaxKind.EnumMember;
200 exports.isEnumMember = isEnumMember;
201 function isExportAssignment(node) {
202 return node.kind === ts.SyntaxKind.ExportAssignment;
204 exports.isExportAssignment = isExportAssignment;
205 function isExportDeclaration(node) {
206 return node.kind === ts.SyntaxKind.ExportDeclaration;
208 exports.isExportDeclaration = isExportDeclaration;
209 function isExportSpecifier(node) {
210 return node.kind === ts.SyntaxKind.ExportSpecifier;
212 exports.isExportSpecifier = isExportSpecifier;
213 function isExpression(node) {
215 case ts.SyntaxKind.ArrayLiteralExpression:
216 case ts.SyntaxKind.ArrowFunction:
217 case ts.SyntaxKind.AsExpression:
218 case ts.SyntaxKind.AwaitExpression:
219 case ts.SyntaxKind.BinaryExpression:
220 case ts.SyntaxKind.CallExpression:
221 case ts.SyntaxKind.ClassExpression:
222 case ts.SyntaxKind.CommaListExpression:
223 case ts.SyntaxKind.ConditionalExpression:
224 case ts.SyntaxKind.DeleteExpression:
225 case ts.SyntaxKind.ElementAccessExpression:
226 case ts.SyntaxKind.FalseKeyword:
227 case ts.SyntaxKind.FunctionExpression:
228 case ts.SyntaxKind.Identifier:
229 case ts.SyntaxKind.JsxElement:
230 case ts.SyntaxKind.JsxFragment:
231 case ts.SyntaxKind.JsxExpression:
232 case ts.SyntaxKind.JsxOpeningElement:
233 case ts.SyntaxKind.JsxOpeningFragment:
234 case ts.SyntaxKind.JsxSelfClosingElement:
235 case ts.SyntaxKind.MetaProperty:
236 case ts.SyntaxKind.NewExpression:
237 case ts.SyntaxKind.NonNullExpression:
238 case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
239 case ts.SyntaxKind.NullKeyword:
240 case ts.SyntaxKind.NumericLiteral:
241 case ts.SyntaxKind.ObjectLiteralExpression:
242 case ts.SyntaxKind.OmittedExpression:
243 case ts.SyntaxKind.ParenthesizedExpression:
244 case ts.SyntaxKind.PostfixUnaryExpression:
245 case ts.SyntaxKind.PrefixUnaryExpression:
246 case ts.SyntaxKind.PropertyAccessExpression:
247 case ts.SyntaxKind.RegularExpressionLiteral:
248 case ts.SyntaxKind.SpreadElement:
249 case ts.SyntaxKind.StringLiteral:
250 case ts.SyntaxKind.SuperKeyword:
251 case ts.SyntaxKind.TaggedTemplateExpression:
252 case ts.SyntaxKind.TemplateExpression:
253 case ts.SyntaxKind.ThisKeyword:
254 case ts.SyntaxKind.TrueKeyword:
255 case ts.SyntaxKind.TypeAssertionExpression:
256 case ts.SyntaxKind.TypeOfExpression:
257 case ts.SyntaxKind.VoidExpression:
258 case ts.SyntaxKind.YieldExpression:
264 exports.isExpression = isExpression;
265 function isExpressionStatement(node) {
266 return node.kind === ts.SyntaxKind.ExpressionStatement;
268 exports.isExpressionStatement = isExpressionStatement;
269 function isExpressionWithTypeArguments(node) {
270 return node.kind === ts.SyntaxKind.ExpressionWithTypeArguments;
272 exports.isExpressionWithTypeArguments = isExpressionWithTypeArguments;
273 function isExternalModuleReference(node) {
274 return node.kind === ts.SyntaxKind.ExternalModuleReference;
276 exports.isExternalModuleReference = isExternalModuleReference;
277 function isForInStatement(node) {
278 return node.kind === ts.SyntaxKind.ForInStatement;
280 exports.isForInStatement = isForInStatement;
281 function isForInOrOfStatement(node) {
282 return node.kind === ts.SyntaxKind.ForOfStatement || node.kind === ts.SyntaxKind.ForInStatement;
284 exports.isForInOrOfStatement = isForInOrOfStatement;
285 function isForOfStatement(node) {
286 return node.kind === ts.SyntaxKind.ForOfStatement;
288 exports.isForOfStatement = isForOfStatement;
289 function isForStatement(node) {
290 return node.kind === ts.SyntaxKind.ForStatement;
292 exports.isForStatement = isForStatement;
293 function isFunctionDeclaration(node) {
294 return node.kind === ts.SyntaxKind.FunctionDeclaration;
296 exports.isFunctionDeclaration = isFunctionDeclaration;
297 function isFunctionExpression(node) {
298 return node.kind === ts.SyntaxKind.FunctionExpression;
300 exports.isFunctionExpression = isFunctionExpression;
301 function isFunctionTypeNode(node) {
302 return node.kind === ts.SyntaxKind.FunctionType;
304 exports.isFunctionTypeNode = isFunctionTypeNode;
305 function isGetAccessorDeclaration(node) {
306 return node.kind === ts.SyntaxKind.GetAccessor;
308 exports.isGetAccessorDeclaration = isGetAccessorDeclaration;
309 function isIdentifier(node) {
310 return node.kind === ts.SyntaxKind.Identifier;
312 exports.isIdentifier = isIdentifier;
313 function isIfStatement(node) {
314 return node.kind === ts.SyntaxKind.IfStatement;
316 exports.isIfStatement = isIfStatement;
317 function isImportClause(node) {
318 return node.kind === ts.SyntaxKind.ImportClause;
320 exports.isImportClause = isImportClause;
321 function isImportDeclaration(node) {
322 return node.kind === ts.SyntaxKind.ImportDeclaration;
324 exports.isImportDeclaration = isImportDeclaration;
325 function isImportEqualsDeclaration(node) {
326 return node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
328 exports.isImportEqualsDeclaration = isImportEqualsDeclaration;
329 function isImportSpecifier(node) {
330 return node.kind === ts.SyntaxKind.ImportSpecifier;
332 exports.isImportSpecifier = isImportSpecifier;
333 function isIndexedAccessTypeNode(node) {
334 return node.kind === ts.SyntaxKind.IndexedAccessType;
336 exports.isIndexedAccessTypeNode = isIndexedAccessTypeNode;
337 function isIndexSignatureDeclaration(node) {
338 return node.kind === ts.SyntaxKind.IndexSignature;
340 exports.isIndexSignatureDeclaration = isIndexSignatureDeclaration;
341 function isInferTypeNode(node) {
342 return node.kind === ts.SyntaxKind.InferType;
344 exports.isInferTypeNode = isInferTypeNode;
345 function isInterfaceDeclaration(node) {
346 return node.kind === ts.SyntaxKind.InterfaceDeclaration;
348 exports.isInterfaceDeclaration = isInterfaceDeclaration;
349 function isIntersectionTypeNode(node) {
350 return node.kind === ts.SyntaxKind.IntersectionType;
352 exports.isIntersectionTypeNode = isIntersectionTypeNode;
353 function isIterationStatement(node) {
355 case ts.SyntaxKind.ForStatement:
356 case ts.SyntaxKind.ForOfStatement:
357 case ts.SyntaxKind.ForInStatement:
358 case ts.SyntaxKind.WhileStatement:
359 case ts.SyntaxKind.DoStatement:
365 exports.isIterationStatement = isIterationStatement;
366 function isJsDoc(node) {
367 return node.kind === ts.SyntaxKind.JSDocComment;
369 exports.isJsDoc = isJsDoc;
370 function isJsxAttribute(node) {
371 return node.kind === ts.SyntaxKind.JsxAttribute;
373 exports.isJsxAttribute = isJsxAttribute;
374 function isJsxAttributeLike(node) {
375 return node.kind === ts.SyntaxKind.JsxAttribute ||
376 node.kind === ts.SyntaxKind.JsxSpreadAttribute;
378 exports.isJsxAttributeLike = isJsxAttributeLike;
379 function isJsxAttributes(node) {
380 return node.kind === ts.SyntaxKind.JsxAttributes;
382 exports.isJsxAttributes = isJsxAttributes;
383 function isJsxClosingElement(node) {
384 return node.kind === ts.SyntaxKind.JsxClosingElement;
386 exports.isJsxClosingElement = isJsxClosingElement;
387 function isJsxClosingFragment(node) {
388 return node.kind === ts.SyntaxKind.JsxClosingFragment;
390 exports.isJsxClosingFragment = isJsxClosingFragment;
391 function isJsxElement(node) {
392 return node.kind === ts.SyntaxKind.JsxElement;
394 exports.isJsxElement = isJsxElement;
395 function isJsxExpression(node) {
396 return node.kind === ts.SyntaxKind.JsxExpression;
398 exports.isJsxExpression = isJsxExpression;
399 function isJsxFragment(node) {
400 return node.kind === ts.SyntaxKind.JsxFragment;
402 exports.isJsxFragment = isJsxFragment;
403 function isJsxOpeningElement(node) {
404 return node.kind === ts.SyntaxKind.JsxOpeningElement;
406 exports.isJsxOpeningElement = isJsxOpeningElement;
407 function isJsxOpeningFragment(node) {
408 return node.kind === ts.SyntaxKind.JsxOpeningFragment;
410 exports.isJsxOpeningFragment = isJsxOpeningFragment;
411 function isJsxOpeningLikeElement(node) {
412 return node.kind === ts.SyntaxKind.JsxOpeningElement ||
413 node.kind === ts.SyntaxKind.JsxSelfClosingElement;
415 exports.isJsxOpeningLikeElement = isJsxOpeningLikeElement;
416 function isJsxSelfClosingElement(node) {
417 return node.kind === ts.SyntaxKind.JsxSelfClosingElement;
419 exports.isJsxSelfClosingElement = isJsxSelfClosingElement;
420 function isJsxSpreadAttribute(node) {
421 return node.kind === ts.SyntaxKind.JsxSpreadAttribute;
423 exports.isJsxSpreadAttribute = isJsxSpreadAttribute;
424 function isJsxText(node) {
425 return node.kind === ts.SyntaxKind.JsxText;
427 exports.isJsxText = isJsxText;
428 function isLabeledStatement(node) {
429 return node.kind === ts.SyntaxKind.LabeledStatement;
431 exports.isLabeledStatement = isLabeledStatement;
432 function isLiteralExpression(node) {
433 return node.kind >= ts.SyntaxKind.FirstLiteralToken &&
434 node.kind <= ts.SyntaxKind.LastLiteralToken;
436 exports.isLiteralExpression = isLiteralExpression;
437 function isLiteralTypeNode(node) {
438 return node.kind === ts.SyntaxKind.LiteralType;
440 exports.isLiteralTypeNode = isLiteralTypeNode;
441 function isMappedTypeNode(node) {
442 return node.kind === ts.SyntaxKind.MappedType;
444 exports.isMappedTypeNode = isMappedTypeNode;
445 function isMetaProperty(node) {
446 return node.kind === ts.SyntaxKind.MetaProperty;
448 exports.isMetaProperty = isMetaProperty;
449 function isMethodDeclaration(node) {
450 return node.kind === ts.SyntaxKind.MethodDeclaration;
452 exports.isMethodDeclaration = isMethodDeclaration;
453 function isMethodSignature(node) {
454 return node.kind === ts.SyntaxKind.MethodSignature;
456 exports.isMethodSignature = isMethodSignature;
457 function isModuleBlock(node) {
458 return node.kind === ts.SyntaxKind.ModuleBlock;
460 exports.isModuleBlock = isModuleBlock;
461 function isModuleDeclaration(node) {
462 return node.kind === ts.SyntaxKind.ModuleDeclaration;
464 exports.isModuleDeclaration = isModuleDeclaration;
465 function isNamedExports(node) {
466 return node.kind === ts.SyntaxKind.NamedExports;
468 exports.isNamedExports = isNamedExports;
469 function isNamedImports(node) {
470 return node.kind === ts.SyntaxKind.NamedImports;
472 exports.isNamedImports = isNamedImports;
473 function isNamespaceDeclaration(node) {
474 return isModuleDeclaration(node) &&
475 node.name.kind === ts.SyntaxKind.Identifier &&
476 node.body !== undefined &&
477 (node.body.kind === ts.SyntaxKind.ModuleBlock ||
478 isNamespaceDeclaration(node.body));
480 exports.isNamespaceDeclaration = isNamespaceDeclaration;
481 function isNamespaceImport(node) {
482 return node.kind === ts.SyntaxKind.NamespaceImport;
484 exports.isNamespaceImport = isNamespaceImport;
485 function isNamespaceExportDeclaration(node) {
486 return node.kind === ts.SyntaxKind.NamespaceExportDeclaration;
488 exports.isNamespaceExportDeclaration = isNamespaceExportDeclaration;
489 function isNewExpression(node) {
490 return node.kind === ts.SyntaxKind.NewExpression;
492 exports.isNewExpression = isNewExpression;
493 function isNonNullExpression(node) {
494 return node.kind === ts.SyntaxKind.NonNullExpression;
496 exports.isNonNullExpression = isNonNullExpression;
497 function isNoSubstitutionTemplateLiteral(node) {
498 return node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
500 exports.isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral;
501 function isNullLiteral(node) {
502 return node.kind === ts.SyntaxKind.NullKeyword;
504 exports.isNullLiteral = isNullLiteral;
505 function isNumericLiteral(node) {
506 return node.kind === ts.SyntaxKind.NumericLiteral;
508 exports.isNumericLiteral = isNumericLiteral;
509 function isNumericOrStringLikeLiteral(node) {
511 case ts.SyntaxKind.StringLiteral:
512 case ts.SyntaxKind.NumericLiteral:
513 case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
519 exports.isNumericOrStringLikeLiteral = isNumericOrStringLikeLiteral;
520 function isObjectBindingPattern(node) {
521 return node.kind === ts.SyntaxKind.ObjectBindingPattern;
523 exports.isObjectBindingPattern = isObjectBindingPattern;
524 function isObjectLiteralExpression(node) {
525 return node.kind === ts.SyntaxKind.ObjectLiteralExpression;
527 exports.isObjectLiteralExpression = isObjectLiteralExpression;
528 function isOmittedExpression(node) {
529 return node.kind === ts.SyntaxKind.OmittedExpression;
531 exports.isOmittedExpression = isOmittedExpression;
532 function isParameterDeclaration(node) {
533 return node.kind === ts.SyntaxKind.Parameter;
535 exports.isParameterDeclaration = isParameterDeclaration;
536 function isParenthesizedExpression(node) {
537 return node.kind === ts.SyntaxKind.ParenthesizedExpression;
539 exports.isParenthesizedExpression = isParenthesizedExpression;
540 function isParenthesizedTypeNode(node) {
541 return node.kind === ts.SyntaxKind.ParenthesizedType;
543 exports.isParenthesizedTypeNode = isParenthesizedTypeNode;
544 function isPostfixUnaryExpression(node) {
545 return node.kind === ts.SyntaxKind.PostfixUnaryExpression;
547 exports.isPostfixUnaryExpression = isPostfixUnaryExpression;
548 function isPrefixUnaryExpression(node) {
549 return node.kind === ts.SyntaxKind.PrefixUnaryExpression;
551 exports.isPrefixUnaryExpression = isPrefixUnaryExpression;
552 function isPropertyAccessExpression(node) {
553 return node.kind === ts.SyntaxKind.PropertyAccessExpression;
555 exports.isPropertyAccessExpression = isPropertyAccessExpression;
556 function isPropertyAssignment(node) {
557 return node.kind === ts.SyntaxKind.PropertyAssignment;
559 exports.isPropertyAssignment = isPropertyAssignment;
560 function isPropertyDeclaration(node) {
561 return node.kind === ts.SyntaxKind.PropertyDeclaration;
563 exports.isPropertyDeclaration = isPropertyDeclaration;
564 function isPropertySignature(node) {
565 return node.kind === ts.SyntaxKind.PropertySignature;
567 exports.isPropertySignature = isPropertySignature;
568 function isQualifiedName(node) {
569 return node.kind === ts.SyntaxKind.QualifiedName;
571 exports.isQualifiedName = isQualifiedName;
572 function isRegularExpressionLiteral(node) {
573 return node.kind === ts.SyntaxKind.RegularExpressionLiteral;
575 exports.isRegularExpressionLiteral = isRegularExpressionLiteral;
576 function isReturnStatement(node) {
577 return node.kind === ts.SyntaxKind.ReturnStatement;
579 exports.isReturnStatement = isReturnStatement;
580 function isSetAccessorDeclaration(node) {
581 return node.kind === ts.SyntaxKind.SetAccessor;
583 exports.isSetAccessorDeclaration = isSetAccessorDeclaration;
584 function isShorthandPropertyAssignment(node) {
585 return node.kind === ts.SyntaxKind.ShorthandPropertyAssignment;
587 exports.isShorthandPropertyAssignment = isShorthandPropertyAssignment;
588 function isSignatureDeclaration(node) {
589 return node.parameters !== undefined;
591 exports.isSignatureDeclaration = isSignatureDeclaration;
592 function isSourceFile(node) {
593 return node.kind === ts.SyntaxKind.SourceFile;
595 exports.isSourceFile = isSourceFile;
596 function isSpreadAssignment(node) {
597 return node.kind === ts.SyntaxKind.SpreadAssignment;
599 exports.isSpreadAssignment = isSpreadAssignment;
600 function isSpreadElement(node) {
601 return node.kind === ts.SyntaxKind.SpreadElement;
603 exports.isSpreadElement = isSpreadElement;
604 function isStringLiteral(node) {
605 return node.kind === ts.SyntaxKind.StringLiteral;
607 exports.isStringLiteral = isStringLiteral;
608 function isSwitchStatement(node) {
609 return node.kind === ts.SyntaxKind.SwitchStatement;
611 exports.isSwitchStatement = isSwitchStatement;
612 function isSyntaxList(node) {
613 return node.kind === ts.SyntaxKind.SyntaxList;
615 exports.isSyntaxList = isSyntaxList;
616 function isTaggedTemplateExpression(node) {
617 return node.kind === ts.SyntaxKind.TaggedTemplateExpression;
619 exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
620 function isTemplateExpression(node) {
621 return node.kind === ts.SyntaxKind.TemplateExpression;
623 exports.isTemplateExpression = isTemplateExpression;
624 function isTemplateLiteral(node) {
625 return node.kind === ts.SyntaxKind.TemplateExpression ||
626 node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
628 exports.isTemplateLiteral = isTemplateLiteral;
629 function isTextualLiteral(node) {
630 return node.kind === ts.SyntaxKind.StringLiteral ||
631 node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
633 exports.isTextualLiteral = isTextualLiteral;
634 function isThrowStatement(node) {
635 return node.kind === ts.SyntaxKind.ThrowStatement;
637 exports.isThrowStatement = isThrowStatement;
638 function isTryStatement(node) {
639 return node.kind === ts.SyntaxKind.TryStatement;
641 exports.isTryStatement = isTryStatement;
642 function isTupleTypeNode(node) {
643 return node.kind === ts.SyntaxKind.TupleType;
645 exports.isTupleTypeNode = isTupleTypeNode;
646 function isTypeAliasDeclaration(node) {
647 return node.kind === ts.SyntaxKind.TypeAliasDeclaration;
649 exports.isTypeAliasDeclaration = isTypeAliasDeclaration;
650 function isTypeAssertion(node) {
651 return node.kind === ts.SyntaxKind.TypeAssertionExpression;
653 exports.isTypeAssertion = isTypeAssertion;
654 function isTypeLiteralNode(node) {
655 return node.kind === ts.SyntaxKind.TypeLiteral;
657 exports.isTypeLiteralNode = isTypeLiteralNode;
658 function isTypeOfExpression(node) {
659 return node.kind === ts.SyntaxKind.TypeOfExpression;
661 exports.isTypeOfExpression = isTypeOfExpression;
662 function isTypeOperatorNode(node) {
663 return node.kind === ts.SyntaxKind.TypeOperator;
665 exports.isTypeOperatorNode = isTypeOperatorNode;
666 function isTypeParameterDeclaration(node) {
667 return node.kind === ts.SyntaxKind.TypeParameter;
669 exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
670 function isTypePredicateNode(node) {
671 return node.kind === ts.SyntaxKind.TypePredicate;
673 exports.isTypePredicateNode = isTypePredicateNode;
674 function isTypeReferenceNode(node) {
675 return node.kind === ts.SyntaxKind.TypeReference;
677 exports.isTypeReferenceNode = isTypeReferenceNode;
678 function isTypeQueryNode(node) {
679 return node.kind === ts.SyntaxKind.TypeQuery;
681 exports.isTypeQueryNode = isTypeQueryNode;
682 function isUnionTypeNode(node) {
683 return node.kind === ts.SyntaxKind.UnionType;
685 exports.isUnionTypeNode = isUnionTypeNode;
686 function isVariableDeclaration(node) {
687 return node.kind === ts.SyntaxKind.VariableDeclaration;
689 exports.isVariableDeclaration = isVariableDeclaration;
690 function isVariableStatement(node) {
691 return node.kind === ts.SyntaxKind.VariableStatement;
693 exports.isVariableStatement = isVariableStatement;
694 function isVariableDeclarationList(node) {
695 return node.kind === ts.SyntaxKind.VariableDeclarationList;
697 exports.isVariableDeclarationList = isVariableDeclarationList;
698 function isVoidExpression(node) {
699 return node.kind === ts.SyntaxKind.VoidExpression;
701 exports.isVoidExpression = isVoidExpression;
702 function isWhileStatement(node) {
703 return node.kind === ts.SyntaxKind.WhileStatement;
705 exports.isWhileStatement = isWhileStatement;
706 function isWithStatement(node) {
707 return node.kind === ts.SyntaxKind.WithStatement;
709 exports.isWithStatement = isWithStatement;