@tslite/services 0.0.0-stage → 1.12.0

package/dist/utilities.js

@@ -0,0 +1,1981 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/utilities.ts: o namespace virou módulo ES, com os imports explícitos.
+// O arquivo entra com o que os serviços que já vieram usam; o resto dele vem com o grupo que o usa (o docs/ARCHITECTURE.md
+// do pacote). No fim, o que a leitura usa da edição e desceu para ela pela dependência (CK-67): o nome de um módulo como
+// identificador, do `codefixes/importFixes.ts` da tag, e o comentário que cerca uma posição, do `formatting/formatting.ts`.
+import { CharacterCodes, Debug, EmitFlags, InternalSymbolName, ModifierFlags, ModuleInstanceState, NodeFlags, ScriptTarget, SymbolAccessibility, SymbolDisplayPartKind, SymbolFlags, SymbolFormatFlags, SyntaxKind, TypeFormatFlags, addEmitFlags, addSyntheticLeadingComment, addSyntheticTrailingComment, cast, concatenate, contains, createBindingElement, createIdentifier, createImportClause, createImportDeclaration, createLiteral, createNamedImports, createRange, createScanner, createTextSpan, createTextSpanFromBounds, defaultMaximumTruncationLength, ensureScriptKind, find, findAncestor, findLast, firstDefined, forEachChild, forEachLeadingCommentRange, forEachTrailingCommentRange, getBaseFileName, getCombinedModifierFlags, getIndentString, getLeadingCommentRangesOfNode, getLastChild, getLineStarts, getModuleInstanceState, getNameOfDeclaration, getNodeId, getRootDeclaration, getSynthesizedClone, getSymbolId, getTextOfIdentifierOrLiteral, getTrailingCommentRanges, indexOfNode, isAmbientModule, isAnyImportSyntax, isArray, isArrayTypeNode, isAsExpression, isAwaitExpression, isBinaryExpression, isBindingElement, isCallExpression, isConditionalTypeNode, isDeclaration, isDeclarationName, isDeleteExpression, isElementAccessExpression, isExportAssignment, isExportDeclaration, isExportSpecifier, isExternalModule, isForInStatement, isForOfStatement, isFileLevelUniqueName, isFunctionLike, isIdentifier, isIdentifierPart, isIdentifierStart, isImportClause, isImportDeclaration, isImportOrExportSpecifier, isImportSpecifier, isInferTypeNode, isJsxElement, isJsxExpression, isJsxOpeningLikeElement, isJsxText, isKeyword, isLet, isLiteralTypeNode, isMappedTypeNode, isModifier, isModuleBlock, isModuleDeclaration, isNamedDeclaration, isNamedExports, isNamedImports, isNamespaceExport, isNamespaceImport, isNumericLiteral, isObjectLiteralExpression, isObjectBindingPattern, isOptionalChain, isOptionalChainRoot, isPartOfTypeNode, isPropertyAccessExpression, isPropertyNameLiteral, isRightSideOfQualifiedNameOrPropertyAccess, isSourceFile, isStringANonContextualKeyword, isStringDoubleQuoted, isStringLiteral, isStringOrNumericLiteralLike, isStringTextContainingNode, isSyntaxList, isTemplateLiteralKind, isToken, isTypeAliasDeclaration, isTypeNode, isTypeOfExpression, isTypeOperatorNode, isTypeParameterDeclaration, isTypeReferenceNode, isVarConst, isVariableDeclarationList, isWhiteSpaceLike, isWhiteSpaceSingleLine, last, lastOrUndefined, maybeBind, nodeIsMissing, nodeIsPresent, noop, notImplemented, nullTransformationContext, or, removeFileExtension, removeSuffix, setOriginalNode, setTextRange, singleOrUndefined, skipAlias, skipOuterExpressions, startsWith, stringToToken, stripQuotes, textSpanContainsPosition, textSpanEnd, tokenToString, tryCast, unescapeLeadingUnderscores, visitEachChild, } from "./_namespaces/ts.js";
+// Os utilitários que mais de um serviço usa.
+export const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);
+export var SemanticMeaning;
+(function (SemanticMeaning) {
+    SemanticMeaning[SemanticMeaning["None"] = 0] = "None";
+    SemanticMeaning[SemanticMeaning["Value"] = 1] = "Value";
+    SemanticMeaning[SemanticMeaning["Type"] = 2] = "Type";
+    SemanticMeaning[SemanticMeaning["Namespace"] = 4] = "Namespace";
+    SemanticMeaning[SemanticMeaning["All"] = 7] = "All";
+})(SemanticMeaning || (SemanticMeaning = {}));
+export function getMeaningFromDeclaration(node) {
+    switch (node.kind) {
+        case SyntaxKind.VariableDeclaration:
+            // Na tag, a variável de um arquivo JavaScript com a tag `@enum` do JSDoc era de todo significado (CK-03).
+            return 1 /* SemanticMeaning.Value */;
+        case SyntaxKind.Parameter:
+        case SyntaxKind.BindingElement:
+        case SyntaxKind.PropertySignature:
+        case SyntaxKind.PropertyAssignment:
+        case SyntaxKind.ShorthandPropertyAssignment:
+        case SyntaxKind.ArrowFunction:
+        case SyntaxKind.CatchClause:
+        case SyntaxKind.JsxAttribute:
+            return 1 /* SemanticMeaning.Value */;
+        case SyntaxKind.TypeParameter:
+        case SyntaxKind.TypeAliasDeclaration:
+        case SyntaxKind.TypeLiteral:
+            return 2 /* SemanticMeaning.Type */;
+        case SyntaxKind.ModuleDeclaration:
+            if (isAmbientModule(node)) {
+                return 4 /* SemanticMeaning.Namespace */ | 1 /* SemanticMeaning.Value */;
+            }
+            else if (getModuleInstanceState(node) === ModuleInstanceState.Instantiated) {
+                return 4 /* SemanticMeaning.Namespace */ | 1 /* SemanticMeaning.Value */;
+            }
+            else {
+                return 4 /* SemanticMeaning.Namespace */;
+            }
+        case SyntaxKind.NamedImports:
+        case SyntaxKind.ImportSpecifier:
+        case SyntaxKind.ImportDeclaration:
+        case SyntaxKind.ExportAssignment:
+        case SyntaxKind.ExportDeclaration:
+            return 7 /* SemanticMeaning.All */;
+        // An external module can be a Value
+        case SyntaxKind.SourceFile:
+            return 4 /* SemanticMeaning.Namespace */ | 1 /* SemanticMeaning.Value */;
+    }
+    return 7 /* SemanticMeaning.All */;
+}
+export function getMeaningFromLocation(node) {
+    node = getAdjustedReferenceLocation(node);
+    if (node.kind === SyntaxKind.SourceFile) {
+        return 1 /* SemanticMeaning.Value */;
+    }
+    else if (node.parent.kind === SyntaxKind.ExportAssignment
+        || node.parent.kind === SyntaxKind.ImportSpecifier
+        || node.parent.kind === SyntaxKind.ImportClause) {
+        return 7 /* SemanticMeaning.All */;
+    }
+    else if (isDeclarationName(node)) {
+        return getMeaningFromDeclaration(node.parent);
+    }
+    else if (isTypeReference(node)) {
+        return 2 /* SemanticMeaning.Type */;
+    }
+    else if (isNamespaceReference(node)) {
+        return 4 /* SemanticMeaning.Namespace */;
+    }
+    else if (isLiteralTypeNode(node.parent)) {
+        // This might be T["name"], which is actually referencing a property and not a type. So allow both meanings.
+        return 2 /* SemanticMeaning.Type */ | 1 /* SemanticMeaning.Value */;
+    }
+    else {
+        return 1 /* SemanticMeaning.Value */;
+    }
+}
+/**
+ * Se o nome é a parte de fora de um nome qualificado num tipo (`A` em `A.B`). Na tag, também o de um acesso a propriedade
+ * no `implements` de uma classe ou no `extends` de uma interface (o `isPropertyAccessNamespaceReference`), que a Linguagem
+ * não tem (CK-02).
+ */
+function isNamespaceReference(node) {
+    return isQualifiedNameNamespaceReference(node);
+}
+function isQualifiedNameNamespaceReference(node) {
+    let root = node;
+    let isLastClause = true;
+    if (root.parent.kind === SyntaxKind.QualifiedName) {
+        while (root.parent && root.parent.kind === SyntaxKind.QualifiedName) {
+            root = root.parent;
+        }
+        isLastClause = root.right === node;
+    }
+    return root.parent.kind === SyntaxKind.TypeReference && !isLastClause;
+}
+function isTypeReference(node) {
+    if (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
+        node = node.parent;
+    }
+    // Na tag, o `this` e o tipo `this` vinham antes (CK-02).
+    switch (node.parent.kind) {
+        case SyntaxKind.TypeReference:
+            return true;
+        case SyntaxKind.ImportType:
+            return !node.parent.isTypeOf;
+    }
+    return false;
+}
+export function isCallExpressionTarget(node, includeElementAccess = false, skipPastOuterExpressions = false) {
+    return isCalleeWorker(node, isCallExpression, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions);
+}
+function selectExpressionOfCallOrNewExpressionOrDecorator(node) {
+    return node.expression;
+}
+function isCalleeWorker(node, pred, calleeSelector, includeElementAccess, skipPastOuterExpressions) {
+    let target = includeElementAccess ? climbPastPropertyOrElementAccess(node) : climbPastPropertyAccess(node);
+    if (skipPastOuterExpressions) {
+        target = skipOuterExpressions(target);
+    }
+    return !!target && !!target.parent && pred(target.parent) && calleeSelector(target.parent) === target;
+}
+export function climbPastPropertyAccess(node) {
+    return isRightSideOfPropertyAccess(node) ? node.parent : node;
+}
+export function climbPastPropertyOrElementAccess(node) {
+    return isRightSideOfPropertyAccess(node) || isArgumentExpressionOfElementAccess(node) ? node.parent : node;
+}
+export function hasPropertyAccessExpressionWithName(node, funcName) {
+    if (!isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    return node.expression.name.text === funcName;
+}
+export function isRightSideOfPropertyAccess(node) {
+    return tryCast(node.parent, isPropertyAccessExpression)?.name === node;
+}
+export function isArgumentExpressionOfElementAccess(node) {
+    return tryCast(node.parent, isElementAccessExpression)?.argumentExpression === node;
+}
+/**
+ * Se o literal é o nome de uma declaração ou a chave de um acesso. Na tag, também o de uma propriedade de classe, de um
+ * membro de enum, de um método e de um acessor (CK-02), o de uma method signature (CK-36), e o de um `declare module "x"`
+ * (CK-02).
+ */
+export function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) {
+    switch (node.parent.kind) {
+        case SyntaxKind.PropertySignature:
+        case SyntaxKind.PropertyAssignment:
+            return getNameOfDeclaration(node.parent) === node;
+        case SyntaxKind.ElementAccessExpression:
+            return node.parent.argumentExpression === node;
+        case SyntaxKind.ComputedPropertyName:
+            return true;
+        case SyntaxKind.LiteralType:
+            return node.parent.parent.kind === SyntaxKind.IndexedAccessType;
+        default:
+            return false;
+    }
+}
+/**
+ * A declaração que contém o nó: o arquivo ou o namespace. Na tag, também o método, a `function`, o acessor, a classe, a
+ * interface e o enum (CK-02), a method signature (CK-36), e o escopo do typedef do JSDoc (CK-03).
+ */
+export function getContainerNode(node) {
+    while (true) {
+        node = node.parent;
+        if (!node) {
+            return undefined;
+        }
+        switch (node.kind) {
+            case SyntaxKind.SourceFile:
+            case SyntaxKind.ModuleDeclaration:
+                return node;
+        }
+    }
+}
+/**
+ * O tipo de elemento que o nó declara. Na tag, também a classe, a interface, o enum e o membro dele, a `function`, o
+ * acessor, o método, a construct signature, o construtor e a parameter property (CK-02), a method signature (CK-36), o
+ * typedef do JSDoc e o `import =` (CK-03), e a atribuição que declara: as do JavaScript (CK-03) e o expando (CK-38), que o
+ * binder da cópia não liga como declaração.
+ */
+export function getNodeKind(node) {
+    switch (node.kind) {
+        case SyntaxKind.SourceFile:
+            return isExternalModule(node) ? "module" /* ScriptElementKind.moduleElement */ : "script" /* ScriptElementKind.scriptElement */;
+        case SyntaxKind.ModuleDeclaration:
+            return "module" /* ScriptElementKind.moduleElement */;
+        case SyntaxKind.TypeAliasDeclaration:
+            return "type" /* ScriptElementKind.typeElement */;
+        case SyntaxKind.VariableDeclaration:
+            return getKindOfVariableDeclaration(node);
+        case SyntaxKind.BindingElement:
+            return getKindOfVariableDeclaration(getRootDeclaration(node));
+        case SyntaxKind.ArrowFunction:
+            return "function" /* ScriptElementKind.functionElement */;
+        case SyntaxKind.PropertyAssignment:
+            const { initializer } = node;
+            return isFunctionLike(initializer) ? "method" /* ScriptElementKind.memberFunctionElement */ : "property" /* ScriptElementKind.memberVariableElement */;
+        case SyntaxKind.PropertySignature:
+        case SyntaxKind.ShorthandPropertyAssignment:
+        case SyntaxKind.SpreadAssignment:
+            return "property" /* ScriptElementKind.memberVariableElement */;
+        case SyntaxKind.IndexSignature: return "index" /* ScriptElementKind.indexSignatureElement */;
+        case SyntaxKind.CallSignature: return "call" /* ScriptElementKind.callSignatureElement */;
+        case SyntaxKind.TypeParameter: return "type parameter" /* ScriptElementKind.typeParameterElement */;
+        case SyntaxKind.Parameter: return "parameter" /* ScriptElementKind.parameterElement */;
+        case SyntaxKind.ImportSpecifier:
+        case SyntaxKind.ExportSpecifier:
+        case SyntaxKind.NamespaceImport:
+        case SyntaxKind.NamespaceExport:
+            return "alias" /* ScriptElementKind.alias */;
+        case SyntaxKind.Identifier:
+            return isImportClause(node.parent) ? "alias" /* ScriptElementKind.alias */ : "" /* ScriptElementKind.unknown */;
+        case SyntaxKind.ExportAssignment:
+            const scriptKind = getNodeKind(node.expression);
+            // If the expression didn't come back with something (like it does for an identifiers)
+            return scriptKind === "" /* ScriptElementKind.unknown */ ? "const" /* ScriptElementKind.constElement */ : scriptKind;
+        default:
+            return "" /* ScriptElementKind.unknown */;
+    }
+    function getKindOfVariableDeclaration(v) {
+        return isVarConst(v)
+            ? "const" /* ScriptElementKind.constElement */
+            : isLet(v)
+                ? "let" /* ScriptElementKind.letElement */
+                : "var" /* ScriptElementKind.variableElement */;
+    }
+}
+// Matches the beginning of a triple slash directive
+const tripleSlashDirectivePrefixRegex = /^\/\/\/\s*</;
+export function getLineStartPositionForPosition(position, sourceFile) {
+    const lineStarts = getLineStarts(sourceFile);
+    const line = sourceFile.getLineAndCharacterOfPosition(position).line;
+    return lineStarts[line];
+}
+export function rangeContainsRange(r1, r2) {
+    return startEndContainsRange(r1.pos, r1.end, r2);
+}
+export function rangeContainsRangeExclusive(r1, r2) {
+    return rangeContainsPositionExclusive(r1, r2.pos) && rangeContainsPositionExclusive(r1, r2.end);
+}
+export function rangeContainsPositionExclusive(r, pos) {
+    return r.pos < pos && pos < r.end;
+}
+export function startEndContainsRange(start, end, range) {
+    return start <= range.pos && end >= range.end;
+}
+export function rangeContainsStartEnd(range, start, end) {
+    return range.pos <= start && range.end >= end;
+}
+export function rangeOverlapsWithStartEnd(r1, start, end) {
+    return startEndOverlapsWithStartEnd(r1.pos, r1.end, start, end);
+}
+export function startEndOverlapsWithStartEnd(start1, end1, start2, end2) {
+    const start = Math.max(start1, start2);
+    const end = Math.min(end1, end2);
+    return start < end;
+}
+/**
+ * Assumes `candidate.start <= position` holds.
+ */
+export function positionBelongsToNode(candidate, position, sourceFile) {
+    Debug.assert(candidate.pos <= position);
+    return position < candidate.end || !isCompletedNode(candidate, sourceFile);
+}
+/**
+ * Se o nó já está fechado no texto, para que a posição logo depois dele não pertença mais a ele. Na tag, também os nós
+ * que a parse tree não tem: a classe, a interface, o enum, o `new`, o construtor e o tipo construtor, o acessor, a
+ * `function`, o método, a construct signature, o `yield` e o template marcado (CK-02), a method signature (CK-36) e o
+ * operador `void` (CK-63).
+ */
+function isCompletedNode(n, sourceFile) {
+    if (n === undefined || nodeIsMissing(n)) {
+        return false;
+    }
+    switch (n.kind) {
+        case SyntaxKind.ObjectLiteralExpression:
+        case SyntaxKind.ObjectBindingPattern:
+        case SyntaxKind.TypeLiteral:
+        case SyntaxKind.Block:
+        case SyntaxKind.ModuleBlock:
+        case SyntaxKind.CaseBlock:
+        case SyntaxKind.NamedImports:
+        case SyntaxKind.NamedExports:
+            return nodeEndsWith(n, SyntaxKind.CloseBraceToken, sourceFile);
+        case SyntaxKind.CatchClause:
+            return isCompletedNode(n.block, sourceFile);
+        case SyntaxKind.CallExpression:
+        case SyntaxKind.ParenthesizedExpression:
+        case SyntaxKind.ParenthesizedType:
+            return nodeEndsWith(n, SyntaxKind.CloseParenToken, sourceFile);
+        case SyntaxKind.FunctionType:
+            return isCompletedNode(n.type, sourceFile);
+        case SyntaxKind.CallSignature:
+        case SyntaxKind.ArrowFunction:
+            if (n.body) {
+                return isCompletedNode(n.body, sourceFile);
+            }
+            if (n.type) {
+                return isCompletedNode(n.type, sourceFile);
+            }
+            // Even though type parameters can be unclosed, we can get away with
+            // having at least a closing paren.
+            return hasChildOfKind(n, SyntaxKind.CloseParenToken, sourceFile);
+        case SyntaxKind.ModuleDeclaration:
+            return !!n.body && isCompletedNode(n.body, sourceFile);
+        case SyntaxKind.IfStatement:
+            if (n.elseStatement) {
+                return isCompletedNode(n.elseStatement, sourceFile);
+            }
+            return isCompletedNode(n.thenStatement, sourceFile);
+        case SyntaxKind.ExpressionStatement:
+            return isCompletedNode(n.expression, sourceFile) ||
+                hasChildOfKind(n, SyntaxKind.SemicolonToken, sourceFile);
+        case SyntaxKind.ArrayLiteralExpression:
+        case SyntaxKind.ArrayBindingPattern:
+        case SyntaxKind.ElementAccessExpression:
+        case SyntaxKind.ComputedPropertyName:
+        case SyntaxKind.TupleType:
+            return nodeEndsWith(n, SyntaxKind.CloseBracketToken, sourceFile);
+        case SyntaxKind.IndexSignature:
+            if (n.type) {
+                return isCompletedNode(n.type, sourceFile);
+            }
+            return hasChildOfKind(n, SyntaxKind.CloseBracketToken, sourceFile);
+        case SyntaxKind.CaseClause:
+        case SyntaxKind.DefaultClause:
+            // there is no such thing as terminator token for CaseClause/DefaultClause so for simplicity always consider them non-completed
+            return false;
+        case SyntaxKind.ForStatement:
+        case SyntaxKind.ForInStatement:
+        case SyntaxKind.ForOfStatement:
+        case SyntaxKind.WhileStatement:
+            return isCompletedNode(n.statement, sourceFile);
+        case SyntaxKind.DoStatement:
+            // rough approximation: if DoStatement has While keyword - then if node is completed is checking the presence of ')';
+            return hasChildOfKind(n, SyntaxKind.WhileKeyword, sourceFile)
+                ? nodeEndsWith(n, SyntaxKind.CloseParenToken, sourceFile)
+                : isCompletedNode(n.statement, sourceFile);
+        case SyntaxKind.TypeQuery:
+            return isCompletedNode(n.exprName, sourceFile);
+        case SyntaxKind.TypeOfExpression:
+        case SyntaxKind.DeleteExpression:
+        case SyntaxKind.SpreadElement:
+            const unaryWordExpression = n;
+            return isCompletedNode(unaryWordExpression.expression, sourceFile);
+        case SyntaxKind.TemplateExpression:
+            const lastSpan = lastOrUndefined(n.templateSpans);
+            return isCompletedNode(lastSpan, sourceFile);
+        case SyntaxKind.TemplateSpan:
+            return nodeIsPresent(n.literal);
+        case SyntaxKind.ExportDeclaration:
+        case SyntaxKind.ImportDeclaration:
+            return nodeIsPresent(n.moduleSpecifier);
+        case SyntaxKind.PrefixUnaryExpression:
+            return isCompletedNode(n.operand, sourceFile);
+        case SyntaxKind.BinaryExpression:
+            return isCompletedNode(n.right, sourceFile);
+        case SyntaxKind.ConditionalExpression:
+            return isCompletedNode(n.whenFalse, sourceFile);
+        default:
+            return true;
+    }
+}
+/*
+ * Checks if node ends with 'expectedLastToken'.
+ * If child at position 'length - 1' is 'SemicolonToken' it is skipped and 'expectedLastToken' is compared with child at position 'length - 2'.
+ */
+function nodeEndsWith(n, expectedLastToken, sourceFile) {
+    const children = n.getChildren(sourceFile);
+    if (children.length) {
+        const lastChild = last(children);
+        if (lastChild.kind === expectedLastToken) {
+            return true;
+        }
+        else if (lastChild.kind === SyntaxKind.SemicolonToken && children.length !== 1) {
+            return children[children.length - 2].kind === expectedLastToken;
+        }
+    }
+    return false;
+}
+export function findListItemInfo(node) {
+    const list = findContainingList(node);
+    // It is possible at this point for syntaxList to be undefined, either if
+    // node.parent had no list child, or if none of its list children contained
+    // the span of node. If this happens, return undefined. The caller should
+    // handle this case.
+    if (!list) {
+        return undefined;
+    }
+    const children = list.getChildren();
+    const listItemIndex = indexOfNode(children, node);
+    return {
+        listItemIndex,
+        list
+    };
+}
+export function hasChildOfKind(n, kind, sourceFile) {
+    return !!findChildOfKind(n, kind, sourceFile);
+}
+export function findChildOfKind(n, kind, sourceFile) {
+    return find(n.getChildren(sourceFile), (c) => c.kind === kind);
+}
+export function findContainingList(node) {
+    // The node might be a list element (nonsynthetic) or a comma (synthetic). Either way, it will
+    // be parented by the container of the SyntaxList, not the SyntaxList itself.
+    // In order to find the list item index, we first need to locate SyntaxList itself and then search
+    // for the position of the relevant node (or comma).
+    const syntaxList = find(node.parent.getChildren(), (c) => isSyntaxList(c) && rangeContainsRange(c, node));
+    // Either we didn't find an appropriate list, or the list must contain us.
+    Debug.assert(!syntaxList || contains(syntaxList.getChildren(), node));
+    return syntaxList;
+}
+/**
+ * O nome de uma declaração. Na tag, fora do rename, a classe e a `function` sem nome davam o modificador `default` ou a
+ * palavra-chave delas (CK-02).
+ */
+function getAdjustedLocationForDeclaration(node) {
+    if (isNamedDeclaration(node)) {
+        return node.name;
+    }
+}
+function getAdjustedLocationForImportDeclaration(node, forRename) {
+    if (node.importClause) {
+        if (node.importClause.name && node.importClause.namedBindings) {
+            // do not adjust if we have both a name and named bindings
+            return;
+        }
+        // /**/import [|name|] from ...;
+        // import /**/type [|name|] from ...;
+        if (node.importClause.name) {
+            return node.importClause.name;
+        }
+        // /**/import { [|name|] } from ...;
+        // /**/import { propertyName as [|name|] } from ...;
+        // /**/import * as [|name|] from ...;
+        // import /**/type { [|name|] } from ...;
+        // import /**/type { propertyName as [|name|] } from ...;
+        // import /**/type * as [|name|] from ...;
+        if (node.importClause.namedBindings) {
+            if (isNamedImports(node.importClause.namedBindings)) {
+                // do nothing if there is more than one binding
+                const onlyBinding = singleOrUndefined(node.importClause.namedBindings.elements);
+                if (!onlyBinding) {
+                    return;
+                }
+                return onlyBinding.name;
+            }
+            else if (isNamespaceImport(node.importClause.namedBindings)) {
+                return node.importClause.namedBindings.name;
+            }
+        }
+    }
+    if (!forRename) {
+        // /**/import "[|module|]";
+        // /**/import ... from "[|module|]";
+        // import /**/type ... from "[|module|]";
+        return node.moduleSpecifier;
+    }
+}
+function getAdjustedLocationForExportDeclaration(node, forRename) {
+    if (node.exportClause) {
+        // /**/export { [|name|] } ...
+        // /**/export { propertyName as [|name|] } ...
+        // /**/export * as [|name|] ...
+        // export /**/type { [|name|] } from ...
+        // export /**/type { propertyName as [|name|] } from ...
+        // export /**/type * as [|name|] ...
+        if (isNamedExports(node.exportClause)) {
+            // do nothing if there is more than one binding
+            const onlyBinding = singleOrUndefined(node.exportClause.elements);
+            if (!onlyBinding) {
+                return;
+            }
+            return node.exportClause.elements[0].name;
+        }
+        else if (isNamespaceExport(node.exportClause)) {
+            return node.exportClause.name;
+        }
+    }
+    if (!forRename) {
+        // /**/export * from "[|module|]";
+        // export /**/type * from "[|module|]";
+        return node.moduleSpecifier;
+    }
+}
+function getAdjustedLocation(node, forRename) {
+    const { parent } = node;
+    // /**/<modifier> [|name|] ...
+    // /**/<modifier> <type|namespace> [|name|] ...
+    // /**/<type|namespace> [|name|] ...
+    //
+    // Na tag, também a palavra da classe, da interface, do enum, da `function`, do acessor e do `module` (CK-02, CK-56) e a
+    // do `import =` (CK-03). E, fora do rename, a tag não ajustava o modificador `default`; a cópia não o tem: ele só
+    // existia diante da `function` e da classe, e o `export default` que fica é de expressão (CK-46).
+    if (isModifier(node) ? contains(parent.modifiers, node) :
+        node.kind === SyntaxKind.TypeKeyword ? isTypeAliasDeclaration(parent) :
+            node.kind === SyntaxKind.NamespaceKeyword ? isModuleDeclaration(parent) :
+                false) {
+        const location = getAdjustedLocationForDeclaration(parent);
+        if (location) {
+            return location;
+        }
+    }
+    // /**/<let|const> [|name|] ...
+    // Na tag, também o `var` (CK-54).
+    if ((node.kind === SyntaxKind.ConstKeyword || node.kind === SyntaxKind.LetKeyword) &&
+        isVariableDeclarationList(parent) && parent.declarations.length === 1) {
+        const decl = parent.declarations[0];
+        if (isIdentifier(decl.name)) {
+            return decl.name;
+        }
+    }
+    if (node.kind === SyntaxKind.TypeKeyword) {
+        // import /**/type [|name|] from ...;
+        // import /**/type { [|name|] } from ...;
+        // import /**/type { propertyName as [|name|] } from ...;
+        // import /**/type ... from "[|module|]";
+        if (isImportClause(parent) && parent.isTypeOnly) {
+            const location = getAdjustedLocationForImportDeclaration(parent.parent, forRename);
+            if (location) {
+                return location;
+            }
+        }
+        // export /**/type { [|name|] } from ...;
+        // export /**/type { propertyName as [|name|] } from ...;
+        // export /**/type * from "[|module|]";
+        // export /**/type * as ... from "[|module|]";
+        if (isExportDeclaration(parent) && parent.isTypeOnly) {
+            const location = getAdjustedLocationForExportDeclaration(parent, forRename);
+            if (location) {
+                return location;
+            }
+        }
+    }
+    // import { propertyName /**/as [|name|] } ...
+    // import * /**/as [|name|] ...
+    // export { propertyName /**/as [|name|] } ...
+    // export * /**/as [|name|] ...
+    if (node.kind === SyntaxKind.AsKeyword) {
+        if (isImportSpecifier(parent) && parent.propertyName ||
+            isExportSpecifier(parent) && parent.propertyName ||
+            isNamespaceImport(parent) ||
+            isNamespaceExport(parent)) {
+            return parent.name;
+        }
+        if (isExportDeclaration(parent) && parent.exportClause && isNamespaceExport(parent.exportClause)) {
+            return parent.exportClause.name;
+        }
+    }
+    // /**/import [|name|] from ...;
+    // /**/import { [|name|] } from ...;
+    // /**/import { propertyName as [|name|] } from ...;
+    // /**/import ... from "[|module|]";
+    // /**/import "[|module|]";
+    if (node.kind === SyntaxKind.ImportKeyword && isImportDeclaration(parent)) {
+        const location = getAdjustedLocationForImportDeclaration(parent, forRename);
+        if (location) {
+            return location;
+        }
+    }
+    if (node.kind === SyntaxKind.ExportKeyword) {
+        // /**/export { [|name|] } ...;
+        // /**/export { propertyName as [|name|] } ...;
+        // /**/export * from "[|module|]";
+        // /**/export * as ... from "[|module|]";
+        if (isExportDeclaration(parent)) {
+            const location = getAdjustedLocationForExportDeclaration(parent, forRename);
+            if (location) {
+                return location;
+            }
+        }
+        // NOTE: We don't adjust the location of the `default` keyword as that is handled specially by `getSymbolAtLocation`.
+        // /**/export default [|name|];
+        // /**/export = [|name|];
+        if (isExportAssignment(parent)) {
+            return skipOuterExpressions(parent.expression);
+        }
+    }
+    // import ... /**/from "[|module|]";
+    // export ... /**/from "[|module|]";
+    if (node.kind === SyntaxKind.FromKeyword && (isImportDeclaration(parent) || isExportDeclaration(parent)) && parent.moduleSpecifier) {
+        return parent.moduleSpecifier;
+    }
+    // Na tag, também o `require` do `import =` e o `extends` e o `implements` de classe e de interface (CK-02, CK-03).
+    if (node.kind === SyntaxKind.ExtendsKeyword) {
+        // ... <T /**/extends [|U|]> ...
+        if (isTypeParameterDeclaration(parent) && parent.constraint && isTypeReferenceNode(parent.constraint)) {
+            return parent.constraint.typeName;
+        }
+        // ... T /**/extends [|U|] ? ...
+        if (isConditionalTypeNode(parent) && isTypeReferenceNode(parent.extendsType)) {
+            return parent.extendsType.typeName;
+        }
+    }
+    // ... T extends /**/infer [|U|] ? ...
+    if (node.kind === SyntaxKind.InferKeyword && isInferTypeNode(parent)) {
+        return parent.typeParameter.name;
+    }
+    // { [ [|K|] /**/in keyof T]: ... }
+    if (node.kind === SyntaxKind.InKeyword && isTypeParameterDeclaration(parent) && isMappedTypeNode(parent.parent)) {
+        return parent.name;
+    }
+    // /**/keyof [|T|]
+    if (node.kind === SyntaxKind.KeyOfKeyword && isTypeOperatorNode(parent) && parent.operator === SyntaxKind.KeyOfKeyword &&
+        isTypeReferenceNode(parent.type)) {
+        return parent.type.typeName;
+    }
+    // /**/readonly [|name|][]
+    if (node.kind === SyntaxKind.ReadonlyKeyword && isTypeOperatorNode(parent) && parent.operator === SyntaxKind.ReadonlyKeyword &&
+        isArrayTypeNode(parent.type) && isTypeReferenceNode(parent.type.elementType)) {
+        return parent.type.elementType.typeName;
+    }
+    if (!forRename) {
+        // /**/typeof [|name|]
+        // /**/typeof obj.[|name|]
+        // /**/await [|name|]
+        // /**/await obj.[|name|]
+        // /**/delete obj.[|name|]
+        // Na tag, também o `new`, o `void` e o `yield` (CK-02, CK-63).
+        if (node.kind === SyntaxKind.TypeOfKeyword && isTypeOfExpression(parent) ||
+            node.kind === SyntaxKind.AwaitKeyword && isAwaitExpression(parent) ||
+            node.kind === SyntaxKind.DeleteKeyword && isDeleteExpression(parent)) {
+            if (parent.expression) {
+                return skipOuterExpressions(parent.expression);
+            }
+        }
+        // left /**/in [|name|]
+        // Na tag, também o `instanceof` (CK-02).
+        if (node.kind === SyntaxKind.InKeyword && isBinaryExpression(parent) && parent.operatorToken === node) {
+            return skipOuterExpressions(parent.right);
+        }
+        // left /**/as [|name|]
+        if (node.kind === SyntaxKind.AsKeyword && isAsExpression(parent) && isTypeReferenceNode(parent.type)) {
+            return parent.type.typeName;
+        }
+        // for (... /**/in [|name|])
+        // for (... /**/of [|name|])
+        if (node.kind === SyntaxKind.InKeyword && isForInStatement(parent) ||
+            node.kind === SyntaxKind.OfKeyword && isForOfStatement(parent)) {
+            return skipOuterExpressions(parent.expression);
+        }
+    }
+    return node;
+}
+/**
+ * Adjusts the location used for "find references" and "go to definition" when the cursor was not
+ * on a property name.
+ */
+export function getAdjustedReferenceLocation(node) {
+    return getAdjustedLocation(node, /*forRename*/ false);
+}
+/**
+ * Adjusts the location used for "rename" when the cursor was not on a property name.
+ */
+export function getAdjustedRenameLocation(node) {
+    return getAdjustedLocation(node, /*forRename*/ true);
+}
+/**
+ * O token cujo texto contém a posição, ou o que termina nela quando é um nome, um literal ou uma palavra-chave. Na tag,
+ * também o nome `#private` (CK-02).
+ */
+export function getTouchingPropertyName(sourceFile, position) {
+    return getTouchingToken(sourceFile, position, n => isPropertyNameLiteral(n) || isKeyword(n.kind));
+}
+/**
+ * Returns the token if position is in [start, end).
+ * If position === end, returns the preceding token if includeItemAtEndPosition(previousToken) === true
+ */
+export function getTouchingToken(sourceFile, position, includePrecedingTokenAtEndPosition) {
+    return getTokenAtPositionWorker(sourceFile, position, /*allowPositionInLeadingTrivia*/ false, includePrecedingTokenAtEndPosition, /*includeEndPosition*/ false);
+}
+/** Returns a token if position is in [start-of-leading-trivia, end) */
+export function getTokenAtPosition(sourceFile, position) {
+    return getTokenAtPositionWorker(sourceFile, position, /*allowPositionInLeadingTrivia*/ true, /*includePrecedingTokenAtEndPosition*/ undefined, /*includeEndPosition*/ false);
+}
+/** Get the token whose text contains the position */
+function getTokenAtPositionWorker(sourceFile, position, allowPositionInLeadingTrivia, includePrecedingTokenAtEndPosition, includeEndPosition) {
+    let current = sourceFile;
+    outer: while (true) {
+        // find the child that contains 'position'
+        for (const child of current.getChildren(sourceFile)) {
+            // Na tag, o começo do filho contava o JSDoc dele (CK-03).
+            const start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile);
+            if (start > position) {
+                // If this child begins after position, then all subsequent children will as well.
+                break;
+            }
+            const end = child.getEnd();
+            if (position < end || (position === end && (child.kind === SyntaxKind.EndOfFileToken || includeEndPosition))) {
+                current = child;
+                continue outer;
+            }
+            else if (includePrecedingTokenAtEndPosition && end === position) {
+                const previousToken = findPrecedingToken(position, sourceFile, child);
+                if (previousToken && includePrecedingTokenAtEndPosition(previousToken)) {
+                    return previousToken;
+                }
+            }
+        }
+        return current;
+    }
+}
+/**
+ * The token on the left of the position is the token that strictly includes the position
+ * or sits to the left of the cursor if it is on a boundary. For example
+ *
+ *   fo|o               -> will return foo
+ *   foo <comment> |bar -> will return foo
+ *
+ */
+export function findTokenOnLeftOfPosition(file, position) {
+    // Ideally, getTokenAtPosition should return a token. However, it is currently
+    // broken, so we do a check to make sure the result was indeed a token.
+    const tokenAtPosition = getTokenAtPosition(file, position);
+    if (isToken(tokenAtPosition) && position > tokenAtPosition.getStart(file) && position < tokenAtPosition.getEnd()) {
+        return tokenAtPosition;
+    }
+    return findPrecedingToken(position, file);
+}
+export function findNextToken(previousToken, parent, sourceFile) {
+    return find(parent);
+    function find(n) {
+        if (isToken(n) && n.pos === previousToken.end) {
+            // this is token that starts at the end of previous token - return it
+            return n;
+        }
+        return firstDefined(n.getChildren(sourceFile), child => {
+            const shouldDiveInChildNode = 
+            // previous token is enclosed somewhere in the child
+            (child.pos <= previousToken.pos && child.end > previousToken.end) ||
+                // previous token ends exactly at the beginning of child
+                (child.pos === previousToken.end);
+            return shouldDiveInChildNode && nodeHasTokens(child, sourceFile) ? find(child) : undefined;
+        });
+    }
+}
+/**
+ * O token mais à direita que termina até a posição, fora o `JsxText` só de espaço. Na tag, o `excludeJsdoc` escolhia se
+ * o começo de um filho contava o JSDoc dele; a cópia não tem o JSDoc (CK-03).
+ */
+export function findPrecedingToken(position, sourceFile, startNode) {
+    const result = find(startNode || sourceFile);
+    Debug.assert(!(result && isWhiteSpaceOnlyJsxText(result)));
+    return result;
+    function find(n) {
+        if (isNonWhitespaceToken(n) && n.kind !== SyntaxKind.EndOfFileToken) {
+            return n;
+        }
+        const children = n.getChildren(sourceFile);
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            // Note that the span of a node's tokens is [node.getStart(...), node.end).
+            // Given that `position < child.end` and child has constituent tokens, we distinguish these cases:
+            // 1) `position` precedes `child`'s tokens or `child` has no tokens (ie: in a comment or whitespace preceding `child`):
+            // we need to find the last token in a previous child.
+            // 2) `position` is within the same span: we recurse on `child`.
+            if (position < child.end) {
+                const start = child.getStart(sourceFile);
+                const lookInPreviousChild = (start >= position) || // cursor in the leading trivia
+                    !nodeHasTokens(child, sourceFile) ||
+                    isWhiteSpaceOnlyJsxText(child);
+                if (lookInPreviousChild) {
+                    // actual start of the node is past the position - previous token should be at the end of previous child
+                    const candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ i, sourceFile);
+                    return candidate && findRightmostToken(candidate, sourceFile);
+                }
+                else {
+                    // candidate should be in this node
+                    return find(child);
+                }
+            }
+        }
+        // Na tag, também o nó de JSDoc (CK-03).
+        Debug.assert(startNode !== undefined || n.kind === SyntaxKind.SourceFile || n.kind === SyntaxKind.EndOfFileToken);
+        // Here we know that none of child token nodes embrace the position,
+        // the only known case is when position is at the end of the file.
+        // Try to find the rightmost token in the file without filtering.
+        // Namely we are skipping the check: 'position < node.end'
+        const candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ children.length, sourceFile);
+        return candidate && findRightmostToken(candidate, sourceFile);
+    }
+}
+function isNonWhitespaceToken(n) {
+    return isToken(n) && !isWhiteSpaceOnlyJsxText(n);
+}
+function findRightmostToken(n, sourceFile) {
+    if (isNonWhitespaceToken(n)) {
+        return n;
+    }
+    const children = n.getChildren(sourceFile);
+    const candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ children.length, sourceFile);
+    return candidate && findRightmostToken(candidate, sourceFile);
+}
+/**
+ * Finds the rightmost child to the left of `children[exclusiveStartPosition]` which is a non-all-whitespace token or has constituent tokens.
+ */
+function findRightmostChildNodeWithTokens(children, exclusiveStartPosition, sourceFile) {
+    for (let i = exclusiveStartPosition - 1; i >= 0; i--) {
+        const child = children[i];
+        if (isWhiteSpaceOnlyJsxText(child)) {
+            Debug.assert(i > 0, "`JsxText` tokens should not be the first child of `JsxElement | JsxSelfClosingElement`");
+        }
+        else if (nodeHasTokens(children[i], sourceFile)) {
+            return children[i];
+        }
+    }
+}
+export function isInString(sourceFile, position, previousToken = findPrecedingToken(position, sourceFile)) {
+    if (previousToken && isStringTextContainingNode(previousToken)) {
+        const start = previousToken.getStart(sourceFile);
+        const end = previousToken.getEnd();
+        // To be "in" one of these literals, the position has to be:
+        //   1. entirely within the token text.
+        //   2. at the end position of an unterminated token.
+        //   3. at the end of a regular expression (due to trailing flags like '/foo/g').
+        if (start < position && position < end) {
+            return true;
+        }
+        if (position === end) {
+            return !!previousToken.isUnterminated;
+        }
+    }
+    return false;
+}
+/**
+ * returns true if the position is in between the open and close elements of an JSX expression.
+ */
+export function isInsideJsxElementOrAttribute(sourceFile, position) {
+    const token = getTokenAtPosition(sourceFile, position);
+    if (!token) {
+        return false;
+    }
+    if (token.kind === SyntaxKind.JsxText) {
+        return true;
+    }
+    // <div>Hello |</div>
+    if (token.kind === SyntaxKind.LessThanToken && token.parent.kind === SyntaxKind.JsxText) {
+        return true;
+    }
+    // <div> { | </div> or <div a={| </div>
+    if (token.kind === SyntaxKind.LessThanToken && token.parent.kind === SyntaxKind.JsxExpression) {
+        return true;
+    }
+    // <div> {
+    // |
+    // } < /div>
+    if (token && token.kind === SyntaxKind.CloseBraceToken && token.parent.kind === SyntaxKind.JsxExpression) {
+        return true;
+    }
+    // <div>|</div>
+    if (token.kind === SyntaxKind.LessThanToken && token.parent.kind === SyntaxKind.JsxClosingElement) {
+        return true;
+    }
+    return false;
+}
+function isWhiteSpaceOnlyJsxText(node) {
+    return isJsxText(node) && node.containsOnlyTriviaWhiteSpaces;
+}
+export function isInTemplateString(sourceFile, position) {
+    const token = getTokenAtPosition(sourceFile, position);
+    return isTemplateLiteralKind(token.kind) && position > token.getStart(sourceFile);
+}
+export function isInJSXText(sourceFile, position) {
+    const token = getTokenAtPosition(sourceFile, position);
+    if (isJsxText(token)) {
+        return true;
+    }
+    if (token.kind === SyntaxKind.OpenBraceToken && isJsxExpression(token.parent) && isJsxElement(token.parent.parent)) {
+        return true;
+    }
+    if (token.kind === SyntaxKind.LessThanToken && isJsxOpeningLikeElement(token.parent) && isJsxElement(token.parent.parent)) {
+        return true;
+    }
+    return false;
+}
+export function findPrecedingMatchingToken(token, matchingTokenKind, sourceFile) {
+    const tokenKind = token.kind;
+    let remainingMatchingTokens = 0;
+    while (true) {
+        const preceding = findPrecedingToken(token.getFullStart(), sourceFile);
+        if (!preceding) {
+            return undefined;
+        }
+        token = preceding;
+        if (token.kind === matchingTokenKind) {
+            if (remainingMatchingTokens === 0) {
+                return token;
+            }
+            remainingMatchingTokens--;
+        }
+        else if (token.kind === tokenKind) {
+            remainingMatchingTokens++;
+        }
+    }
+}
+export function removeOptionality(type, isOptionalExpression, isOptionalChain) {
+    return isOptionalExpression ? type.getNonNullableType() :
+        isOptionalChain ? type.getNonOptionalType() :
+            type;
+}
+export function isPossiblyTypeArgumentPosition(token, sourceFile, checker) {
+    const info = getPossibleTypeArgumentsInfo(token, sourceFile);
+    return info !== undefined && (isPartOfTypeNode(info.called) ||
+        getPossibleGenericSignatures(info.called, info.nTypeArguments, checker).length !== 0 ||
+        isPossiblyTypeArgumentPosition(info.called, sourceFile, checker));
+}
+export function getPossibleGenericSignatures(called, typeArgumentCount, checker) {
+    let type = checker.getTypeAtLocation(called);
+    if (isOptionalChain(called.parent)) {
+        type = removeOptionality(type, isOptionalChainRoot(called.parent), /*isOptionalChain*/ true);
+    }
+    // Na tag, a construct signature do `new` (CK-02).
+    const signatures = type.getCallSignatures();
+    return signatures.filter(candidate => !!candidate.typeParameters && candidate.typeParameters.length >= typeArgumentCount);
+}
+// Get info for an expression like `f <` that may be the start of type arguments.
+export function getPossibleTypeArgumentsInfo(tokenIn, sourceFile) {
+    let token = tokenIn;
+    // This function determines if the node could be type argument position
+    // Since during editing, when type argument list is not complete,
+    // the tree could be of any shape depending on the tokens parsed before current node,
+    // scanning of the previous identifier followed by "<" before current node would give us better result
+    // Note that we also balance out the already provided type arguments, arrays, object literals while doing so
+    let remainingLessThanTokens = 0;
+    let nTypeArguments = 0;
+    while (token) {
+        switch (token.kind) {
+            case SyntaxKind.LessThanToken:
+                // Found the beginning of the generic argument expression
+                token = findPrecedingToken(token.getFullStart(), sourceFile);
+                if (token && token.kind === SyntaxKind.QuestionDotToken) {
+                    token = findPrecedingToken(token.getFullStart(), sourceFile);
+                }
+                if (!token || !isIdentifier(token))
+                    return undefined;
+                if (!remainingLessThanTokens) {
+                    return isDeclarationName(token) ? undefined : { called: token, nTypeArguments };
+                }
+                remainingLessThanTokens--;
+                break;
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+                remainingLessThanTokens = +3;
+                break;
+            case SyntaxKind.GreaterThanGreaterThanToken:
+                remainingLessThanTokens = +2;
+                break;
+            case SyntaxKind.GreaterThanToken:
+                remainingLessThanTokens++;
+                break;
+            case SyntaxKind.CloseBraceToken:
+                // This can be object type, skip until we find the matching open brace token
+                // Skip until the matching open brace token
+                token = findPrecedingMatchingToken(token, SyntaxKind.OpenBraceToken, sourceFile);
+                if (!token)
+                    return undefined;
+                break;
+            case SyntaxKind.CloseParenToken:
+                // This can be object type, skip until we find the matching open brace token
+                // Skip until the matching open brace token
+                token = findPrecedingMatchingToken(token, SyntaxKind.OpenParenToken, sourceFile);
+                if (!token)
+                    return undefined;
+                break;
+            case SyntaxKind.CloseBracketToken:
+                // This can be object type, skip until we find the matching open brace token
+                // Skip until the matching open brace token
+                token = findPrecedingMatchingToken(token, SyntaxKind.OpenBracketToken, sourceFile);
+                if (!token)
+                    return undefined;
+                break;
+            // Valid tokens in a type name. Skip.
+            case SyntaxKind.CommaToken:
+                nTypeArguments++;
+                break;
+            case SyntaxKind.EqualsGreaterThanToken:
+            // falls through
+            case SyntaxKind.Identifier:
+            case SyntaxKind.StringLiteral:
+            case SyntaxKind.NumericLiteral:
+            case SyntaxKind.BigIntLiteral:
+            case SyntaxKind.TrueKeyword:
+            case SyntaxKind.FalseKeyword:
+            // falls through
+            case SyntaxKind.TypeOfKeyword:
+            case SyntaxKind.ExtendsKeyword:
+            case SyntaxKind.KeyOfKeyword:
+            case SyntaxKind.DotToken:
+            case SyntaxKind.BarToken:
+            case SyntaxKind.QuestionToken:
+            case SyntaxKind.ColonToken:
+                break;
+            default:
+                if (isTypeNode(token)) {
+                    break;
+                }
+                // Invalid token in type
+                return undefined;
+        }
+        token = findPrecedingToken(token.getFullStart(), sourceFile);
+    }
+    return undefined;
+}
+/**
+ * Returns true if the cursor at position in sourceFile is within a comment.
+ *
+ * @param tokenAtPosition Must equal `getTokenAtPosition(sourceFile, position)
+ * @param predicate Additional predicate to test on the comment range.
+ */
+export function isInComment(sourceFile, position, tokenAtPosition) {
+    return getRangeOfEnclosingComment(sourceFile, position, /*precedingToken*/ undefined, tokenAtPosition);
+}
+function nodeHasTokens(n, sourceFile) {
+    // O token ou o nó de largura não nula tem tokens; a largura não conta a trivia. Na tag, o fim do arquivo tinha tokens
+    // quando levava um JSDoc; a cópia não tem o JSDoc (CK-03).
+    return n.kind !== SyntaxKind.EndOfFileToken && n.getWidth(sourceFile) !== 0;
+}
+export function getNodeModifiers(node) {
+    const flags = isDeclaration(node) ? getCombinedModifierFlags(node) : ModifierFlags.None;
+    const result = [];
+    // Na tag, também os modificadores de membro de classe: o de acesso, o `static` e o `abstract` (CK-02).
+    if (flags & ModifierFlags.Export)
+        result.push("export" /* ScriptElementKindModifier.exportedModifier */);
+    if (node.flags & NodeFlags.Ambient)
+        result.push("declare" /* ScriptElementKindModifier.ambientModifier */);
+    if (node.kind === SyntaxKind.ExportAssignment)
+        result.push("export" /* ScriptElementKindModifier.exportedModifier */);
+    return result.length > 0 ? result.join(",") : "" /* ScriptElementKindModifier.none */;
+}
+/** Na tag, também os parâmetros de tipo de uma classe e de uma interface declaradas (CK-02). */
+export function getTypeArgumentOrTypeParameterList(node) {
+    if (node.kind === SyntaxKind.TypeReference || node.kind === SyntaxKind.CallExpression) {
+        return node.typeArguments;
+    }
+    if (isFunctionLike(node)) {
+        return node.typeParameters;
+    }
+    return undefined;
+}
+export function isComment(kind) {
+    return kind === SyntaxKind.SingleLineCommentTrivia || kind === SyntaxKind.MultiLineCommentTrivia;
+}
+/** A string e o template. Na tag, também o literal de regex (CK-02). */
+export function isStringOrRegularExpressionOrTemplateLiteral(kind) {
+    if (kind === SyntaxKind.StringLiteral
+        || isTemplateLiteralKind(kind)) {
+        return true;
+    }
+    return false;
+}
+export function isPunctuation(kind) {
+    return SyntaxKind.FirstPunctuation <= kind && kind <= SyntaxKind.LastPunctuation;
+}
+export function isArrayLiteralOrObjectLiteralDestructuringPattern(node) {
+    if (node.kind === SyntaxKind.ArrayLiteralExpression ||
+        node.kind === SyntaxKind.ObjectLiteralExpression) {
+        // [a,b,c] from:
+        // [a, b, c] = someExpression;
+        if (node.parent.kind === SyntaxKind.BinaryExpression &&
+            node.parent.left === node &&
+            node.parent.operatorToken.kind === SyntaxKind.EqualsToken) {
+            return true;
+        }
+        // [a, b, c] from:
+        // for([a, b, c] of expression)
+        if (node.parent.kind === SyntaxKind.ForOfStatement &&
+            node.parent.initializer === node) {
+            return true;
+        }
+        // [a, b, c] of
+        // [x, [a, b, c] ] = someExpression
+        // or
+        // {x, a: {a, b, c} } = someExpression
+        if (isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.kind === SyntaxKind.PropertyAssignment ? node.parent.parent : node.parent)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isInNonReferenceComment(sourceFile, position) {
+    return isInReferenceCommentWorker(sourceFile, position, /*shouldBeReference*/ false);
+}
+function isInReferenceCommentWorker(sourceFile, position, shouldBeReference) {
+    const range = isInComment(sourceFile, position, /*tokenAtPosition*/ undefined);
+    return !!range && shouldBeReference === tripleSlashDirectivePrefixRegex.test(sourceFile.text.substring(range.pos, range.end));
+}
+export function getReplacementSpanForContextToken(contextToken) {
+    if (!contextToken)
+        return undefined;
+    switch (contextToken.kind) {
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+            return createTextSpanFromStringLiteralLikeContent(contextToken);
+        default:
+            return createTextSpanFromNode(contextToken);
+    }
+}
+export function createTextSpanFromNode(node, sourceFile, endNode) {
+    return createTextSpanFromBounds(node.getStart(sourceFile), (endNode || node).getEnd());
+}
+export function createTextSpanFromStringLiteralLikeContent(node) {
+    if (node.isUnterminated)
+        return undefined;
+    return createTextSpanFromBounds(node.getStart() + 1, node.getEnd() - 1);
+}
+export function createTextSpanFromRange(range) {
+    return createTextSpanFromBounds(range.pos, range.end);
+}
+export function createTextRangeFromSpan(span) {
+    return createRange(span.start, span.start + span.length);
+}
+export function createTextChangeFromStartLength(start, length, newText) {
+    return createTextChange(createTextSpan(start, length), newText);
+}
+export function createTextChange(span, newText) {
+    return { span, newText };
+}
+export const typeKeywords = [
+    SyntaxKind.AnyKeyword,
+    SyntaxKind.AssertsKeyword,
+    SyntaxKind.BigIntKeyword,
+    SyntaxKind.BooleanKeyword,
+    SyntaxKind.FalseKeyword,
+    SyntaxKind.KeyOfKeyword,
+    SyntaxKind.NeverKeyword,
+    SyntaxKind.NullKeyword,
+    SyntaxKind.NumberKeyword,
+    SyntaxKind.ObjectKeyword,
+    SyntaxKind.ReadonlyKeyword,
+    SyntaxKind.StringKeyword,
+    SyntaxKind.SymbolKeyword,
+    SyntaxKind.TrueKeyword,
+    SyntaxKind.VoidKeyword,
+    SyntaxKind.UndefinedKeyword,
+    // Na tag, também o `unique`, que saiu do scanner com o `unique symbol` (CK-02, CK-56).
+    SyntaxKind.UnknownKeyword,
+];
+export function isTypeKeyword(kind) {
+    return contains(typeKeywords, kind);
+}
+export function isTypeKeywordToken(node) {
+    return node.kind === SyntaxKind.TypeKeyword;
+}
+/** True if the symbol is for an external module, as opposed to a namespace. */
+export function isExternalModuleSymbol(moduleSymbol) {
+    return !!(moduleSymbol.flags & SymbolFlags.Module) && moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote;
+}
+export function nodeSeenTracker() {
+    const seen = [];
+    return node => {
+        const id = getNodeId(node);
+        return !seen[id] && (seen[id] = true);
+    };
+}
+export function getSnapshotText(snap) {
+    return snap.getText(0, snap.getLength());
+}
+export function repeatString(str, count) {
+    let result = "";
+    for (let i = 0; i < count; i++) {
+        result += str;
+    }
+    return result;
+}
+export function skipConstraint(type) {
+    return type.isTypeParameter() ? type.getConstraint() || type : type;
+}
+export function getNameFromPropertyName(name) {
+    return name.kind === SyntaxKind.ComputedPropertyName
+        // O nome computado com um literal de string ou de número vale como o literal.
+        ? isStringOrNumericLiteralLike(name.expression) ? name.expression.text : undefined
+        : getTextOfIdentifierOrLiteral(name);
+}
+/**
+ * O host do cálculo de um specifier. Na tag, recebia também o programa, e o host dava ainda o que a resolução do Node,
+ * os symlinks, o cache de tipos e as project references perguntavam (CK-46, CK-47).
+ */
+export function createModuleSpecifierResolutionHost(host) {
+    return {
+        getCurrentDirectory: () => host.getCurrentDirectory(),
+        useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
+    };
+}
+export function makeImportIfNecessary(defaultImport, namedImports, moduleSpecifier, quotePreference) {
+    return defaultImport || namedImports && namedImports.length ? makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference) : undefined;
+}
+export function makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference, isTypeOnly) {
+    return createImportDeclaration(
+    /*modifiers*/ undefined, defaultImport || namedImports
+        ? createImportClause(defaultImport, namedImports && namedImports.length ? createNamedImports(namedImports) : undefined, isTypeOnly)
+        : undefined, typeof moduleSpecifier === "string" ? makeStringLiteral(moduleSpecifier, quotePreference) : moduleSpecifier);
+}
+export function makeStringLiteral(text, quotePreference) {
+    return createLiteral(text, quotePreference === 0 /* QuotePreference.Single */);
+}
+export var QuotePreference;
+(function (QuotePreference) {
+    QuotePreference[QuotePreference["Single"] = 0] = "Single";
+    QuotePreference[QuotePreference["Double"] = 1] = "Double";
+})(QuotePreference || (QuotePreference = {}));
+export function quotePreferenceFromString(str, sourceFile) {
+    return isStringDoubleQuoted(str, sourceFile) ? 1 /* QuotePreference.Double */ : 0 /* QuotePreference.Single */;
+}
+export function getQuotePreference(sourceFile, preferences) {
+    if (preferences.quotePreference && preferences.quotePreference !== "auto") {
+        return preferences.quotePreference === "single" ? 0 /* QuotePreference.Single */ : 1 /* QuotePreference.Double */;
+    }
+    else {
+        const firstModuleSpecifier = sourceFile.imports && find(sourceFile.imports, isStringLiteral);
+        return firstModuleSpecifier ? quotePreferenceFromString(firstModuleSpecifier, sourceFile) : 1 /* QuotePreference.Double */;
+    }
+}
+export function symbolNameNoDefault(symbol) {
+    const escaped = symbolEscapedNameNoDefault(symbol);
+    return escaped === undefined ? undefined : unescapeLeadingUnderscores(escaped);
+}
+export function symbolEscapedNameNoDefault(symbol) {
+    if (symbol.escapedName !== InternalSymbolName.Default) {
+        return symbol.escapedName;
+    }
+    return firstDefined(symbol.declarations, decl => {
+        const name = getNameOfDeclaration(decl);
+        return name && name.kind === SyntaxKind.Identifier ? name.escapedText : undefined;
+    });
+}
+export function isObjectBindingElementWithoutPropertyName(bindingElement) {
+    return isBindingElement(bindingElement) &&
+        isObjectBindingPattern(bindingElement.parent) &&
+        isIdentifier(bindingElement.name) &&
+        !bindingElement.propertyName;
+}
+export function getPropertySymbolFromBindingElement(checker, bindingElement) {
+    const typeOfPattern = checker.getTypeAtLocation(bindingElement.parent);
+    return typeOfPattern && checker.getPropertyOfType(typeOfPattern, bindingElement.name.text);
+}
+export function getParentNodeInSpan(node, file, span) {
+    if (!node)
+        return undefined;
+    while (node.parent) {
+        if (isSourceFile(node.parent) || !spanContainsNode(span, node.parent, file)) {
+            return node;
+        }
+        node = node.parent;
+    }
+}
+function spanContainsNode(span, node, file) {
+    return textSpanContainsPosition(span, node.getStart(file)) &&
+        node.getEnd() <= textSpanEnd(span);
+}
+export function findModifier(node, kind) {
+    return node.modifiers && find(node.modifiers, m => m.kind === kind);
+}
+export function insertImports(changes, sourceFile, imports, blankLineBetween) {
+    // Na tag, o `const x = require(…)` novo entrava depois dos outros `require` (CK-03).
+    const lastImportDeclaration = findLast(sourceFile.statements, statement => isAnyImportSyntax(statement));
+    if (lastImportDeclaration) {
+        if (isArray(imports)) {
+            changes.insertNodesAfter(sourceFile, lastImportDeclaration, imports);
+        }
+        else {
+            changes.insertNodeAfter(sourceFile, lastImportDeclaration, imports);
+        }
+    }
+    else if (isArray(imports)) {
+        changes.insertNodesAtTopOfFile(sourceFile, imports, blankLineBetween);
+    }
+    else {
+        changes.insertNodeAtTopOfFile(sourceFile, imports, blankLineBetween);
+    }
+}
+export function getTypeKeywordOfTypeOnlyImport(importClause, sourceFile) {
+    Debug.assert(importClause.isTypeOnly);
+    return cast(importClause.getChildAt(0, sourceFile), isTypeKeywordToken);
+}
+export function textSpansEqual(a, b) {
+    return !!a && !!b && a.start === b.start && a.length === b.length;
+}
+// #endregion
+// Display-part writer helpers
+// #region
+export function isFirstDeclarationOfSymbolParameter(symbol) {
+    return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter;
+}
+const displayPartWriter = getDisplayPartWriter();
+function getDisplayPartWriter() {
+    const absoluteMaximumLength = defaultMaximumTruncationLength * 10; // A hard cutoff to avoid overloading the messaging channel in worst-case scenarios
+    let displayParts;
+    let lineStart;
+    let indent;
+    let length;
+    resetWriter();
+    const unknownWrite = (text) => writeKind(text, SymbolDisplayPartKind.text);
+    return {
+        displayParts: () => {
+            const finalText = displayParts.length && displayParts[displayParts.length - 1].text;
+            if (length > absoluteMaximumLength && finalText && finalText !== "...") {
+                if (!isWhiteSpaceLike(finalText.charCodeAt(finalText.length - 1))) {
+                    displayParts.push(displayPart(" ", SymbolDisplayPartKind.space));
+                }
+                displayParts.push(displayPart("...", SymbolDisplayPartKind.punctuation));
+            }
+            return displayParts;
+        },
+        writeKeyword: text => writeKind(text, SymbolDisplayPartKind.keyword),
+        writeOperator: text => writeKind(text, SymbolDisplayPartKind.operator),
+        writePunctuation: text => writeKind(text, SymbolDisplayPartKind.punctuation),
+        writeTrailingSemicolon: text => writeKind(text, SymbolDisplayPartKind.punctuation),
+        writeSpace: text => writeKind(text, SymbolDisplayPartKind.space),
+        writeStringLiteral: text => writeKind(text, SymbolDisplayPartKind.stringLiteral),
+        writeParameter: text => writeKind(text, SymbolDisplayPartKind.parameterName),
+        writeProperty: text => writeKind(text, SymbolDisplayPartKind.propertyName),
+        writeLiteral: text => writeKind(text, SymbolDisplayPartKind.stringLiteral),
+        writeSymbol,
+        writeLine,
+        write: unknownWrite,
+        writeComment: unknownWrite,
+        getText: () => "",
+        getTextPos: () => 0,
+        getColumn: () => 0,
+        getLine: () => 0,
+        isAtStartOfLine: () => false,
+        hasTrailingWhitespace: () => false,
+        hasTrailingComment: () => false,
+        rawWrite: notImplemented,
+        getIndent: () => indent,
+        increaseIndent: () => { indent++; },
+        decreaseIndent: () => { indent--; },
+        clear: resetWriter,
+        trackSymbol: noop,
+        reportInaccessibleThisError: noop,
+        reportInaccessibleUniqueSymbolError: noop,
+        // Na tag, também o aviso do membro privado na base de uma class expression, que saiu do `SymbolTracker` da cópia
+        // com a classe (CK-02).
+    };
+    function writeIndent() {
+        if (length > absoluteMaximumLength)
+            return;
+        if (lineStart) {
+            const indentString = getIndentString(indent);
+            if (indentString) {
+                length += indentString.length;
+                displayParts.push(displayPart(indentString, SymbolDisplayPartKind.space));
+            }
+            lineStart = false;
+        }
+    }
+    function writeKind(text, kind) {
+        if (length > absoluteMaximumLength)
+            return;
+        writeIndent();
+        length += text.length;
+        displayParts.push(displayPart(text, kind));
+    }
+    function writeSymbol(text, symbol) {
+        if (length > absoluteMaximumLength)
+            return;
+        writeIndent();
+        length += text.length;
+        displayParts.push(symbolPart(text, symbol));
+    }
+    function writeLine() {
+        if (length > absoluteMaximumLength)
+            return;
+        length += 1;
+        displayParts.push(lineBreakPart());
+        lineStart = true;
+    }
+    function resetWriter() {
+        displayParts = [];
+        lineStart = true;
+        indent = 0;
+        length = 0;
+    }
+}
+export function symbolPart(text, symbol) {
+    return displayPart(text, displayPartKind(symbol));
+    function displayPartKind(symbol) {
+        const flags = symbol.flags;
+        if (flags & SymbolFlags.Variable) {
+            return isFirstDeclarationOfSymbolParameter(symbol) ? SymbolDisplayPartKind.parameterName : SymbolDisplayPartKind.localName;
+        }
+        // Na tag, também o acessor, o membro de enum, a classe e o enum (CK-02).
+        else if (flags & SymbolFlags.Property) {
+            return SymbolDisplayPartKind.propertyName;
+        }
+        else if (flags & SymbolFlags.Function) {
+            return SymbolDisplayPartKind.functionName;
+        }
+        else if (flags & SymbolFlags.Interface) {
+            return SymbolDisplayPartKind.interfaceName;
+        }
+        else if (flags & SymbolFlags.Module) {
+            return SymbolDisplayPartKind.moduleName;
+        }
+        else if (flags & SymbolFlags.Method) {
+            return SymbolDisplayPartKind.methodName;
+        }
+        else if (flags & SymbolFlags.TypeParameter) {
+            return SymbolDisplayPartKind.typeParameterName;
+        }
+        else if (flags & SymbolFlags.TypeAlias) {
+            return SymbolDisplayPartKind.aliasName;
+        }
+        else if (flags & SymbolFlags.Alias) {
+            return SymbolDisplayPartKind.aliasName;
+        }
+        return SymbolDisplayPartKind.text;
+    }
+}
+export function displayPart(text, kind) {
+    return { text, kind: SymbolDisplayPartKind[kind] };
+}
+export function spacePart() {
+    return displayPart(" ", SymbolDisplayPartKind.space);
+}
+export function keywordPart(kind) {
+    return displayPart(tokenToString(kind), SymbolDisplayPartKind.keyword);
+}
+export function punctuationPart(kind) {
+    return displayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation);
+}
+export function operatorPart(kind) {
+    return displayPart(tokenToString(kind), SymbolDisplayPartKind.operator);
+}
+export function textOrKeywordPart(text) {
+    const kind = stringToToken(text);
+    return kind === undefined
+        ? textPart(text)
+        : keywordPart(kind);
+}
+export function textPart(text) {
+    return displayPart(text, SymbolDisplayPartKind.text);
+}
+const carriageReturnLineFeed = "\r\n";
+/**
+ * The default is CRLF.
+ */
+export function getNewLineOrDefaultFromHost(host, formatSettings) {
+    return formatSettings?.newLineCharacter ||
+        host.getNewLine?.() ||
+        carriageReturnLineFeed;
+}
+export function lineBreakPart() {
+    return displayPart("\n", SymbolDisplayPartKind.lineBreak);
+}
+export function mapToDisplayParts(writeDisplayParts) {
+    try {
+        writeDisplayParts(displayPartWriter);
+        return displayPartWriter.displayParts();
+    }
+    finally {
+        displayPartWriter.clear();
+    }
+}
+export function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = TypeFormatFlags.None) {
+    return mapToDisplayParts(writer => {
+        typechecker.writeType(type, enclosingDeclaration, flags | TypeFormatFlags.MultilineObjectLiterals | TypeFormatFlags.UseAliasDefinedOutsideCurrentScope, writer);
+    });
+}
+export function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags = SymbolFormatFlags.None) {
+    return mapToDisplayParts(writer => {
+        typeChecker.writeSymbol(symbol, enclosingDeclaration, meaning, flags | SymbolFormatFlags.UseAliasDefinedOutsideCurrentScope, writer);
+    });
+}
+export function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, flags = TypeFormatFlags.None) {
+    flags |= TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | TypeFormatFlags.MultilineObjectLiterals | TypeFormatFlags.WriteTypeArgumentsOfSignature | TypeFormatFlags.OmitParameterModifiers;
+    return mapToDisplayParts(writer => {
+        // Na tag, também o `kind`, que imprimia a construct signature (CK-02).
+        typechecker.writeSignature(signature, enclosingDeclaration, flags, writer);
+    });
+}
+export function isImportOrExportSpecifierName(location) {
+    return !!location.parent && isImportOrExportSpecifier(location.parent) && location.parent.propertyName === location;
+}
+export function getScriptKind(fileName, host) {
+    // O host pode dar o tipo do arquivo, no lugar do que a extensão diria.
+    return ensureScriptKind(fileName, host && host.getScriptKind && host.getScriptKind(fileName));
+}
+export function getSymbolTarget(symbol, checker) {
+    let next = symbol;
+    while (isAliasSymbol(next) || (isTransientSymbol(next) && next.target)) {
+        if (isTransientSymbol(next) && next.target) {
+            next = next.target;
+        }
+        else {
+            next = skipAlias(next, checker);
+        }
+    }
+    return next;
+}
+function isTransientSymbol(symbol) {
+    return (symbol.flags & SymbolFlags.Transient) !== 0;
+}
+function isAliasSymbol(symbol) {
+    return (symbol.flags & SymbolFlags.Alias) !== 0;
+}
+export function getUniqueSymbolId(symbol, checker) {
+    return getSymbolId(skipAlias(symbol, checker));
+}
+export function getFirstNonSpaceCharacterPosition(text, position) {
+    while (isWhiteSpaceLike(text.charCodeAt(position))) {
+        position += 1;
+    }
+    return position;
+}
+export function getPrecedingNonSpaceCharacterPosition(text, position) {
+    while (position > -1 && isWhiteSpaceSingleLine(text.charCodeAt(position))) {
+        position -= 1;
+    }
+    return position + 1;
+}
+/**
+ * Creates a deep, memberwise clone of a node with no source map location.
+ *
+ * WARNING: This is an expensive operation and is only intended to be used in refactorings
+ * and code fixes (because those are triggered by explicit user actions).
+ */
+export function getSynthesizedDeepClone(node, includeTrivia = true) {
+    const clone = node && getSynthesizedDeepCloneWorker(node);
+    if (clone && !includeTrivia)
+        suppressLeadingAndTrailingTrivia(clone);
+    return clone;
+}
+export function getSynthesizedDeepCloneWithRenames(node, includeTrivia = true, renameMap, checker, callback) {
+    let clone;
+    if (renameMap && checker && isBindingElement(node) && isIdentifier(node.name) && isObjectBindingPattern(node.parent)) {
+        const symbol = checker.getSymbolAtLocation(node.name);
+        const renameInfo = symbol && renameMap.get(String(getSymbolId(symbol)));
+        if (renameInfo && renameInfo.text !== (node.name || node.propertyName).getText()) {
+            clone = setOriginalNode(createBindingElement(node.dotDotDotToken, node.propertyName || node.name, renameInfo, node.initializer), node);
+        }
+    }
+    else if (renameMap && checker && isIdentifier(node)) {
+        const symbol = checker.getSymbolAtLocation(node);
+        const renameInfo = symbol && renameMap.get(String(getSymbolId(symbol)));
+        if (renameInfo) {
+            clone = setOriginalNode(createIdentifier(renameInfo.text), node);
+        }
+    }
+    if (!clone) {
+        clone = getSynthesizedDeepCloneWorker(node, renameMap, checker, callback);
+    }
+    if (clone && !includeTrivia)
+        suppressLeadingAndTrailingTrivia(clone);
+    if (callback && clone)
+        callback(node, clone);
+    return clone;
+}
+function getSynthesizedDeepCloneWorker(node, renameMap, checker, callback) {
+    const visited = (renameMap || checker || callback) ?
+        visitEachChild(node, wrapper, nullTransformationContext) :
+        visitEachChild(node, getSynthesizedDeepClone, nullTransformationContext);
+    if (visited === node) {
+        // This only happens for leaf nodes - internal nodes always see their children change.
+        const clone = getSynthesizedClone(node);
+        if (isStringLiteral(clone)) {
+            clone.textSourceNode = node;
+        }
+        else if (isNumericLiteral(clone)) {
+            clone.numericLiteralFlags = node.numericLiteralFlags;
+        }
+        return setTextRange(clone, node);
+    }
+    // PERF: As an optimization, rather than calling getSynthesizedClone, we'll update
+    // the new node created by visitEachChild with the extra changes getSynthesizedClone
+    // would have made.
+    visited.parent = undefined;
+    return visited;
+    function wrapper(node) {
+        return getSynthesizedDeepCloneWithRenames(node, /*includeTrivia*/ true, renameMap, checker, callback);
+    }
+}
+/**
+ * Sets EmitFlags to suppress leading and trailing trivia on the node.
+ */
+export function suppressLeadingAndTrailingTrivia(node) {
+    suppressLeadingTrivia(node);
+    suppressTrailingTrivia(node);
+}
+/**
+ * Sets EmitFlags to suppress leading trivia on the node.
+ */
+export function suppressLeadingTrivia(node) {
+    addEmitFlagsRecursively(node, EmitFlags.NoLeadingComments, getFirstChild);
+}
+/**
+ * Sets EmitFlags to suppress trailing trivia on the node.
+ */
+export function suppressTrailingTrivia(node) {
+    addEmitFlagsRecursively(node, EmitFlags.NoTrailingComments, getLastChild);
+}
+export function copyComments(sourceNode, targetNode) {
+    const sourceFile = sourceNode.getSourceFile();
+    const text = sourceFile.text;
+    if (hasLeadingLineBreak(sourceNode, text)) {
+        copyLeadingComments(sourceNode, targetNode, sourceFile);
+    }
+    else {
+        copyTrailingAsLeadingComments(sourceNode, targetNode, sourceFile);
+    }
+    copyTrailingComments(sourceNode, targetNode, sourceFile);
+}
+function hasLeadingLineBreak(node, text) {
+    const start = node.getFullStart();
+    const end = node.getStart();
+    for (let i = start; i < end; i++) {
+        if (text.charCodeAt(i) === CharacterCodes.lineFeed)
+            return true;
+    }
+    return false;
+}
+function addEmitFlagsRecursively(node, flag, getChild) {
+    addEmitFlags(node, flag);
+    const child = getChild(node);
+    if (child)
+        addEmitFlagsRecursively(child, flag, getChild);
+}
+function getFirstChild(node) {
+    return node.forEachChild(child => child);
+}
+export function getUniqueName(baseName, sourceFile) {
+    let nameText = baseName;
+    for (let i = 1; !isFileLevelUniqueName(sourceFile, nameText); i++) {
+        nameText = `${baseName}_${i}`;
+    }
+    return nameText;
+}
+/**
+ * @return The index of the (only) reference to the extracted symbol.  We want the cursor
+ * to be on the reference, rather than the declaration, because it's closer to where the
+ * user was before extracting it.
+ */
+export function getRenameLocation(edits, renameFilename, name, preferLastLocation) {
+    let delta = 0;
+    let lastPos = -1;
+    for (const { fileName, textChanges } of edits) {
+        Debug.assert(fileName === renameFilename);
+        for (const change of textChanges) {
+            const { span, newText } = change;
+            const index = indexInTextChange(newText, name);
+            if (index !== -1) {
+                lastPos = span.start + delta + index;
+                // If the reference comes first, return immediately.
+                if (!preferLastLocation) {
+                    return lastPos;
+                }
+            }
+            delta += newText.length - span.length;
+        }
+    }
+    // If the declaration comes first, return the position of the last occurrence.
+    Debug.assert(preferLastLocation);
+    Debug.assert(lastPos >= 0);
+    return lastPos;
+}
+export function copyLeadingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) {
+    forEachLeadingCommentRange(sourceFile.text, sourceNode.pos, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, addSyntheticLeadingComment));
+}
+export function copyTrailingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) {
+    forEachTrailingCommentRange(sourceFile.text, sourceNode.end, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, addSyntheticTrailingComment));
+}
+/**
+ * This function copies the trailing comments for the token that comes before `sourceNode`, as leading comments of `targetNode`.
+ * This is useful because sometimes a comment that refers to `sourceNode` will be a leading comment for `sourceNode`, according to the
+ * notion of trivia ownership, and instead will be a trailing comment for the token before `sourceNode`, e.g.:
+ * `function foo(\* not leading comment for a *\ a: string) {}`
+ * The comment refers to `a` but belongs to the `(` token, but we might want to copy it.
+ */
+export function copyTrailingAsLeadingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) {
+    forEachTrailingCommentRange(sourceFile.text, sourceNode.pos, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, addSyntheticLeadingComment));
+}
+function getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, cb) {
+    return (pos, end, kind, htnl) => {
+        if (kind === SyntaxKind.MultiLineCommentTrivia) {
+            // Remove leading /*
+            pos += 2;
+            // Remove trailing */
+            end -= 2;
+        }
+        else {
+            // Remove leading //
+            pos += 2;
+        }
+        cb(targetNode, commentKind || kind, sourceFile.text.slice(pos, end), hasTrailingNewLine !== undefined ? hasTrailingNewLine : htnl);
+    };
+}
+function indexInTextChange(change, name) {
+    if (startsWith(change, name))
+        return 0;
+    // Add a " " to avoid references inside words
+    let idx = change.indexOf(" " + name);
+    if (idx === -1)
+        idx = change.indexOf("." + name);
+    if (idx === -1)
+        idx = change.indexOf('"' + name);
+    return idx === -1 ? -1 : idx + 1;
+}
+/** Na tag, também a expressão com o operador vírgula (CK-02). */
+export function needsParentheses(expression) {
+    return isObjectLiteralExpression(expression);
+}
+export function getContextualTypeFromParent(node, checker) {
+    const { parent } = node;
+    switch (parent.kind) {
+        // Na tag, também o `new` (CK-02).
+        case SyntaxKind.BinaryExpression: {
+            const { left, operatorToken, right } = parent;
+            return isEqualityOperatorKind(operatorToken.kind)
+                ? checker.getTypeAtLocation(node === right ? left : right)
+                : checker.getContextualType(node);
+        }
+        case SyntaxKind.CaseClause:
+            return parent.expression === node ? getSwitchedType(parent, checker) : undefined;
+        default:
+            return checker.getContextualType(node);
+    }
+}
+export function quote(text, preferences) {
+    // Editors can pass in undefined or empty string - we want to infer the preference in those cases.
+    const quotePreference = preferences.quotePreference || "auto";
+    const quoted = JSON.stringify(text);
+    switch (quotePreference) {
+        // TODO use getQuotePreference to infer the actual quote style.
+        case "auto":
+        case "double":
+            return quoted;
+        case "single":
+            return `'${stripQuotes(quoted).replace("'", "\\'").replace('\\"', '"')}'`;
+        default:
+            return Debug.assertNever(quotePreference);
+    }
+}
+/** A igualdade da Linguagem: o `==` e o `!=`. Na tag, também o `===` e o `!==`, que a Linguagem não tem (CK-70). */
+export function isEqualityOperatorKind(kind) {
+    switch (kind) {
+        case SyntaxKind.EqualsEqualsToken:
+        case SyntaxKind.ExclamationEqualsToken:
+            return true;
+        default:
+            return false;
+    }
+}
+/** Na tag, também o template marcado (CK-02). */
+export function isStringLiteralOrTemplate(node) {
+    switch (node.kind) {
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+        case SyntaxKind.TemplateExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+export function hasIndexSignature(type) {
+    return !!type.getStringIndexType() || !!type.getNumberIndexType();
+}
+export function getSwitchedType(caseClause, checker) {
+    return checker.getTypeAtLocation(caseClause.parent.parent.expression);
+}
+/**
+ * O tipo como nó, se todo símbolo que ele nomeia é acessível do ponto. Na tag, o tracker recebia também os avisos do
+ * `this`, do `private` de uma classe e do `unique symbol` inacessíveis, que o node builder da cópia não dá (CK-02), e o
+ * host do specifier somava o diretório comum do `Program` (CK-47).
+ */
+export function getTypeNodeIfAccessible(type, enclosingScope, program, host) {
+    const checker = program.getTypeChecker();
+    let typeIsAccessible = true;
+    const res = checker.typeToTypeNode(type, enclosingScope, /*flags*/ undefined, {
+        trackSymbol: (symbol, declaration, meaning) => {
+            typeIsAccessible = typeIsAccessible && checker.isSymbolAccessible(symbol, declaration, meaning).accessibility === SymbolAccessibility.Accessible;
+        },
+        moduleResolverHost: createModuleSpecifierResolutionHost(host),
+    });
+    return typeIsAccessible ? res : undefined;
+}
+/** Na tag, também a construct signature (CK-02) e a method signature (CK-36). */
+export function syntaxRequiresTrailingCommaOrSemicolonOrASI(kind) {
+    return kind === SyntaxKind.CallSignature
+        || kind === SyntaxKind.IndexSignature
+        || kind === SyntaxKind.PropertySignature;
+}
+// Na tag, o `syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI`: a declaração com corpo de função que podia terminar
+// sem ele (a `function`, o construtor, o método e o acessor), que a parse tree não tem (CK-02).
+export function syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(kind) {
+    return kind === SyntaxKind.ModuleDeclaration;
+}
+/** Na tag, também o `debugger` e a propriedade de classe (CK-02), e o `import =` e o `export as namespace` (CK-03). */
+export function syntaxRequiresTrailingSemicolonOrASI(kind) {
+    return kind === SyntaxKind.VariableStatement
+        || kind === SyntaxKind.ExpressionStatement
+        || kind === SyntaxKind.DoStatement
+        || kind === SyntaxKind.ContinueStatement
+        || kind === SyntaxKind.BreakStatement
+        || kind === SyntaxKind.ReturnStatement
+        || kind === SyntaxKind.ThrowStatement
+        || kind === SyntaxKind.TypeAliasDeclaration
+        || kind === SyntaxKind.ImportDeclaration
+        || kind === SyntaxKind.ExportDeclaration
+        || kind === SyntaxKind.ExportAssignment;
+}
+export const syntaxMayBeASICandidate = or(syntaxRequiresTrailingCommaOrSemicolonOrASI, syntaxRequiresTrailingModuleBlockOrSemicolonOrASI, syntaxRequiresTrailingSemicolonOrASI);
+function nodeIsASICandidate(node, sourceFile) {
+    const lastToken = node.getLastToken(sourceFile);
+    if (lastToken && lastToken.kind === SyntaxKind.SemicolonToken) {
+        return false;
+    }
+    if (syntaxRequiresTrailingCommaOrSemicolonOrASI(node.kind)) {
+        if (lastToken && lastToken.kind === SyntaxKind.CommaToken) {
+            return false;
+        }
+    }
+    else if (syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(node.kind)) {
+        const lastChild = last(node.getChildren(sourceFile));
+        if (lastChild && isModuleBlock(lastChild)) {
+            return false;
+        }
+    }
+    // Na tag, também a declaração que termina num corpo de função (CK-02).
+    else if (!syntaxRequiresTrailingSemicolonOrASI(node.kind)) {
+        return false;
+    }
+    // See comment in parser’s `parseDoStatement`
+    if (node.kind === SyntaxKind.DoStatement) {
+        return true;
+    }
+    const topNode = findAncestor(node, ancestor => !ancestor.parent);
+    const nextToken = findNextToken(node, topNode, sourceFile);
+    if (!nextToken || nextToken.kind === SyntaxKind.CloseBraceToken) {
+        return true;
+    }
+    const startLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
+    const endLine = sourceFile.getLineAndCharacterOfPosition(nextToken.getStart(sourceFile)).line;
+    return startLine !== endLine;
+}
+export function positionIsASICandidate(pos, context, sourceFile) {
+    const contextAncestor = findAncestor(context, ancestor => {
+        if (ancestor.end !== pos) {
+            return "quit";
+        }
+        return syntaxMayBeASICandidate(ancestor.kind);
+    });
+    return !!contextAncestor && nodeIsASICandidate(contextAncestor, sourceFile);
+}
+export function probablyUsesSemicolons(sourceFile) {
+    let withSemicolon = 0;
+    let withoutSemicolon = 0;
+    const nStatementsToObserve = 5;
+    forEachChild(sourceFile, function visit(node) {
+        if (syntaxRequiresTrailingSemicolonOrASI(node.kind)) {
+            const lastToken = node.getLastToken(sourceFile);
+            if (lastToken && lastToken.kind === SyntaxKind.SemicolonToken) {
+                withSemicolon++;
+            }
+            else {
+                withoutSemicolon++;
+            }
+        }
+        if (withSemicolon + withoutSemicolon >= nStatementsToObserve) {
+            return true;
+        }
+        return forEachChild(node, visit);
+    });
+    // One statement missing a semicolon isn’t sufficient evidence to say the user
+    // doesn’t want semicolons, because they may not even be done writing that statement.
+    if (withSemicolon === 0 && withoutSemicolon <= 1) {
+        return true;
+    }
+    // If even 2/5 places have a semicolon, the user probably wants semicolons
+    return withSemicolon / withoutSemicolon > 1 / nStatementsToObserve;
+}
+export function getRefactorContextSpan({ startPosition, endPosition }) {
+    return createTextSpanFromBounds(startPosition, endPosition === undefined ? startPosition : endPosition);
+}
+export function getNameForExportedSymbol(symbol, scriptTarget) {
+    // Na tag, também o `export =` (CK-03).
+    if (symbol.escapedName === InternalSymbolName.Default) {
+        // O nome do `export default foo;` é `foo`; o do `export default 0`, o do arquivo em camelCase.
+        return firstDefined(symbol.declarations, d => isExportAssignment(d) && isIdentifier(d.expression) ? d.expression.text : undefined)
+            || moduleSymbolToValidIdentifier(Debug.checkDefined(symbol.parent), scriptTarget);
+    }
+    return symbol.name;
+}
+/**
+ * Useful to check whether a string contains another string at a specific index
+ * without allocating another string or traversing the entire contents of the outer string.
+ *
+ * This function is useful in place of either of the following:
+ *
+ * ```ts
+ * // Allocates
+ * haystack.substr(startIndex, needle.length) === needle
+ *
+ * // Full traversal
+ * haystack.indexOf(needle, startIndex) === startIndex
+ * ```
+ *
+ * @param haystack The string that potentially contains `needle`.
+ * @param needle The string whose content might sit within `haystack`.
+ * @param startIndex The index within `haystack` to start searching for `needle`.
+ */
+export function stringContainsAt(haystack, needle, startIndex) {
+    const needleLength = needle.length;
+    if (needleLength + startIndex > haystack.length) {
+        return false;
+    }
+    for (let i = 0; i < needleLength; i++) {
+        if (needle.charCodeAt(i) !== haystack.charCodeAt(i + startIndex))
+            return false;
+    }
+    return true;
+}
+// Do `codefixes/importFixes.ts` da tag: só cálculo de nome, que a leitura usa sem a edição (CK-67).
+export function moduleSymbolToValidIdentifier(moduleSymbol, target) {
+    return moduleSpecifierToValidIdentifier(removeFileExtension(stripQuotes(moduleSymbol.name)), target);
+}
+export function moduleSpecifierToValidIdentifier(moduleSpecifier, target) {
+    const baseName = getBaseFileName(removeSuffix(moduleSpecifier, "/index"));
+    let res = "";
+    let lastCharWasValid = true;
+    const firstCharCode = baseName.charCodeAt(0);
+    if (isIdentifierStart(firstCharCode, target)) {
+        res += String.fromCharCode(firstCharCode);
+    }
+    else {
+        lastCharWasValid = false;
+    }
+    for (let i = 1; i < baseName.length; i++) {
+        const ch = baseName.charCodeAt(i);
+        const isValid = isIdentifierPart(ch, target);
+        if (isValid) {
+            let char = String.fromCharCode(ch);
+            if (!lastCharWasValid) {
+                char = char.toUpperCase();
+            }
+            res += char;
+        }
+        lastCharWasValid = isValid;
+    }
+    // Need `|| "_"` to ensure result isn't empty.
+    return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
+}
+// Do `formatting/formatting.ts` da tag: só usa a árvore e os comentários do texto, e a leitura o usa sem a edição (CK-67).
+/**
+ * @param precedingToken pass `null` if preceding token was already computed and result was `undefined`.
+ */
+export function getRangeOfEnclosingComment(sourceFile, position, precedingToken, tokenAtPosition = getTokenAtPosition(sourceFile, position)) {
+    // Na tag, a posição dentro de um JSDoc subia ao nó que ele documenta; a cópia não tem o JSDoc (CK-03).
+    const tokenStart = tokenAtPosition.getStart(sourceFile);
+    if (tokenStart <= position && position < tokenAtPosition.getEnd()) {
+        return undefined;
+    }
+    // eslint-disable-next-line no-null/no-null
+    precedingToken = precedingToken === null ? undefined : precedingToken === undefined ? findPrecedingToken(position, sourceFile) : precedingToken;
+    // Between two consecutive tokens, all comments are either trailing on the former
+    // or leading on the latter (and none are in both lists).
+    const trailingRangesOfPreviousToken = precedingToken && getTrailingCommentRanges(sourceFile.text, precedingToken.end);
+    const leadingCommentRangesOfNextToken = getLeadingCommentRangesOfNode(tokenAtPosition, sourceFile);
+    const commentRanges = concatenate(trailingRangesOfPreviousToken, leadingCommentRangesOfNextToken);
+    return commentRanges && find(commentRanges, range => rangeContainsPositionExclusive(range, position) ||
+        // The end marker of a single-line comment does not include the newline character.
+        // With caret at `^`, in the following case, we are inside a comment (^ denotes the cursor position):
+        //
+        //    // asdf   ^\n
+        //
+        // But for closed multi-line comments, we don't want to be inside the comment in the following case:
+        //
+        //    /* asdf */^
+        //
+        // However, unterminated multi-line comments *do* contain their end.
+        //
+        // Internally, we represent the end of the comment at the newline and closing '/', respectively.
+        //
+        position === range.end && (range.kind === SyntaxKind.SingleLineCommentTrivia || position === sourceFile.getFullWidth()));
+}