namespace ts {

const enum SignatureFlags {

}

const enum SpeculationKind {

}

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 PrivateIdentifierConstructor: new (kind: SyntaxKind, pos?: number, end?: number) => Node;

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

/**

* NOTE: You should not use this, it is only exported to support `createNode` in `~/src/deprecatedCompat/deprecations.ts`.

*/

/* @internal */

export const parseBaseNodeFactory: BaseNodeFactory = {

createBaseSourceFileNode: kind => new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, -1, -1),

createBaseIdentifierNode: kind => new (IdentifierConstructor || (IdentifierConstructor = objectAllocator.getIdentifierConstructor()))(kind, -1, -1),

createBasePrivateIdentifierNode: kind => new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1),

createBaseTokenNode: kind => new (TokenConstructor || (TokenConstructor = objectAllocator.getTokenConstructor()))(kind, -1, -1),

createBaseNode: kind => new (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()))(kind, -1, -1),

};

/* @internal */

export const parseNodeFactory = createNodeFactory(NodeFactoryFlags.NoParenthesizerRules, parseBaseNodeFactory);

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 {

}

/** @internal */

/**

* 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; additionally,

* unlike `forEachChild`, 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 Unlike `forEachChild`, `forEachChildRecursively` handles recursively invoking the traversal on each child node found,

* and while doing so, handles traversing the structure without relying on the callstack to encode the tree structure.

*/

export function forEachChildRecursively<T>(rootNode: Node, cbNode: (node: Node, parent: Node) => T | "skip" | undefined, cbNodes?: (nodes: NodeArray<Node>, parent: Node) => T | "skip" | undefined): T | undefined {

}

function gatherPossibleChildren(node: Node) {

}

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

// tslint:disable variable-name

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 PrivateIdentifierConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;

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

// tslint:enable variable-name

function countNode(node: Node) {

nodeCount++;

return node;

}

// Rather than using `createBaseNodeFactory` here, we establish a `BaseNodeFactory` that closes over the

// constructors above, which are reset each time `initializeState` is called.

const baseNodeFactory: BaseNodeFactory = {

createBaseSourceFileNode: kind => countNode(new SourceFileConstructor(kind, /*pos*/ 0, /*end*/ 0)),

createBaseIdentifierNode: kind => countNode(new IdentifierConstructor(kind, /*pos*/ 0, /*end*/ 0)),

createBasePrivateIdentifierNode: kind => countNode(new PrivateIdentifierConstructor(kind, /*pos*/ 0, /*end*/ 0)),

createBaseTokenNode: kind => countNode(new TokenConstructor(kind, /*pos*/ 0, /*end*/ 0)),

createBaseNode: kind => countNode(new NodeConstructor(kind, /*pos*/ 0, /*end*/ 0))

};

const factory = createNodeFactory(NodeFactoryFlags.NoParenthesizerRules | NodeFactoryFlags.NoNodeConverters | NodeFactoryFlags.NoOriginalNode, baseNodeFactory);

let fileName: string;

let sourceFlags: NodeFlags;

let sourceText: string;

let languageVersion: ScriptTarget;

let scriptKind: ScriptKind;

let languageVariant: LanguageVariant;

let parseDiagnostics: DiagnosticWithDetachedLocation[];

let jsDocDiagnostics: DiagnosticWithDetachedLocation[];

let syntaxCursor: IncrementalParser.SyntaxCursor | undefined;

let currentToken: SyntaxKind;

let nodeCount: number;

let identifiers: ESMap<string, string>;

let privateIdentifiers: ESMap<string, string>;

let identifierCount: number;

let parsingContext: ParsingContext;

let notParenthesizedArrow: Set<number> | 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;

// Indicates whether we are currently parsing top-level statements.

let topLevel = true;

// 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 = false): JsonSourceFile {

}

function initializeState(_fileName: string, _sourceText: string, _languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor | undefined, _scriptKind: ScriptKind) {