@tslite/services 0.0.0-stage → 1.12.0

package/dist/documentHighlights.d.ts

@@ -0,0 +1,8 @@
+import type { CancellationToken, CheckResult, HighlightSpan, SourceFile } from "./_namespaces/ts.js";
+export interface DocumentHighlights {
+    fileName: string;
+    highlightSpans: HighlightSpan[];
+}
+export declare namespace DocumentHighlights {
+    function getDocumentHighlights(program: CheckResult, cancellationToken: CancellationToken, sourceFile: SourceFile, position: number, sourceFilesToSearch: readonly SourceFile[]): DocumentHighlights[] | undefined;
+}

package/dist/documentHighlights.js

@@ -0,0 +1,367 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/documentHighlights.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, FindAllReferences, SyntaxKind, arrayFrom, arrayToMultiMap, arrayToSet, cast, concatenate, contains, createTextSpanFromBounds, createTextSpanFromNode, findAncestor, findChildOfKind, findModifier, forEach, forEachChild, forEachReturnStatement, getContainingFunction, getTouchingPropertyName, isAwaitExpression, isBlock, isBreakOrContinueStatement, isCaseClause, isDeclaration, isDefaultClause, isFunctionBlock, isFunctionLike, isIfStatement, isIterationStatement, isJsxClosingElement, isJsxOpeningElement, isModifierKind, isModuleDeclaration, isReturnStatement, isSwitchStatement, isThrowStatement, isTryStatement, isTypeAliasDeclaration, isTypeNode, isVariableStatement, isWhiteSpaceSingleLine, mapDefined, modifierToFlag, toArray, } from "./_namespaces/ts.js";
+export var DocumentHighlights;
+(function (DocumentHighlights) {
+    function getDocumentHighlights(program, cancellationToken, sourceFile, position, sourceFilesToSearch) {
+        const node = getTouchingPropertyName(sourceFile, position);
+        if (node.parent && (isJsxOpeningElement(node.parent) && node.parent.tagName === node || isJsxClosingElement(node.parent))) {
+            // For a JSX element, just highlight the matching tag, not all references.
+            const { openingElement, closingElement } = node.parent.parent;
+            const highlightSpans = [openingElement, closingElement].map(({ tagName }) => getHighlightSpanForNode(tagName, sourceFile));
+            return [{ fileName: sourceFile.fileName, highlightSpans }];
+        }
+        return getSemanticDocumentHighlights(position, node, program, cancellationToken, sourceFilesToSearch) || getSyntacticDocumentHighlights(node, sourceFile);
+    }
+    DocumentHighlights.getDocumentHighlights = getDocumentHighlights;
+    function getHighlightSpanForNode(node, sourceFile) {
+        return {
+            fileName: sourceFile.fileName,
+            textSpan: createTextSpanFromNode(node, sourceFile),
+            kind: "none" /* HighlightSpanKind.none */
+        };
+    }
+    function getSemanticDocumentHighlights(position, node, program, cancellationToken, sourceFilesToSearch) {
+        const sourceFilesSet = arrayToSet(sourceFilesToSearch, f => f.fileName);
+        const referenceEntries = FindAllReferences.getReferenceEntriesForNode(position, node, program, sourceFilesToSearch, cancellationToken, /*options*/ undefined, sourceFilesSet);
+        if (!referenceEntries)
+            return undefined;
+        const map = arrayToMultiMap(referenceEntries.map(FindAllReferences.toHighlightSpan), e => e.fileName, e => e.span);
+        // Na tag, o arquivo fora dos pesquisados era o redirecionado por um pacote, que o `Program` criava (o host, CK-47).
+        return arrayFrom(map.entries(), ([fileName, highlightSpans]) => ({ fileName, highlightSpans }));
+    }
+    function getSyntacticDocumentHighlights(node, sourceFile) {
+        const highlightSpans = getHighlightSpans(node, sourceFile);
+        return highlightSpans && [{ fileName: sourceFile.fileName, highlightSpans }];
+    }
+    function getHighlightSpans(node, sourceFile) {
+        switch (node.kind) {
+            case SyntaxKind.IfKeyword:
+            case SyntaxKind.ElseKeyword:
+                return isIfStatement(node.parent) ? getIfElseOccurrences(node.parent, sourceFile) : undefined;
+            case SyntaxKind.ReturnKeyword:
+                return useParent(node.parent, isReturnStatement, getReturnOccurrences);
+            case SyntaxKind.ThrowKeyword:
+                return useParent(node.parent, isThrowStatement, getThrowOccurrences);
+            case SyntaxKind.TryKeyword:
+            case SyntaxKind.CatchKeyword:
+            case SyntaxKind.FinallyKeyword:
+                const tryStatement = node.kind === SyntaxKind.CatchKeyword ? node.parent.parent : node.parent;
+                return useParent(tryStatement, isTryStatement, getTryCatchFinallyOccurrences);
+            case SyntaxKind.SwitchKeyword:
+                return useParent(node.parent, isSwitchStatement, getSwitchCaseDefaultOccurrences);
+            case SyntaxKind.CaseKeyword:
+            case SyntaxKind.DefaultKeyword: {
+                if (isDefaultClause(node.parent) || isCaseClause(node.parent)) {
+                    return useParent(node.parent.parent.parent, isSwitchStatement, getSwitchCaseDefaultOccurrences);
+                }
+                return undefined;
+            }
+            case SyntaxKind.BreakKeyword:
+            case SyntaxKind.ContinueKeyword:
+                return useParent(node.parent, isBreakOrContinueStatement, getBreakOrContinueStatementOccurrences);
+            case SyntaxKind.ForKeyword:
+            case SyntaxKind.WhileKeyword:
+            case SyntaxKind.DoKeyword:
+                // Na tag, o laço com label também (CK-02).
+                return useParent(node.parent, (n) => isIterationStatement(n), getLoopBreakContinueOccurrences);
+            // Na tag, também o `constructor`, o `get` e o `set` de todas as declarações do símbolo, e o `yield` da função
+            // (CK-02, CK-56).
+            case SyntaxKind.AwaitKeyword:
+                return useParent(node.parent, isAwaitExpression, getAsyncAndAwaitOccurrences);
+            case SyntaxKind.AsyncKeyword:
+                return highlightSpans(getAsyncAndAwaitOccurrences(node));
+            default:
+                return isModifierKind(node.kind) && (isDeclaration(node.parent) || isVariableStatement(node.parent))
+                    ? highlightSpans(getModifierOccurrences(node.kind, node.parent))
+                    : undefined;
+        }
+        function useParent(node, nodeTest, getNodes) {
+            return nodeTest(node) ? highlightSpans(getNodes(node, sourceFile)) : undefined;
+        }
+        function highlightSpans(nodes) {
+            return nodes && nodes.map(node => getHighlightSpanForNode(node, sourceFile));
+        }
+    }
+    /**
+     * Aggregates all throw-statements within this node *without* crossing
+     * into function boundaries and try-blocks with catch-clauses.
+     */
+    function aggregateOwnedThrowStatements(node) {
+        if (isThrowStatement(node)) {
+            return [node];
+        }
+        else if (isTryStatement(node)) {
+            // Exceptions thrown within a try block lacking a catch clause are "owned" in the current context.
+            return concatenate(node.catchClause ? aggregateOwnedThrowStatements(node.catchClause) : node.tryBlock && aggregateOwnedThrowStatements(node.tryBlock), node.finallyBlock && aggregateOwnedThrowStatements(node.finallyBlock));
+        }
+        // Do not cross function boundaries.
+        return isFunctionLike(node) ? undefined : flatMapChildren(node, aggregateOwnedThrowStatements);
+    }
+    /**
+     * For lack of a better name, this function takes a throw statement and returns the
+     * nearest ancestor that is a try-block (whose try statement has a catch clause),
+     * function-block, or source file.
+     */
+    function getThrowStatementOwner(throwStatement) {
+        let child = throwStatement;
+        while (child.parent) {
+            const parent = child.parent;
+            if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
+                return parent;
+            }
+            // A throw-statement is only owned by a try-statement if the try-statement has
+            // a catch clause, and if the throw-statement occurs within the try block.
+            if (isTryStatement(parent) && parent.tryBlock === child && parent.catchClause) {
+                return child;
+            }
+            child = parent;
+        }
+        return undefined;
+    }
+    function aggregateAllBreakAndContinueStatements(node) {
+        return isBreakOrContinueStatement(node) ? [node] : isFunctionLike(node) ? undefined : flatMapChildren(node, aggregateAllBreakAndContinueStatements);
+    }
+    function flatMapChildren(node, cb) {
+        const result = [];
+        node.forEachChild(child => {
+            const value = cb(child);
+            if (value !== undefined) {
+                result.push(...toArray(value));
+            }
+        });
+        return result;
+    }
+    function ownsBreakOrContinueStatement(owner, statement) {
+        const actualOwner = getBreakOrContinueOwner(statement);
+        return !!actualOwner && actualOwner === owner;
+    }
+    function getBreakOrContinueOwner(statement) {
+        return findAncestor(statement, node => {
+            switch (node.kind) {
+                case SyntaxKind.SwitchStatement:
+                    if (statement.kind === SyntaxKind.ContinueStatement) {
+                        return false;
+                    }
+                // falls through
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.ForOfStatement:
+                case SyntaxKind.WhileStatement:
+                case SyntaxKind.DoStatement:
+                    // Na tag, o `break` e o `continue` com label só eram do laço do label (CK-02).
+                    return true;
+                default:
+                    // Não atravessa a fronteira de uma função.
+                    return isFunctionLike(node) && "quit";
+            }
+        });
+    }
+    function getModifierOccurrences(modifier, declaration) {
+        return mapDefined(getNodesToSearchForModifier(declaration, modifierToFlag(modifier)), node => findModifier(node, modifier));
+    }
+    /**
+     * Os nós em que se procura o mesmo modificador: os statements em volta, ou os membros do type literal. Na tag, também
+     * os parâmetros e os membros da classe, do construtor, do método e da `function`, os da interface, o `abstract` e
+     * os parâmetros do construtor de um modificador de acesso (CK-02).
+     */
+    function getNodesToSearchForModifier(declaration, _modifierFlag) {
+        const container = declaration.parent;
+        switch (container.kind) {
+            case SyntaxKind.ModuleBlock:
+            case SyntaxKind.SourceFile:
+            case SyntaxKind.Block:
+            case SyntaxKind.CaseClause:
+            case SyntaxKind.DefaultClause:
+                return container.statements;
+            case SyntaxKind.TypeLiteral:
+                return container.members;
+            default:
+                Debug.assertNever(container, "Invalid container kind.");
+        }
+    }
+    function pushKeywordIf(keywordList, token, ...expected) {
+        if (token && contains(expected, token.kind)) {
+            keywordList.push(token);
+            return true;
+        }
+        return false;
+    }
+    function getLoopBreakContinueOccurrences(loopNode) {
+        const keywords = [];
+        if (pushKeywordIf(keywords, loopNode.getFirstToken(), SyntaxKind.ForKeyword, SyntaxKind.WhileKeyword, SyntaxKind.DoKeyword)) {
+            // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
+            if (loopNode.kind === SyntaxKind.DoStatement) {
+                const loopTokens = loopNode.getChildren();
+                for (let i = loopTokens.length - 1; i >= 0; i--) {
+                    if (pushKeywordIf(keywords, loopTokens[i], SyntaxKind.WhileKeyword)) {
+                        break;
+                    }
+                }
+            }
+        }
+        forEach(aggregateAllBreakAndContinueStatements(loopNode.statement), statement => {
+            if (ownsBreakOrContinueStatement(loopNode, statement)) {
+                pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword, SyntaxKind.ContinueKeyword);
+            }
+        });
+        return keywords;
+    }
+    function getBreakOrContinueStatementOccurrences(breakOrContinueStatement) {
+        const owner = getBreakOrContinueOwner(breakOrContinueStatement);
+        if (owner) {
+            switch (owner.kind) {
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.ForOfStatement:
+                case SyntaxKind.DoStatement:
+                case SyntaxKind.WhileStatement:
+                    return getLoopBreakContinueOccurrences(owner);
+                case SyntaxKind.SwitchStatement:
+                    return getSwitchCaseDefaultOccurrences(owner);
+            }
+        }
+        return undefined;
+    }
+    function getSwitchCaseDefaultOccurrences(switchStatement) {
+        const keywords = [];
+        pushKeywordIf(keywords, switchStatement.getFirstToken(), SyntaxKind.SwitchKeyword);
+        // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
+        forEach(switchStatement.caseBlock.clauses, clause => {
+            pushKeywordIf(keywords, clause.getFirstToken(), SyntaxKind.CaseKeyword, SyntaxKind.DefaultKeyword);
+            forEach(aggregateAllBreakAndContinueStatements(clause), statement => {
+                if (ownsBreakOrContinueStatement(switchStatement, statement)) {
+                    pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword);
+                }
+            });
+        });
+        return keywords;
+    }
+    function getTryCatchFinallyOccurrences(tryStatement, sourceFile) {
+        const keywords = [];
+        pushKeywordIf(keywords, tryStatement.getFirstToken(), SyntaxKind.TryKeyword);
+        if (tryStatement.catchClause) {
+            pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), SyntaxKind.CatchKeyword);
+        }
+        if (tryStatement.finallyBlock) {
+            const finallyKeyword = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
+            pushKeywordIf(keywords, finallyKeyword, SyntaxKind.FinallyKeyword);
+        }
+        return keywords;
+    }
+    function getThrowOccurrences(throwStatement, sourceFile) {
+        const owner = getThrowStatementOwner(throwStatement);
+        if (!owner) {
+            return undefined;
+        }
+        const keywords = [];
+        forEach(aggregateOwnedThrowStatements(owner), throwStatement => {
+            keywords.push(findChildOfKind(throwStatement, SyntaxKind.ThrowKeyword, sourceFile));
+        });
+        // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
+        // ability to "jump out" of the function, and include occurrences for both.
+        if (isFunctionBlock(owner)) {
+            forEachReturnStatement(owner, returnStatement => {
+                keywords.push(findChildOfKind(returnStatement, SyntaxKind.ReturnKeyword, sourceFile));
+            });
+        }
+        return keywords;
+    }
+    function getReturnOccurrences(returnStatement, sourceFile) {
+        const func = getContainingFunction(returnStatement);
+        if (!func) {
+            return undefined;
+        }
+        const keywords = [];
+        forEachReturnStatement(cast(func.body, isBlock), returnStatement => {
+            keywords.push(findChildOfKind(returnStatement, SyntaxKind.ReturnKeyword, sourceFile));
+        });
+        // Include 'throw' statements that do not occur within a try block.
+        forEach(aggregateOwnedThrowStatements(func.body), throwStatement => {
+            keywords.push(findChildOfKind(throwStatement, SyntaxKind.ThrowKeyword, sourceFile));
+        });
+        return keywords;
+    }
+    function getAsyncAndAwaitOccurrences(node) {
+        const func = getContainingFunction(node);
+        if (!func) {
+            return undefined;
+        }
+        const keywords = [];
+        if (func.modifiers) {
+            func.modifiers.forEach(modifier => {
+                pushKeywordIf(keywords, modifier, SyntaxKind.AsyncKeyword);
+            });
+        }
+        forEachChild(func, child => {
+            traverseWithoutCrossingFunction(child, node => {
+                if (isAwaitExpression(node)) {
+                    pushKeywordIf(keywords, node.getFirstToken(), SyntaxKind.AwaitKeyword);
+                }
+            });
+        });
+        return keywords;
+    }
+    // Não atravessa a fronteira de uma função, de um namespace ou de um tipo. Na tag, também a da classe e a da interface
+    // (CK-02), e o `yield` de um generator tinha a mesma travessia (o `getYieldOccurrences`, CK-02).
+    function traverseWithoutCrossingFunction(node, cb) {
+        cb(node);
+        if (!isFunctionLike(node) && !isModuleDeclaration(node) && !isTypeAliasDeclaration(node) && !isTypeNode(node)) {
+            forEachChild(node, child => traverseWithoutCrossingFunction(child, cb));
+        }
+    }
+    function getIfElseOccurrences(ifStatement, sourceFile) {
+        const keywords = getIfElseKeywords(ifStatement, sourceFile);
+        const result = [];
+        // We'd like to highlight else/ifs together if they are only separated by whitespace
+        // (i.e. the keywords are separated by no comments, no newlines).
+        for (let i = 0; i < keywords.length; i++) {
+            if (keywords[i].kind === SyntaxKind.ElseKeyword && i < keywords.length - 1) {
+                const elseKeyword = keywords[i];
+                const ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
+                let shouldCombineElseAndIf = true;
+                // Avoid recalculating getStart() by iterating backwards.
+                for (let j = ifKeyword.getStart(sourceFile) - 1; j >= elseKeyword.end; j--) {
+                    if (!isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) {
+                        shouldCombineElseAndIf = false;
+                        break;
+                    }
+                }
+                if (shouldCombineElseAndIf) {
+                    result.push({
+                        fileName: sourceFile.fileName,
+                        textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
+                        kind: "reference" /* HighlightSpanKind.reference */
+                    });
+                    i++; // skip the next keyword
+                    continue;
+                }
+            }
+            // Ordinary case: just highlight the keyword.
+            result.push(getHighlightSpanForNode(keywords[i], sourceFile));
+        }
+        return result;
+    }
+    function getIfElseKeywords(ifStatement, sourceFile) {
+        const keywords = [];
+        // Traverse upwards through all parent if-statements linked by their else-branches.
+        while (isIfStatement(ifStatement.parent) && ifStatement.parent.elseStatement === ifStatement) {
+            ifStatement = ifStatement.parent;
+        }
+        // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
+        while (true) {
+            const children = ifStatement.getChildren(sourceFile);
+            pushKeywordIf(keywords, children[0], SyntaxKind.IfKeyword);
+            // Generally the 'else' keyword is second-to-last, so we traverse backwards.
+            for (let i = children.length - 1; i >= 0; i--) {
+                if (pushKeywordIf(keywords, children[i], SyntaxKind.ElseKeyword)) {
+                    break;
+                }
+            }
+            if (!ifStatement.elseStatement || !isIfStatement(ifStatement.elseStatement)) {
+                break;
+            }
+            ifStatement = ifStatement.elseStatement;
+        }
+        return keywords;
+    }
+})(DocumentHighlights || (DocumentHighlights = {}));

package/dist/documentRegistry.d.ts

@@ -0,0 +1,36 @@
+import type { IScriptSnapshot, Path, ScriptKind, SourceFile } from "./_namespaces/ts.js";
+/**
+ * O registro de documentos guarda os `SourceFile` que várias instâncias do language service compartilham: cada uma
+ * segura as árvores dos arquivos do seu programa, e as árvores são quase toda a memória que ele ocupa. Com um registro
+ * só para todas, elas compartilham pelo menos a lib. Para criar um, `createDocumentRegistry`, passado a cada
+ * `createLanguageService`.
+ *
+ * Na tag, o registro separa as árvores por chave de opções de compilação, porque o alvo muda a forma da árvore. A
+ * configuração é fixa (CK-06), e há uma chave só: o registro é um mapa de caminho para árvore.
+ */
+export interface DocumentRegistry {
+    /**
+     * A árvore guardada do arquivo `fileName`. A primeira aquisição a cria (`createLanguageServiceSourceFile`); as
+     * seguintes contam mais um usuário dela.
+     *
+     * @param scriptSnapshot o texto do arquivo; só se usa quando a árvore ainda não está no registro
+     * @param version a versão do arquivo; idem
+     */
+    acquireDocument(fileName: string, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
+    acquireDocumentWithKey(fileName: string, path: Path, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
+    /**
+     * A versão nova de uma árvore que já está no registro. A atualização chama o `updateLanguageServiceSourceFile`,
+     * que reparseia só o trecho que mudou quando o snapshot diz qual foi.
+     *
+     * @param scriptSnapshot o texto do arquivo
+     * @param version a versão do arquivo
+     */
+    updateDocument(fileName: string, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
+    updateDocumentWithKey(fileName: string, path: Path, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
+    /**
+     * Avisa que um usuário não precisa mais da árvore do arquivo. Só se libera a árvore que veio deste registro.
+     */
+    releaseDocument(fileName: string): void;
+    releaseDocumentWithKey(path: Path): void;
+}
+export declare function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry;

package/dist/documentRegistry.js

@@ -0,0 +1,63 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/documentRegistry.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, ScriptTarget, createGetCanonicalFileName, createLanguageServiceSourceFile, createMap, toPath, updateLanguageServiceSourceFile, } from "./_namespaces/ts.js";
+export function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory = "") {
+    const entries = createMap();
+    const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
+    function acquireDocument(fileName, scriptSnapshot, version, scriptKind) {
+        const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+        return acquireDocumentWithKey(fileName, path, scriptSnapshot, version, scriptKind);
+    }
+    function acquireDocumentWithKey(fileName, path, scriptSnapshot, version, scriptKind) {
+        return acquireOrUpdateDocument(fileName, path, scriptSnapshot, version, /*acquiring*/ true, scriptKind);
+    }
+    function updateDocument(fileName, scriptSnapshot, version, scriptKind) {
+        const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+        return updateDocumentWithKey(fileName, path, scriptSnapshot, version, scriptKind);
+    }
+    function updateDocumentWithKey(fileName, path, scriptSnapshot, version, scriptKind) {
+        return acquireOrUpdateDocument(fileName, path, scriptSnapshot, version, /*acquiring*/ false, scriptKind);
+    }
+    function acquireOrUpdateDocument(fileName, path, scriptSnapshot, version, acquiring, scriptKind) {
+        let entry = entries.get(path);
+        // O alvo da configuração fixa (CK-24).
+        const scriptTarget = ScriptTarget.ES2020;
+        if (!entry) {
+            const sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTarget, version, /*setNodeParents*/ false, scriptKind);
+            entry = {
+                sourceFile,
+                languageServiceRefCount: 1,
+            };
+            entries.set(path, entry);
+        }
+        else {
+            if (entry.sourceFile.version !== version) {
+                entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
+            }
+            if (acquiring) {
+                entry.languageServiceRefCount++;
+            }
+        }
+        Debug.assert(entry.languageServiceRefCount !== 0);
+        return entry.sourceFile;
+    }
+    function releaseDocument(fileName) {
+        const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+        return releaseDocumentWithKey(path);
+    }
+    function releaseDocumentWithKey(path) {
+        const entry = Debug.checkDefined(entries.get(path));
+        entry.languageServiceRefCount--;
+        Debug.assert(entry.languageServiceRefCount >= 0);
+        if (entry.languageServiceRefCount === 0) {
+            entries.delete(path);
+        }
+    }
+    return {
+        acquireDocument,
+        acquireDocumentWithKey,
+        updateDocument,
+        updateDocumentWithKey,
+        releaseDocument,
+        releaseDocumentWithKey,
+    };
+}

package/dist/editingServices.d.ts

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

package/dist/editingServices.js

@@ -0,0 +1,4 @@
+// A edição se registra na casca ao carregar (CK-67). A casca da leitura alcança a edição só por este registro, e não a
+// importa: quem só lê não baixa a edição, e o método de edição de um language service sem ela falha.
+import { OrganizeImports, codefix, formatting, getEditsForFileRename, refactor, registerEditingServices, } from "./_namespaces/edit.js";
+registerEditingServices({ formatting, codefix, refactor, OrganizeImports, getEditsForFileRename });

package/dist/findAllReferences.d.ts

@@ -0,0 +1,113 @@
+import { SemanticMeaning } from "./_namespaces/ts.js";
+import type { BinaryExpression, CallExpression, CancellationToken, CheckResult, ForInOrOfStatement, HighlightSpan, Identifier, ImplementationLocation, NamedDeclaration, Node, ReadonlyMap, ReferenceEntry, ReferencedSymbol, RenameLocation, SignatureDeclaration, SourceFile, StringLiteral, Symbol, TextSpan, TypeChecker } from "./_namespaces/ts.js";
+export interface SymbolAndEntries {
+    readonly definition: Definition | undefined;
+    readonly references: readonly Entry[];
+}
+/** Na tag, também o label e o `this` (CK-02). */
+export declare enum DefinitionKind {
+    Symbol = 0,
+    Keyword = 1,
+    String = 2
+}
+export type Definition = {
+    readonly type: DefinitionKind.Symbol;
+    readonly symbol: Symbol;
+} | {
+    readonly type: DefinitionKind.Keyword;
+    readonly node: Node;
+} | {
+    readonly type: DefinitionKind.String;
+    readonly node: StringLiteral;
+};
+export declare enum EntryKind {
+    Span = 0,
+    Node = 1,
+    StringLiteral = 2,
+    SearchedLocalFoundProperty = 3,
+    SearchedPropertyFoundLocal = 4
+}
+export type NodeEntryKind = EntryKind.Node | EntryKind.StringLiteral | EntryKind.SearchedLocalFoundProperty | EntryKind.SearchedPropertyFoundLocal;
+export type Entry = NodeEntry | SpanEntry;
+export interface ContextWithStartAndEndNode {
+    start: Node;
+    end: Node;
+}
+export type ContextNode = Node | ContextWithStartAndEndNode;
+export interface NodeEntry {
+    readonly kind: NodeEntryKind;
+    readonly node: Node;
+    readonly context?: ContextNode;
+}
+export interface SpanEntry {
+    readonly kind: EntryKind.Span;
+    readonly fileName: string;
+    readonly textSpan: TextSpan;
+}
+export declare function nodeEntry(node: Node, kind?: NodeEntryKind): NodeEntry;
+export declare function isContextWithStartAndEndNode(node: ContextNode): node is ContextWithStartAndEndNode;
+export declare function getContextNode(node: NamedDeclaration | BinaryExpression | ForInOrOfStatement | undefined): ContextNode | undefined;
+export declare function toContextSpan(textSpan: TextSpan, sourceFile: SourceFile, context?: ContextNode): {
+    contextSpan: TextSpan;
+} | undefined;
+export declare enum FindReferencesUse {
+    /**
+     * When searching for references to a symbol, the location will not be adjusted (this is the default behavior when not specified).
+     */
+    Other = 0,
+    /**
+     * When searching for references to a symbol, the location will be adjusted if the cursor was on a keyword.
+     */
+    References = 1,
+    /**
+     * When searching for references to a symbol, the location will be adjusted if the cursor was on a keyword.
+     * Unlike `References`, the location will only be adjusted keyword belonged to a declaration with a valid name.
+     * If set, we will find fewer references -- if it is referenced by several different names, we still only find references for the original name.
+     */
+    Rename = 2
+}
+export interface Options {
+    readonly findInStrings?: boolean;
+    readonly findInComments?: boolean;
+    readonly use?: FindReferencesUse;
+    /** True if we are searching for implementations. We will have a different method of adding references if so. */
+    readonly implementations?: boolean;
+    /**
+     * True to opt in for enhanced renaming of shorthand properties and import/export specifiers.
+     * The options controls the behavior for the whole rename operation; it cannot be changed on a per-file basis.
+     * Default is false for backwards compatibility.
+     */
+    readonly providePrefixAndSuffixTextForRename?: boolean;
+}
+export declare function findReferencedSymbols(program: CheckResult, cancellationToken: CancellationToken, sourceFiles: readonly SourceFile[], sourceFile: SourceFile, position: number): ReferencedSymbol[] | undefined;
+export declare function getImplementationsAtPosition(program: CheckResult, cancellationToken: CancellationToken, sourceFiles: readonly SourceFile[], sourceFile: SourceFile, position: number): ImplementationLocation[] | undefined;
+export declare function findReferenceOrRenameEntries<T>(program: CheckResult, cancellationToken: CancellationToken, sourceFiles: readonly SourceFile[], node: Node, position: number, options: Options | undefined, convertEntry: ToReferenceOrRenameEntry<T>): T[] | undefined;
+export type ToReferenceOrRenameEntry<T> = (entry: Entry, originalNode: Node, checker: TypeChecker) => T;
+export declare function getReferenceEntriesForNode(position: number, node: Node, program: CheckResult, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options?: Options, sourceFilesSet?: ReadonlyMap<true>): readonly Entry[] | undefined;
+export declare function toRenameLocation(entry: Entry, originalNode: Node, checker: TypeChecker, providePrefixAndSuffixText: boolean): RenameLocation;
+export declare function toReferenceEntry(entry: Entry): ReferenceEntry;
+export declare function toHighlightSpan(entry: Entry): {
+    fileName: string;
+    span: HighlightSpan;
+};
+export declare function getTextSpanOfEntry(entry: Entry): TextSpan;
+/** Encapsulates the core find-all-references algorithm. */
+export declare namespace Core {
+    /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */
+    function getReferencedSymbolsForNode(_position: number, node: Node, program: CheckResult, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options?: Options, sourceFilesSet?: ReadonlyMap<true>): readonly SymbolAndEntries[] | undefined;
+    function eachExportReference(sourceFiles: readonly SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken | undefined, exportSymbol: Symbol, exportingModuleSymbol: Symbol, exportName: string, isDefaultExport: boolean, cb: (ref: Identifier) => void): void;
+    /** Used as a quick check for whether a symbol is used at all in a file (besides its definition). */
+    function isSymbolReferencedInFile(definition: Identifier, checker: TypeChecker, sourceFile: SourceFile, searchContainer?: Node): boolean;
+    function eachSymbolReferenceInFile<T>(definition: Identifier, checker: TypeChecker, sourceFile: SourceFile, cb: (token: Identifier) => T, searchContainer?: Node): T | undefined;
+    function eachSignatureCall(signature: SignatureDeclaration, sourceFiles: readonly SourceFile[], checker: TypeChecker, cb: (call: CallExpression) => void): void;
+    /**
+     * Given an initial searchMeaning, extracted from a location, widen the search scope based on the declarations
+     * of the corresponding symbol. e.g. if we are searching for "Foo" in value position, but "Foo" references a class
+     * then we need to widen the search to include type positions as well.
+     * On the contrary, if we are searching for "Bar" in type position and we trace bar to an interface, and an uninstantiated
+     * module, we want to keep the search limited to only types, as the two declarations (interface and uninstantiated module)
+     * do not intersect in any of the three spaces.
+     */
+    function getIntersectingMeaningFromDeclarations(node: Node, symbol: Symbol): SemanticMeaning;
+    function getReferenceEntriesForShorthandPropertyAssignment(node: Node, checker: TypeChecker, addReference: (node: Node) => void): void;
+}