From b75ce53ceb19e5c60cf6a8a6f7fcf01a69513cd0 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 12 Aug 2026 10:00:57 -0700 Subject: [PATCH 1/3] Generate generic .Handle members of is-guards for guarding node handles (sync and async) --- _packages/native-preview/src/api/async/api.ts | 22 +- .../native-preview/src/api/async/types.ts | 3 +- _packages/native-preview/src/api/sync/api.ts | 22 +- .../native-preview/src/api/sync/types.ts | 3 +- .../native-preview/src/ast/is.generated.ts | 2186 ++++++++++++++++- .../native-preview/test/async/api.test.ts | 6 + .../native-preview/test/sync/api.test.ts | 6 + _scripts/generate-ts-ast.ts | 47 +- 8 files changed, 2263 insertions(+), 32 deletions(-) diff --git a/_packages/native-preview/src/api/async/api.ts b/_packages/native-preview/src/api/async/api.ts index f63d500fb3a..d8846954cf2 100644 --- a/_packages/native-preview/src/api/async/api.ts +++ b/_packages/native-preview/src/api/async/api.ts @@ -14,8 +14,10 @@ import { TypeFlags } from "#enums/typeFlags"; import { TypePredicateKind } from "#enums/typePredicateKind"; import { type __String, + type Declaration, type Expression, type Identifier, + type IndexSignatureDeclaration, ModifierFlags, type Node, type Path, @@ -676,7 +678,7 @@ class ProjectObjectRegistry { keyType: this.getOrCreateType(info.keyType), valueType: this.getOrCreateType(info.valueType), isReadonly: info.isReadonly ?? false, - declaration: info.declaration ? new NodeHandle(info.declaration, this.project) : undefined, + declaration: info.declaration ? new NodeHandle(info.declaration, this.project) : undefined, })); } @@ -1810,7 +1812,7 @@ export class Emitter { } } -export class NodeHandle { +export class NodeHandle { /** * The project this handle was produced in, used as the default for {@link resolve}. * Node handles are only meaningful within a project's program, so the producing project @@ -1834,12 +1836,12 @@ export class NodeHandle { * and looking up the node by index. If no project is passed, the project that produced * the handle is used. */ - async resolve(project: Project = this.canonicalProject): Promise { + async resolve(project: Project = this.canonicalProject): Promise { const sourceFile = await project.program.getSourceFile(this.path); if (!sourceFile) { return undefined; } - return (sourceFile as unknown as RemoteSourceFile).getOrCreateNodeAtIndex(this.index); + return (sourceFile as unknown as RemoteSourceFile).getOrCreateNodeAtIndex(this.index) as T | undefined; } } @@ -1877,8 +1879,8 @@ export class Symbol { readonly name: string; readonly flags: SymbolFlags; readonly checkFlags: CheckFlags; - readonly declarations: readonly NodeHandle[]; - readonly valueDeclaration: NodeHandle | undefined; + readonly declarations: readonly NodeHandle[]; + readonly valueDeclaration: NodeHandle | undefined; private readonly parent!: number; private readonly exportSymbol!: number; private membersCache: Promise> | undefined; @@ -1897,8 +1899,8 @@ export class Symbol { throw new Error(`Symbol ${data.id} references unknown canonical project '${data.project}'`); } this.canonicalProject = canonicalProject; - this.declarations = (data.declarations ?? []).map(d => new NodeHandle(d, canonicalProject)); - this.valueDeclaration = data.valueDeclaration ? new NodeHandle(data.valueDeclaration, canonicalProject) : undefined; + this.declarations = (data.declarations ?? []).map(d => new NodeHandle(d, canonicalProject)); + this.valueDeclaration = data.valueDeclaration ? new NodeHandle(data.valueDeclaration, canonicalProject) : undefined; if (data.parent !== undefined) this.parent = data.parent; if (data.exportSymbol !== undefined) this.exportSymbol = data.exportSymbol; @@ -2403,7 +2405,7 @@ export class Signature { private objectRegistry: ProjectObjectRegistry; readonly id: number; - readonly declaration?: NodeHandle | undefined; + readonly declaration?: NodeHandle | undefined; readonly typeParameters?: readonly number[] | undefined; readonly parameters: readonly number[]; readonly thisParameter?: number | undefined; @@ -2414,7 +2416,7 @@ export class Signature { this.id = data.id; this.flags = data.flags; this.objectRegistry = objectRegistry; - this.declaration = data.declaration ? new NodeHandle(data.declaration, project) : undefined; + this.declaration = data.declaration ? new NodeHandle(data.declaration, project) : undefined; this.typeParameters = data.typeParameters ?? []; this.parameters = data.parameters ?? []; this.thisParameter = data.thisParameter; diff --git a/_packages/native-preview/src/api/async/types.ts b/_packages/native-preview/src/api/async/types.ts index 5b5c4e6544e..fae6fce1c43 100644 --- a/_packages/native-preview/src/api/async/types.ts +++ b/_packages/native-preview/src/api/async/types.ts @@ -4,6 +4,7 @@ import type { ElementFlags } from "#enums/elementFlags"; import type { ObjectFlags } from "#enums/objectFlags"; import type { TypeFlags } from "#enums/typeFlags"; import type { TypePredicateKind } from "#enums/typePredicateKind"; +import type { IndexSignatureDeclaration } from "../../ast/ast.ts"; import type { NodeHandle, Signature, @@ -317,7 +318,7 @@ export interface IndexInfo { /** Whether the index signature is readonly */ readonly isReadonly: boolean; /** The index signature declaration, if any */ - readonly declaration?: NodeHandle | undefined; + readonly declaration?: NodeHandle | undefined; } /** diff --git a/_packages/native-preview/src/api/sync/api.ts b/_packages/native-preview/src/api/sync/api.ts index 22aacc48737..ccb06721e74 100644 --- a/_packages/native-preview/src/api/sync/api.ts +++ b/_packages/native-preview/src/api/sync/api.ts @@ -22,8 +22,10 @@ import { TypeFlags } from "#enums/typeFlags"; import { TypePredicateKind } from "#enums/typePredicateKind"; import { type __String, + type Declaration, type Expression, type Identifier, + type IndexSignatureDeclaration, ModifierFlags, type Node, type Path, @@ -684,7 +686,7 @@ class ProjectObjectRegistry { keyType: this.getOrCreateType(info.keyType), valueType: this.getOrCreateType(info.valueType), isReadonly: info.isReadonly ?? false, - declaration: info.declaration ? new NodeHandle(info.declaration, this.project) : undefined, + declaration: info.declaration ? new NodeHandle(info.declaration, this.project) : undefined, })); } @@ -1818,7 +1820,7 @@ export class Emitter { } } -export class NodeHandle { +export class NodeHandle { /** * The project this handle was produced in, used as the default for {@link resolve}. * Node handles are only meaningful within a project's program, so the producing project @@ -1842,12 +1844,12 @@ export class NodeHandle { * and looking up the node by index. If no project is passed, the project that produced * the handle is used. */ - resolve(project: Project = this.canonicalProject): Node | undefined { + resolve(project: Project = this.canonicalProject): T | undefined { const sourceFile = project.program.getSourceFile(this.path); if (!sourceFile) { return undefined; } - return (sourceFile as unknown as RemoteSourceFile).getOrCreateNodeAtIndex(this.index); + return (sourceFile as unknown as RemoteSourceFile).getOrCreateNodeAtIndex(this.index) as T | undefined; } } @@ -1885,8 +1887,8 @@ export class Symbol { readonly name: string; readonly flags: SymbolFlags; readonly checkFlags: CheckFlags; - readonly declarations: readonly NodeHandle[]; - readonly valueDeclaration: NodeHandle | undefined; + readonly declarations: readonly NodeHandle[]; + readonly valueDeclaration: NodeHandle | undefined; private readonly parent!: number; private readonly exportSymbol!: number; private membersCache: ReadonlyMap<__String, Symbol> | undefined; @@ -1905,8 +1907,8 @@ export class Symbol { throw new Error(`Symbol ${data.id} references unknown canonical project '${data.project}'`); } this.canonicalProject = canonicalProject; - this.declarations = (data.declarations ?? []).map(d => new NodeHandle(d, canonicalProject)); - this.valueDeclaration = data.valueDeclaration ? new NodeHandle(data.valueDeclaration, canonicalProject) : undefined; + this.declarations = (data.declarations ?? []).map(d => new NodeHandle(d, canonicalProject)); + this.valueDeclaration = data.valueDeclaration ? new NodeHandle(data.valueDeclaration, canonicalProject) : undefined; if (data.parent !== undefined) this.parent = data.parent; if (data.exportSymbol !== undefined) this.exportSymbol = data.exportSymbol; @@ -2411,7 +2413,7 @@ export class Signature { private objectRegistry: ProjectObjectRegistry; readonly id: number; - readonly declaration?: NodeHandle | undefined; + readonly declaration?: NodeHandle | undefined; readonly typeParameters?: readonly number[] | undefined; readonly parameters: readonly number[]; readonly thisParameter?: number | undefined; @@ -2422,7 +2424,7 @@ export class Signature { this.id = data.id; this.flags = data.flags; this.objectRegistry = objectRegistry; - this.declaration = data.declaration ? new NodeHandle(data.declaration, project) : undefined; + this.declaration = data.declaration ? new NodeHandle(data.declaration, project) : undefined; this.typeParameters = data.typeParameters ?? []; this.parameters = data.parameters ?? []; this.thisParameter = data.thisParameter; diff --git a/_packages/native-preview/src/api/sync/types.ts b/_packages/native-preview/src/api/sync/types.ts index 36c3658daaf..177e1615c2c 100644 --- a/_packages/native-preview/src/api/sync/types.ts +++ b/_packages/native-preview/src/api/sync/types.ts @@ -12,6 +12,7 @@ import type { ElementFlags } from "#enums/elementFlags"; import type { ObjectFlags } from "#enums/objectFlags"; import type { TypeFlags } from "#enums/typeFlags"; import type { TypePredicateKind } from "#enums/typePredicateKind"; +import type { IndexSignatureDeclaration } from "../../ast/ast.ts"; import type { NodeHandle, Signature, @@ -325,7 +326,7 @@ export interface IndexInfo { /** Whether the index signature is readonly */ readonly isReadonly: boolean; /** The index signature declaration, if any */ - readonly declaration?: NodeHandle | undefined; + readonly declaration?: NodeHandle | undefined; } /** diff --git a/_packages/native-preview/src/ast/is.generated.ts b/_packages/native-preview/src/ast/is.generated.ts index 44370944c56..c91d8178119 100644 --- a/_packages/native-preview/src/ast/is.generated.ts +++ b/_packages/native-preview/src/ast/is.generated.ts @@ -1,6 +1,8 @@ // Code generated by _scripts/generate-ts-ast.ts. DO NOT EDIT. import { SyntaxKind } from "#enums/syntaxKind"; +import type { NodeHandle as AsyncNodeHandle } from "../api/async/api.ts"; +import type { NodeHandle as SyncNodeHandle } from "../api/sync/api.ts"; import type { AbstractKeyword, AccessExpression, @@ -326,147 +328,394 @@ import type { WithStatement, YieldExpression, } from "./ast.ts"; +type NodeHandleLike = { kind: SyntaxKind; resolve(...args: any): any; }; +type SpecializeNodeHandle, U extends Node> = T extends AsyncNodeHandle ? AsyncNodeHandle & T : SyncNodeHandle & T; export function isToken(node: Node): node is Token { return isTokenKind(node.kind); } +export declare namespace isToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return isTokenKind(node.kind); +}; + export function isIdentifier(node: Node): node is Identifier { return node.kind === SyntaxKind.Identifier; } +export declare namespace isIdentifier { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isIdentifier.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier; +}; + export function isPrivateIdentifier(node: Node): node is PrivateIdentifier { return node.kind === SyntaxKind.PrivateIdentifier; } +export declare namespace isPrivateIdentifier { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPrivateIdentifier.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PrivateIdentifier; +}; + export function isQualifiedName(node: Node): node is QualifiedName { return node.kind === SyntaxKind.QualifiedName; } +export declare namespace isQualifiedName { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isQualifiedName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.QualifiedName; +}; + export function isComputedPropertyName(node: Node): node is ComputedPropertyName { return node.kind === SyntaxKind.ComputedPropertyName; } +export declare namespace isComputedPropertyName { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isComputedPropertyName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ComputedPropertyName; +}; + export function isDecorator(node: Node): node is Decorator { return node.kind === SyntaxKind.Decorator; } +export declare namespace isDecorator { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isDecorator.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Decorator; +}; + export function isEmptyStatement(node: Node): node is EmptyStatement { return node.kind === SyntaxKind.EmptyStatement; } +export declare namespace isEmptyStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isEmptyStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.EmptyStatement; +}; + export function isIfStatement(node: Node): node is IfStatement { return node.kind === SyntaxKind.IfStatement; } +export declare namespace isIfStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isIfStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.IfStatement; +}; + export function isDoStatement(node: Node): node is DoStatement { return node.kind === SyntaxKind.DoStatement; } +export declare namespace isDoStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isDoStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DoStatement; +}; + export function isWhileStatement(node: Node): node is WhileStatement { return node.kind === SyntaxKind.WhileStatement; } +export declare namespace isWhileStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isWhileStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.WhileStatement; +}; + export function isForStatement(node: Node): node is ForStatement { return node.kind === SyntaxKind.ForStatement; } +export declare namespace isForStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isForStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ForStatement; +}; + export function isBreakStatement(node: Node): node is BreakStatement { return node.kind === SyntaxKind.BreakStatement; } +export declare namespace isBreakStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isBreakStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BreakStatement; +}; + export function isContinueStatement(node: Node): node is ContinueStatement { return node.kind === SyntaxKind.ContinueStatement; } +export declare namespace isContinueStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isContinueStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ContinueStatement; +}; + export function isReturnStatement(node: Node): node is ReturnStatement { return node.kind === SyntaxKind.ReturnStatement; } +export declare namespace isReturnStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isReturnStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ReturnStatement; +}; + export function isWithStatement(node: Node): node is WithStatement { return node.kind === SyntaxKind.WithStatement; } +export declare namespace isWithStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isWithStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.WithStatement; +}; + export function isSwitchStatement(node: Node): node is SwitchStatement { return node.kind === SyntaxKind.SwitchStatement; } +export declare namespace isSwitchStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSwitchStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SwitchStatement; +}; + export function isCaseBlock(node: Node): node is CaseBlock { return node.kind === SyntaxKind.CaseBlock; } +export declare namespace isCaseBlock { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isCaseBlock.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.CaseBlock; +}; + export function isThrowStatement(node: Node): node is ThrowStatement { return node.kind === SyntaxKind.ThrowStatement; } +export declare namespace isThrowStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isThrowStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ThrowStatement; +}; + export function isTryStatement(node: Node): node is TryStatement { return node.kind === SyntaxKind.TryStatement; } +export declare namespace isTryStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTryStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TryStatement; +}; + export function isCatchClause(node: Node): node is CatchClause { return node.kind === SyntaxKind.CatchClause; } +export declare namespace isCatchClause { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isCatchClause.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.CatchClause; +}; + export function isDebuggerStatement(node: Node): node is DebuggerStatement { return node.kind === SyntaxKind.DebuggerStatement; } +export declare namespace isDebuggerStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isDebuggerStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DebuggerStatement; +}; + export function isLabeledStatement(node: Node): node is LabeledStatement { return node.kind === SyntaxKind.LabeledStatement; } +export declare namespace isLabeledStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isLabeledStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.LabeledStatement; +}; + export function isExpressionStatement(node: Node): node is ExpressionStatement { return node.kind === SyntaxKind.ExpressionStatement; } +export declare namespace isExpressionStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isExpressionStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExpressionStatement; +}; + export function isBlock(node: Node): node is Block { return node.kind === SyntaxKind.Block; } +export declare namespace isBlock { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isBlock.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Block; +}; + export function isVariableStatement(node: Node): node is VariableStatement { return node.kind === SyntaxKind.VariableStatement; } +export declare namespace isVariableStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isVariableStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.VariableStatement; +}; + export function isVariableDeclaration(node: Node): node is VariableDeclaration { return node.kind === SyntaxKind.VariableDeclaration; } +export declare namespace isVariableDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isVariableDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.VariableDeclaration; +}; + export function isVariableDeclarationList(node: Node): node is VariableDeclarationList { return node.kind === SyntaxKind.VariableDeclarationList; } +export declare namespace isVariableDeclarationList { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isVariableDeclarationList.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.VariableDeclarationList; +}; + export function isParameterDeclaration(node: Node): node is ParameterDeclaration { return node.kind === SyntaxKind.Parameter; } +export declare namespace isParameterDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isParameterDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Parameter; +}; + export function isBindingElement(node: Node): node is BindingElement { return node.kind === SyntaxKind.BindingElement; } +export declare namespace isBindingElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isBindingElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BindingElement; +}; + export function isMissingDeclaration(node: Node): node is MissingDeclaration { return node.kind === SyntaxKind.MissingDeclaration; } +export declare namespace isMissingDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isMissingDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.MissingDeclaration; +}; + export function isFunctionDeclaration(node: Node): node is FunctionDeclaration { return node.kind === SyntaxKind.FunctionDeclaration; } +export declare namespace isFunctionDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isFunctionDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.FunctionDeclaration; +}; + export function isClassDeclaration(node: Node): node is ClassDeclaration { return node.kind === SyntaxKind.ClassDeclaration; } +export declare namespace isClassDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isClassDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ClassDeclaration; +}; + export function isClassExpression(node: Node): node is ClassExpression { return node.kind === SyntaxKind.ClassExpression; } +export declare namespace isClassExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isClassExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ClassExpression; +}; + export function isHeritageClause(node: Node): node is HeritageClause { return node.kind === SyntaxKind.HeritageClause; } +export declare namespace isHeritageClause { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isHeritageClause.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.HeritageClause; +}; + export function isInterfaceDeclaration(node: Node): node is InterfaceDeclaration { return node.kind === SyntaxKind.InterfaceDeclaration; } +export declare namespace isInterfaceDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isInterfaceDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.InterfaceDeclaration; +}; + export function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration { switch (node.kind) { case SyntaxKind.TypeAliasDeclaration: @@ -477,26 +726,74 @@ export function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration } } +export declare namespace isTypeAliasDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeAliasDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + switch (node.kind) { + case SyntaxKind.TypeAliasDeclaration: + case SyntaxKind.JSTypeAliasDeclaration: + return true; + default: + return false; + } +}; + export function isEnumMember(node: Node): node is EnumMember { return node.kind === SyntaxKind.EnumMember; } +export declare namespace isEnumMember { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isEnumMember.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.EnumMember; +}; + export function isEnumDeclaration(node: Node): node is EnumDeclaration { return node.kind === SyntaxKind.EnumDeclaration; } +export declare namespace isEnumDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isEnumDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.EnumDeclaration; +}; + export function isModuleBlock(node: Node): node is ModuleBlock { return node.kind === SyntaxKind.ModuleBlock; } +export declare namespace isModuleBlock { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isModuleBlock.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ModuleBlock; +}; + export function isNotEmittedStatement(node: Node): node is NotEmittedStatement { return node.kind === SyntaxKind.NotEmittedStatement; } +export declare namespace isNotEmittedStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNotEmittedStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NotEmittedStatement; +}; + export function isNotEmittedTypeElement(node: Node): node is NotEmittedTypeElement { return node.kind === SyntaxKind.NotEmittedTypeElement; } +export declare namespace isNotEmittedTypeElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNotEmittedTypeElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NotEmittedTypeElement; +}; + export function isImportDeclaration(node: Node): node is ImportDeclaration { switch (node.kind) { case SyntaxKind.ImportDeclaration: @@ -507,872 +804,2445 @@ export function isImportDeclaration(node: Node): node is ImportDeclaration { } } +export declare namespace isImportDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isImportDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + switch (node.kind) { + case SyntaxKind.ImportDeclaration: + case SyntaxKind.JSImportDeclaration: + return true; + default: + return false; + } +}; + export function isExternalModuleReference(node: Node): node is ExternalModuleReference { return node.kind === SyntaxKind.ExternalModuleReference; } +export declare namespace isExternalModuleReference { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isExternalModuleReference.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExternalModuleReference; +}; + export function isNamespaceImport(node: Node): node is NamespaceImport { return node.kind === SyntaxKind.NamespaceImport; } +export declare namespace isNamespaceImport { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNamespaceImport.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamespaceImport; +}; + export function isNamedImports(node: Node): node is NamedImports { return node.kind === SyntaxKind.NamedImports; } +export declare namespace isNamedImports { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNamedImports.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamedImports; +}; + export function isExportAssignment(node: Node): node is ExportAssignment { return node.kind === SyntaxKind.ExportAssignment; } +export declare namespace isExportAssignment { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isExportAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExportAssignment; +}; + export function isNamespaceExportDeclaration(node: Node): node is NamespaceExportDeclaration { return node.kind === SyntaxKind.NamespaceExportDeclaration; } +export declare namespace isNamespaceExportDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNamespaceExportDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamespaceExportDeclaration; +}; + export function isNamespaceExport(node: Node): node is NamespaceExport { return node.kind === SyntaxKind.NamespaceExport; } +export declare namespace isNamespaceExport { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNamespaceExport.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamespaceExport; +}; + export function isNamedExports(node: Node): node is NamedExports { return node.kind === SyntaxKind.NamedExports; } +export declare namespace isNamedExports { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNamedExports.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamedExports; +}; + export function isExportSpecifier(node: Node): node is ExportSpecifier { return node.kind === SyntaxKind.ExportSpecifier; } +export declare namespace isExportSpecifier { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isExportSpecifier.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExportSpecifier; +}; + export function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration { return node.kind === SyntaxKind.CallSignature; } +export declare namespace isCallSignatureDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isCallSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.CallSignature; +}; + export function isConstructSignatureDeclaration(node: Node): node is ConstructSignatureDeclaration { return node.kind === SyntaxKind.ConstructSignature; } +export declare namespace isConstructSignatureDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isConstructSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ConstructSignature; +}; + export function isConstructorDeclaration(node: Node): node is ConstructorDeclaration { return node.kind === SyntaxKind.Constructor; } +export declare namespace isConstructorDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isConstructorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Constructor; +}; + export function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration { return node.kind === SyntaxKind.GetAccessor; } +export declare namespace isGetAccessorDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isGetAccessorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.GetAccessor; +}; + export function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration { return node.kind === SyntaxKind.SetAccessor; } +export declare namespace isSetAccessorDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSetAccessorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SetAccessor; +}; + export function isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration { return node.kind === SyntaxKind.IndexSignature; } +export declare namespace isIndexSignatureDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isIndexSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.IndexSignature; +}; + export function isMethodSignatureDeclaration(node: Node): node is MethodSignatureDeclaration { return node.kind === SyntaxKind.MethodSignature; } +export declare namespace isMethodSignatureDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isMethodSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.MethodSignature; +}; + export function isMethodDeclaration(node: Node): node is MethodDeclaration { return node.kind === SyntaxKind.MethodDeclaration; } +export declare namespace isMethodDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isMethodDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.MethodDeclaration; +}; + export function isPropertySignatureDeclaration(node: Node): node is PropertySignatureDeclaration { return node.kind === SyntaxKind.PropertySignature; } +export declare namespace isPropertySignatureDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPropertySignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PropertySignature; +}; + export function isPropertyDeclaration(node: Node): node is PropertyDeclaration { return node.kind === SyntaxKind.PropertyDeclaration; } +export declare namespace isPropertyDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPropertyDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PropertyDeclaration; +}; + export function isSemicolonClassElement(node: Node): node is SemicolonClassElement { return node.kind === SyntaxKind.SemicolonClassElement; } +export declare namespace isSemicolonClassElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSemicolonClassElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SemicolonClassElement; +}; + export function isClassStaticBlockDeclaration(node: Node): node is ClassStaticBlockDeclaration { return node.kind === SyntaxKind.ClassStaticBlockDeclaration; } +export declare namespace isClassStaticBlockDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isClassStaticBlockDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ClassStaticBlockDeclaration; +}; + export function isOmittedExpression(node: Node): node is OmittedExpression { return node.kind === SyntaxKind.OmittedExpression; } +export declare namespace isOmittedExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isOmittedExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.OmittedExpression; +}; + export function isKeywordExpression(node: Node): node is KeywordExpression { return isKeywordExpressionKind(node.kind); } +export declare namespace isKeywordExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isKeywordExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return isKeywordExpressionKind(node.kind); +}; + export function isStringLiteral(node: Node): node is StringLiteral { return node.kind === SyntaxKind.StringLiteral; } +export declare namespace isStringLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isStringLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.StringLiteral; +}; + export function isNumericLiteral(node: Node): node is NumericLiteral { return node.kind === SyntaxKind.NumericLiteral; } +export declare namespace isNumericLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNumericLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NumericLiteral; +}; + export function isBigIntLiteral(node: Node): node is BigIntLiteral { return node.kind === SyntaxKind.BigIntLiteral; } +export declare namespace isBigIntLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isBigIntLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BigIntLiteral; +}; + export function isRegularExpressionLiteral(node: Node): node is RegularExpressionLiteral { return node.kind === SyntaxKind.RegularExpressionLiteral; } +export declare namespace isRegularExpressionLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isRegularExpressionLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.RegularExpressionLiteral; +}; + export function isNoSubstitutionTemplateLiteral(node: Node): node is NoSubstitutionTemplateLiteral { return node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; } +export declare namespace isNoSubstitutionTemplateLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNoSubstitutionTemplateLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; +}; + export function isBinaryExpression(node: Node): node is BinaryExpression { return node.kind === SyntaxKind.BinaryExpression; } +export declare namespace isBinaryExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isBinaryExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BinaryExpression; +}; + export function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression { return node.kind === SyntaxKind.PrefixUnaryExpression; } +export declare namespace isPrefixUnaryExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPrefixUnaryExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PrefixUnaryExpression; +}; + export function isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpression { return node.kind === SyntaxKind.PostfixUnaryExpression; } +export declare namespace isPostfixUnaryExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPostfixUnaryExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PostfixUnaryExpression; +}; + export function isYieldExpression(node: Node): node is YieldExpression { return node.kind === SyntaxKind.YieldExpression; } +export declare namespace isYieldExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isYieldExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.YieldExpression; +}; + export function isArrowFunction(node: Node): node is ArrowFunction { return node.kind === SyntaxKind.ArrowFunction; } +export declare namespace isArrowFunction { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isArrowFunction.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ArrowFunction; +}; + export function isFunctionExpression(node: Node): node is FunctionExpression { return node.kind === SyntaxKind.FunctionExpression; } +export declare namespace isFunctionExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isFunctionExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.FunctionExpression; +}; + export function isAsExpression(node: Node): node is AsExpression { return node.kind === SyntaxKind.AsExpression; } +export declare namespace isAsExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isAsExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AsExpression; +}; + export function isSatisfiesExpression(node: Node): node is SatisfiesExpression { return node.kind === SyntaxKind.SatisfiesExpression; } +export declare namespace isSatisfiesExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSatisfiesExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SatisfiesExpression; +}; + export function isConditionalExpression(node: Node): node is ConditionalExpression { return node.kind === SyntaxKind.ConditionalExpression; } +export declare namespace isConditionalExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isConditionalExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ConditionalExpression; +}; + export function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression { return node.kind === SyntaxKind.PropertyAccessExpression; } +export declare namespace isPropertyAccessExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPropertyAccessExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PropertyAccessExpression; +}; + export function isElementAccessExpression(node: Node): node is ElementAccessExpression { return node.kind === SyntaxKind.ElementAccessExpression; } +export declare namespace isElementAccessExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isElementAccessExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ElementAccessExpression; +}; + export function isCallExpression(node: Node): node is CallExpression { return node.kind === SyntaxKind.CallExpression; } +export declare namespace isCallExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isCallExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.CallExpression; +}; + export function isNewExpression(node: Node): node is NewExpression { return node.kind === SyntaxKind.NewExpression; } -export function isMetaProperty(node: Node): node is MetaProperty { +export declare namespace isNewExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNewExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NewExpression; +}; + +export function isMetaProperty(node: Node): node is MetaProperty { return node.kind === SyntaxKind.MetaProperty; } +export declare namespace isMetaProperty { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isMetaProperty.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.MetaProperty; +}; + export function isNonNullExpression(node: Node): node is NonNullExpression { return node.kind === SyntaxKind.NonNullExpression; } +export declare namespace isNonNullExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNonNullExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NonNullExpression; +}; + export function isSpreadElement(node: Node): node is SpreadElement { return node.kind === SyntaxKind.SpreadElement; } +export declare namespace isSpreadElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSpreadElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SpreadElement; +}; + export function isTemplateExpression(node: Node): node is TemplateExpression { return node.kind === SyntaxKind.TemplateExpression; } +export declare namespace isTemplateExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTemplateExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateExpression; +}; + export function isTemplateSpan(node: Node): node is TemplateSpan { return node.kind === SyntaxKind.TemplateSpan; } +export declare namespace isTemplateSpan { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTemplateSpan.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateSpan; +}; + export function isTaggedTemplateExpression(node: Node): node is TaggedTemplateExpression { return node.kind === SyntaxKind.TaggedTemplateExpression; } +export declare namespace isTaggedTemplateExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTaggedTemplateExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TaggedTemplateExpression; +}; + export function isParenthesizedExpression(node: Node): node is ParenthesizedExpression { return node.kind === SyntaxKind.ParenthesizedExpression; } +export declare namespace isParenthesizedExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isParenthesizedExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ParenthesizedExpression; +}; + export function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression { return node.kind === SyntaxKind.ArrayLiteralExpression; } +export declare namespace isArrayLiteralExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isArrayLiteralExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ArrayLiteralExpression; +}; + export function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression { return node.kind === SyntaxKind.ObjectLiteralExpression; } +export declare namespace isObjectLiteralExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isObjectLiteralExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ObjectLiteralExpression; +}; + export function isSpreadAssignment(node: Node): node is SpreadAssignment { return node.kind === SyntaxKind.SpreadAssignment; } +export declare namespace isSpreadAssignment { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSpreadAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SpreadAssignment; +}; + export function isPropertyAssignment(node: Node): node is PropertyAssignment { return node.kind === SyntaxKind.PropertyAssignment; } +export declare namespace isPropertyAssignment { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPropertyAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PropertyAssignment; +}; + export function isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment { return node.kind === SyntaxKind.ShorthandPropertyAssignment; } +export declare namespace isShorthandPropertyAssignment { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isShorthandPropertyAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ShorthandPropertyAssignment; +}; + export function isDeleteExpression(node: Node): node is DeleteExpression { return node.kind === SyntaxKind.DeleteExpression; } +export declare namespace isDeleteExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isDeleteExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DeleteExpression; +}; + export function isTypeOfExpression(node: Node): node is TypeOfExpression { return node.kind === SyntaxKind.TypeOfExpression; } +export declare namespace isTypeOfExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeOfExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeOfExpression; +}; + export function isVoidExpression(node: Node): node is VoidExpression { return node.kind === SyntaxKind.VoidExpression; } +export declare namespace isVoidExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isVoidExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.VoidExpression; +}; + export function isAwaitExpression(node: Node): node is AwaitExpression { return node.kind === SyntaxKind.AwaitExpression; } +export declare namespace isAwaitExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isAwaitExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AwaitExpression; +}; + export function isTypeAssertion(node: Node): node is TypeAssertion { return node.kind === SyntaxKind.TypeAssertionExpression; } +export declare namespace isTypeAssertion { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeAssertion.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeAssertionExpression; +}; + export function isKeywordTypeNode(node: Node): node is KeywordTypeNode { return isKeywordTypeKind(node.kind); } +export declare namespace isKeywordTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isKeywordTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return isKeywordTypeKind(node.kind); +}; + export function isUnionTypeNode(node: Node): node is UnionTypeNode { return node.kind === SyntaxKind.UnionType; } +export declare namespace isUnionTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isUnionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.UnionType; +}; + export function isIntersectionTypeNode(node: Node): node is IntersectionTypeNode { return node.kind === SyntaxKind.IntersectionType; } +export declare namespace isIntersectionTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isIntersectionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.IntersectionType; +}; + export function isConditionalTypeNode(node: Node): node is ConditionalTypeNode { return node.kind === SyntaxKind.ConditionalType; } +export declare namespace isConditionalTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isConditionalTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ConditionalType; +}; + export function isTypeOperatorNode(node: Node): node is TypeOperatorNode { return node.kind === SyntaxKind.TypeOperator; } +export declare namespace isTypeOperatorNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeOperatorNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeOperator; +}; + export function isInferTypeNode(node: Node): node is InferTypeNode { return node.kind === SyntaxKind.InferType; } +export declare namespace isInferTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isInferTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.InferType; +}; + export function isArrayTypeNode(node: Node): node is ArrayTypeNode { return node.kind === SyntaxKind.ArrayType; } +export declare namespace isArrayTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isArrayTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ArrayType; +}; + export function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode { return node.kind === SyntaxKind.IndexedAccessType; } +export declare namespace isIndexedAccessTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isIndexedAccessTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.IndexedAccessType; +}; + export function isTypeReferenceNode(node: Node): node is TypeReferenceNode { return node.kind === SyntaxKind.TypeReference; } +export declare namespace isTypeReferenceNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeReferenceNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeReference; +}; + export function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments { return node.kind === SyntaxKind.ExpressionWithTypeArguments; } +export declare namespace isExpressionWithTypeArguments { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isExpressionWithTypeArguments.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExpressionWithTypeArguments; +}; + export function isLiteralTypeNode(node: Node): node is LiteralTypeNode { return node.kind === SyntaxKind.LiteralType; } +export declare namespace isLiteralTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isLiteralTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.LiteralType; +}; + export function isThisTypeNode(node: Node): node is ThisTypeNode { return node.kind === SyntaxKind.ThisType; } +export declare namespace isThisTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isThisTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ThisType; +}; + export function isTypePredicateNode(node: Node): node is TypePredicateNode { return node.kind === SyntaxKind.TypePredicate; } +export declare namespace isTypePredicateNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypePredicateNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypePredicate; +}; + export function isImportAttribute(node: Node): node is ImportAttribute { return node.kind === SyntaxKind.ImportAttribute; } +export declare namespace isImportAttribute { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isImportAttribute.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportAttribute; +}; + export function isImportAttributes(node: Node): node is ImportAttributes { return node.kind === SyntaxKind.ImportAttributes; } +export declare namespace isImportAttributes { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isImportAttributes.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportAttributes; +}; + export function isTypeQueryNode(node: Node): node is TypeQueryNode { return node.kind === SyntaxKind.TypeQuery; } +export declare namespace isTypeQueryNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeQueryNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeQuery; +}; + export function isMappedTypeNode(node: Node): node is MappedTypeNode { return node.kind === SyntaxKind.MappedType; } +export declare namespace isMappedTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isMappedTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.MappedType; +}; + export function isTypeLiteralNode(node: Node): node is TypeLiteralNode { return node.kind === SyntaxKind.TypeLiteral; } +export declare namespace isTypeLiteralNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeLiteralNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeLiteral; +}; + export function isTupleTypeNode(node: Node): node is TupleTypeNode { return node.kind === SyntaxKind.TupleType; } +export declare namespace isTupleTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTupleTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TupleType; +}; + export function isNamedTupleMember(node: Node): node is NamedTupleMember { return node.kind === SyntaxKind.NamedTupleMember; } +export declare namespace isNamedTupleMember { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isNamedTupleMember.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamedTupleMember; +}; + export function isOptionalTypeNode(node: Node): node is OptionalTypeNode { return node.kind === SyntaxKind.OptionalType; } +export declare namespace isOptionalTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isOptionalTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.OptionalType; +}; + export function isRestTypeNode(node: Node): node is RestTypeNode { return node.kind === SyntaxKind.RestType; } +export declare namespace isRestTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isRestTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.RestType; +}; + export function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode { return node.kind === SyntaxKind.ParenthesizedType; } +export declare namespace isParenthesizedTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isParenthesizedTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ParenthesizedType; +}; + export function isFunctionTypeNode(node: Node): node is FunctionTypeNode { return node.kind === SyntaxKind.FunctionType; } +export declare namespace isFunctionTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isFunctionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.FunctionType; +}; + export function isConstructorTypeNode(node: Node): node is ConstructorTypeNode { return node.kind === SyntaxKind.ConstructorType; } +export declare namespace isConstructorTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isConstructorTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ConstructorType; +}; + export function isTemplateHead(node: Node): node is TemplateHead { return node.kind === SyntaxKind.TemplateHead; } +export declare namespace isTemplateHead { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTemplateHead.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateHead; +}; + export function isTemplateMiddle(node: Node): node is TemplateMiddle { return node.kind === SyntaxKind.TemplateMiddle; } +export declare namespace isTemplateMiddle { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTemplateMiddle.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateMiddle; +}; + export function isTemplateTail(node: Node): node is TemplateTail { return node.kind === SyntaxKind.TemplateTail; } +export declare namespace isTemplateTail { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTemplateTail.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateTail; +}; + export function isTemplateLiteralTypeNode(node: Node): node is TemplateLiteralTypeNode { return node.kind === SyntaxKind.TemplateLiteralType; } +export declare namespace isTemplateLiteralTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTemplateLiteralTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateLiteralType; +}; + export function isTemplateLiteralTypeSpan(node: Node): node is TemplateLiteralTypeSpan { return node.kind === SyntaxKind.TemplateLiteralTypeSpan; } +export declare namespace isTemplateLiteralTypeSpan { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTemplateLiteralTypeSpan.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateLiteralTypeSpan; +}; + export function isSyntheticExpression(node: Node): node is SyntheticExpression { return node.kind === SyntaxKind.SyntheticExpression; } +export declare namespace isSyntheticExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSyntheticExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SyntheticExpression; +}; + export function isPartiallyEmittedExpression(node: Node): node is PartiallyEmittedExpression { return node.kind === SyntaxKind.PartiallyEmittedExpression; } +export declare namespace isPartiallyEmittedExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isPartiallyEmittedExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PartiallyEmittedExpression; +}; + export function isJsxElement(node: Node): node is JsxElement { return node.kind === SyntaxKind.JsxElement; } +export declare namespace isJsxElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxElement; +}; + export function isJsxAttributes(node: Node): node is JsxAttributes { return node.kind === SyntaxKind.JsxAttributes; } +export declare namespace isJsxAttributes { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxAttributes.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxAttributes; +}; + export function isJsxNamespacedName(node: Node): node is JsxNamespacedName { return node.kind === SyntaxKind.JsxNamespacedName; } +export declare namespace isJsxNamespacedName { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxNamespacedName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxNamespacedName; +}; + export function isJsxOpeningElement(node: Node): node is JsxOpeningElement { return node.kind === SyntaxKind.JsxOpeningElement; } +export declare namespace isJsxOpeningElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxOpeningElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxOpeningElement; +}; + export function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement { return node.kind === SyntaxKind.JsxSelfClosingElement; } +export declare namespace isJsxSelfClosingElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxSelfClosingElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxSelfClosingElement; +}; + export function isJsxFragment(node: Node): node is JsxFragment { return node.kind === SyntaxKind.JsxFragment; } +export declare namespace isJsxFragment { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxFragment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxFragment; +}; + export function isJsxOpeningFragment(node: Node): node is JsxOpeningFragment { return node.kind === SyntaxKind.JsxOpeningFragment; } +export declare namespace isJsxOpeningFragment { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxOpeningFragment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxOpeningFragment; +}; + export function isJsxClosingFragment(node: Node): node is JsxClosingFragment { return node.kind === SyntaxKind.JsxClosingFragment; } +export declare namespace isJsxClosingFragment { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxClosingFragment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxClosingFragment; +}; + export function isJsxAttribute(node: Node): node is JsxAttribute { return node.kind === SyntaxKind.JsxAttribute; } +export declare namespace isJsxAttribute { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxAttribute.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxAttribute; +}; + export function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute { return node.kind === SyntaxKind.JsxSpreadAttribute; } +export declare namespace isJsxSpreadAttribute { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxSpreadAttribute.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxSpreadAttribute; +}; + export function isJsxClosingElement(node: Node): node is JsxClosingElement { return node.kind === SyntaxKind.JsxClosingElement; } +export declare namespace isJsxClosingElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxClosingElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxClosingElement; +}; + export function isJsxExpression(node: Node): node is JsxExpression { return node.kind === SyntaxKind.JsxExpression; } +export declare namespace isJsxExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxExpression; +}; + export function isJsxText(node: Node): node is JsxText { return node.kind === SyntaxKind.JsxText; } +export declare namespace isJsxText { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJsxText.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxText; +}; + export function isSyntaxList(node: Node): node is SyntaxList { return node.kind === SyntaxKind.SyntaxList; } +export declare namespace isSyntaxList { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSyntaxList.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SyntaxList; +}; + export function isJSDoc(node: Node): node is JSDoc { return node.kind === SyntaxKind.JSDoc; } +export declare namespace isJSDoc { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDoc.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDoc; +}; + export function isJSDocTypeExpression(node: Node): node is JSDocTypeExpression { return node.kind === SyntaxKind.JSDocTypeExpression; } +export declare namespace isJSDocTypeExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocTypeExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocTypeExpression; +}; + export function isJSDocNonNullableType(node: Node): node is JSDocNonNullableType { return node.kind === SyntaxKind.JSDocNonNullableType; } +export declare namespace isJSDocNonNullableType { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocNonNullableType.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocNonNullableType; +}; + export function isJSDocNullableType(node: Node): node is JSDocNullableType { return node.kind === SyntaxKind.JSDocNullableType; } +export declare namespace isJSDocNullableType { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocNullableType.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocNullableType; +}; + export function isJSDocAllType(node: Node): node is JSDocAllType { return node.kind === SyntaxKind.JSDocAllType; } +export declare namespace isJSDocAllType { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocAllType.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocAllType; +}; + export function isJSDocVariadicType(node: Node): node is JSDocVariadicType { return node.kind === SyntaxKind.JSDocVariadicType; } +export declare namespace isJSDocVariadicType { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocVariadicType.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocVariadicType; +}; + export function isJSDocOptionalType(node: Node): node is JSDocOptionalType { return node.kind === SyntaxKind.JSDocOptionalType; } +export declare namespace isJSDocOptionalType { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocOptionalType.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocOptionalType; +}; + export function isJSDocTypeTag(node: Node): node is JSDocTypeTag { return node.kind === SyntaxKind.JSDocTypeTag; } +export declare namespace isJSDocTypeTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocTypeTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocTypeTag; +}; + export function isJSDocUnknownTag(node: Node): node is JSDocUnknownTag { return node.kind === SyntaxKind.JSDocUnknownTag; } +export declare namespace isJSDocUnknownTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocUnknownTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocUnknownTag; +}; + export function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag { return node.kind === SyntaxKind.JSDocTemplateTag; } +export declare namespace isJSDocTemplateTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocTemplateTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocTemplateTag; +}; + export function isJSDocReturnTag(node: Node): node is JSDocReturnTag { return node.kind === SyntaxKind.JSDocReturnTag; } +export declare namespace isJSDocReturnTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocReturnTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocReturnTag; +}; + export function isJSDocPublicTag(node: Node): node is JSDocPublicTag { return node.kind === SyntaxKind.JSDocPublicTag; } +export declare namespace isJSDocPublicTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocPublicTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocPublicTag; +}; + export function isJSDocPrivateTag(node: Node): node is JSDocPrivateTag { return node.kind === SyntaxKind.JSDocPrivateTag; } +export declare namespace isJSDocPrivateTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocPrivateTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocPrivateTag; +}; + export function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag { return node.kind === SyntaxKind.JSDocProtectedTag; } +export declare namespace isJSDocProtectedTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocProtectedTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocProtectedTag; +}; + export function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag { return node.kind === SyntaxKind.JSDocReadonlyTag; } +export declare namespace isJSDocReadonlyTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocReadonlyTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocReadonlyTag; +}; + export function isJSDocOverrideTag(node: Node): node is JSDocOverrideTag { return node.kind === SyntaxKind.JSDocOverrideTag; } +export declare namespace isJSDocOverrideTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocOverrideTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocOverrideTag; +}; + export function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag { return node.kind === SyntaxKind.JSDocDeprecatedTag; } +export declare namespace isJSDocDeprecatedTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocDeprecatedTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocDeprecatedTag; +}; + export function isJSDocSeeTag(node: Node): node is JSDocSeeTag { return node.kind === SyntaxKind.JSDocSeeTag; } +export declare namespace isJSDocSeeTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocSeeTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocSeeTag; +}; + export function isJSDocImplementsTag(node: Node): node is JSDocImplementsTag { return node.kind === SyntaxKind.JSDocImplementsTag; } +export declare namespace isJSDocImplementsTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocImplementsTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocImplementsTag; +}; + export function isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag { return node.kind === SyntaxKind.JSDocAugmentsTag; } +export declare namespace isJSDocAugmentsTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocAugmentsTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocAugmentsTag; +}; + export function isJSDocSatisfiesTag(node: Node): node is JSDocSatisfiesTag { return node.kind === SyntaxKind.JSDocSatisfiesTag; } +export declare namespace isJSDocSatisfiesTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocSatisfiesTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocSatisfiesTag; +}; + export function isJSDocThrowsTag(node: Node): node is JSDocThrowsTag { return node.kind === SyntaxKind.JSDocThrowsTag; } +export declare namespace isJSDocThrowsTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocThrowsTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocThrowsTag; +}; + export function isJSDocThisTag(node: Node): node is JSDocThisTag { return node.kind === SyntaxKind.JSDocThisTag; } +export declare namespace isJSDocThisTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocThisTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocThisTag; +}; + export function isJSDocImportTag(node: Node): node is JSDocImportTag { return node.kind === SyntaxKind.JSDocImportTag; } +export declare namespace isJSDocImportTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocImportTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocImportTag; +}; + export function isJSDocCallbackTag(node: Node): node is JSDocCallbackTag { return node.kind === SyntaxKind.JSDocCallbackTag; } +export declare namespace isJSDocCallbackTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocCallbackTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocCallbackTag; +}; + export function isJSDocOverloadTag(node: Node): node is JSDocOverloadTag { return node.kind === SyntaxKind.JSDocOverloadTag; } +export declare namespace isJSDocOverloadTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocOverloadTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocOverloadTag; +}; + export function isJSDocTypedefTag(node: Node): node is JSDocTypedefTag { return node.kind === SyntaxKind.JSDocTypedefTag; } +export declare namespace isJSDocTypedefTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocTypedefTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocTypedefTag; +}; + export function isJSDocSignature(node: Node): node is JSDocSignature { return node.kind === SyntaxKind.JSDocSignature; } +export declare namespace isJSDocSignature { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocSignature.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocSignature; +}; + export function isJSDocNameReference(node: Node): node is JSDocNameReference { return node.kind === SyntaxKind.JSDocNameReference; } +export declare namespace isJSDocNameReference { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocNameReference.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocNameReference; +}; + export function isSourceFile(node: Node): node is SourceFile { return node.kind === SyntaxKind.SourceFile; } +export declare namespace isSourceFile { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSourceFile.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SourceFile; +}; + export function isModuleDeclaration(node: Node): node is ModuleDeclaration { return node.kind === SyntaxKind.ModuleDeclaration; } +export declare namespace isModuleDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isModuleDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ModuleDeclaration; +}; + export function isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration { return node.kind === SyntaxKind.ImportEqualsDeclaration; } +export declare namespace isImportEqualsDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isImportEqualsDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportEqualsDeclaration; +}; + export function isExportDeclaration(node: Node): node is ExportDeclaration { return node.kind === SyntaxKind.ExportDeclaration; } +export declare namespace isExportDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isExportDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExportDeclaration; +}; + export function isImportTypeNode(node: Node): node is ImportTypeNode { return node.kind === SyntaxKind.ImportType; } +export declare namespace isImportTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isImportTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportType; +}; + export function isImportClause(node: Node): node is ImportClause { return node.kind === SyntaxKind.ImportClause; } +export declare namespace isImportClause { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isImportClause.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportClause; +}; + export function isImportSpecifier(node: Node): node is ImportSpecifier { return node.kind === SyntaxKind.ImportSpecifier; } +export declare namespace isImportSpecifier { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isImportSpecifier.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportSpecifier; +}; + export function isJSDocText(node: Node): node is JSDocText { return node.kind === SyntaxKind.JSDocText; } +export declare namespace isJSDocText { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocText.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocText; +}; + export function isJSDocLink(node: Node): node is JSDocLink { return node.kind === SyntaxKind.JSDocLink; } +export declare namespace isJSDocLink { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocLink.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocLink; +}; + export function isJSDocLinkPlain(node: Node): node is JSDocLinkPlain { return node.kind === SyntaxKind.JSDocLinkPlain; } +export declare namespace isJSDocLinkPlain { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocLinkPlain.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocLinkPlain; +}; + export function isJSDocLinkCode(node: Node): node is JSDocLinkCode { return node.kind === SyntaxKind.JSDocLinkCode; } +export declare namespace isJSDocLinkCode { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocLinkCode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocLinkCode; +}; + export function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration { return node.kind === SyntaxKind.TypeParameter; } +export declare namespace isTypeParameterDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isTypeParameterDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeParameter; +}; + export function isSyntheticReferenceExpression(node: Node): node is SyntheticReferenceExpression { return node.kind === SyntaxKind.SyntheticReferenceExpression; } +export declare namespace isSyntheticReferenceExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isSyntheticReferenceExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SyntheticReferenceExpression; +}; + export function isJSDocTypeLiteral(node: Node): node is JSDocTypeLiteral { return node.kind === SyntaxKind.JSDocTypeLiteral; } +export declare namespace isJSDocTypeLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocTypeLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocTypeLiteral; +}; + export function isForInStatement(node: Node): node is ForInStatement { return node.kind === SyntaxKind.ForInStatement; } +export declare namespace isForInStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isForInStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ForInStatement; +}; + export function isForOfStatement(node: Node): node is ForOfStatement { return node.kind === SyntaxKind.ForOfStatement; } +export declare namespace isForOfStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isForOfStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ForOfStatement; +}; + export function isCaseClause(node: Node): node is CaseClause { return node.kind === SyntaxKind.CaseClause; } +export declare namespace isCaseClause { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isCaseClause.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.CaseClause; +}; + export function isDefaultClause(node: Node): node is DefaultClause { return node.kind === SyntaxKind.DefaultClause; } +export declare namespace isDefaultClause { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isDefaultClause.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DefaultClause; +}; + export function isObjectBindingPattern(node: Node): node is ObjectBindingPattern { return node.kind === SyntaxKind.ObjectBindingPattern; } +export declare namespace isObjectBindingPattern { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isObjectBindingPattern.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ObjectBindingPattern; +}; + export function isArrayBindingPattern(node: Node): node is ArrayBindingPattern { return node.kind === SyntaxKind.ArrayBindingPattern; } +export declare namespace isArrayBindingPattern { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isArrayBindingPattern.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ArrayBindingPattern; +}; + export function isJSDocParameterTag(node: Node): node is JSDocParameterTag { return node.kind === SyntaxKind.JSDocParameterTag; } +export declare namespace isJSDocParameterTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocParameterTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocParameterTag; +}; + export function isJSDocPropertyTag(node: Node): node is JSDocPropertyTag { return node.kind === SyntaxKind.JSDocPropertyTag; } +export declare namespace isJSDocPropertyTag { + function Handle>(node: T): node is SpecializeNodeHandle; +} +isJSDocPropertyTag.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JSDocPropertyTag; +}; + export function isHeritageClauseElement(node: Node): node is HeritageClauseElement { return node.kind === SyntaxKind.ExpressionWithTypeArguments || node.kind === SyntaxKind.TypeReference; } +export declare namespace isHeritageClauseElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isHeritageClauseElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExpressionWithTypeArguments || node.kind === SyntaxKind.TypeReference; +}; + export function isAccessExpression(node: Node): node is AccessExpression { return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression; } +export declare namespace isAccessExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAccessExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression; +}; + export function isDeclarationName(node: Node): node is DeclarationName { const kind = node.kind; return kind === SyntaxKind.Identifier || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.ObjectBindingPattern || kind === SyntaxKind.ArrayBindingPattern || kind === SyntaxKind.ElementAccessExpression; } +export declare namespace isDeclarationName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isDeclarationName.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.Identifier || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.ObjectBindingPattern || kind === SyntaxKind.ArrayBindingPattern || kind === SyntaxKind.ElementAccessExpression; +}; + export function isModuleName(node: Node): node is ModuleName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; } +export declare namespace isModuleName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isModuleName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; +}; + export function isModuleExportName(node: Node): node is ModuleExportName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; } +export declare namespace isModuleExportName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isModuleExportName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; +}; + export function isPropertyName(node: Node): node is PropertyName { const kind = node.kind; return kind === SyntaxKind.Identifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.BigIntLiteral; } +export declare namespace isPropertyName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isPropertyName.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.Identifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.BigIntLiteral; +}; + export function isModuleBody(node: Node): node is ModuleBody { return node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.ModuleDeclaration; } +export declare namespace isModuleBody { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isModuleBody.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.ModuleDeclaration; +}; + export function isJSDocFullName(node: Node): node is JSDocFullName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration; } +export declare namespace isJSDocFullName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isJSDocFullName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration; +}; + export function isModuleReference(node: Node): node is ModuleReference { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.ExternalModuleReference; } +export declare namespace isModuleReference { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isModuleReference.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.ExternalModuleReference; +}; + export function isNamedImportBindings(node: Node): node is NamedImportBindings { return node.kind === SyntaxKind.NamespaceImport || node.kind === SyntaxKind.NamedImports; } +export declare namespace isNamedImportBindings { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isNamedImportBindings.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamespaceImport || node.kind === SyntaxKind.NamedImports; +}; + export function isNamedExportBindings(node: Node): node is NamedExportBindings { return node.kind === SyntaxKind.NamespaceExport || node.kind === SyntaxKind.NamedExports; } +export declare namespace isNamedExportBindings { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isNamedExportBindings.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamespaceExport || node.kind === SyntaxKind.NamedExports; +}; + export function isMemberName(node: Node): node is MemberName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier; } +export declare namespace isMemberName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isMemberName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier; +}; + export function isEntityName(node: Node): node is EntityName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName; } +export declare namespace isEntityName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isEntityName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName; +}; + export function isBindingName(node: Node): node is BindingName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; } +export declare namespace isBindingName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isBindingName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; +}; + export function isModifierLike(node: Node): node is ModifierLike { const kind = node.kind; return kind === SyntaxKind.AbstractKeyword || kind === SyntaxKind.AccessorKeyword || kind === SyntaxKind.AsyncKeyword || kind === SyntaxKind.ConstKeyword || kind === SyntaxKind.DeclareKeyword || kind === SyntaxKind.DefaultKeyword || kind === SyntaxKind.ExportKeyword || kind === SyntaxKind.InKeyword || kind === SyntaxKind.PrivateKeyword || kind === SyntaxKind.ProtectedKeyword || kind === SyntaxKind.PublicKeyword || kind === SyntaxKind.ReadonlyKeyword || kind === SyntaxKind.OutKeyword || kind === SyntaxKind.OverrideKeyword || kind === SyntaxKind.StaticKeyword || kind === SyntaxKind.Decorator; } +export declare namespace isModifierLike { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isModifierLike.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.AbstractKeyword || kind === SyntaxKind.AccessorKeyword || kind === SyntaxKind.AsyncKeyword || kind === SyntaxKind.ConstKeyword || kind === SyntaxKind.DeclareKeyword || kind === SyntaxKind.DefaultKeyword || kind === SyntaxKind.ExportKeyword || kind === SyntaxKind.InKeyword || kind === SyntaxKind.PrivateKeyword || kind === SyntaxKind.ProtectedKeyword || kind === SyntaxKind.PublicKeyword || kind === SyntaxKind.ReadonlyKeyword || kind === SyntaxKind.OutKeyword || kind === SyntaxKind.OverrideKeyword || kind === SyntaxKind.StaticKeyword || kind === SyntaxKind.Decorator; +}; + export function isJsxChild(node: Node): node is JsxChild { const kind = node.kind; return kind === SyntaxKind.JsxText || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment; } +export declare namespace isJsxChild { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isJsxChild.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.JsxText || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment; +}; + export function isJsxAttributeLike(node: Node): node is JsxAttributeLike { return node.kind === SyntaxKind.JsxAttribute || node.kind === SyntaxKind.JsxSpreadAttribute; } +export declare namespace isJsxAttributeLike { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isJsxAttributeLike.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxAttribute || node.kind === SyntaxKind.JsxSpreadAttribute; +}; + export function isJsxAttributeName(node: Node): node is JsxAttributeName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.JsxNamespacedName; } +export declare namespace isJsxAttributeName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isJsxAttributeName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.JsxNamespacedName; +}; + export function isJsxAttributeValue(node: Node): node is JsxAttributeValue { const kind = node.kind; return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment; } +export declare namespace isJsxAttributeValue { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isJsxAttributeValue.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment; +}; + export function isClassLikeDeclaration(node: Node): node is ClassLikeDeclaration { return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression; } +export declare namespace isClassLikeDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isClassLikeDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression; +}; + export function isAccessorDeclaration(node: Node): node is AccessorDeclaration { return node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor; } +export declare namespace isAccessorDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAccessorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor; +}; + export function isLiteralLikeNode(node: Node): node is LiteralLikeNode { const kind = node.kind; return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail || kind === SyntaxKind.JsxText; } +export declare namespace isLiteralLikeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail || kind === SyntaxKind.JsxText; +}; + export function isLiteralExpression(node: Node): node is LiteralExpression { const kind = node.kind; return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; } +export declare namespace isLiteralExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isLiteralExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; +}; + export function isUnionOrIntersectionTypeNode(node: Node): node is UnionOrIntersectionTypeNode { return node.kind === SyntaxKind.UnionType || node.kind === SyntaxKind.IntersectionType; } +export declare namespace isUnionOrIntersectionTypeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isUnionOrIntersectionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.UnionType || node.kind === SyntaxKind.IntersectionType; +}; + export function isTemplateLiteralLikeNode(node: Node): node is TemplateLiteralLikeNode { const kind = node.kind; return isPseudoLiteralKind(kind); } +export declare namespace isTemplateLiteralLikeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isTemplateLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return isPseudoLiteralKind(kind); +}; + export function isTemplateMiddleOrTail(node: Node): node is TemplateMiddleOrTail { return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail; } +export declare namespace isTemplateMiddleOrTail { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isTemplateMiddleOrTail.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail; +}; + export function isTemplateLiteral(node: Node): node is TemplateLiteral { return node.kind === SyntaxKind.TemplateExpression || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; } +export declare namespace isTemplateLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isTemplateLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TemplateExpression || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; +}; + export function isTypePredicateParameterName(node: Node): node is TypePredicateParameterName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType; } +export declare namespace isTypePredicateParameterName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isTypePredicateParameterName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType; +}; + export function isImportAttributeName(node: Node): node is ImportAttributeName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; } +export declare namespace isImportAttributeName { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isImportAttributeName.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; +}; + export function isJSDocComment(node: Node): node is JSDocComment { const kind = node.kind; return kind === SyntaxKind.JSDocText || kind === SyntaxKind.JSDocLink || kind === SyntaxKind.JSDocLinkCode || kind === SyntaxKind.JSDocLinkPlain; } +export declare namespace isJSDocComment { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isJSDocComment.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.JSDocText || kind === SyntaxKind.JSDocLink || kind === SyntaxKind.JSDocLinkCode || kind === SyntaxKind.JSDocLinkPlain; +}; + export function isSignatureDeclaration(node: Node): node is SignatureDeclaration { const kind = node.kind; return kind === SyntaxKind.CallSignature || kind === SyntaxKind.ConstructSignature || kind === SyntaxKind.MethodSignature || kind === SyntaxKind.IndexSignature || kind === SyntaxKind.FunctionType || kind === SyntaxKind.ConstructorType || kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.Constructor || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction; } +export declare namespace isSignatureDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.CallSignature || kind === SyntaxKind.ConstructSignature || kind === SyntaxKind.MethodSignature || kind === SyntaxKind.IndexSignature || kind === SyntaxKind.FunctionType || kind === SyntaxKind.ConstructorType || kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.Constructor || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction; +}; + export function isStringLiteralLikeNode(node: Node): node is StringLiteralLikeNode { return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; } +export declare namespace isStringLiteralLikeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isStringLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; +}; + export function isNumericOrStringLikeLiteral(node: Node): node is NumericOrStringLikeLiteral { return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.NumericLiteral; } +export declare namespace isNumericOrStringLikeLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isNumericOrStringLikeLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.NumericLiteral; +}; + export function isObjectLiteralLikeNode(node: Node): node is ObjectLiteralLikeNode { return node.kind === SyntaxKind.ObjectLiteralExpression || node.kind === SyntaxKind.ObjectBindingPattern; } +export declare namespace isObjectLiteralLikeNode { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isObjectLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ObjectLiteralExpression || node.kind === SyntaxKind.ObjectBindingPattern; +}; + export function isObjectTypeDeclaration(node: Node): node is ObjectTypeDeclaration { const kind = node.kind; return kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.ClassExpression || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeLiteral; -} +} + +export declare namespace isObjectTypeDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isObjectTypeDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.ClassExpression || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeLiteral; +}; export function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement { return node.kind === SyntaxKind.JsxOpeningElement || node.kind === SyntaxKind.JsxSelfClosingElement; } +export declare namespace isJsxOpeningLikeElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isJsxOpeningLikeElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.JsxOpeningElement || node.kind === SyntaxKind.JsxSelfClosingElement; +}; + export function isNamedImportsOrExports(node: Node): node is NamedImportsOrExports { return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports; } +export declare namespace isNamedImportsOrExports { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isNamedImportsOrExports.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports; +}; + export function isBreakOrContinueStatement(node: Node): node is BreakOrContinueStatement { return node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement; } +export declare namespace isBreakOrContinueStatement { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isBreakOrContinueStatement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement; +}; + export function isCallLikeExpression(node: Node): node is CallLikeExpression { const kind = node.kind; return kind === SyntaxKind.CallExpression || kind === SyntaxKind.NewExpression || kind === SyntaxKind.TaggedTemplateExpression || kind === SyntaxKind.Decorator || kind === SyntaxKind.JsxOpeningElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.BinaryExpression; } +export declare namespace isCallLikeExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isCallLikeExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.CallExpression || kind === SyntaxKind.NewExpression || kind === SyntaxKind.TaggedTemplateExpression || kind === SyntaxKind.Decorator || kind === SyntaxKind.JsxOpeningElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.BinaryExpression; +}; + export function isFunctionLikeDeclaration(node: Node): node is FunctionLikeDeclaration { const kind = node.kind; return kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.Constructor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction; } +export declare namespace isFunctionLikeDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isFunctionLikeDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.Constructor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction; +}; + export function isVariableOrParameterDeclaration(node: Node): node is VariableOrParameterDeclaration { return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.Parameter; } +export declare namespace isVariableOrParameterDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isVariableOrParameterDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.Parameter; +}; + export function isVariableOrPropertyDeclaration(node: Node): node is VariableOrPropertyDeclaration { return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.PropertyDeclaration; } +export declare namespace isVariableOrPropertyDeclaration { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isVariableOrPropertyDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.PropertyDeclaration; +}; + export function isCallOrNewExpression(node: Node): node is CallOrNewExpression { return node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.NewExpression; } +export declare namespace isCallOrNewExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isCallOrNewExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.NewExpression; +}; + export function isImportClauseOrBindingPattern(node: Node): node is ImportClauseOrBindingPattern { return node.kind === SyntaxKind.ImportClause || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; } +export declare namespace isImportClauseOrBindingPattern { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isImportClauseOrBindingPattern.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportClause || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; +}; + export function isAnyImportSyntax(node: Node): node is AnyImportSyntax { return node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.JSImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration; } +export declare namespace isAnyImportSyntax { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAnyImportSyntax.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.JSImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration; +}; + export function isArrayBindingElement(node: Node): node is ArrayBindingElement { return node.kind === SyntaxKind.BindingElement || node.kind === SyntaxKind.OmittedExpression; } +export declare namespace isArrayBindingElement { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isArrayBindingElement.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BindingElement || node.kind === SyntaxKind.OmittedExpression; +}; + export function isAssertionExpression(node: Node): node is AssertionExpression { return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression; } +export declare namespace isAssertionExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAssertionExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression; +}; + export function isBooleanLiteral(node: Node): node is BooleanLiteral { return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword; } +export declare namespace isBooleanLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isBooleanLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword; +}; + export function isDestructuringAssignment(node: Node): node is DestructuringAssignment { return node.kind === SyntaxKind.BinaryExpression; } +export declare namespace isDestructuringAssignment { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isDestructuringAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BinaryExpression; +}; + export function isLiteralToken(node: Node): node is LiteralToken { const kind = node.kind; return kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxText || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; } +export declare namespace isLiteralToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isLiteralToken.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxText || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; +}; + export function isModifier(node: Node): node is Modifier { const kind = node.kind; return isModifierKind(kind); } +export declare namespace isModifier { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isModifier.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return isModifierKind(kind); +}; + export function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike { const kind = node.kind; return kind === SyntaxKind.PropertyAssignment || kind === SyntaxKind.ShorthandPropertyAssignment || kind === SyntaxKind.SpreadAssignment || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor; } +export declare namespace isObjectLiteralElementLike { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isObjectLiteralElementLike.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.PropertyAssignment || kind === SyntaxKind.ShorthandPropertyAssignment || kind === SyntaxKind.SpreadAssignment || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor; +}; + export function isPropertyNameLiteral(node: Node): node is PropertyNameLiteral { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral; } +export declare namespace isPropertyNameLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isPropertyNameLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral; +}; + export function isPseudoLiteralToken(node: Node): node is PseudoLiteralToken { const kind = node.kind; return isPseudoLiteralKind(kind); } +export declare namespace isPseudoLiteralToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isPseudoLiteralToken.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return isPseudoLiteralKind(kind); +}; + export function isTemplateLiteralToken(node: Node): node is TemplateLiteralToken { const kind = node.kind; return kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail; } +export declare namespace isTemplateLiteralToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isTemplateLiteralToken.Handle = >(node: T): node is SpecializeNodeHandle => { + const kind = node.kind; + return kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail; +}; + export function isArrayDestructuringAssignment(node: Node): node is ArrayDestructuringAssignment { return node.kind === SyntaxKind.BinaryExpression; } +export declare namespace isArrayDestructuringAssignment { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isArrayDestructuringAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BinaryExpression; +}; + export function isObjectDestructuringAssignment(node: Node): node is ObjectDestructuringAssignment { return node.kind === SyntaxKind.BinaryExpression; } +export declare namespace isObjectDestructuringAssignment { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isObjectDestructuringAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.BinaryExpression; +}; + export function isFunctionBody(node: Node): node is FunctionBody { return node.kind === SyntaxKind.Block; } +export declare namespace isFunctionBody { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isFunctionBody.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.Block; +}; + export function isTriviaKind(kind: SyntaxKind): kind is TriviaSyntaxKind { return kind === SyntaxKind.SingleLineCommentTrivia || kind === SyntaxKind.MultiLineCommentTrivia @@ -1605,154 +3475,466 @@ export function isEndOfFile(node: Node): node is EndOfFile { return node.kind === SyntaxKind.EndOfFile; } +export declare namespace isEndOfFile { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isEndOfFile.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.EndOfFile; +}; + export function isDotToken(node: Node): node is DotToken { return node.kind === SyntaxKind.DotToken; } +export declare namespace isDotToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isDotToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DotToken; +}; + export function isDotDotDotToken(node: Node): node is DotDotDotToken { return node.kind === SyntaxKind.DotDotDotToken; } +export declare namespace isDotDotDotToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isDotDotDotToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DotDotDotToken; +}; + export function isQuestionToken(node: Node): node is QuestionToken { return node.kind === SyntaxKind.QuestionToken; } +export declare namespace isQuestionToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isQuestionToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.QuestionToken; +}; + export function isExclamationToken(node: Node): node is ExclamationToken { return node.kind === SyntaxKind.ExclamationToken; } +export declare namespace isExclamationToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isExclamationToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExclamationToken; +}; + export function isColonToken(node: Node): node is ColonToken { return node.kind === SyntaxKind.ColonToken; } +export declare namespace isColonToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isColonToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ColonToken; +}; + export function isEqualsToken(node: Node): node is EqualsToken { return node.kind === SyntaxKind.EqualsToken; } +export declare namespace isEqualsToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isEqualsToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.EqualsToken; +}; + export function isAsteriskToken(node: Node): node is AsteriskToken { return node.kind === SyntaxKind.AsteriskToken; } +export declare namespace isAsteriskToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAsteriskToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AsteriskToken; +}; + export function isEqualsGreaterThanToken(node: Node): node is EqualsGreaterThanToken { return node.kind === SyntaxKind.EqualsGreaterThanToken; } +export declare namespace isEqualsGreaterThanToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isEqualsGreaterThanToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.EqualsGreaterThanToken; +}; + export function isPlusToken(node: Node): node is PlusToken { return node.kind === SyntaxKind.PlusToken; } +export declare namespace isPlusToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isPlusToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PlusToken; +}; + export function isMinusToken(node: Node): node is MinusToken { return node.kind === SyntaxKind.MinusToken; } +export declare namespace isMinusToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isMinusToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.MinusToken; +}; + export function isQuestionDotToken(node: Node): node is QuestionDotToken { return node.kind === SyntaxKind.QuestionDotToken; } +export declare namespace isQuestionDotToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isQuestionDotToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.QuestionDotToken; +}; + export function isAssertsKeyword(node: Node): node is AssertsKeyword { return node.kind === SyntaxKind.AssertsKeyword; } +export declare namespace isAssertsKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAssertsKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AssertsKeyword; +}; + export function isAssertKeyword(node: Node): node is AssertKeyword { return node.kind === SyntaxKind.AssertKeyword; } +export declare namespace isAssertKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAssertKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AssertKeyword; +}; + export function isAwaitKeyword(node: Node): node is AwaitKeyword { return node.kind === SyntaxKind.AwaitKeyword; } +export declare namespace isAwaitKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAwaitKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AwaitKeyword; +}; + export function isCaseKeyword(node: Node): node is CaseKeyword { return node.kind === SyntaxKind.CaseKeyword; } +export declare namespace isCaseKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isCaseKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.CaseKeyword; +}; + export function isAbstractKeyword(node: Node): node is AbstractKeyword { return node.kind === SyntaxKind.AbstractKeyword; } +export declare namespace isAbstractKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAbstractKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AbstractKeyword; +}; + export function isAccessorKeyword(node: Node): node is AccessorKeyword { return node.kind === SyntaxKind.AccessorKeyword; } +export declare namespace isAccessorKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAccessorKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AccessorKeyword; +}; + export function isAsyncKeyword(node: Node): node is AsyncKeyword { return node.kind === SyntaxKind.AsyncKeyword; } +export declare namespace isAsyncKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAsyncKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.AsyncKeyword; +}; + export function isConstKeyword(node: Node): node is ConstKeyword { return node.kind === SyntaxKind.ConstKeyword; } +export declare namespace isConstKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isConstKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ConstKeyword; +}; + export function isDeclareKeyword(node: Node): node is DeclareKeyword { return node.kind === SyntaxKind.DeclareKeyword; } +export declare namespace isDeclareKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isDeclareKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DeclareKeyword; +}; + export function isDefaultKeyword(node: Node): node is DefaultKeyword { return node.kind === SyntaxKind.DefaultKeyword; } +export declare namespace isDefaultKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isDefaultKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.DefaultKeyword; +}; + export function isExportKeyword(node: Node): node is ExportKeyword { return node.kind === SyntaxKind.ExportKeyword; } +export declare namespace isExportKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isExportKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ExportKeyword; +}; + export function isInKeyword(node: Node): node is InKeyword { return node.kind === SyntaxKind.InKeyword; } +export declare namespace isInKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isInKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.InKeyword; +}; + export function isPrivateKeyword(node: Node): node is PrivateKeyword { return node.kind === SyntaxKind.PrivateKeyword; } +export declare namespace isPrivateKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isPrivateKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PrivateKeyword; +}; + export function isProtectedKeyword(node: Node): node is ProtectedKeyword { return node.kind === SyntaxKind.ProtectedKeyword; } +export declare namespace isProtectedKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isProtectedKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ProtectedKeyword; +}; + export function isPublicKeyword(node: Node): node is PublicKeyword { return node.kind === SyntaxKind.PublicKeyword; } +export declare namespace isPublicKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isPublicKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.PublicKeyword; +}; + export function isReadonlyKeyword(node: Node): node is ReadonlyKeyword { return node.kind === SyntaxKind.ReadonlyKeyword; } +export declare namespace isReadonlyKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isReadonlyKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ReadonlyKeyword; +}; + export function isOutKeyword(node: Node): node is OutKeyword { return node.kind === SyntaxKind.OutKeyword; } +export declare namespace isOutKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isOutKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.OutKeyword; +}; + export function isOverrideKeyword(node: Node): node is OverrideKeyword { return node.kind === SyntaxKind.OverrideKeyword; } +export declare namespace isOverrideKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isOverrideKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.OverrideKeyword; +}; + export function isStaticKeyword(node: Node): node is StaticKeyword { return node.kind === SyntaxKind.StaticKeyword; } +export declare namespace isStaticKeyword { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isStaticKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.StaticKeyword; +}; + export function isBinaryOperatorToken(node: Node): node is BinaryOperatorToken { return isBinaryOperator(node.kind); } +export declare namespace isBinaryOperatorToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isBinaryOperatorToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return isBinaryOperator(node.kind); +}; + export function isAssignmentOperatorToken(node: Node): node is AssignmentOperatorToken { return isAssignmentOperator(node.kind); } +export declare namespace isAssignmentOperatorToken { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isAssignmentOperatorToken.Handle = >(node: T): node is SpecializeNodeHandle => { + return isAssignmentOperator(node.kind); +}; + export function isNullLiteral(node: Node): node is NullLiteral { return node.kind === SyntaxKind.NullKeyword; } +export declare namespace isNullLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isNullLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.NullKeyword; +}; + export function isTrueLiteral(node: Node): node is TrueLiteral { return node.kind === SyntaxKind.TrueKeyword; } +export declare namespace isTrueLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isTrueLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.TrueKeyword; +}; + export function isFalseLiteral(node: Node): node is FalseLiteral { return node.kind === SyntaxKind.FalseKeyword; } +export declare namespace isFalseLiteral { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isFalseLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.FalseKeyword; +}; + export function isThisExpression(node: Node): node is ThisExpression { return node.kind === SyntaxKind.ThisKeyword; } +export declare namespace isThisExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isThisExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ThisKeyword; +}; + export function isSuperExpression(node: Node): node is SuperExpression { return node.kind === SyntaxKind.SuperKeyword; } +export declare namespace isSuperExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isSuperExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.SuperKeyword; +}; + export function isImportExpression(node: Node): node is ImportExpression { return node.kind === SyntaxKind.ImportKeyword; } + +export declare namespace isImportExpression { + function Handle>(node: T): node is SpecializeNodeHandle; +} + +isImportExpression.Handle = >(node: T): node is SpecializeNodeHandle => { + return node.kind === SyntaxKind.ImportKeyword; +}; diff --git a/_packages/native-preview/test/async/api.test.ts b/_packages/native-preview/test/async/api.test.ts index ce4e6f53af3..739936cd63e 100644 --- a/_packages/native-preview/test/async/api.test.ts +++ b/_packages/native-preview/test/async/api.test.ts @@ -81,6 +81,7 @@ import { } from "node:test"; import { fileURLToPath } from "node:url"; import { runBenchmarks } from "./api.bench.ts"; +import { isSignatureDeclaration } from "../../src/ast/is.ts"; const defaultFiles = { "/tsconfig.json": "{}", @@ -1531,11 +1532,16 @@ export class Cache { assert.ok(callSigs.length > 0); const sig = callSigs[0]; assert.ok(sig.declaration); + assert.ok(isSignatureDeclaration.Handle(sig.declaration)) const node = await sig.declaration.resolve(project); assert.ok(node); + assert.ok(node.parameters); + assert.ok(isSignatureDeclaration(node)); // The handle remembers its canonical project, so resolve() works without an argument. const nodeFromCanonical = await sig.declaration.resolve(); assert.ok(nodeFromCanonical); + assert.ok(nodeFromCanonical.parameters); + assert.ok(isSignatureDeclaration(nodeFromCanonical)); assert.strictEqual(nodeFromCanonical.kind, node.kind); const methodPos = src.indexOf("getValue"); diff --git a/_packages/native-preview/test/sync/api.test.ts b/_packages/native-preview/test/sync/api.test.ts index 9fe20fb9192..cb0430ad6f2 100644 --- a/_packages/native-preview/test/sync/api.test.ts +++ b/_packages/native-preview/test/sync/api.test.ts @@ -88,6 +88,7 @@ import { test, } from "node:test"; import { fileURLToPath } from "node:url"; +import { isSignatureDeclaration } from "../../src/ast/is.ts"; import { runBenchmarks } from "./api.bench.ts"; const defaultFiles = { @@ -1539,11 +1540,16 @@ export class Cache { assert.ok(callSigs.length > 0); const sig = callSigs[0]; assert.ok(sig.declaration); + assert.ok(isSignatureDeclaration.Handle(sig.declaration)); const node = sig.declaration.resolve(project); assert.ok(node); + assert.ok(node.parameters); + assert.ok(isSignatureDeclaration(node)); // The handle remembers its canonical project, so resolve() works without an argument. const nodeFromCanonical = sig.declaration.resolve(); assert.ok(nodeFromCanonical); + assert.ok(nodeFromCanonical.parameters); + assert.ok(isSignatureDeclaration(nodeFromCanonical)); assert.strictEqual(nodeFromCanonical.kind, node.kind); const methodPos = src.indexOf("getValue"); diff --git a/_scripts/generate-ts-ast.ts b/_scripts/generate-ts-ast.ts index 17ff07631b4..7e54e1d7d07 100644 --- a/_scripts/generate-ts-ast.ts +++ b/_scripts/generate-ts-ast.ts @@ -1422,30 +1422,44 @@ function generateIsGenerated(): string { out.push(` ${t},`); } out.push(`} from "./ast.ts";`); + out.push(`import type { NodeHandle as AsyncNodeHandle } from "../api/async/api.ts";`); + out.push(`import type { NodeHandle as SyncNodeHandle } from "../api/sync/api.ts";`); + out.push(`type NodeHandleLike = { kind: SyntaxKind; resolve(...args: any): any; };`); + // Note that we must `& T` to satisfy the requirements of a type guard, and it must be _second_ so the narrowed `resolve` overload from the specialization is selected (order matters) + out.push(`type SpecializeNodeHandle, U extends Node> = T extends AsyncNodeHandle ? AsyncNodeHandle & T : SyncNodeHandle & T;`); out.push(``); // ── Simple guards ── for (const g of guards) { out.push(`export function ${g.funcName}(node: Node): node is ${g.typeName} {`); + const functionContent = [] if (g.kindAliasConstraint) { // Use the kind-level guard for nodes with a kind alias constraint - out.push(` return ${kindGuardName(g.kindAliasConstraint)}(node.kind);`); + functionContent.push(` return ${kindGuardName(g.kindAliasConstraint)}(node.kind);`); } else if (g.kindChecks.length === 1) { - out.push(` return node.kind === ${g.kindChecks[0]};`); + functionContent.push(` return node.kind === ${g.kindChecks[0]};`); } else { - out.push(` switch (node.kind) {`); + functionContent.push(` switch (node.kind) {`); for (const kindCheck of g.kindChecks) { - out.push(` case ${kindCheck}:`); + functionContent.push(` case ${kindCheck}:`); } - out.push(` return true;`); - out.push(` default:`); - out.push(` return false;`); - out.push(` }`); + functionContent.push(` return true;`); + functionContent.push(` default:`); + functionContent.push(` return false;`); + functionContent.push(` }`); } + out.push(...functionContent); out.push(`}`); out.push(``); + out.push(`export declare namespace ${g.funcName} {`); + out.push(` function Handle>(node: T): node is SpecializeNodeHandle;`); + out.push(`}`); + out.push(`${g.funcName}.Handle = >(node: T): node is SpecializeNodeHandle => {`); + out.push(...functionContent); + out.push(`}`) + out.push(``); } // ── Composite guards ── @@ -1454,6 +1468,14 @@ function generateIsGenerated(): string { out.push(` ${g.body}`); out.push(`}`); out.push(``); + out.push(`export declare namespace ${g.funcName} {`); + out.push(` function Handle>(node: T): node is SpecializeNodeHandle;`); + out.push(`}`); + out.push(``); + out.push(`${g.funcName}.Handle = >(node: T): node is SpecializeNodeHandle => {`); + out.push(` ${g.body}`); + out.push(`}`); + out.push(``); } // ── Kind alias guards ── @@ -1480,10 +1502,19 @@ function generateIsGenerated(): string { // ── Token alias guards ── for (const g of tokenAliasGuards) { const returnType = g.isRangeBased ? `boolean` : `node is ${g.typeName}`; + const handleReturnType = g.isRangeBased ? `boolean` : `node is SpecializeNodeHandle`; out.push(`export function ${g.funcName}(node: Node): ${returnType} {`); out.push(` ${g.body}`); out.push(`}`); out.push(``); + out.push(`export declare namespace ${g.funcName} {`); + out.push(` function Handle>(node: T): ${handleReturnType};`); + out.push(`}`); + out.push(``); + out.push(`${g.funcName}.Handle = >(node: T): ${handleReturnType} => {`); + out.push(` ${g.body}`); + out.push(`}`); + out.push(``); } while (out.length > 0 && out[out.length - 1] === "") out.pop(); From 342a1ff0abe16aaa3c1aa92063475b934bca525e Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Wed, 12 Aug 2026 12:42:49 -0700 Subject: [PATCH 2/3] Format --- _packages/native-preview/test/async/api.test.ts | 4 ++-- _scripts/generate-ts-ast.ts | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/_packages/native-preview/test/async/api.test.ts b/_packages/native-preview/test/async/api.test.ts index 739936cd63e..bd0dd86c8b8 100644 --- a/_packages/native-preview/test/async/api.test.ts +++ b/_packages/native-preview/test/async/api.test.ts @@ -80,8 +80,8 @@ import { test, } from "node:test"; import { fileURLToPath } from "node:url"; -import { runBenchmarks } from "./api.bench.ts"; import { isSignatureDeclaration } from "../../src/ast/is.ts"; +import { runBenchmarks } from "./api.bench.ts"; const defaultFiles = { "/tsconfig.json": "{}", @@ -1532,7 +1532,7 @@ export class Cache { assert.ok(callSigs.length > 0); const sig = callSigs[0]; assert.ok(sig.declaration); - assert.ok(isSignatureDeclaration.Handle(sig.declaration)) + assert.ok(isSignatureDeclaration.Handle(sig.declaration)); const node = await sig.declaration.resolve(project); assert.ok(node); assert.ok(node.parameters); diff --git a/_scripts/generate-ts-ast.ts b/_scripts/generate-ts-ast.ts index 7e54e1d7d07..400cf11cd58 100644 --- a/_scripts/generate-ts-ast.ts +++ b/_scripts/generate-ts-ast.ts @@ -1432,7 +1432,7 @@ function generateIsGenerated(): string { // ── Simple guards ── for (const g of guards) { out.push(`export function ${g.funcName}(node: Node): node is ${g.typeName} {`); - const functionContent = [] + const functionContent = []; if (g.kindAliasConstraint) { // Use the kind-level guard for nodes with a kind alias constraint functionContent.push(` return ${kindGuardName(g.kindAliasConstraint)}(node.kind);`); @@ -1458,7 +1458,7 @@ function generateIsGenerated(): string { out.push(`}`); out.push(`${g.funcName}.Handle = >(node: T): node is SpecializeNodeHandle => {`); out.push(...functionContent); - out.push(`}`) + out.push(`}`); out.push(``); } From 62700b5e0b69ec51247e2e185c30a7be255ccd02 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Thu, 13 Aug 2026 10:37:50 -0700 Subject: [PATCH 3/3] Prefer brevity --- .../native-preview/src/ast/is.generated.ts | 1202 ++++------------- _scripts/generate-ts-ast.ts | 30 +- 2 files changed, 304 insertions(+), 928 deletions(-) diff --git a/_packages/native-preview/src/ast/is.generated.ts b/_packages/native-preview/src/ast/is.generated.ts index c91d8178119..5cd47656956 100644 --- a/_packages/native-preview/src/ast/is.generated.ts +++ b/_packages/native-preview/src/ast/is.generated.ts @@ -338,9 +338,7 @@ export function isToken(node: Node): node is Token { export declare namespace isToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return isTokenKind(node.kind); -}; +isToken.Handle = isToken as any; export function isIdentifier(node: Node): node is Identifier { return node.kind === SyntaxKind.Identifier; @@ -349,9 +347,7 @@ export function isIdentifier(node: Node): node is Identifier { export declare namespace isIdentifier { function Handle>(node: T): node is SpecializeNodeHandle; } -isIdentifier.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier; -}; +isIdentifier.Handle = isIdentifier as any; export function isPrivateIdentifier(node: Node): node is PrivateIdentifier { return node.kind === SyntaxKind.PrivateIdentifier; @@ -360,9 +356,7 @@ export function isPrivateIdentifier(node: Node): node is PrivateIdentifier { export declare namespace isPrivateIdentifier { function Handle>(node: T): node is SpecializeNodeHandle; } -isPrivateIdentifier.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PrivateIdentifier; -}; +isPrivateIdentifier.Handle = isPrivateIdentifier as any; export function isQualifiedName(node: Node): node is QualifiedName { return node.kind === SyntaxKind.QualifiedName; @@ -371,9 +365,7 @@ export function isQualifiedName(node: Node): node is QualifiedName { export declare namespace isQualifiedName { function Handle>(node: T): node is SpecializeNodeHandle; } -isQualifiedName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.QualifiedName; -}; +isQualifiedName.Handle = isQualifiedName as any; export function isComputedPropertyName(node: Node): node is ComputedPropertyName { return node.kind === SyntaxKind.ComputedPropertyName; @@ -382,9 +374,7 @@ export function isComputedPropertyName(node: Node): node is ComputedPropertyName export declare namespace isComputedPropertyName { function Handle>(node: T): node is SpecializeNodeHandle; } -isComputedPropertyName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ComputedPropertyName; -}; +isComputedPropertyName.Handle = isComputedPropertyName as any; export function isDecorator(node: Node): node is Decorator { return node.kind === SyntaxKind.Decorator; @@ -393,9 +383,7 @@ export function isDecorator(node: Node): node is Decorator { export declare namespace isDecorator { function Handle>(node: T): node is SpecializeNodeHandle; } -isDecorator.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Decorator; -}; +isDecorator.Handle = isDecorator as any; export function isEmptyStatement(node: Node): node is EmptyStatement { return node.kind === SyntaxKind.EmptyStatement; @@ -404,9 +392,7 @@ export function isEmptyStatement(node: Node): node is EmptyStatement { export declare namespace isEmptyStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isEmptyStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.EmptyStatement; -}; +isEmptyStatement.Handle = isEmptyStatement as any; export function isIfStatement(node: Node): node is IfStatement { return node.kind === SyntaxKind.IfStatement; @@ -415,9 +401,7 @@ export function isIfStatement(node: Node): node is IfStatement { export declare namespace isIfStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isIfStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.IfStatement; -}; +isIfStatement.Handle = isIfStatement as any; export function isDoStatement(node: Node): node is DoStatement { return node.kind === SyntaxKind.DoStatement; @@ -426,9 +410,7 @@ export function isDoStatement(node: Node): node is DoStatement { export declare namespace isDoStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isDoStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DoStatement; -}; +isDoStatement.Handle = isDoStatement as any; export function isWhileStatement(node: Node): node is WhileStatement { return node.kind === SyntaxKind.WhileStatement; @@ -437,9 +419,7 @@ export function isWhileStatement(node: Node): node is WhileStatement { export declare namespace isWhileStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isWhileStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.WhileStatement; -}; +isWhileStatement.Handle = isWhileStatement as any; export function isForStatement(node: Node): node is ForStatement { return node.kind === SyntaxKind.ForStatement; @@ -448,9 +428,7 @@ export function isForStatement(node: Node): node is ForStatement { export declare namespace isForStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isForStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ForStatement; -}; +isForStatement.Handle = isForStatement as any; export function isBreakStatement(node: Node): node is BreakStatement { return node.kind === SyntaxKind.BreakStatement; @@ -459,9 +437,7 @@ export function isBreakStatement(node: Node): node is BreakStatement { export declare namespace isBreakStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isBreakStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BreakStatement; -}; +isBreakStatement.Handle = isBreakStatement as any; export function isContinueStatement(node: Node): node is ContinueStatement { return node.kind === SyntaxKind.ContinueStatement; @@ -470,9 +446,7 @@ export function isContinueStatement(node: Node): node is ContinueStatement { export declare namespace isContinueStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isContinueStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ContinueStatement; -}; +isContinueStatement.Handle = isContinueStatement as any; export function isReturnStatement(node: Node): node is ReturnStatement { return node.kind === SyntaxKind.ReturnStatement; @@ -481,9 +455,7 @@ export function isReturnStatement(node: Node): node is ReturnStatement { export declare namespace isReturnStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isReturnStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ReturnStatement; -}; +isReturnStatement.Handle = isReturnStatement as any; export function isWithStatement(node: Node): node is WithStatement { return node.kind === SyntaxKind.WithStatement; @@ -492,9 +464,7 @@ export function isWithStatement(node: Node): node is WithStatement { export declare namespace isWithStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isWithStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.WithStatement; -}; +isWithStatement.Handle = isWithStatement as any; export function isSwitchStatement(node: Node): node is SwitchStatement { return node.kind === SyntaxKind.SwitchStatement; @@ -503,9 +473,7 @@ export function isSwitchStatement(node: Node): node is SwitchStatement { export declare namespace isSwitchStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isSwitchStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SwitchStatement; -}; +isSwitchStatement.Handle = isSwitchStatement as any; export function isCaseBlock(node: Node): node is CaseBlock { return node.kind === SyntaxKind.CaseBlock; @@ -514,9 +482,7 @@ export function isCaseBlock(node: Node): node is CaseBlock { export declare namespace isCaseBlock { function Handle>(node: T): node is SpecializeNodeHandle; } -isCaseBlock.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.CaseBlock; -}; +isCaseBlock.Handle = isCaseBlock as any; export function isThrowStatement(node: Node): node is ThrowStatement { return node.kind === SyntaxKind.ThrowStatement; @@ -525,9 +491,7 @@ export function isThrowStatement(node: Node): node is ThrowStatement { export declare namespace isThrowStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isThrowStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ThrowStatement; -}; +isThrowStatement.Handle = isThrowStatement as any; export function isTryStatement(node: Node): node is TryStatement { return node.kind === SyntaxKind.TryStatement; @@ -536,9 +500,7 @@ export function isTryStatement(node: Node): node is TryStatement { export declare namespace isTryStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isTryStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TryStatement; -}; +isTryStatement.Handle = isTryStatement as any; export function isCatchClause(node: Node): node is CatchClause { return node.kind === SyntaxKind.CatchClause; @@ -547,9 +509,7 @@ export function isCatchClause(node: Node): node is CatchClause { export declare namespace isCatchClause { function Handle>(node: T): node is SpecializeNodeHandle; } -isCatchClause.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.CatchClause; -}; +isCatchClause.Handle = isCatchClause as any; export function isDebuggerStatement(node: Node): node is DebuggerStatement { return node.kind === SyntaxKind.DebuggerStatement; @@ -558,9 +518,7 @@ export function isDebuggerStatement(node: Node): node is DebuggerStatement { export declare namespace isDebuggerStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isDebuggerStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DebuggerStatement; -}; +isDebuggerStatement.Handle = isDebuggerStatement as any; export function isLabeledStatement(node: Node): node is LabeledStatement { return node.kind === SyntaxKind.LabeledStatement; @@ -569,9 +527,7 @@ export function isLabeledStatement(node: Node): node is LabeledStatement { export declare namespace isLabeledStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isLabeledStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.LabeledStatement; -}; +isLabeledStatement.Handle = isLabeledStatement as any; export function isExpressionStatement(node: Node): node is ExpressionStatement { return node.kind === SyntaxKind.ExpressionStatement; @@ -580,9 +536,7 @@ export function isExpressionStatement(node: Node): node is ExpressionStatement { export declare namespace isExpressionStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isExpressionStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExpressionStatement; -}; +isExpressionStatement.Handle = isExpressionStatement as any; export function isBlock(node: Node): node is Block { return node.kind === SyntaxKind.Block; @@ -591,9 +545,7 @@ export function isBlock(node: Node): node is Block { export declare namespace isBlock { function Handle>(node: T): node is SpecializeNodeHandle; } -isBlock.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Block; -}; +isBlock.Handle = isBlock as any; export function isVariableStatement(node: Node): node is VariableStatement { return node.kind === SyntaxKind.VariableStatement; @@ -602,9 +554,7 @@ export function isVariableStatement(node: Node): node is VariableStatement { export declare namespace isVariableStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isVariableStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.VariableStatement; -}; +isVariableStatement.Handle = isVariableStatement as any; export function isVariableDeclaration(node: Node): node is VariableDeclaration { return node.kind === SyntaxKind.VariableDeclaration; @@ -613,9 +563,7 @@ export function isVariableDeclaration(node: Node): node is VariableDeclaration { export declare namespace isVariableDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isVariableDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.VariableDeclaration; -}; +isVariableDeclaration.Handle = isVariableDeclaration as any; export function isVariableDeclarationList(node: Node): node is VariableDeclarationList { return node.kind === SyntaxKind.VariableDeclarationList; @@ -624,9 +572,7 @@ export function isVariableDeclarationList(node: Node): node is VariableDeclarati export declare namespace isVariableDeclarationList { function Handle>(node: T): node is SpecializeNodeHandle; } -isVariableDeclarationList.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.VariableDeclarationList; -}; +isVariableDeclarationList.Handle = isVariableDeclarationList as any; export function isParameterDeclaration(node: Node): node is ParameterDeclaration { return node.kind === SyntaxKind.Parameter; @@ -635,9 +581,7 @@ export function isParameterDeclaration(node: Node): node is ParameterDeclaration export declare namespace isParameterDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isParameterDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Parameter; -}; +isParameterDeclaration.Handle = isParameterDeclaration as any; export function isBindingElement(node: Node): node is BindingElement { return node.kind === SyntaxKind.BindingElement; @@ -646,9 +590,7 @@ export function isBindingElement(node: Node): node is BindingElement { export declare namespace isBindingElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isBindingElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BindingElement; -}; +isBindingElement.Handle = isBindingElement as any; export function isMissingDeclaration(node: Node): node is MissingDeclaration { return node.kind === SyntaxKind.MissingDeclaration; @@ -657,9 +599,7 @@ export function isMissingDeclaration(node: Node): node is MissingDeclaration { export declare namespace isMissingDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isMissingDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.MissingDeclaration; -}; +isMissingDeclaration.Handle = isMissingDeclaration as any; export function isFunctionDeclaration(node: Node): node is FunctionDeclaration { return node.kind === SyntaxKind.FunctionDeclaration; @@ -668,9 +608,7 @@ export function isFunctionDeclaration(node: Node): node is FunctionDeclaration { export declare namespace isFunctionDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isFunctionDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.FunctionDeclaration; -}; +isFunctionDeclaration.Handle = isFunctionDeclaration as any; export function isClassDeclaration(node: Node): node is ClassDeclaration { return node.kind === SyntaxKind.ClassDeclaration; @@ -679,9 +617,7 @@ export function isClassDeclaration(node: Node): node is ClassDeclaration { export declare namespace isClassDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isClassDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ClassDeclaration; -}; +isClassDeclaration.Handle = isClassDeclaration as any; export function isClassExpression(node: Node): node is ClassExpression { return node.kind === SyntaxKind.ClassExpression; @@ -690,9 +626,7 @@ export function isClassExpression(node: Node): node is ClassExpression { export declare namespace isClassExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isClassExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ClassExpression; -}; +isClassExpression.Handle = isClassExpression as any; export function isHeritageClause(node: Node): node is HeritageClause { return node.kind === SyntaxKind.HeritageClause; @@ -701,9 +635,7 @@ export function isHeritageClause(node: Node): node is HeritageClause { export declare namespace isHeritageClause { function Handle>(node: T): node is SpecializeNodeHandle; } -isHeritageClause.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.HeritageClause; -}; +isHeritageClause.Handle = isHeritageClause as any; export function isInterfaceDeclaration(node: Node): node is InterfaceDeclaration { return node.kind === SyntaxKind.InterfaceDeclaration; @@ -712,9 +644,7 @@ export function isInterfaceDeclaration(node: Node): node is InterfaceDeclaration export declare namespace isInterfaceDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isInterfaceDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.InterfaceDeclaration; -}; +isInterfaceDeclaration.Handle = isInterfaceDeclaration as any; export function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration { switch (node.kind) { @@ -729,15 +659,7 @@ export function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration export declare namespace isTypeAliasDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeAliasDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - switch (node.kind) { - case SyntaxKind.TypeAliasDeclaration: - case SyntaxKind.JSTypeAliasDeclaration: - return true; - default: - return false; - } -}; +isTypeAliasDeclaration.Handle = isTypeAliasDeclaration as any; export function isEnumMember(node: Node): node is EnumMember { return node.kind === SyntaxKind.EnumMember; @@ -746,9 +668,7 @@ export function isEnumMember(node: Node): node is EnumMember { export declare namespace isEnumMember { function Handle>(node: T): node is SpecializeNodeHandle; } -isEnumMember.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.EnumMember; -}; +isEnumMember.Handle = isEnumMember as any; export function isEnumDeclaration(node: Node): node is EnumDeclaration { return node.kind === SyntaxKind.EnumDeclaration; @@ -757,9 +677,7 @@ export function isEnumDeclaration(node: Node): node is EnumDeclaration { export declare namespace isEnumDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isEnumDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.EnumDeclaration; -}; +isEnumDeclaration.Handle = isEnumDeclaration as any; export function isModuleBlock(node: Node): node is ModuleBlock { return node.kind === SyntaxKind.ModuleBlock; @@ -768,9 +686,7 @@ export function isModuleBlock(node: Node): node is ModuleBlock { export declare namespace isModuleBlock { function Handle>(node: T): node is SpecializeNodeHandle; } -isModuleBlock.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ModuleBlock; -}; +isModuleBlock.Handle = isModuleBlock as any; export function isNotEmittedStatement(node: Node): node is NotEmittedStatement { return node.kind === SyntaxKind.NotEmittedStatement; @@ -779,9 +695,7 @@ export function isNotEmittedStatement(node: Node): node is NotEmittedStatement { export declare namespace isNotEmittedStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isNotEmittedStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NotEmittedStatement; -}; +isNotEmittedStatement.Handle = isNotEmittedStatement as any; export function isNotEmittedTypeElement(node: Node): node is NotEmittedTypeElement { return node.kind === SyntaxKind.NotEmittedTypeElement; @@ -790,9 +704,7 @@ export function isNotEmittedTypeElement(node: Node): node is NotEmittedTypeEleme export declare namespace isNotEmittedTypeElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isNotEmittedTypeElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NotEmittedTypeElement; -}; +isNotEmittedTypeElement.Handle = isNotEmittedTypeElement as any; export function isImportDeclaration(node: Node): node is ImportDeclaration { switch (node.kind) { @@ -807,15 +719,7 @@ export function isImportDeclaration(node: Node): node is ImportDeclaration { export declare namespace isImportDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - switch (node.kind) { - case SyntaxKind.ImportDeclaration: - case SyntaxKind.JSImportDeclaration: - return true; - default: - return false; - } -}; +isImportDeclaration.Handle = isImportDeclaration as any; export function isExternalModuleReference(node: Node): node is ExternalModuleReference { return node.kind === SyntaxKind.ExternalModuleReference; @@ -824,9 +728,7 @@ export function isExternalModuleReference(node: Node): node is ExternalModuleRef export declare namespace isExternalModuleReference { function Handle>(node: T): node is SpecializeNodeHandle; } -isExternalModuleReference.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExternalModuleReference; -}; +isExternalModuleReference.Handle = isExternalModuleReference as any; export function isNamespaceImport(node: Node): node is NamespaceImport { return node.kind === SyntaxKind.NamespaceImport; @@ -835,9 +737,7 @@ export function isNamespaceImport(node: Node): node is NamespaceImport { export declare namespace isNamespaceImport { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamespaceImport.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamespaceImport; -}; +isNamespaceImport.Handle = isNamespaceImport as any; export function isNamedImports(node: Node): node is NamedImports { return node.kind === SyntaxKind.NamedImports; @@ -846,9 +746,7 @@ export function isNamedImports(node: Node): node is NamedImports { export declare namespace isNamedImports { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamedImports.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamedImports; -}; +isNamedImports.Handle = isNamedImports as any; export function isExportAssignment(node: Node): node is ExportAssignment { return node.kind === SyntaxKind.ExportAssignment; @@ -857,9 +755,7 @@ export function isExportAssignment(node: Node): node is ExportAssignment { export declare namespace isExportAssignment { function Handle>(node: T): node is SpecializeNodeHandle; } -isExportAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExportAssignment; -}; +isExportAssignment.Handle = isExportAssignment as any; export function isNamespaceExportDeclaration(node: Node): node is NamespaceExportDeclaration { return node.kind === SyntaxKind.NamespaceExportDeclaration; @@ -868,9 +764,7 @@ export function isNamespaceExportDeclaration(node: Node): node is NamespaceExpor export declare namespace isNamespaceExportDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamespaceExportDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamespaceExportDeclaration; -}; +isNamespaceExportDeclaration.Handle = isNamespaceExportDeclaration as any; export function isNamespaceExport(node: Node): node is NamespaceExport { return node.kind === SyntaxKind.NamespaceExport; @@ -879,9 +773,7 @@ export function isNamespaceExport(node: Node): node is NamespaceExport { export declare namespace isNamespaceExport { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamespaceExport.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamespaceExport; -}; +isNamespaceExport.Handle = isNamespaceExport as any; export function isNamedExports(node: Node): node is NamedExports { return node.kind === SyntaxKind.NamedExports; @@ -890,9 +782,7 @@ export function isNamedExports(node: Node): node is NamedExports { export declare namespace isNamedExports { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamedExports.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamedExports; -}; +isNamedExports.Handle = isNamedExports as any; export function isExportSpecifier(node: Node): node is ExportSpecifier { return node.kind === SyntaxKind.ExportSpecifier; @@ -901,9 +791,7 @@ export function isExportSpecifier(node: Node): node is ExportSpecifier { export declare namespace isExportSpecifier { function Handle>(node: T): node is SpecializeNodeHandle; } -isExportSpecifier.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExportSpecifier; -}; +isExportSpecifier.Handle = isExportSpecifier as any; export function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration { return node.kind === SyntaxKind.CallSignature; @@ -912,9 +800,7 @@ export function isCallSignatureDeclaration(node: Node): node is CallSignatureDec export declare namespace isCallSignatureDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isCallSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.CallSignature; -}; +isCallSignatureDeclaration.Handle = isCallSignatureDeclaration as any; export function isConstructSignatureDeclaration(node: Node): node is ConstructSignatureDeclaration { return node.kind === SyntaxKind.ConstructSignature; @@ -923,9 +809,7 @@ export function isConstructSignatureDeclaration(node: Node): node is ConstructSi export declare namespace isConstructSignatureDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isConstructSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ConstructSignature; -}; +isConstructSignatureDeclaration.Handle = isConstructSignatureDeclaration as any; export function isConstructorDeclaration(node: Node): node is ConstructorDeclaration { return node.kind === SyntaxKind.Constructor; @@ -934,9 +818,7 @@ export function isConstructorDeclaration(node: Node): node is ConstructorDeclara export declare namespace isConstructorDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isConstructorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Constructor; -}; +isConstructorDeclaration.Handle = isConstructorDeclaration as any; export function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration { return node.kind === SyntaxKind.GetAccessor; @@ -945,9 +827,7 @@ export function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclara export declare namespace isGetAccessorDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isGetAccessorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.GetAccessor; -}; +isGetAccessorDeclaration.Handle = isGetAccessorDeclaration as any; export function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration { return node.kind === SyntaxKind.SetAccessor; @@ -956,9 +836,7 @@ export function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclara export declare namespace isSetAccessorDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isSetAccessorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SetAccessor; -}; +isSetAccessorDeclaration.Handle = isSetAccessorDeclaration as any; export function isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration { return node.kind === SyntaxKind.IndexSignature; @@ -967,9 +845,7 @@ export function isIndexSignatureDeclaration(node: Node): node is IndexSignatureD export declare namespace isIndexSignatureDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isIndexSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.IndexSignature; -}; +isIndexSignatureDeclaration.Handle = isIndexSignatureDeclaration as any; export function isMethodSignatureDeclaration(node: Node): node is MethodSignatureDeclaration { return node.kind === SyntaxKind.MethodSignature; @@ -978,9 +854,7 @@ export function isMethodSignatureDeclaration(node: Node): node is MethodSignatur export declare namespace isMethodSignatureDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isMethodSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.MethodSignature; -}; +isMethodSignatureDeclaration.Handle = isMethodSignatureDeclaration as any; export function isMethodDeclaration(node: Node): node is MethodDeclaration { return node.kind === SyntaxKind.MethodDeclaration; @@ -989,9 +863,7 @@ export function isMethodDeclaration(node: Node): node is MethodDeclaration { export declare namespace isMethodDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isMethodDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.MethodDeclaration; -}; +isMethodDeclaration.Handle = isMethodDeclaration as any; export function isPropertySignatureDeclaration(node: Node): node is PropertySignatureDeclaration { return node.kind === SyntaxKind.PropertySignature; @@ -1000,9 +872,7 @@ export function isPropertySignatureDeclaration(node: Node): node is PropertySign export declare namespace isPropertySignatureDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isPropertySignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PropertySignature; -}; +isPropertySignatureDeclaration.Handle = isPropertySignatureDeclaration as any; export function isPropertyDeclaration(node: Node): node is PropertyDeclaration { return node.kind === SyntaxKind.PropertyDeclaration; @@ -1011,9 +881,7 @@ export function isPropertyDeclaration(node: Node): node is PropertyDeclaration { export declare namespace isPropertyDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isPropertyDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PropertyDeclaration; -}; +isPropertyDeclaration.Handle = isPropertyDeclaration as any; export function isSemicolonClassElement(node: Node): node is SemicolonClassElement { return node.kind === SyntaxKind.SemicolonClassElement; @@ -1022,9 +890,7 @@ export function isSemicolonClassElement(node: Node): node is SemicolonClassEleme export declare namespace isSemicolonClassElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isSemicolonClassElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SemicolonClassElement; -}; +isSemicolonClassElement.Handle = isSemicolonClassElement as any; export function isClassStaticBlockDeclaration(node: Node): node is ClassStaticBlockDeclaration { return node.kind === SyntaxKind.ClassStaticBlockDeclaration; @@ -1033,9 +899,7 @@ export function isClassStaticBlockDeclaration(node: Node): node is ClassStaticBl export declare namespace isClassStaticBlockDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isClassStaticBlockDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ClassStaticBlockDeclaration; -}; +isClassStaticBlockDeclaration.Handle = isClassStaticBlockDeclaration as any; export function isOmittedExpression(node: Node): node is OmittedExpression { return node.kind === SyntaxKind.OmittedExpression; @@ -1044,9 +908,7 @@ export function isOmittedExpression(node: Node): node is OmittedExpression { export declare namespace isOmittedExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isOmittedExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.OmittedExpression; -}; +isOmittedExpression.Handle = isOmittedExpression as any; export function isKeywordExpression(node: Node): node is KeywordExpression { return isKeywordExpressionKind(node.kind); @@ -1055,9 +917,7 @@ export function isKeywordExpression(node: Node): node is KeywordExpression { export declare namespace isKeywordExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isKeywordExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return isKeywordExpressionKind(node.kind); -}; +isKeywordExpression.Handle = isKeywordExpression as any; export function isStringLiteral(node: Node): node is StringLiteral { return node.kind === SyntaxKind.StringLiteral; @@ -1066,9 +926,7 @@ export function isStringLiteral(node: Node): node is StringLiteral { export declare namespace isStringLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isStringLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.StringLiteral; -}; +isStringLiteral.Handle = isStringLiteral as any; export function isNumericLiteral(node: Node): node is NumericLiteral { return node.kind === SyntaxKind.NumericLiteral; @@ -1077,9 +935,7 @@ export function isNumericLiteral(node: Node): node is NumericLiteral { export declare namespace isNumericLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isNumericLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NumericLiteral; -}; +isNumericLiteral.Handle = isNumericLiteral as any; export function isBigIntLiteral(node: Node): node is BigIntLiteral { return node.kind === SyntaxKind.BigIntLiteral; @@ -1088,9 +944,7 @@ export function isBigIntLiteral(node: Node): node is BigIntLiteral { export declare namespace isBigIntLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isBigIntLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BigIntLiteral; -}; +isBigIntLiteral.Handle = isBigIntLiteral as any; export function isRegularExpressionLiteral(node: Node): node is RegularExpressionLiteral { return node.kind === SyntaxKind.RegularExpressionLiteral; @@ -1099,9 +953,7 @@ export function isRegularExpressionLiteral(node: Node): node is RegularExpressio export declare namespace isRegularExpressionLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isRegularExpressionLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.RegularExpressionLiteral; -}; +isRegularExpressionLiteral.Handle = isRegularExpressionLiteral as any; export function isNoSubstitutionTemplateLiteral(node: Node): node is NoSubstitutionTemplateLiteral { return node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; @@ -1110,9 +962,7 @@ export function isNoSubstitutionTemplateLiteral(node: Node): node is NoSubstitut export declare namespace isNoSubstitutionTemplateLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isNoSubstitutionTemplateLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; -}; +isNoSubstitutionTemplateLiteral.Handle = isNoSubstitutionTemplateLiteral as any; export function isBinaryExpression(node: Node): node is BinaryExpression { return node.kind === SyntaxKind.BinaryExpression; @@ -1121,9 +971,7 @@ export function isBinaryExpression(node: Node): node is BinaryExpression { export declare namespace isBinaryExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isBinaryExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BinaryExpression; -}; +isBinaryExpression.Handle = isBinaryExpression as any; export function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression { return node.kind === SyntaxKind.PrefixUnaryExpression; @@ -1132,9 +980,7 @@ export function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpressi export declare namespace isPrefixUnaryExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isPrefixUnaryExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PrefixUnaryExpression; -}; +isPrefixUnaryExpression.Handle = isPrefixUnaryExpression as any; export function isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpression { return node.kind === SyntaxKind.PostfixUnaryExpression; @@ -1143,9 +989,7 @@ export function isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpres export declare namespace isPostfixUnaryExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isPostfixUnaryExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PostfixUnaryExpression; -}; +isPostfixUnaryExpression.Handle = isPostfixUnaryExpression as any; export function isYieldExpression(node: Node): node is YieldExpression { return node.kind === SyntaxKind.YieldExpression; @@ -1154,9 +998,7 @@ export function isYieldExpression(node: Node): node is YieldExpression { export declare namespace isYieldExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isYieldExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.YieldExpression; -}; +isYieldExpression.Handle = isYieldExpression as any; export function isArrowFunction(node: Node): node is ArrowFunction { return node.kind === SyntaxKind.ArrowFunction; @@ -1165,9 +1007,7 @@ export function isArrowFunction(node: Node): node is ArrowFunction { export declare namespace isArrowFunction { function Handle>(node: T): node is SpecializeNodeHandle; } -isArrowFunction.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ArrowFunction; -}; +isArrowFunction.Handle = isArrowFunction as any; export function isFunctionExpression(node: Node): node is FunctionExpression { return node.kind === SyntaxKind.FunctionExpression; @@ -1176,9 +1016,7 @@ export function isFunctionExpression(node: Node): node is FunctionExpression { export declare namespace isFunctionExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isFunctionExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.FunctionExpression; -}; +isFunctionExpression.Handle = isFunctionExpression as any; export function isAsExpression(node: Node): node is AsExpression { return node.kind === SyntaxKind.AsExpression; @@ -1187,9 +1025,7 @@ export function isAsExpression(node: Node): node is AsExpression { export declare namespace isAsExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isAsExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AsExpression; -}; +isAsExpression.Handle = isAsExpression as any; export function isSatisfiesExpression(node: Node): node is SatisfiesExpression { return node.kind === SyntaxKind.SatisfiesExpression; @@ -1198,9 +1034,7 @@ export function isSatisfiesExpression(node: Node): node is SatisfiesExpression { export declare namespace isSatisfiesExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isSatisfiesExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SatisfiesExpression; -}; +isSatisfiesExpression.Handle = isSatisfiesExpression as any; export function isConditionalExpression(node: Node): node is ConditionalExpression { return node.kind === SyntaxKind.ConditionalExpression; @@ -1209,9 +1043,7 @@ export function isConditionalExpression(node: Node): node is ConditionalExpressi export declare namespace isConditionalExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isConditionalExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ConditionalExpression; -}; +isConditionalExpression.Handle = isConditionalExpression as any; export function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression { return node.kind === SyntaxKind.PropertyAccessExpression; @@ -1220,9 +1052,7 @@ export function isPropertyAccessExpression(node: Node): node is PropertyAccessEx export declare namespace isPropertyAccessExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isPropertyAccessExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PropertyAccessExpression; -}; +isPropertyAccessExpression.Handle = isPropertyAccessExpression as any; export function isElementAccessExpression(node: Node): node is ElementAccessExpression { return node.kind === SyntaxKind.ElementAccessExpression; @@ -1231,9 +1061,7 @@ export function isElementAccessExpression(node: Node): node is ElementAccessExpr export declare namespace isElementAccessExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isElementAccessExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ElementAccessExpression; -}; +isElementAccessExpression.Handle = isElementAccessExpression as any; export function isCallExpression(node: Node): node is CallExpression { return node.kind === SyntaxKind.CallExpression; @@ -1242,9 +1070,7 @@ export function isCallExpression(node: Node): node is CallExpression { export declare namespace isCallExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isCallExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.CallExpression; -}; +isCallExpression.Handle = isCallExpression as any; export function isNewExpression(node: Node): node is NewExpression { return node.kind === SyntaxKind.NewExpression; @@ -1253,9 +1079,7 @@ export function isNewExpression(node: Node): node is NewExpression { export declare namespace isNewExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isNewExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NewExpression; -}; +isNewExpression.Handle = isNewExpression as any; export function isMetaProperty(node: Node): node is MetaProperty { return node.kind === SyntaxKind.MetaProperty; @@ -1264,9 +1088,7 @@ export function isMetaProperty(node: Node): node is MetaProperty { export declare namespace isMetaProperty { function Handle>(node: T): node is SpecializeNodeHandle; } -isMetaProperty.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.MetaProperty; -}; +isMetaProperty.Handle = isMetaProperty as any; export function isNonNullExpression(node: Node): node is NonNullExpression { return node.kind === SyntaxKind.NonNullExpression; @@ -1275,9 +1097,7 @@ export function isNonNullExpression(node: Node): node is NonNullExpression { export declare namespace isNonNullExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isNonNullExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NonNullExpression; -}; +isNonNullExpression.Handle = isNonNullExpression as any; export function isSpreadElement(node: Node): node is SpreadElement { return node.kind === SyntaxKind.SpreadElement; @@ -1286,9 +1106,7 @@ export function isSpreadElement(node: Node): node is SpreadElement { export declare namespace isSpreadElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isSpreadElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SpreadElement; -}; +isSpreadElement.Handle = isSpreadElement as any; export function isTemplateExpression(node: Node): node is TemplateExpression { return node.kind === SyntaxKind.TemplateExpression; @@ -1297,9 +1115,7 @@ export function isTemplateExpression(node: Node): node is TemplateExpression { export declare namespace isTemplateExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateExpression; -}; +isTemplateExpression.Handle = isTemplateExpression as any; export function isTemplateSpan(node: Node): node is TemplateSpan { return node.kind === SyntaxKind.TemplateSpan; @@ -1308,9 +1124,7 @@ export function isTemplateSpan(node: Node): node is TemplateSpan { export declare namespace isTemplateSpan { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateSpan.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateSpan; -}; +isTemplateSpan.Handle = isTemplateSpan as any; export function isTaggedTemplateExpression(node: Node): node is TaggedTemplateExpression { return node.kind === SyntaxKind.TaggedTemplateExpression; @@ -1319,9 +1133,7 @@ export function isTaggedTemplateExpression(node: Node): node is TaggedTemplateEx export declare namespace isTaggedTemplateExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isTaggedTemplateExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TaggedTemplateExpression; -}; +isTaggedTemplateExpression.Handle = isTaggedTemplateExpression as any; export function isParenthesizedExpression(node: Node): node is ParenthesizedExpression { return node.kind === SyntaxKind.ParenthesizedExpression; @@ -1330,9 +1142,7 @@ export function isParenthesizedExpression(node: Node): node is ParenthesizedExpr export declare namespace isParenthesizedExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isParenthesizedExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ParenthesizedExpression; -}; +isParenthesizedExpression.Handle = isParenthesizedExpression as any; export function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression { return node.kind === SyntaxKind.ArrayLiteralExpression; @@ -1341,9 +1151,7 @@ export function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpres export declare namespace isArrayLiteralExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isArrayLiteralExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ArrayLiteralExpression; -}; +isArrayLiteralExpression.Handle = isArrayLiteralExpression as any; export function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression { return node.kind === SyntaxKind.ObjectLiteralExpression; @@ -1352,9 +1160,7 @@ export function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpr export declare namespace isObjectLiteralExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isObjectLiteralExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ObjectLiteralExpression; -}; +isObjectLiteralExpression.Handle = isObjectLiteralExpression as any; export function isSpreadAssignment(node: Node): node is SpreadAssignment { return node.kind === SyntaxKind.SpreadAssignment; @@ -1363,9 +1169,7 @@ export function isSpreadAssignment(node: Node): node is SpreadAssignment { export declare namespace isSpreadAssignment { function Handle>(node: T): node is SpecializeNodeHandle; } -isSpreadAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SpreadAssignment; -}; +isSpreadAssignment.Handle = isSpreadAssignment as any; export function isPropertyAssignment(node: Node): node is PropertyAssignment { return node.kind === SyntaxKind.PropertyAssignment; @@ -1374,9 +1178,7 @@ export function isPropertyAssignment(node: Node): node is PropertyAssignment { export declare namespace isPropertyAssignment { function Handle>(node: T): node is SpecializeNodeHandle; } -isPropertyAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PropertyAssignment; -}; +isPropertyAssignment.Handle = isPropertyAssignment as any; export function isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment { return node.kind === SyntaxKind.ShorthandPropertyAssignment; @@ -1385,9 +1187,7 @@ export function isShorthandPropertyAssignment(node: Node): node is ShorthandProp export declare namespace isShorthandPropertyAssignment { function Handle>(node: T): node is SpecializeNodeHandle; } -isShorthandPropertyAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ShorthandPropertyAssignment; -}; +isShorthandPropertyAssignment.Handle = isShorthandPropertyAssignment as any; export function isDeleteExpression(node: Node): node is DeleteExpression { return node.kind === SyntaxKind.DeleteExpression; @@ -1396,9 +1196,7 @@ export function isDeleteExpression(node: Node): node is DeleteExpression { export declare namespace isDeleteExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isDeleteExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DeleteExpression; -}; +isDeleteExpression.Handle = isDeleteExpression as any; export function isTypeOfExpression(node: Node): node is TypeOfExpression { return node.kind === SyntaxKind.TypeOfExpression; @@ -1407,9 +1205,7 @@ export function isTypeOfExpression(node: Node): node is TypeOfExpression { export declare namespace isTypeOfExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeOfExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeOfExpression; -}; +isTypeOfExpression.Handle = isTypeOfExpression as any; export function isVoidExpression(node: Node): node is VoidExpression { return node.kind === SyntaxKind.VoidExpression; @@ -1418,9 +1214,7 @@ export function isVoidExpression(node: Node): node is VoidExpression { export declare namespace isVoidExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isVoidExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.VoidExpression; -}; +isVoidExpression.Handle = isVoidExpression as any; export function isAwaitExpression(node: Node): node is AwaitExpression { return node.kind === SyntaxKind.AwaitExpression; @@ -1429,9 +1223,7 @@ export function isAwaitExpression(node: Node): node is AwaitExpression { export declare namespace isAwaitExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isAwaitExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AwaitExpression; -}; +isAwaitExpression.Handle = isAwaitExpression as any; export function isTypeAssertion(node: Node): node is TypeAssertion { return node.kind === SyntaxKind.TypeAssertionExpression; @@ -1440,9 +1232,7 @@ export function isTypeAssertion(node: Node): node is TypeAssertion { export declare namespace isTypeAssertion { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeAssertion.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeAssertionExpression; -}; +isTypeAssertion.Handle = isTypeAssertion as any; export function isKeywordTypeNode(node: Node): node is KeywordTypeNode { return isKeywordTypeKind(node.kind); @@ -1451,9 +1241,7 @@ export function isKeywordTypeNode(node: Node): node is KeywordTypeNode { export declare namespace isKeywordTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isKeywordTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return isKeywordTypeKind(node.kind); -}; +isKeywordTypeNode.Handle = isKeywordTypeNode as any; export function isUnionTypeNode(node: Node): node is UnionTypeNode { return node.kind === SyntaxKind.UnionType; @@ -1462,9 +1250,7 @@ export function isUnionTypeNode(node: Node): node is UnionTypeNode { export declare namespace isUnionTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isUnionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.UnionType; -}; +isUnionTypeNode.Handle = isUnionTypeNode as any; export function isIntersectionTypeNode(node: Node): node is IntersectionTypeNode { return node.kind === SyntaxKind.IntersectionType; @@ -1473,9 +1259,7 @@ export function isIntersectionTypeNode(node: Node): node is IntersectionTypeNode export declare namespace isIntersectionTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isIntersectionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.IntersectionType; -}; +isIntersectionTypeNode.Handle = isIntersectionTypeNode as any; export function isConditionalTypeNode(node: Node): node is ConditionalTypeNode { return node.kind === SyntaxKind.ConditionalType; @@ -1484,9 +1268,7 @@ export function isConditionalTypeNode(node: Node): node is ConditionalTypeNode { export declare namespace isConditionalTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isConditionalTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ConditionalType; -}; +isConditionalTypeNode.Handle = isConditionalTypeNode as any; export function isTypeOperatorNode(node: Node): node is TypeOperatorNode { return node.kind === SyntaxKind.TypeOperator; @@ -1495,9 +1277,7 @@ export function isTypeOperatorNode(node: Node): node is TypeOperatorNode { export declare namespace isTypeOperatorNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeOperatorNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeOperator; -}; +isTypeOperatorNode.Handle = isTypeOperatorNode as any; export function isInferTypeNode(node: Node): node is InferTypeNode { return node.kind === SyntaxKind.InferType; @@ -1506,9 +1286,7 @@ export function isInferTypeNode(node: Node): node is InferTypeNode { export declare namespace isInferTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isInferTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.InferType; -}; +isInferTypeNode.Handle = isInferTypeNode as any; export function isArrayTypeNode(node: Node): node is ArrayTypeNode { return node.kind === SyntaxKind.ArrayType; @@ -1517,9 +1295,7 @@ export function isArrayTypeNode(node: Node): node is ArrayTypeNode { export declare namespace isArrayTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isArrayTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ArrayType; -}; +isArrayTypeNode.Handle = isArrayTypeNode as any; export function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode { return node.kind === SyntaxKind.IndexedAccessType; @@ -1528,9 +1304,7 @@ export function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNo export declare namespace isIndexedAccessTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isIndexedAccessTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.IndexedAccessType; -}; +isIndexedAccessTypeNode.Handle = isIndexedAccessTypeNode as any; export function isTypeReferenceNode(node: Node): node is TypeReferenceNode { return node.kind === SyntaxKind.TypeReference; @@ -1539,9 +1313,7 @@ export function isTypeReferenceNode(node: Node): node is TypeReferenceNode { export declare namespace isTypeReferenceNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeReferenceNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeReference; -}; +isTypeReferenceNode.Handle = isTypeReferenceNode as any; export function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments { return node.kind === SyntaxKind.ExpressionWithTypeArguments; @@ -1550,9 +1322,7 @@ export function isExpressionWithTypeArguments(node: Node): node is ExpressionWit export declare namespace isExpressionWithTypeArguments { function Handle>(node: T): node is SpecializeNodeHandle; } -isExpressionWithTypeArguments.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExpressionWithTypeArguments; -}; +isExpressionWithTypeArguments.Handle = isExpressionWithTypeArguments as any; export function isLiteralTypeNode(node: Node): node is LiteralTypeNode { return node.kind === SyntaxKind.LiteralType; @@ -1561,9 +1331,7 @@ export function isLiteralTypeNode(node: Node): node is LiteralTypeNode { export declare namespace isLiteralTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isLiteralTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.LiteralType; -}; +isLiteralTypeNode.Handle = isLiteralTypeNode as any; export function isThisTypeNode(node: Node): node is ThisTypeNode { return node.kind === SyntaxKind.ThisType; @@ -1572,9 +1340,7 @@ export function isThisTypeNode(node: Node): node is ThisTypeNode { export declare namespace isThisTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isThisTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ThisType; -}; +isThisTypeNode.Handle = isThisTypeNode as any; export function isTypePredicateNode(node: Node): node is TypePredicateNode { return node.kind === SyntaxKind.TypePredicate; @@ -1583,9 +1349,7 @@ export function isTypePredicateNode(node: Node): node is TypePredicateNode { export declare namespace isTypePredicateNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypePredicateNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypePredicate; -}; +isTypePredicateNode.Handle = isTypePredicateNode as any; export function isImportAttribute(node: Node): node is ImportAttribute { return node.kind === SyntaxKind.ImportAttribute; @@ -1594,9 +1358,7 @@ export function isImportAttribute(node: Node): node is ImportAttribute { export declare namespace isImportAttribute { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportAttribute.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportAttribute; -}; +isImportAttribute.Handle = isImportAttribute as any; export function isImportAttributes(node: Node): node is ImportAttributes { return node.kind === SyntaxKind.ImportAttributes; @@ -1605,9 +1367,7 @@ export function isImportAttributes(node: Node): node is ImportAttributes { export declare namespace isImportAttributes { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportAttributes.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportAttributes; -}; +isImportAttributes.Handle = isImportAttributes as any; export function isTypeQueryNode(node: Node): node is TypeQueryNode { return node.kind === SyntaxKind.TypeQuery; @@ -1616,9 +1376,7 @@ export function isTypeQueryNode(node: Node): node is TypeQueryNode { export declare namespace isTypeQueryNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeQueryNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeQuery; -}; +isTypeQueryNode.Handle = isTypeQueryNode as any; export function isMappedTypeNode(node: Node): node is MappedTypeNode { return node.kind === SyntaxKind.MappedType; @@ -1627,9 +1385,7 @@ export function isMappedTypeNode(node: Node): node is MappedTypeNode { export declare namespace isMappedTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isMappedTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.MappedType; -}; +isMappedTypeNode.Handle = isMappedTypeNode as any; export function isTypeLiteralNode(node: Node): node is TypeLiteralNode { return node.kind === SyntaxKind.TypeLiteral; @@ -1638,9 +1394,7 @@ export function isTypeLiteralNode(node: Node): node is TypeLiteralNode { export declare namespace isTypeLiteralNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeLiteralNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeLiteral; -}; +isTypeLiteralNode.Handle = isTypeLiteralNode as any; export function isTupleTypeNode(node: Node): node is TupleTypeNode { return node.kind === SyntaxKind.TupleType; @@ -1649,9 +1403,7 @@ export function isTupleTypeNode(node: Node): node is TupleTypeNode { export declare namespace isTupleTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTupleTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TupleType; -}; +isTupleTypeNode.Handle = isTupleTypeNode as any; export function isNamedTupleMember(node: Node): node is NamedTupleMember { return node.kind === SyntaxKind.NamedTupleMember; @@ -1660,9 +1412,7 @@ export function isNamedTupleMember(node: Node): node is NamedTupleMember { export declare namespace isNamedTupleMember { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamedTupleMember.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamedTupleMember; -}; +isNamedTupleMember.Handle = isNamedTupleMember as any; export function isOptionalTypeNode(node: Node): node is OptionalTypeNode { return node.kind === SyntaxKind.OptionalType; @@ -1671,9 +1421,7 @@ export function isOptionalTypeNode(node: Node): node is OptionalTypeNode { export declare namespace isOptionalTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isOptionalTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.OptionalType; -}; +isOptionalTypeNode.Handle = isOptionalTypeNode as any; export function isRestTypeNode(node: Node): node is RestTypeNode { return node.kind === SyntaxKind.RestType; @@ -1682,9 +1430,7 @@ export function isRestTypeNode(node: Node): node is RestTypeNode { export declare namespace isRestTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isRestTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.RestType; -}; +isRestTypeNode.Handle = isRestTypeNode as any; export function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode { return node.kind === SyntaxKind.ParenthesizedType; @@ -1693,9 +1439,7 @@ export function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNo export declare namespace isParenthesizedTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isParenthesizedTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ParenthesizedType; -}; +isParenthesizedTypeNode.Handle = isParenthesizedTypeNode as any; export function isFunctionTypeNode(node: Node): node is FunctionTypeNode { return node.kind === SyntaxKind.FunctionType; @@ -1704,9 +1448,7 @@ export function isFunctionTypeNode(node: Node): node is FunctionTypeNode { export declare namespace isFunctionTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isFunctionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.FunctionType; -}; +isFunctionTypeNode.Handle = isFunctionTypeNode as any; export function isConstructorTypeNode(node: Node): node is ConstructorTypeNode { return node.kind === SyntaxKind.ConstructorType; @@ -1715,9 +1457,7 @@ export function isConstructorTypeNode(node: Node): node is ConstructorTypeNode { export declare namespace isConstructorTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isConstructorTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ConstructorType; -}; +isConstructorTypeNode.Handle = isConstructorTypeNode as any; export function isTemplateHead(node: Node): node is TemplateHead { return node.kind === SyntaxKind.TemplateHead; @@ -1726,9 +1466,7 @@ export function isTemplateHead(node: Node): node is TemplateHead { export declare namespace isTemplateHead { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateHead.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateHead; -}; +isTemplateHead.Handle = isTemplateHead as any; export function isTemplateMiddle(node: Node): node is TemplateMiddle { return node.kind === SyntaxKind.TemplateMiddle; @@ -1737,9 +1475,7 @@ export function isTemplateMiddle(node: Node): node is TemplateMiddle { export declare namespace isTemplateMiddle { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateMiddle.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateMiddle; -}; +isTemplateMiddle.Handle = isTemplateMiddle as any; export function isTemplateTail(node: Node): node is TemplateTail { return node.kind === SyntaxKind.TemplateTail; @@ -1748,9 +1484,7 @@ export function isTemplateTail(node: Node): node is TemplateTail { export declare namespace isTemplateTail { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateTail.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateTail; -}; +isTemplateTail.Handle = isTemplateTail as any; export function isTemplateLiteralTypeNode(node: Node): node is TemplateLiteralTypeNode { return node.kind === SyntaxKind.TemplateLiteralType; @@ -1759,9 +1493,7 @@ export function isTemplateLiteralTypeNode(node: Node): node is TemplateLiteralTy export declare namespace isTemplateLiteralTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateLiteralTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateLiteralType; -}; +isTemplateLiteralTypeNode.Handle = isTemplateLiteralTypeNode as any; export function isTemplateLiteralTypeSpan(node: Node): node is TemplateLiteralTypeSpan { return node.kind === SyntaxKind.TemplateLiteralTypeSpan; @@ -1770,9 +1502,7 @@ export function isTemplateLiteralTypeSpan(node: Node): node is TemplateLiteralTy export declare namespace isTemplateLiteralTypeSpan { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateLiteralTypeSpan.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateLiteralTypeSpan; -}; +isTemplateLiteralTypeSpan.Handle = isTemplateLiteralTypeSpan as any; export function isSyntheticExpression(node: Node): node is SyntheticExpression { return node.kind === SyntaxKind.SyntheticExpression; @@ -1781,9 +1511,7 @@ export function isSyntheticExpression(node: Node): node is SyntheticExpression { export declare namespace isSyntheticExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isSyntheticExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SyntheticExpression; -}; +isSyntheticExpression.Handle = isSyntheticExpression as any; export function isPartiallyEmittedExpression(node: Node): node is PartiallyEmittedExpression { return node.kind === SyntaxKind.PartiallyEmittedExpression; @@ -1792,9 +1520,7 @@ export function isPartiallyEmittedExpression(node: Node): node is PartiallyEmitt export declare namespace isPartiallyEmittedExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isPartiallyEmittedExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PartiallyEmittedExpression; -}; +isPartiallyEmittedExpression.Handle = isPartiallyEmittedExpression as any; export function isJsxElement(node: Node): node is JsxElement { return node.kind === SyntaxKind.JsxElement; @@ -1803,9 +1529,7 @@ export function isJsxElement(node: Node): node is JsxElement { export declare namespace isJsxElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxElement; -}; +isJsxElement.Handle = isJsxElement as any; export function isJsxAttributes(node: Node): node is JsxAttributes { return node.kind === SyntaxKind.JsxAttributes; @@ -1814,9 +1538,7 @@ export function isJsxAttributes(node: Node): node is JsxAttributes { export declare namespace isJsxAttributes { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxAttributes.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxAttributes; -}; +isJsxAttributes.Handle = isJsxAttributes as any; export function isJsxNamespacedName(node: Node): node is JsxNamespacedName { return node.kind === SyntaxKind.JsxNamespacedName; @@ -1825,9 +1547,7 @@ export function isJsxNamespacedName(node: Node): node is JsxNamespacedName { export declare namespace isJsxNamespacedName { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxNamespacedName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxNamespacedName; -}; +isJsxNamespacedName.Handle = isJsxNamespacedName as any; export function isJsxOpeningElement(node: Node): node is JsxOpeningElement { return node.kind === SyntaxKind.JsxOpeningElement; @@ -1836,9 +1556,7 @@ export function isJsxOpeningElement(node: Node): node is JsxOpeningElement { export declare namespace isJsxOpeningElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxOpeningElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxOpeningElement; -}; +isJsxOpeningElement.Handle = isJsxOpeningElement as any; export function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement { return node.kind === SyntaxKind.JsxSelfClosingElement; @@ -1847,9 +1565,7 @@ export function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingEleme export declare namespace isJsxSelfClosingElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxSelfClosingElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxSelfClosingElement; -}; +isJsxSelfClosingElement.Handle = isJsxSelfClosingElement as any; export function isJsxFragment(node: Node): node is JsxFragment { return node.kind === SyntaxKind.JsxFragment; @@ -1858,9 +1574,7 @@ export function isJsxFragment(node: Node): node is JsxFragment { export declare namespace isJsxFragment { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxFragment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxFragment; -}; +isJsxFragment.Handle = isJsxFragment as any; export function isJsxOpeningFragment(node: Node): node is JsxOpeningFragment { return node.kind === SyntaxKind.JsxOpeningFragment; @@ -1869,9 +1583,7 @@ export function isJsxOpeningFragment(node: Node): node is JsxOpeningFragment { export declare namespace isJsxOpeningFragment { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxOpeningFragment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxOpeningFragment; -}; +isJsxOpeningFragment.Handle = isJsxOpeningFragment as any; export function isJsxClosingFragment(node: Node): node is JsxClosingFragment { return node.kind === SyntaxKind.JsxClosingFragment; @@ -1880,9 +1592,7 @@ export function isJsxClosingFragment(node: Node): node is JsxClosingFragment { export declare namespace isJsxClosingFragment { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxClosingFragment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxClosingFragment; -}; +isJsxClosingFragment.Handle = isJsxClosingFragment as any; export function isJsxAttribute(node: Node): node is JsxAttribute { return node.kind === SyntaxKind.JsxAttribute; @@ -1891,9 +1601,7 @@ export function isJsxAttribute(node: Node): node is JsxAttribute { export declare namespace isJsxAttribute { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxAttribute.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxAttribute; -}; +isJsxAttribute.Handle = isJsxAttribute as any; export function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute { return node.kind === SyntaxKind.JsxSpreadAttribute; @@ -1902,9 +1610,7 @@ export function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute { export declare namespace isJsxSpreadAttribute { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxSpreadAttribute.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxSpreadAttribute; -}; +isJsxSpreadAttribute.Handle = isJsxSpreadAttribute as any; export function isJsxClosingElement(node: Node): node is JsxClosingElement { return node.kind === SyntaxKind.JsxClosingElement; @@ -1913,9 +1619,7 @@ export function isJsxClosingElement(node: Node): node is JsxClosingElement { export declare namespace isJsxClosingElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxClosingElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxClosingElement; -}; +isJsxClosingElement.Handle = isJsxClosingElement as any; export function isJsxExpression(node: Node): node is JsxExpression { return node.kind === SyntaxKind.JsxExpression; @@ -1924,9 +1628,7 @@ export function isJsxExpression(node: Node): node is JsxExpression { export declare namespace isJsxExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxExpression; -}; +isJsxExpression.Handle = isJsxExpression as any; export function isJsxText(node: Node): node is JsxText { return node.kind === SyntaxKind.JsxText; @@ -1935,9 +1637,7 @@ export function isJsxText(node: Node): node is JsxText { export declare namespace isJsxText { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxText.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxText; -}; +isJsxText.Handle = isJsxText as any; export function isSyntaxList(node: Node): node is SyntaxList { return node.kind === SyntaxKind.SyntaxList; @@ -1946,9 +1646,7 @@ export function isSyntaxList(node: Node): node is SyntaxList { export declare namespace isSyntaxList { function Handle>(node: T): node is SpecializeNodeHandle; } -isSyntaxList.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SyntaxList; -}; +isSyntaxList.Handle = isSyntaxList as any; export function isJSDoc(node: Node): node is JSDoc { return node.kind === SyntaxKind.JSDoc; @@ -1957,9 +1655,7 @@ export function isJSDoc(node: Node): node is JSDoc { export declare namespace isJSDoc { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDoc.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDoc; -}; +isJSDoc.Handle = isJSDoc as any; export function isJSDocTypeExpression(node: Node): node is JSDocTypeExpression { return node.kind === SyntaxKind.JSDocTypeExpression; @@ -1968,9 +1664,7 @@ export function isJSDocTypeExpression(node: Node): node is JSDocTypeExpression { export declare namespace isJSDocTypeExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocTypeExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocTypeExpression; -}; +isJSDocTypeExpression.Handle = isJSDocTypeExpression as any; export function isJSDocNonNullableType(node: Node): node is JSDocNonNullableType { return node.kind === SyntaxKind.JSDocNonNullableType; @@ -1979,9 +1673,7 @@ export function isJSDocNonNullableType(node: Node): node is JSDocNonNullableType export declare namespace isJSDocNonNullableType { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocNonNullableType.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocNonNullableType; -}; +isJSDocNonNullableType.Handle = isJSDocNonNullableType as any; export function isJSDocNullableType(node: Node): node is JSDocNullableType { return node.kind === SyntaxKind.JSDocNullableType; @@ -1990,9 +1682,7 @@ export function isJSDocNullableType(node: Node): node is JSDocNullableType { export declare namespace isJSDocNullableType { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocNullableType.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocNullableType; -}; +isJSDocNullableType.Handle = isJSDocNullableType as any; export function isJSDocAllType(node: Node): node is JSDocAllType { return node.kind === SyntaxKind.JSDocAllType; @@ -2001,9 +1691,7 @@ export function isJSDocAllType(node: Node): node is JSDocAllType { export declare namespace isJSDocAllType { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocAllType.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocAllType; -}; +isJSDocAllType.Handle = isJSDocAllType as any; export function isJSDocVariadicType(node: Node): node is JSDocVariadicType { return node.kind === SyntaxKind.JSDocVariadicType; @@ -2012,9 +1700,7 @@ export function isJSDocVariadicType(node: Node): node is JSDocVariadicType { export declare namespace isJSDocVariadicType { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocVariadicType.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocVariadicType; -}; +isJSDocVariadicType.Handle = isJSDocVariadicType as any; export function isJSDocOptionalType(node: Node): node is JSDocOptionalType { return node.kind === SyntaxKind.JSDocOptionalType; @@ -2023,9 +1709,7 @@ export function isJSDocOptionalType(node: Node): node is JSDocOptionalType { export declare namespace isJSDocOptionalType { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocOptionalType.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocOptionalType; -}; +isJSDocOptionalType.Handle = isJSDocOptionalType as any; export function isJSDocTypeTag(node: Node): node is JSDocTypeTag { return node.kind === SyntaxKind.JSDocTypeTag; @@ -2034,9 +1718,7 @@ export function isJSDocTypeTag(node: Node): node is JSDocTypeTag { export declare namespace isJSDocTypeTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocTypeTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocTypeTag; -}; +isJSDocTypeTag.Handle = isJSDocTypeTag as any; export function isJSDocUnknownTag(node: Node): node is JSDocUnknownTag { return node.kind === SyntaxKind.JSDocUnknownTag; @@ -2045,9 +1727,7 @@ export function isJSDocUnknownTag(node: Node): node is JSDocUnknownTag { export declare namespace isJSDocUnknownTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocUnknownTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocUnknownTag; -}; +isJSDocUnknownTag.Handle = isJSDocUnknownTag as any; export function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag { return node.kind === SyntaxKind.JSDocTemplateTag; @@ -2056,9 +1736,7 @@ export function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag { export declare namespace isJSDocTemplateTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocTemplateTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocTemplateTag; -}; +isJSDocTemplateTag.Handle = isJSDocTemplateTag as any; export function isJSDocReturnTag(node: Node): node is JSDocReturnTag { return node.kind === SyntaxKind.JSDocReturnTag; @@ -2067,9 +1745,7 @@ export function isJSDocReturnTag(node: Node): node is JSDocReturnTag { export declare namespace isJSDocReturnTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocReturnTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocReturnTag; -}; +isJSDocReturnTag.Handle = isJSDocReturnTag as any; export function isJSDocPublicTag(node: Node): node is JSDocPublicTag { return node.kind === SyntaxKind.JSDocPublicTag; @@ -2078,9 +1754,7 @@ export function isJSDocPublicTag(node: Node): node is JSDocPublicTag { export declare namespace isJSDocPublicTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocPublicTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocPublicTag; -}; +isJSDocPublicTag.Handle = isJSDocPublicTag as any; export function isJSDocPrivateTag(node: Node): node is JSDocPrivateTag { return node.kind === SyntaxKind.JSDocPrivateTag; @@ -2089,9 +1763,7 @@ export function isJSDocPrivateTag(node: Node): node is JSDocPrivateTag { export declare namespace isJSDocPrivateTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocPrivateTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocPrivateTag; -}; +isJSDocPrivateTag.Handle = isJSDocPrivateTag as any; export function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag { return node.kind === SyntaxKind.JSDocProtectedTag; @@ -2100,9 +1772,7 @@ export function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag { export declare namespace isJSDocProtectedTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocProtectedTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocProtectedTag; -}; +isJSDocProtectedTag.Handle = isJSDocProtectedTag as any; export function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag { return node.kind === SyntaxKind.JSDocReadonlyTag; @@ -2111,9 +1781,7 @@ export function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag { export declare namespace isJSDocReadonlyTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocReadonlyTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocReadonlyTag; -}; +isJSDocReadonlyTag.Handle = isJSDocReadonlyTag as any; export function isJSDocOverrideTag(node: Node): node is JSDocOverrideTag { return node.kind === SyntaxKind.JSDocOverrideTag; @@ -2122,9 +1790,7 @@ export function isJSDocOverrideTag(node: Node): node is JSDocOverrideTag { export declare namespace isJSDocOverrideTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocOverrideTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocOverrideTag; -}; +isJSDocOverrideTag.Handle = isJSDocOverrideTag as any; export function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag { return node.kind === SyntaxKind.JSDocDeprecatedTag; @@ -2133,9 +1799,7 @@ export function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag { export declare namespace isJSDocDeprecatedTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocDeprecatedTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocDeprecatedTag; -}; +isJSDocDeprecatedTag.Handle = isJSDocDeprecatedTag as any; export function isJSDocSeeTag(node: Node): node is JSDocSeeTag { return node.kind === SyntaxKind.JSDocSeeTag; @@ -2144,9 +1808,7 @@ export function isJSDocSeeTag(node: Node): node is JSDocSeeTag { export declare namespace isJSDocSeeTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocSeeTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocSeeTag; -}; +isJSDocSeeTag.Handle = isJSDocSeeTag as any; export function isJSDocImplementsTag(node: Node): node is JSDocImplementsTag { return node.kind === SyntaxKind.JSDocImplementsTag; @@ -2155,9 +1817,7 @@ export function isJSDocImplementsTag(node: Node): node is JSDocImplementsTag { export declare namespace isJSDocImplementsTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocImplementsTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocImplementsTag; -}; +isJSDocImplementsTag.Handle = isJSDocImplementsTag as any; export function isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag { return node.kind === SyntaxKind.JSDocAugmentsTag; @@ -2166,9 +1826,7 @@ export function isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag { export declare namespace isJSDocAugmentsTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocAugmentsTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocAugmentsTag; -}; +isJSDocAugmentsTag.Handle = isJSDocAugmentsTag as any; export function isJSDocSatisfiesTag(node: Node): node is JSDocSatisfiesTag { return node.kind === SyntaxKind.JSDocSatisfiesTag; @@ -2177,9 +1835,7 @@ export function isJSDocSatisfiesTag(node: Node): node is JSDocSatisfiesTag { export declare namespace isJSDocSatisfiesTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocSatisfiesTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocSatisfiesTag; -}; +isJSDocSatisfiesTag.Handle = isJSDocSatisfiesTag as any; export function isJSDocThrowsTag(node: Node): node is JSDocThrowsTag { return node.kind === SyntaxKind.JSDocThrowsTag; @@ -2188,9 +1844,7 @@ export function isJSDocThrowsTag(node: Node): node is JSDocThrowsTag { export declare namespace isJSDocThrowsTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocThrowsTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocThrowsTag; -}; +isJSDocThrowsTag.Handle = isJSDocThrowsTag as any; export function isJSDocThisTag(node: Node): node is JSDocThisTag { return node.kind === SyntaxKind.JSDocThisTag; @@ -2199,9 +1853,7 @@ export function isJSDocThisTag(node: Node): node is JSDocThisTag { export declare namespace isJSDocThisTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocThisTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocThisTag; -}; +isJSDocThisTag.Handle = isJSDocThisTag as any; export function isJSDocImportTag(node: Node): node is JSDocImportTag { return node.kind === SyntaxKind.JSDocImportTag; @@ -2210,9 +1862,7 @@ export function isJSDocImportTag(node: Node): node is JSDocImportTag { export declare namespace isJSDocImportTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocImportTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocImportTag; -}; +isJSDocImportTag.Handle = isJSDocImportTag as any; export function isJSDocCallbackTag(node: Node): node is JSDocCallbackTag { return node.kind === SyntaxKind.JSDocCallbackTag; @@ -2221,9 +1871,7 @@ export function isJSDocCallbackTag(node: Node): node is JSDocCallbackTag { export declare namespace isJSDocCallbackTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocCallbackTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocCallbackTag; -}; +isJSDocCallbackTag.Handle = isJSDocCallbackTag as any; export function isJSDocOverloadTag(node: Node): node is JSDocOverloadTag { return node.kind === SyntaxKind.JSDocOverloadTag; @@ -2232,9 +1880,7 @@ export function isJSDocOverloadTag(node: Node): node is JSDocOverloadTag { export declare namespace isJSDocOverloadTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocOverloadTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocOverloadTag; -}; +isJSDocOverloadTag.Handle = isJSDocOverloadTag as any; export function isJSDocTypedefTag(node: Node): node is JSDocTypedefTag { return node.kind === SyntaxKind.JSDocTypedefTag; @@ -2243,9 +1889,7 @@ export function isJSDocTypedefTag(node: Node): node is JSDocTypedefTag { export declare namespace isJSDocTypedefTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocTypedefTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocTypedefTag; -}; +isJSDocTypedefTag.Handle = isJSDocTypedefTag as any; export function isJSDocSignature(node: Node): node is JSDocSignature { return node.kind === SyntaxKind.JSDocSignature; @@ -2254,9 +1898,7 @@ export function isJSDocSignature(node: Node): node is JSDocSignature { export declare namespace isJSDocSignature { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocSignature.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocSignature; -}; +isJSDocSignature.Handle = isJSDocSignature as any; export function isJSDocNameReference(node: Node): node is JSDocNameReference { return node.kind === SyntaxKind.JSDocNameReference; @@ -2265,9 +1907,7 @@ export function isJSDocNameReference(node: Node): node is JSDocNameReference { export declare namespace isJSDocNameReference { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocNameReference.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocNameReference; -}; +isJSDocNameReference.Handle = isJSDocNameReference as any; export function isSourceFile(node: Node): node is SourceFile { return node.kind === SyntaxKind.SourceFile; @@ -2276,9 +1916,7 @@ export function isSourceFile(node: Node): node is SourceFile { export declare namespace isSourceFile { function Handle>(node: T): node is SpecializeNodeHandle; } -isSourceFile.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SourceFile; -}; +isSourceFile.Handle = isSourceFile as any; export function isModuleDeclaration(node: Node): node is ModuleDeclaration { return node.kind === SyntaxKind.ModuleDeclaration; @@ -2287,9 +1925,7 @@ export function isModuleDeclaration(node: Node): node is ModuleDeclaration { export declare namespace isModuleDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isModuleDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ModuleDeclaration; -}; +isModuleDeclaration.Handle = isModuleDeclaration as any; export function isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration { return node.kind === SyntaxKind.ImportEqualsDeclaration; @@ -2298,9 +1934,7 @@ export function isImportEqualsDeclaration(node: Node): node is ImportEqualsDecla export declare namespace isImportEqualsDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportEqualsDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportEqualsDeclaration; -}; +isImportEqualsDeclaration.Handle = isImportEqualsDeclaration as any; export function isExportDeclaration(node: Node): node is ExportDeclaration { return node.kind === SyntaxKind.ExportDeclaration; @@ -2309,9 +1943,7 @@ export function isExportDeclaration(node: Node): node is ExportDeclaration { export declare namespace isExportDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isExportDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExportDeclaration; -}; +isExportDeclaration.Handle = isExportDeclaration as any; export function isImportTypeNode(node: Node): node is ImportTypeNode { return node.kind === SyntaxKind.ImportType; @@ -2320,9 +1952,7 @@ export function isImportTypeNode(node: Node): node is ImportTypeNode { export declare namespace isImportTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportType; -}; +isImportTypeNode.Handle = isImportTypeNode as any; export function isImportClause(node: Node): node is ImportClause { return node.kind === SyntaxKind.ImportClause; @@ -2331,9 +1961,7 @@ export function isImportClause(node: Node): node is ImportClause { export declare namespace isImportClause { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportClause.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportClause; -}; +isImportClause.Handle = isImportClause as any; export function isImportSpecifier(node: Node): node is ImportSpecifier { return node.kind === SyntaxKind.ImportSpecifier; @@ -2342,9 +1970,7 @@ export function isImportSpecifier(node: Node): node is ImportSpecifier { export declare namespace isImportSpecifier { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportSpecifier.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportSpecifier; -}; +isImportSpecifier.Handle = isImportSpecifier as any; export function isJSDocText(node: Node): node is JSDocText { return node.kind === SyntaxKind.JSDocText; @@ -2353,9 +1979,7 @@ export function isJSDocText(node: Node): node is JSDocText { export declare namespace isJSDocText { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocText.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocText; -}; +isJSDocText.Handle = isJSDocText as any; export function isJSDocLink(node: Node): node is JSDocLink { return node.kind === SyntaxKind.JSDocLink; @@ -2364,9 +1988,7 @@ export function isJSDocLink(node: Node): node is JSDocLink { export declare namespace isJSDocLink { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocLink.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocLink; -}; +isJSDocLink.Handle = isJSDocLink as any; export function isJSDocLinkPlain(node: Node): node is JSDocLinkPlain { return node.kind === SyntaxKind.JSDocLinkPlain; @@ -2375,9 +1997,7 @@ export function isJSDocLinkPlain(node: Node): node is JSDocLinkPlain { export declare namespace isJSDocLinkPlain { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocLinkPlain.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocLinkPlain; -}; +isJSDocLinkPlain.Handle = isJSDocLinkPlain as any; export function isJSDocLinkCode(node: Node): node is JSDocLinkCode { return node.kind === SyntaxKind.JSDocLinkCode; @@ -2386,9 +2006,7 @@ export function isJSDocLinkCode(node: Node): node is JSDocLinkCode { export declare namespace isJSDocLinkCode { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocLinkCode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocLinkCode; -}; +isJSDocLinkCode.Handle = isJSDocLinkCode as any; export function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration { return node.kind === SyntaxKind.TypeParameter; @@ -2397,9 +2015,7 @@ export function isTypeParameterDeclaration(node: Node): node is TypeParameterDec export declare namespace isTypeParameterDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypeParameterDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeParameter; -}; +isTypeParameterDeclaration.Handle = isTypeParameterDeclaration as any; export function isSyntheticReferenceExpression(node: Node): node is SyntheticReferenceExpression { return node.kind === SyntaxKind.SyntheticReferenceExpression; @@ -2408,9 +2024,7 @@ export function isSyntheticReferenceExpression(node: Node): node is SyntheticRef export declare namespace isSyntheticReferenceExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isSyntheticReferenceExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SyntheticReferenceExpression; -}; +isSyntheticReferenceExpression.Handle = isSyntheticReferenceExpression as any; export function isJSDocTypeLiteral(node: Node): node is JSDocTypeLiteral { return node.kind === SyntaxKind.JSDocTypeLiteral; @@ -2419,9 +2033,7 @@ export function isJSDocTypeLiteral(node: Node): node is JSDocTypeLiteral { export declare namespace isJSDocTypeLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocTypeLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocTypeLiteral; -}; +isJSDocTypeLiteral.Handle = isJSDocTypeLiteral as any; export function isForInStatement(node: Node): node is ForInStatement { return node.kind === SyntaxKind.ForInStatement; @@ -2430,9 +2042,7 @@ export function isForInStatement(node: Node): node is ForInStatement { export declare namespace isForInStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isForInStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ForInStatement; -}; +isForInStatement.Handle = isForInStatement as any; export function isForOfStatement(node: Node): node is ForOfStatement { return node.kind === SyntaxKind.ForOfStatement; @@ -2441,9 +2051,7 @@ export function isForOfStatement(node: Node): node is ForOfStatement { export declare namespace isForOfStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isForOfStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ForOfStatement; -}; +isForOfStatement.Handle = isForOfStatement as any; export function isCaseClause(node: Node): node is CaseClause { return node.kind === SyntaxKind.CaseClause; @@ -2452,9 +2060,7 @@ export function isCaseClause(node: Node): node is CaseClause { export declare namespace isCaseClause { function Handle>(node: T): node is SpecializeNodeHandle; } -isCaseClause.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.CaseClause; -}; +isCaseClause.Handle = isCaseClause as any; export function isDefaultClause(node: Node): node is DefaultClause { return node.kind === SyntaxKind.DefaultClause; @@ -2463,9 +2069,7 @@ export function isDefaultClause(node: Node): node is DefaultClause { export declare namespace isDefaultClause { function Handle>(node: T): node is SpecializeNodeHandle; } -isDefaultClause.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DefaultClause; -}; +isDefaultClause.Handle = isDefaultClause as any; export function isObjectBindingPattern(node: Node): node is ObjectBindingPattern { return node.kind === SyntaxKind.ObjectBindingPattern; @@ -2474,9 +2078,7 @@ export function isObjectBindingPattern(node: Node): node is ObjectBindingPattern export declare namespace isObjectBindingPattern { function Handle>(node: T): node is SpecializeNodeHandle; } -isObjectBindingPattern.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ObjectBindingPattern; -}; +isObjectBindingPattern.Handle = isObjectBindingPattern as any; export function isArrayBindingPattern(node: Node): node is ArrayBindingPattern { return node.kind === SyntaxKind.ArrayBindingPattern; @@ -2485,9 +2087,7 @@ export function isArrayBindingPattern(node: Node): node is ArrayBindingPattern { export declare namespace isArrayBindingPattern { function Handle>(node: T): node is SpecializeNodeHandle; } -isArrayBindingPattern.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ArrayBindingPattern; -}; +isArrayBindingPattern.Handle = isArrayBindingPattern as any; export function isJSDocParameterTag(node: Node): node is JSDocParameterTag { return node.kind === SyntaxKind.JSDocParameterTag; @@ -2496,9 +2096,7 @@ export function isJSDocParameterTag(node: Node): node is JSDocParameterTag { export declare namespace isJSDocParameterTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocParameterTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocParameterTag; -}; +isJSDocParameterTag.Handle = isJSDocParameterTag as any; export function isJSDocPropertyTag(node: Node): node is JSDocPropertyTag { return node.kind === SyntaxKind.JSDocPropertyTag; @@ -2507,9 +2105,7 @@ export function isJSDocPropertyTag(node: Node): node is JSDocPropertyTag { export declare namespace isJSDocPropertyTag { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocPropertyTag.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JSDocPropertyTag; -}; +isJSDocPropertyTag.Handle = isJSDocPropertyTag as any; export function isHeritageClauseElement(node: Node): node is HeritageClauseElement { return node.kind === SyntaxKind.ExpressionWithTypeArguments || node.kind === SyntaxKind.TypeReference; @@ -2519,9 +2115,7 @@ export declare namespace isHeritageClauseElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isHeritageClauseElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExpressionWithTypeArguments || node.kind === SyntaxKind.TypeReference; -}; +isHeritageClauseElement.Handle = isHeritageClauseElement as any; export function isAccessExpression(node: Node): node is AccessExpression { return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression; @@ -2531,9 +2125,7 @@ export declare namespace isAccessExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isAccessExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression; -}; +isAccessExpression.Handle = isAccessExpression as any; export function isDeclarationName(node: Node): node is DeclarationName { const kind = node.kind; @@ -2544,10 +2136,7 @@ export declare namespace isDeclarationName { function Handle>(node: T): node is SpecializeNodeHandle; } -isDeclarationName.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.Identifier || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.ObjectBindingPattern || kind === SyntaxKind.ArrayBindingPattern || kind === SyntaxKind.ElementAccessExpression; -}; +isDeclarationName.Handle = isDeclarationName as any; export function isModuleName(node: Node): node is ModuleName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; @@ -2557,9 +2146,7 @@ export declare namespace isModuleName { function Handle>(node: T): node is SpecializeNodeHandle; } -isModuleName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; -}; +isModuleName.Handle = isModuleName as any; export function isModuleExportName(node: Node): node is ModuleExportName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; @@ -2569,9 +2156,7 @@ export declare namespace isModuleExportName { function Handle>(node: T): node is SpecializeNodeHandle; } -isModuleExportName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; -}; +isModuleExportName.Handle = isModuleExportName as any; export function isPropertyName(node: Node): node is PropertyName { const kind = node.kind; @@ -2582,10 +2167,7 @@ export declare namespace isPropertyName { function Handle>(node: T): node is SpecializeNodeHandle; } -isPropertyName.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.Identifier || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.ComputedPropertyName || kind === SyntaxKind.PrivateIdentifier || kind === SyntaxKind.BigIntLiteral; -}; +isPropertyName.Handle = isPropertyName as any; export function isModuleBody(node: Node): node is ModuleBody { return node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.ModuleDeclaration; @@ -2595,9 +2177,7 @@ export declare namespace isModuleBody { function Handle>(node: T): node is SpecializeNodeHandle; } -isModuleBody.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.ModuleDeclaration; -}; +isModuleBody.Handle = isModuleBody as any; export function isJSDocFullName(node: Node): node is JSDocFullName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration; @@ -2607,9 +2187,7 @@ export declare namespace isJSDocFullName { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocFullName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ModuleDeclaration; -}; +isJSDocFullName.Handle = isJSDocFullName as any; export function isModuleReference(node: Node): node is ModuleReference { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.ExternalModuleReference; @@ -2619,9 +2197,7 @@ export declare namespace isModuleReference { function Handle>(node: T): node is SpecializeNodeHandle; } -isModuleReference.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.ExternalModuleReference; -}; +isModuleReference.Handle = isModuleReference as any; export function isNamedImportBindings(node: Node): node is NamedImportBindings { return node.kind === SyntaxKind.NamespaceImport || node.kind === SyntaxKind.NamedImports; @@ -2631,9 +2207,7 @@ export declare namespace isNamedImportBindings { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamedImportBindings.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamespaceImport || node.kind === SyntaxKind.NamedImports; -}; +isNamedImportBindings.Handle = isNamedImportBindings as any; export function isNamedExportBindings(node: Node): node is NamedExportBindings { return node.kind === SyntaxKind.NamespaceExport || node.kind === SyntaxKind.NamedExports; @@ -2643,9 +2217,7 @@ export declare namespace isNamedExportBindings { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamedExportBindings.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamespaceExport || node.kind === SyntaxKind.NamedExports; -}; +isNamedExportBindings.Handle = isNamedExportBindings as any; export function isMemberName(node: Node): node is MemberName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier; @@ -2655,9 +2227,7 @@ export declare namespace isMemberName { function Handle>(node: T): node is SpecializeNodeHandle; } -isMemberName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier; -}; +isMemberName.Handle = isMemberName as any; export function isEntityName(node: Node): node is EntityName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName; @@ -2667,9 +2237,7 @@ export declare namespace isEntityName { function Handle>(node: T): node is SpecializeNodeHandle; } -isEntityName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName; -}; +isEntityName.Handle = isEntityName as any; export function isBindingName(node: Node): node is BindingName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; @@ -2679,9 +2247,7 @@ export declare namespace isBindingName { function Handle>(node: T): node is SpecializeNodeHandle; } -isBindingName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; -}; +isBindingName.Handle = isBindingName as any; export function isModifierLike(node: Node): node is ModifierLike { const kind = node.kind; @@ -2692,10 +2258,7 @@ export declare namespace isModifierLike { function Handle>(node: T): node is SpecializeNodeHandle; } -isModifierLike.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.AbstractKeyword || kind === SyntaxKind.AccessorKeyword || kind === SyntaxKind.AsyncKeyword || kind === SyntaxKind.ConstKeyword || kind === SyntaxKind.DeclareKeyword || kind === SyntaxKind.DefaultKeyword || kind === SyntaxKind.ExportKeyword || kind === SyntaxKind.InKeyword || kind === SyntaxKind.PrivateKeyword || kind === SyntaxKind.ProtectedKeyword || kind === SyntaxKind.PublicKeyword || kind === SyntaxKind.ReadonlyKeyword || kind === SyntaxKind.OutKeyword || kind === SyntaxKind.OverrideKeyword || kind === SyntaxKind.StaticKeyword || kind === SyntaxKind.Decorator; -}; +isModifierLike.Handle = isModifierLike as any; export function isJsxChild(node: Node): node is JsxChild { const kind = node.kind; @@ -2706,10 +2269,7 @@ export declare namespace isJsxChild { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxChild.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.JsxText || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment; -}; +isJsxChild.Handle = isJsxChild as any; export function isJsxAttributeLike(node: Node): node is JsxAttributeLike { return node.kind === SyntaxKind.JsxAttribute || node.kind === SyntaxKind.JsxSpreadAttribute; @@ -2719,9 +2279,7 @@ export declare namespace isJsxAttributeLike { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxAttributeLike.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxAttribute || node.kind === SyntaxKind.JsxSpreadAttribute; -}; +isJsxAttributeLike.Handle = isJsxAttributeLike as any; export function isJsxAttributeName(node: Node): node is JsxAttributeName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.JsxNamespacedName; @@ -2731,9 +2289,7 @@ export declare namespace isJsxAttributeName { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxAttributeName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.JsxNamespacedName; -}; +isJsxAttributeName.Handle = isJsxAttributeName as any; export function isJsxAttributeValue(node: Node): node is JsxAttributeValue { const kind = node.kind; @@ -2744,10 +2300,7 @@ export declare namespace isJsxAttributeValue { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxAttributeValue.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxExpression || kind === SyntaxKind.JsxElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.JsxFragment; -}; +isJsxAttributeValue.Handle = isJsxAttributeValue as any; export function isClassLikeDeclaration(node: Node): node is ClassLikeDeclaration { return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression; @@ -2757,9 +2310,7 @@ export declare namespace isClassLikeDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isClassLikeDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression; -}; +isClassLikeDeclaration.Handle = isClassLikeDeclaration as any; export function isAccessorDeclaration(node: Node): node is AccessorDeclaration { return node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor; @@ -2769,9 +2320,7 @@ export declare namespace isAccessorDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isAccessorDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor; -}; +isAccessorDeclaration.Handle = isAccessorDeclaration as any; export function isLiteralLikeNode(node: Node): node is LiteralLikeNode { const kind = node.kind; @@ -2782,10 +2331,7 @@ export declare namespace isLiteralLikeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail || kind === SyntaxKind.JsxText; -}; +isLiteralLikeNode.Handle = isLiteralLikeNode as any; export function isLiteralExpression(node: Node): node is LiteralExpression { const kind = node.kind; @@ -2796,10 +2342,7 @@ export declare namespace isLiteralExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isLiteralExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; -}; +isLiteralExpression.Handle = isLiteralExpression as any; export function isUnionOrIntersectionTypeNode(node: Node): node is UnionOrIntersectionTypeNode { return node.kind === SyntaxKind.UnionType || node.kind === SyntaxKind.IntersectionType; @@ -2809,9 +2352,7 @@ export declare namespace isUnionOrIntersectionTypeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isUnionOrIntersectionTypeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.UnionType || node.kind === SyntaxKind.IntersectionType; -}; +isUnionOrIntersectionTypeNode.Handle = isUnionOrIntersectionTypeNode as any; export function isTemplateLiteralLikeNode(node: Node): node is TemplateLiteralLikeNode { const kind = node.kind; @@ -2822,10 +2363,7 @@ export declare namespace isTemplateLiteralLikeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return isPseudoLiteralKind(kind); -}; +isTemplateLiteralLikeNode.Handle = isTemplateLiteralLikeNode as any; export function isTemplateMiddleOrTail(node: Node): node is TemplateMiddleOrTail { return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail; @@ -2835,9 +2373,7 @@ export declare namespace isTemplateMiddleOrTail { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateMiddleOrTail.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateMiddle || node.kind === SyntaxKind.TemplateTail; -}; +isTemplateMiddleOrTail.Handle = isTemplateMiddleOrTail as any; export function isTemplateLiteral(node: Node): node is TemplateLiteral { return node.kind === SyntaxKind.TemplateExpression || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; @@ -2847,9 +2383,7 @@ export declare namespace isTemplateLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TemplateExpression || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; -}; +isTemplateLiteral.Handle = isTemplateLiteral as any; export function isTypePredicateParameterName(node: Node): node is TypePredicateParameterName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType; @@ -2859,9 +2393,7 @@ export declare namespace isTypePredicateParameterName { function Handle>(node: T): node is SpecializeNodeHandle; } -isTypePredicateParameterName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisType; -}; +isTypePredicateParameterName.Handle = isTypePredicateParameterName as any; export function isImportAttributeName(node: Node): node is ImportAttributeName { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; @@ -2871,9 +2403,7 @@ export declare namespace isImportAttributeName { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportAttributeName.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral; -}; +isImportAttributeName.Handle = isImportAttributeName as any; export function isJSDocComment(node: Node): node is JSDocComment { const kind = node.kind; @@ -2884,10 +2414,7 @@ export declare namespace isJSDocComment { function Handle>(node: T): node is SpecializeNodeHandle; } -isJSDocComment.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.JSDocText || kind === SyntaxKind.JSDocLink || kind === SyntaxKind.JSDocLinkCode || kind === SyntaxKind.JSDocLinkPlain; -}; +isJSDocComment.Handle = isJSDocComment as any; export function isSignatureDeclaration(node: Node): node is SignatureDeclaration { const kind = node.kind; @@ -2898,10 +2425,7 @@ export declare namespace isSignatureDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isSignatureDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.CallSignature || kind === SyntaxKind.ConstructSignature || kind === SyntaxKind.MethodSignature || kind === SyntaxKind.IndexSignature || kind === SyntaxKind.FunctionType || kind === SyntaxKind.ConstructorType || kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.Constructor || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction; -}; +isSignatureDeclaration.Handle = isSignatureDeclaration as any; export function isStringLiteralLikeNode(node: Node): node is StringLiteralLikeNode { return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; @@ -2911,9 +2435,7 @@ export declare namespace isStringLiteralLikeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isStringLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral; -}; +isStringLiteralLikeNode.Handle = isStringLiteralLikeNode as any; export function isNumericOrStringLikeLiteral(node: Node): node is NumericOrStringLikeLiteral { return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.NumericLiteral; @@ -2923,9 +2445,7 @@ export declare namespace isNumericOrStringLikeLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isNumericOrStringLikeLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.NumericLiteral; -}; +isNumericOrStringLikeLiteral.Handle = isNumericOrStringLikeLiteral as any; export function isObjectLiteralLikeNode(node: Node): node is ObjectLiteralLikeNode { return node.kind === SyntaxKind.ObjectLiteralExpression || node.kind === SyntaxKind.ObjectBindingPattern; @@ -2935,9 +2455,7 @@ export declare namespace isObjectLiteralLikeNode { function Handle>(node: T): node is SpecializeNodeHandle; } -isObjectLiteralLikeNode.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ObjectLiteralExpression || node.kind === SyntaxKind.ObjectBindingPattern; -}; +isObjectLiteralLikeNode.Handle = isObjectLiteralLikeNode as any; export function isObjectTypeDeclaration(node: Node): node is ObjectTypeDeclaration { const kind = node.kind; @@ -2948,10 +2466,7 @@ export declare namespace isObjectTypeDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isObjectTypeDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.ClassDeclaration || kind === SyntaxKind.ClassExpression || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeLiteral; -}; +isObjectTypeDeclaration.Handle = isObjectTypeDeclaration as any; export function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement { return node.kind === SyntaxKind.JsxOpeningElement || node.kind === SyntaxKind.JsxSelfClosingElement; @@ -2961,9 +2476,7 @@ export declare namespace isJsxOpeningLikeElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isJsxOpeningLikeElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.JsxOpeningElement || node.kind === SyntaxKind.JsxSelfClosingElement; -}; +isJsxOpeningLikeElement.Handle = isJsxOpeningLikeElement as any; export function isNamedImportsOrExports(node: Node): node is NamedImportsOrExports { return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports; @@ -2973,9 +2486,7 @@ export declare namespace isNamedImportsOrExports { function Handle>(node: T): node is SpecializeNodeHandle; } -isNamedImportsOrExports.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NamedImports || node.kind === SyntaxKind.NamedExports; -}; +isNamedImportsOrExports.Handle = isNamedImportsOrExports as any; export function isBreakOrContinueStatement(node: Node): node is BreakOrContinueStatement { return node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement; @@ -2985,9 +2496,7 @@ export declare namespace isBreakOrContinueStatement { function Handle>(node: T): node is SpecializeNodeHandle; } -isBreakOrContinueStatement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement; -}; +isBreakOrContinueStatement.Handle = isBreakOrContinueStatement as any; export function isCallLikeExpression(node: Node): node is CallLikeExpression { const kind = node.kind; @@ -2998,10 +2507,7 @@ export declare namespace isCallLikeExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isCallLikeExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.CallExpression || kind === SyntaxKind.NewExpression || kind === SyntaxKind.TaggedTemplateExpression || kind === SyntaxKind.Decorator || kind === SyntaxKind.JsxOpeningElement || kind === SyntaxKind.JsxSelfClosingElement || kind === SyntaxKind.BinaryExpression; -}; +isCallLikeExpression.Handle = isCallLikeExpression as any; export function isFunctionLikeDeclaration(node: Node): node is FunctionLikeDeclaration { const kind = node.kind; @@ -3012,10 +2518,7 @@ export declare namespace isFunctionLikeDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isFunctionLikeDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.FunctionDeclaration || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor || kind === SyntaxKind.Constructor || kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction; -}; +isFunctionLikeDeclaration.Handle = isFunctionLikeDeclaration as any; export function isVariableOrParameterDeclaration(node: Node): node is VariableOrParameterDeclaration { return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.Parameter; @@ -3025,9 +2528,7 @@ export declare namespace isVariableOrParameterDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isVariableOrParameterDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.Parameter; -}; +isVariableOrParameterDeclaration.Handle = isVariableOrParameterDeclaration as any; export function isVariableOrPropertyDeclaration(node: Node): node is VariableOrPropertyDeclaration { return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.PropertyDeclaration; @@ -3037,9 +2538,7 @@ export declare namespace isVariableOrPropertyDeclaration { function Handle>(node: T): node is SpecializeNodeHandle; } -isVariableOrPropertyDeclaration.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.PropertyDeclaration; -}; +isVariableOrPropertyDeclaration.Handle = isVariableOrPropertyDeclaration as any; export function isCallOrNewExpression(node: Node): node is CallOrNewExpression { return node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.NewExpression; @@ -3049,9 +2548,7 @@ export declare namespace isCallOrNewExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isCallOrNewExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.CallExpression || node.kind === SyntaxKind.NewExpression; -}; +isCallOrNewExpression.Handle = isCallOrNewExpression as any; export function isImportClauseOrBindingPattern(node: Node): node is ImportClauseOrBindingPattern { return node.kind === SyntaxKind.ImportClause || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; @@ -3061,9 +2558,7 @@ export declare namespace isImportClauseOrBindingPattern { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportClauseOrBindingPattern.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportClause || node.kind === SyntaxKind.ObjectBindingPattern || node.kind === SyntaxKind.ArrayBindingPattern; -}; +isImportClauseOrBindingPattern.Handle = isImportClauseOrBindingPattern as any; export function isAnyImportSyntax(node: Node): node is AnyImportSyntax { return node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.JSImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration; @@ -3073,9 +2568,7 @@ export declare namespace isAnyImportSyntax { function Handle>(node: T): node is SpecializeNodeHandle; } -isAnyImportSyntax.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.JSImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration; -}; +isAnyImportSyntax.Handle = isAnyImportSyntax as any; export function isArrayBindingElement(node: Node): node is ArrayBindingElement { return node.kind === SyntaxKind.BindingElement || node.kind === SyntaxKind.OmittedExpression; @@ -3085,9 +2578,7 @@ export declare namespace isArrayBindingElement { function Handle>(node: T): node is SpecializeNodeHandle; } -isArrayBindingElement.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BindingElement || node.kind === SyntaxKind.OmittedExpression; -}; +isArrayBindingElement.Handle = isArrayBindingElement as any; export function isAssertionExpression(node: Node): node is AssertionExpression { return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression; @@ -3097,9 +2588,7 @@ export declare namespace isAssertionExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isAssertionExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression; -}; +isAssertionExpression.Handle = isAssertionExpression as any; export function isBooleanLiteral(node: Node): node is BooleanLiteral { return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword; @@ -3109,9 +2598,7 @@ export declare namespace isBooleanLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isBooleanLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TrueKeyword || node.kind === SyntaxKind.FalseKeyword; -}; +isBooleanLiteral.Handle = isBooleanLiteral as any; export function isDestructuringAssignment(node: Node): node is DestructuringAssignment { return node.kind === SyntaxKind.BinaryExpression; @@ -3121,9 +2608,7 @@ export declare namespace isDestructuringAssignment { function Handle>(node: T): node is SpecializeNodeHandle; } -isDestructuringAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BinaryExpression; -}; +isDestructuringAssignment.Handle = isDestructuringAssignment as any; export function isLiteralToken(node: Node): node is LiteralToken { const kind = node.kind; @@ -3134,10 +2619,7 @@ export declare namespace isLiteralToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isLiteralToken.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.NumericLiteral || kind === SyntaxKind.BigIntLiteral || kind === SyntaxKind.StringLiteral || kind === SyntaxKind.JsxText || kind === SyntaxKind.RegularExpressionLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral; -}; +isLiteralToken.Handle = isLiteralToken as any; export function isModifier(node: Node): node is Modifier { const kind = node.kind; @@ -3148,10 +2630,7 @@ export declare namespace isModifier { function Handle>(node: T): node is SpecializeNodeHandle; } -isModifier.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return isModifierKind(kind); -}; +isModifier.Handle = isModifier as any; export function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike { const kind = node.kind; @@ -3162,10 +2641,7 @@ export declare namespace isObjectLiteralElementLike { function Handle>(node: T): node is SpecializeNodeHandle; } -isObjectLiteralElementLike.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.PropertyAssignment || kind === SyntaxKind.ShorthandPropertyAssignment || kind === SyntaxKind.SpreadAssignment || kind === SyntaxKind.MethodDeclaration || kind === SyntaxKind.GetAccessor || kind === SyntaxKind.SetAccessor; -}; +isObjectLiteralElementLike.Handle = isObjectLiteralElementLike as any; export function isPropertyNameLiteral(node: Node): node is PropertyNameLiteral { return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral; @@ -3175,9 +2651,7 @@ export declare namespace isPropertyNameLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isPropertyNameLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral; -}; +isPropertyNameLiteral.Handle = isPropertyNameLiteral as any; export function isPseudoLiteralToken(node: Node): node is PseudoLiteralToken { const kind = node.kind; @@ -3188,10 +2662,7 @@ export declare namespace isPseudoLiteralToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isPseudoLiteralToken.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return isPseudoLiteralKind(kind); -}; +isPseudoLiteralToken.Handle = isPseudoLiteralToken as any; export function isTemplateLiteralToken(node: Node): node is TemplateLiteralToken { const kind = node.kind; @@ -3202,10 +2673,7 @@ export declare namespace isTemplateLiteralToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isTemplateLiteralToken.Handle = >(node: T): node is SpecializeNodeHandle => { - const kind = node.kind; - return kind === SyntaxKind.NoSubstitutionTemplateLiteral || kind === SyntaxKind.TemplateHead || kind === SyntaxKind.TemplateMiddle || kind === SyntaxKind.TemplateTail; -}; +isTemplateLiteralToken.Handle = isTemplateLiteralToken as any; export function isArrayDestructuringAssignment(node: Node): node is ArrayDestructuringAssignment { return node.kind === SyntaxKind.BinaryExpression; @@ -3215,9 +2683,7 @@ export declare namespace isArrayDestructuringAssignment { function Handle>(node: T): node is SpecializeNodeHandle; } -isArrayDestructuringAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BinaryExpression; -}; +isArrayDestructuringAssignment.Handle = isArrayDestructuringAssignment as any; export function isObjectDestructuringAssignment(node: Node): node is ObjectDestructuringAssignment { return node.kind === SyntaxKind.BinaryExpression; @@ -3227,9 +2693,7 @@ export declare namespace isObjectDestructuringAssignment { function Handle>(node: T): node is SpecializeNodeHandle; } -isObjectDestructuringAssignment.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.BinaryExpression; -}; +isObjectDestructuringAssignment.Handle = isObjectDestructuringAssignment as any; export function isFunctionBody(node: Node): node is FunctionBody { return node.kind === SyntaxKind.Block; @@ -3239,9 +2703,7 @@ export declare namespace isFunctionBody { function Handle>(node: T): node is SpecializeNodeHandle; } -isFunctionBody.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.Block; -}; +isFunctionBody.Handle = isFunctionBody as any; export function isTriviaKind(kind: SyntaxKind): kind is TriviaSyntaxKind { return kind === SyntaxKind.SingleLineCommentTrivia @@ -3479,9 +2941,7 @@ export declare namespace isEndOfFile { function Handle>(node: T): node is SpecializeNodeHandle; } -isEndOfFile.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.EndOfFile; -}; +isEndOfFile.Handle = isEndOfFile as any; export function isDotToken(node: Node): node is DotToken { return node.kind === SyntaxKind.DotToken; @@ -3491,9 +2951,7 @@ export declare namespace isDotToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isDotToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DotToken; -}; +isDotToken.Handle = isDotToken as any; export function isDotDotDotToken(node: Node): node is DotDotDotToken { return node.kind === SyntaxKind.DotDotDotToken; @@ -3503,9 +2961,7 @@ export declare namespace isDotDotDotToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isDotDotDotToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DotDotDotToken; -}; +isDotDotDotToken.Handle = isDotDotDotToken as any; export function isQuestionToken(node: Node): node is QuestionToken { return node.kind === SyntaxKind.QuestionToken; @@ -3515,9 +2971,7 @@ export declare namespace isQuestionToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isQuestionToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.QuestionToken; -}; +isQuestionToken.Handle = isQuestionToken as any; export function isExclamationToken(node: Node): node is ExclamationToken { return node.kind === SyntaxKind.ExclamationToken; @@ -3527,9 +2981,7 @@ export declare namespace isExclamationToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isExclamationToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExclamationToken; -}; +isExclamationToken.Handle = isExclamationToken as any; export function isColonToken(node: Node): node is ColonToken { return node.kind === SyntaxKind.ColonToken; @@ -3539,9 +2991,7 @@ export declare namespace isColonToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isColonToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ColonToken; -}; +isColonToken.Handle = isColonToken as any; export function isEqualsToken(node: Node): node is EqualsToken { return node.kind === SyntaxKind.EqualsToken; @@ -3551,9 +3001,7 @@ export declare namespace isEqualsToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isEqualsToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.EqualsToken; -}; +isEqualsToken.Handle = isEqualsToken as any; export function isAsteriskToken(node: Node): node is AsteriskToken { return node.kind === SyntaxKind.AsteriskToken; @@ -3563,9 +3011,7 @@ export declare namespace isAsteriskToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isAsteriskToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AsteriskToken; -}; +isAsteriskToken.Handle = isAsteriskToken as any; export function isEqualsGreaterThanToken(node: Node): node is EqualsGreaterThanToken { return node.kind === SyntaxKind.EqualsGreaterThanToken; @@ -3575,9 +3021,7 @@ export declare namespace isEqualsGreaterThanToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isEqualsGreaterThanToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.EqualsGreaterThanToken; -}; +isEqualsGreaterThanToken.Handle = isEqualsGreaterThanToken as any; export function isPlusToken(node: Node): node is PlusToken { return node.kind === SyntaxKind.PlusToken; @@ -3587,9 +3031,7 @@ export declare namespace isPlusToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isPlusToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PlusToken; -}; +isPlusToken.Handle = isPlusToken as any; export function isMinusToken(node: Node): node is MinusToken { return node.kind === SyntaxKind.MinusToken; @@ -3599,9 +3041,7 @@ export declare namespace isMinusToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isMinusToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.MinusToken; -}; +isMinusToken.Handle = isMinusToken as any; export function isQuestionDotToken(node: Node): node is QuestionDotToken { return node.kind === SyntaxKind.QuestionDotToken; @@ -3611,9 +3051,7 @@ export declare namespace isQuestionDotToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isQuestionDotToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.QuestionDotToken; -}; +isQuestionDotToken.Handle = isQuestionDotToken as any; export function isAssertsKeyword(node: Node): node is AssertsKeyword { return node.kind === SyntaxKind.AssertsKeyword; @@ -3623,9 +3061,7 @@ export declare namespace isAssertsKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isAssertsKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AssertsKeyword; -}; +isAssertsKeyword.Handle = isAssertsKeyword as any; export function isAssertKeyword(node: Node): node is AssertKeyword { return node.kind === SyntaxKind.AssertKeyword; @@ -3635,9 +3071,7 @@ export declare namespace isAssertKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isAssertKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AssertKeyword; -}; +isAssertKeyword.Handle = isAssertKeyword as any; export function isAwaitKeyword(node: Node): node is AwaitKeyword { return node.kind === SyntaxKind.AwaitKeyword; @@ -3647,9 +3081,7 @@ export declare namespace isAwaitKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isAwaitKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AwaitKeyword; -}; +isAwaitKeyword.Handle = isAwaitKeyword as any; export function isCaseKeyword(node: Node): node is CaseKeyword { return node.kind === SyntaxKind.CaseKeyword; @@ -3659,9 +3091,7 @@ export declare namespace isCaseKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isCaseKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.CaseKeyword; -}; +isCaseKeyword.Handle = isCaseKeyword as any; export function isAbstractKeyword(node: Node): node is AbstractKeyword { return node.kind === SyntaxKind.AbstractKeyword; @@ -3671,9 +3101,7 @@ export declare namespace isAbstractKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isAbstractKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AbstractKeyword; -}; +isAbstractKeyword.Handle = isAbstractKeyword as any; export function isAccessorKeyword(node: Node): node is AccessorKeyword { return node.kind === SyntaxKind.AccessorKeyword; @@ -3683,9 +3111,7 @@ export declare namespace isAccessorKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isAccessorKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AccessorKeyword; -}; +isAccessorKeyword.Handle = isAccessorKeyword as any; export function isAsyncKeyword(node: Node): node is AsyncKeyword { return node.kind === SyntaxKind.AsyncKeyword; @@ -3695,9 +3121,7 @@ export declare namespace isAsyncKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isAsyncKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.AsyncKeyword; -}; +isAsyncKeyword.Handle = isAsyncKeyword as any; export function isConstKeyword(node: Node): node is ConstKeyword { return node.kind === SyntaxKind.ConstKeyword; @@ -3707,9 +3131,7 @@ export declare namespace isConstKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isConstKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ConstKeyword; -}; +isConstKeyword.Handle = isConstKeyword as any; export function isDeclareKeyword(node: Node): node is DeclareKeyword { return node.kind === SyntaxKind.DeclareKeyword; @@ -3719,9 +3141,7 @@ export declare namespace isDeclareKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isDeclareKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DeclareKeyword; -}; +isDeclareKeyword.Handle = isDeclareKeyword as any; export function isDefaultKeyword(node: Node): node is DefaultKeyword { return node.kind === SyntaxKind.DefaultKeyword; @@ -3731,9 +3151,7 @@ export declare namespace isDefaultKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isDefaultKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.DefaultKeyword; -}; +isDefaultKeyword.Handle = isDefaultKeyword as any; export function isExportKeyword(node: Node): node is ExportKeyword { return node.kind === SyntaxKind.ExportKeyword; @@ -3743,9 +3161,7 @@ export declare namespace isExportKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isExportKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ExportKeyword; -}; +isExportKeyword.Handle = isExportKeyword as any; export function isInKeyword(node: Node): node is InKeyword { return node.kind === SyntaxKind.InKeyword; @@ -3755,9 +3171,7 @@ export declare namespace isInKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isInKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.InKeyword; -}; +isInKeyword.Handle = isInKeyword as any; export function isPrivateKeyword(node: Node): node is PrivateKeyword { return node.kind === SyntaxKind.PrivateKeyword; @@ -3767,9 +3181,7 @@ export declare namespace isPrivateKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isPrivateKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PrivateKeyword; -}; +isPrivateKeyword.Handle = isPrivateKeyword as any; export function isProtectedKeyword(node: Node): node is ProtectedKeyword { return node.kind === SyntaxKind.ProtectedKeyword; @@ -3779,9 +3191,7 @@ export declare namespace isProtectedKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isProtectedKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ProtectedKeyword; -}; +isProtectedKeyword.Handle = isProtectedKeyword as any; export function isPublicKeyword(node: Node): node is PublicKeyword { return node.kind === SyntaxKind.PublicKeyword; @@ -3791,9 +3201,7 @@ export declare namespace isPublicKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isPublicKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.PublicKeyword; -}; +isPublicKeyword.Handle = isPublicKeyword as any; export function isReadonlyKeyword(node: Node): node is ReadonlyKeyword { return node.kind === SyntaxKind.ReadonlyKeyword; @@ -3803,9 +3211,7 @@ export declare namespace isReadonlyKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isReadonlyKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ReadonlyKeyword; -}; +isReadonlyKeyword.Handle = isReadonlyKeyword as any; export function isOutKeyword(node: Node): node is OutKeyword { return node.kind === SyntaxKind.OutKeyword; @@ -3815,9 +3221,7 @@ export declare namespace isOutKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isOutKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.OutKeyword; -}; +isOutKeyword.Handle = isOutKeyword as any; export function isOverrideKeyword(node: Node): node is OverrideKeyword { return node.kind === SyntaxKind.OverrideKeyword; @@ -3827,9 +3231,7 @@ export declare namespace isOverrideKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isOverrideKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.OverrideKeyword; -}; +isOverrideKeyword.Handle = isOverrideKeyword as any; export function isStaticKeyword(node: Node): node is StaticKeyword { return node.kind === SyntaxKind.StaticKeyword; @@ -3839,9 +3241,7 @@ export declare namespace isStaticKeyword { function Handle>(node: T): node is SpecializeNodeHandle; } -isStaticKeyword.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.StaticKeyword; -}; +isStaticKeyword.Handle = isStaticKeyword as any; export function isBinaryOperatorToken(node: Node): node is BinaryOperatorToken { return isBinaryOperator(node.kind); @@ -3851,9 +3251,7 @@ export declare namespace isBinaryOperatorToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isBinaryOperatorToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return isBinaryOperator(node.kind); -}; +isBinaryOperatorToken.Handle = isBinaryOperatorToken as any; export function isAssignmentOperatorToken(node: Node): node is AssignmentOperatorToken { return isAssignmentOperator(node.kind); @@ -3863,9 +3261,7 @@ export declare namespace isAssignmentOperatorToken { function Handle>(node: T): node is SpecializeNodeHandle; } -isAssignmentOperatorToken.Handle = >(node: T): node is SpecializeNodeHandle => { - return isAssignmentOperator(node.kind); -}; +isAssignmentOperatorToken.Handle = isAssignmentOperatorToken as any; export function isNullLiteral(node: Node): node is NullLiteral { return node.kind === SyntaxKind.NullKeyword; @@ -3875,9 +3271,7 @@ export declare namespace isNullLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isNullLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.NullKeyword; -}; +isNullLiteral.Handle = isNullLiteral as any; export function isTrueLiteral(node: Node): node is TrueLiteral { return node.kind === SyntaxKind.TrueKeyword; @@ -3887,9 +3281,7 @@ export declare namespace isTrueLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isTrueLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.TrueKeyword; -}; +isTrueLiteral.Handle = isTrueLiteral as any; export function isFalseLiteral(node: Node): node is FalseLiteral { return node.kind === SyntaxKind.FalseKeyword; @@ -3899,9 +3291,7 @@ export declare namespace isFalseLiteral { function Handle>(node: T): node is SpecializeNodeHandle; } -isFalseLiteral.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.FalseKeyword; -}; +isFalseLiteral.Handle = isFalseLiteral as any; export function isThisExpression(node: Node): node is ThisExpression { return node.kind === SyntaxKind.ThisKeyword; @@ -3911,9 +3301,7 @@ export declare namespace isThisExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isThisExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ThisKeyword; -}; +isThisExpression.Handle = isThisExpression as any; export function isSuperExpression(node: Node): node is SuperExpression { return node.kind === SyntaxKind.SuperKeyword; @@ -3923,9 +3311,7 @@ export declare namespace isSuperExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isSuperExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.SuperKeyword; -}; +isSuperExpression.Handle = isSuperExpression as any; export function isImportExpression(node: Node): node is ImportExpression { return node.kind === SyntaxKind.ImportKeyword; @@ -3935,6 +3321,4 @@ export declare namespace isImportExpression { function Handle>(node: T): node is SpecializeNodeHandle; } -isImportExpression.Handle = >(node: T): node is SpecializeNodeHandle => { - return node.kind === SyntaxKind.ImportKeyword; -}; +isImportExpression.Handle = isImportExpression as any; diff --git a/_scripts/generate-ts-ast.ts b/_scripts/generate-ts-ast.ts index 400cf11cd58..eed6f9b862f 100644 --- a/_scripts/generate-ts-ast.ts +++ b/_scripts/generate-ts-ast.ts @@ -1432,33 +1432,29 @@ function generateIsGenerated(): string { // ── Simple guards ── for (const g of guards) { out.push(`export function ${g.funcName}(node: Node): node is ${g.typeName} {`); - const functionContent = []; if (g.kindAliasConstraint) { // Use the kind-level guard for nodes with a kind alias constraint - functionContent.push(` return ${kindGuardName(g.kindAliasConstraint)}(node.kind);`); + out.push(` return ${kindGuardName(g.kindAliasConstraint)}(node.kind);`); } else if (g.kindChecks.length === 1) { - functionContent.push(` return node.kind === ${g.kindChecks[0]};`); + out.push(` return node.kind === ${g.kindChecks[0]};`); } else { - functionContent.push(` switch (node.kind) {`); + out.push(` switch (node.kind) {`); for (const kindCheck of g.kindChecks) { - functionContent.push(` case ${kindCheck}:`); + out.push(` case ${kindCheck}:`); } - functionContent.push(` return true;`); - functionContent.push(` default:`); - functionContent.push(` return false;`); - functionContent.push(` }`); + out.push(` return true;`); + out.push(` default:`); + out.push(` return false;`); + out.push(` }`); } - out.push(...functionContent); out.push(`}`); out.push(``); out.push(`export declare namespace ${g.funcName} {`); out.push(` function Handle>(node: T): node is SpecializeNodeHandle;`); out.push(`}`); - out.push(`${g.funcName}.Handle = >(node: T): node is SpecializeNodeHandle => {`); - out.push(...functionContent); - out.push(`}`); + out.push(`${g.funcName}.Handle = ${g.funcName} as any;`); out.push(``); } @@ -1472,9 +1468,7 @@ function generateIsGenerated(): string { out.push(` function Handle>(node: T): node is SpecializeNodeHandle;`); out.push(`}`); out.push(``); - out.push(`${g.funcName}.Handle = >(node: T): node is SpecializeNodeHandle => {`); - out.push(` ${g.body}`); - out.push(`}`); + out.push(`${g.funcName}.Handle = ${g.funcName} as any;`); out.push(``); } @@ -1511,9 +1505,7 @@ function generateIsGenerated(): string { out.push(` function Handle>(node: T): ${handleReturnType};`); out.push(`}`); out.push(``); - out.push(`${g.funcName}.Handle = >(node: T): ${handleReturnType} => {`); - out.push(` ${g.body}`); - out.push(`}`); + out.push(`${g.funcName}.Handle = ${g.funcName} as any;`); out.push(``); }