@tslite/services 0.0.0-stage → 1.12.0

package/dist/services.js

@@ -0,0 +1,1480 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/services.ts: o namespace virou módulo ES, com os imports explícitos.
+// O arquivo entra com o modelo de objetos do language service, a casca e os serviços dos grupos que já vieram; o resto
+// dele vem com o grupo que o usa (o docs/ARCHITECTURE.md do pacote).
+import * as ts from "./_namespaces/ts.js";
+import { AssignmentDeclarationKind, CharacterCodes, Debug, DocumentHighlights, FindAllReferences, GoToDefinition, IndexKind, ModifierFlags, NavigationBar, NodeFlags, ObjectFlags, OperationCanceledException, OutliningElementsCollector, Rename, ScriptKind, ScriptTarget, SignatureHelp, SmartSelectionRange, SymbolDisplay, SyntaxKind, TransformFlags, TypeFlags, arrayIsEqualTo, check, compareValues, computePositionOfLineAndCharacter, Completions, computeSuggestionDiagnostics, createDocumentRegistry, createGetCanonicalFileName, createMap, createMapFromTemplate, createMultiMap, createSourceFile, createTextSpanFromBounds, createTextSpanFromNode, createTextSpanFromRange, createUnderscoreEscapedMap, deduplicate, emptyArray, emptyOptions, equateValues, find, findChildOfKind, findPrecedingToken, first, flatMap, forEach, forEachChild, getAdjustedRenameLocation, getAssignmentDeclarationKind, getContainerNode, getEscapedTextOfIdentifierOrLiteral, getLineAndCharacterOfPosition, getLineStarts, getNameFromPropertyName, getNonAssignedNameOfDeclaration, getObjectFlags, getRangeOfEnclosingComment, getScriptKind, getSnapshotText, getSourceFileOfNode, getTokenPosOfNode, getTouchingPropertyName, getTouchingToken, hasProperty, hostUsesCaseSensitiveFileNames, idText, identity, isBindingPattern, isComputedPropertyName, isDeclarationName, isIdentifier, isInComment, isInString, isInTemplateString, isInsideJsxElementOrAttribute, isIntrinsicJsxName, isJsxAttributes, isJsxClosingElement, isJsxElement, isJsxOpeningElement, isJsxText, isLiteralComputedPropertyDeclarationName, isNamedExports, isNodeKind, isObjectLiteralElement, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyName, isString, isStringOrNumericLiteralLike, lastOrUndefined, localizedDiagnosticMessages, map, mapDefined, normalizePath, positionIsSynthesized, scanner, setLocalizedDiagnosticMessages, setObjectAllocator, setTypeObjectAllocator, symbolName, tagNamesAreEquivalent, textSpanEnd, timestamp, toPath, typeToDisplayParts, updateSourceFile, } from "./_namespaces/ts.js";
+/** A versão da API do language service. */
+export const servicesVersion = "0.8";
+function createNode(kind, pos, end, parent) {
+    const node = isNodeKind(kind) ? new NodeObject(kind, pos, end) :
+        kind === SyntaxKind.Identifier ? new IdentifierObject(SyntaxKind.Identifier, pos, end) :
+            new TokenObject(kind, pos, end);
+    node.parent = parent;
+    node.flags = parent.flags & NodeFlags.ContextFlags;
+    return node;
+}
+class NodeObject {
+    constructor(kind, pos, end) {
+        this.pos = pos;
+        this.end = end;
+        this.flags = NodeFlags.None;
+        this.modifierFlagsCache = ModifierFlags.None;
+        this.transformFlags = TransformFlags.None;
+        this.parent = undefined;
+        this.kind = kind;
+    }
+    assertHasRealPosition(message) {
+        // eslint-disable-next-line debug-assert
+        Debug.assert(!positionIsSynthesized(this.pos) && !positionIsSynthesized(this.end), message || "Node must have a real position for this operation");
+    }
+    getSourceFile() {
+        return getSourceFileOfNode(this);
+    }
+    getStart(sourceFile) {
+        this.assertHasRealPosition();
+        return getTokenPosOfNode(this, sourceFile);
+    }
+    getFullStart() {
+        this.assertHasRealPosition();
+        return this.pos;
+    }
+    getEnd() {
+        this.assertHasRealPosition();
+        return this.end;
+    }
+    getWidth(sourceFile) {
+        this.assertHasRealPosition();
+        return this.getEnd() - this.getStart(sourceFile);
+    }
+    getFullWidth() {
+        this.assertHasRealPosition();
+        return this.end - this.pos;
+    }
+    getLeadingTriviaWidth(sourceFile) {
+        this.assertHasRealPosition();
+        return this.getStart(sourceFile) - this.pos;
+    }
+    getFullText(sourceFile) {
+        this.assertHasRealPosition();
+        return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end);
+    }
+    getText(sourceFile) {
+        this.assertHasRealPosition();
+        if (!sourceFile) {
+            sourceFile = this.getSourceFile();
+        }
+        return sourceFile.text.substring(this.getStart(sourceFile), this.getEnd());
+    }
+    getChildCount(sourceFile) {
+        return this.getChildren(sourceFile).length;
+    }
+    getChildAt(index, sourceFile) {
+        return this.getChildren(sourceFile)[index];
+    }
+    getChildren(sourceFile) {
+        this.assertHasRealPosition("Node without a real position cannot be scanned and thus has no token nodes - use forEachChild and collect the result if that's fine");
+        return this._children || (this._children = createChildren(this, sourceFile));
+    }
+    getFirstToken(sourceFile) {
+        this.assertHasRealPosition();
+        const children = this.getChildren(sourceFile);
+        if (!children.length) {
+            return undefined;
+        }
+        const child = find(children, kid => kid.kind < SyntaxKind.FirstJSDocNode || kid.kind > SyntaxKind.LastJSDocNode);
+        return child.kind < SyntaxKind.FirstNode ?
+            child :
+            child.getFirstToken(sourceFile);
+    }
+    getLastToken(sourceFile) {
+        this.assertHasRealPosition();
+        const children = this.getChildren(sourceFile);
+        const child = lastOrUndefined(children);
+        if (!child) {
+            return undefined;
+        }
+        return child.kind < SyntaxKind.FirstNode ? child : child.getLastToken(sourceFile);
+    }
+    forEachChild(cbNode, cbNodeArray) {
+        return forEachChild(this, cbNode, cbNodeArray);
+    }
+}
+function createChildren(node, sourceFile) {
+    if (!isNodeKind(node.kind)) {
+        return emptyArray;
+    }
+    const children = [];
+    scanner.setText((sourceFile || node.getSourceFile()).text);
+    let pos = node.pos;
+    const processNode = (child) => {
+        addSyntheticNodes(children, pos, child.pos, node);
+        children.push(child);
+        pos = child.end;
+    };
+    const processNodes = (nodes) => {
+        addSyntheticNodes(children, pos, nodes.pos, node);
+        children.push(createSyntaxList(nodes, node));
+        pos = nodes.end;
+    };
+    node.forEachChild(processNode, processNodes);
+    addSyntheticNodes(children, pos, node.end, node);
+    scanner.setText(undefined);
+    return children;
+}
+function addSyntheticNodes(nodes, pos, end, parent) {
+    scanner.setTextPos(pos);
+    while (pos < end) {
+        const token = scanner.scan();
+        const textPos = scanner.getTextPos();
+        if (textPos <= end) {
+            if (token === SyntaxKind.Identifier) {
+                Debug.fail(`Did not expect ${Debug.formatSyntaxKind(parent.kind)} to have an Identifier in its trivia`);
+            }
+            nodes.push(createNode(token, pos, textPos, parent));
+        }
+        pos = textPos;
+        if (token === SyntaxKind.EndOfFileToken) {
+            break;
+        }
+    }
+}
+function createSyntaxList(nodes, parent) {
+    const list = createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, parent);
+    list._children = [];
+    let pos = nodes.pos;
+    for (const node of nodes) {
+        addSyntheticNodes(list._children, pos, node.pos, parent);
+        list._children.push(node);
+        pos = node.end;
+    }
+    addSyntheticNodes(list._children, pos, nodes.end, parent);
+    return list;
+}
+class TokenOrIdentifierObject {
+    constructor(pos, end) {
+        // Os campos na mesma ordem que no `NodeObject`.
+        this.pos = pos;
+        this.end = end;
+        this.flags = NodeFlags.None;
+        this.modifierFlagsCache = ModifierFlags.None;
+        this.transformFlags = TransformFlags.None;
+        this.parent = undefined;
+    }
+    getSourceFile() {
+        return getSourceFileOfNode(this);
+    }
+    getStart(sourceFile) {
+        return getTokenPosOfNode(this, sourceFile);
+    }
+    getFullStart() {
+        return this.pos;
+    }
+    getEnd() {
+        return this.end;
+    }
+    getWidth(sourceFile) {
+        return this.getEnd() - this.getStart(sourceFile);
+    }
+    getFullWidth() {
+        return this.end - this.pos;
+    }
+    getLeadingTriviaWidth(sourceFile) {
+        return this.getStart(sourceFile) - this.pos;
+    }
+    getFullText(sourceFile) {
+        return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end);
+    }
+    getText(sourceFile) {
+        if (!sourceFile) {
+            sourceFile = this.getSourceFile();
+        }
+        return sourceFile.text.substring(this.getStart(sourceFile), this.getEnd());
+    }
+    getChildCount() {
+        return 0;
+    }
+    getChildAt() {
+        return undefined;
+    }
+    getChildren() {
+        return emptyArray;
+    }
+    getFirstToken() {
+        return undefined;
+    }
+    getLastToken() {
+        return undefined;
+    }
+    forEachChild() {
+        return undefined;
+    }
+}
+class SymbolObject {
+    constructor(flags, name) {
+        this.flags = flags;
+        this.escapedName = name;
+    }
+    getFlags() {
+        return this.flags;
+    }
+    get name() {
+        return symbolName(this);
+    }
+    getEscapedName() {
+        return this.escapedName;
+    }
+    getName() {
+        return this.name;
+    }
+    getDeclarations() {
+        return this.declarations;
+    }
+}
+class TokenObject extends TokenOrIdentifierObject {
+    constructor(kind, pos, end) {
+        super(pos, end);
+        this.kind = kind;
+    }
+}
+class IdentifierObject extends TokenOrIdentifierObject {
+    constructor(_kind, pos, end) {
+        super(pos, end);
+        this.kind = SyntaxKind.Identifier;
+    }
+    get text() {
+        return idText(this);
+    }
+}
+IdentifierObject.prototype.kind = SyntaxKind.Identifier;
+class TypeObject {
+    constructor(checker, flags) {
+        this.checker = checker;
+        this.flags = flags;
+    }
+    getFlags() {
+        return this.flags;
+    }
+    getSymbol() {
+        return this.symbol;
+    }
+    getProperties() {
+        return this.checker.getPropertiesOfType(this);
+    }
+    getProperty(propertyName) {
+        return this.checker.getPropertyOfType(this, propertyName);
+    }
+    getApparentProperties() {
+        return this.checker.getAugmentedPropertiesOfType(this);
+    }
+    getCallSignatures() {
+        return this.checker.getSignaturesOfType(this);
+    }
+    getStringIndexType() {
+        return this.checker.getIndexTypeOfType(this, IndexKind.String);
+    }
+    getNumberIndexType() {
+        return this.checker.getIndexTypeOfType(this, IndexKind.Number);
+    }
+    isNullableType() {
+        return this.checker.isNullableType(this);
+    }
+    getNonNullableType() {
+        return this.checker.getNonNullableType(this);
+    }
+    getNonOptionalType() {
+        return this.checker.getNonOptionalType(this);
+    }
+    getConstraint() {
+        return this.checker.getBaseConstraintOfType(this);
+    }
+    getDefault() {
+        return this.checker.getDefaultFromTypeParameter(this);
+    }
+    isUnion() {
+        return !!(this.flags & TypeFlags.Union);
+    }
+    isIntersection() {
+        return !!(this.flags & TypeFlags.Intersection);
+    }
+    isUnionOrIntersection() {
+        return !!(this.flags & TypeFlags.UnionOrIntersection);
+    }
+    isLiteral() {
+        return !!(this.flags & TypeFlags.StringOrNumberLiteral);
+    }
+    isStringLiteral() {
+        return !!(this.flags & TypeFlags.StringLiteral);
+    }
+    isNumberLiteral() {
+        return !!(this.flags & TypeFlags.NumberLiteral);
+    }
+    isTypeParameter() {
+        return !!(this.flags & TypeFlags.TypeParameter);
+    }
+    /**
+     * O `referenceType.typeArguments` para quem usa a API.
+     */
+    get typeArguments() {
+        if (getObjectFlags(this) & ObjectFlags.Reference) {
+            return this.checker.getTypeArguments(this);
+        }
+        return undefined;
+    }
+}
+class SignatureObject {
+    constructor(checker, flags) {
+        this.checker = checker;
+        this.flags = flags;
+    }
+    getDeclaration() {
+        return this.declaration;
+    }
+    getTypeParameters() {
+        return this.typeParameters;
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    getReturnType() {
+        return this.checker.getReturnTypeOfSignature(this);
+    }
+}
+class SourceFileObject extends NodeObject {
+    constructor(kind, pos, end) {
+        super(kind, pos, end);
+        this.kind = SyntaxKind.SourceFile;
+    }
+    update(newText, textChangeRange) {
+        return updateSourceFile(this, newText, textChangeRange);
+    }
+    getLineAndCharacterOfPosition(position) {
+        return getLineAndCharacterOfPosition(this, position);
+    }
+    getLineStarts() {
+        return getLineStarts(this);
+    }
+    getPositionOfLineAndCharacter(line, character, allowEdits) {
+        return computePositionOfLineAndCharacter(getLineStarts(this), line, character, this.text, allowEdits);
+    }
+    getLineEndOfPosition(pos) {
+        const { line } = this.getLineAndCharacterOfPosition(pos);
+        const lineStarts = this.getLineStarts();
+        let lastCharPos;
+        if (line + 1 >= lineStarts.length) {
+            lastCharPos = this.getEnd();
+        }
+        if (!lastCharPos) {
+            lastCharPos = lineStarts[line + 1] - 1;
+        }
+        const fullText = this.getFullText();
+        // Com a quebra de linha "\r\n", a posição é a do último caractere antes dela.
+        return fullText[lastCharPos] === "\n" && fullText[lastCharPos - 1] === "\r" ? lastCharPos - 1 : lastCharPos;
+    }
+    getNamedDeclarations() {
+        if (!this.namedDeclarations) {
+            this.namedDeclarations = this.computeNamedDeclarations();
+        }
+        return this.namedDeclarations;
+    }
+    computeNamedDeclarations() {
+        const result = createMultiMap();
+        this.forEachChild(visit);
+        return result;
+        function addDeclaration(declaration) {
+            const name = getDeclarationName(declaration);
+            if (name) {
+                result.add(name, declaration);
+            }
+        }
+        function getDeclarationName(declaration) {
+            const name = getNonAssignedNameOfDeclaration(declaration);
+            return name && (isComputedPropertyName(name) && isPropertyAccessExpression(name.expression) ? name.expression.name.text
+                : isPropertyName(name) ? getNameFromPropertyName(name) : undefined);
+        }
+        function visit(node) {
+            switch (node.kind) {
+                case SyntaxKind.TypeAliasDeclaration:
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.ExportSpecifier:
+                case SyntaxKind.ImportSpecifier:
+                case SyntaxKind.ImportClause:
+                case SyntaxKind.NamespaceImport:
+                case SyntaxKind.TypeLiteral:
+                    addDeclaration(node);
+                    forEachChild(node, visit);
+                    break;
+                case SyntaxKind.VariableDeclaration:
+                case SyntaxKind.BindingElement: {
+                    const decl = node;
+                    if (isBindingPattern(decl.name)) {
+                        forEachChild(decl.name, visit);
+                        break;
+                    }
+                    if (decl.initializer) {
+                        visit(decl.initializer);
+                    }
+                }
+                // falls through
+                case SyntaxKind.PropertySignature:
+                    addDeclaration(node);
+                    break;
+                case SyntaxKind.ExportDeclaration:
+                    // O export nomeado: `export {a, b as B} from "mod";`
+                    const exportDeclaration = node;
+                    if (exportDeclaration.exportClause) {
+                        if (isNamedExports(exportDeclaration.exportClause)) {
+                            forEach(exportDeclaration.exportClause.elements, visit);
+                        }
+                        else {
+                            visit(exportDeclaration.exportClause.name);
+                        }
+                    }
+                    break;
+                case SyntaxKind.ImportDeclaration:
+                    const importClause = node.importClause;
+                    if (importClause) {
+                        // O import default: `import d from "mod";`
+                        if (importClause.name) {
+                            addDeclaration(importClause.name);
+                        }
+                        // As ligações nomeadas: `import * as NS from "mod";` e `import {a, b as B} from "mod";`
+                        if (importClause.namedBindings) {
+                            if (importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {
+                                addDeclaration(importClause.namedBindings);
+                            }
+                            else {
+                                forEach(importClause.namedBindings.elements, visit);
+                            }
+                        }
+                    }
+                    break;
+                case SyntaxKind.BinaryExpression:
+                    if (getAssignmentDeclarationKind(node) !== AssignmentDeclarationKind.None) {
+                        addDeclaration(node);
+                    }
+                // falls through
+                default:
+                    forEachChild(node, visit);
+            }
+        }
+    }
+}
+class SourceMapSourceObject {
+    constructor(fileName, text, skipTrivia) {
+        this.fileName = fileName;
+        this.text = text;
+        this.skipTrivia = skipTrivia;
+    }
+    getLineAndCharacterOfPosition(pos) {
+        return getLineAndCharacterOfPosition(this, pos);
+    }
+}
+function getServicesObjectAllocator() {
+    return {
+        getNodeConstructor: () => NodeObject,
+        getTokenConstructor: () => TokenObject,
+        getIdentifierConstructor: () => IdentifierObject,
+        getSourceFileConstructor: () => SourceFileObject,
+        getSymbolConstructor: () => SymbolObject,
+        getSourceMapSourceConstructor: () => SourceMapSourceObject,
+    };
+}
+// O `Type` e a `Signature` têm alocador próprio, no checker (CK-64); na tag, eram do mesmo alocador do nó.
+function getServicesTypeObjectAllocator() {
+    return {
+        getTypeConstructor: () => TypeObject,
+        getSignatureConstructor: () => SignatureObject,
+    };
+}
+export function toEditorSettings(optionsAsMap) {
+    let allPropertiesAreCamelCased = true;
+    for (const key in optionsAsMap) {
+        if (hasProperty(optionsAsMap, key) && !isCamelCase(key)) {
+            allPropertiesAreCamelCased = false;
+            break;
+        }
+    }
+    if (allPropertiesAreCamelCased) {
+        return optionsAsMap;
+    }
+    const settings = {};
+    for (const key in optionsAsMap) {
+        if (hasProperty(optionsAsMap, key)) {
+            const newKey = isCamelCase(key) ? key : key.charAt(0).toLowerCase() + key.substr(1);
+            settings[newKey] = optionsAsMap[key];
+        }
+    }
+    return settings;
+}
+function isCamelCase(s) {
+    return !s.length || s.charAt(0) === s.charAt(0).toLowerCase();
+}
+export function displayPartsToString(displayParts) {
+    if (displayParts) {
+        return map(displayParts, displayPart => displayPart.text).join("");
+    }
+    return "";
+}
+// O que o host diz dos arquivos, numa foto: refeita a cada entrada pública do language service, porque não se sabe
+// quando o conjunto de arquivos do host muda.
+class HostCache {
+    constructor(host, getCanonicalFileName) {
+        this.host = host;
+        this.currentDirectory = host.getCurrentDirectory();
+        this.fileNameToEntry = createMap();
+        // A lista começa com os arquivos do programa.
+        const rootFileNames = host.getScriptFileNames();
+        for (const fileName of rootFileNames) {
+            this.createEntry(fileName, toPath(fileName, this.currentDirectory, getCanonicalFileName));
+        }
+    }
+    createEntry(fileName, path) {
+        let entry;
+        const scriptSnapshot = this.host.getScriptSnapshot(fileName);
+        if (scriptSnapshot) {
+            entry = {
+                hostFileName: fileName,
+                version: this.host.getScriptVersion(fileName),
+                scriptSnapshot,
+                scriptKind: getScriptKind(fileName, this.host)
+            };
+        }
+        else {
+            entry = fileName;
+        }
+        this.fileNameToEntry.set(path, entry);
+        return entry;
+    }
+    getEntryByPath(path) {
+        return this.fileNameToEntry.get(path);
+    }
+    getHostFileInformation(path) {
+        const entry = this.fileNameToEntry.get(path);
+        return !isString(entry) ? entry : undefined;
+    }
+    getRootFileNames() {
+        const names = [];
+        this.fileNameToEntry.forEach(entry => {
+            if (isString(entry)) {
+                names.push(entry);
+            }
+            else {
+                names.push(entry.hostFileName);
+            }
+        });
+        return names;
+    }
+    getScriptSnapshot(path) {
+        const file = this.getHostFileInformation(path);
+        return (file && file.scriptSnapshot);
+    }
+}
+class SyntaxTreeCache {
+    constructor(host) {
+        this.host = host;
+    }
+    getCurrentSourceFile(fileName) {
+        const scriptSnapshot = this.host.getScriptSnapshot(fileName);
+        if (!scriptSnapshot) {
+            // O host não conhece o arquivo. Na tag, um `Error` comum; aqui, o `Debug.fail`, como a pergunta por um arquivo
+            // fora do programa (o `getValidSourceFile`).
+            return Debug.fail(`Could not find file: '${fileName}'.`);
+        }
+        const scriptKind = getScriptKind(fileName, this.host);
+        const version = this.host.getScriptVersion(fileName);
+        let sourceFile;
+        if (this.currentFileName !== fileName) {
+            // This is a new file, just parse it
+            sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, ScriptTarget.Latest, version, /*setNodeParents*/ true, scriptKind);
+        }
+        else if (this.currentFileVersion !== version) {
+            // This is the same file, just a newer version. Incrementally parse the file.
+            const editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot);
+            sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange);
+        }
+        if (sourceFile) {
+            // All done, ensure state is up to date
+            this.currentFileVersion = version;
+            this.currentFileName = fileName;
+            this.currentFileScriptSnapshot = scriptSnapshot;
+            this.currentSourceFile = sourceFile;
+        }
+        return this.currentSourceFile;
+    }
+}
+function setSourceFileFields(sourceFile, scriptSnapshot, version) {
+    sourceFile.version = version;
+    sourceFile.scriptSnapshot = scriptSnapshot;
+}
+export function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTarget, version, setNodeParents, scriptKind) {
+    const sourceFile = createSourceFile(fileName, getSnapshotText(scriptSnapshot), scriptTarget, setNodeParents, scriptKind);
+    setSourceFileFields(sourceFile, scriptSnapshot, version);
+    return sourceFile;
+}
+export function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version, textChangeRange, aggressiveChecks) {
+    // Com o trecho que mudou, e a versão mudada, o arquivo se reparseia só onde mudou.
+    if (textChangeRange) {
+        if (version !== sourceFile.version) {
+            let newText;
+            // o texto do começo do original até o começo do trecho
+            const prefix = textChangeRange.span.start !== 0
+                ? sourceFile.text.substr(0, textChangeRange.span.start)
+                : "";
+            // o texto do fim do trecho até o fim do original
+            const suffix = textSpanEnd(textChangeRange.span) !== sourceFile.text.length
+                ? sourceFile.text.substr(textSpanEnd(textChangeRange.span))
+                : "";
+            if (textChangeRange.newLength === 0) {
+                // a edição apagou: junta o antes e o depois
+                newText = prefix && suffix ? prefix + suffix : prefix || suffix;
+            }
+            else {
+                // a edição escreveu: o texto novo do trecho, entre o antes e o depois
+                const changedText = scriptSnapshot.getText(textChangeRange.span.start, textChangeRange.span.start + textChangeRange.newLength);
+                newText = prefix && suffix
+                    ? prefix + changedText + suffix
+                    : prefix
+                        ? (prefix + changedText)
+                        : (changedText + suffix);
+            }
+            const newSourceFile = updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
+            setSourceFileFields(newSourceFile, scriptSnapshot, version);
+            // Depois do parse incremental, a tabela de nomes pode estar velha: sai, e se refaz quando pedida.
+            newSourceFile.nameTable = undefined;
+            // os recursos do snapshot velho se liberam
+            if (sourceFile !== newSourceFile && sourceFile.scriptSnapshot) {
+                if (sourceFile.scriptSnapshot.dispose) {
+                    sourceFile.scriptSnapshot.dispose();
+                }
+                sourceFile.scriptSnapshot = undefined;
+            }
+            return newSourceFile;
+        }
+    }
+    // Sem o trecho, o arquivo se parseia de novo, inteiro.
+    return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, /*setNodeParents*/ true, sourceFile.scriptKind);
+}
+class CancellationTokenObject {
+    constructor(cancellationToken) {
+        this.cancellationToken = cancellationToken;
+    }
+    isCancellationRequested() {
+        return !!this.cancellationToken && this.cancellationToken.isCancellationRequested();
+    }
+    throwIfCancellationRequested() {
+        if (this.isCancellationRequested()) {
+            throw new OperationCanceledException();
+        }
+    }
+}
+/** O cancelamento que pergunta ao host no máximo a cada `throttleWaitMilliseconds`: perguntar custa. */
+export class ThrottledCancellationToken {
+    constructor(hostCancellationToken, throttleWaitMilliseconds = 20) {
+        this.hostCancellationToken = hostCancellationToken;
+        this.throttleWaitMilliseconds = throttleWaitMilliseconds;
+        // Quando se perguntou ao host da última vez.
+        this.lastCancellationCheckTime = 0;
+    }
+    isCancellationRequested() {
+        const time = timestamp();
+        const duration = Math.abs(time - this.lastCancellationCheckTime);
+        if (duration >= this.throttleWaitMilliseconds) {
+            this.lastCancellationCheckTime = time;
+            return this.hostCancellationToken.isCancellationRequested();
+        }
+        return false;
+    }
+    throwIfCancellationRequested() {
+        if (this.isCancellationRequested()) {
+            throw new OperationCanceledException();
+        }
+    }
+}
+/**
+ * O programa está em dia com o host: os mesmos arquivos, na mesma ordem, cada um na versão que o host diz. Do
+ * `isProgramUptoDate` do `program.ts` da tag, sem o que é do host do `tsc`: as diretivas de tipo automáticas, as
+ * referências de projeto, os arquivos que faltavam e passaram a existir, as opções (a configuração é fixa) e a
+ * resolução invalidada (quem resolve é o host, e a resolução se pergunta a cada programa).
+ */
+function isProgramUptoDate(program, rootFileNames, getSourceVersion) {
+    // Sem programa, não está em dia.
+    if (!program) {
+        return false;
+    }
+    // Os arquivos do programa são os do host, na ordem dele.
+    if (!arrayIsEqualTo(program.getSourceFiles().map(f => f.fileName), rootFileNames)) {
+        return false;
+    }
+    // Um arquivo fora de dia tira o programa inteiro de dia.
+    if (program.getSourceFiles().some(sourceFileNotUptoDate)) {
+        return false;
+    }
+    return true;
+    function sourceFileNotUptoDate(sourceFile) {
+        return sourceFile.version !== getSourceVersion(sourceFile.resolvedPath, sourceFile.fileName);
+    }
+}
+let editingServices;
+/** Registra a edição na casca. O `@tslite/services/edit` o chama ao carregar; o registro vale para o processo. */
+export function registerEditingServices(services) {
+    editingServices = services;
+}
+/** A edição registrada. Sem ela, o método de edição falha, como o método semântico no modo `syntaxOnly` da tag. */
+function getEditingServices() {
+    return editingServices || Debug.fail("The editing services are not loaded: import '@tslite/services/edit'.");
+}
+export function createLanguageService(host, documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()), syntaxOnly = false) {
+    const syntaxTreeCache = new SyntaxTreeCache(host);
+    let program;
+    let lastProjectVersion;
+    const cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken());
+    const currentDirectory = host.getCurrentDirectory();
+    // As mensagens traduzidas, quando o host as tem.
+    if (!localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) {
+        setLocalizedDiagnosticMessages(host.getLocalizedDiagnosticMessages());
+    }
+    function log(message) {
+        if (host.log) {
+            host.log(message);
+        }
+    }
+    const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
+    const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
+    function getValidSourceFile(fileName) {
+        const sourceFile = program.getSourceFile(fileName);
+        if (!sourceFile) {
+            return Debug.fail(`Could not find source file: '${fileName}'.`);
+        }
+        return sourceFile;
+    }
+    /**
+     * A foto do host num programa. Da tag, com o `check` da cópia no lugar do `createProgram` sobre um `CompilerHost`
+     * (CK-47): os arquivos do programa são os que o host lista e tem, na ordem dele, as árvores vêm do registro de
+     * documentos, como na tag, e o host resolve os imports (CK-46). O arquivo que o host lista e não tem fica fora do
+     * programa; na tag, ele era um diagnóstico do programa, que é do host.
+     */
+    function synchronizeHostData() {
+        Debug.assert(!syntaxOnly);
+        // a conferência rápida, quando o host dá a versão do projeto
+        if (host.getProjectVersion) {
+            const hostProjectVersion = host.getProjectVersion();
+            if (hostProjectVersion) {
+                if (lastProjectVersion === hostProjectVersion) {
+                    return;
+                }
+                lastProjectVersion = hostProjectVersion;
+            }
+        }
+        // uma foto nova do host
+        let hostCache = new HostCache(host, getCanonicalFileName);
+        const rootFileNames = hostCache.getRootFileNames().filter(fileName => hostCache.getHostFileInformation(toPath(fileName, currentDirectory, getCanonicalFileName)));
+        // o programa em dia se reaproveita
+        if (isProgramUptoDate(program, rootFileNames, (_path, fileName) => host.getScriptVersion(fileName))) {
+            return;
+        }
+        // Daqui em diante, nenhum token de cancelamento se consulta: as árvores do programa anterior mudam, e um
+        // cancelamento no meio deixaria o programa apontando para árvores invalidadas pelo parse incremental.
+        const oldProgram = program;
+        const files = mapDefined(rootFileNames, fileName => getOrCreateSourceFile(fileName));
+        program = check(files, {
+            getCurrentDirectory: () => currentDirectory,
+            useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
+            resolveModule: (moduleName, containingFile) => host.resolveModule(moduleName, containingFile),
+        });
+        // A árvore do programa anterior que o novo não tem se libera no registro, como o `createProgram` da tag
+        // fazia pelo `onReleaseOldSourceFile` do host.
+        if (oldProgram) {
+            for (const oldSourceFile of oldProgram.getSourceFiles()) {
+                if (!program.getSourceFile(oldSourceFile.resolvedPath)) {
+                    documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath);
+                }
+            }
+        }
+        // A foto do host não se usa depois daqui: os snapshots que ela segura se liberam.
+        hostCache = undefined;
+        // Todos os nós do programa ligados, e com o pai.
+        program.getTypeChecker();
+        return;
+        function getOrCreateSourceFile(fileName) {
+            return getOrCreateSourceFileByPath(fileName, toPath(fileName, currentDirectory, getCanonicalFileName));
+        }
+        function getOrCreateSourceFileByPath(fileName, path) {
+            Debug.assert(hostCache !== undefined, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host.");
+            // O arquivo que o host não tem não existe para o programa.
+            const hostFileInformation = hostCache && hostCache.getHostFileInformation(path);
+            if (!hostFileInformation) {
+                return undefined;
+            }
+            // O arquivo que o programa anterior já tinha se atualiza pelo registro, que sabe a versão que vale: outra
+            // instância do language service pode ter atualizado a árvore compartilhada, e a versão que esta segurava
+            // ficou inválida.
+            const oldSourceFile = oldProgram && oldProgram.getSourceFile(path);
+            if (oldSourceFile) {
+                // O tipo de um arquivo registrado não muda de um programa para o outro.
+                Debug.assertEqual(hostFileInformation.scriptKind, oldSourceFile.scriptKind, "Registered script kind should match new script kind.");
+                return documentRegistry.updateDocumentWithKey(fileName, path, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+            }
+            // O arquivo novo para este programa vem do registro, que o cria se ninguém o tem.
+            return documentRegistry.acquireDocumentWithKey(fileName, path, hostFileInformation.scriptSnapshot, hostFileInformation.version, hostFileInformation.scriptKind);
+        }
+    }
+    function getProgram() {
+        if (syntaxOnly) {
+            Debug.assert(program === undefined);
+            return undefined;
+        }
+        synchronizeHostData();
+        return program;
+    }
+    function cleanupSemanticCache() {
+        program = undefined;
+    }
+    function dispose() {
+        if (program) {
+            forEach(program.getSourceFiles(), f => documentRegistry.releaseDocumentWithKey(f.resolvedPath));
+            program = undefined;
+        }
+        host = undefined;
+    }
+    /// Diagnostics
+    function getSyntacticDiagnostics(fileName) {
+        synchronizeHostData();
+        return program.getSyntacticDiagnostics(getValidSourceFile(fileName)).slice();
+    }
+    /**
+     * Os erros de tipo do arquivo. Na tag, com a emissão de declarações ligada, vinham junto os erros dela; a
+     * configuração é fixa, sem emissão.
+     */
+    function getSemanticDiagnostics(fileName) {
+        synchronizeHostData();
+        const targetSourceFile = getValidSourceFile(fileName);
+        // Só o arquivo pedido: o host pede arquivo a arquivo.
+        return program.getSemanticDiagnostics(targetSourceFile, cancellationToken).slice();
+    }
+    function getSuggestionDiagnostics(fileName) {
+        synchronizeHostData();
+        return computeSuggestionDiagnostics(getValidSourceFile(fileName), program, cancellationToken);
+    }
+    function getCompletionsAtPosition(fileName, position, options = emptyOptions) {
+        // os nomes antigos das preferências, nos novos
+        const fullPreferences = {
+            ...identity(options), // sem a conferência de propriedade a mais
+            includeCompletionsForModuleExports: options.includeCompletionsForModuleExports || options.includeExternalModuleExports,
+            includeCompletionsWithInsertText: options.includeCompletionsWithInsertText || options.includeInsertTextCompletions,
+        };
+        synchronizeHostData();
+        return Completions.getCompletionsAtPosition(host, program, log, getValidSourceFile(fileName), position, fullPreferences, options.triggerCharacter);
+    }
+    /**
+     * O detalhe de um item. Na tag, as opções de formatação viravam aqui o contexto de formatação, que só a ação do
+     * auto-import usa; aqui, elas seguem cruas até o auto-import da edição (CK-67).
+     */
+    function getCompletionEntryDetails(fileName, position, name, formattingOptions, source, preferences = emptyOptions) {
+        synchronizeHostData();
+        return Completions.getCompletionEntryDetails(program, log, getValidSourceFile(fileName), position, { name, source }, host, formattingOptions, preferences, cancellationToken);
+    }
+    function getCompletionEntrySymbol(fileName, position, name, source, preferences = emptyOptions) {
+        synchronizeHostData();
+        return Completions.getCompletionEntrySymbol(program, log, getValidSourceFile(fileName), position, { name, source }, host, preferences);
+    }
+    function getQuickInfoAtPosition(fileName, position) {
+        synchronizeHostData();
+        const sourceFile = getValidSourceFile(fileName);
+        const node = getTouchingPropertyName(sourceFile, position);
+        if (node === sourceFile) {
+            // Avoid giving quickInfo for the sourceFile as a whole.
+            return undefined;
+        }
+        const typeChecker = program.getTypeChecker();
+        const nodeForQuickInfo = getNodeForQuickInfo(node);
+        const symbol = getSymbolAtLocationForQuickInfo(nodeForQuickInfo, typeChecker);
+        if (!symbol || typeChecker.isUnknownSymbol(symbol)) {
+            const type = shouldGetType(sourceFile, nodeForQuickInfo, position) ? typeChecker.getTypeAtLocation(nodeForQuickInfo) : undefined;
+            return type && {
+                kind: "" /* ScriptElementKind.unknown */,
+                kindModifiers: "" /* ScriptElementKindModifier.none */,
+                textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
+                displayParts: typeChecker.runWithCancellationToken(cancellationToken, typeChecker => typeToDisplayParts(typeChecker, type, getContainerNode(nodeForQuickInfo))),
+                // Na tag, a documentação e as tags do JSDoc do símbolo do tipo. Sem o JSDoc (CK-03), as duas saem vazias,
+                // como as de um símbolo sem comentário na tag.
+                documentation: type.symbol ? [] : undefined,
+                tags: type.symbol ? [] : undefined
+            };
+        }
+        const { symbolKind, displayParts, documentation, tags } = typeChecker.runWithCancellationToken(cancellationToken, typeChecker => SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, getContainerNode(nodeForQuickInfo), nodeForQuickInfo));
+        return {
+            kind: symbolKind,
+            kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),
+            textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
+            displayParts,
+            documentation,
+            tags,
+        };
+    }
+    /** Na tag, o nome de um `new`, na posição do próprio `new`, dava o quick info da expressão chamada (CK-02). */
+    function getNodeForQuickInfo(node) {
+        return node;
+    }
+    /**
+     * Na tag, também o `this`, o tipo `this` e o `super` (CK-02); e, num identificador, o nome de um label e o de uma tag do
+     * JSDoc não davam o tipo (CK-02, CK-03).
+     */
+    function shouldGetType(sourceFile, node, position) {
+        switch (node.kind) {
+            case SyntaxKind.Identifier:
+                return true;
+            case SyntaxKind.PropertyAccessExpression:
+            case SyntaxKind.QualifiedName:
+                // Don't return quickInfo if inside the comment in `a/**/.b`
+                return !isInComment(sourceFile, position);
+            default:
+                return false;
+        }
+    }
+    /// Goto definition
+    function getDefinitionAtPosition(fileName, position) {
+        synchronizeHostData();
+        return GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position);
+    }
+    function getDefinitionAndBoundSpan(fileName, position) {
+        synchronizeHostData();
+        return GoToDefinition.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position);
+    }
+    function getTypeDefinitionAtPosition(fileName, position) {
+        synchronizeHostData();
+        return GoToDefinition.getTypeDefinitionAtPosition(program.getTypeChecker(), getValidSourceFile(fileName), position);
+    }
+    /// Goto implementation
+    function getImplementationAtPosition(fileName, position) {
+        synchronizeHostData();
+        return FindAllReferences.getImplementationsAtPosition(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
+    }
+    /// References and Occurrences
+    function getOccurrencesAtPosition(fileName, position) {
+        return flatMap(getDocumentHighlights(fileName, position, [fileName]), entry => entry.highlightSpans.map(highlightSpan => ({
+            fileName: entry.fileName,
+            textSpan: highlightSpan.textSpan,
+            isWriteAccess: highlightSpan.kind === "writtenReference" /* HighlightSpanKind.writtenReference */,
+            isDefinition: false,
+            ...highlightSpan.isInString && { isInString: true },
+            ...highlightSpan.contextSpan && { contextSpan: highlightSpan.contextSpan }
+        })));
+    }
+    function getDocumentHighlights(fileName, position, filesToSearch) {
+        const normalizedFileName = normalizePath(fileName);
+        Debug.assert(filesToSearch.some(f => normalizePath(f) === normalizedFileName));
+        synchronizeHostData();
+        const sourceFilesToSearch = mapDefined(filesToSearch, fileName => program.getSourceFile(fileName));
+        const sourceFile = getValidSourceFile(fileName);
+        return DocumentHighlights.getDocumentHighlights(program, cancellationToken, sourceFile, position, sourceFilesToSearch);
+    }
+    function findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename) {
+        synchronizeHostData();
+        const sourceFile = getValidSourceFile(fileName);
+        const node = getAdjustedRenameLocation(getTouchingPropertyName(sourceFile, position));
+        if (isIdentifier(node) && (isJsxOpeningElement(node.parent) || isJsxClosingElement(node.parent)) && isIntrinsicJsxName(node.escapedText)) {
+            const { openingElement, closingElement } = node.parent.parent;
+            return [openingElement, closingElement].map((node) => {
+                const textSpan = createTextSpanFromNode(node.tagName, sourceFile);
+                return {
+                    fileName: sourceFile.fileName,
+                    textSpan,
+                    ...FindAllReferences.toContextSpan(textSpan, sourceFile, node.parent)
+                };
+            });
+        }
+        else {
+            return getReferencesWorker(node, position, { findInStrings, findInComments, providePrefixAndSuffixTextForRename, use: 2 /* FindAllReferences.FindReferencesUse.Rename */ }, (entry, originalNode, checker) => FindAllReferences.toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixTextForRename || false));
+        }
+    }
+    function getReferencesAtPosition(fileName, position) {
+        synchronizeHostData();
+        return getReferencesWorker(getTouchingPropertyName(getValidSourceFile(fileName), position), position, { use: 1 /* FindAllReferences.FindReferencesUse.References */ }, FindAllReferences.toReferenceEntry);
+    }
+    function getReferencesWorker(node, position, options, cb) {
+        synchronizeHostData();
+        // Exclude default library when renaming as commonly user don't want to change that file.
+        const sourceFiles = options && options.use === 2 /* FindAllReferences.FindReferencesUse.Rename */
+            ? program.getSourceFiles().filter(sourceFile => !program.isSourceFileDefaultLibrary(sourceFile))
+            : program.getSourceFiles();
+        return FindAllReferences.findReferenceOrRenameEntries(program, cancellationToken, sourceFiles, node, position, options, cb);
+    }
+    function findReferences(fileName, position) {
+        synchronizeHostData();
+        return FindAllReferences.findReferencedSymbols(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
+    }
+    function getSignatureHelpItems(fileName, position, { triggerReason } = emptyOptions) {
+        synchronizeHostData();
+        const sourceFile = getValidSourceFile(fileName);
+        return SignatureHelp.getSignatureHelpItems(program, sourceFile, position, triggerReason, cancellationToken);
+    }
+    function getNavigationBarItems(fileName) {
+        return NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken);
+    }
+    function getNavigationTree(fileName) {
+        return NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken);
+    }
+    function isTsOrTsxFile(fileName) {
+        const kind = getScriptKind(fileName, host);
+        return kind === ScriptKind.TS || kind === ScriptKind.TSX;
+    }
+    function getSemanticClassifications(fileName, span) {
+        if (!isTsOrTsxFile(fileName)) {
+            // do not run semantic classification on non-ts-or-tsx files
+            return [];
+        }
+        synchronizeHostData();
+        return ts.getSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
+    }
+    function getEncodedSemanticClassifications(fileName, span) {
+        if (!isTsOrTsxFile(fileName)) {
+            // do not run semantic classification on non-ts-or-tsx files
+            return { spans: [], endOfLineState: 0 /* EndOfLineState.None */ };
+        }
+        synchronizeHostData();
+        return ts.getEncodedSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
+    }
+    function getSyntacticClassifications(fileName, span) {
+        // doesn't use compiler - no need to synchronize with host
+        return ts.getSyntacticClassifications(cancellationToken, syntaxTreeCache.getCurrentSourceFile(fileName), span);
+    }
+    function getEncodedSyntacticClassifications(fileName, span) {
+        // doesn't use compiler - no need to synchronize with host
+        return ts.getEncodedSyntacticClassifications(cancellationToken, syntaxTreeCache.getCurrentSourceFile(fileName), span);
+    }
+    function getOutliningSpans(fileName) {
+        // doesn't use compiler - no need to synchronize with host
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        return OutliningElementsCollector.collectElements(sourceFile, cancellationToken);
+    }
+    const braceMatching = createMapFromTemplate({
+        [SyntaxKind.OpenBraceToken]: SyntaxKind.CloseBraceToken,
+        [SyntaxKind.OpenParenToken]: SyntaxKind.CloseParenToken,
+        [SyntaxKind.OpenBracketToken]: SyntaxKind.CloseBracketToken,
+        [SyntaxKind.GreaterThanToken]: SyntaxKind.LessThanToken,
+    });
+    braceMatching.forEach((value, key) => braceMatching.set(value.toString(), Number(key)));
+    function getBraceMatchingAtPosition(fileName, position) {
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        const token = getTouchingToken(sourceFile, position);
+        const matchKind = token.getStart(sourceFile) === position ? braceMatching.get(token.kind.toString()) : undefined;
+        const match = matchKind && findChildOfKind(token.parent, matchKind, sourceFile);
+        // We want to order the braces when we return the result.
+        return match ? [createTextSpanFromNode(token, sourceFile), createTextSpanFromNode(match, sourceFile)].sort((a, b) => a.start - b.start) : emptyArray;
+    }
+    function getIndentationAtPosition(fileName, position, editorOptions) {
+        const { formatting } = getEditingServices();
+        let start = timestamp();
+        const settings = toEditorSettings(editorOptions);
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        log("getIndentationAtPosition: getCurrentSourceFile: " + (timestamp() - start));
+        start = timestamp();
+        const result = formatting.SmartIndenter.getIndentation(position, sourceFile, settings);
+        log("getIndentationAtPosition: computeIndentation  : " + (timestamp() - start));
+        return result;
+    }
+    function getFormattingEditsForRange(fileName, start, end, options) {
+        const { formatting } = getEditingServices();
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        return formatting.formatSelection(start, end, sourceFile, formatting.getFormatContext(toEditorSettings(options), host));
+    }
+    function getFormattingEditsForDocument(fileName, options) {
+        const { formatting } = getEditingServices();
+        return formatting.formatDocument(syntaxTreeCache.getCurrentSourceFile(fileName), formatting.getFormatContext(toEditorSettings(options), host));
+    }
+    function getFormattingEditsAfterKeystroke(fileName, position, key, options) {
+        const { formatting } = getEditingServices();
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        const formatContext = formatting.getFormatContext(toEditorSettings(options), host);
+        if (!isInComment(sourceFile, position)) {
+            switch (key) {
+                case "{":
+                    return formatting.formatOnOpeningCurly(position, sourceFile, formatContext);
+                case "}":
+                    return formatting.formatOnClosingCurly(position, sourceFile, formatContext);
+                case ";":
+                    return formatting.formatOnSemicolon(position, sourceFile, formatContext);
+                case "\n":
+                    return formatting.formatOnEnter(position, sourceFile, formatContext);
+            }
+        }
+        return [];
+    }
+    function getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences = emptyOptions) {
+        const { formatting, codefix } = getEditingServices();
+        synchronizeHostData();
+        const sourceFile = getValidSourceFile(fileName);
+        const span = createTextSpanFromBounds(start, end);
+        const formatContext = formatting.getFormatContext(formatOptions, host);
+        return flatMap(deduplicate(errorCodes, equateValues, compareValues), errorCode => {
+            cancellationToken.throwIfCancellationRequested();
+            return codefix.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences });
+        });
+    }
+    function getCombinedCodeFix(scope, fixId, formatOptions, preferences = emptyOptions) {
+        const { formatting, codefix } = getEditingServices();
+        synchronizeHostData();
+        Debug.assert(scope.type === "file");
+        const sourceFile = getValidSourceFile(scope.fileName);
+        const formatContext = formatting.getFormatContext(formatOptions, host);
+        return codefix.getAllFixes({ fixId, sourceFile, program, host, cancellationToken, formatContext, preferences });
+    }
+    // Na tag, também o `applyCodeActionCommand`, que pedia ao host a instalação de um pacote de tipos (CK-47).
+    function organizeImports(scope, formatOptions, preferences = emptyOptions) {
+        const { formatting, OrganizeImports } = getEditingServices();
+        synchronizeHostData();
+        Debug.assert(scope.type === "file");
+        const sourceFile = getValidSourceFile(scope.fileName);
+        const formatContext = formatting.getFormatContext(formatOptions, host);
+        return OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences);
+    }
+    // Na tag, também o mapa de fontes (o `sourceMapper`), que é do host (CK-47).
+    function getEditsForFileRename(oldFilePath, newFilePath, formatOptions, preferences = emptyOptions) {
+        const { formatting, getEditsForFileRename } = getEditingServices();
+        return getEditsForFileRename(getProgram(), oldFilePath, newFilePath, host, formatting.getFormatContext(formatOptions, host), preferences);
+    }
+    function isValidBraceCompletionAtPosition(fileName, position, openingBrace) {
+        // '<' is currently not supported, figuring out if we're in a Generic Type vs. a comparison is too
+        // expensive to do during typing scenarios
+        // i.e. whether we're dealing with:
+        //      var x = new foo<| ( with class foo<T>{} )
+        // or
+        //      var y = 3 <|
+        if (openingBrace === CharacterCodes.lessThan) {
+            return false;
+        }
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        // Check if in a context where we don't want to perform any insertion
+        if (isInString(sourceFile, position)) {
+            return false;
+        }
+        if (isInsideJsxElementOrAttribute(sourceFile, position)) {
+            return openingBrace === CharacterCodes.openBrace;
+        }
+        if (isInTemplateString(sourceFile, position)) {
+            return false;
+        }
+        switch (openingBrace) {
+            case CharacterCodes.singleQuote:
+            case CharacterCodes.doubleQuote:
+            case CharacterCodes.backtick:
+                return !isInComment(sourceFile, position);
+        }
+        return true;
+    }
+    function getJsxClosingTagAtPosition(fileName, position) {
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        const token = findPrecedingToken(position, sourceFile);
+        if (!token)
+            return undefined;
+        const element = token.kind === SyntaxKind.GreaterThanToken && isJsxOpeningElement(token.parent) ? token.parent.parent
+            : isJsxText(token) ? token.parent : undefined;
+        if (element && isUnclosedTag(element)) {
+            return { newText: `</${element.openingElement.tagName.getText(sourceFile)}>` };
+        }
+    }
+    function isUnclosedTag({ openingElement, closingElement, parent }) {
+        return !tagNamesAreEquivalent(openingElement.tagName, closingElement.tagName) ||
+            isJsxElement(parent) && tagNamesAreEquivalent(openingElement.tagName, parent.openingElement.tagName) && isUnclosedTag(parent);
+    }
+    function getSpanOfEnclosingComment(fileName, position, onlyMultiLine) {
+        const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+        const range = getRangeOfEnclosingComment(sourceFile, position);
+        return range && (!onlyMultiLine || range.kind === SyntaxKind.MultiLineCommentTrivia) ? createTextSpanFromRange(range) : undefined;
+    }
+    function getTodoComments(fileName, descriptors) {
+        // Note: while getting todo comments seems like a syntactic operation, we actually
+        // treat it as a semantic operation here.  This is because we expect our host to call
+        // this on every single file.  If we treat this syntactically, then that will cause
+        // us to populate and throw away the tree in our syntax tree cache for each file.  By
+        // treating this as a semantic operation, we can access any tree without throwing
+        // anything away.
+        synchronizeHostData();
+        const sourceFile = getValidSourceFile(fileName);
+        cancellationToken.throwIfCancellationRequested();
+        const fileContents = sourceFile.text;
+        const result = [];
+        // Na tag, o arquivo de dentro de um `node_modules` ficava de fora, como lib de terceiros; o `node_modules` é da
+        // resolução do host, e o nome de um arquivo é uma chave virtual (CK-46, CK-47).
+        if (descriptors.length > 0) {
+            const regExp = getTodoCommentsRegExp();
+            let matchArray;
+            while (matchArray = regExp.exec(fileContents)) {
+                cancellationToken.throwIfCancellationRequested();
+                // If we got a match, here is what the match array will look like.  Say the source text is:
+                //
+                //      "    // hack   1"
+                //
+                // The result array with the regexp:    will be:
+                //
+                //      ["// hack   1", "// ", "hack   1", undefined, "hack"]
+                //
+                // Here are the relevant capture groups:
+                //  0) The full match for the entire regexp.
+                //  1) The preamble to the message portion.
+                //  2) The message portion.
+                //  3...N) The descriptor that was matched - by index.  'undefined' for each
+                //         descriptor that didn't match.  an actual value if it did match.
+                //
+                //  i.e. 'undefined' in position 3 above means TODO(jason) didn't match.
+                //       "hack"      in position 4 means HACK did match.
+                const firstDescriptorCaptureIndex = 3;
+                Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex);
+                const preamble = matchArray[1];
+                const matchPosition = matchArray.index + preamble.length;
+                // OK, we have found a match in the file.  This is only an acceptable match if
+                // it is contained within a comment.
+                if (!isInComment(sourceFile, matchPosition)) {
+                    continue;
+                }
+                let descriptor;
+                for (let i = 0; i < descriptors.length; i++) {
+                    if (matchArray[i + firstDescriptorCaptureIndex]) {
+                        descriptor = descriptors[i];
+                    }
+                }
+                if (descriptor === undefined)
+                    return Debug.fail();
+                // We don't want to match something like 'TODOBY', so we make sure a non
+                // letter/digit follows the match.
+                if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) {
+                    continue;
+                }
+                const message = matchArray[2];
+                result.push({ descriptor, message, position: matchPosition });
+            }
+        }
+        return result;
+        function escapeRegExp(str) {
+            return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
+        }
+        function getTodoCommentsRegExp() {
+            // NOTE: `?:` means 'non-capture group'.  It allows us to have groups without having to
+            // filter them out later in the final result array.
+            // TODO comments can appear in one of the following forms:
+            //
+            //  1)      // TODO     or  /////////// TODO
+            //
+            //  2)      /* TODO     or  /********** TODO
+            //
+            //  3)      /*
+            //           *   TODO
+            //           */
+            //
+            // The following three regexps are used to match the start of the text up to the TODO
+            // comment portion.
+            const singleLineCommentStart = /(?:\/\/+\s*)/.source;
+            const multiLineCommentStart = /(?:\/\*+\s*)/.source;
+            const anyNumberOfSpacesAndAsterisksAtStartOfLine = /(?:^(?:\s|\*)*)/.source;
+            // Match any of the above three TODO comment start regexps.
+            // Note that the outermost group *is* a capture group.  We want to capture the preamble
+            // so that we can determine the starting position of the TODO comment match.
+            const preamble = "(" + anyNumberOfSpacesAndAsterisksAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")";
+            // Takes the descriptors and forms a regexp that matches them as if they were literals.
+            // For example, if the descriptors are "TODO(jason)" and "HACK", then this will be:
+            //
+            //      (?:(TODO\(jason\))|(HACK))
+            //
+            // Note that the outermost group is *not* a capture group, but the innermost groups
+            // *are* capture groups.  By capturing the inner literals we can determine after
+            // matching which descriptor we are dealing with.
+            const literals = "(?:" + map(descriptors, d => "(" + escapeRegExp(d.text) + ")").join("|") + ")";
+            // After matching a descriptor literal, the following regexp matches the rest of the
+            // text up to the end of the line (or */).
+            const endOfLineOrEndOfComment = /(?:$|\*\/)/.source;
+            const messageRemainder = /(?:.*?)/.source;
+            // This is the portion of the match we'll return as part of the TODO comment result. We
+            // match the literal portion up to the end of the line or end of comment.
+            const messagePortion = "(" + literals + messageRemainder + ")";
+            const regExpString = preamble + messagePortion + endOfLineOrEndOfComment;
+            // The final regexp will look like this:
+            // /((?:\/\/+\s*)|(?:\/\*+\s*)|(?:^(?:\s|\*)*))((?:(TODO\(jason\))|(HACK))(?:.*?))(?:$|\*\/)/gim
+            // The flags of the regexp are important here.
+            //  'g' is so that we are doing a global search and can find matches several times
+            //  in the input.
+            //
+            //  'i' is for case insensitivity (We do this to match C# TODO comment code).
+            //
+            //  'm' is so we can find matches in a multi-line input.
+            return new RegExp(regExpString, "gim");
+        }
+        function isLetterOrDigit(char) {
+            return (char >= CharacterCodes.a && char <= CharacterCodes.z) ||
+                (char >= CharacterCodes.A && char <= CharacterCodes.Z) ||
+                (char >= CharacterCodes._0 && char <= CharacterCodes._9);
+        }
+    }
+    function getRenameInfo(fileName, position, options) {
+        synchronizeHostData();
+        return Rename.getRenameInfo(program, getValidSourceFile(fileName), position, options);
+    }
+    function getRefactorContext(file, positionOrRange, preferences, formatOptions) {
+        const { formatting } = getEditingServices();
+        const [startPosition, endPosition] = typeof positionOrRange === "number" ? [positionOrRange, undefined] : [positionOrRange.pos, positionOrRange.end];
+        return {
+            file,
+            startPosition,
+            endPosition,
+            program: getProgram(),
+            host,
+            formatContext: formatting.getFormatContext(formatOptions, host),
+            cancellationToken,
+            preferences,
+        };
+    }
+    function getSmartSelectionRange(fileName, position) {
+        return SmartSelectionRange.getSmartSelectionRange(position, syntaxTreeCache.getCurrentSourceFile(fileName));
+    }
+    function getApplicableRefactors(fileName, positionOrRange, preferences = emptyOptions) {
+        const { refactor } = getEditingServices();
+        synchronizeHostData();
+        const file = getValidSourceFile(fileName);
+        return refactor.getApplicableRefactors(getRefactorContext(file, positionOrRange, preferences));
+    }
+    function getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences = emptyOptions) {
+        const { refactor } = getEditingServices();
+        synchronizeHostData();
+        const file = getValidSourceFile(fileName);
+        return refactor.getEditsForRefactor(getRefactorContext(file, positionOrRange, preferences, formatOptions), refactorName, actionName);
+    }
+    return {
+        dispose,
+        cleanupSemanticCache,
+        getSyntacticDiagnostics,
+        getSemanticDiagnostics,
+        getSuggestionDiagnostics,
+        getSyntacticClassifications,
+        getSemanticClassifications,
+        getEncodedSyntacticClassifications,
+        getEncodedSemanticClassifications,
+        getCompletionsAtPosition,
+        getCompletionEntryDetails,
+        getCompletionEntrySymbol,
+        getSignatureHelpItems,
+        getQuickInfoAtPosition,
+        getDefinitionAtPosition,
+        getDefinitionAndBoundSpan,
+        getImplementationAtPosition,
+        getTypeDefinitionAtPosition,
+        getReferencesAtPosition,
+        findReferences,
+        getOccurrencesAtPosition,
+        getDocumentHighlights,
+        getRenameInfo,
+        getSmartSelectionRange,
+        findRenameLocations,
+        getNavigationBarItems,
+        getNavigationTree,
+        getOutliningSpans,
+        getTodoComments,
+        getBraceMatchingAtPosition,
+        getIndentationAtPosition,
+        getFormattingEditsForRange,
+        getFormattingEditsForDocument,
+        getFormattingEditsAfterKeystroke,
+        isValidBraceCompletionAtPosition,
+        getJsxClosingTagAtPosition,
+        getSpanOfEnclosingComment,
+        getCodeFixesAtPosition,
+        getCombinedCodeFix,
+        organizeImports,
+        getEditsForFileRename,
+        getProgram,
+        getApplicableRefactors,
+        getEditsForRefactor,
+    };
+}
+/** Names in the name table are escaped, so an identifier `__foo` will have a name table entry `___foo`. */
+export function getNameTable(sourceFile) {
+    if (!sourceFile.nameTable) {
+        initializeNameTable(sourceFile);
+    }
+    return sourceFile.nameTable;
+}
+function initializeNameTable(sourceFile) {
+    const nameTable = sourceFile.nameTable = createUnderscoreEscapedMap();
+    sourceFile.forEachChild(function walk(node) {
+        if (isIdentifier(node) && node.escapedText || isStringOrNumericLiteralLike(node) && literalIsName(node)) {
+            const text = getEscapedTextOfIdentifierOrLiteral(node);
+            nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1);
+        }
+        // Na tag, também o nome `#private` (CK-02), e o identificador que é nome de uma tag do JSDoc ficava de fora, com
+        // os nomes dentro do JSDoc de cada nó (CK-03).
+        forEachChild(node, walk);
+    });
+}
+/**
+ * We want to store any numbers/strings if they were a name that could be
+ * related to a declaration.  So, if we have 'import x = require("something")'
+ * then we want 'something' to be in the name table.  Similarly, if we have
+ * "a['propname']" then we want to store "propname" in the name table.
+ */
+function literalIsName(node) {
+    // Na tag, também o `require("…")` de um `import =` (CK-03).
+    return isDeclarationName(node) ||
+        isArgumentOfElementAccessExpression(node) ||
+        isLiteralComputedPropertyDeclarationName(node);
+}
+/**
+ * Returns the containing object literal property declaration given a possible name node, e.g. "a" in x = { "a": 1 }
+ */
+export function getContainingObjectLiteralElement(node) {
+    const element = getContainingObjectLiteralElementWorker(node);
+    return element && (isObjectLiteralExpression(element.parent) || isJsxAttributes(element.parent)) ? element : undefined;
+}
+function getContainingObjectLiteralElementWorker(node) {
+    switch (node.kind) {
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+        case SyntaxKind.NumericLiteral:
+            if (node.parent.kind === SyntaxKind.ComputedPropertyName) {
+                return isObjectLiteralElement(node.parent.parent) ? node.parent.parent : undefined;
+            }
+        // falls through
+        case SyntaxKind.Identifier:
+            return isObjectLiteralElement(node.parent) &&
+                (node.parent.parent.kind === SyntaxKind.ObjectLiteralExpression || node.parent.parent.kind === SyntaxKind.JsxAttributes) &&
+                node.parent.name === node ? node.parent : undefined;
+    }
+    return undefined;
+}
+function getSymbolAtLocationForQuickInfo(node, checker) {
+    const object = getContainingObjectLiteralElement(node);
+    if (object) {
+        const contextualType = checker.getContextualType(object.parent);
+        const properties = contextualType && getPropertySymbolsFromContextualType(object, checker, contextualType, /*unionSymbolOk*/ false);
+        if (properties && properties.length === 1) {
+            return first(properties);
+        }
+    }
+    return checker.getSymbolAtLocation(node);
+}
+/** Gets all symbols for one property. Does not get symbols for every property. */
+export function getPropertySymbolsFromContextualType(node, checker, contextualType, unionSymbolOk) {
+    const name = getNameFromPropertyName(node.name);
+    if (!name)
+        return emptyArray;
+    if (!contextualType.isUnion()) {
+        const symbol = contextualType.getProperty(name);
+        return symbol ? [symbol] : emptyArray;
+    }
+    const discriminatedPropertySymbols = mapDefined(contextualType.types, t => isObjectLiteralExpression(node.parent) && checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent) ? undefined : t.getProperty(name));
+    if (unionSymbolOk && (discriminatedPropertySymbols.length === 0 || discriminatedPropertySymbols.length === contextualType.types.length)) {
+        const symbol = contextualType.getProperty(name);
+        if (symbol)
+            return [symbol];
+    }
+    if (discriminatedPropertySymbols.length === 0) {
+        // Bad discriminant -- do again without discriminating
+        return mapDefined(contextualType.types, t => t.getProperty(name));
+    }
+    return discriminatedPropertySymbols;
+}
+function isArgumentOfElementAccessExpression(node) {
+    return node &&
+        node.parent &&
+        node.parent.kind === SyntaxKind.ElementAccessExpression &&
+        node.parent.argumentExpression === node;
+}
+setObjectAllocator(getServicesObjectAllocator());
+setTypeObjectAllocator(getServicesTypeObjectAllocator());