Genese complexity report

<- typescriptServices.d.ts
Methods : 435
Complexity index : 290.1
Cyclomatic complexity : 435
Cognitive complexity
100 % Correct 435/435
0 % Warning 0/435 (threshold : 10)
0 % Error 0/435 (threshold : 20)
Cyclomatic complexity
100 % Correct 435/435
0 % Warning 0/435 (threshold : 5)
0 % Error 0/435 (threshold : 10)
Methods of typescriptServices.d.ts
setTimeout Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
            
            declare function setTimeout(handler: (...args: any[]) => void, timeout: number): any; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
clearTimeout Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
            declare function clearTimeout(handle: any): void; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getNodeMajorVersion Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                export function getNodeMajorVersion(): number | undefined; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
tokenToString Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function tokenToString(t: SyntaxKind): string | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getPositionOfLineAndCharacter Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function getPositionOfLineAndCharacter(sourceFile: SourceFileLike, line: number, character: number): number; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLineAndCharacterOfPosition Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function getLineAndCharacterOfPosition(sourceFile: SourceFileLike, position: number): LineAndCharacter; // ------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isWhiteSpaceLike Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                function isWhiteSpaceLike(ch: number): boolean; // --------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isWhiteSpaceSingleLine Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Does not include line breaks. For that, see isWhiteSpaceLike. */
                function isWhiteSpaceSingleLine(ch: number): boolean; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isLineBreak Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                function isLineBreak(ch: number): boolean; // ------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
couldStartTrivia Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function couldStartTrivia(text: string, pos: number): boolean; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
forEachLeadingCommentRange Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function forEachLeadingCommentRange<U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean) => U): U | undefined; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
forEachLeadingCommentRange Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state: T): U | undefined; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
forEachTrailingCommentRange Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function forEachTrailingCommentRange<U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean) => U): U | undefined; // ----------------------------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
forEachTrailingCommentRange Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state: T): U | undefined; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
reduceEachLeadingCommentRange Complexity Index 2.3 Cyclomatic complexity 1
                            
                                
                
                function reduceEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U | undefined; // ------- +2.3 Complexity index (+2.3 atomic)
            
                            
                        
reduceEachTrailingCommentRange Complexity Index 2.3 Cyclomatic complexity 1
                            
                                
                
                function reduceEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U | undefined; // ------- +2.3 Complexity index (+2.3 atomic)
            
                            
                        
getLeadingCommentRanges Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function getLeadingCommentRanges(text: string, pos: number): CommentRange[] | undefined; // ------------------------------------------------------------------------------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getTrailingCommentRanges Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function getTrailingCommentRanges(text: string, pos: number): CommentRange[] | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getShebang Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Optionally, get the shebang */
                function getShebang(text: string): string | undefined; // ------------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIdentifierStart Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isIdentifierStart(ch: number, languageVersion: ScriptTarget | undefined): boolean; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIdentifierPart Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isIdentifierPart(ch: number, languageVersion: ScriptTarget | undefined, identifierVariant?: LanguageVariant): boolean; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
createScanner Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, languageVariant?: LanguageVariant, textInitial?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
isExternalModuleNameRelative Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                function isExternalModuleNameRelative(moduleName: string): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
sortAndDeduplicateDiagnostics Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                function sortAndDeduplicateDiagnostics<T extends Diagnostic>(diagnostics: readonly T[]): SortedReadonlyArray<T>; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getDefaultLibFileName Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function getDefaultLibFileName(options: CompilerOptions): string; // ------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
textSpanEnd Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                function textSpanEnd(span: TextSpan): number; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
textSpanIsEmpty Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                function textSpanIsEmpty(span: TextSpan): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
textSpanContainsPosition Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function textSpanContainsPosition(span: TextSpan, position: number): boolean; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
textSpanContainsTextSpan Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function textSpanContainsTextSpan(span: TextSpan, other: TextSpan): boolean; // -------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
textSpanOverlapsWith Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function textSpanOverlapsWith(span: TextSpan, other: TextSpan): boolean; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
textSpanOverlap Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
textSpanIntersectsWithTextSpan Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): boolean; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
textSpanIntersectsWith Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
decodedTextSpanIntersectsWith Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
textSpanIntersectsWithPosition Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean; // -------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
textSpanIntersection Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
createTextSpan Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function createTextSpan(start: number, length: number): TextSpan; // ---------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
createTextSpanFromBounds Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function createTextSpanFromBounds(start: number, end: number): TextSpan; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
textChangeRangeNewSpan Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function textChangeRangeNewSpan(range: TextChangeRange): TextSpan; // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
textChangeRangeIsUnchanged Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                function textChangeRangeIsUnchanged(range: TextChangeRange): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
createTextChangeRange Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
collapseTextChangeRangesAcrossMultipleVersions Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Called to merge all the changes that occurred across several versions of a script snapshot
                 * into a single change.  i.e. if a user keeps making successive edits to a script we will
                 * have a text change from V1 to V2, V2 to V3, ..., Vn.
                 *
                 * This function will then merge those changes into a single change range valid between V1 and
                 * Vn.
                 */
                function collapseTextChangeRangesAcrossMultipleVersions(changes: readonly TextChangeRange[]): TextChangeRange; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeParameterOwner Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function getTypeParameterOwner(d: Declaration): Declaration | undefined; // --------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isParameterPropertyDeclaration Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isParameterPropertyDeclaration(node: Node, parent: Node): node is ParameterPropertyDeclaration; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isEmptyBindingPattern Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isEmptyBindingPattern(node: BindingName): node is BindingPattern; // ------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isEmptyBindingElement Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                function isEmptyBindingElement(node: BindingElement): boolean; // ------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
walkUpBindingElementsAndPatterns Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getCombinedModifierFlags Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function getCombinedModifierFlags(node: Declaration): ModifierFlags; // -------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getCombinedNodeFlags Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function getCombinedNodeFlags(node: Node): NodeFlags; // ---------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
validateLocaleAndSetLanguage Complexity Index 2.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Checks to see if the locale is in the appropriate format,
                 * and if it is, attempts to set the appropriate language.
                 */
                function validateLocaleAndSetLanguage(locale: string, sys: { // ------- +0.4 Complexity index (+0.4 atomic)
                    getExecutingFilePath(): string; // -------------------------------- +0.2 Complexity index (+0.2 atomic)
                    resolvePath(path: string): string; // ----------------------------- +0.4 Complexity index (+0.4 atomic)
                    fileExists(fileName: string): boolean; // ------------------------- +0.3 Complexity index (+0.3 atomic)
                    readFile(fileName: string): string | undefined; // ---------------- +0.5 Complexity index (+0.5 atomic)
                }, errors?: Push<Diagnostic>): void; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getOriginalNode Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function getOriginalNode(node: Node): Node; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getOriginalNode Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                function getOriginalNode<T extends Node>(node: Node, nodeTest: (node: Node) => node is T): T; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
getOriginalNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function getOriginalNode(node: Node | undefined): Node | undefined; // --------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getOriginalNode Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function getOriginalNode<T extends Node>(node: Node | undefined, nodeTest: (node: Node | undefined) => node is T): T | undefined; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
isParseTreeNode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a value indicating whether a node originated in the parse tree.
                 *
                 * @param node The node to test.
                 */
                function isParseTreeNode(node: Node): boolean; // ------------------------------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParseTreeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the original parse tree node for a node.
                 *
                 * @param node The original node.
                 * @returns The original parse tree node if found; otherwise, undefined.
                 */
                function getParseTreeNode(node: Node | undefined): Node | undefined; // ----------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getParseTreeNode Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the original parse tree node for a node.
                 *
                 * @param node The original node.
                 * @param nodeTest A callback used to ensure the correct type of parse tree node is returned.
                 * @returns The original parse tree node if found; otherwise, undefined.
                 */
                function getParseTreeNode<T extends Node>(node: T | undefined, nodeTest?: (node: Node) => node is T): T | undefined; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
escapeLeadingUnderscores Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' */
                function escapeLeadingUnderscores(identifier: string): __String; // ---------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
unescapeLeadingUnderscores Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Remove extra underscore from escaped identifier text content.
                 *
                 * @param identifier The escaped identifier text.
                 * @returns The unescaped identifier text.
                 */
                function unescapeLeadingUnderscores(identifier: __String): string; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
idText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function idText(identifierOrPrivateName: Identifier | PrivateIdentifier): string; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
symbolName Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function symbolName(symbol: Symbol): string; // -------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getNameOfJSDocTypedef Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateIdentifier | undefined; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getNameOfDeclaration Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function getNameOfDeclaration(declaration: Declaration | Expression): DeclarationName | undefined; // -------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getJSDocParameterTags Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the JSDoc parameter tags for the node if present.
                 *
                 * @remarks Returns any JSDoc param tag whose name matches the provided
                 * parameter, whether a param tag on a containing function
                 * expression, or a param tag on a variable declaration whose
                 * initializer is the containing function. The tags closest to the
                 * node are returned first, so in the previous example, the param
                 * tag on the containing function expression would be first.
                 *
                 * For binding patterns, parameter tags are matched by position.
                 */
                function getJSDocParameterTags(param: ParameterDeclaration): readonly JSDocParameterTag[]; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocTypeParameterTags Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the JSDoc type parameter tags for the node if present.
                 *
                 * @remarks Returns any JSDoc template tag whose names match the provided
                 * parameter, whether a template tag on a containing function
                 * expression, or a template tag on a variable declaration whose
                 * initializer is the containing function. The tags closest to the
                 * node are returned first, so in the previous example, the template
                 * tag on the containing function expression would be first.
                 */
                function getJSDocTypeParameterTags(param: TypeParameterDeclaration): readonly JSDocTemplateTag[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
hasJSDocParameterTags Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Return true if the node has JSDoc parameter tags.
                 *
                 * @remarks Includes parameter tags that are not directly on the node,
                 * for example on a variable declaration whose initializer is a function expression.
                 */
                function hasJSDocParameterTags(node: FunctionLikeDeclaration | SignatureDeclaration): boolean; // ---------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocAugmentsTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc augments tag for the node if present */
                function getJSDocAugmentsTag(node: Node): JSDocAugmentsTag | undefined; // ------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocImplementsTags Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc implements tags for the node if present */
                function getJSDocImplementsTags(node: Node): readonly JSDocImplementsTag[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocClassTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc class tag for the node if present */
                function getJSDocClassTag(node: Node): JSDocClassTag | undefined; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocPublicTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc public tag for the node if present */
                function getJSDocPublicTag(node: Node): JSDocPublicTag | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocPrivateTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc private tag for the node if present */
                function getJSDocPrivateTag(node: Node): JSDocPrivateTag | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocProtectedTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc protected tag for the node if present */
                function getJSDocProtectedTag(node: Node): JSDocProtectedTag | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocReadonlyTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc protected tag for the node if present */
                function getJSDocReadonlyTag(node: Node): JSDocReadonlyTag | undefined; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocDeprecatedTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc deprecated tag for the node if present */
                function getJSDocDeprecatedTag(node: Node): JSDocDeprecatedTag | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocEnumTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc enum tag for the node if present */
                function getJSDocEnumTag(node: Node): JSDocEnumTag | undefined; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocThisTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc this tag for the node if present */
                function getJSDocThisTag(node: Node): JSDocThisTag | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocReturnTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc return tag for the node if present */
                function getJSDocReturnTag(node: Node): JSDocReturnTag | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocTemplateTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc template tag for the node if present */
                function getJSDocTemplateTag(node: Node): JSDocTemplateTag | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocTypeTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc type tag for the node if present and valid */
                function getJSDocTypeTag(node: Node): JSDocTypeTag | undefined; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the type node for the node if provided via JSDoc.
                 *
                 * @remarks The search includes any JSDoc param tag that relates
                 * to the provided parameter, for example a type tag on the
                 * parameter itself, or a param tag on a containing function
                 * expression, or a param tag on a variable declaration whose
                 * initializer is the containing function. The tags closest to the
                 * node are examined first, so in the previous example, the type
                 * tag directly on the node would be returned.
                 */
                function getJSDocType(node: Node): TypeNode | undefined; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocReturnType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the return type node for the node if provided via JSDoc return tag or type tag.
                 *
                 * @remarks `getJSDocReturnTag` just gets the whole JSDoc tag. This function
                 * gets the type from inside the braces, after the fat arrow, etc.
                 */
                function getJSDocReturnType(node: Node): TypeNode | undefined; // -------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJSDocTags Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Get all JSDoc tags related to a node, including those on parent nodes. */
                function getJSDocTags(node: Node): readonly JSDocTag[]; // ----------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getAllJSDocTags Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets all JSDoc tags that match a specified predicate */
                function getAllJSDocTags<T extends JSDocTag>(node: Node, predicate: (tag: JSDocTag) => tag is T): readonly T[]; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
getAllJSDocTagsOfKind Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /** Gets all JSDoc tags of a specified kind */
                function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): readonly JSDocTag[]; // ------------------------------------ +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getEffectiveTypeParameterDeclarations Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the effective type parameters. If the node was parsed in a
                 * JavaScript file, gets the type parameters from the `@template` tag from JSDoc.
                 */
                function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters): readonly TypeParameterDeclaration[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getEffectiveConstraintOfTypeParameter Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function getEffectiveConstraintOfTypeParameter(node: TypeParameterDeclaration): TypeNode | undefined; // --------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIdentifierOrPrivateIdentifier Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isIdentifierOrPrivateIdentifier(node: Node): node is Identifier | PrivateIdentifier; // --------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isPropertyAccessChain Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPropertyAccessChain(node: Node): node is PropertyAccessChain; // ---------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isElementAccessChain Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isElementAccessChain(node: Node): node is ElementAccessChain; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCallChain Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCallChain(node: Node): node is CallChain; // ------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isOptionalChain Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function isOptionalChain(node: Node): node is PropertyAccessChain | ElementAccessChain | CallChain | NonNullChain; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
isNullishCoalesce Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                function isNullishCoalesce(node: Node): boolean; // ------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isConstTypeReference Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                function isConstTypeReference(node: Node): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
skipPartiallyEmittedExpressions Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function skipPartiallyEmittedExpressions(node: Expression): Expression; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
skipPartiallyEmittedExpressions Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function skipPartiallyEmittedExpressions(node: Node): Node; // ------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isNonNullChain Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNonNullChain(node: Node): node is NonNullChain; // -------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBreakOrContinueStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBreakOrContinueStatement(node: Node): node is BreakOrContinueStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNamedExportBindings Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNamedExportBindings(node: Node): node is NamedExportBindings; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUnparsedTextLike Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isUnparsedTextLike(node: Node): node is UnparsedTextLike; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUnparsedNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isUnparsedNode(node: Node): node is UnparsedNode; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocPropertyLikeTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocPropertyLikeTag(node: Node): node is JSDocPropertyLikeTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isToken Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * True if node is of some token syntax kind.
                 * For example, this is true for an IfKeyword but not for an IfStatement.
                 * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail.
                 */
                function isToken(n: Node): boolean; // ------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isLiteralExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isLiteralExpression(node: Node): node is LiteralExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTemplateLiteralToken Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTemplateLiteralToken(node: Node): node is TemplateLiteralToken; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTemplateMiddleOrTemplateTail Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isTemplateMiddleOrTemplateTail(node: Node): node is TemplateMiddle | TemplateTail; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isImportOrExportSpecifier Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isImportOrExportSpecifier(node: Node): node is ImportSpecifier | ExportSpecifier; // -------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isTypeOnlyImportOrExportDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyCompatibleAliasDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isStringTextContainingNode Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isStringTextContainingNode(node: Node): node is StringLiteral | TemplateLiteralToken; // -------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isModifier Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isModifier(node: Node): node is Modifier; // --------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isEntityName Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isEntityName(node: Node): node is EntityName; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPropertyName Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPropertyName(node: Node): node is PropertyName; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBindingName Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBindingName(node: Node): node is BindingName; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isFunctionLike Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isFunctionLike(node: Node): node is SignatureDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isClassElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isClassElement(node: Node): node is ClassElement; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isClassLike Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isClassLike(node: Node): node is ClassLikeDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isAccessor Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isAccessor(node: Node): node is AccessorDeclaration; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeElement(node: Node): node is TypeElement; // ------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isClassOrTypeElement Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isObjectLiteralElementLike Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Node test that determines whether a node is a valid type node.
                 * This differs from the `isPartOfTypeNode` function which determines whether a node is *part*
                 * of a TypeNode.
                 */
                function isTypeNode(node: Node): node is TypeNode; // --------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isFunctionOrConstructorTypeNode Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isFunctionOrConstructorTypeNode(node: Node): node is FunctionTypeNode | ConstructorTypeNode; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isPropertyAccessOrQualifiedName Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isPropertyAccessOrQualifiedName(node: Node): node is PropertyAccessExpression | QualifiedName; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isCallLikeExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCallLikeExpression(node: Node): node is CallLikeExpression; // ---------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCallOrNewExpression Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isCallOrNewExpression(node: Node): node is CallExpression | NewExpression; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isTemplateLiteral Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTemplateLiteral(node: Node): node is TemplateLiteral; // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isAssertionExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isAssertionExpression(node: Node): node is AssertionExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIterationStatement Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function isIterationStatement(node: Node, lookInLabeledStatements: false): node is IterationStatement; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
isIterationStatement Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                function isIterationStatement(node: Node, lookInLabeledStatements: boolean): node is IterationStatement | LabeledStatement; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
isJsxOpeningLikeElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement; // ------------------------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCaseOrDefaultClause Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocCommentContainingNode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** True if node is of a kind that may contain comment text. */
                function isJSDocCommentContainingNode(node: Node): boolean; // -------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isSetAccessor Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSetAccessor(node: Node): node is SetAccessorDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isGetAccessor Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isGetAccessor(node: Node): node is GetAccessorDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
hasOnlyExpressionInitializer Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** True if has initializer node attached to it. */
                function hasOnlyExpressionInitializer(node: Node): node is HasExpressionInitializer; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isObjectLiteralElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isObjectLiteralElement(node: Node): node is ObjectLiteralElement; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isStringLiteralLike Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isStringLiteralLike(node: Node): node is StringLiteralLike; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
createUnparsedSourceFile Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function createUnparsedSourceFile(text: string): UnparsedSource; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
createUnparsedSourceFile Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function createUnparsedSourceFile(inputFile: InputFiles, type: "js" | "dts", stripInternal?: boolean): UnparsedSource; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
createUnparsedSourceFile Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                function createUnparsedSourceFile(text: string, mapPath: string | undefined, map: string | undefined): UnparsedSource; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
createInputFiles Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function createInputFiles(javascriptText: string, declarationText: string): InputFiles; // -------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
createInputFiles Complexity Index 2 Cyclomatic complexity 1
                            
                                
                
                function createInputFiles(readFileText: (path: string) => string | undefined, javascriptPath: string, javascriptMapPath: string | undefined, declarationPath: string, declarationMapPath: string | undefined, buildInfoPath: string | undefined): InputFiles; // ------- +2.0 Complexity index (+2.0 atomic)
            
                            
                        
createInputFiles Complexity Index 1.8 Cyclomatic complexity 1
                            
                                
                
                function createInputFiles(javascriptText: string, declarationText: string, javascriptMapPath: string | undefined, javascriptMapText: string | undefined, declarationMapPath: string | undefined, declarationMapText: string | undefined): InputFiles; // --------------- +1.8 Complexity index (+1.8 atomic)
            
                            
                        
createSourceMapSource Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Create an external source map source file reference
                 */
                function createSourceMapSource(fileName: string, text: string, skipTrivia?: (pos: number) => number): SourceMapSource; // -------------------------------------------------------------------------------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
setOriginalNode Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function setOriginalNode<T extends Node>(node: T, original: Node | undefined): T; // -------------------------------------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
disposeEmitNodes Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Clears any `EmitNode` entries from parse-tree nodes.
                 * @param sourceFile A source file.
                 */
                function disposeEmitNodes(sourceFile: SourceFile | undefined): void; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setEmitFlags Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets flags that control emit behavior of a node.
                 */
                function setEmitFlags<T extends Node>(node: T, emitFlags: EmitFlags): T; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getSourceMapRange Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a custom text range to use when emitting source maps.
                 */
                function getSourceMapRange(node: Node): SourceMapRange; // ------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
setSourceMapRange Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets a custom text range to use when emitting source maps.
                 */
                function setSourceMapRange<T extends Node>(node: T, range: SourceMapRange | undefined): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getTokenSourceMapRange Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the TextRange to use for source maps for a token of a node.
                 */
                function getTokenSourceMapRange(node: Node, token: SyntaxKind): SourceMapRange | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
setTokenSourceMapRange Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the TextRange to use for source maps for a token of a node.
                 */
                function setTokenSourceMapRange<T extends Node>(node: T, token: SyntaxKind, range: SourceMapRange | undefined): T; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
getCommentRange Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a custom text range to use when emitting comments.
                 */
                function getCommentRange(node: Node): TextRange; // ------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
setCommentRange Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets a custom text range to use when emitting comments.
                 */
                function setCommentRange<T extends Node>(node: T, range: TextRange): T; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getSyntheticLeadingComments Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function getSyntheticLeadingComments(node: Node): SynthesizedComment[] | undefined; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
setSyntheticLeadingComments Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                function setSyntheticLeadingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
addSyntheticLeadingComment Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                function addSyntheticLeadingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T; // ------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
getSyntheticTrailingComments Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function getSyntheticTrailingComments(node: Node): SynthesizedComment[] | undefined; // ------------------------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
setSyntheticTrailingComments Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                function setSyntheticTrailingComments<T extends Node>(node: T, comments: SynthesizedComment[] | undefined): T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
addSyntheticTrailingComment Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                function addSyntheticTrailingComment<T extends Node>(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T; // ------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
moveSyntheticComments Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                function moveSyntheticComments<T extends Node>(node: T, original: Node): T; // ----------------------------------------------------------------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getConstantValue Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the constant value to emit for an expression representing an enum.
                 */
                function getConstantValue(node: AccessExpression): string | number | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setConstantValue Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the constant value to emit for an expression.
                 */
                function setConstantValue(node: AccessExpression, value: string | number): AccessExpression; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
addEmitHelper Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds an EmitHelper to a node.
                 */
                function addEmitHelper<T extends Node>(node: T, helper: EmitHelper): T; // ---------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addEmitHelpers Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add EmitHelpers to a node.
                 */
                function addEmitHelpers<T extends Node>(node: T, helpers: EmitHelper[] | undefined): T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
removeEmitHelper Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes an EmitHelper from a node.
                 */
                function removeEmitHelper(node: Node, helper: EmitHelper): boolean; // --------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getEmitHelpers Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the EmitHelpers of a node.
                 */
                function getEmitHelpers(node: Node): EmitHelper[] | undefined; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
moveEmitHelpers Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Moves matching emit helpers from a source node to a target node.
                 */
                function moveEmitHelpers(source: Node, target: Node, predicate: (helper: EmitHelper) => boolean): void; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
isNumericLiteral Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
                function isNumericLiteral(node: Node): node is NumericLiteral; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBigIntLiteral Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBigIntLiteral(node: Node): node is BigIntLiteral; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isStringLiteral Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isStringLiteral(node: Node): node is StringLiteral; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxText Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxText(node: Node): node is JsxText; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isRegularExpressionLiteral Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isRegularExpressionLiteral(node: Node): node is RegularExpressionLiteral; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNoSubstitutionTemplateLiteral Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNoSubstitutionTemplateLiteral(node: Node): node is NoSubstitutionTemplateLiteral; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTemplateHead Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTemplateHead(node: Node): node is TemplateHead; // ----------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTemplateMiddle Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTemplateMiddle(node: Node): node is TemplateMiddle; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTemplateTail Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTemplateTail(node: Node): node is TemplateTail; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIdentifier Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isIdentifier(node: Node): node is Identifier; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isQualifiedName Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isQualifiedName(node: Node): node is QualifiedName; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isComputedPropertyName Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isComputedPropertyName(node: Node): node is ComputedPropertyName; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPrivateIdentifier Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPrivateIdentifier(node: Node): node is PrivateIdentifier; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeParameterDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isParameter Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isParameter(node: Node): node is ParameterDeclaration; // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDecorator Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isDecorator(node: Node): node is Decorator; // ------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPropertySignature Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPropertySignature(node: Node): node is PropertySignature; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPropertyDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPropertyDeclaration(node: Node): node is PropertyDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isMethodSignature Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isMethodSignature(node: Node): node is MethodSignature; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isMethodDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isMethodDeclaration(node: Node): node is MethodDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isConstructorDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isConstructorDeclaration(node: Node): node is ConstructorDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isGetAccessorDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSetAccessorDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCallSignatureDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isConstructSignatureDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isConstructSignatureDeclaration(node: Node): node is ConstructSignatureDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIndexSignatureDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypePredicateNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypePredicateNode(node: Node): node is TypePredicateNode; // ----------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeReferenceNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeReferenceNode(node: Node): node is TypeReferenceNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isFunctionTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isFunctionTypeNode(node: Node): node is FunctionTypeNode; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isConstructorTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isConstructorTypeNode(node: Node): node is ConstructorTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeQueryNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeQueryNode(node: Node): node is TypeQueryNode; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeLiteralNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeLiteralNode(node: Node): node is TypeLiteralNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isArrayTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isArrayTypeNode(node: Node): node is ArrayTypeNode; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTupleTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTupleTypeNode(node: Node): node is TupleTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNamedTupleMember Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNamedTupleMember(node: Node): node is NamedTupleMember; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isOptionalTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isOptionalTypeNode(node: Node): node is OptionalTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isRestTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isRestTypeNode(node: Node): node is RestTypeNode; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUnionTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isUnionTypeNode(node: Node): node is UnionTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIntersectionTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isIntersectionTypeNode(node: Node): node is IntersectionTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isConditionalTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isConditionalTypeNode(node: Node): node is ConditionalTypeNode; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isInferTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isInferTypeNode(node: Node): node is InferTypeNode; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isParenthesizedTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isThisTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isThisTypeNode(node: Node): node is ThisTypeNode; // ------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeOperatorNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeOperatorNode(node: Node): node is TypeOperatorNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIndexedAccessTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isMappedTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isMappedTypeNode(node: Node): node is MappedTypeNode; // --------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isLiteralTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isLiteralTypeNode(node: Node): node is LiteralTypeNode; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isImportTypeNode Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isImportTypeNode(node: Node): node is ImportTypeNode; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isObjectBindingPattern Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isObjectBindingPattern(node: Node): node is ObjectBindingPattern; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isArrayBindingPattern Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isArrayBindingPattern(node: Node): node is ArrayBindingPattern; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBindingElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBindingElement(node: Node): node is BindingElement; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isArrayLiteralExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isObjectLiteralExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPropertyAccessExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isElementAccessExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isElementAccessExpression(node: Node): node is ElementAccessExpression; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCallExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCallExpression(node: Node): node is CallExpression; // ------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNewExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNewExpression(node: Node): node is NewExpression; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTaggedTemplateExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTaggedTemplateExpression(node: Node): node is TaggedTemplateExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeAssertionExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeAssertionExpression(node: Node): node is TypeAssertion; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isParenthesizedExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isParenthesizedExpression(node: Node): node is ParenthesizedExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isFunctionExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isFunctionExpression(node: Node): node is FunctionExpression; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isArrowFunction Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isArrowFunction(node: Node): node is ArrowFunction; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDeleteExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isDeleteExpression(node: Node): node is DeleteExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeOfExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeOfExpression(node: Node): node is TypeOfExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isVoidExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isVoidExpression(node: Node): node is VoidExpression; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isAwaitExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isAwaitExpression(node: Node): node is AwaitExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPrefixUnaryExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPostfixUnaryExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBinaryExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBinaryExpression(node: Node): node is BinaryExpression; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isConditionalExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isConditionalExpression(node: Node): node is ConditionalExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTemplateExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTemplateExpression(node: Node): node is TemplateExpression; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isYieldExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isYieldExpression(node: Node): node is YieldExpression; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSpreadElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSpreadElement(node: Node): node is SpreadElement; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isClassExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isClassExpression(node: Node): node is ClassExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isOmittedExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isOmittedExpression(node: Node): node is OmittedExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExpressionWithTypeArguments Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isAsExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isAsExpression(node: Node): node is AsExpression; // ------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNonNullExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNonNullExpression(node: Node): node is NonNullExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isMetaProperty Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isMetaProperty(node: Node): node is MetaProperty; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSyntheticExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSyntheticExpression(node: Node): node is SyntheticExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPartiallyEmittedExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPartiallyEmittedExpression(node: Node): node is PartiallyEmittedExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCommaListExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCommaListExpression(node: Node): node is CommaListExpression; // --------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTemplateSpan Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTemplateSpan(node: Node): node is TemplateSpan; // --------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSemicolonClassElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSemicolonClassElement(node: Node): node is SemicolonClassElement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBlock Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBlock(node: Node): node is Block; // --------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isVariableStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isVariableStatement(node: Node): node is VariableStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isEmptyStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isEmptyStatement(node: Node): node is EmptyStatement; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExpressionStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isExpressionStatement(node: Node): node is ExpressionStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isIfStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isIfStatement(node: Node): node is IfStatement; // ----------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDoStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isDoStatement(node: Node): node is DoStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isWhileStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isWhileStatement(node: Node): node is WhileStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isForStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isForStatement(node: Node): node is ForStatement; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isForInStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isForInStatement(node: Node): node is ForInStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isForOfStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isForOfStatement(node: Node): node is ForOfStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isContinueStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isContinueStatement(node: Node): node is ContinueStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBreakStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBreakStatement(node: Node): node is BreakStatement; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isReturnStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isReturnStatement(node: Node): node is ReturnStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isWithStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isWithStatement(node: Node): node is WithStatement; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSwitchStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSwitchStatement(node: Node): node is SwitchStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isLabeledStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isLabeledStatement(node: Node): node is LabeledStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isThrowStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isThrowStatement(node: Node): node is ThrowStatement; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTryStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTryStatement(node: Node): node is TryStatement; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDebuggerStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isDebuggerStatement(node: Node): node is DebuggerStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isVariableDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isVariableDeclaration(node: Node): node is VariableDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isVariableDeclarationList Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isVariableDeclarationList(node: Node): node is VariableDeclarationList; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isFunctionDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isFunctionDeclaration(node: Node): node is FunctionDeclaration; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isClassDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isClassDeclaration(node: Node): node is ClassDeclaration; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isInterfaceDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isInterfaceDeclaration(node: Node): node is InterfaceDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeAliasDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isEnumDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isEnumDeclaration(node: Node): node is EnumDeclaration; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isModuleDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isModuleDeclaration(node: Node): node is ModuleDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isModuleBlock Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isModuleBlock(node: Node): node is ModuleBlock; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCaseBlock Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCaseBlock(node: Node): node is CaseBlock; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNamespaceExportDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNamespaceExportDeclaration(node: Node): node is NamespaceExportDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isImportEqualsDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isImportDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isImportDeclaration(node: Node): node is ImportDeclaration; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isImportClause Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isImportClause(node: Node): node is ImportClause; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNamespaceImport Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNamespaceImport(node: Node): node is NamespaceImport; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNamespaceExport Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNamespaceExport(node: Node): node is NamespaceExport; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNamedImports Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNamedImports(node: Node): node is NamedImports; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isImportSpecifier Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isImportSpecifier(node: Node): node is ImportSpecifier; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExportAssignment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isExportAssignment(node: Node): node is ExportAssignment; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExportDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isExportDeclaration(node: Node): node is ExportDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNamedExports Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNamedExports(node: Node): node is NamedExports; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExportSpecifier Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isExportSpecifier(node: Node): node is ExportSpecifier; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isMissingDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isMissingDeclaration(node: Node): node is MissingDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNotEmittedStatement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isNotEmittedStatement(node: Node): node is NotEmittedStatement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExternalModuleReference Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isExternalModuleReference(node: Node): node is ExternalModuleReference; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxElement(node: Node): node is JsxElement; // --------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxSelfClosingElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxOpeningElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxOpeningElement(node: Node): node is JsxOpeningElement; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxClosingElement Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxClosingElement(node: Node): node is JsxClosingElement; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxFragment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxFragment(node: Node): node is JsxFragment; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxOpeningFragment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxOpeningFragment(node: Node): node is JsxOpeningFragment; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxClosingFragment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxClosingFragment(node: Node): node is JsxClosingFragment; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxAttribute Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxAttribute(node: Node): node is JsxAttribute; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxAttributes Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxAttributes(node: Node): node is JsxAttributes; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxSpreadAttribute Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJsxExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJsxExpression(node: Node): node is JsxExpression; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCaseClause Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCaseClause(node: Node): node is CaseClause; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDefaultClause Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isDefaultClause(node: Node): node is DefaultClause; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isHeritageClause Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isHeritageClause(node: Node): node is HeritageClause; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isCatchClause Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isCatchClause(node: Node): node is CatchClause; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isPropertyAssignment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isPropertyAssignment(node: Node): node is PropertyAssignment; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isShorthandPropertyAssignment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSpreadAssignment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSpreadAssignment(node: Node): node is SpreadAssignment; // ----------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isEnumMember Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isEnumMember(node: Node): node is EnumMember; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUnparsedPrepend Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isUnparsedPrepend(node: Node): node is UnparsedPrepend; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isSourceFile Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isSourceFile(node: Node): node is SourceFile; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isBundle Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isBundle(node: Node): node is Bundle; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isUnparsedSource Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isUnparsedSource(node: Node): node is UnparsedSource; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocTypeExpression Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocTypeExpression(node: Node): node is JSDocTypeExpression; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocAllType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocAllType(node: Node): node is JSDocAllType; // --------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocUnknownType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocUnknownType(node: Node): node is JSDocUnknownType; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocNullableType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocNullableType(node: Node): node is JSDocNullableType; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocNonNullableType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocNonNullableType(node: Node): node is JSDocNonNullableType; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocOptionalType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocOptionalType(node: Node): node is JSDocOptionalType; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocFunctionType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocFunctionType(node: Node): node is JSDocFunctionType; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocVariadicType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocVariadicType(node: Node): node is JSDocVariadicType; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocNamepathType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocNamepathType(node: Node): node is JSDocNamepathType; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDoc Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDoc(node: Node): node is JSDoc; // ------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocTypeLiteral Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocTypeLiteral(node: Node): node is JSDocTypeLiteral; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocSignature Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocSignature(node: Node): node is JSDocSignature; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocAugmentsTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocAuthorTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocAuthorTag(node: Node): node is JSDocAuthorTag; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocClassTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocClassTag(node: Node): node is JSDocClassTag; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocCallbackTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocCallbackTag(node: Node): node is JSDocCallbackTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocPublicTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocPublicTag(node: Node): node is JSDocPublicTag; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocPrivateTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocPrivateTag(node: Node): node is JSDocPrivateTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocProtectedTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocReadonlyTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocDeprecatedTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocEnumTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocEnumTag(node: Node): node is JSDocEnumTag; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocParameterTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocParameterTag(node: Node): node is JSDocParameterTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocReturnTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocReturnTag(node: Node): node is JSDocReturnTag; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocThisTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocThisTag(node: Node): node is JSDocThisTag; // ----------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocTypeTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocTypeTag(node: Node): node is JSDocTypeTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocTemplateTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocTypedefTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocTypedefTag(node: Node): node is JSDocTypedefTag; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocUnknownTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocUnknownTag(node: Node): node is JSDocUnknownTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocPropertyTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocPropertyTag(node: Node): node is JSDocPropertyTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isJSDocImplementsTag Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function isJSDocImplementsTag(node: Node): node is JSDocImplementsTag; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setTextRange Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
            
                function setTextRange<T extends TextRange>(range: T, location: TextRange | undefined): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
forEachChild Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
                 * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
                 * embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
                 * a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned.
                 *
                 * @param node a given node to visit its children
                 * @param cbNode a callback to be invoked for all child nodes
                 * @param cbNodes a callback to be invoked for embedded array
                 *
                 * @remarks `forEachChild` must visit the children of a node in the order
                 * that they appear in the source code. The language service depends on this property to locate nodes by position.
                 */
                export function forEachChild<T>(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray<Node>) => T | undefined): T | undefined; // ------- +1.7 Complexity index (+1.7 atomic)
            
                            
                        
createSourceFile Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean, scriptKind?: ScriptKind): SourceFile; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
parseIsolatedEntityName Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                export function parseIsolatedEntityName(text: string, languageVersion: ScriptTarget): EntityName | undefined; // --------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
parseJsonText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Parse json text into SyntaxTree and return node and parse errors if any
                 * @param fileName
                 * @param sourceText
                 */
                export function parseJsonText(fileName: string, sourceText: string): JsonSourceFile; // -------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isExternalModule Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                export function isExternalModule(file: SourceFile): boolean; // ------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
updateSourceFile Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                export function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
parseCommandLine Complexity Index 1 Cyclomatic complexity 1
                            
                                
            
                export function parseCommandLine(commandLine: readonly string[], readFile?: (path: string) => string | undefined): ParsedCommandLine; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getParsedCommandLineOfConfigFile Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Reads the config file, reports errors if any and exits if the config file cannot be found
                 */
                export function getParsedCommandLineOfConfigFile(configFileName: string, optionsToExtend: CompilerOptions, host: ParseConfigFileHost, extendedConfigCache?: Map<ExtendedConfigCacheEntry>, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): ParsedCommandLine | undefined; // ------- +1.7 Complexity index (+1.7 atomic)
            
                            
                        
readConfigFile Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Read tsconfig.json file
                 * @param fileName The path to the config file
                 */
                export function readConfigFile(fileName: string, readFile: (path: string) => string | undefined): { // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
                    config?: any; // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    error?: Diagnostic; // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                };
            
                            
                        
parseConfigFileTextToJson Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Parse the text of the tsconfig.json file
                 * @param fileName The path to the config file
                 * @param jsonText The text of the config file
                 */
                export function parseConfigFileTextToJson(fileName: string, jsonText: string): { // ------- +0.5 Complexity index (+0.5 atomic)
                    config?: any; // ---------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    error?: Diagnostic; // ---------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                };
            
                            
                        
readJsonConfigFile Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Read tsconfig.json file
                 * @param fileName The path to the config file
                 */
                export function readJsonConfigFile(fileName: string, readFile: (path: string) => string | undefined): TsConfigSourceFile; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
convertToObject Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Convert the json syntax tree into the json value
                 */
                export function convertToObject(sourceFile: JsonSourceFile, errors: Push<Diagnostic>): any; // ------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
parseJsonConfigFileContent Complexity Index 2.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Parse the contents of a config file (tsconfig.json).
                 * @param json The contents of the config file to parse
                 * @param host Instance of ParseConfigHost used to enumerate files in folder.
                 * @param basePath A root directory to resolve relative path entries in the config
                 *    file to. e.g. outDir
                 */
                export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine; // ------- +2.3 Complexity index (+2.3 atomic)
            
                            
                        
parseJsonSourceFileConfigFileContent Complexity Index 2.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Parse the contents of a config file (tsconfig.json).
                 * @param jsonNode The contents of the config file to parse
                 * @param host Instance of ParseConfigHost used to enumerate files in folder.
                 * @param basePath A root directory to resolve relative path entries in the config
                 *    file to. e.g. outDir
                 */
                export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine; // ------- +2.3 Complexity index (+2.3 atomic)
            
                            
                        
convertCompilerOptionsFromJson Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): { // ------- +0.7 Complexity index (+0.7 atomic)
                    options: CompilerOptions; // ---------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    errors: Diagnostic[]; // -------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                };
            
                            
                        
convertTypeAcquisitionFromJson Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                export function convertTypeAcquisitionFromJson(jsonOptions: any, basePath: string, configFileName?: string): { // ------- +0.7 Complexity index (+0.7 atomic)
                    options: TypeAcquisition; // ---------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    errors: Diagnostic[]; // -------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                };
            
                            
                        
getEffectiveTypeRoots Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
            
                function getEffectiveTypeRoots(options: CompilerOptions, host: GetEffectiveTypeRootsHost): string[] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
resolveTypeReferenceDirective Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
                 * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
                 * is assumed to be the same as root directory of the project.
                 */
                function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost, redirectedReference?: ResolvedProjectReference): ResolvedTypeReferenceDirectiveWithFailedLookupLocations; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
getAutomaticTypeDirectiveNames Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Given a set of options, returns the set of type directive names
                 *   that should be included for this program automatically.
                 * This list could either come from the config file,
                 *   or from enumerating the types root + initial secondary types lookup location.
                 * More type directives might appear in the program later as a result of loading actual source files;
                 *   this list is only the set of defaults that are implicitly included.
                 */
                function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[]; // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
createModuleResolutionCache Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string, options?: CompilerOptions): ModuleResolutionCache; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
resolveModuleNameFromCache Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function resolveModuleNameFromCache(moduleName: string, containingFile: string, cache: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations | undefined; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
resolveModuleName Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
nodeModuleNameResolver Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
classicNameResolver Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: NonRelativeModuleNameResolutionCache, redirectedReference?: ResolvedProjectReference): ResolvedModuleWithFailedLookupLocations; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
visitNode Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
                 *
                 * @param node The Node to visit.
                 * @param visitor The callback used to visit the Node.
                 * @param test A callback to execute to verify the Node is valid.
                 * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
                 */
                function visitNode<T extends Node>(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T): T; // ------- +1.7 Complexity index (+1.7 atomic)
            
                            
                        
visitNode Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
                 *
                 * @param node The Node to visit.
                 * @param visitor The callback used to visit the Node.
                 * @param test A callback to execute to verify the Node is valid.
                 * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
                 */
                function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T): T | undefined; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
visitNodes Complexity Index 1.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
                 *
                 * @param nodes The NodeArray to visit.
                 * @param visitor The callback used to visit a Node.
                 * @param test A node test to execute for each node.
                 * @param start An optional value indicating the starting offset at which to start visiting.
                 * @param count An optional value indicating the maximum number of nodes to visit.
                 */
                function visitNodes<T extends Node>(nodes: NodeArray<T>, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>; // ------------ +1.6 Complexity index (+1.6 atomic)
            
                            
                        
visitNodes Complexity Index 1.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
                 *
                 * @param nodes The NodeArray to visit.
                 * @param visitor The callback used to visit a Node.
                 * @param test A node test to execute for each node.
                 * @param start An optional value indicating the starting offset at which to start visiting.
                 * @param count An optional value indicating the maximum number of nodes to visit.
                 */
                function visitNodes<T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined; // ------- +1.8 Complexity index (+1.8 atomic)
            
                            
                        
visitLexicalEnvironment Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Starts a new lexical environment and visits a statement list, ending the lexical environment
                 * and merging hoisted declarations upon completion.
                 */
                function visitLexicalEnvironment(statements: NodeArray<Statement>, visitor: Visitor, context: TransformationContext, start?: number, ensureUseStrict?: boolean, nodesVisitor?: NodesVisitor): NodeArray<Statement>; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
visitParameterList Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Starts a new lexical environment and visits a parameter list, suspending the lexical
                 * environment upon completion.
                 */
                function visitParameterList(nodes: NodeArray<ParameterDeclaration>, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration>; // -------------------------------------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
visitParameterList Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                function visitParameterList(nodes: NodeArray<ParameterDeclaration> | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: NodesVisitor): NodeArray<ParameterDeclaration> | undefined; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
visitFunctionBody Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Resumes a suspended lexical environment and visits a function body, ending the lexical
                 * environment and merging hoisted declarations upon completion.
                 */
                function visitFunctionBody(node: FunctionBody, visitor: Visitor, context: TransformationContext): FunctionBody; // ---------------------------------------------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
visitFunctionBody Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Resumes a suspended lexical environment and visits a function body, ending the lexical
                 * environment and merging hoisted declarations upon completion.
                 */
                function visitFunctionBody(node: FunctionBody | undefined, visitor: Visitor, context: TransformationContext): FunctionBody | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
visitFunctionBody Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Resumes a suspended lexical environment and visits a concise body, ending the lexical
                 * environment and merging hoisted declarations upon completion.
                 */
                function visitFunctionBody(node: ConciseBody, visitor: Visitor, context: TransformationContext): ConciseBody; // --------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
visitEachChild Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
                 *
                 * @param node The Node whose children will be visited.
                 * @param visitor The callback used to visit each child.
                 * @param context A lexical environment context for the visitor.
                 */
                function visitEachChild<T extends Node>(node: T, visitor: Visitor, context: TransformationContext): T; // ------------------------ +1.0 Complexity index (+1.0 atomic)
            
                            
                        
visitEachChild Complexity Index 1.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
                 *
                 * @param node The Node whose children will be visited.
                 * @param visitor The callback used to visit each child.
                 * @param context A lexical environment context for the visitor.
                 */
                function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined; // ------- +1.6 Complexity index (+1.6 atomic)
            
                            
                        
getTsBuildInfoEmitOutputFilePath Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
                function getTsBuildInfoEmitOutputFilePath(options: CompilerOptions): string | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getOutputFileNames Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                function getOutputFileNames(commandLine: ParsedCommandLine, inputFileName: string, ignoreCase: boolean): readonly string[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
createPrinter Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function createPrinter(printerOptions?: PrinterOptions, handlers?: PrintHandlers): Printer; // --------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
findConfigFile Complexity Index 1 Cyclomatic complexity 1
                            
                                
            
                export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName?: string): string | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
resolveTripleslashReference Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                export function resolveTripleslashReference(moduleName: string, containingFile: string): string; // ---------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
createCompilerHost Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getPreEmitDiagnostics Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                export function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[]; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
formatDiagnostics Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                export function formatDiagnostics(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
formatDiagnostic Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                export function formatDiagnostic(diagnostic: Diagnostic, host: FormatDiagnosticsHost): string; // -------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
formatDiagnosticsWithColorAndContext Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                export function formatDiagnosticsWithColorAndContext(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
flattenDiagnosticMessageText Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                export function flattenDiagnosticMessageText(diag: string | DiagnosticMessageChain | undefined, newLine: string, indent?: number): string; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getConfigFileParsingDiagnostics Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                export function getConfigFileParsingDiagnostics(configFileParseResult: ParsedCommandLine): readonly Diagnostic[]; // -------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
createProgram Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'
                 * that represent a compilation unit.
                 *
                 * Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and
                 * triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.
                 *
                 * @param createProgramOptions - The options for creating a program.
                 * @returns A 'Program' object.
                 */
                export function createProgram(createProgramOptions: CreateProgramOptions): Program; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
createProgram Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions'
                 * that represent a compilation unit.
                 *
                 * Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and
                 * triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in.
                 *
                 * @param rootNames - A set of root files.
                 * @param options - The compiler options which should be used.
                 * @param host - The host interacts with the underlying file system.
                 * @param oldProgram - Reuses an old program structure.
                 * @param configFileParsingDiagnostics - error during config file parsing
                 * @returns A 'Program' object.
                 */
                export function createProgram(rootNames: readonly string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program, configFileParsingDiagnostics?: readonly Diagnostic[]): Program; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
resolveProjectReferencePath Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Returns the target config filename of a project reference.
                 * Note: The file might not exist.
                 */
                export function resolveProjectReferencePath(ref: ProjectReference): ResolvedConfigFileName; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
resolveProjectReferencePath Complexity Index 0 Cyclomatic complexity 1
                            
                                
                
                /** @deprecated */ export function resolveProjectReferencePath(host: ResolveProjectReferencePathHost, ref: ProjectReference): ResolvedConfigFileName;
            
                            
                        
createSemanticDiagnosticsBuilderProgram Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Create the builder to manage semantic diagnostics and cache them
                 */
                function createSemanticDiagnosticsBuilderProgram(newProgram: Program, host: BuilderProgramHost, oldProgram?: SemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): SemanticDiagnosticsBuilderProgram; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
createSemanticDiagnosticsBuilderProgram Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                function createSemanticDiagnosticsBuilderProgram(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: SemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): SemanticDiagnosticsBuilderProgram; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
createEmitAndSemanticDiagnosticsBuilderProgram Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Create the builder that can handle the changes in program and iterate through changed files
                 * to emit the those files and manage semantic diagnostics cache as well
                 */
                function createEmitAndSemanticDiagnosticsBuilderProgram(newProgram: Program, host: BuilderProgramHost, oldProgram?: EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): EmitAndSemanticDiagnosticsBuilderProgram; // ----------------------------------------------------------------------------------------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
createEmitAndSemanticDiagnosticsBuilderProgram Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                function createEmitAndSemanticDiagnosticsBuilderProgram(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: EmitAndSemanticDiagnosticsBuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): EmitAndSemanticDiagnosticsBuilderProgram; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
createAbstractBuilder Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a builder thats just abstraction over program and can be used with watch
                 */
                function createAbstractBuilder(newProgram: Program, host: BuilderProgramHost, oldProgram?: BuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[]): BuilderProgram; // ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
createAbstractBuilder Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                function createAbstractBuilder(rootNames: readonly string[] | undefined, options: CompilerOptions | undefined, host?: CompilerHost, oldProgram?: BuilderProgram, configFileParsingDiagnostics?: readonly Diagnostic[], projectReferences?: readonly ProjectReference[]): BuilderProgram; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
readBuilderProgram Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                function readBuilderProgram(compilerOptions: CompilerOptions, host: ReadBuildProgramHost): EmitAndSemanticDiagnosticsBuilderProgram | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
createIncrementalCompilerHost Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function createIncrementalCompilerHost(options: CompilerOptions, system?: System): CompilerHost; // ------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
createIncrementalProgram Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                function createIncrementalProgram<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>({ rootNames, options, configFileParsingDiagnostics, projectReferences, host, createProgram }: IncrementalProgramOptions<T>): T; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
createWatchCompilerHost Complexity Index 2.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Create the watch compiler host for either configFile or fileNames and its options
                 */
                function createWatchCompilerHost<T extends BuilderProgram>(configFileName: string, optionsToExtend: CompilerOptions | undefined, system: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): WatchCompilerHostOfConfigFile<T>; // ------- +2.4 Complexity index (+2.4 atomic)
            
                            
                        
createWatchCompilerHost Complexity Index 2.4 Cyclomatic complexity 1
                            
                                
                
                function createWatchCompilerHost<T extends BuilderProgram>(rootFiles: string[], options: CompilerOptions, system: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter, projectReferences?: readonly ProjectReference[], watchOptions?: WatchOptions): WatchCompilerHostOfFilesAndCompilerOptions<T>; // ---------------------------- +2.4 Complexity index (+2.4 atomic)
            
                            
                        
createWatchProgram Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates the watch from the host for root files and compiler options
                 */
                function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfFilesAndCompilerOptions<T>): WatchOfFilesAndCompilerOptions<T>; // ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
createWatchProgram Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates the watch from the host for config file
                 */
                function createWatchProgram<T extends BuilderProgram>(host: WatchCompilerHostOfConfigFile<T>): WatchOfConfigFile<T>; // --------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
createBuilderStatusReporter Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Create a function that reports watch status by writing to the system and handles the formating of the diagnostic
                 */
                function createBuilderStatusReporter(system: System, pretty?: boolean): DiagnosticReporter; // ------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
createSolutionBuilderHost Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                
                function createSolutionBuilderHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system?: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportErrorSummary?: ReportEmitErrorSummary): SolutionBuilderHost<T>; // ------- +1.7 Complexity index (+1.7 atomic)
            
                            
                        
createSolutionBuilderWithWatchHost Complexity Index 1.7 Cyclomatic complexity 1
                            
                                
                
                function createSolutionBuilderWithWatchHost<T extends BuilderProgram = EmitAndSemanticDiagnosticsBuilderProgram>(system?: System, createProgram?: CreateProgram<T>, reportDiagnostic?: DiagnosticReporter, reportSolutionBuilderStatus?: DiagnosticReporter, reportWatchStatus?: WatchStatusReporter): SolutionBuilderWithWatchHost<T>; // ------- +1.7 Complexity index (+1.7 atomic)
            
                            
                        
createSolutionBuilder Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                function createSolutionBuilder<T extends BuilderProgram>(host: SolutionBuilderHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions): SolutionBuilder<T>; // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
createSolutionBuilderWithWatch Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                function createSolutionBuilderWithWatch<T extends BuilderProgram>(host: SolutionBuilderWithWatchHost<T>, rootNames: readonly string[], defaultOptions: BuildOptions, baseWatchOptions?: WatchOptions): SolutionBuilder<T>; // ------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
fromString Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                    function fromString(text: string): IScriptSnapshot; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getDefaultFormatCodeSettings Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
createClassifier Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** The classifier is used for syntactic highlighting in editors via the TSServer */
                function createClassifier(): Classifier; // --------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
createDocumentRegistry Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
preProcessFile Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
                function preProcessFile(sourceText: string, readImportFiles?: boolean, detectJavaScriptImports?: boolean): PreProcessedFileInfo; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
transpileModule Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
transpile Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
toEditorSettings Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
displayPartsToString Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                function displayPartsToString(displayParts: SymbolDisplayPart[] | undefined): string; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getDefaultCompilerOptions Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                function getDefaultCompilerOptions(): CompilerOptions; // -------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getSupportedCodeFixes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                function getSupportedCodeFixes(): string[]; // ------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
createLanguageServiceSourceFile Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean, scriptKind?: ScriptKind): SourceFile; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
updateLanguageServiceSourceFile Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange | undefined, aggressiveChecks?: boolean): SourceFile; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
createLanguageService Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry, syntaxOnlyOrLanguageServiceMode?: boolean | LanguageServiceMode): LanguageService; // ------------------------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getDefaultLibFilePath Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Get the path of the default library files (lib.d.ts) as distributed with the typescript
                 * node package.
                 * The functionality is not supported if the ts module is consumed outside of a node module.
                 */
                function getDefaultLibFilePath(options: CompilerOptions): string; // ----------------------------------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
transform Complexity Index 1.6 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Transform one or more nodes using the supplied transformers.
                 * @param source A single `Node` or an array of `Node` objects.
                 * @param transformers An array of `TransformerFactory` callbacks used to process the transformation.
                 * @param compilerOptions Optional compiler options.
                 */
                function transform<T extends Node>(source: T | T[], transformers: TransformerFactory<T>[], compilerOptions?: CompilerOptions): TransformationResult<T>; // ------- +1.6 Complexity index (+1.6 atomic)