@tslite/services 0.0.0-stage → 1.13.0

package/dist/formatting/smartIndenter.js

@@ -0,0 +1,518 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/formatting/smartIndenter.ts: o namespace virou módulo ES, com os imports explícitos.
+import { CharacterCodes, Debug, IndentStyle, SyntaxKind, contains, find, findChildOfKind, findListItemInfo, findNextToken, findPrecedingToken, getLineAndCharacterOfPosition, getLineStartPositionForPosition, getRangeOfEnclosingComment, getStartPositionOfLine, isCallExpression, isCallOrNewExpression, isDeclaration, isStatementButNotDeclaration, isStringOrRegularExpressionOrTemplateLiteral, isWhiteSpaceLike, isWhiteSpaceSingleLine, positionBelongsToNode, rangeContainsRange, rangeContainsStartEnd, skipTrivia, } from "../_namespaces/edit.js";
+export var SmartIndenter;
+(function (SmartIndenter) {
+    let Value;
+    (function (Value) {
+        Value[Value["Unknown"] = -1] = "Unknown";
+    })(Value || (Value = {}));
+    /**
+     * @param assumeNewLineBeforeCloseBrace
+     * `false` when called on text from a real source file.
+     * `true` when we need to assume `position` is on a newline.
+     *
+     * This is useful for codefixes. Consider
+     * ```
+     * function f() {
+     * |}
+     * ```
+     * with `position` at `|`.
+     *
+     * When inserting some text after an open brace, we would like to get indentation as if a newline was already there.
+     * By default indentation at `position` will be 0 so 'assumeNewLineBeforeCloseBrace' overrides this behavior.
+     */
+    function getIndentation(position, sourceFile, options, assumeNewLineBeforeCloseBrace = false) {
+        if (position > sourceFile.text.length) {
+            return getBaseIndentation(options); // past EOF
+        }
+        // no indentation when the indent style is set to none,
+        // so we can return fast
+        if (options.indentStyle === IndentStyle.None) {
+            return 0;
+        }
+        // Na tag, sem o token de um JSDoc (o `excludeJsdoc`, CK-03).
+        const precedingToken = findPrecedingToken(position, sourceFile, /*startNode*/ undefined);
+        // eslint-disable-next-line no-null/no-null
+        const enclosingCommentRange = getRangeOfEnclosingComment(sourceFile, position, precedingToken || null);
+        if (enclosingCommentRange && enclosingCommentRange.kind === SyntaxKind.MultiLineCommentTrivia) {
+            return getCommentIndent(sourceFile, position, options, enclosingCommentRange);
+        }
+        if (!precedingToken) {
+            return getBaseIndentation(options);
+        }
+        // no indentation in string \regex\template literals
+        const precedingTokenIsLiteral = isStringOrRegularExpressionOrTemplateLiteral(precedingToken.kind);
+        if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && position < precedingToken.end) {
+            return 0;
+        }
+        const lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
+        // indentation is first non-whitespace character in a previous line
+        // for block indentation, we should look for a line which contains something that's not
+        // whitespace.
+        if (options.indentStyle === IndentStyle.Block) {
+            return getBlockIndent(sourceFile, position, options);
+        }
+        if (precedingToken.kind === SyntaxKind.CommaToken && precedingToken.parent.kind !== SyntaxKind.BinaryExpression) {
+            // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
+            const actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options);
+            if (actualIndentation !== -1 /* Value.Unknown */) {
+                return actualIndentation;
+            }
+        }
+        const containerList = getListByPosition(position, precedingToken.parent, sourceFile);
+        // use list position if the preceding token is before any list items
+        if (containerList && !rangeContainsRange(containerList, precedingToken)) {
+            return getActualIndentationForListStartLine(containerList, sourceFile, options) + options.indentSize; // TODO: GH#18217
+        }
+        return getSmartIndent(sourceFile, position, precedingToken, lineAtPosition, assumeNewLineBeforeCloseBrace, options);
+    }
+    SmartIndenter.getIndentation = getIndentation;
+    function getCommentIndent(sourceFile, position, options, enclosingCommentRange) {
+        const previousLine = getLineAndCharacterOfPosition(sourceFile, position).line - 1;
+        const commentStartLine = getLineAndCharacterOfPosition(sourceFile, enclosingCommentRange.pos).line;
+        Debug.assert(commentStartLine >= 0);
+        if (previousLine <= commentStartLine) {
+            return findFirstNonWhitespaceColumn(getStartPositionOfLine(commentStartLine, sourceFile), position, sourceFile, options);
+        }
+        const startPositionOfLine = getStartPositionOfLine(previousLine, sourceFile);
+        const { column, character } = findFirstNonWhitespaceCharacterAndColumn(startPositionOfLine, position, sourceFile, options);
+        if (column === 0) {
+            return column;
+        }
+        const firstNonWhitespaceCharacterCode = sourceFile.text.charCodeAt(startPositionOfLine + character);
+        return firstNonWhitespaceCharacterCode === CharacterCodes.asterisk ? column - 1 : column;
+    }
+    function getBlockIndent(sourceFile, position, options) {
+        // move backwards until we find a line with a non-whitespace character,
+        // then find the first non-whitespace character for that line.
+        let current = position;
+        while (current > 0) {
+            const char = sourceFile.text.charCodeAt(current);
+            if (!isWhiteSpaceLike(char)) {
+                break;
+            }
+            current--;
+        }
+        const lineStart = getLineStartPositionForPosition(current, sourceFile);
+        return findFirstNonWhitespaceColumn(lineStart, current, sourceFile, options);
+    }
+    function getSmartIndent(sourceFile, position, precedingToken, lineAtPosition, assumeNewLineBeforeCloseBrace, options) {
+        // try to find node that can contribute to indentation and includes 'position' starting from 'precedingToken'
+        // if such node is found - compute initial indentation for 'position' inside this node
+        let previous;
+        let current = precedingToken;
+        while (current) {
+            if (positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(options, current, previous, sourceFile, /*isNextChild*/ true)) {
+                const currentStart = getStartLineAndCharacterForNode(current, sourceFile);
+                const nextTokenKind = nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile);
+                const indentationDelta = nextTokenKind !== 0 /* NextTokenKind.Unknown */
+                    // handle cases when codefix is about to be inserted before the close brace
+                    ? assumeNewLineBeforeCloseBrace && nextTokenKind === 2 /* NextTokenKind.CloseBrace */ ? options.indentSize : 0
+                    : lineAtPosition !== currentStart.line ? options.indentSize : 0;
+                return getIndentationForNodeWorker(current, currentStart, /*ignoreActualIndentationRange*/ undefined, indentationDelta, sourceFile, /*isNextChild*/ true, options); // TODO: GH#18217
+            }
+            // check if current node is a list item - if yes, take indentation from it
+            // do not consider parent-child line sharing yet:
+            // function foo(a
+            //    | preceding node 'a' does share line with its parent but indentation is expected
+            const actualIndentation = getActualIndentationForListItem(current, sourceFile, options, /*listIndentsChild*/ true);
+            if (actualIndentation !== -1 /* Value.Unknown */) {
+                return actualIndentation;
+            }
+            previous = current;
+            current = current.parent;
+        }
+        // no parent was found - return the base indentation of the SourceFile
+        return getBaseIndentation(options);
+    }
+    function getIndentationForNode(n, ignoreActualIndentationRange, sourceFile, options) {
+        const start = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
+        return getIndentationForNodeWorker(n, start, ignoreActualIndentationRange, /*indentationDelta*/ 0, sourceFile, /*isNextChild*/ false, options);
+    }
+    SmartIndenter.getIndentationForNode = getIndentationForNode;
+    function getBaseIndentation(options) {
+        return options.baseIndentSize || 0;
+    }
+    SmartIndenter.getBaseIndentation = getBaseIndentation;
+    function getIndentationForNodeWorker(current, currentStart, ignoreActualIndentationRange, indentationDelta, sourceFile, isNextChild, options) {
+        let parent = current.parent;
+        // Walk up the tree and collect indentation for parent-child node pairs. Indentation is not added if
+        // * parent and child nodes start on the same line, or
+        // * parent is an IfStatement and child starts on the same line as an 'else clause'.
+        while (parent) {
+            let useActualIndentation = true;
+            if (ignoreActualIndentationRange) {
+                const start = current.getStart(sourceFile);
+                useActualIndentation = start < ignoreActualIndentationRange.pos || start > ignoreActualIndentationRange.end;
+            }
+            const containingListOrParentStart = getContainingListOrParentStart(parent, current, sourceFile);
+            const parentAndChildShareLine = containingListOrParentStart.line === currentStart.line ||
+                childStartsOnTheSameLineWithElseInIfStatement(parent, current, currentStart.line, sourceFile);
+            if (useActualIndentation) {
+                // check if current node is a list item - if yes, take indentation from it
+                let actualIndentation = getActualIndentationForListItem(current, sourceFile, options, !parentAndChildShareLine);
+                if (actualIndentation !== -1 /* Value.Unknown */) {
+                    return actualIndentation + indentationDelta;
+                }
+                // try to fetch actual indentation for current node from source text
+                actualIndentation = getActualIndentationForNode(current, parent, currentStart, parentAndChildShareLine, sourceFile, options);
+                if (actualIndentation !== -1 /* Value.Unknown */) {
+                    return actualIndentation + indentationDelta;
+                }
+            }
+            // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line
+            if (shouldIndentChildNode(options, parent, current, sourceFile, isNextChild) && !parentAndChildShareLine) {
+                indentationDelta += options.indentSize;
+            }
+            // In our AST, a call argument's `parent` is the call-expression, not the argument list.
+            // We would like to increase indentation based on the relationship between an argument and its argument-list,
+            // so we spoof the starting position of the (parent) call-expression to match the (non-parent) argument-list.
+            // But, the spoofed start-value could then cause a problem when comparing the start position of the call-expression
+            // to *its* parent (in the case of an iife, an expression statement), adding an extra level of indentation.
+            //
+            // Instead, when at an argument, we unspoof the starting position of the enclosing call expression
+            // *after* applying indentation for the argument.
+            const useTrueStart = isArgumentAndStartLineOverlapsExpressionBeingCalled(parent, current, currentStart.line, sourceFile);
+            current = parent;
+            parent = current.parent;
+            currentStart = useTrueStart ? sourceFile.getLineAndCharacterOfPosition(current.getStart(sourceFile)) : containingListOrParentStart;
+        }
+        return indentationDelta + getBaseIndentation(options);
+    }
+    function getContainingListOrParentStart(parent, child, sourceFile) {
+        const containingList = getContainingList(child, sourceFile);
+        const startPos = containingList ? containingList.pos : parent.getStart(sourceFile);
+        return sourceFile.getLineAndCharacterOfPosition(startPos);
+    }
+    /*
+     * Function returns Value.Unknown if indentation cannot be determined
+     */
+    function getActualIndentationForListItemBeforeComma(commaToken, sourceFile, options) {
+        // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
+        const commaItemInfo = findListItemInfo(commaToken);
+        if (commaItemInfo && commaItemInfo.listItemIndex > 0) {
+            return deriveActualIndentationFromList(commaItemInfo.list.getChildren(), commaItemInfo.listItemIndex - 1, sourceFile, options);
+        }
+        else {
+            // handle broken code gracefully
+            return -1 /* Value.Unknown */;
+        }
+    }
+    /*
+     * Function returns Value.Unknown if actual indentation for node should not be used (i.e because node is nested expression)
+     */
+    function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) {
+        // actual indentation is used for statements\declarations if one of cases below is true:
+        // - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually
+        // - parent and child are not on the same line
+        const useActualIndentation = (isDeclaration(current) || isStatementButNotDeclaration(current)) &&
+            (parent.kind === SyntaxKind.SourceFile || !parentAndChildShareLine);
+        if (!useActualIndentation) {
+            return -1 /* Value.Unknown */;
+        }
+        return findColumnForFirstNonWhitespaceCharacterInLine(currentLineAndChar, sourceFile, options);
+    }
+    let NextTokenKind;
+    (function (NextTokenKind) {
+        NextTokenKind[NextTokenKind["Unknown"] = 0] = "Unknown";
+        NextTokenKind[NextTokenKind["OpenBrace"] = 1] = "OpenBrace";
+        NextTokenKind[NextTokenKind["CloseBrace"] = 2] = "CloseBrace";
+    })(NextTokenKind || (NextTokenKind = {}));
+    function nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile) {
+        const nextToken = findNextToken(precedingToken, current, sourceFile);
+        if (!nextToken) {
+            return 0 /* NextTokenKind.Unknown */;
+        }
+        if (nextToken.kind === SyntaxKind.OpenBraceToken) {
+            // open braces are always indented at the parent level
+            return 1 /* NextTokenKind.OpenBrace */;
+        }
+        else if (nextToken.kind === SyntaxKind.CloseBraceToken) {
+            // close braces are indented at the parent level if they are located on the same line with cursor
+            // this means that if new line will be added at $ position, this case will be indented
+            // class A {
+            //    $
+            // }
+            /// and this one - not
+            // class A {
+            // $}
+            const nextTokenStartLine = getStartLineAndCharacterForNode(nextToken, sourceFile).line;
+            return lineAtPosition === nextTokenStartLine ? 2 /* NextTokenKind.CloseBrace */ : 0 /* NextTokenKind.Unknown */;
+        }
+        return 0 /* NextTokenKind.Unknown */;
+    }
+    function getStartLineAndCharacterForNode(n, sourceFile) {
+        return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
+    }
+    function isArgumentAndStartLineOverlapsExpressionBeingCalled(parent, child, childStartLine, sourceFile) {
+        if (!(isCallExpression(parent) && contains(parent.arguments, child))) {
+            return false;
+        }
+        const expressionOfCallExpressionEnd = parent.expression.getEnd();
+        const expressionOfCallExpressionEndLine = getLineAndCharacterOfPosition(sourceFile, expressionOfCallExpressionEnd).line;
+        return expressionOfCallExpressionEndLine === childStartLine;
+    }
+    SmartIndenter.isArgumentAndStartLineOverlapsExpressionBeingCalled = isArgumentAndStartLineOverlapsExpressionBeingCalled;
+    function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) {
+        if (parent.kind === SyntaxKind.IfStatement && parent.elseStatement === child) {
+            const elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile);
+            Debug.assert(elseKeyword !== undefined);
+            const elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line;
+            return elseKeywordStartLine === childStartLine;
+        }
+        return false;
+    }
+    SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement = childStartsOnTheSameLineWithElseInIfStatement;
+    function argumentStartsOnSameLineAsPreviousArgument(parent, child, childStartLine, sourceFile) {
+        if (isCallOrNewExpression(parent)) {
+            if (!parent.arguments)
+                return false;
+            const currentNode = find(parent.arguments, arg => arg.pos === child.pos);
+            // If it's not one of the arguments, don't look past this
+            if (!currentNode)
+                return false;
+            const currentIndex = parent.arguments.indexOf(currentNode);
+            if (currentIndex === 0)
+                return false; // Can't look at previous node if first
+            const previousNode = parent.arguments[currentIndex - 1];
+            const lineOfPreviousNode = getLineAndCharacterOfPosition(sourceFile, previousNode.getEnd()).line;
+            if (childStartLine === lineOfPreviousNode) {
+                return true;
+            }
+        }
+        return false;
+    }
+    SmartIndenter.argumentStartsOnSameLineAsPreviousArgument = argumentStartsOnSameLineAsPreviousArgument;
+    function getContainingList(node, sourceFile) {
+        return node.parent && getListByRange(node.getStart(sourceFile), node.getEnd(), node.parent, sourceFile);
+    }
+    SmartIndenter.getContainingList = getContainingList;
+    function getListByPosition(pos, node, sourceFile) {
+        return node && getListByRange(pos, pos, node, sourceFile);
+    }
+    function getListByRange(start, end, node, sourceFile) {
+        switch (node.kind) {
+            case SyntaxKind.TypeReference:
+                return getList(node.typeArguments);
+            case SyntaxKind.ObjectLiteralExpression:
+                return getList(node.properties);
+            case SyntaxKind.ArrayLiteralExpression:
+                return getList(node.elements);
+            case SyntaxKind.TypeLiteral:
+                return getList(node.members);
+            // Na tag, também a `function`, a function expression, o método, o construtor, o tipo construtor e a construct
+            // signature (CK-02), e a method signature (CK-36).
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.CallSignature:
+                return getList(node.typeParameters) || getList(node.parameters);
+            // Na tag, também a classe, a class expression e a interface (CK-02), e o `@template` do JSDoc (CK-03).
+            case SyntaxKind.TypeAliasDeclaration:
+                return getList(node.typeParameters);
+            // Na tag, também o `new` (CK-02).
+            case SyntaxKind.CallExpression:
+                return getList(node.typeArguments) || getList(node.arguments);
+            case SyntaxKind.VariableDeclarationList:
+                return getList(node.declarations);
+            case SyntaxKind.NamedImports:
+            case SyntaxKind.NamedExports:
+                return getList(node.elements);
+            case SyntaxKind.ObjectBindingPattern:
+            case SyntaxKind.ArrayBindingPattern:
+                return getList(node.elements);
+        }
+        function getList(list) {
+            return list && rangeContainsStartEnd(getVisualListRange(node, list, sourceFile), start, end) ? list : undefined;
+        }
+    }
+    function getVisualListRange(node, list, sourceFile) {
+        const children = node.getChildren(sourceFile);
+        for (let i = 1; i < children.length - 1; i++) {
+            if (children[i].pos === list.pos && children[i].end === list.end) {
+                return { pos: children[i - 1].end, end: children[i + 1].getStart(sourceFile) };
+            }
+        }
+        return list;
+    }
+    function getActualIndentationForListStartLine(list, sourceFile, options) {
+        if (!list) {
+            return -1 /* Value.Unknown */;
+        }
+        return findColumnForFirstNonWhitespaceCharacterInLine(sourceFile.getLineAndCharacterOfPosition(list.pos), sourceFile, options);
+    }
+    function getActualIndentationForListItem(node, sourceFile, options, listIndentsChild) {
+        if (node.parent && node.parent.kind === SyntaxKind.VariableDeclarationList) {
+            // VariableDeclarationList has no wrapping tokens
+            return -1 /* Value.Unknown */;
+        }
+        const containingList = getContainingList(node, sourceFile);
+        if (containingList) {
+            const index = containingList.indexOf(node);
+            if (index !== -1) {
+                const result = deriveActualIndentationFromList(containingList, index, sourceFile, options);
+                if (result !== -1 /* Value.Unknown */) {
+                    return result;
+                }
+            }
+            return getActualIndentationForListStartLine(containingList, sourceFile, options) + (listIndentsChild ? options.indentSize : 0); // TODO: GH#18217
+        }
+        return -1 /* Value.Unknown */;
+    }
+    function deriveActualIndentationFromList(list, index, sourceFile, options) {
+        Debug.assert(index >= 0 && index < list.length);
+        const node = list[index];
+        // walk toward the start of the list starting from current node and check if the line is the same for all items.
+        // if end line for item [i - 1] differs from the start line for item [i] - find column of the first non-whitespace character on the line of item [i]
+        let lineAndCharacter = getStartLineAndCharacterForNode(node, sourceFile);
+        for (let i = index - 1; i >= 0; i--) {
+            if (list[i].kind === SyntaxKind.CommaToken) {
+                continue;
+            }
+            // skip list items that ends on the same line with the current list element
+            const prevEndLine = sourceFile.getLineAndCharacterOfPosition(list[i].end).line;
+            if (prevEndLine !== lineAndCharacter.line) {
+                return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options);
+            }
+            lineAndCharacter = getStartLineAndCharacterForNode(list[i], sourceFile);
+        }
+        return -1 /* Value.Unknown */;
+    }
+    function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options) {
+        const lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0);
+        return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options);
+    }
+    /**
+     * Character is the actual index of the character since the beginning of the line.
+     * Column - position of the character after expanding tabs to spaces.
+     * "0\t2$"
+     * value of 'character' for '$' is 3
+     * value of 'column' for '$' is 6 (assuming that tab size is 4)
+     */
+    function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) {
+        let character = 0;
+        let column = 0;
+        for (let pos = startPos; pos < endPos; pos++) {
+            const ch = sourceFile.text.charCodeAt(pos);
+            if (!isWhiteSpaceSingleLine(ch)) {
+                break;
+            }
+            if (ch === CharacterCodes.tab) {
+                column += options.tabSize + (column % options.tabSize);
+            }
+            else {
+                column++;
+            }
+            character++;
+        }
+        return { column, character };
+    }
+    SmartIndenter.findFirstNonWhitespaceCharacterAndColumn = findFirstNonWhitespaceCharacterAndColumn;
+    function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) {
+        return findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options).column;
+    }
+    SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn;
+    function nodeWillIndentChild(settings, parent, child, sourceFile, indentByDefault) {
+        const childKind = child ? child.kind : SyntaxKind.Unknown;
+        switch (parent.kind) {
+            // Na tag, também a classe, a class expression, a interface, o enum, o `new`, a construct signature, o tipo
+            // construtor, o template marcado e a propriedade de classe (CK-02), e a method signature (CK-36).
+            case SyntaxKind.ExpressionStatement:
+            case SyntaxKind.TypeAliasDeclaration:
+            case SyntaxKind.ArrayLiteralExpression:
+            case SyntaxKind.Block:
+            case SyntaxKind.ModuleBlock:
+            case SyntaxKind.ObjectLiteralExpression:
+            case SyntaxKind.TypeLiteral:
+            case SyntaxKind.MappedType:
+            case SyntaxKind.TupleType:
+            case SyntaxKind.CaseBlock:
+            case SyntaxKind.DefaultClause:
+            case SyntaxKind.CaseClause:
+            case SyntaxKind.ParenthesizedExpression:
+            case SyntaxKind.PropertyAccessExpression:
+            case SyntaxKind.CallExpression:
+            case SyntaxKind.VariableStatement:
+            case SyntaxKind.ExportAssignment:
+            case SyntaxKind.ReturnStatement:
+            case SyntaxKind.ConditionalExpression:
+            case SyntaxKind.ArrayBindingPattern:
+            case SyntaxKind.ObjectBindingPattern:
+            case SyntaxKind.JsxOpeningElement:
+            case SyntaxKind.JsxOpeningFragment:
+            case SyntaxKind.JsxSelfClosingElement:
+            case SyntaxKind.JsxExpression:
+            case SyntaxKind.CallSignature:
+            case SyntaxKind.Parameter:
+            case SyntaxKind.FunctionType:
+            case SyntaxKind.ParenthesizedType:
+            case SyntaxKind.AwaitExpression:
+            case SyntaxKind.NamedExports:
+            case SyntaxKind.NamedImports:
+            case SyntaxKind.ExportSpecifier:
+            case SyntaxKind.ImportSpecifier:
+                return true;
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.BinaryExpression:
+                if (!settings.indentMultiLineObjectLiteralBeginningOnBlankLine && sourceFile && childKind === SyntaxKind.ObjectLiteralExpression) { // TODO: GH#18217
+                    return rangeIsOnOneLine(sourceFile, child);
+                }
+                if (parent.kind !== SyntaxKind.BinaryExpression) {
+                    return true;
+                }
+                break;
+            case SyntaxKind.DoStatement:
+            case SyntaxKind.WhileStatement:
+            case SyntaxKind.ForInStatement:
+            case SyntaxKind.ForOfStatement:
+            case SyntaxKind.ForStatement:
+            case SyntaxKind.IfStatement:
+            // Na tag, também a `function`, a function expression, o método, o construtor e o acessor (CK-02).
+            case SyntaxKind.ArrowFunction:
+                return childKind !== SyntaxKind.Block;
+            case SyntaxKind.ExportDeclaration:
+                return childKind !== SyntaxKind.NamedExports;
+            case SyntaxKind.ImportDeclaration:
+                return childKind !== SyntaxKind.ImportClause ||
+                    (!!child.namedBindings && child.namedBindings.kind !== SyntaxKind.NamedImports);
+            case SyntaxKind.JsxElement:
+                return childKind !== SyntaxKind.JsxClosingElement;
+            case SyntaxKind.JsxFragment:
+                return childKind !== SyntaxKind.JsxClosingFragment;
+            case SyntaxKind.IntersectionType:
+            case SyntaxKind.UnionType:
+                if (childKind === SyntaxKind.TypeLiteral) {
+                    return false;
+                }
+            // falls through
+        }
+        // No explicit rule for given nodes so the result will follow the default value argument
+        return indentByDefault;
+    }
+    SmartIndenter.nodeWillIndentChild = nodeWillIndentChild;
+    function isControlFlowEndingStatement(kind, parent) {
+        switch (kind) {
+            case SyntaxKind.ReturnStatement:
+            case SyntaxKind.ThrowStatement:
+            case SyntaxKind.ContinueStatement:
+            case SyntaxKind.BreakStatement:
+                return parent.kind !== SyntaxKind.Block;
+            default:
+                return false;
+        }
+    }
+    /**
+     * True when the parent node should indent the given child by an explicit rule.
+     * @param isNextChild If true, we are judging indent of a hypothetical child *after* this one, not the current child.
+     */
+    function shouldIndentChildNode(settings, parent, child, sourceFile, isNextChild = false) {
+        return nodeWillIndentChild(settings, parent, child, sourceFile, /*indentByDefault*/ false)
+            && !(isNextChild && child && isControlFlowEndingStatement(child.kind, parent));
+    }
+    SmartIndenter.shouldIndentChildNode = shouldIndentChildNode;
+    function rangeIsOnOneLine(sourceFile, range) {
+        const rangeStart = skipTrivia(sourceFile.text, range.pos);
+        const startLine = sourceFile.getLineAndCharacterOfPosition(rangeStart).line;
+        const endLine = sourceFile.getLineAndCharacterOfPosition(range.end).line;
+        return startLine === endLine;
+    }
+})(SmartIndenter || (SmartIndenter = {}));

package/dist/getEditsForFileRename.d.ts

@@ -0,0 +1,6 @@
+import type { CheckResult, FileTextChanges, GetCanonicalFileName, LanguageServiceHost, UserPreferences, formatting } from "./_namespaces/edit.js";
+export declare function getEditsForFileRename(program: CheckResult, oldFileOrDirPath: string, newFileOrDirPath: string, host: LanguageServiceHost, formatContext: formatting.FormatContext, preferences: UserPreferences): readonly FileTextChanges[];
+/** If 'path' refers to an old directory, returns path in the new directory. */
+type PathUpdater = (path: string) => string | undefined;
+export declare function getPathUpdater(oldFileOrDirPath: string, newFileOrDirPath: string, getCanonicalFileName: GetCanonicalFileName): PathUpdater;
+export {};

package/dist/getEditsForFileRename.js

@@ -0,0 +1,86 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/getEditsForFileRename.ts: o namespace virou módulo ES, com os imports explícitos.
+// Saem a atualização do `tsconfig` (o `files`, o `include`, o `exclude` e as opções de caminho) e o mapa de fontes (o
+// `sourceMapper`, que achava o `.ts` de um `.d.ts`), que são do host (CK-47, CK-06); e a referência `/// <reference
+// path>` (CK-03). A resolução de um import é do host (CK-46): onde a tag refazia a resolução do Node a partir do lugar
+// antigo de quem importa, o language service pergunta ao `resolveModule` do host; e o import que não resolve mais, que a
+// tag achava pelos caminhos que a resolução tentou (os `failedLookupLocations`), não tem o que perguntar.
+import { createGetCanonicalFileName, createModuleSpecifierResolutionHost, createRange, find, getResolvedModule, hostUsesCaseSensitiveFileNames, isAmbientModule, isSourceFile, moduleSpecifiers, pathIsRelative, textChanges, tryRemoveDirectoryPrefix, } from "./_namespaces/edit.js";
+export function getEditsForFileRename(program, oldFileOrDirPath, newFileOrDirPath, host, formatContext, preferences) {
+    const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
+    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    const oldToNew = getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName);
+    const newToOld = getPathUpdater(newFileOrDirPath, oldFileOrDirPath, getCanonicalFileName);
+    return textChanges.ChangeTracker.with({ host, formatContext, preferences }, changeTracker => {
+        updateImports(program, changeTracker, oldToNew, newToOld, host);
+    });
+}
+// exported for tests
+export function getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName) {
+    const canonicalOldPath = getCanonicalFileName(oldFileOrDirPath);
+    return path => getUpdatedPath(path);
+    function getUpdatedPath(pathToUpdate) {
+        if (getCanonicalFileName(pathToUpdate) === canonicalOldPath)
+            return newFileOrDirPath;
+        const suffix = tryRemoveDirectoryPrefix(pathToUpdate, canonicalOldPath, getCanonicalFileName);
+        return suffix === undefined ? undefined : newFileOrDirPath + "/" + suffix;
+    }
+}
+function updateImports(program, changeTracker, oldToNew, newToOld, host) {
+    const allFiles = program.getSourceFiles();
+    for (const sourceFile of allFiles) {
+        const newFromOld = oldToNew(sourceFile.path);
+        const newImportFromPath = newFromOld !== undefined ? newFromOld : sourceFile.path;
+        const oldFromNew = newToOld(sourceFile.fileName);
+        const oldImportFromPath = oldFromNew || sourceFile.fileName;
+        const importingSourceFileMoved = newFromOld !== undefined || oldFromNew !== undefined;
+        updateImportsWorker(sourceFile, changeTracker, importLiteral => {
+            const importedModuleSymbol = program.getTypeChecker().getSymbolAtLocation(importLiteral);
+            // No need to update if it's an ambient module
+            if (importedModuleSymbol && importedModuleSymbol.declarations.some(d => isAmbientModule(d)))
+                return undefined;
+            const toImport = oldFromNew !== undefined
+                // If we're at the new location (file was already renamed), need to redo module resolution starting from the old location.
+                ? getSourceFileToImportFromResolved(host.resolveModule(importLiteral.text, oldImportFromPath), oldToNew)
+                : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, oldToNew);
+            // Need an update if the imported file moved, or the importing file moved and was using a relative path.
+            return toImport !== undefined && (toImport.updated || (importingSourceFileMoved && pathIsRelative(importLiteral.text)))
+                ? moduleSpecifiers.updateModuleSpecifier(newImportFromPath, toImport.newFileName, createModuleSpecifierResolutionHost(host), importLiteral.text)
+                : undefined;
+        });
+    }
+}
+function getSourceFileToImport(importedModuleSymbol, importLiteral, importingSourceFile, oldToNew) {
+    if (importedModuleSymbol) {
+        // `find` should succeed because we checked for ambient modules before calling this function.
+        const oldFileName = find(importedModuleSymbol.declarations, isSourceFile).fileName;
+        const newFileName = oldToNew(oldFileName);
+        return newFileName === undefined ? { newFileName: oldFileName, updated: false } : { newFileName, updated: true };
+    }
+    else {
+        // O arquivo a que o import resolve sem dar um símbolo de módulo (o que não tem `import` nem `export`). Na tag, a
+        // resolução vinha do cache do host, com os caminhos que ela tentou; aqui, é a que o `check` gravou no arquivo,
+        // o arquivo que o host deu ou nada (CK-46).
+        const resolved = getResolvedModule(importingSourceFile, importLiteral.text);
+        return getSourceFileToImportFromResolved(resolved && resolved.resolvedFileName, oldToNew);
+    }
+}
+// Na tag, a resolução vinha com os caminhos que ela tentou e não achou, e eles se procuravam entre os que mudaram; o
+// `resolveModule` do host dá só o arquivo (CK-46).
+function getSourceFileToImportFromResolved(resolvedFileName, oldToNew) {
+    if (!resolvedFileName)
+        return undefined;
+    const newFileName = oldToNew(resolvedFileName);
+    return newFileName ? { newFileName, updated: true } : { newFileName: resolvedFileName, updated: false };
+}
+// Na tag, também as referências `/// <reference path>` do arquivo (CK-03). Com elas, saíram o caminho que a referência daria
+// e os auxiliares de caminho que ela e o `tsconfig` usavam.
+function updateImportsWorker(sourceFile, changeTracker, updateImport) {
+    for (const importStringLiteral of sourceFile.imports) {
+        const updated = updateImport(importStringLiteral);
+        if (updated !== undefined && updated !== importStringLiteral.text)
+            changeTracker.replaceRangeWithText(sourceFile, createStringRange(importStringLiteral, sourceFile), updated);
+    }
+}
+function createStringRange(node, sourceFile) {
+    return createRange(node.getStart(sourceFile) + 1, node.end - 1);
+}

package/dist/goToDefinition.d.ts

@@ -0,0 +1,8 @@
+import type { CheckResult, DefinitionInfo, DefinitionInfoAndBoundSpan, SourceFile, TypeChecker } from "./_namespaces/ts.js";
+/**
+ * Na tag, também a referência `/// <reference path>`, `<reference types>` e `<reference lib>` na posição, que dava o
+ * arquivo referido (CK-03, CK-46, CK-39), e o label de um `break` ou `continue` (CK-02).
+ */
+export declare function getDefinitionAtPosition(program: CheckResult, sourceFile: SourceFile, position: number): readonly DefinitionInfo[] | undefined;
+export declare function getTypeDefinitionAtPosition(typeChecker: TypeChecker, sourceFile: SourceFile, position: number): readonly DefinitionInfo[] | undefined;
+export declare function getDefinitionAndBoundSpan(program: CheckResult, sourceFile: SourceFile, position: number): DefinitionInfoAndBoundSpan | undefined;