@tslite/services 0.0.0-stage → 1.13.0

package/dist/classifier.js

@@ -0,0 +1,439 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/classifier.ts: o namespace virou módulo ES, com os imports explícitos.
+// O arquivo entra com o que os serviços que já vieram usam (a classificação sintática e a semântica); o classificador
+// léxico (o `createClassifier`) vem com o grupo que o usar (o docs/ARCHITECTURE.md do pacote).
+import { CharacterCodes, Debug, ModuleInstanceState, ScriptTarget, SymbolFlags, SyntaxKind, commentPragmas, couldStartTrivia, createScanner, createTextSpan, decodedTextSpanIntersectsWith, getMeaningFromLocation, getModuleInstanceState, getTypeArgumentOrTypeParameterList, isIdentifier, isKeyword, isLineBreak, isModuleDeclaration, isPunctuation, isTemplateLiteralKind, isToken, isTrivia, nodeIsMissing, some, textSpanIntersectsWith, } from "./_namespaces/ts.js";
+export function getSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span) {
+    return convertClassificationsToSpans(getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span));
+}
+function checkForClassificationCancellation(cancellationToken, kind) {
+    // We don't want to actually call back into our host on every node to find out if we've
+    // been canceled.  That would be an enormous amount of chattyness, along with the all
+    // the overhead of marshalling the data to/from the host.  So instead we pick a few
+    // reasonable node kinds to bother checking on.  These node kinds represent high level
+    // constructs that we would expect to see commonly, but just at a far less frequent
+    // interval.
+    //
+    // For example, in checker.ts (around 750k) we only have around 600 of these constructs.
+    // That means we're calling back into the host around every 1.2k of the file we process.
+    // Lib.d.ts has similar numbers.
+    // Na tag, também a classe, a interface e a `function` declaradas (CK-02).
+    switch (kind) {
+        case SyntaxKind.ModuleDeclaration:
+            cancellationToken.throwIfCancellationRequested();
+    }
+}
+export function getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span) {
+    const spans = [];
+    sourceFile.forEachChild(function cb(node) {
+        // Only walk into nodes that intersect the requested span.
+        if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth())) {
+            return;
+        }
+        checkForClassificationCancellation(cancellationToken, node.kind);
+        // Only bother calling into the typechecker if this is an identifier that
+        // could possibly resolve to a type name.  This makes classification run
+        // in a third of the time it would normally take.
+        if (isIdentifier(node) && !nodeIsMissing(node) && classifiableNames.has(node.escapedText)) {
+            const symbol = typeChecker.getSymbolAtLocation(node);
+            const type = symbol && classifySymbol(symbol, getMeaningFromLocation(node), typeChecker);
+            if (type) {
+                pushClassification(node.getStart(sourceFile), node.getEnd(), type);
+            }
+        }
+        node.forEachChild(cb);
+    });
+    return { spans, endOfLineState: 0 /* EndOfLineState.None */ };
+    function pushClassification(start, end, type) {
+        const length = end - start;
+        Debug.assert(length > 0, `Classification had non-positive length of ${length}`);
+        spans.push(start);
+        spans.push(length);
+        spans.push(type);
+    }
+}
+function classifySymbol(symbol, meaningAtPosition, checker) {
+    const flags = symbol.getFlags();
+    // Na tag, também a classe e o enum (CK-02). A interface que fica é a do embutido (CK-48).
+    if ((flags & SymbolFlags.Classifiable) === SymbolFlags.None) {
+        return undefined;
+    }
+    else if (flags & SymbolFlags.TypeAlias) {
+        return 16 /* ClassificationType.typeAliasName */;
+    }
+    else if (flags & SymbolFlags.Module) {
+        // Only classify a module as such if
+        //  - It appears in a namespace context.
+        //  - There exists a module declaration which actually impacts the value side.
+        return meaningAtPosition & 4 /* SemanticMeaning.Namespace */ || meaningAtPosition & 1 /* SemanticMeaning.Value */ && hasValueSideModule(symbol) ? 14 /* ClassificationType.moduleName */ : undefined;
+    }
+    else if (flags & SymbolFlags.Alias) {
+        return classifySymbol(checker.getAliasedSymbol(symbol), meaningAtPosition, checker);
+    }
+    else if (meaningAtPosition & 2 /* SemanticMeaning.Type */) {
+        return flags & SymbolFlags.Interface ? 13 /* ClassificationType.interfaceName */ : flags & SymbolFlags.TypeParameter ? 15 /* ClassificationType.typeParameterName */ : undefined;
+    }
+    else {
+        return undefined;
+    }
+}
+/** Returns true if there exists a module that introduces entities on the value side. */
+function hasValueSideModule(symbol) {
+    return some(symbol.declarations, declaration => isModuleDeclaration(declaration) && getModuleInstanceState(declaration) === ModuleInstanceState.Instantiated);
+}
+function getClassificationTypeName(type) {
+    switch (type) {
+        case 1 /* ClassificationType.comment */: return "comment" /* ClassificationTypeNames.comment */;
+        case 2 /* ClassificationType.identifier */: return "identifier" /* ClassificationTypeNames.identifier */;
+        case 3 /* ClassificationType.keyword */: return "keyword" /* ClassificationTypeNames.keyword */;
+        case 4 /* ClassificationType.numericLiteral */: return "number" /* ClassificationTypeNames.numericLiteral */;
+        case 25 /* ClassificationType.bigintLiteral */: return "bigint" /* ClassificationTypeNames.bigintLiteral */;
+        case 5 /* ClassificationType.operator */: return "operator" /* ClassificationTypeNames.operator */;
+        case 6 /* ClassificationType.stringLiteral */: return "string" /* ClassificationTypeNames.stringLiteral */;
+        case 8 /* ClassificationType.whiteSpace */: return "whitespace" /* ClassificationTypeNames.whiteSpace */;
+        case 9 /* ClassificationType.text */: return "text" /* ClassificationTypeNames.text */;
+        case 10 /* ClassificationType.punctuation */: return "punctuation" /* ClassificationTypeNames.punctuation */;
+        case 11 /* ClassificationType.className */: return "class name" /* ClassificationTypeNames.className */;
+        case 12 /* ClassificationType.enumName */: return "enum name" /* ClassificationTypeNames.enumName */;
+        case 13 /* ClassificationType.interfaceName */: return "interface name" /* ClassificationTypeNames.interfaceName */;
+        case 14 /* ClassificationType.moduleName */: return "module name" /* ClassificationTypeNames.moduleName */;
+        case 15 /* ClassificationType.typeParameterName */: return "type parameter name" /* ClassificationTypeNames.typeParameterName */;
+        case 16 /* ClassificationType.typeAliasName */: return "type alias name" /* ClassificationTypeNames.typeAliasName */;
+        case 17 /* ClassificationType.parameterName */: return "parameter name" /* ClassificationTypeNames.parameterName */;
+        case 18 /* ClassificationType.docCommentTagName */: return "doc comment tag name" /* ClassificationTypeNames.docCommentTagName */;
+        case 19 /* ClassificationType.jsxOpenTagName */: return "jsx open tag name" /* ClassificationTypeNames.jsxOpenTagName */;
+        case 20 /* ClassificationType.jsxCloseTagName */: return "jsx close tag name" /* ClassificationTypeNames.jsxCloseTagName */;
+        case 21 /* ClassificationType.jsxSelfClosingTagName */: return "jsx self closing tag name" /* ClassificationTypeNames.jsxSelfClosingTagName */;
+        case 22 /* ClassificationType.jsxAttribute */: return "jsx attribute" /* ClassificationTypeNames.jsxAttribute */;
+        case 23 /* ClassificationType.jsxText */: return "jsx text" /* ClassificationTypeNames.jsxText */;
+        case 24 /* ClassificationType.jsxAttributeStringLiteralValue */: return "jsx attribute string literal value" /* ClassificationTypeNames.jsxAttributeStringLiteralValue */;
+        default: return undefined;
+    }
+}
+function convertClassificationsToSpans(classifications) {
+    Debug.assert(classifications.spans.length % 3 === 0);
+    const dense = classifications.spans;
+    const result = [];
+    for (let i = 0; i < dense.length; i += 3) {
+        result.push({
+            textSpan: createTextSpan(dense[i], dense[i + 1]),
+            classificationType: getClassificationTypeName(dense[i + 2])
+        });
+    }
+    return result;
+}
+export function getSyntacticClassifications(cancellationToken, sourceFile, span) {
+    return convertClassificationsToSpans(getEncodedSyntacticClassifications(cancellationToken, sourceFile, span));
+}
+export function getEncodedSyntacticClassifications(cancellationToken, sourceFile, span) {
+    const spanStart = span.start;
+    const spanLength = span.length;
+    // Make a scanner we can get trivia from.
+    const triviaScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+    const mergeConflictScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+    const result = [];
+    processElement(sourceFile);
+    return { spans: result, endOfLineState: 0 /* EndOfLineState.None */ };
+    function pushClassification(start, length, type) {
+        result.push(start);
+        result.push(length);
+        result.push(type);
+    }
+    function classifyLeadingTriviaAndGetTokenStart(token) {
+        triviaScanner.setTextPos(token.pos);
+        while (true) {
+            const start = triviaScanner.getTextPos();
+            // only bother scanning if we have something that could be trivia.
+            if (!couldStartTrivia(sourceFile.text, start)) {
+                return start;
+            }
+            const kind = triviaScanner.scan();
+            const end = triviaScanner.getTextPos();
+            const width = end - start;
+            // The moment we get something that isn't trivia, then stop processing.
+            if (!isTrivia(kind)) {
+                return start;
+            }
+            switch (kind) {
+                case SyntaxKind.NewLineTrivia:
+                case SyntaxKind.WhitespaceTrivia:
+                    // Don't bother with newlines/whitespace.
+                    continue;
+                case SyntaxKind.SingleLineCommentTrivia:
+                case SyntaxKind.MultiLineCommentTrivia:
+                    // Only bother with the trivia if it at least intersects the span of interest.
+                    classifyComment(kind, start, width);
+                    // Classifying a comment might cause us to reuse the trivia scanner
+                    // (because of jsdoc comments).  So after we classify the comment make
+                    // sure we set the scanner position back to where it needs to be.
+                    triviaScanner.setTextPos(end);
+                    continue;
+                case SyntaxKind.ConflictMarkerTrivia:
+                    const text = sourceFile.text;
+                    const ch = text.charCodeAt(start);
+                    // for the <<<<<<< and >>>>>>> markers, we just add them in as comments
+                    // in the classification stream.
+                    if (ch === CharacterCodes.lessThan || ch === CharacterCodes.greaterThan) {
+                        pushClassification(start, width, 1 /* ClassificationType.comment */);
+                        continue;
+                    }
+                    // for the ||||||| and ======== markers, add a comment for the first line,
+                    // and then lex all subsequent lines up until the end of the conflict marker.
+                    Debug.assert(ch === CharacterCodes.bar || ch === CharacterCodes.equals);
+                    classifyDisabledMergeCode(text, start, end);
+                    break;
+                case SyntaxKind.ShebangTrivia:
+                    // TODO: Maybe we should classify these.
+                    break;
+                default:
+                    Debug.assertNever(kind);
+            }
+        }
+    }
+    /**
+     * Na tag, o comentário JSDoc se classificava por partes (a tag, o nome do parâmetro, o tipo), pelo nó que o parser do
+     * JSDoc montava, e o nó que o comentário documenta era o `token`; sem o JSDoc (CK-03), ele é um comentário como os
+     * outros.
+     */
+    function classifyComment(kind, start, width) {
+        if (kind === SyntaxKind.SingleLineCommentTrivia) {
+            if (tryClassifyTripleSlashComment(start, width)) {
+                return;
+            }
+        }
+        // Simple comment.  Just add as is.
+        pushCommentRange(start, width);
+    }
+    function pushCommentRange(start, width) {
+        pushClassification(start, width, 1 /* ClassificationType.comment */);
+    }
+    function tryClassifyTripleSlashComment(start, width) {
+        const tripleSlashXMLCommentRegEx = /^(\/\/\/\s*)(<)(?:(\S+)((?:[^/]|\/[^>])*)(\/>)?)?/im;
+        const attributeRegex = /(\S+)(\s*)(=)(\s*)('[^']+'|"[^"]+")/img;
+        const text = sourceFile.text.substr(start, width);
+        const match = tripleSlashXMLCommentRegEx.exec(text);
+        if (!match) {
+            return false;
+        }
+        // Limiting classification to exactly the elements and attributes
+        // defined in `ts.commentPragmas` would be excessive, but we can avoid
+        // some obvious false positives (e.g. in XML-like doc comments) by
+        // checking the element name.
+        // eslint-disable-next-line no-in-operator
+        if (!match[3] || !(match[3] in commentPragmas)) {
+            return false;
+        }
+        let pos = start;
+        pushCommentRange(pos, match[1].length); // ///
+        pos += match[1].length;
+        pushClassification(pos, match[2].length, 10 /* ClassificationType.punctuation */); // <
+        pos += match[2].length;
+        pushClassification(pos, match[3].length, 21 /* ClassificationType.jsxSelfClosingTagName */); // element name
+        pos += match[3].length;
+        const attrText = match[4];
+        let attrPos = pos;
+        while (true) {
+            const attrMatch = attributeRegex.exec(attrText);
+            if (!attrMatch) {
+                break;
+            }
+            const newAttrPos = pos + attrMatch.index;
+            if (newAttrPos > attrPos) {
+                pushCommentRange(attrPos, newAttrPos - attrPos);
+                attrPos = newAttrPos;
+            }
+            pushClassification(attrPos, attrMatch[1].length, 22 /* ClassificationType.jsxAttribute */); // attribute name
+            attrPos += attrMatch[1].length;
+            if (attrMatch[2].length) {
+                pushCommentRange(attrPos, attrMatch[2].length); // whitespace
+                attrPos += attrMatch[2].length;
+            }
+            pushClassification(attrPos, attrMatch[3].length, 5 /* ClassificationType.operator */); // =
+            attrPos += attrMatch[3].length;
+            if (attrMatch[4].length) {
+                pushCommentRange(attrPos, attrMatch[4].length); // whitespace
+                attrPos += attrMatch[4].length;
+            }
+            pushClassification(attrPos, attrMatch[5].length, 24 /* ClassificationType.jsxAttributeStringLiteralValue */); // attribute value
+            attrPos += attrMatch[5].length;
+        }
+        pos += match[4].length;
+        if (pos > attrPos) {
+            pushCommentRange(attrPos, pos - attrPos);
+        }
+        if (match[5]) {
+            pushClassification(pos, match[5].length, 10 /* ClassificationType.punctuation */); // />
+            pos += match[5].length;
+        }
+        const end = start + width;
+        if (pos < end) {
+            pushCommentRange(pos, end - pos);
+        }
+        return true;
+    }
+    function classifyDisabledMergeCode(text, start, end) {
+        // Classify the line that the ||||||| or ======= marker is on as a comment.
+        // Then just lex all further tokens and add them to the result.
+        let i;
+        for (i = start; i < end; i++) {
+            if (isLineBreak(text.charCodeAt(i))) {
+                break;
+            }
+        }
+        pushClassification(start, i - start, 1 /* ClassificationType.comment */);
+        mergeConflictScanner.setTextPos(i);
+        while (mergeConflictScanner.getTextPos() < end) {
+            classifyDisabledCodeToken();
+        }
+    }
+    function classifyDisabledCodeToken() {
+        const start = mergeConflictScanner.getTextPos();
+        const tokenKind = mergeConflictScanner.scan();
+        const end = mergeConflictScanner.getTextPos();
+        const type = classifyTokenType(tokenKind);
+        if (type) {
+            pushClassification(start, end - start, type);
+        }
+    }
+    /**
+     * Returns true if node should be treated as classified and no further processing is required.
+     * False will mean that node is not classified and traverse routine should recurse into node contents.
+     * Na tag, também o nó de JSDoc, que a parse tree da cópia não tem (CK-03).
+     */
+    function tryClassifyNode(node) {
+        if (nodeIsMissing(node)) {
+            return true;
+        }
+        const classifiedElementName = tryClassifyJsxElementName(node);
+        if (!isToken(node) && node.kind !== SyntaxKind.JsxText && classifiedElementName === undefined) {
+            return false;
+        }
+        const tokenStart = node.kind === SyntaxKind.JsxText ? node.pos : classifyLeadingTriviaAndGetTokenStart(node);
+        const tokenWidth = node.end - tokenStart;
+        Debug.assert(tokenWidth >= 0);
+        if (tokenWidth > 0) {
+            const type = classifiedElementName || classifyTokenType(node.kind, node);
+            if (type) {
+                pushClassification(tokenStart, tokenWidth, type);
+            }
+        }
+        return true;
+    }
+    function tryClassifyJsxElementName(token) {
+        switch (token.parent && token.parent.kind) {
+            case SyntaxKind.JsxOpeningElement:
+                if (token.parent.tagName === token) {
+                    return 19 /* ClassificationType.jsxOpenTagName */;
+                }
+                break;
+            case SyntaxKind.JsxClosingElement:
+                if (token.parent.tagName === token) {
+                    return 20 /* ClassificationType.jsxCloseTagName */;
+                }
+                break;
+            case SyntaxKind.JsxSelfClosingElement:
+                if (token.parent.tagName === token) {
+                    return 21 /* ClassificationType.jsxSelfClosingTagName */;
+                }
+                break;
+            case SyntaxKind.JsxAttribute:
+                if (token.parent.name === token) {
+                    return 22 /* ClassificationType.jsxAttribute */;
+                }
+                break;
+        }
+        return undefined;
+    }
+    // for accurate classification, the actual token should be passed in.  however, for
+    // cases like 'disabled merge code' classification, we just get the token kind and
+    // classify based on that instead.
+    function classifyTokenType(tokenKind, token) {
+        if (isKeyword(tokenKind)) {
+            return 3 /* ClassificationType.keyword */;
+        }
+        // Special case `<` and `>`: If they appear in a generic context they are punctuation,
+        // not operators.
+        if (tokenKind === SyntaxKind.LessThanToken || tokenKind === SyntaxKind.GreaterThanToken) {
+            // If the node owning the token has a type argument list or type parameter list, then
+            // we can effectively assume that a '<' and '>' belong to those lists.
+            if (token && getTypeArgumentOrTypeParameterList(token.parent)) {
+                return 10 /* ClassificationType.punctuation */;
+            }
+        }
+        if (isPunctuation(tokenKind)) {
+            if (token) {
+                const parent = token.parent;
+                if (tokenKind === SyntaxKind.EqualsToken) {
+                    // the '=' in a variable declaration is special cased here.
+                    // Na tag, também o de uma propriedade de classe (CK-02).
+                    if (parent.kind === SyntaxKind.VariableDeclaration ||
+                        parent.kind === SyntaxKind.Parameter ||
+                        parent.kind === SyntaxKind.JsxAttribute) {
+                        return 5 /* ClassificationType.operator */;
+                    }
+                }
+                if (parent.kind === SyntaxKind.BinaryExpression ||
+                    parent.kind === SyntaxKind.PrefixUnaryExpression ||
+                    parent.kind === SyntaxKind.PostfixUnaryExpression ||
+                    parent.kind === SyntaxKind.ConditionalExpression) {
+                    return 5 /* ClassificationType.operator */;
+                }
+            }
+            return 10 /* ClassificationType.punctuation */;
+        }
+        else if (tokenKind === SyntaxKind.NumericLiteral) {
+            return 4 /* ClassificationType.numericLiteral */;
+        }
+        else if (tokenKind === SyntaxKind.BigIntLiteral) {
+            return 25 /* ClassificationType.bigintLiteral */;
+        }
+        else if (tokenKind === SyntaxKind.StringLiteral) {
+            return token && token.parent.kind === SyntaxKind.JsxAttribute ? 24 /* ClassificationType.jsxAttributeStringLiteralValue */ : 6 /* ClassificationType.stringLiteral */;
+        }
+        // Na tag, também o literal de regex, como string (CK-02).
+        else if (isTemplateLiteralKind(tokenKind)) {
+            return 6 /* ClassificationType.stringLiteral */;
+        }
+        else if (tokenKind === SyntaxKind.JsxText) {
+            return 23 /* ClassificationType.jsxText */;
+        }
+        else if (tokenKind === SyntaxKind.Identifier) {
+            if (token) {
+                // Na tag, também o nome de uma classe, de uma interface e de um enum declarados, e o parâmetro `this`, que
+                // era palavra-chave (CK-02).
+                switch (token.parent.kind) {
+                    case SyntaxKind.TypeParameter:
+                        if (token.parent.name === token) {
+                            return 15 /* ClassificationType.typeParameterName */;
+                        }
+                        return;
+                    case SyntaxKind.ModuleDeclaration:
+                        if (token.parent.name === token) {
+                            return 14 /* ClassificationType.moduleName */;
+                        }
+                        return;
+                    case SyntaxKind.Parameter:
+                        if (token.parent.name === token) {
+                            return 17 /* ClassificationType.parameterName */;
+                        }
+                        return;
+                }
+            }
+            return 2 /* ClassificationType.identifier */;
+        }
+    }
+    function processElement(element) {
+        if (!element) {
+            return;
+        }
+        // Ignore nodes that don't intersect the original span to classify.
+        if (decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) {
+            checkForClassificationCancellation(cancellationToken, element.kind);
+            for (const child of element.getChildren(sourceFile)) {
+                if (!tryClassifyNode(child)) {
+                    // Recurse into our child nodes.
+                    processElement(child);
+                }
+            }
+        }
+    }
+}

package/dist/codeFixProvider.d.ts

@@ -0,0 +1,13 @@
+import { textChanges } from "./_namespaces/edit.js";
+import type { CodeFixAction, CodeFixAllContext, CodeFixContext, CodeFixRegistration, CombinedCodeActions, DiagnosticMessage, DiagnosticWithLocation, FileTextChanges, TextChange } from "./_namespaces/edit.js";
+export type DiagnosticAndArguments = DiagnosticMessage | [DiagnosticMessage, string] | [DiagnosticMessage, string, string];
+export declare function createCodeFixActionWithoutFixAll(fixName: string, changes: FileTextChanges[], description: DiagnosticAndArguments): CodeFixAction;
+export declare function createCodeFixAction(fixName: string, changes: FileTextChanges[], description: DiagnosticAndArguments, fixId: {}, fixAllDescription: DiagnosticAndArguments): CodeFixAction;
+export declare function registerCodeFix(reg: CodeFixRegistration): void;
+export declare function getSupportedErrorCodes(): string[];
+export declare function getFixes(context: CodeFixContext): readonly CodeFixAction[];
+export declare function getAllFixes(context: CodeFixAllContext): CombinedCodeActions;
+export declare function createCombinedCodeActions(changes: FileTextChanges[]): CombinedCodeActions;
+export declare function createFileTextChanges(fileName: string, textChanges: TextChange[]): FileTextChanges;
+export declare function codeFixAll(context: CodeFixAllContext, errorCodes: number[], use: (changes: textChanges.ChangeTracker, error: DiagnosticWithLocation) => void): CombinedCodeActions;
+export declare function eachDiagnostic(context: CodeFixAllContext, errorCodes: readonly number[], cb: (diag: DiagnosticWithLocation) => void): void;

package/dist/codeFixProvider.js

@@ -0,0 +1,84 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codeFixProvider.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, arrayFrom, cast, computeSuggestionDiagnostics, contains, createMap, createMultiMap, flatMap, formatStringFromArgs, getLocaleSpecificMessage, isArray, isString, map, textChanges, } from "./_namespaces/edit.js";
+const errorCodeToFixes = createMultiMap();
+const fixIdToRegistration = createMap();
+function diagnosticToString(diag) {
+    return isArray(diag)
+        ? formatStringFromArgs(getLocaleSpecificMessage(diag[0]), diag.slice(1))
+        : getLocaleSpecificMessage(diag);
+}
+export function createCodeFixActionWithoutFixAll(fixName, changes, description) {
+    return createCodeFixActionWorker(fixName, diagnosticToString(description), changes, /*fixId*/ undefined, /*fixAllDescription*/ undefined);
+}
+// Na tag, a ação e o worker dela recebiam também o `command`, o pedido ao host de instalar um pacote de tipos (CK-47).
+export function createCodeFixAction(fixName, changes, description, fixId, fixAllDescription) {
+    return createCodeFixActionWorker(fixName, diagnosticToString(description), changes, fixId, diagnosticToString(fixAllDescription));
+}
+function createCodeFixActionWorker(fixName, description, changes, fixId, fixAllDescription) {
+    return { fixName, description, changes, fixId, fixAllDescription };
+}
+export function registerCodeFix(reg) {
+    for (const error of reg.errorCodes) {
+        errorCodeToFixes.add(String(error), reg);
+    }
+    if (reg.fixIds) {
+        for (const fixId of reg.fixIds) {
+            Debug.assert(!fixIdToRegistration.has(fixId));
+            fixIdToRegistration.set(fixId, reg);
+        }
+    }
+}
+export function getSupportedErrorCodes() {
+    return arrayFrom(errorCodeToFixes.keys());
+}
+function removeFixIdIfFixAllUnavailable(registration, diagnostics) {
+    const { errorCodes } = registration;
+    let maybeFixableDiagnostics = 0;
+    for (const diag of diagnostics) {
+        if (contains(errorCodes, diag.code))
+            maybeFixableDiagnostics++;
+        if (maybeFixableDiagnostics > 1)
+            break;
+    }
+    const fixAllUnavailable = maybeFixableDiagnostics < 2;
+    return ({ fixId, fixAllDescription, ...action }) => {
+        return fixAllUnavailable ? action : { ...action, fixId, fixAllDescription };
+    };
+}
+export function getFixes(context) {
+    const diagnostics = getDiagnostics(context);
+    const registrations = errorCodeToFixes.get(String(context.errorCode));
+    return flatMap(registrations, f => map(f.getCodeActions(context), removeFixIdIfFixAllUnavailable(f, diagnostics)));
+}
+export function getAllFixes(context) {
+    // Currently fixId is always a string.
+    return fixIdToRegistration.get(cast(context.fixId, isString)).getAllCodeActions(context);
+}
+// Na tag, também os `commands` da ação combinada (CK-47).
+export function createCombinedCodeActions(changes) {
+    return { changes };
+}
+export function createFileTextChanges(fileName, textChanges) {
+    return { fileName, textChanges };
+}
+export function codeFixAll(context, errorCodes, 
+// Na tag, o `use` recebia também os `commands` que a ação combinada levava ao host (CK-47).
+use) {
+    const changes = textChanges.ChangeTracker.with(context, t => eachDiagnostic(context, errorCodes, diag => use(t, diag)));
+    return createCombinedCodeActions(changes);
+}
+export function eachDiagnostic(context, errorCodes, cb) {
+    for (const diag of getDiagnostics(context)) {
+        if (contains(errorCodes, diag.code)) {
+            cb(diag);
+        }
+    }
+}
+function getDiagnostics({ program, sourceFile, cancellationToken }) {
+    return [
+        ...program.getSemanticDiagnostics(sourceFile, cancellationToken),
+        // Na tag, com o cancelamento; os diagnósticos de parse do `check` da cópia não o perguntam, como na casca.
+        ...program.getSyntacticDiagnostics(sourceFile),
+        ...computeSuggestionDiagnostics(sourceFile, program, cancellationToken)
+    ];
+}

package/dist/codefixes/addConvertToUnknownForNonOverlappingTypes.d.ts

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

package/dist/codefixes/addConvertToUnknownForNonOverlappingTypes.js

@@ -0,0 +1,21 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/addConvertToUnknownForNonOverlappingTypes.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, Diagnostics, SyntaxKind, createAsExpression, createKeywordTypeNode, findAncestor, getTokenAtPosition, isAsExpression, textChanges, } from "../_namespaces/edit.js";
+import { codeFixAll, createCodeFixAction, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+const fixId = "addConvertToUnknownForNonOverlappingTypes";
+const errorCodes = [Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first.code];
+registerCodeFix({
+    errorCodes,
+    getCodeActions: (context) => {
+        const changes = textChanges.ChangeTracker.with(context, t => makeChange(t, context.sourceFile, context.span.start));
+        return [createCodeFixAction(fixId, changes, Diagnostics.Add_unknown_conversion_for_non_overlapping_types, fixId, Diagnostics.Add_unknown_to_all_conversions_of_non_overlapping_types)];
+    },
+    fixIds: [fixId],
+    getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => makeChange(changes, diag.file, diag.start)),
+});
+function makeChange(changeTracker, sourceFile, pos) {
+    const token = getTokenAtPosition(sourceFile, pos);
+    // Na tag, também a asserção `<T>x`, que ganhava o `<unknown>` (CK-62).
+    const assertion = Debug.checkDefined(findAncestor(token, (n) => isAsExpression(n)), "Expected to find an assertion expression");
+    const replacement = createAsExpression(assertion.expression, createKeywordTypeNode(SyntaxKind.UnknownKeyword));
+    changeTracker.replaceNode(sourceFile, assertion.expression, replacement);
+}

package/dist/codefixes/addEmptyExportDeclaration.d.ts

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

package/dist/codefixes/addEmptyExportDeclaration.js

@@ -0,0 +1,17 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/codefixes/addEmptyExportDeclaration.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Diagnostics, createExportDeclaration, createNamedExports, textChanges, } from "../_namespaces/edit.js";
+import { createCodeFixActionWithoutFixAll, registerCodeFix, } from "../_namespaces/ts.codefix.js";
+registerCodeFix({
+    errorCodes: [Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code],
+    getCodeActions: context => {
+        const { sourceFile } = context;
+        const changes = textChanges.ChangeTracker.with(context, changes => {
+            const exportDeclaration = createExportDeclaration(
+            /*modifiers*/ undefined, createNamedExports([]), 
+            /*moduleSpecifier*/ undefined, 
+            /*isTypeOnly*/ false);
+            changes.insertNodeAtEndOfScope(sourceFile, sourceFile, exportDeclaration);
+        });
+        return [createCodeFixActionWithoutFixAll("addEmptyExportDeclaration", changes, Diagnostics.Add_export_to_make_this_file_into_a_module)];
+    },
+});

package/dist/codefixes/addMissingAsync.d.ts

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