namespace ts {

const enum SignatureFlags {

}

let NodeConstructor: new (kind: SyntaxKind, pos?: number, end?: number) => Node;

let TokenConstructor: new (kind: SyntaxKind, pos?: number, end?: number) => Node;

let IdentifierConstructor: new (kind: SyntaxKind, pos?: number, end?: number) => Node;

let SourceFileConstructor: new (kind: SyntaxKind, pos?: number, end?: number) => Node;

export function createNode(kind: SyntaxKind, pos?: number, end?: number): Node {

}

function visitNode<T>(cbNode: (node: Node) => T, node: Node | undefined): T | undefined {

return node && cbNode(node);

}

function visitNodes<T>(cbNode: (node: Node) => T, cbNodes: ((node: NodeArray<Node>) => T | undefined) | undefined, nodes: NodeArray<Node> | undefined): T | undefined {

}

/*@internal*/

export function isJSDocLikeText(text: string, start: number) {

}

/**

* 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 {

}

export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false, scriptKind?: ScriptKind): SourceFile {

}

export function parseIsolatedEntityName(text: string, languageVersion: ScriptTarget): EntityName | undefined {

return Parser.parseIsolatedEntityName(text, languageVersion);

}

/**

* 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 {

return Parser.parseJsonText(fileName, sourceText);

}

// See also `isExternalOrCommonJsModule` in utilities.ts

export function isExternalModule(file: SourceFile): boolean {

return file.externalModuleIndicator !== undefined;

}

// Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter

// indicates what changed between the 'text' that this SourceFile has and the 'newText'.

// The SourceFile will be created with the compiler attempting to reuse as many nodes from

// this file as possible.

//

// Note: this function mutates nodes from this SourceFile. That means any existing nodes

// from this SourceFile that are being held onto may change as a result (including

// becoming detached from any SourceFile). It is recommended that this SourceFile not

// be used once 'update' is called on it.

export function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks = false): SourceFile {

}

/* @internal */

export function parseIsolatedJSDocComment(content: string, start?: number, length?: number) {

}

/* @internal */

// Exposed only for testing.

export function parseJSDocTypeExpressionForTests(content: string, start?: number, length?: number) {

return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start, length);

}

// Implement the parser as a singleton module. We do this for perf reasons because creating

// parser instances can actually be expensive enough to impact us on projects with many source

// files.

namespace Parser {

// Share a single scanner across all calls to parse a source file. This helps speed things

// up by avoiding the cost of creating/compiling scanners over and over again.

const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);

const disallowInAndDecoratorContext = NodeFlags.DisallowInContext | NodeFlags.DecoratorContext;

// capture constructors in 'initializeState' to avoid null checks

let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let TokenConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let IdentifierConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

let sourceFile: SourceFile;

let parseDiagnostics: DiagnosticWithLocation[];

let syntaxCursor: IncrementalParser.SyntaxCursor | undefined;

let currentToken: SyntaxKind;

let sourceText: string;

let nodeCount: number;

let identifiers: Map<string>;

let identifierCount: number;

let parsingContext: ParsingContext;

let notParenthesizedArrow: Map<true> | undefined;

// Flags that dictate what parsing context we're in. For example:

// Whether or not we are in strict parsing mode. All that changes in strict parsing mode is

// that some tokens that would be considered identifiers may be considered keywords.

//

// When adding more parser context flags, consider which is the more common case that the

// flag will be in. This should be the 'false' state for that flag. The reason for this is

// that we don't store data in our nodes unless the value is in the *non-default* state. So,

// for example, more often than code 'allows-in' (or doesn't 'disallow-in'). We opt for

// 'disallow-in' set to 'false'. Otherwise, if we had 'allowsIn' set to 'true', then almost

// all nodes would need extra state on them to store this info.

//

// Note: 'allowIn' and 'allowYield' track 1:1 with the [in] and [yield] concepts in the ES6

// grammar specification.

//

// An important thing about these context concepts. By default they are effectively inherited

// while parsing through every grammar production. i.e. if you don't change them, then when

// you parse a sub-production, it will have the same context values as the parent production.

// This is great most of the time. After all, consider all the 'expression' grammar productions

// and how nearly all of them pass along the 'in' and 'yield' context values:

//

// EqualityExpression[In, Yield] :

// RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] === RelationalExpression[?In, ?Yield]

// EqualityExpression[?In, ?Yield] !== RelationalExpression[?In, ?Yield]

//

// Where you have to be careful is then understanding what the points are in the grammar

// where the values are *not* passed along. For example:

//

// SingleNameBinding[Yield,GeneratorParameter]

// [+GeneratorParameter]BindingIdentifier[Yield] Initializer[In]opt

// [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt

//

// Here this is saying that if the GeneratorParameter context flag is set, that we should

// explicitly set the 'yield' context flag to false before calling into the BindingIdentifier

// and we should explicitly unset the 'yield' context flag before calling into the Initializer.

// production. Conversely, if the GeneratorParameter context flag is not set, then we

// should leave the 'yield' context flag alone.

//

// Getting this all correct is tricky and requires careful reading of the grammar to

// understand when these values should be changed versus when they should be inherited.

//

// Note: it should not be necessary to save/restore these flags during speculative/lookahead

// parsing. These context flags are naturally stored and restored through normal recursive

// descent parsing and unwinding.

let contextFlags: NodeFlags;

// Whether or not we've had a parse error since creating the last AST node. If we have

// encountered an error, it will be stored on the next AST node we create. Parse errors

// can be broken down into three categories:

//

// 1) An error that occurred during scanning. For example, an unterminated literal, or a

// character that was completely not understood.

//

// 2) A token was expected, but was not present. This type of error is commonly produced

// by the 'parseExpected' function.

//

// 3) A token was present that no parsing function was able to consume. This type of error

// only occurs in the 'abortParsingListOrMoveToNextToken' function when the parser

// decides to skip the token.

//

// In all of these cases, we want to mark the next node as having had an error before it.

// With this mark, we can know in incremental settings if this node can be reused, or if

// we have to reparse it. If we don't keep this information around, we may just reuse the

// node. in that event we would then not produce the same errors as we did before, causing

// significant confusion problems.

//

// Note: it is necessary that this value be saved/restored during speculative/lookahead

// parsing. During lookahead parsing, we will often create a node. That node will have

// this value attached, and then this value will be set back to 'false'. If we decide to

// rewind, we must get back to the same value we had prior to the lookahead.

//

// Note: any errors at the end of the file that do not precede a regular node, should get

// attached to the EOF token.

let parseErrorBeforeNextFinishedNode = false;

export function parseSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, syntaxCursor: IncrementalParser.SyntaxCursor | undefined, setParentNodes = false, scriptKind?: ScriptKind): SourceFile {

}

export function parseIsolatedEntityName(content: string, languageVersion: ScriptTarget): EntityName | undefined {

}

export function parseJsonText(fileName: string, sourceText: string, languageVersion: ScriptTarget = ScriptTarget.ES2015, syntaxCursor?: IncrementalParser.SyntaxCursor, setParentNodes?: boolean): JsonSourceFile {

}

function getLanguageVariant(scriptKind: ScriptKind) {

// .tsx and .jsx files are treated as jsx language variant.

return scriptKind === ScriptKind.TSX || scriptKind === ScriptKind.JSX || scriptKind === ScriptKind.JS || scriptKind === ScriptKind.JSON ? LanguageVariant.JSX : LanguageVariant.Standard;

}

function initializeState(_sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor | undefined, scriptKind: ScriptKind) {

}

function clearState() {

}

function parseSourceFileWorker(fileName: string, languageVersion: ScriptTarget, setParentNodes: boolean, scriptKind: ScriptKind): SourceFile {

}

function addJSDocComment<T extends HasJSDoc>(node: T): T {

}

export function fixupParentReferences(rootNode: Node) {

}

function createSourceFile(fileName: string, languageVersion: ScriptTarget, scriptKind: ScriptKind, isDeclarationFile: boolean): SourceFile {

}

function setContextFlag(val: boolean, flag: NodeFlags) {

}

function setDisallowInContext(val: boolean) {

setContextFlag(val, NodeFlags.DisallowInContext);

}

function setYieldContext(val: boolean) {

setContextFlag(val, NodeFlags.YieldContext);

}

function setDecoratorContext(val: boolean) {

setContextFlag(val, NodeFlags.DecoratorContext);

}

function setAwaitContext(val: boolean) {

setContextFlag(val, NodeFlags.AwaitContext);

}

function doOutsideOfContext<T>(context: NodeFlags, func: () => T): T {

}

function doInsideOfContext<T>(context: NodeFlags, func: () => T): T {