const result = (n as any).__pos;

Debug.assert(typeof result === "number");

return result;

const result = (n as any).__end;

Debug.assert(typeof result === "number");

return result;

/** Exclude all leading trivia (use getStart()) */

Exclude,

/** Include leading trivia and,

IncludeAll,

/**

JSDoc,

/**

StartLine,

/** Exclude all trailing trivia (use getEnd()) */

Exclude,

/** Doesn't include whitespace, but does strip comments */

ExcludeWhitespace,

/** Include trailing trivia */

Include,

let i = start;

while (i < text.length) {

const ch = text.charCodeAt(i);

if (isWhiteSpaceSingleLine(ch)) {

i++;

continue;

}

return ch === CharacterCodes.slash;

}

return false;

/**

prefix?: string;

/**

suffix?: string;

/**

indentation?: number;

/**

delta?: number;

Remove,

ReplaceWithSingleNode,

ReplaceWithMultipleNodes,

Text,

readonly kind: ChangeKind.ReplaceWithSingleNode;

readonly node: Node;

readonly options?: InsertNodeOptions;

readonly kind: ChangeKind.Remove;

readonly node?: never;

readonly options?: never;

readonly kind: ChangeKind.ReplaceWithMultipleNodes;

readonly nodes: readonly Node[];

readonly options?: ReplaceWithMultipleNodesOptions;

const { leadingTriviaOption } = options;

if (leadingTriviaOption === LeadingTriviaOption.Exclude) {

return node.getStart(sourceFile);

}

if (leadingTriviaOption === LeadingTriviaOption.StartLine) {

const startPos = node.getStart(sourceFile);

const pos = getLineStartPositionForPosition(startPos, sourceFile);

return rangeContainsPosition(node, pos) ? pos : startPos;

}

if (leadingTriviaOption === LeadingTriviaOption.JSDoc) {

const JSDocComments = getJSDocCommentRanges(node, sourceFile.text);

if (JSDocComments?.length) {

return getLineStartPositionForPosition(JSDocComments[0].pos, sourceFile);

}

}

const fullStart = node.getFullStart();

const start = node.getStart(sourceFile);

if (fullStart === start) {

return start;

}

const fullStartLine = getLineStartPositionForPosition(fullStart, sourceFile);

const startLine = getLineStartPositionForPosition(start, sourceFile);

if (startLine === fullStartLine) {

// full start and start of the node are on the same line

// a, b;

// ^ ^

// | start

// fullstart

// when b is replaced - we usually want to keep the leading trvia

// when b is deleted - we delete it

return leadingTriviaOption === LeadingTriviaOption.IncludeAll ? fullStart : start;

}

// if node has a trailing comments, use comment end position as the text has already been included.

if (hasTrailingComment) {

// Check first for leading comments as if the node is the first import, we want to exclude the trivia;

// otherwise we get the trailing comments.

const comment = getLeadingCommentRanges(sourceFile.text, fullStart)?.[0] || getTrailingCommentRanges(sourceFile.text, fullStart)?.[0];

if (comment) {

return skipTrivia(sourceFile.text, comment.end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);

}

}

// get start position of the line following the line that contains fullstart position

// (but only if the fullstart isn't the very beginning of the file)

const nextLineStart = fullStart > 0 ? 1 : 0;

let adjustedStartPosition = getStartPositionOfLine(getLineOfLocalPosition(sourceFile, fullStartLine) + nextLineStart, sourceFile);

// skip whitespaces/newlines

adjustedStartPosition = skipWhitespacesAndLineBreaks(sourceFile.text, adjustedStartPosition);

return getStartPositionOfLine(getLineOfLocalPosition(sourceFile, adjustedStartPosition), sourceFile);

const { end } = node;

const { trailingTriviaOption } = options;

if (trailingTriviaOption === TrailingTriviaOption.Include) {

// If the trailing comment is a multiline comment that extends to the next lines,

// return the end of the comment and track it for the next nodes to adjust.

const comments = getTrailingCommentRanges(sourceFile.text, end);

if (comments) {

const nodeEndLine = getLineOfLocalPosition(sourceFile, node.end);

for (const comment of comments) {

// Single line can break the loop as trivia will only be this line.

// Comments on subsequest lines are also ignored.

if (comment.kind === SyntaxKind.SingleLineCommentTrivia || getLineOfLocalPosition(sourceFile, comment.pos) > nodeEndLine) {

break;

}

// Get the end line of the comment and compare against the end line of the node.

// If the comment end line position and the multiline comment extends to multiple lines,

// then is safe to return the end position.

const commentEndLine = getLineOfLocalPosition(sourceFile, comment.end);

if (commentEndLine > nodeEndLine) {

return skipTrivia(sourceFile.text, comment.end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);

}

}

}

}

return undefined;

const { end } = node;

const { trailingTriviaOption } = options;

if (trailingTriviaOption === TrailingTriviaOption.Exclude) {

return end;

}

if (trailingTriviaOption === TrailingTriviaOption.ExcludeWhitespace) {

const comments = concatenate(getTrailingCommentRanges(sourceFile.text, end), getLeadingCommentRanges(sourceFile.text, end));

const realEnd = comments?.[comments.length - 1]?.end;

if (realEnd) {

return realEnd;

}

return end;

}

const multilineEndPosition = getEndPositionOfMultilineTrailingComment(sourceFile, node, options);

if (multilineEndPosition) {

return multilineEndPosition;

}

const newEnd = skipTrivia(sourceFile.text, end, /*stopAfterLineBreak*/ true);

return newEnd !== end && (trailingTriviaOption === TrailingTriviaOption.Include || isLineBreak(sourceFile.text.charCodeAt(newEnd - 1)))

? newEnd

: end;

host: LanguageServiceHost;

formatContext: formatting.FormatContext;

preferences: UserPreferences;

private readonly changes: Change[] = [];

private readonly newFiles: { readonly oldFile: SourceFile | undefined, readonly fileName: string, readonly statements: readonly (Statement | SyntaxKind.NewLineTrivia)[] }[] = [];

private readonly classesWithNodesInsertedAtStart = new Map<number, { readonly node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression, readonly sourceFile: SourceFile }>(); // Set<ClassDeclaration> implemented as Map<node id, ClassDeclaration>

private readonly deletedNodes: { readonly sourceFile: SourceFile, readonly node: Node | NodeArray<TypeParameterDeclaration> }[] = [];

public static fromContext(context: TextChangesContext): ChangeTracker {

return new ChangeTracker(getNewLineOrDefaultFromHost(context.host, context.formatContext.options), context.formatContext);

}

public static with(context: TextChangesContext, cb: (tracker: ChangeTracker) => void): FileTextChanges[] {

const tracker = ChangeTracker.fromContext(context);

cb(tracker);

return tracker.getChanges();

}

/** Public for tests only. Other callers should use `ChangeTracker.with`. */

constructor(private readonly newLineCharacter: string, private readonly formatContext: formatting.FormatContext) {}

public pushRaw(sourceFile: SourceFile, change: FileTextChanges) {

Debug.assertEqual(sourceFile.fileName, change.fileName);

for (const c of change.textChanges) {

this.changes.push({

kind: ChangeKind.Text,

sourceFile,

text: c.newText,

range: createTextRangeFromSpan(c.span),

});

}

}

public deleteRange(sourceFile: SourceFile, range: TextRange): void {

this.changes.push({ kind: ChangeKind.Remove, sourceFile, range });

}

delete(sourceFile: SourceFile, node: Node | NodeArray<TypeParameterDeclaration>): void {

this.deletedNodes.push({ sourceFile, node });

}

/** Stop! Consider using `delete` instead, which has logic for deleting nodes from delimited lists. */

public deleteNode(sourceFile: SourceFile, node: Node, options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }): void {

this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options));

}

public deleteNodes(sourceFile: SourceFile, nodes: readonly Node[], options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }, hasTrailingComment: boolean): void {

// When deleting multiple nodes we need to track if the end position is including multiline trailing comments.

for (const node of nodes) {

const pos = getAdjustedStartPosition(sourceFile, node, options, hasTrailingComment);

const end = getAdjustedEndPosition(sourceFile, node, options);

this.deleteRange(sourceFile, { pos, end });

hasTrailingComment = !!getEndPositionOfMultilineTrailingComment(sourceFile, node, options);

}

}

public deleteModifier(sourceFile: SourceFile, modifier: Modifier): void {

this.deleteRange(sourceFile, { pos: modifier.getStart(sourceFile), end: skipTrivia(sourceFile.text, modifier.end, /*stopAfterLineBreak*/ true) });

}

public deleteNodeRange(sourceFile: SourceFile, startNode: Node, endNode: Node, options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }): void {

const startPosition = getAdjustedStartPosition(sourceFile, startNode, options);

const endPosition = getAdjustedEndPosition(sourceFile, endNode, options);

this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });

}

public deleteNodeRangeExcludingEnd(sourceFile: SourceFile, startNode: Node, afterEndNode: Node | undefined, options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }): void {

const startPosition = getAdjustedStartPosition(sourceFile, startNode, options);

const endPosition = afterEndNode === undefined ? sourceFile.text.length : getAdjustedStartPosition(sourceFile, afterEndNode, options);

this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });

}

public replaceRange(sourceFile: SourceFile, range: TextRange, newNode: Node, options: InsertNodeOptions = {}): void {

this.changes.push({ kind: ChangeKind.ReplaceWithSingleNode, sourceFile, range, options, node: newNode });

}

public replaceNode(sourceFile: SourceFile, oldNode: Node, newNode: Node, options: ChangeNodeOptions = useNonAdjustedPositions): void {

this.replaceRange(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNode, options);

}

public replaceNodeRange(sourceFile: SourceFile, startNode: Node, endNode: Node, newNode: Node, options: ChangeNodeOptions = useNonAdjustedPositions): void {

this.replaceRange(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNode, options);

}

private replaceRangeWithNodes(sourceFile: SourceFile, range: TextRange, newNodes: readonly Node[], options: ReplaceWithMultipleNodesOptions & ConfigurableStartEnd = {}): void {

this.changes.push({ kind: ChangeKind.ReplaceWithMultipleNodes, sourceFile, range, options, nodes: newNodes });

}

public replaceNodeWithNodes(sourceFile: SourceFile, oldNode: Node, newNodes: readonly Node[], options: ChangeNodeOptions = useNonAdjustedPositions): void {

this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNodes, options);

}

public replaceNodeWithText(sourceFile: SourceFile, oldNode: Node, text: string): void {

this.replaceRangeWithText(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, useNonAdjustedPositions), text);

}

public replaceNodeRangeWithNodes(sourceFile: SourceFile, startNode: Node, endNode: Node, newNodes: readonly Node[], options: ReplaceWithMultipleNodesOptions & ConfigurableStartEnd = useNonAdjustedPositions): void {

this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNodes, options);

}

public nodeHasTrailingComment(sourceFile: SourceFile, oldNode: Node, configurableEnd: ConfigurableEnd = useNonAdjustedPositions): boolean {

return !!getEndPositionOfMultilineTrailingComment(sourceFile, oldNode, configurableEnd);

}

private nextCommaToken(sourceFile: SourceFile, node: Node): Node | undefined {

const next = findNextToken(node, node.parent, sourceFile);

return next && next.kind === SyntaxKind.CommaToken ? next : undefined;

}

public replacePropertyAssignment(sourceFile: SourceFile, oldNode: PropertyAssignment, newNode: PropertyAssignment): void {

const suffix = this.nextCommaToken(sourceFile, oldNode) ? "" : ("," + this.newLineCharacter);

this.replaceNode(sourceFile, oldNode, newNode, { suffix });

}

public insertNodeAt(sourceFile: SourceFile, pos: number, newNode: Node, options: InsertNodeOptions = {}): void {

this.replaceRange(sourceFile, createRange(pos), newNode, options);

}

private insertNodesAt(sourceFile: SourceFile, pos: number, newNodes: readonly Node[], options: ReplaceWithMultipleNodesOptions = {}): void {

this.replaceRangeWithNodes(sourceFile, createRange(pos), newNodes, options);

}

public insertNodeAtTopOfFile(sourceFile: SourceFile, newNode: Statement, blankLineBetween: boolean): void {

this.insertAtTopOfFile(sourceFile, newNode, blankLineBetween);

}

public insertNodesAtTopOfFile(sourceFile: SourceFile, newNodes: readonly Statement[], blankLineBetween: boolean): void {

this.insertAtTopOfFile(sourceFile, newNodes, blankLineBetween);

}

private insertAtTopOfFile(sourceFile: SourceFile, insert: Statement | readonly Statement[], blankLineBetween: boolean): void {

const pos = getInsertionPositionAtSourceFileTop(sourceFile);

const options = {

prefix: pos === 0 ? undefined : this.newLineCharacter,

suffix: (isLineBreak(sourceFile.text.charCodeAt(pos)) ? "" : this.newLineCharacter) + (blankLineBetween ? this.newLineCharacter : ""),

};

if (isArray(insert)) {

this.insertNodesAt(sourceFile, pos, insert, options);

}

else {

this.insertNodeAt(sourceFile, pos, insert, options);

}

}

public insertFirstParameter(sourceFile: SourceFile, parameters: NodeArray<ParameterDeclaration>, newParam: ParameterDeclaration): void {

const p0 = firstOrUndefined(parameters);

if (p0) {

this.insertNodeBefore(sourceFile, p0, newParam);

}

else {

this.insertNodeAt(sourceFile, parameters.pos, newParam);

}

}

public insertNodeBefore(sourceFile: SourceFile, before: Node, newNode: Node, blankLineBetween = false, options: ConfigurableStartEnd = {}): void {

this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween));

}

public insertModifierAt(sourceFile: SourceFile, pos: number, modifier: SyntaxKind, options: InsertNodeOptions = {}): void {

this.insertNodeAt(sourceFile, pos, factory.createToken(modifier), options);

}

public insertModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void {

return this.insertModifierAt(sourceFile, before.getStart(sourceFile), modifier, { suffix: " " });

}

public insertCommentBeforeLine(sourceFile: SourceFile, lineNumber: number, position: number, commentText: string): void {

const lineStartPosition = getStartPositionOfLine(lineNumber, sourceFile);

const startPosition = getFirstNonSpaceCharacterPosition(sourceFile.text, lineStartPosition);

// First try to see if we can put the comment on the previous line.

// We need to make sure that we are not in the middle of a string literal or a comment.

// If so, we do not want to separate the node from its comment if we can.

// Otherwise, add an extra new line immediately before the error span.

const insertAtLineStart = isValidLocationToAddComment(sourceFile, startPosition);

const token = getTouchingToken(sourceFile, insertAtLineStart ? startPosition : position);

const indent = sourceFile.text.slice(lineStartPosition, startPosition);

const text = `${insertAtLineStart ? "" : this.newLineCharacter}//${commentText}${this.newLineCharacter}${indent}`;

this.insertText(sourceFile, token.getStart(sourceFile), text);

}

public insertJsdocCommentBefore(sourceFile: SourceFile, node: HasJSDoc, tag: JSDoc): void {

const fnStart = node.getStart(sourceFile);

if (node.jsDoc) {

for (const jsdoc of node.jsDoc) {

this.deleteRange(sourceFile, {

pos: getLineStartPositionForPosition(jsdoc.getStart(sourceFile), sourceFile),

end: getAdjustedEndPosition(sourceFile, jsdoc, /*options*/ {})

});

}

}

const startPosition = getPrecedingNonSpaceCharacterPosition(sourceFile.text, fnStart - 1);

const indent = sourceFile.text.slice(startPosition, fnStart);

this.insertNodeAt(sourceFile, fnStart, tag, { suffix: this.newLineCharacter + indent });

}

private createJSDocText(sourceFile: SourceFile, node: HasJSDoc) {

const comments = flatMap(node.jsDoc, jsDoc =>

isString(jsDoc.comment) ? factory.createJSDocText(jsDoc.comment) : jsDoc.comment) as JSDocComment[];

const jsDoc = singleOrUndefined(node.jsDoc);

return jsDoc && positionsAreOnSameLine(jsDoc.pos, jsDoc.end, sourceFile) && length(comments) === 0 ? undefined :

factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n")));

}

public replaceJSDocComment(sourceFile: SourceFile, node: HasJSDoc, tags: readonly JSDocTag[]) {

this.insertJsdocCommentBefore(sourceFile, updateJSDocHost(node), factory.createJSDocComment(this.createJSDocText(sourceFile, node), factory.createNodeArray(tags)));

}

public addJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {

const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);

const unmergedNewTags = newTags.filter(newTag => !oldTags.some((tag, i) => {

const merged = tryMergeJsdocTags(tag, newTag);

if (merged) oldTags[i] = merged;

return !!merged;

}));

this.replaceJSDocComment(sourceFile, parent, [...oldTags, ...unmergedNewTags]);

}

public filterJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, predicate: (tag: JSDocTag) => boolean): void {

this.replaceJSDocComment(sourceFile, parent, filter(flatMapToMutable(parent.jsDoc, j => j.tags), predicate));

}

public replaceRangeWithText(sourceFile: SourceFile, range: TextRange, text: string): void {

this.changes.push({ kind: ChangeKind.Text, sourceFile, range, text });

}

public insertText(sourceFile: SourceFile, pos: number, text: string): void {

this.replaceRangeWithText(sourceFile, createRange(pos), text);

}

/** Prefer this over replacing a node with another that has a type annotation, as it avoids reformatting the other parts of the node. */

public tryInsertTypeAnnotation(sourceFile: SourceFile, node: TypeAnnotatable, type: TypeNode): boolean {

let endNode: Node | undefined;

if (isFunctionLike(node)) {

endNode = findChildOfKind(node, SyntaxKind.CloseParenToken, sourceFile);

if (!endNode) {

if (!isArrowFunction(node)) return false; // Function missing parentheses, give up

// If no `)`, is an arrow function `x => x`, so use the end of the first parameter

endNode = first(node.parameters);

}

}

else {

endNode = (node.kind === SyntaxKind.VariableDeclaration ? node.exclamationToken : node.questionToken) ?? node.name;

}

this.insertNodeAt(sourceFile, endNode.end, type, { prefix: ": " });

return true;

}

public tryInsertThisTypeAnnotation(sourceFile: SourceFile, node: ThisTypeAnnotatable, type: TypeNode): void {

const start = findChildOfKind(node, SyntaxKind.OpenParenToken, sourceFile)!.getStart(sourceFile) + 1;

const suffix = node.parameters.length ? ", " : "";

this.insertNodeAt(sourceFile, start, type, { prefix: "this: ", suffix });

}

public insertTypeParameters(sourceFile: SourceFile, node: SignatureDeclaration, typeParameters: readonly TypeParameterDeclaration[]): void {

// If no `(`, is an arrow function `x => x`, so use the pos of the first parameter

const start = (findChildOfKind(node, SyntaxKind.OpenParenToken, sourceFile) || first(node.parameters)).getStart(sourceFile);

this.insertNodesAt(sourceFile, start, typeParameters, { prefix: "<", suffix: ">", joiner: ", " });

}

private getOptionsForInsertNodeBefore(before: Node, inserted: Node, blankLineBetween: boolean): InsertNodeOptions {

if (isStatement(before) || isClassElement(before)) {

return { suffix: blankLineBetween ? this.newLineCharacter + this.newLineCharacter : this.newLineCharacter };

}

else if (isVariableDeclaration(before)) { // insert `x = 1, ` into `const x = 1, y = 2;

return { suffix: ", " };

}

else if (isParameter(before)) {

return isParameter(inserted) ? { suffix: ", " } : {};

}

else if (isStringLiteral(before) && isImportDeclaration(before.parent) || isNamedImports(before)) {

return { suffix: ", " };

}

else if (isImportSpecifier(before)) {

return { suffix: "," + (blankLineBetween ? this.newLineCharacter : " ") };

}

return Debug.failBadSyntaxKind(before); // We haven't handled this kind of node yet -- add it

}

public insertNodeAtConstructorStart(sourceFile: SourceFile, ctr: ConstructorDeclaration, newStatement: Statement): void {

const firstStatement = firstOrUndefined(ctr.body!.statements);

if (!firstStatement || !ctr.body!.multiLine) {

this.replaceConstructorBody(sourceFile, ctr, [newStatement, ...ctr.body!.statements]);

}

else {

this.insertNodeBefore(sourceFile, firstStatement, newStatement);

}

}

public insertNodeAtConstructorStartAfterSuperCall(sourceFile: SourceFile, ctr: ConstructorDeclaration, newStatement: Statement): void {

const superCallStatement = find(ctr.body!.statements, stmt => isExpressionStatement(stmt) && isSuperCall(stmt.expression));

if (!superCallStatement || !ctr.body!.multiLine) {

this.replaceConstructorBody(sourceFile, ctr, [...ctr.body!.statements, newStatement]);

}

else {

this.insertNodeAfter(sourceFile, superCallStatement, newStatement);

}

}

public insertNodeAtConstructorEnd(sourceFile: SourceFile, ctr: ConstructorDeclaration, newStatement: Statement): void {

const lastStatement = lastOrUndefined(ctr.body!.statements);

if (!lastStatement || !ctr.body!.multiLine) {

this.replaceConstructorBody(sourceFile, ctr, [...ctr.body!.statements, newStatement]);

}

else {

this.insertNodeAfter(sourceFile, lastStatement, newStatement);

}

}

private replaceConstructorBody(sourceFile: SourceFile, ctr: ConstructorDeclaration, statements: readonly Statement[]): void {

this.replaceNode(sourceFile, ctr.body!, factory.createBlock(statements, /*multiLine*/ true));

}

public insertNodeAtEndOfScope(sourceFile: SourceFile, scope: Node, newNode: Node): void {

const pos = getAdjustedStartPosition(sourceFile, scope.getLastToken()!, {});

this.insertNodeAt(sourceFile, pos, newNode, {

prefix: isLineBreak(sourceFile.text.charCodeAt(scope.getLastToken()!.pos)) ? this.newLineCharacter : this.newLineCharacter + this.newLineCharacter,

suffix: this.newLineCharacter

});

}

public insertMemberAtStart(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | TypeLiteralNode, newElement: ClassElement | PropertySignature | MethodSignature): void {

this.insertNodeAtStartWorker(sourceFile, node, newElement);

}

public insertNodeAtObjectStart(sourceFile: SourceFile, obj: ObjectLiteralExpression, newElement: ObjectLiteralElementLike): void {

this.insertNodeAtStartWorker(sourceFile, obj, newElement);

}

private insertNodeAtStartWorker(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode, newElement: ClassElement | ObjectLiteralElementLike | PropertySignature | MethodSignature): void {

const indentation = this.guessIndentationFromExistingMembers(sourceFile, node) ?? this.computeIndentationForNewMember(sourceFile, node);

this.insertNodeAt(sourceFile, getMembersOrProperties(node).pos, newElement, this.getInsertNodeAtStartInsertOptions(sourceFile, node, indentation));

}

/**

private guessIndentationFromExistingMembers(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode) {

let indentation: number | undefined;

let lastRange: TextRange = node;

for (const member of getMembersOrProperties(node)) {

if (rangeStartPositionsAreOnSameLine(lastRange, member, sourceFile)) {

// each indented member must be on a new line

return undefined;

}

const memberStart = member.getStart(sourceFile);

const memberIndentation = formatting.SmartIndenter.findFirstNonWhitespaceColumn(getLineStartPositionForPosition(memberStart, sourceFile), memberStart, sourceFile, this.formatContext.options);

if (indentation === undefined) {

indentation = memberIndentation;

}

else if (memberIndentation !== indentation) {

// indentation of multiple members is not consistent

return undefined;

}

lastRange = member;

}

return indentation;

}

private computeIndentationForNewMember(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode) {

const nodeStart = node.getStart(sourceFile);

return formatting.SmartIndenter.findFirstNonWhitespaceColumn(getLineStartPositionForPosition(nodeStart, sourceFile), nodeStart, sourceFile, this.formatContext.options)

+ (this.formatContext.options.indentSize ?? 4);

}

private getInsertNodeAtStartInsertOptions(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode, indentation: number): InsertNodeOptions {

// Rules:

// - Always insert leading newline.