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