@tslite/services 0.0.0-stage → 1.12.0

package/dist/textChanges.js

@@ -0,0 +1,1163 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/textChanges.ts: o namespace virou módulo ES, com os imports explícitos.
+import { CharacterCodes, Debug, EmitHint, NewLineKind, NodeSet, ScriptTarget, SemicolonPreference, SyntaxKind, addToSeen, contains, createMap, createNodeArray, createObjectLiteral, createParen, createPrinter, createRange, createSourceFile, createTextChange, createTextRangeFromSpan, createTextSpan, createTextSpanFromRange, createTextWriter, createToken, endsWith, find, findChildOfKind, findLastIndex, findNextToken, findPrecedingToken, first, firstOrUndefined, formatting, getAncestor, getFirstNonSpaceCharacterPosition, getLeadingCommentRanges, getLineAndCharacterOfPosition, getLineOfLocalPosition, getLineStartPositionForPosition, getNewLineOrDefaultFromHost, getNodeId, getScriptKindFromFileName, getShebang, getStartPositionOfLine, getTokenAtPosition, getTouchingToken, group, indexOfNode, isAnyImportSyntax, isArray, isArrowFunction, isCallExpression, isExpression, isFunctionLike, isImportClause, isImportDeclaration, isInComment, isInJSXText, isInString, isInTemplateString, isJsonSourceFile, isLineBreak, isNamedImports, isObjectLiteralExpression, isParameter, isPinnedComment, isPrologueDirective, isPropertySignature, isRecognizedTripleSlashComment, isStatement, isStatementButNotDeclaration, isStringLiteral, isTypeElement, isVariableDeclaration, isWhiteSpaceLike, isWhiteSpaceSingleLine, last, mapDefined, nodeIsSynthesized, nullTransformationContext, positionsAreOnSameLine, probablyUsesSemicolons, rangeContainsRangeExclusive, rangeOfNode, rangeOfTypeParameters, rangeStartPositionsAreOnSameLine, removeSuffix, skipTrivia, stableSort, stringContainsAt, textSpanEnd, tokenToString, visitEachChild, visitNodes, } from "./_namespaces/edit.js";
+/**
+ * Currently for simplicity we store recovered positions on the node itself.
+ * It can be changed to side-table later if we decide that current design is too invasive.
+ */
+function getPos(n) {
+    const result = n.__pos;
+    Debug.assert(typeof result === "number");
+    return result;
+}
+function setPos(n, pos) {
+    Debug.assert(typeof pos === "number");
+    n.__pos = pos;
+}
+function getEnd(n) {
+    const result = n.__end;
+    Debug.assert(typeof result === "number");
+    return result;
+}
+function setEnd(n, end) {
+    Debug.assert(typeof end === "number");
+    n.__end = end;
+}
+export var LeadingTriviaOption;
+(function (LeadingTriviaOption) {
+    /** Exclude all leading trivia (use getStart()) */
+    LeadingTriviaOption[LeadingTriviaOption["Exclude"] = 0] = "Exclude";
+    /** Include leading trivia and,
+     * if there are no line breaks between the node and the previous token,
+     * include all trivia between the node and the previous token
+     */
+    LeadingTriviaOption[LeadingTriviaOption["IncludeAll"] = 1] = "IncludeAll";
+    // Na tag, também o JSDoc preso ao nó; a cópia não tem o JSDoc, e o comentário `/** */` é um comentário como outro
+    // (CK-03).
+    /**
+     * Only delete trivia on the same line as getStart().
+     * Used to avoid deleting leading comments
+     */
+    LeadingTriviaOption[LeadingTriviaOption["StartLine"] = 2] = "StartLine";
+})(LeadingTriviaOption || (LeadingTriviaOption = {}));
+export var TrailingTriviaOption;
+(function (TrailingTriviaOption) {
+    /** Exclude all trailing trivia (use getEnd()) */
+    TrailingTriviaOption[TrailingTriviaOption["Exclude"] = 0] = "Exclude";
+    /** Include trailing trivia */
+    TrailingTriviaOption[TrailingTriviaOption["Include"] = 1] = "Include";
+})(TrailingTriviaOption || (TrailingTriviaOption = {}));
+function skipWhitespacesAndLineBreaks(text, start) {
+    return skipTrivia(text, start, /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
+}
+function hasCommentsBeforeLineBreak(text, start) {
+    let i = start;
+    while (i < text.length) {
+        const ch = text.charCodeAt(i);
+        if (isWhiteSpaceSingleLine(ch)) {
+            i++;
+            continue;
+        }
+        return ch === CharacterCodes.slash;
+    }
+    return false;
+}
+const useNonAdjustedPositions = {
+    leadingTriviaOption: LeadingTriviaOption.Exclude,
+    trailingTriviaOption: TrailingTriviaOption.Exclude,
+};
+var ChangeKind;
+(function (ChangeKind) {
+    ChangeKind[ChangeKind["Remove"] = 0] = "Remove";
+    ChangeKind[ChangeKind["ReplaceWithSingleNode"] = 1] = "ReplaceWithSingleNode";
+    ChangeKind[ChangeKind["ReplaceWithMultipleNodes"] = 2] = "ReplaceWithMultipleNodes";
+    ChangeKind[ChangeKind["Text"] = 3] = "Text";
+})(ChangeKind || (ChangeKind = {}));
+function getAdjustedRange(sourceFile, startNode, endNode, options) {
+    return { pos: getAdjustedStartPosition(sourceFile, startNode, options), end: getAdjustedEndPosition(sourceFile, endNode, options) };
+}
+function getAdjustedStartPosition(sourceFile, node, options) {
+    const { leadingTriviaOption } = options;
+    if (leadingTriviaOption === LeadingTriviaOption.Exclude) {
+        return node.getStart(sourceFile);
+    }
+    if (leadingTriviaOption === LeadingTriviaOption.StartLine) {
+        return getLineStartPositionForPosition(node.getStart(sourceFile), sourceFile);
+    }
+    // Na tag, também o começo do JSDoc preso ao nó (CK-03).
+    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;
+    }
+    // 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);
+}
+function getAdjustedEndPosition(sourceFile, node, options) {
+    const { end } = node;
+    const { trailingTriviaOption } = options;
+    if (trailingTriviaOption === TrailingTriviaOption.Exclude || (isExpression(node) && trailingTriviaOption !== TrailingTriviaOption.Include)) {
+        return end;
+    }
+    const newEnd = skipTrivia(sourceFile.text, end, /*stopAfterLineBreak*/ true);
+    return newEnd !== end && (trailingTriviaOption === TrailingTriviaOption.Include || isLineBreak(sourceFile.text.charCodeAt(newEnd - 1)))
+        ? newEnd
+        : end;
+}
+/**
+ * Checks if 'candidate' argument is a legal separator in the list that contains 'node' as an element
+ */
+function isSeparator(node, candidate) {
+    return !!candidate && !!node.parent && (candidate.kind === SyntaxKind.CommaToken || (candidate.kind === SyntaxKind.SemicolonToken && node.parent.kind === SyntaxKind.ObjectLiteralExpression));
+}
+function spaces(count) {
+    let s = "";
+    for (let i = 0; i < count; i++) {
+        s += " ";
+    }
+    return s;
+}
+// Na tag, também o que recebe a anotação do `this` (a `function` e a function expression), com o
+// `isThisTypeAnnotatable` (CK-02).
+export class ChangeTracker {
+    static fromContext(context) {
+        return new ChangeTracker(getNewLineOrDefaultFromHost(context.host, context.formatContext.options), context.formatContext);
+    }
+    static with(context, cb) {
+        const tracker = ChangeTracker.fromContext(context);
+        cb(tracker);
+        return tracker.getChanges();
+    }
+    /** Public for tests only. Other callers should use `ChangeTracker.with`. */
+    constructor(newLineCharacter, formatContext) {
+        this.newLineCharacter = newLineCharacter;
+        this.formatContext = formatContext;
+        this.changes = [];
+        this.newFiles = [];
+        // Na tag, também a classe e a interface em que um membro se insere no começo (CK-02).
+        this.classesWithNodesInsertedAtStart = createMap(); // Set<ClassDeclaration> implemented as Map<node id, ClassDeclaration>
+        this.deletedNodes = [];
+    }
+    pushRaw(sourceFile, change) {
+        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),
+            });
+        }
+    }
+    deleteRange(sourceFile, range) {
+        this.changes.push({ kind: ChangeKind.Remove, sourceFile, range });
+    }
+    delete(sourceFile, node) {
+        this.deletedNodes.push({ sourceFile, node });
+    }
+    deleteNode(sourceFile, node, options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }) {
+        this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options));
+    }
+    deleteModifier(sourceFile, modifier) {
+        this.deleteRange(sourceFile, { pos: modifier.getStart(sourceFile), end: skipTrivia(sourceFile.text, modifier.end, /*stopAfterLineBreak*/ true) });
+    }
+    deleteNodeRange(sourceFile, startNode, endNode, options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }) {
+        const startPosition = getAdjustedStartPosition(sourceFile, startNode, options);
+        const endPosition = getAdjustedEndPosition(sourceFile, endNode, options);
+        this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });
+    }
+    deleteNodeRangeExcludingEnd(sourceFile, startNode, afterEndNode, options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }) {
+        const startPosition = getAdjustedStartPosition(sourceFile, startNode, options);
+        const endPosition = afterEndNode === undefined ? sourceFile.text.length : getAdjustedStartPosition(sourceFile, afterEndNode, options);
+        this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });
+    }
+    replaceRange(sourceFile, range, newNode, options = {}) {
+        this.changes.push({ kind: ChangeKind.ReplaceWithSingleNode, sourceFile, range, options, node: newNode });
+    }
+    replaceNode(sourceFile, oldNode, newNode, options = useNonAdjustedPositions) {
+        this.replaceRange(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNode, options);
+    }
+    replaceNodeRange(sourceFile, startNode, endNode, newNode, options = useNonAdjustedPositions) {
+        this.replaceRange(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNode, options);
+    }
+    replaceRangeWithNodes(sourceFile, range, newNodes, options = {}) {
+        this.changes.push({ kind: ChangeKind.ReplaceWithMultipleNodes, sourceFile, range, options, nodes: newNodes });
+    }
+    replaceNodeWithNodes(sourceFile, oldNode, newNodes, options = useNonAdjustedPositions) {
+        this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNodes, options);
+    }
+    replaceNodeWithText(sourceFile, oldNode, text) {
+        this.replaceRangeWithText(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, useNonAdjustedPositions), text);
+    }
+    replaceNodeRangeWithNodes(sourceFile, startNode, endNode, newNodes, options = useNonAdjustedPositions) {
+        this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNodes, options);
+    }
+    nextCommaToken(sourceFile, node) {
+        const next = findNextToken(node, node.parent, sourceFile);
+        return next && next.kind === SyntaxKind.CommaToken ? next : undefined;
+    }
+    replacePropertyAssignment(sourceFile, oldNode, newNode) {
+        const suffix = this.nextCommaToken(sourceFile, oldNode) ? "" : ("," + this.newLineCharacter);
+        this.replaceNode(sourceFile, oldNode, newNode, { suffix });
+    }
+    insertNodeAt(sourceFile, pos, newNode, options = {}) {
+        this.replaceRange(sourceFile, createRange(pos), newNode, options);
+    }
+    insertNodesAt(sourceFile, pos, newNodes, options = {}) {
+        this.replaceRangeWithNodes(sourceFile, createRange(pos), newNodes, options);
+    }
+    insertNodeAtTopOfFile(sourceFile, newNode, blankLineBetween) {
+        this.insertAtTopOfFile(sourceFile, newNode, blankLineBetween);
+    }
+    insertNodesAtTopOfFile(sourceFile, newNodes, blankLineBetween) {
+        this.insertAtTopOfFile(sourceFile, newNodes, blankLineBetween);
+    }
+    insertAtTopOfFile(sourceFile, insert, blankLineBetween) {
+        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);
+        }
+    }
+    insertFirstParameter(sourceFile, parameters, newParam) {
+        const p0 = firstOrUndefined(parameters);
+        if (p0) {
+            this.insertNodeBefore(sourceFile, p0, newParam);
+        }
+        else {
+            this.insertNodeAt(sourceFile, parameters.pos, newParam);
+        }
+    }
+    insertNodeBefore(sourceFile, before, newNode, blankLineBetween = false) {
+        this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, {}), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween));
+    }
+    insertModifierBefore(sourceFile, modifier, before) {
+        const pos = before.getStart(sourceFile);
+        this.insertNodeAt(sourceFile, pos, createToken(modifier), { suffix: " " });
+    }
+    insertLastModifierBefore(sourceFile, modifier, before) {
+        if (!before.modifiers) {
+            this.insertModifierBefore(sourceFile, modifier, before);
+            return;
+        }
+        const pos = before.modifiers.end;
+        this.insertNodeAt(sourceFile, pos, createToken(modifier), { prefix: " " });
+    }
+    insertCommentBeforeLine(sourceFile, lineNumber, position, commentText) {
+        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);
+    }
+    // Na tag, também a inserção de um comentário JSDoc antes de um nó (o `insertJsdocCommentBefore`, CK-03).
+    replaceRangeWithText(sourceFile, range, text) {
+        this.changes.push({ kind: ChangeKind.Text, sourceFile, range, text });
+    }
+    insertText(sourceFile, pos, text) {
+        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. */
+    tryInsertTypeAnnotation(sourceFile, node, type) {
+        let endNode;
+        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;
+    }
+    // Na tag, também a anotação do parâmetro `this` (o `tryInsertThisTypeAnnotation`, CK-02).
+    insertTypeParameters(sourceFile, node, typeParameters) {
+        // 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: ">" });
+    }
+    getOptionsForInsertNodeBefore(before, inserted, doubleNewlines) {
+        // Na tag, também antes de um membro de classe (CK-02).
+        if (isStatement(before)) {
+            return { suffix: doubleNewlines ? 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: ", " };
+        }
+        return Debug.failBadSyntaxKind(before); // We haven't handled this kind of node yet -- add it
+    }
+    // Na tag, também a inserção no começo e no fim do corpo de um construtor (o `insertNodeAtConstructorStart` e o
+    // `insertNodeAtConstructorEnd`, CK-02).
+    insertNodeAtEndOfScope(sourceFile, scope, newNode) {
+        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
+        });
+    }
+    // Na tag, também a inserção de um membro no começo de uma classe ou de uma interface (o `insertNodeAtClassStart`,
+    // CK-02); o worker e os auxiliares dele ficam com o object literal.
+    insertNodeAtObjectStart(sourceFile, obj, newElement) {
+        this.insertNodeAtStartWorker(sourceFile, obj, newElement);
+    }
+    insertNodeAtStartWorker(sourceFile, cls, newElement) {
+        const indentation = this.guessIndentationFromExistingMembers(sourceFile, cls) ?? this.computeIndentationForNewMember(sourceFile, cls);
+        this.insertNodeAt(sourceFile, getMembersOrProperties(cls).pos, newElement, this.getInsertNodeAtStartInsertOptions(sourceFile, cls, indentation));
+    }
+    /**
+     * Tries to guess the indentation from the existing members of a class/interface/object. All members must be on
+     * new lines and must share the same indentation.
+     */
+    guessIndentationFromExistingMembers(sourceFile, cls) {
+        let indentation;
+        let lastRange = cls;
+        for (const member of getMembersOrProperties(cls)) {
+            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;
+    }
+    computeIndentationForNewMember(sourceFile, cls) {
+        const clsStart = cls.getStart(sourceFile);
+        return formatting.SmartIndenter.findFirstNonWhitespaceColumn(getLineStartPositionForPosition(clsStart, sourceFile), clsStart, sourceFile, this.formatContext.options)
+            + (this.formatContext.options.indentSize ?? 4);
+    }
+    getInsertNodeAtStartInsertOptions(sourceFile, cls, indentation) {
+        // Rules:
+        // - Always insert leading newline.
+        // - For object literals:
+        //   - Add a trailing comma if there are existing members in the node, or the source file is not a JSON file
+        //     (because trailing commas are generally illegal in a JSON file).
+        //   - Add a leading comma if the source file is not a JSON file, there are existing insertions,
+        //     and the node is empty (because we didn't add a trailing comma per the previous rule).
+        // - Only insert a trailing newline if body is single-line and there are no other insertions for the node.
+        //   NOTE: This is handled in `finishClassesWithNodesInsertedAtStart`.
+        const members = getMembersOrProperties(cls);
+        const isEmpty = members.length === 0;
+        const isFirstInsertion = addToSeen(this.classesWithNodesInsertedAtStart, getNodeId(cls), { node: cls, sourceFile });
+        const insertTrailingComma = isObjectLiteralExpression(cls) && (!isJsonSourceFile(sourceFile) || !isEmpty);
+        const insertLeadingComma = isObjectLiteralExpression(cls) && isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion;
+        return {
+            indentation,
+            prefix: (insertLeadingComma ? "," : "") + this.newLineCharacter,
+            suffix: insertTrailingComma ? "," : ""
+        };
+    }
+    insertNodeAfterComma(sourceFile, after, newNode) {
+        const endPosition = this.insertNodeAfterWorker(sourceFile, this.nextCommaToken(sourceFile, after) || after, newNode);
+        this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after));
+    }
+    insertNodeAfter(sourceFile, after, newNode) {
+        const endPosition = this.insertNodeAfterWorker(sourceFile, after, newNode);
+        this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after));
+    }
+    insertNodeAtEndOfList(sourceFile, list, newNode) {
+        this.insertNodeAt(sourceFile, list.end, newNode, { prefix: ", " });
+    }
+    insertNodesAfter(sourceFile, after, newNodes) {
+        const endPosition = this.insertNodeAfterWorker(sourceFile, after, first(newNodes));
+        this.insertNodesAt(sourceFile, endPosition, newNodes, this.getInsertNodeAfterOptions(sourceFile, after));
+    }
+    insertNodeAfterWorker(sourceFile, after, newNode) {
+        if (needSemicolonBetween(after, newNode)) {
+            // check if previous statement ends with semicolon
+            // if not - insert semicolon to preserve the code from changing the meaning due to ASI
+            if (sourceFile.text.charCodeAt(after.end - 1) !== CharacterCodes.semicolon) {
+                this.replaceRange(sourceFile, createRange(after.end), createToken(SyntaxKind.SemicolonToken));
+            }
+        }
+        const endPosition = getAdjustedEndPosition(sourceFile, after, {});
+        return endPosition;
+    }
+    getInsertNodeAfterOptions(sourceFile, after) {
+        const options = this.getInsertNodeAfterOptionsWorker(after);
+        return {
+            ...options,
+            prefix: after.end === sourceFile.end && isStatement(after) ? (options.prefix ? `\n${options.prefix}` : "\n") : options.prefix,
+        };
+    }
+    getInsertNodeAfterOptionsWorker(node) {
+        switch (node.kind) {
+            // Na tag, também a classe (CK-02).
+            case SyntaxKind.ModuleDeclaration:
+                return { prefix: this.newLineCharacter, suffix: this.newLineCharacter };
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.StringLiteral:
+            case SyntaxKind.Identifier:
+                return { prefix: ", " };
+            case SyntaxKind.PropertyAssignment:
+                return { suffix: "," + this.newLineCharacter };
+            case SyntaxKind.ExportKeyword:
+                return { prefix: " " };
+            case SyntaxKind.Parameter:
+                return {};
+            default:
+                // Na tag, também o membro de classe (CK-02).
+                Debug.assert(isStatement(node) || isTypeElement(node)); // Else we haven't handled this kind of node yet -- add it
+                return { suffix: this.newLineCharacter };
+        }
+    }
+    // Na tag, também o nome dado a uma function expression, a uma class expression ou a uma arrow, que virava uma
+    // `function` (o `insertName`): só o `convertToEs6Module` o chamava, e ele sai com o CommonJS (CK-03).
+    insertExportModifier(sourceFile, node) {
+        this.insertText(sourceFile, node.getStart(sourceFile), "export ");
+    }
+    /**
+     * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range,
+     * i.e. arguments in arguments lists, parameters in parameter lists etc.
+     * Note that separators are part of the node in statements and class elements.
+     */
+    insertNodeInListAfter(sourceFile, after, newNode, containingList = formatting.SmartIndenter.getContainingList(after, sourceFile)) {
+        if (!containingList) {
+            Debug.fail("node is not a list element");
+            return;
+        }
+        const index = indexOfNode(containingList, after);
+        if (index < 0) {
+            return;
+        }
+        const end = after.getEnd();
+        if (index !== containingList.length - 1) {
+            // any element except the last one
+            // use next sibling as an anchor
+            const nextToken = getTokenAtPosition(sourceFile, after.end);
+            if (nextToken && isSeparator(after, nextToken)) {
+                // for list
+                // a, b, c
+                // create change for adding 'e' after 'a' as
+                // - find start of next element after a (it is b)
+                // - use this start as start and end position in final change
+                // - build text of change by formatting the text of node + separator + whitespace trivia of b
+                // in multiline case it will work as
+                //   a,
+                //   b,
+                //   c,
+                // result - '*' denotes leading trivia that will be inserted after new text (displayed as '#')
+                //   a,*
+                // ***insertedtext<separator>#
+                // ###b,
+                //   c,
+                // find line and character of the next element
+                const lineAndCharOfNextElement = getLineAndCharacterOfPosition(sourceFile, skipWhitespacesAndLineBreaks(sourceFile.text, containingList[index + 1].getFullStart()));
+                // find line and character of the token that precedes next element (usually it is separator)
+                const lineAndCharOfNextToken = getLineAndCharacterOfPosition(sourceFile, nextToken.end);
+                let prefix;
+                let startPos;
+                if (lineAndCharOfNextToken.line === lineAndCharOfNextElement.line) {
+                    // next element is located on the same line with separator:
+                    // a,$$$$b
+                    //  ^    ^
+                    //  |    |-next element
+                    //  |-separator
+                    // where $$$ is some leading trivia
+                    // for a newly inserted node we'll maintain the same relative position comparing to separator and replace leading trivia with spaces
+                    // a,    x,$$$$b
+                    //  ^    ^     ^
+                    //  |    |     |-next element
+                    //  |    |-new inserted node padded with spaces
+                    //  |-separator
+                    startPos = nextToken.end;
+                    prefix = spaces(lineAndCharOfNextElement.character - lineAndCharOfNextToken.character);
+                }
+                else {
+                    // next element is located on different line that separator
+                    // let insert position be the beginning of the line that contains next element
+                    startPos = getStartPositionOfLine(lineAndCharOfNextElement.line, sourceFile);
+                }
+                // write separator and leading trivia of the next element as suffix
+                const suffix = `${tokenToString(nextToken.kind)}${sourceFile.text.substring(nextToken.end, containingList[index + 1].getStart(sourceFile))}`;
+                this.replaceRange(sourceFile, createRange(startPos, containingList[index + 1].getStart(sourceFile)), newNode, { prefix, suffix });
+            }
+        }
+        else {
+            const afterStart = after.getStart(sourceFile);
+            const afterStartLinePosition = getLineStartPositionForPosition(afterStart, sourceFile);
+            let separator;
+            let multilineList = false;
+            // insert element after the last element in the list that has more than one item
+            // pick the element preceding the after element to:
+            // - pick the separator
+            // - determine if list is a multiline
+            if (containingList.length === 1) {
+                // if list has only one element then we'll format is as multiline if node has comment in trailing trivia, or as singleline otherwise
+                // i.e. var x = 1 // this is x
+                //     | new element will be inserted at this position
+                separator = SyntaxKind.CommaToken;
+            }
+            else {
+                // element has more than one element, pick separator from the list
+                const tokenBeforeInsertPosition = findPrecedingToken(after.pos, sourceFile);
+                separator = isSeparator(after, tokenBeforeInsertPosition) ? tokenBeforeInsertPosition.kind : SyntaxKind.CommaToken;
+                // determine if list is multiline by checking lines of after element and element that precedes it.
+                const afterMinusOneStartLinePosition = getLineStartPositionForPosition(containingList[index - 1].getStart(sourceFile), sourceFile);
+                multilineList = afterMinusOneStartLinePosition !== afterStartLinePosition;
+            }
+            if (hasCommentsBeforeLineBreak(sourceFile.text, after.end)) {
+                // in this case we'll always treat containing list as multiline
+                multilineList = true;
+            }
+            if (multilineList) {
+                // insert separator immediately following the 'after' node to preserve comments in trailing trivia
+                this.replaceRange(sourceFile, createRange(end), createToken(separator));
+                // use the same indentation as 'after' item
+                const indentation = formatting.SmartIndenter.findFirstNonWhitespaceColumn(afterStartLinePosition, afterStart, sourceFile, this.formatContext.options);
+                // insert element before the line break on the line that contains 'after' element
+                let insertPos = skipTrivia(sourceFile.text, end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ false);
+                if (insertPos !== end && isLineBreak(sourceFile.text.charCodeAt(insertPos - 1))) {
+                    insertPos--;
+                }
+                this.replaceRange(sourceFile, createRange(insertPos), newNode, { indentation, prefix: this.newLineCharacter });
+            }
+            else {
+                this.replaceRange(sourceFile, createRange(end), newNode, { prefix: `${tokenToString(separator)} ` });
+            }
+        }
+    }
+    parenthesizeExpression(sourceFile, expression) {
+        this.replaceRange(sourceFile, rangeOfNode(expression), createParen(expression));
+    }
+    finishClassesWithNodesInsertedAtStart() {
+        this.classesWithNodesInsertedAtStart.forEach(({ node, sourceFile }) => {
+            const [openBraceEnd, closeBraceEnd] = getClassOrObjectBraceEnds(node, sourceFile);
+            if (openBraceEnd !== undefined && closeBraceEnd !== undefined) {
+                const isEmpty = getMembersOrProperties(node).length === 0;
+                const isSingleLine = positionsAreOnSameLine(openBraceEnd, closeBraceEnd, sourceFile);
+                if (isEmpty && isSingleLine && openBraceEnd !== closeBraceEnd - 1) {
+                    // For `class C { }` remove the whitespace inside the braces.
+                    this.deleteRange(sourceFile, createRange(openBraceEnd, closeBraceEnd - 1));
+                }
+                if (isSingleLine) {
+                    this.insertText(sourceFile, closeBraceEnd - 1, this.newLineCharacter);
+                }
+            }
+        });
+    }
+    finishDeleteDeclarations() {
+        const deletedNodesInLists = new NodeSet(); // Stores nodes in lists that we already deleted. Used to avoid deleting `, ` twice in `a, b`.
+        for (const { sourceFile, node } of this.deletedNodes) {
+            if (!this.deletedNodes.some(d => d.sourceFile === sourceFile && rangeContainsRangeExclusive(d.node, node))) {
+                if (isArray(node)) {
+                    this.deleteRange(sourceFile, rangeOfTypeParameters(node));
+                }
+                else {
+                    deleteDeclaration.deleteDeclaration(this, deletedNodesInLists, sourceFile, node);
+                }
+            }
+        }
+        deletedNodesInLists.forEach(node => {
+            const sourceFile = node.getSourceFile();
+            const list = formatting.SmartIndenter.getContainingList(node, sourceFile);
+            if (node !== last(list))
+                return;
+            const lastNonDeletedIndex = findLastIndex(list, n => !deletedNodesInLists.has(n), list.length - 2);
+            if (lastNonDeletedIndex !== -1) {
+                this.deleteRange(sourceFile, { pos: list[lastNonDeletedIndex].end, end: startPositionToDeleteNodeInList(sourceFile, list[lastNonDeletedIndex + 1]) });
+            }
+        });
+    }
+    /**
+     * Note: after calling this, the TextChanges object must be discarded!
+     * @param validate only for tests
+     *    The reason we must validate as part of this method is that `getNonFormattedText` changes the node's positions,
+     *    so we can only call this once and can't get the non-formatted text separately.
+     */
+    getChanges(validate) {
+        this.finishDeleteDeclarations();
+        this.finishClassesWithNodesInsertedAtStart();
+        const changes = changesToText.getTextChangesFromChanges(this.changes, this.newLineCharacter, this.formatContext, validate);
+        for (const { oldFile, fileName, statements } of this.newFiles) {
+            changes.push(changesToText.newFileChanges(oldFile, fileName, statements, this.newLineCharacter, this.formatContext));
+        }
+        return changes;
+    }
+    createNewFile(oldFile, fileName, statements) {
+        this.newFiles.push({ oldFile, fileName, statements });
+    }
+}
+// find first non-whitespace position in the leading trivia of the node
+function startPositionToDeleteNodeInList(sourceFile, node) {
+    return skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
+}
+// Os dois auxiliares abaixo: na tag, também a classe e a interface (CK-02).
+function getClassOrObjectBraceEnds(cls, sourceFile) {
+    const open = findChildOfKind(cls, SyntaxKind.OpenBraceToken, sourceFile);
+    const close = findChildOfKind(cls, SyntaxKind.CloseBraceToken, sourceFile);
+    return [open?.end, close?.end];
+}
+function getMembersOrProperties(cls) {
+    return cls.properties;
+}
+export function getNewFileText(statements, scriptKind, newLineCharacter, formatContext) {
+    return changesToText.newFileChangesWorker(/*oldFile*/ undefined, scriptKind, statements, newLineCharacter, formatContext);
+}
+var changesToText;
+(function (changesToText) {
+    function getTextChangesFromChanges(changes, newLineCharacter, formatContext, validate) {
+        return mapDefined(group(changes, c => c.sourceFile.path), changesInFile => {
+            const sourceFile = changesInFile[0].sourceFile;
+            // order changes by start position
+            // If the start position is the same, put the shorter range first, since an empty range (x, x) may precede (x, y) but not vice-versa.
+            const normalized = stableSort(changesInFile, (a, b) => (a.range.pos - b.range.pos) || (a.range.end - b.range.end));
+            // verify that change intervals do not overlap, except possibly at end points.
+            for (let i = 0; i < normalized.length - 1; i++) {
+                Debug.assert(normalized[i].range.end <= normalized[i + 1].range.pos, "Changes overlap", () => `${JSON.stringify(normalized[i].range)} and ${JSON.stringify(normalized[i + 1].range)}`);
+            }
+            const textChanges = mapDefined(normalized, c => {
+                const span = createTextSpanFromRange(c.range);
+                const newText = computeNewText(c, sourceFile, newLineCharacter, formatContext, validate);
+                // Filter out redundant changes.
+                if (span.length === newText.length && stringContainsAt(sourceFile.text, newText, span.start)) {
+                    return undefined;
+                }
+                return createTextChange(span, newText);
+            });
+            return textChanges.length > 0 ? { fileName: sourceFile.fileName, textChanges } : undefined;
+        });
+    }
+    changesToText.getTextChangesFromChanges = getTextChangesFromChanges;
+    function newFileChanges(oldFile, fileName, statements, newLineCharacter, formatContext) {
+        const text = newFileChangesWorker(oldFile, getScriptKindFromFileName(fileName), statements, newLineCharacter, formatContext);
+        return { fileName, textChanges: [createTextChange(createTextSpan(0, 0), text)], isNewFile: true };
+    }
+    changesToText.newFileChanges = newFileChanges;
+    function newFileChangesWorker(oldFile, scriptKind, statements, newLineCharacter, formatContext) {
+        // TODO: this emits the file, parses it back, then formats it that -- may be a less roundabout way to do this
+        const nonFormattedText = statements.map(s => getNonformattedText(s, oldFile, newLineCharacter).text).join(newLineCharacter);
+        const sourceFile = createSourceFile("any file name", nonFormattedText, ScriptTarget.ESNext, /*setParentNodes*/ true, scriptKind);
+        const changes = formatting.formatDocument(sourceFile, formatContext);
+        return applyChanges(nonFormattedText, changes) + newLineCharacter;
+    }
+    changesToText.newFileChangesWorker = newFileChangesWorker;
+    function computeNewText(change, sourceFile, newLineCharacter, formatContext, validate) {
+        if (change.kind === ChangeKind.Remove) {
+            return "";
+        }
+        if (change.kind === ChangeKind.Text) {
+            return change.text;
+        }
+        const { options = {}, range: { pos } } = change;
+        const format = (n) => getFormattedTextOfNode(n, sourceFile, pos, options, newLineCharacter, formatContext, validate);
+        const text = change.kind === ChangeKind.ReplaceWithMultipleNodes
+            ? change.nodes.map(n => removeSuffix(format(n), newLineCharacter)).join(change.options.joiner || newLineCharacter) // TODO: GH#18217
+            : format(change.node);
+        // strip initial indentation (spaces or tabs) if text will be inserted in the middle of the line
+        const noIndent = (options.preserveLeadingWhitespace || options.indentation !== undefined || getLineStartPositionForPosition(pos, sourceFile) === pos) ? text : text.replace(/^\s+/, "");
+        return (options.prefix || "") + noIndent
+            + ((!options.suffix || endsWith(noIndent, options.suffix))
+                ? "" : options.suffix);
+    }
+    function getFormatCodeSettingsForWriting({ options }, sourceFile) {
+        const shouldAutoDetectSemicolonPreference = !options.semicolons || options.semicolons === SemicolonPreference.Ignore;
+        const shouldRemoveSemicolons = options.semicolons === SemicolonPreference.Remove || shouldAutoDetectSemicolonPreference && !probablyUsesSemicolons(sourceFile);
+        return {
+            ...options,
+            semicolons: shouldRemoveSemicolons ? SemicolonPreference.Remove : SemicolonPreference.Ignore,
+        };
+    }
+    /** Note: this may mutate `nodeIn`. */
+    function getFormattedTextOfNode(nodeIn, sourceFile, pos, { indentation, prefix, delta }, newLineCharacter, formatContext, validate) {
+        const { node, text } = getNonformattedText(nodeIn, sourceFile, newLineCharacter);
+        if (validate)
+            validate(node, text);
+        const formatOptions = getFormatCodeSettingsForWriting(formatContext, sourceFile);
+        const initialIndentation = indentation !== undefined
+            ? indentation
+            : formatting.SmartIndenter.getIndentation(pos, sourceFile, formatOptions, prefix === newLineCharacter || getLineStartPositionForPosition(pos, sourceFile) === pos);
+        if (delta === undefined) {
+            delta = formatting.SmartIndenter.shouldIndentChildNode(formatOptions, nodeIn) ? (formatOptions.indentSize || 0) : 0;
+        }
+        const file = { text, getLineAndCharacterOfPosition(pos) { return getLineAndCharacterOfPosition(this, pos); } };
+        const changes = formatting.formatNodeGivenIndentation(node, file, sourceFile.languageVariant, initialIndentation, delta, { ...formatContext, options: formatOptions });
+        return applyChanges(text, changes);
+    }
+    /** Note: output node may be mutated input node. */
+    function getNonformattedText(node, sourceFile, newLineCharacter) {
+        const writer = createWriter(newLineCharacter);
+        const newLine = newLineCharacter === "\n" ? NewLineKind.LineFeed : NewLineKind.CarriageReturnLineFeed;
+        createPrinter({ newLine, neverAsciiEscape: true, preserveSourceNewlines: true }, writer).writeNode(EmitHint.Unspecified, node, sourceFile, writer);
+        return { text: writer.getText(), node: assignPositionsToNode(node) };
+    }
+    changesToText.getNonformattedText = getNonformattedText;
+})(changesToText || (changesToText = {}));
+export function applyChanges(text, changes) {
+    for (let i = changes.length - 1; i >= 0; i--) {
+        const { span, newText } = changes[i];
+        text = `${text.substring(0, span.start)}${newText}${text.substring(textSpanEnd(span))}`;
+    }
+    return text;
+}
+function isTrivia(s) {
+    return skipTrivia(s, 0) === s.length;
+}
+function assignPositionsToNode(node) {
+    // O `as`: as sobrecargas do `visitNodes` não aceitam o callback sob o `strict` do repo (o §5 da arquitetura do checker).
+    const visited = visitEachChild(node, assignPositionsToNode, nullTransformationContext, assignPositionsToNodeArray, assignPositionsToNode); // TODO: GH#18217
+    // create proxy node for non synthesized nodes
+    const newNode = nodeIsSynthesized(visited) ? visited : Object.create(visited);
+    newNode.pos = getPos(node);
+    newNode.end = getEnd(node);
+    return newNode;
+}
+function assignPositionsToNodeArray(nodes, visitor, test, start, count) {
+    const visited = visitNodes(nodes, visitor, test, start, count);
+    if (!visited) {
+        return visited;
+    }
+    // clone nodearray if necessary
+    const nodeArray = visited === nodes ? createNodeArray(visited.slice(0)) : visited;
+    nodeArray.pos = getPos(nodes);
+    nodeArray.end = getEnd(nodes);
+    return nodeArray;
+}
+function createWriter(newLine) {
+    let lastNonTriviaPosition = 0;
+    const writer = createTextWriter(newLine);
+    const onEmitNode = (hint, node, printCallback) => {
+        if (node) {
+            setPos(node, lastNonTriviaPosition);
+        }
+        printCallback(hint, node);
+        if (node) {
+            setEnd(node, lastNonTriviaPosition);
+        }
+    };
+    const onBeforeEmitNodeArray = nodes => {
+        if (nodes) {
+            setPos(nodes, lastNonTriviaPosition);
+        }
+    };
+    const onAfterEmitNodeArray = nodes => {
+        if (nodes) {
+            setEnd(nodes, lastNonTriviaPosition);
+        }
+    };
+    const onBeforeEmitToken = node => {
+        if (node) {
+            setPos(node, lastNonTriviaPosition);
+        }
+    };
+    const onAfterEmitToken = node => {
+        if (node) {
+            setEnd(node, lastNonTriviaPosition);
+        }
+    };
+    function setLastNonTriviaPosition(s, force) {
+        if (force || !isTrivia(s)) {
+            lastNonTriviaPosition = writer.getTextPos();
+            let i = 0;
+            while (isWhiteSpaceLike(s.charCodeAt(s.length - i - 1))) {
+                i++;
+            }
+            // trim trailing whitespaces
+            lastNonTriviaPosition -= i;
+        }
+    }
+    function write(s) {
+        writer.write(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeComment(s) {
+        writer.writeComment(s);
+    }
+    function writeKeyword(s) {
+        writer.writeKeyword(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeOperator(s) {
+        writer.writeOperator(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writePunctuation(s) {
+        writer.writePunctuation(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeTrailingSemicolon(s) {
+        writer.writeTrailingSemicolon(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeParameter(s) {
+        writer.writeParameter(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeProperty(s) {
+        writer.writeProperty(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeSpace(s) {
+        writer.writeSpace(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeStringLiteral(s) {
+        writer.writeStringLiteral(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeSymbol(s, sym) {
+        writer.writeSymbol(s, sym);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeLine(force) {
+        writer.writeLine(force);
+    }
+    function increaseIndent() {
+        writer.increaseIndent();
+    }
+    function decreaseIndent() {
+        writer.decreaseIndent();
+    }
+    function getText() {
+        return writer.getText();
+    }
+    function rawWrite(s) {
+        writer.rawWrite(s);
+        setLastNonTriviaPosition(s, /*force*/ false);
+    }
+    function writeLiteral(s) {
+        writer.writeLiteral(s);
+        setLastNonTriviaPosition(s, /*force*/ true);
+    }
+    function getTextPos() {
+        return writer.getTextPos();
+    }
+    function getLine() {
+        return writer.getLine();
+    }
+    function getColumn() {
+        return writer.getColumn();
+    }
+    function getIndent() {
+        return writer.getIndent();
+    }
+    function isAtStartOfLine() {
+        return writer.isAtStartOfLine();
+    }
+    function clear() {
+        writer.clear();
+        lastNonTriviaPosition = 0;
+    }
+    return {
+        onEmitNode,
+        onBeforeEmitNodeArray,
+        onAfterEmitNodeArray,
+        onBeforeEmitToken,
+        onAfterEmitToken,
+        write,
+        writeComment,
+        writeKeyword,
+        writeOperator,
+        writePunctuation,
+        writeTrailingSemicolon,
+        writeParameter,
+        writeProperty,
+        writeSpace,
+        writeStringLiteral,
+        writeSymbol,
+        writeLine,
+        increaseIndent,
+        decreaseIndent,
+        getText,
+        rawWrite,
+        writeLiteral,
+        getTextPos,
+        getLine,
+        getColumn,
+        getIndent,
+        isAtStartOfLine,
+        hasTrailingComment: () => writer.hasTrailingComment(),
+        hasTrailingWhitespace: () => writer.hasTrailingWhitespace(),
+        clear
+    };
+}
+function getInsertionPositionAtSourceFileTop(sourceFile) {
+    let lastPrologue;
+    for (const node of sourceFile.statements) {
+        if (isPrologueDirective(node)) {
+            lastPrologue = node;
+        }
+        else {
+            break;
+        }
+    }
+    let position = 0;
+    const text = sourceFile.text;
+    if (lastPrologue) {
+        position = lastPrologue.end;
+        advancePastLineBreak();
+        return position;
+    }
+    const shebang = getShebang(text);
+    if (shebang !== undefined) {
+        position = shebang.length;
+        advancePastLineBreak();
+    }
+    const ranges = getLeadingCommentRanges(text, position);
+    if (!ranges)
+        return position;
+    // Find the first attached comment to the first node and add before it
+    let lastComment;
+    let firstNodeLine;
+    for (const range of ranges) {
+        if (range.kind === SyntaxKind.MultiLineCommentTrivia) {
+            if (isPinnedComment(text, range.pos)) {
+                lastComment = { range, pinnedOrTripleSlash: true };
+                continue;
+            }
+        }
+        else if (isRecognizedTripleSlashComment(text, range.pos, range.end)) {
+            lastComment = { range, pinnedOrTripleSlash: true };
+            continue;
+        }
+        if (lastComment) {
+            // Always insert after pinned or triple slash comments
+            if (lastComment.pinnedOrTripleSlash)
+                break;
+            // There was a blank line between the last comment and this comment.
+            // This comment is not part of the copyright comments
+            const commentLine = sourceFile.getLineAndCharacterOfPosition(range.pos).line;
+            const lastCommentEndLine = sourceFile.getLineAndCharacterOfPosition(lastComment.range.end).line;
+            if (commentLine >= lastCommentEndLine + 2)
+                break;
+        }
+        if (sourceFile.statements.length) {
+            if (firstNodeLine === undefined)
+                firstNodeLine = sourceFile.getLineAndCharacterOfPosition(sourceFile.statements[0].getStart()).line;
+            const commentEndLine = sourceFile.getLineAndCharacterOfPosition(range.end).line;
+            if (firstNodeLine < commentEndLine + 2)
+                break;
+        }
+        lastComment = { range, pinnedOrTripleSlash: false };
+    }
+    if (lastComment) {
+        position = lastComment.range.end;
+        advancePastLineBreak();
+    }
+    return position;
+    function advancePastLineBreak() {
+        if (position < text.length) {
+            const charCode = text.charCodeAt(position);
+            if (isLineBreak(charCode)) {
+                position++;
+                if (position < text.length && charCode === CharacterCodes.carriageReturn && text.charCodeAt(position) === CharacterCodes.lineFeed) {
+                    position++;
+                }
+            }
+        }
+    }
+}
+export function isValidLocationToAddComment(sourceFile, position) {
+    return !isInComment(sourceFile, position) && !isInString(sourceFile, position) && !isInTemplateString(sourceFile, position) && !isInJSXText(sourceFile, position);
+}
+function needSemicolonBetween(a, b) {
+    // Na tag, também a propriedade e o membro de classe (CK-02).
+    return isPropertySignature(a) && isTypeElement(b) && b.name.kind === SyntaxKind.ComputedPropertyName
+        || isStatementButNotDeclaration(a) && isStatementButNotDeclaration(b); // TODO: only if b would start with a `(` or `[`
+}
+var deleteDeclaration;
+(function (deleteDeclaration_1) {
+    function deleteDeclaration(changes, deletedNodesInLists, sourceFile, node) {
+        switch (node.kind) {
+            case SyntaxKind.Parameter: {
+                const oldFunction = node.parent;
+                if (isArrowFunction(oldFunction) &&
+                    oldFunction.parameters.length === 1 &&
+                    !findChildOfKind(oldFunction, SyntaxKind.OpenParenToken, sourceFile)) {
+                    // Lambdas with exactly one parameter are special because, after removal, there
+                    // must be an empty parameter list (i.e. `()`) and this won't necessarily be the
+                    // case if the parameter is simply removed (e.g. in `x => 1`).
+                    changes.replaceNodeWithText(sourceFile, node, "()");
+                }
+                else {
+                    deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
+                }
+                break;
+            }
+            // Na tag, também o `import =` (CK-03).
+            case SyntaxKind.ImportDeclaration:
+                const isFirstImport = sourceFile.imports.length && node === first(sourceFile.imports).parent || node === find(sourceFile.statements, isAnyImportSyntax);
+                // For first import, leave header comment in place, otherwise only delete JSDoc comments
+                // Na tag, com o JSDoc preso ao import; a cópia não tem o JSDoc (CK-03).
+                deleteNode(changes, sourceFile, node, { leadingTriviaOption: isFirstImport ? LeadingTriviaOption.Exclude : LeadingTriviaOption.StartLine });
+                break;
+            case SyntaxKind.BindingElement:
+                const pattern = node.parent;
+                const preserveComma = pattern.kind === SyntaxKind.ArrayBindingPattern && node !== last(pattern.elements);
+                if (preserveComma) {
+                    deleteNode(changes, sourceFile, node);
+                }
+                else {
+                    deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
+                }
+                break;
+            case SyntaxKind.VariableDeclaration:
+                deleteVariableDeclaration(changes, deletedNodesInLists, sourceFile, node);
+                break;
+            case SyntaxKind.TypeParameter:
+                deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
+                break;
+            case SyntaxKind.ImportSpecifier:
+                const namedImports = node.parent;
+                if (namedImports.elements.length === 1) {
+                    deleteImportBinding(changes, sourceFile, namedImports);
+                }
+                else {
+                    deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
+                }
+                break;
+            case SyntaxKind.NamespaceImport:
+                deleteImportBinding(changes, sourceFile, node);
+                break;
+            case SyntaxKind.SemicolonToken:
+                deleteNode(changes, sourceFile, node, { trailingTriviaOption: TrailingTriviaOption.Exclude });
+                break;
+            // Na tag, também a palavra `function`, a classe e a `function` declarada (CK-02).
+            default:
+                if (isImportClause(node.parent) && node.parent.name === node) {
+                    deleteDefaultImport(changes, sourceFile, node.parent);
+                }
+                else if (isCallExpression(node.parent) && contains(node.parent.arguments, node)) {
+                    deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
+                }
+                else {
+                    deleteNode(changes, sourceFile, node);
+                }
+        }
+    }
+    deleteDeclaration_1.deleteDeclaration = deleteDeclaration;
+    function deleteDefaultImport(changes, sourceFile, importClause) {
+        if (!importClause.namedBindings) {
+            // Delete the whole import
+            deleteNode(changes, sourceFile, importClause.parent);
+        }
+        else {
+            // import |d,| * as ns from './file'
+            const start = importClause.name.getStart(sourceFile);
+            const nextToken = getTokenAtPosition(sourceFile, importClause.name.end);
+            if (nextToken && nextToken.kind === SyntaxKind.CommaToken) {
+                // shift first non-whitespace position after comma to the start position of the node
+                const end = skipTrivia(sourceFile.text, nextToken.end, /*stopAfterLineBreaks*/ false, /*stopAtComments*/ true);
+                changes.deleteRange(sourceFile, { pos: start, end });
+            }
+            else {
+                deleteNode(changes, sourceFile, importClause.name);
+            }
+        }
+    }
+    function deleteImportBinding(changes, sourceFile, node) {
+        if (node.parent.name) {
+            // Delete named imports while preserving the default import
+            // import d|, * as ns| from './file'
+            // import d|, { a }| from './file'
+            const previousToken = Debug.checkDefined(getTokenAtPosition(sourceFile, node.pos - 1));
+            changes.deleteRange(sourceFile, { pos: previousToken.getStart(sourceFile), end: node.end });
+        }
+        else {
+            // Delete the entire import declaration
+            // |import * as ns from './file'|
+            // |import { a } from './file'|
+            const importDecl = getAncestor(node, SyntaxKind.ImportDeclaration);
+            deleteNode(changes, sourceFile, importDecl);
+        }
+    }
+    function deleteVariableDeclaration(changes, deletedNodesInLists, sourceFile, node) {
+        const { parent } = node;
+        if (parent.kind === SyntaxKind.CatchClause) {
+            // TODO: There's currently no unused diagnostic for this, could be a suggestion
+            changes.deleteNodeRange(sourceFile, findChildOfKind(parent, SyntaxKind.OpenParenToken, sourceFile), findChildOfKind(parent, SyntaxKind.CloseParenToken, sourceFile));
+            return;
+        }
+        if (parent.declarations.length !== 1) {
+            deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
+            return;
+        }
+        const gp = parent.parent;
+        switch (gp.kind) {
+            case SyntaxKind.ForOfStatement:
+            case SyntaxKind.ForInStatement:
+                changes.replaceNode(sourceFile, node, createObjectLiteral());
+                break;
+            case SyntaxKind.ForStatement:
+                deleteNode(changes, sourceFile, parent);
+                break;
+            case SyntaxKind.VariableStatement:
+                // Na tag, com o JSDoc preso à declaração; a cópia não tem o JSDoc (CK-03).
+                deleteNode(changes, sourceFile, gp, { leadingTriviaOption: LeadingTriviaOption.StartLine });
+                break;
+            default:
+                Debug.assertNever(gp);
+        }
+    }
+})(deleteDeclaration || (deleteDeclaration = {}));
+/** Warning: This deletes comments too. See `copyComments` in `convertFunctionToEs6Class`. */
+// Exported for tests only! (TODO: improve tests to not need this)
+export function deleteNode(changes, sourceFile, node, options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }) {
+    const startPosition = getAdjustedStartPosition(sourceFile, node, options);
+    const endPosition = getAdjustedEndPosition(sourceFile, node, options);
+    changes.deleteRange(sourceFile, { pos: startPosition, end: endPosition });
+}
+function deleteNodeInList(changes, deletedNodesInLists, sourceFile, node) {
+    const containingList = Debug.checkDefined(formatting.SmartIndenter.getContainingList(node, sourceFile));
+    const index = indexOfNode(containingList, node);
+    Debug.assert(index !== -1);
+    if (containingList.length === 1) {
+        deleteNode(changes, sourceFile, node);
+        return;
+    }
+    // Note: We will only delete a comma *after* a node. This will leave a trailing comma if we delete the last node.
+    // That's handled in the end by `finishTrailingCommaAfterDeletingNodesInList`.
+    Debug.assert(!deletedNodesInLists.has(node), "Deleting a node twice");
+    deletedNodesInLists.add(node);
+    changes.deleteRange(sourceFile, {
+        pos: startPositionToDeleteNodeInList(sourceFile, node),
+        end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : startPositionToDeleteNodeInList(sourceFile, containingList[index + 1]),
+    });
+}