.config/coc/extensions/node_modules/coc-prettier/node_modules/tsutils/typeguard/2.8/node.js

   1 "use strict";
   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;
   7 }
   8 exports.isAccessorDeclaration = isAccessorDeclaration;
   9 function isArrayBindingPattern(node) {
  10     return node.kind === ts.SyntaxKind.ArrayBindingPattern;
  11 }
  12 exports.isArrayBindingPattern = isArrayBindingPattern;
  13 function isArrayLiteralExpression(node) {
  14     return node.kind === ts.SyntaxKind.ArrayLiteralExpression;
  15 }
  16 exports.isArrayLiteralExpression = isArrayLiteralExpression;
  17 function isArrayTypeNode(node) {
  18     return node.kind === ts.SyntaxKind.ArrayType;
  19 }
  20 exports.isArrayTypeNode = isArrayTypeNode;
  21 function isArrowFunction(node) {
  22     return node.kind === ts.SyntaxKind.ArrowFunction;
  23 }
  24 exports.isArrowFunction = isArrowFunction;
  25 function isAsExpression(node) {
  26     return node.kind === ts.SyntaxKind.AsExpression;
  27 }
  28 exports.isAsExpression = isAsExpression;
  29 function isAssertionExpression(node) {
  30     return node.kind === ts.SyntaxKind.AsExpression ||
  31         node.kind === ts.SyntaxKind.TypeAssertionExpression;
  32 }
  33 exports.isAssertionExpression = isAssertionExpression;
  34 function isAwaitExpression(node) {
  35     return node.kind === ts.SyntaxKind.AwaitExpression;
  36 }
  37 exports.isAwaitExpression = isAwaitExpression;
  38 function isBinaryExpression(node) {
  39     return node.kind === ts.SyntaxKind.BinaryExpression;
  40 }
  41 exports.isBinaryExpression = isBinaryExpression;
  42 function isBindingElement(node) {
  43     return node.kind === ts.SyntaxKind.BindingElement;
  44 }
  45 exports.isBindingElement = isBindingElement;
  46 function isBindingPattern(node) {
  47     return node.kind === ts.SyntaxKind.ArrayBindingPattern ||
  48         node.kind === ts.SyntaxKind.ObjectBindingPattern;
  49 }
  50 exports.isBindingPattern = isBindingPattern;
  51 function isBlock(node) {
  52     return node.kind === ts.SyntaxKind.Block;
  53 }
  54 exports.isBlock = isBlock;
  55 function isBlockLike(node) {
  56     return node.statements !== undefined;
  57 }
  58 exports.isBlockLike = isBlockLike;
  59 function isBooleanLiteral(node) {
  60     return node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword;
  61 }
  62 exports.isBooleanLiteral = isBooleanLiteral;
  63 function isBreakOrContinueStatement(node) {
  64     return node.kind === ts.SyntaxKind.BreakStatement ||
  65         node.kind === ts.SyntaxKind.ContinueStatement;
  66 }
  67 exports.isBreakOrContinueStatement = isBreakOrContinueStatement;
  68 function isBreakStatement(node) {
  69     return node.kind === ts.SyntaxKind.BreakStatement;
  70 }
  71 exports.isBreakStatement = isBreakStatement;
  72 function isCallExpression(node) {
  73     return node.kind === ts.SyntaxKind.CallExpression;
  74 }
  75 exports.isCallExpression = isCallExpression;
  76 function isCallLikeExpression(node) {
  77     switch (node.kind) {
  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:
  84             return true;
  85         default:
  86             return false;
  87     }
  88 }
  89 exports.isCallLikeExpression = isCallLikeExpression;
  90 function isCallSignatureDeclaration(node) {
  91     return node.kind === ts.SyntaxKind.CallSignature;
  92 }
  93 exports.isCallSignatureDeclaration = isCallSignatureDeclaration;
  94 function isCaseBlock(node) {
  95     return node.kind === ts.SyntaxKind.CaseBlock;
  96 }
  97 exports.isCaseBlock = isCaseBlock;
  98 function isCaseClause(node) {
  99     return node.kind === ts.SyntaxKind.CaseClause;
 100 }
 101 exports.isCaseClause = isCaseClause;
 102 function isCaseOrDefaultClause(node) {
 103     return node.kind === ts.SyntaxKind.CaseClause ||
 104         node.kind === ts.SyntaxKind.DefaultClause;
 105 }
 106 exports.isCaseOrDefaultClause = isCaseOrDefaultClause;
 107 function isCatchClause(node) {
 108     return node.kind === ts.SyntaxKind.CatchClause;
 109 }
 110 exports.isCatchClause = isCatchClause;
 111 function isClassDeclaration(node) {
 112     return node.kind === ts.SyntaxKind.ClassDeclaration;
 113 }
 114 exports.isClassDeclaration = isClassDeclaration;
 115 function isClassExpression(node) {
 116     return node.kind === ts.SyntaxKind.ClassExpression;
 117 }
 118 exports.isClassExpression = isClassExpression;
 119 function isClassLikeDeclaration(node) {
 120     return node.kind === ts.SyntaxKind.ClassDeclaration ||
 121         node.kind === ts.SyntaxKind.ClassExpression;
 122 }
 123 exports.isClassLikeDeclaration = isClassLikeDeclaration;
 124 function isCommaListExpression(node) {
 125     return node.kind === ts.SyntaxKind.CommaListExpression;
 126 }
 127 exports.isCommaListExpression = isCommaListExpression;
 128 function isConditionalExpression(node) {
 129     return node.kind === ts.SyntaxKind.ConditionalExpression;
 130 }
 131 exports.isConditionalExpression = isConditionalExpression;
 132 function isConditionalTypeNode(node) {
 133     return node.kind === ts.SyntaxKind.ConditionalType;
 134 }
 135 exports.isConditionalTypeNode = isConditionalTypeNode;
 136 function isConstructorDeclaration(node) {
 137     return node.kind === ts.SyntaxKind.Constructor;
 138 }
 139 exports.isConstructorDeclaration = isConstructorDeclaration;
 140 function isConstructorTypeNode(node) {
 141     return node.kind === ts.SyntaxKind.ConstructorType;
 142 }
 143 exports.isConstructorTypeNode = isConstructorTypeNode;
 144 function isConstructSignatureDeclaration(node) {
 145     return node.kind === ts.SyntaxKind.ConstructSignature;
 146 }
 147 exports.isConstructSignatureDeclaration = isConstructSignatureDeclaration;
 148 function isContinueStatement(node) {
 149     return node.kind === ts.SyntaxKind.ContinueStatement;
 150 }
 151 exports.isContinueStatement = isContinueStatement;
 152 function isComputedPropertyName(node) {
 153     return node.kind === ts.SyntaxKind.ComputedPropertyName;
 154 }
 155 exports.isComputedPropertyName = isComputedPropertyName;
 156 function isDebuggerStatement(node) {
 157     return node.kind === ts.SyntaxKind.DebuggerStatement;
 158 }
 159 exports.isDebuggerStatement = isDebuggerStatement;
 160 function isDecorator(node) {
 161     return node.kind === ts.SyntaxKind.Decorator;
 162 }
 163 exports.isDecorator = isDecorator;
 164 function isDefaultClause(node) {
 165     return node.kind === ts.SyntaxKind.DefaultClause;
 166 }
 167 exports.isDefaultClause = isDefaultClause;
 168 function isDeleteExpression(node) {
 169     return node.kind === ts.SyntaxKind.DeleteExpression;
 170 }
 171 exports.isDeleteExpression = isDeleteExpression;
 172 function isDoStatement(node) {
 173     return node.kind === ts.SyntaxKind.DoStatement;
 174 }
 175 exports.isDoStatement = isDoStatement;
 176 function isElementAccessExpression(node) {
 177     return node.kind === ts.SyntaxKind.ElementAccessExpression;
 178 }
 179 exports.isElementAccessExpression = isElementAccessExpression;
 180 function isEmptyStatement(node) {
 181     return node.kind === ts.SyntaxKind.EmptyStatement;
 182 }
 183 exports.isEmptyStatement = isEmptyStatement;
 184 function isEntityName(node) {
 185     return node.kind === ts.SyntaxKind.Identifier || isQualifiedName(node);
 186 }
 187 exports.isEntityName = isEntityName;
 188 function isEntityNameExpression(node) {
 189     return node.kind === ts.SyntaxKind.Identifier ||
 190         isPropertyAccessExpression(node) && isEntityNameExpression(node.expression);
 191 }
 192 exports.isEntityNameExpression = isEntityNameExpression;
 193 function isEnumDeclaration(node) {
 194     return node.kind === ts.SyntaxKind.EnumDeclaration;
 195 }
 196 exports.isEnumDeclaration = isEnumDeclaration;
 197 function isEnumMember(node) {
 198     return node.kind === ts.SyntaxKind.EnumMember;
 199 }
 200 exports.isEnumMember = isEnumMember;
 201 function isExportAssignment(node) {
 202     return node.kind === ts.SyntaxKind.ExportAssignment;
 203 }
 204 exports.isExportAssignment = isExportAssignment;
 205 function isExportDeclaration(node) {
 206     return node.kind === ts.SyntaxKind.ExportDeclaration;
 207 }
 208 exports.isExportDeclaration = isExportDeclaration;
 209 function isExportSpecifier(node) {
 210     return node.kind === ts.SyntaxKind.ExportSpecifier;
 211 }
 212 exports.isExportSpecifier = isExportSpecifier;
 213 function isExpression(node) {
 214     switch (node.kind) {
 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:
 259             return true;
 260         default:
 261             return false;
 262     }
 263 }
 264 exports.isExpression = isExpression;
 265 function isExpressionStatement(node) {
 266     return node.kind === ts.SyntaxKind.ExpressionStatement;
 267 }
 268 exports.isExpressionStatement = isExpressionStatement;
 269 function isExpressionWithTypeArguments(node) {
 270     return node.kind === ts.SyntaxKind.ExpressionWithTypeArguments;
 271 }
 272 exports.isExpressionWithTypeArguments = isExpressionWithTypeArguments;
 273 function isExternalModuleReference(node) {
 274     return node.kind === ts.SyntaxKind.ExternalModuleReference;
 275 }
 276 exports.isExternalModuleReference = isExternalModuleReference;
 277 function isForInStatement(node) {
 278     return node.kind === ts.SyntaxKind.ForInStatement;
 279 }
 280 exports.isForInStatement = isForInStatement;
 281 function isForInOrOfStatement(node) {
 282     return node.kind === ts.SyntaxKind.ForOfStatement || node.kind === ts.SyntaxKind.ForInStatement;
 283 }
 284 exports.isForInOrOfStatement = isForInOrOfStatement;
 285 function isForOfStatement(node) {
 286     return node.kind === ts.SyntaxKind.ForOfStatement;
 287 }
 288 exports.isForOfStatement = isForOfStatement;
 289 function isForStatement(node) {
 290     return node.kind === ts.SyntaxKind.ForStatement;
 291 }
 292 exports.isForStatement = isForStatement;
 293 function isFunctionDeclaration(node) {
 294     return node.kind === ts.SyntaxKind.FunctionDeclaration;
 295 }
 296 exports.isFunctionDeclaration = isFunctionDeclaration;
 297 function isFunctionExpression(node) {
 298     return node.kind === ts.SyntaxKind.FunctionExpression;
 299 }
 300 exports.isFunctionExpression = isFunctionExpression;
 301 function isFunctionTypeNode(node) {
 302     return node.kind === ts.SyntaxKind.FunctionType;
 303 }
 304 exports.isFunctionTypeNode = isFunctionTypeNode;
 305 function isGetAccessorDeclaration(node) {
 306     return node.kind === ts.SyntaxKind.GetAccessor;
 307 }
 308 exports.isGetAccessorDeclaration = isGetAccessorDeclaration;
 309 function isIdentifier(node) {
 310     return node.kind === ts.SyntaxKind.Identifier;
 311 }
 312 exports.isIdentifier = isIdentifier;
 313 function isIfStatement(node) {
 314     return node.kind === ts.SyntaxKind.IfStatement;
 315 }
 316 exports.isIfStatement = isIfStatement;
 317 function isImportClause(node) {
 318     return node.kind === ts.SyntaxKind.ImportClause;
 319 }
 320 exports.isImportClause = isImportClause;
 321 function isImportDeclaration(node) {
 322     return node.kind === ts.SyntaxKind.ImportDeclaration;
 323 }
 324 exports.isImportDeclaration = isImportDeclaration;
 325 function isImportEqualsDeclaration(node) {
 326     return node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
 327 }
 328 exports.isImportEqualsDeclaration = isImportEqualsDeclaration;
 329 function isImportSpecifier(node) {
 330     return node.kind === ts.SyntaxKind.ImportSpecifier;
 331 }
 332 exports.isImportSpecifier = isImportSpecifier;
 333 function isIndexedAccessTypeNode(node) {
 334     return node.kind === ts.SyntaxKind.IndexedAccessType;
 335 }
 336 exports.isIndexedAccessTypeNode = isIndexedAccessTypeNode;
 337 function isIndexSignatureDeclaration(node) {
 338     return node.kind === ts.SyntaxKind.IndexSignature;
 339 }
 340 exports.isIndexSignatureDeclaration = isIndexSignatureDeclaration;
 341 function isInferTypeNode(node) {
 342     return node.kind === ts.SyntaxKind.InferType;
 343 }
 344 exports.isInferTypeNode = isInferTypeNode;
 345 function isInterfaceDeclaration(node) {
 346     return node.kind === ts.SyntaxKind.InterfaceDeclaration;
 347 }
 348 exports.isInterfaceDeclaration = isInterfaceDeclaration;
 349 function isIntersectionTypeNode(node) {
 350     return node.kind === ts.SyntaxKind.IntersectionType;
 351 }
 352 exports.isIntersectionTypeNode = isIntersectionTypeNode;
 353 function isIterationStatement(node) {
 354     switch (node.kind) {
 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:
 360             return true;
 361         default:
 362             return false;
 363     }
 364 }
 365 exports.isIterationStatement = isIterationStatement;
 366 function isJsDoc(node) {
 367     return node.kind === ts.SyntaxKind.JSDocComment;
 368 }
 369 exports.isJsDoc = isJsDoc;
 370 function isJsxAttribute(node) {
 371     return node.kind === ts.SyntaxKind.JsxAttribute;
 372 }
 373 exports.isJsxAttribute = isJsxAttribute;
 374 function isJsxAttributeLike(node) {
 375     return node.kind === ts.SyntaxKind.JsxAttribute ||
 376         node.kind === ts.SyntaxKind.JsxSpreadAttribute;
 377 }
 378 exports.isJsxAttributeLike = isJsxAttributeLike;
 379 function isJsxAttributes(node) {
 380     return node.kind === ts.SyntaxKind.JsxAttributes;
 381 }
 382 exports.isJsxAttributes = isJsxAttributes;
 383 function isJsxClosingElement(node) {
 384     return node.kind === ts.SyntaxKind.JsxClosingElement;
 385 }
 386 exports.isJsxClosingElement = isJsxClosingElement;
 387 function isJsxClosingFragment(node) {
 388     return node.kind === ts.SyntaxKind.JsxClosingFragment;
 389 }
 390 exports.isJsxClosingFragment = isJsxClosingFragment;
 391 function isJsxElement(node) {
 392     return node.kind === ts.SyntaxKind.JsxElement;
 393 }
 394 exports.isJsxElement = isJsxElement;
 395 function isJsxExpression(node) {
 396     return node.kind === ts.SyntaxKind.JsxExpression;
 397 }
 398 exports.isJsxExpression = isJsxExpression;
 399 function isJsxFragment(node) {
 400     return node.kind === ts.SyntaxKind.JsxFragment;
 401 }
 402 exports.isJsxFragment = isJsxFragment;
 403 function isJsxOpeningElement(node) {
 404     return node.kind === ts.SyntaxKind.JsxOpeningElement;
 405 }
 406 exports.isJsxOpeningElement = isJsxOpeningElement;
 407 function isJsxOpeningFragment(node) {
 408     return node.kind === ts.SyntaxKind.JsxOpeningFragment;
 409 }
 410 exports.isJsxOpeningFragment = isJsxOpeningFragment;
 411 function isJsxOpeningLikeElement(node) {
 412     return node.kind === ts.SyntaxKind.JsxOpeningElement ||
 413         node.kind === ts.SyntaxKind.JsxSelfClosingElement;
 414 }
 415 exports.isJsxOpeningLikeElement = isJsxOpeningLikeElement;
 416 function isJsxSelfClosingElement(node) {
 417     return node.kind === ts.SyntaxKind.JsxSelfClosingElement;
 418 }
 419 exports.isJsxSelfClosingElement = isJsxSelfClosingElement;
 420 function isJsxSpreadAttribute(node) {
 421     return node.kind === ts.SyntaxKind.JsxSpreadAttribute;
 422 }
 423 exports.isJsxSpreadAttribute = isJsxSpreadAttribute;
 424 function isJsxText(node) {
 425     return node.kind === ts.SyntaxKind.JsxText;
 426 }
 427 exports.isJsxText = isJsxText;
 428 function isLabeledStatement(node) {
 429     return node.kind === ts.SyntaxKind.LabeledStatement;
 430 }
 431 exports.isLabeledStatement = isLabeledStatement;
 432 function isLiteralExpression(node) {
 433     return node.kind >= ts.SyntaxKind.FirstLiteralToken &&
 434         node.kind <= ts.SyntaxKind.LastLiteralToken;
 435 }
 436 exports.isLiteralExpression = isLiteralExpression;
 437 function isLiteralTypeNode(node) {
 438     return node.kind === ts.SyntaxKind.LiteralType;
 439 }
 440 exports.isLiteralTypeNode = isLiteralTypeNode;
 441 function isMappedTypeNode(node) {
 442     return node.kind === ts.SyntaxKind.MappedType;
 443 }
 444 exports.isMappedTypeNode = isMappedTypeNode;
 445 function isMetaProperty(node) {
 446     return node.kind === ts.SyntaxKind.MetaProperty;
 447 }
 448 exports.isMetaProperty = isMetaProperty;
 449 function isMethodDeclaration(node) {
 450     return node.kind === ts.SyntaxKind.MethodDeclaration;
 451 }
 452 exports.isMethodDeclaration = isMethodDeclaration;
 453 function isMethodSignature(node) {
 454     return node.kind === ts.SyntaxKind.MethodSignature;
 455 }
 456 exports.isMethodSignature = isMethodSignature;
 457 function isModuleBlock(node) {
 458     return node.kind === ts.SyntaxKind.ModuleBlock;
 459 }
 460 exports.isModuleBlock = isModuleBlock;
 461 function isModuleDeclaration(node) {
 462     return node.kind === ts.SyntaxKind.ModuleDeclaration;
 463 }
 464 exports.isModuleDeclaration = isModuleDeclaration;
 465 function isNamedExports(node) {
 466     return node.kind === ts.SyntaxKind.NamedExports;
 467 }
 468 exports.isNamedExports = isNamedExports;
 469 function isNamedImports(node) {
 470     return node.kind === ts.SyntaxKind.NamedImports;
 471 }
 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));
 479 }
 480 exports.isNamespaceDeclaration = isNamespaceDeclaration;
 481 function isNamespaceImport(node) {
 482     return node.kind === ts.SyntaxKind.NamespaceImport;
 483 }
 484 exports.isNamespaceImport = isNamespaceImport;
 485 function isNamespaceExportDeclaration(node) {
 486     return node.kind === ts.SyntaxKind.NamespaceExportDeclaration;
 487 }
 488 exports.isNamespaceExportDeclaration = isNamespaceExportDeclaration;
 489 function isNewExpression(node) {
 490     return node.kind === ts.SyntaxKind.NewExpression;
 491 }
 492 exports.isNewExpression = isNewExpression;
 493 function isNonNullExpression(node) {
 494     return node.kind === ts.SyntaxKind.NonNullExpression;
 495 }
 496 exports.isNonNullExpression = isNonNullExpression;
 497 function isNoSubstitutionTemplateLiteral(node) {
 498     return node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
 499 }
 500 exports.isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral;
 501 function isNullLiteral(node) {
 502     return node.kind === ts.SyntaxKind.NullKeyword;
 503 }
 504 exports.isNullLiteral = isNullLiteral;
 505 function isNumericLiteral(node) {
 506     return node.kind === ts.SyntaxKind.NumericLiteral;
 507 }
 508 exports.isNumericLiteral = isNumericLiteral;
 509 function isNumericOrStringLikeLiteral(node) {
 510     switch (node.kind) {
 511         case ts.SyntaxKind.StringLiteral:
 512         case ts.SyntaxKind.NumericLiteral:
 513         case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
 514             return true;
 515         default:
 516             return false;
 517     }
 518 }
 519 exports.isNumericOrStringLikeLiteral = isNumericOrStringLikeLiteral;
 520 function isObjectBindingPattern(node) {
 521     return node.kind === ts.SyntaxKind.ObjectBindingPattern;
 522 }
 523 exports.isObjectBindingPattern = isObjectBindingPattern;
 524 function isObjectLiteralExpression(node) {
 525     return node.kind === ts.SyntaxKind.ObjectLiteralExpression;
 526 }
 527 exports.isObjectLiteralExpression = isObjectLiteralExpression;
 528 function isOmittedExpression(node) {
 529     return node.kind === ts.SyntaxKind.OmittedExpression;
 530 }
 531 exports.isOmittedExpression = isOmittedExpression;
 532 function isParameterDeclaration(node) {
 533     return node.kind === ts.SyntaxKind.Parameter;
 534 }
 535 exports.isParameterDeclaration = isParameterDeclaration;
 536 function isParenthesizedExpression(node) {
 537     return node.kind === ts.SyntaxKind.ParenthesizedExpression;
 538 }
 539 exports.isParenthesizedExpression = isParenthesizedExpression;
 540 function isParenthesizedTypeNode(node) {
 541     return node.kind === ts.SyntaxKind.ParenthesizedType;
 542 }
 543 exports.isParenthesizedTypeNode = isParenthesizedTypeNode;
 544 function isPostfixUnaryExpression(node) {
 545     return node.kind === ts.SyntaxKind.PostfixUnaryExpression;
 546 }
 547 exports.isPostfixUnaryExpression = isPostfixUnaryExpression;
 548 function isPrefixUnaryExpression(node) {
 549     return node.kind === ts.SyntaxKind.PrefixUnaryExpression;
 550 }
 551 exports.isPrefixUnaryExpression = isPrefixUnaryExpression;
 552 function isPropertyAccessExpression(node) {
 553     return node.kind === ts.SyntaxKind.PropertyAccessExpression;
 554 }
 555 exports.isPropertyAccessExpression = isPropertyAccessExpression;
 556 function isPropertyAssignment(node) {
 557     return node.kind === ts.SyntaxKind.PropertyAssignment;
 558 }
 559 exports.isPropertyAssignment = isPropertyAssignment;
 560 function isPropertyDeclaration(node) {
 561     return node.kind === ts.SyntaxKind.PropertyDeclaration;
 562 }
 563 exports.isPropertyDeclaration = isPropertyDeclaration;
 564 function isPropertySignature(node) {
 565     return node.kind === ts.SyntaxKind.PropertySignature;
 566 }
 567 exports.isPropertySignature = isPropertySignature;
 568 function isQualifiedName(node) {
 569     return node.kind === ts.SyntaxKind.QualifiedName;
 570 }
 571 exports.isQualifiedName = isQualifiedName;
 572 function isRegularExpressionLiteral(node) {
 573     return node.kind === ts.SyntaxKind.RegularExpressionLiteral;
 574 }
 575 exports.isRegularExpressionLiteral = isRegularExpressionLiteral;
 576 function isReturnStatement(node) {
 577     return node.kind === ts.SyntaxKind.ReturnStatement;
 578 }
 579 exports.isReturnStatement = isReturnStatement;
 580 function isSetAccessorDeclaration(node) {
 581     return node.kind === ts.SyntaxKind.SetAccessor;
 582 }
 583 exports.isSetAccessorDeclaration = isSetAccessorDeclaration;
 584 function isShorthandPropertyAssignment(node) {
 585     return node.kind === ts.SyntaxKind.ShorthandPropertyAssignment;
 586 }
 587 exports.isShorthandPropertyAssignment = isShorthandPropertyAssignment;
 588 function isSignatureDeclaration(node) {
 589     return node.parameters !== undefined;
 590 }
 591 exports.isSignatureDeclaration = isSignatureDeclaration;
 592 function isSourceFile(node) {
 593     return node.kind === ts.SyntaxKind.SourceFile;
 594 }
 595 exports.isSourceFile = isSourceFile;
 596 function isSpreadAssignment(node) {
 597     return node.kind === ts.SyntaxKind.SpreadAssignment;
 598 }
 599 exports.isSpreadAssignment = isSpreadAssignment;
 600 function isSpreadElement(node) {
 601     return node.kind === ts.SyntaxKind.SpreadElement;
 602 }
 603 exports.isSpreadElement = isSpreadElement;
 604 function isStringLiteral(node) {
 605     return node.kind === ts.SyntaxKind.StringLiteral;
 606 }
 607 exports.isStringLiteral = isStringLiteral;
 608 function isSwitchStatement(node) {
 609     return node.kind === ts.SyntaxKind.SwitchStatement;
 610 }
 611 exports.isSwitchStatement = isSwitchStatement;
 612 function isSyntaxList(node) {
 613     return node.kind === ts.SyntaxKind.SyntaxList;
 614 }
 615 exports.isSyntaxList = isSyntaxList;
 616 function isTaggedTemplateExpression(node) {
 617     return node.kind === ts.SyntaxKind.TaggedTemplateExpression;
 618 }
 619 exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
 620 function isTemplateExpression(node) {
 621     return node.kind === ts.SyntaxKind.TemplateExpression;
 622 }
 623 exports.isTemplateExpression = isTemplateExpression;
 624 function isTemplateLiteral(node) {
 625     return node.kind === ts.SyntaxKind.TemplateExpression ||
 626         node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
 627 }
 628 exports.isTemplateLiteral = isTemplateLiteral;
 629 function isTextualLiteral(node) {
 630     return node.kind === ts.SyntaxKind.StringLiteral ||
 631         node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
 632 }
 633 exports.isTextualLiteral = isTextualLiteral;
 634 function isThrowStatement(node) {
 635     return node.kind === ts.SyntaxKind.ThrowStatement;
 636 }
 637 exports.isThrowStatement = isThrowStatement;
 638 function isTryStatement(node) {
 639     return node.kind === ts.SyntaxKind.TryStatement;
 640 }
 641 exports.isTryStatement = isTryStatement;
 642 function isTupleTypeNode(node) {
 643     return node.kind === ts.SyntaxKind.TupleType;
 644 }
 645 exports.isTupleTypeNode = isTupleTypeNode;
 646 function isTypeAliasDeclaration(node) {
 647     return node.kind === ts.SyntaxKind.TypeAliasDeclaration;
 648 }
 649 exports.isTypeAliasDeclaration = isTypeAliasDeclaration;
 650 function isTypeAssertion(node) {
 651     return node.kind === ts.SyntaxKind.TypeAssertionExpression;
 652 }
 653 exports.isTypeAssertion = isTypeAssertion;
 654 function isTypeLiteralNode(node) {
 655     return node.kind === ts.SyntaxKind.TypeLiteral;
 656 }
 657 exports.isTypeLiteralNode = isTypeLiteralNode;
 658 function isTypeOfExpression(node) {
 659     return node.kind === ts.SyntaxKind.TypeOfExpression;
 660 }
 661 exports.isTypeOfExpression = isTypeOfExpression;
 662 function isTypeOperatorNode(node) {
 663     return node.kind === ts.SyntaxKind.TypeOperator;
 664 }
 665 exports.isTypeOperatorNode = isTypeOperatorNode;
 666 function isTypeParameterDeclaration(node) {
 667     return node.kind === ts.SyntaxKind.TypeParameter;
 668 }
 669 exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
 670 function isTypePredicateNode(node) {
 671     return node.kind === ts.SyntaxKind.TypePredicate;
 672 }
 673 exports.isTypePredicateNode = isTypePredicateNode;
 674 function isTypeReferenceNode(node) {
 675     return node.kind === ts.SyntaxKind.TypeReference;
 676 }
 677 exports.isTypeReferenceNode = isTypeReferenceNode;
 678 function isTypeQueryNode(node) {
 679     return node.kind === ts.SyntaxKind.TypeQuery;
 680 }
 681 exports.isTypeQueryNode = isTypeQueryNode;
 682 function isUnionTypeNode(node) {
 683     return node.kind === ts.SyntaxKind.UnionType;
 684 }
 685 exports.isUnionTypeNode = isUnionTypeNode;
 686 function isVariableDeclaration(node) {
 687     return node.kind === ts.SyntaxKind.VariableDeclaration;
 688 }
 689 exports.isVariableDeclaration = isVariableDeclaration;
 690 function isVariableStatement(node) {
 691     return node.kind === ts.SyntaxKind.VariableStatement;
 692 }
 693 exports.isVariableStatement = isVariableStatement;
 694 function isVariableDeclarationList(node) {
 695     return node.kind === ts.SyntaxKind.VariableDeclarationList;
 696 }
 697 exports.isVariableDeclarationList = isVariableDeclarationList;
 698 function isVoidExpression(node) {
 699     return node.kind === ts.SyntaxKind.VoidExpression;
 700 }
 701 exports.isVoidExpression = isVoidExpression;
 702 function isWhileStatement(node) {
 703     return node.kind === ts.SyntaxKind.WhileStatement;
 704 }
 705 exports.isWhileStatement = isWhileStatement;
 706 function isWithStatement(node) {
 707     return node.kind === ts.SyntaxKind.WithStatement;
 708 }
 709 exports.isWithStatement = isWithStatement;