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

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