@tslite/services 0.0.0-stage → 1.12.0

package/dist/organizeImports.js

@@ -0,0 +1,290 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/organizeImports.ts: o namespace virou módulo ES, com os imports explícitos.
+// Saem o import da fábrica do JSX, que a tag tinha por usado sempre que o arquivo tem JSX (a fábrica é do emit, CK-19), e
+// o import que um `declare module "x"` aumenta, que a tag mantinha mesmo sem uso (o módulo ambiente de nome em string,
+// CK-02, princípio 4).
+import { FindAllReferences, compareBooleans, compareStringsCaseInsensitive, createIdentifier, createImportSpecifier, createNamedImports, emptyArray, flatMap, getNewLineOrDefaultFromHost, group, isAmbientModule, isExportDeclaration, isExternalModuleNameRelative, isImportDeclaration, isNamedExports, isNamespaceImport, isStringLiteralLike, length, stableSort, suppressLeadingTrivia, textChanges, updateExportDeclaration, updateImportClause, updateImportDeclaration, updateNamedExports, updateNamedImports, updateNamespaceExport, } from "./_namespaces/edit.js";
+/**
+ * Organize imports by:
+ *   1) Removing unused imports
+ *   2) Coalescing imports from the same module
+ *   3) Sorting imports
+ */
+export function organizeImports(sourceFile, formatContext, host, program, preferences) {
+    const changeTracker = textChanges.ChangeTracker.fromContext({ host, formatContext, preferences });
+    const coalesceAndOrganizeImports = (importGroup) => coalesceImports(removeUnusedImports(importGroup, sourceFile, program));
+    // All of the old ImportDeclarations in the file, in syntactic order.
+    const topLevelImportDecls = sourceFile.statements.filter(isImportDeclaration);
+    organizeImportsWorker(topLevelImportDecls, coalesceAndOrganizeImports);
+    // All of the old ExportDeclarations in the file, in syntactic order.
+    const topLevelExportDecls = sourceFile.statements.filter(isExportDeclaration);
+    organizeImportsWorker(topLevelExportDecls, coalesceExports);
+    for (const ambientModule of sourceFile.statements.filter(isAmbientModule)) {
+        if (!ambientModule.body) {
+            continue;
+        }
+        const ambientModuleImportDecls = ambientModule.body.statements.filter(isImportDeclaration);
+        organizeImportsWorker(ambientModuleImportDecls, coalesceAndOrganizeImports);
+        const ambientModuleExportDecls = ambientModule.body.statements.filter(isExportDeclaration);
+        organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
+    }
+    return changeTracker.getChanges();
+    function organizeImportsWorker(oldImportDecls, coalesce) {
+        if (length(oldImportDecls) === 0) {
+            return;
+        }
+        // Special case: normally, we'd expect leading and trailing trivia to follow each import
+        // around as it's sorted.  However, we do not want this to happen for leading trivia
+        // on the first import because it is probably the header comment for the file.
+        // Consider: we could do a more careful check that this trivia is actually a header,
+        // but the consequences of being wrong are very minor.
+        suppressLeadingTrivia(oldImportDecls[0]);
+        const oldImportGroups = group(oldImportDecls, importDecl => getExternalModuleName(importDecl.moduleSpecifier));
+        const sortedImportGroups = stableSort(oldImportGroups, (group1, group2) => compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier));
+        const newImportDecls = flatMap(sortedImportGroups, importGroup => getExternalModuleName(importGroup[0].moduleSpecifier)
+            ? coalesce(importGroup)
+            : importGroup);
+        // Delete or replace the first import.
+        if (newImportDecls.length === 0) {
+            changeTracker.delete(sourceFile, oldImportDecls[0]);
+        }
+        else {
+            // Note: Delete the surrounding trivia because it will have been retained in newImportDecls.
+            changeTracker.replaceNodeWithNodes(sourceFile, oldImportDecls[0], newImportDecls, {
+                leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, // Leave header comment in place
+                trailingTriviaOption: textChanges.TrailingTriviaOption.Include,
+                suffix: getNewLineOrDefaultFromHost(host, formatContext.options),
+            });
+        }
+        // Delete any subsequent imports.
+        for (let i = 1; i < oldImportDecls.length; i++) {
+            changeTracker.deleteNode(sourceFile, oldImportDecls[i]);
+        }
+    }
+}
+function removeUnusedImports(oldImports, sourceFile, program) {
+    const typeChecker = program.getTypeChecker();
+    const usedImports = [];
+    for (const importDecl of oldImports) {
+        const { importClause } = importDecl;
+        if (!importClause) {
+            // Imports without import clauses are assumed to be included for their side effects and are not removed.
+            usedImports.push(importDecl);
+            continue;
+        }
+        let { name, namedBindings } = importClause;
+        // Default import
+        if (name && !isDeclarationUsed(name)) {
+            name = undefined;
+        }
+        if (namedBindings) {
+            if (isNamespaceImport(namedBindings)) {
+                // Namespace import
+                if (!isDeclarationUsed(namedBindings.name)) {
+                    namedBindings = undefined;
+                }
+            }
+            else {
+                // List of named imports
+                const newElements = namedBindings.elements.filter(e => isDeclarationUsed(e.name));
+                if (newElements.length < namedBindings.elements.length) {
+                    namedBindings = newElements.length
+                        ? updateNamedImports(namedBindings, newElements)
+                        : undefined;
+                }
+            }
+        }
+        if (name || namedBindings) {
+            usedImports.push(updateImportDeclarationAndClause(importDecl, name, namedBindings));
+        }
+        // Na tag, o import que um `declare module "x"` do arquivo aumentava ficava, mesmo sem uso (CK-02, princípio 4).
+    }
+    return usedImports;
+    // Na tag, também o nome da fábrica do JSX, que contava como usado quando o arquivo tinha JSX (CK-19).
+    function isDeclarationUsed(identifier) {
+        return FindAllReferences.Core.isSymbolReferencedInFile(identifier, typeChecker, sourceFile);
+    }
+}
+function getExternalModuleName(specifier) {
+    return specifier !== undefined && isStringLiteralLike(specifier)
+        ? specifier.text
+        : undefined;
+}
+// Internal for testing
+/**
+ * @param importGroup a list of ImportDeclarations, all with the same module name.
+ */
+export function coalesceImports(importGroup) {
+    if (importGroup.length === 0) {
+        return importGroup;
+    }
+    const { importWithoutClause, typeOnlyImports, regularImports } = getCategorizedImports(importGroup);
+    const coalescedImports = [];
+    if (importWithoutClause) {
+        coalescedImports.push(importWithoutClause);
+    }
+    for (const group of [regularImports, typeOnlyImports]) {
+        const isTypeOnly = group === typeOnlyImports;
+        const { defaultImports, namespaceImports, namedImports } = group;
+        // Normally, we don't combine default and namespace imports, but it would be silly to
+        // produce two import declarations in this special case.
+        if (!isTypeOnly && defaultImports.length === 1 && namespaceImports.length === 1 && namedImports.length === 0) {
+            // Add the namespace import to the existing default ImportDeclaration.
+            const defaultImport = defaultImports[0];
+            coalescedImports.push(updateImportDeclarationAndClause(defaultImport, defaultImport.importClause.name, namespaceImports[0].importClause.namedBindings)); // TODO: GH#18217
+            continue;
+        }
+        const sortedNamespaceImports = stableSort(namespaceImports, (i1, i2) => compareIdentifiers(i1.importClause.namedBindings.name, i2.importClause.namedBindings.name)); // TODO: GH#18217
+        for (const namespaceImport of sortedNamespaceImports) {
+            // Drop the name, if any
+            coalescedImports.push(updateImportDeclarationAndClause(namespaceImport, /*name*/ undefined, namespaceImport.importClause.namedBindings)); // TODO: GH#18217
+        }
+        if (defaultImports.length === 0 && namedImports.length === 0) {
+            continue;
+        }
+        let newDefaultImport;
+        const newImportSpecifiers = [];
+        if (defaultImports.length === 1) {
+            newDefaultImport = defaultImports[0].importClause.name;
+        }
+        else {
+            for (const defaultImport of defaultImports) {
+                newImportSpecifiers.push(createImportSpecifier(createIdentifier("default"), defaultImport.importClause.name)); // TODO: GH#18217
+            }
+        }
+        newImportSpecifiers.push(...flatMap(namedImports, i => i.importClause.namedBindings.elements)); // TODO: GH#18217
+        const sortedImportSpecifiers = sortSpecifiers(newImportSpecifiers);
+        const importDecl = defaultImports.length > 0
+            ? defaultImports[0]
+            : namedImports[0];
+        const newNamedImports = sortedImportSpecifiers.length === 0
+            ? newDefaultImport
+                ? undefined
+                : createNamedImports(emptyArray)
+            : namedImports.length === 0
+                ? createNamedImports(sortedImportSpecifiers)
+                : updateNamedImports(namedImports[0].importClause.namedBindings, sortedImportSpecifiers); // TODO: GH#18217
+        // Type-only imports are not allowed to mix default, namespace, and named imports in any combination.
+        // We could rewrite a default import as a named import (`import { default as name }`), but we currently
+        // choose not to as a stylistic preference.
+        if (isTypeOnly && newDefaultImport && newNamedImports) {
+            coalescedImports.push(updateImportDeclarationAndClause(importDecl, newDefaultImport, /*namedBindings*/ undefined));
+            coalescedImports.push(updateImportDeclarationAndClause(namedImports[0] ?? importDecl, /*name*/ undefined, newNamedImports));
+        }
+        else {
+            coalescedImports.push(updateImportDeclarationAndClause(importDecl, newDefaultImport, newNamedImports));
+        }
+    }
+    return coalescedImports;
+}
+/*
+ * Returns entire import declarations because they may already have been rewritten and
+ * may lack parent pointers.  The desired parts can easily be recovered based on the
+ * categorization.
+ *
+ * NB: There may be overlap between `defaultImports` and `namespaceImports`/`namedImports`.
+ */
+function getCategorizedImports(importGroup) {
+    let importWithoutClause;
+    const typeOnlyImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
+    const regularImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
+    for (const importDeclaration of importGroup) {
+        if (importDeclaration.importClause === undefined) {
+            // Only the first such import is interesting - the others are redundant.
+            // Note: Unfortunately, we will lose trivia that was on this node.
+            importWithoutClause = importWithoutClause || importDeclaration;
+            continue;
+        }
+        const group = importDeclaration.importClause.isTypeOnly ? typeOnlyImports : regularImports;
+        const { name, namedBindings } = importDeclaration.importClause;
+        if (name) {
+            group.defaultImports.push(importDeclaration);
+        }
+        if (namedBindings) {
+            if (isNamespaceImport(namedBindings)) {
+                group.namespaceImports.push(importDeclaration);
+            }
+            else {
+                group.namedImports.push(importDeclaration);
+            }
+        }
+    }
+    return {
+        importWithoutClause,
+        typeOnlyImports,
+        regularImports,
+    };
+}
+// Internal for testing
+/**
+ * @param exportGroup a list of ExportDeclarations, all with the same module name.
+ */
+export function coalesceExports(exportGroup) {
+    if (exportGroup.length === 0) {
+        return exportGroup;
+    }
+    const { exportWithoutClause, namedExports, typeOnlyExports } = getCategorizedExports(exportGroup);
+    const coalescedExports = [];
+    if (exportWithoutClause) {
+        coalescedExports.push(exportWithoutClause);
+    }
+    for (const exportGroup of [namedExports, typeOnlyExports]) {
+        if (exportGroup.length === 0) {
+            continue;
+        }
+        const newExportSpecifiers = [];
+        newExportSpecifiers.push(...flatMap(exportGroup, i => i.exportClause && isNamedExports(i.exportClause) ? i.exportClause.elements : emptyArray));
+        const sortedExportSpecifiers = sortSpecifiers(newExportSpecifiers);
+        const exportDecl = exportGroup[0];
+        coalescedExports.push(updateExportDeclaration(exportDecl, exportDecl.modifiers, exportDecl.exportClause && (isNamedExports(exportDecl.exportClause) ?
+            updateNamedExports(exportDecl.exportClause, sortedExportSpecifiers) :
+            updateNamespaceExport(exportDecl.exportClause, exportDecl.exportClause.name)), exportDecl.moduleSpecifier, exportDecl.isTypeOnly));
+    }
+    return coalescedExports;
+    /*
+     * Returns entire export declarations because they may already have been rewritten and
+     * may lack parent pointers.  The desired parts can easily be recovered based on the
+     * categorization.
+     */
+    function getCategorizedExports(exportGroup) {
+        let exportWithoutClause;
+        const namedExports = [];
+        const typeOnlyExports = [];
+        for (const exportDeclaration of exportGroup) {
+            if (exportDeclaration.exportClause === undefined) {
+                // Only the first such export is interesting - the others are redundant.
+                // Note: Unfortunately, we will lose trivia that was on this node.
+                exportWithoutClause = exportWithoutClause || exportDeclaration;
+            }
+            else if (exportDeclaration.isTypeOnly) {
+                typeOnlyExports.push(exportDeclaration);
+            }
+            else {
+                namedExports.push(exportDeclaration);
+            }
+        }
+        return {
+            exportWithoutClause,
+            namedExports,
+            typeOnlyExports,
+        };
+    }
+}
+function updateImportDeclarationAndClause(importDeclaration, name, namedBindings) {
+    return updateImportDeclaration(importDeclaration, importDeclaration.modifiers, updateImportClause(importDeclaration.importClause, name, namedBindings, importDeclaration.importClause.isTypeOnly), // TODO: GH#18217
+    importDeclaration.moduleSpecifier);
+}
+function sortSpecifiers(specifiers) {
+    return stableSort(specifiers, (s1, s2) => compareIdentifiers(s1.propertyName || s1.name, s2.propertyName || s2.name) ||
+        compareIdentifiers(s1.name, s2.name));
+}
+/* internal */ // Exported for testing
+export function compareModuleSpecifiers(m1, m2) {
+    const name1 = getExternalModuleName(m1);
+    const name2 = getExternalModuleName(m2);
+    return compareBooleans(name1 === undefined, name2 === undefined) ||
+        compareBooleans(isExternalModuleNameRelative(name1), isExternalModuleNameRelative(name2)) ||
+        compareStringsCaseInsensitive(name1, name2);
+}
+function compareIdentifiers(s1, s2) {
+    return compareStringsCaseInsensitive(s1.text, s2.text);
+}

package/dist/outliningElementsCollector.d.ts

@@ -0,0 +1,2 @@
+import type { CancellationToken, OutliningSpan, SourceFile } from "./_namespaces/ts.js";
+export declare function collectElements(sourceFile: SourceFile, cancellationToken: CancellationToken): OutliningSpan[];

package/dist/outliningElementsCollector.js

@@ -0,0 +1,261 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/outliningElementsCollector.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, SyntaxKind, createTextSpanFromBounds, createTextSpanFromNode, createTextSpanFromRange, findAncestor, findChildOfKind, getLeadingCommentRangesOfNode, getSingleInitializerOfVariableStatementOrPropertyDeclaration, isAnyImportSyntax, isArrayLiteralExpression, isArrowFunction, isCallExpression, isDeclaration, isFunctionLike, isIfStatement, isInComment, isNodeArrayMultiLine, isVariableStatement, } from "./_namespaces/ts.js";
+export function collectElements(sourceFile, cancellationToken) {
+    const res = [];
+    addNodeOutliningSpans(sourceFile, cancellationToken, res);
+    addRegionOutliningSpans(sourceFile, res);
+    return res.sort((span1, span2) => span1.textSpan.start - span2.textSpan.start);
+}
+function addNodeOutliningSpans(sourceFile, cancellationToken, out) {
+    let depthRemaining = 40;
+    let current = 0;
+    // Includes the EOF Token so that comments which aren't attached to statements are included
+    const statements = [...sourceFile.statements, sourceFile.endOfFileToken];
+    const n = statements.length;
+    while (current < n) {
+        while (current < n && !isAnyImportSyntax(statements[current])) {
+            visitNonImportNode(statements[current]);
+            current++;
+        }
+        if (current === n)
+            break;
+        const firstImport = current;
+        while (current < n && isAnyImportSyntax(statements[current])) {
+            addOutliningForLeadingCommentsForNode(statements[current], sourceFile, cancellationToken, out);
+            current++;
+        }
+        const lastImport = current - 1;
+        if (lastImport !== firstImport) {
+            out.push(createOutliningSpanFromBounds(findChildOfKind(statements[firstImport], SyntaxKind.ImportKeyword, sourceFile).getStart(sourceFile), statements[lastImport].getEnd(), "imports" /* OutliningSpanKind.Imports */));
+        }
+    }
+    function visitNonImportNode(n) {
+        if (depthRemaining === 0)
+            return;
+        cancellationToken.throwIfCancellationRequested();
+        if (isDeclaration(n) || n.kind === SyntaxKind.EndOfFileToken) {
+            addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out);
+        }
+        if (isFunctionExpressionAssignedToVariable(n)) {
+            addOutliningForLeadingCommentsForNode(n.parent.parent.parent, sourceFile, cancellationToken, out);
+        }
+        const span = getOutliningSpanForNode(n, sourceFile);
+        if (span)
+            out.push(span);
+        depthRemaining--;
+        if (isCallExpression(n)) {
+            depthRemaining++;
+            visitNonImportNode(n.expression);
+            depthRemaining--;
+            n.arguments.forEach(visitNonImportNode);
+            n.typeArguments?.forEach(visitNonImportNode);
+        }
+        else if (isIfStatement(n) && n.elseStatement && isIfStatement(n.elseStatement)) {
+            // Consider an 'else if' to be on the same depth as the 'if'.
+            visitNonImportNode(n.expression);
+            visitNonImportNode(n.thenStatement);
+            depthRemaining++;
+            visitNonImportNode(n.elseStatement);
+            depthRemaining--;
+        }
+        else {
+            n.forEachChild(visitNonImportNode);
+        }
+        depthRemaining++;
+    }
+    /** A arrow atribuída a uma variável. Na tag, também a function expression (CK-02). */
+    function isFunctionExpressionAssignedToVariable(n) {
+        if (!isArrowFunction(n)) {
+            return false;
+        }
+        const ancestor = findAncestor(n, isVariableStatement);
+        return !!ancestor && getSingleInitializerOfVariableStatementOrPropertyDeclaration(ancestor) === n;
+    }
+}
+function addRegionOutliningSpans(sourceFile, out) {
+    const regions = [];
+    const lineStarts = sourceFile.getLineStarts();
+    for (const currentLineStart of lineStarts) {
+        const lineEnd = sourceFile.getLineEndOfPosition(currentLineStart);
+        const lineText = sourceFile.text.substring(currentLineStart, lineEnd);
+        const result = isRegionDelimiter(lineText);
+        if (!result || isInComment(sourceFile, currentLineStart)) {
+            continue;
+        }
+        if (!result[1]) {
+            const span = createTextSpanFromBounds(sourceFile.text.indexOf("//", currentLineStart), lineEnd);
+            regions.push(createOutliningSpan(span, "region" /* OutliningSpanKind.Region */, span, /*autoCollapse*/ false, result[2] || "#region"));
+        }
+        else {
+            const region = regions.pop();
+            if (region) {
+                region.textSpan.length = lineEnd - region.textSpan.start;
+                region.hintSpan.length = lineEnd - region.textSpan.start;
+                out.push(region);
+            }
+        }
+    }
+}
+const regionDelimiterRegExp = /^\s*\/\/\s*#(end)?region(?:\s+(.*))?(?:\r)?$/;
+function isRegionDelimiter(lineText) {
+    return regionDelimiterRegExp.exec(lineText);
+}
+function addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out) {
+    const comments = getLeadingCommentRangesOfNode(n, sourceFile);
+    if (!comments)
+        return;
+    let firstSingleLineCommentStart = -1;
+    let lastSingleLineCommentEnd = -1;
+    let singleLineCommentCount = 0;
+    const sourceText = sourceFile.getFullText();
+    for (const { kind, pos, end } of comments) {
+        cancellationToken.throwIfCancellationRequested();
+        switch (kind) {
+            case SyntaxKind.SingleLineCommentTrivia:
+                // never fold region delimiters into single-line comment regions
+                const commentText = sourceText.slice(pos, end);
+                if (isRegionDelimiter(commentText)) {
+                    combineAndAddMultipleSingleLineComments();
+                    singleLineCommentCount = 0;
+                    break;
+                }
+                // For single line comments, combine consecutive ones (2 or more) into
+                // a single span from the start of the first till the end of the last
+                if (singleLineCommentCount === 0) {
+                    firstSingleLineCommentStart = pos;
+                }
+                lastSingleLineCommentEnd = end;
+                singleLineCommentCount++;
+                break;
+            case SyntaxKind.MultiLineCommentTrivia:
+                combineAndAddMultipleSingleLineComments();
+                out.push(createOutliningSpanFromBounds(pos, end, "comment" /* OutliningSpanKind.Comment */));
+                singleLineCommentCount = 0;
+                break;
+            default:
+                Debug.assertNever(kind);
+        }
+    }
+    combineAndAddMultipleSingleLineComments();
+    function combineAndAddMultipleSingleLineComments() {
+        // Only outline spans of two or more consecutive single line comments
+        if (singleLineCommentCount > 1) {
+            out.push(createOutliningSpanFromBounds(firstSingleLineCommentStart, lastSingleLineCommentEnd, "comment" /* OutliningSpanKind.Comment */));
+        }
+    }
+}
+function createOutliningSpanFromBounds(pos, end, kind) {
+    return createOutliningSpan(createTextSpanFromBounds(pos, end), kind);
+}
+function getOutliningSpanForNode(n, sourceFile) {
+    switch (n.kind) {
+        case SyntaxKind.Block:
+            if (isFunctionLike(n.parent)) {
+                return functionSpan(n.parent, n, sourceFile);
+            }
+            // Check if the block is standalone, or 'attached' to some parent statement.
+            // If the latter, we want to collapse the block, but consider its hint span
+            // to be the entire span of the parent.
+            switch (n.parent.kind) {
+                case SyntaxKind.DoStatement:
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.ForOfStatement:
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.IfStatement:
+                case SyntaxKind.WhileStatement:
+                // Na tag, também o `with` (CK-02).
+                case SyntaxKind.CatchClause:
+                    return spanForNode(n.parent);
+                case SyntaxKind.TryStatement:
+                    // Could be the try-block, or the finally-block.
+                    const tryStatement = n.parent;
+                    if (tryStatement.tryBlock === n) {
+                        return spanForNode(n.parent);
+                    }
+                    else if (tryStatement.finallyBlock === n) {
+                        const node = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
+                        if (node)
+                            return spanForNode(node);
+                    }
+                // falls through
+                default:
+                    // Block was a standalone block.  In this case we want to only collapse
+                    // the span of the block, independent of any parent span.
+                    return createOutliningSpan(createTextSpanFromNode(n, sourceFile), "code" /* OutliningSpanKind.Code */);
+            }
+        case SyntaxKind.ModuleBlock:
+            return spanForNode(n.parent);
+        // Na tag, também a classe, a class expression, a interface e o enum (CK-02).
+        case SyntaxKind.CaseBlock:
+        case SyntaxKind.TypeLiteral:
+            return spanForNode(n);
+        case SyntaxKind.CaseClause:
+        case SyntaxKind.DefaultClause:
+            return spanForNodeArray(n.statements);
+        case SyntaxKind.ObjectLiteralExpression:
+            return spanForObjectOrArrayLiteral(n);
+        case SyntaxKind.ArrayLiteralExpression:
+            return spanForObjectOrArrayLiteral(n, SyntaxKind.OpenBracketToken);
+        case SyntaxKind.JsxElement:
+            return spanForJSXElement(n);
+        case SyntaxKind.JsxFragment:
+            return spanForJSXFragment(n);
+        case SyntaxKind.JsxSelfClosingElement:
+        case SyntaxKind.JsxOpeningElement:
+            return spanForJSXAttributes(n.attributes);
+        case SyntaxKind.TemplateExpression:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+            return spanForTemplateLiteral(n);
+    }
+    function spanForJSXElement(node) {
+        const textSpan = createTextSpanFromBounds(node.openingElement.getStart(sourceFile), node.closingElement.getEnd());
+        const tagName = node.openingElement.tagName.getText(sourceFile);
+        const bannerText = "<" + tagName + ">...</" + tagName + ">";
+        return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, textSpan, /*autoCollapse*/ false, bannerText);
+    }
+    function spanForJSXFragment(node) {
+        const textSpan = createTextSpanFromBounds(node.openingFragment.getStart(sourceFile), node.closingFragment.getEnd());
+        const bannerText = "<>...</>";
+        return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, textSpan, /*autoCollapse*/ false, bannerText);
+    }
+    function spanForJSXAttributes(node) {
+        if (node.properties.length === 0) {
+            return undefined;
+        }
+        return createOutliningSpanFromBounds(node.getStart(sourceFile), node.getEnd(), "code" /* OutliningSpanKind.Code */);
+    }
+    function spanForTemplateLiteral(node) {
+        if (node.kind === SyntaxKind.NoSubstitutionTemplateLiteral && node.text.length === 0) {
+            return undefined;
+        }
+        return createOutliningSpanFromBounds(node.getStart(sourceFile), node.getEnd(), "code" /* OutliningSpanKind.Code */);
+    }
+    function spanForObjectOrArrayLiteral(node, open = SyntaxKind.OpenBraceToken) {
+        // If the block has no leading keywords and is inside an array literal or call expression,
+        // we only want to collapse the span of the block.
+        // Otherwise, the collapsed section will include the end of the previous line.
+        return spanForNode(node, /*autoCollapse*/ false, /*useFullStart*/ !isArrayLiteralExpression(node.parent) && !isCallExpression(node.parent), open);
+    }
+    function spanForNode(hintSpanNode, autoCollapse = false, useFullStart = true, open = SyntaxKind.OpenBraceToken, close = open === SyntaxKind.OpenBraceToken ? SyntaxKind.CloseBraceToken : SyntaxKind.CloseBracketToken) {
+        const openToken = findChildOfKind(n, open, sourceFile);
+        const closeToken = findChildOfKind(n, close, sourceFile);
+        return openToken && closeToken && spanBetweenTokens(openToken, closeToken, hintSpanNode, sourceFile, autoCollapse, useFullStart);
+    }
+    function spanForNodeArray(nodeArray) {
+        return nodeArray.length ? createOutliningSpan(createTextSpanFromRange(nodeArray), "code" /* OutliningSpanKind.Code */) : undefined;
+    }
+}
+function functionSpan(node, body, sourceFile) {
+    const openToken = isNodeArrayMultiLine(node.parameters, sourceFile)
+        ? findChildOfKind(node, SyntaxKind.OpenParenToken, sourceFile)
+        : findChildOfKind(body, SyntaxKind.OpenBraceToken, sourceFile);
+    const closeToken = findChildOfKind(body, SyntaxKind.CloseBraceToken, sourceFile);
+    return openToken && closeToken && spanBetweenTokens(openToken, closeToken, node, sourceFile, /*autoCollapse*/ node.kind !== SyntaxKind.ArrowFunction);
+}
+function spanBetweenTokens(openToken, closeToken, hintSpanNode, sourceFile, autoCollapse = false, useFullStart = true) {
+    const textSpan = createTextSpanFromBounds(useFullStart ? openToken.getFullStart() : openToken.getStart(sourceFile), closeToken.getEnd());
+    return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, createTextSpanFromNode(hintSpanNode, sourceFile), autoCollapse);
+}
+function createOutliningSpan(textSpan, kind, hintSpan = textSpan, autoCollapse = false, bannerText = "...") {
+    return { textSpan, kind, hintSpan, bannerText, autoCollapse };
+}

package/dist/refactorProvider.d.ts

@@ -0,0 +1,5 @@
+import type { ApplicableRefactorInfo, Refactor, RefactorContext, RefactorEditInfo } from "./_namespaces/edit.js";
+/** @param name An unique code associated with each refactor. Does not have to be human-readable. */
+export declare function registerRefactor(name: string, refactor: Refactor): void;
+export declare function getApplicableRefactors(context: RefactorContext): ApplicableRefactorInfo[];
+export declare function getEditsForRefactor(context: RefactorContext, refactorName: string, actionName: string): RefactorEditInfo | undefined;

package/dist/refactorProvider.js

@@ -0,0 +1,16 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactorProvider.ts: o namespace virou módulo ES, com os imports explícitos.
+import { arrayFrom, createMap, flatMapIterator, } from "./_namespaces/edit.js";
+// A map with the refactor code as key, the refactor itself as value
+// e.g.  nonSuggestableRefactors[refactorCode] -> the refactor you want
+const refactors = createMap();
+/** @param name An unique code associated with each refactor. Does not have to be human-readable. */
+export function registerRefactor(name, refactor) {
+    refactors.set(name, refactor);
+}
+export function getApplicableRefactors(context) {
+    return arrayFrom(flatMapIterator(refactors.values(), refactor => context.cancellationToken && context.cancellationToken.isCancellationRequested() ? undefined : refactor.getAvailableActions(context)));
+}
+export function getEditsForRefactor(context, refactorName, actionName) {
+    const refactor = refactors.get(refactorName);
+    return refactor && refactor.getEditsForAction(context, actionName);
+}

package/dist/refactors/addOrRemoveBracesToArrowFunction.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/refactors/addOrRemoveBracesToArrowFunction.js

@@ -0,0 +1,86 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/refactors/addOrRemoveBracesToArrowFunction.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, SyntaxKind, copyLeadingComments, copyTrailingAsLeadingComments, copyTrailingComments, createBlock, createIdentifier, createParen, createReturn, emptyArray, first, getContainingFunction, getTokenAtPosition, isArrowFunction, isExpression, isReturnStatement, needsParentheses, rangeContainsRange, suppressLeadingAndTrailingTrivia, textChanges, } from "../_namespaces/edit.js";
+import { registerRefactor, } from "../_namespaces/ts.refactor.js";
+const refactorName = "Add or remove braces in an arrow function";
+const refactorDescription = Diagnostics.Add_or_remove_braces_in_an_arrow_function.message;
+const addBracesActionName = "Add braces to arrow function";
+const removeBracesActionName = "Remove braces from arrow function";
+const addBracesActionDescription = Diagnostics.Add_braces_to_arrow_function.message;
+const removeBracesActionDescription = Diagnostics.Remove_braces_from_arrow_function.message;
+registerRefactor(refactorName, { getEditsForAction, getAvailableActions });
+function getAvailableActions(context) {
+    const { file, startPosition } = context;
+    const info = getConvertibleArrowFunctionAtPosition(file, startPosition);
+    if (!info)
+        return emptyArray;
+    return [{
+            name: refactorName,
+            description: refactorDescription,
+            actions: [
+                info.addBraces ?
+                    {
+                        name: addBracesActionName,
+                        description: addBracesActionDescription
+                    } : {
+                    name: removeBracesActionName,
+                    description: removeBracesActionDescription
+                }
+            ]
+        }];
+}
+function getEditsForAction(context, actionName) {
+    const { file, startPosition } = context;
+    const info = getConvertibleArrowFunctionAtPosition(file, startPosition);
+    if (!info)
+        return undefined;
+    const { expression, returnStatement, func } = info;
+    let body;
+    if (actionName === addBracesActionName) {
+        const returnStatement = createReturn(expression);
+        body = createBlock([returnStatement], /* multiLine */ true);
+        suppressLeadingAndTrailingTrivia(body);
+        copyLeadingComments(expression, returnStatement, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ true);
+    }
+    else if (actionName === removeBracesActionName && returnStatement) {
+        // O corpo `{ return; }` vira o `undefined`, e não o `void 0` da tag: o operador `void` saiu da Linguagem
+        // (CK-63, CK-69).
+        const actualExpression = expression || createIdentifier("undefined");
+        body = needsParentheses(actualExpression) ? createParen(actualExpression) : actualExpression;
+        suppressLeadingAndTrailingTrivia(body);
+        copyTrailingAsLeadingComments(returnStatement, body, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false);
+        copyLeadingComments(returnStatement, body, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false);
+        copyTrailingComments(returnStatement, body, file, SyntaxKind.MultiLineCommentTrivia, /* hasTrailingNewLine */ false);
+    }
+    else {
+        Debug.fail("invalid action");
+    }
+    const edits = textChanges.ChangeTracker.with(context, t => {
+        t.replaceNode(file, func.body, body);
+    });
+    return { renameFilename: undefined, renameLocation: undefined, edits };
+}
+function getConvertibleArrowFunctionAtPosition(file, startPosition) {
+    const node = getTokenAtPosition(file, startPosition);
+    const func = getContainingFunction(node);
+    if (!func || !isArrowFunction(func) || (!rangeContainsRange(func, node) || rangeContainsRange(func.body, node)))
+        return undefined;
+    if (isExpression(func.body)) {
+        return {
+            func,
+            addBraces: true,
+            expression: func.body
+        };
+    }
+    else if (func.body.statements.length === 1) {
+        const firstStatement = first(func.body.statements);
+        if (isReturnStatement(firstStatement)) {
+            return {
+                func,
+                addBraces: false,
+                expression: firstStatement.expression,
+                returnStatement: firstStatement
+            };
+        }
+    }
+    return undefined;
+}