@tslite/services 0.0.0-stage → 1.13.0

package/dist/types.js

@@ -0,0 +1,263 @@
+export var ScriptSnapshot;
+(function (ScriptSnapshot) {
+    class StringScriptSnapshot {
+        constructor(text) {
+            this.text = text;
+        }
+        getText(start, end) {
+            return start === 0 && end === this.text.length
+                ? this.text
+                : this.text.substring(start, end);
+        }
+        getLength() {
+            return this.text.length;
+        }
+        getChangeRange() {
+            // Text-based snapshots do not support incremental parsing. Return undefined
+            // to signal that to the caller.
+            return undefined;
+        }
+    }
+    function fromString(text) {
+        return new StringScriptSnapshot(text);
+    }
+    ScriptSnapshot.fromString = fromString;
+})(ScriptSnapshot || (ScriptSnapshot = {}));
+export const emptyOptions = {};
+export var HighlightSpanKind;
+(function (HighlightSpanKind) {
+    HighlightSpanKind["none"] = "none";
+    HighlightSpanKind["definition"] = "definition";
+    HighlightSpanKind["reference"] = "reference";
+    HighlightSpanKind["writtenReference"] = "writtenReference";
+})(HighlightSpanKind || (HighlightSpanKind = {}));
+export var IndentStyle;
+(function (IndentStyle) {
+    IndentStyle[IndentStyle["None"] = 0] = "None";
+    IndentStyle[IndentStyle["Block"] = 1] = "Block";
+    IndentStyle[IndentStyle["Smart"] = 2] = "Smart";
+})(IndentStyle || (IndentStyle = {}));
+export var SemicolonPreference;
+(function (SemicolonPreference) {
+    SemicolonPreference["Ignore"] = "ignore";
+    SemicolonPreference["Insert"] = "insert";
+    SemicolonPreference["Remove"] = "remove";
+})(SemicolonPreference || (SemicolonPreference = {}));
+export function getDefaultFormatCodeSettings(newLineCharacter) {
+    return {
+        indentSize: 4,
+        tabSize: 4,
+        newLineCharacter: newLineCharacter || "\n",
+        convertTabsToSpaces: true,
+        indentStyle: IndentStyle.Smart,
+        insertSpaceAfterConstructor: false,
+        insertSpaceAfterCommaDelimiter: true,
+        insertSpaceAfterSemicolonInForStatements: true,
+        insertSpaceBeforeAndAfterBinaryOperators: true,
+        insertSpaceAfterKeywordsInControlFlowStatements: true,
+        insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+        insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
+        insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+        insertSpaceBeforeFunctionParenthesis: false,
+        placeOpenBraceOnNewLineForFunctions: false,
+        placeOpenBraceOnNewLineForControlBlocks: false,
+        semicolons: SemicolonPreference.Ignore,
+        trimTrailingWhitespace: true
+    };
+}
+export var SymbolDisplayPartKind;
+(function (SymbolDisplayPartKind) {
+    SymbolDisplayPartKind[SymbolDisplayPartKind["aliasName"] = 0] = "aliasName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["className"] = 1] = "className";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["enumName"] = 2] = "enumName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["fieldName"] = 3] = "fieldName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["interfaceName"] = 4] = "interfaceName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["keyword"] = 5] = "keyword";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["lineBreak"] = 6] = "lineBreak";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["numericLiteral"] = 7] = "numericLiteral";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["stringLiteral"] = 8] = "stringLiteral";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["localName"] = 9] = "localName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["methodName"] = 10] = "methodName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["moduleName"] = 11] = "moduleName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["operator"] = 12] = "operator";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["parameterName"] = 13] = "parameterName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["propertyName"] = 14] = "propertyName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["punctuation"] = 15] = "punctuation";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["space"] = 16] = "space";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["text"] = 17] = "text";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["typeParameterName"] = 18] = "typeParameterName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["enumMemberName"] = 19] = "enumMemberName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["functionName"] = 20] = "functionName";
+    SymbolDisplayPartKind[SymbolDisplayPartKind["regularExpressionLiteral"] = 21] = "regularExpressionLiteral";
+})(SymbolDisplayPartKind || (SymbolDisplayPartKind = {}));
+export var OutliningSpanKind;
+(function (OutliningSpanKind) {
+    /** Single or multi-line comments */
+    OutliningSpanKind["Comment"] = "comment";
+    /** Sections marked by '// #region' and '// #endregion' comments */
+    OutliningSpanKind["Region"] = "region";
+    /** Declarations and expressions */
+    OutliningSpanKind["Code"] = "code";
+    /** Contiguous blocks of import declarations */
+    OutliningSpanKind["Imports"] = "imports";
+})(OutliningSpanKind || (OutliningSpanKind = {}));
+export var ScriptElementKind;
+(function (ScriptElementKind) {
+    ScriptElementKind["unknown"] = "";
+    ScriptElementKind["warning"] = "warning";
+    /** predefined type (void) or keyword (class) */
+    ScriptElementKind["keyword"] = "keyword";
+    /** top level script node */
+    ScriptElementKind["scriptElement"] = "script";
+    /** module foo {} */
+    ScriptElementKind["moduleElement"] = "module";
+    /** class X {} */
+    ScriptElementKind["classElement"] = "class";
+    /** var x = class X {} */
+    ScriptElementKind["localClassElement"] = "local class";
+    /** interface Y {} */
+    ScriptElementKind["interfaceElement"] = "interface";
+    /** type T = ... */
+    ScriptElementKind["typeElement"] = "type";
+    /** enum E */
+    ScriptElementKind["enumElement"] = "enum";
+    ScriptElementKind["enumMemberElement"] = "enum member";
+    /**
+     * Inside module and script only
+     * const v = ..
+     */
+    ScriptElementKind["variableElement"] = "var";
+    /** Inside function */
+    ScriptElementKind["localVariableElement"] = "local var";
+    /**
+     * Inside module and script only
+     * function f() { }
+     */
+    ScriptElementKind["functionElement"] = "function";
+    /** Inside function */
+    ScriptElementKind["localFunctionElement"] = "local function";
+    /** class X { [public|private]* foo() {} } */
+    ScriptElementKind["memberFunctionElement"] = "method";
+    /** class X { [public|private]* [get|set] foo:number; } */
+    ScriptElementKind["memberGetAccessorElement"] = "getter";
+    ScriptElementKind["memberSetAccessorElement"] = "setter";
+    /**
+     * class X { [public|private]* foo:number; }
+     * interface Y { foo:number; }
+     */
+    ScriptElementKind["memberVariableElement"] = "property";
+    /** class X { constructor() { } } */
+    ScriptElementKind["constructorImplementationElement"] = "constructor";
+    /** interface Y { ():number; } */
+    ScriptElementKind["callSignatureElement"] = "call";
+    /** interface Y { []:number; } */
+    ScriptElementKind["indexSignatureElement"] = "index";
+    /** interface Y { new():Y; } */
+    ScriptElementKind["constructSignatureElement"] = "construct";
+    /** function foo(*Y*: string) */
+    ScriptElementKind["parameterElement"] = "parameter";
+    ScriptElementKind["typeParameterElement"] = "type parameter";
+    ScriptElementKind["primitiveType"] = "primitive type";
+    ScriptElementKind["label"] = "label";
+    ScriptElementKind["alias"] = "alias";
+    ScriptElementKind["constElement"] = "const";
+    ScriptElementKind["letElement"] = "let";
+    ScriptElementKind["directory"] = "directory";
+    ScriptElementKind["externalModuleName"] = "external module name";
+    /**
+     * <JsxTagName attribute1 attribute2={0} />
+     */
+    ScriptElementKind["jsxAttribute"] = "JSX attribute";
+    /** String literal */
+    ScriptElementKind["string"] = "string";
+})(ScriptElementKind || (ScriptElementKind = {}));
+export var ScriptElementKindModifier;
+(function (ScriptElementKindModifier) {
+    ScriptElementKindModifier["none"] = "";
+    ScriptElementKindModifier["publicMemberModifier"] = "public";
+    ScriptElementKindModifier["privateMemberModifier"] = "private";
+    ScriptElementKindModifier["protectedMemberModifier"] = "protected";
+    ScriptElementKindModifier["exportedModifier"] = "export";
+    ScriptElementKindModifier["ambientModifier"] = "declare";
+    ScriptElementKindModifier["staticModifier"] = "static";
+    ScriptElementKindModifier["abstractModifier"] = "abstract";
+    ScriptElementKindModifier["optionalModifier"] = "optional";
+    ScriptElementKindModifier["dtsModifier"] = ".d.ts";
+    ScriptElementKindModifier["tsModifier"] = ".ts";
+    ScriptElementKindModifier["tsxModifier"] = ".tsx";
+    ScriptElementKindModifier["jsModifier"] = ".js";
+    ScriptElementKindModifier["jsxModifier"] = ".jsx";
+    ScriptElementKindModifier["jsonModifier"] = ".json";
+})(ScriptElementKindModifier || (ScriptElementKindModifier = {}));
+export var EndOfLineState;
+(function (EndOfLineState) {
+    EndOfLineState[EndOfLineState["None"] = 0] = "None";
+    EndOfLineState[EndOfLineState["InMultiLineCommentTrivia"] = 1] = "InMultiLineCommentTrivia";
+    EndOfLineState[EndOfLineState["InSingleQuoteStringLiteral"] = 2] = "InSingleQuoteStringLiteral";
+    EndOfLineState[EndOfLineState["InDoubleQuoteStringLiteral"] = 3] = "InDoubleQuoteStringLiteral";
+    EndOfLineState[EndOfLineState["InTemplateHeadOrNoSubstitutionTemplate"] = 4] = "InTemplateHeadOrNoSubstitutionTemplate";
+    EndOfLineState[EndOfLineState["InTemplateMiddleOrTail"] = 5] = "InTemplateMiddleOrTail";
+    EndOfLineState[EndOfLineState["InTemplateSubstitutionPosition"] = 6] = "InTemplateSubstitutionPosition";
+})(EndOfLineState || (EndOfLineState = {}));
+export var ClassificationTypeNames;
+(function (ClassificationTypeNames) {
+    ClassificationTypeNames["comment"] = "comment";
+    ClassificationTypeNames["identifier"] = "identifier";
+    ClassificationTypeNames["keyword"] = "keyword";
+    ClassificationTypeNames["numericLiteral"] = "number";
+    ClassificationTypeNames["bigintLiteral"] = "bigint";
+    ClassificationTypeNames["operator"] = "operator";
+    ClassificationTypeNames["stringLiteral"] = "string";
+    ClassificationTypeNames["whiteSpace"] = "whitespace";
+    ClassificationTypeNames["text"] = "text";
+    ClassificationTypeNames["punctuation"] = "punctuation";
+    ClassificationTypeNames["className"] = "class name";
+    ClassificationTypeNames["enumName"] = "enum name";
+    ClassificationTypeNames["interfaceName"] = "interface name";
+    ClassificationTypeNames["moduleName"] = "module name";
+    ClassificationTypeNames["typeParameterName"] = "type parameter name";
+    ClassificationTypeNames["typeAliasName"] = "type alias name";
+    ClassificationTypeNames["parameterName"] = "parameter name";
+    ClassificationTypeNames["docCommentTagName"] = "doc comment tag name";
+    ClassificationTypeNames["jsxOpenTagName"] = "jsx open tag name";
+    ClassificationTypeNames["jsxCloseTagName"] = "jsx close tag name";
+    ClassificationTypeNames["jsxSelfClosingTagName"] = "jsx self closing tag name";
+    ClassificationTypeNames["jsxAttribute"] = "jsx attribute";
+    ClassificationTypeNames["jsxText"] = "jsx text";
+    ClassificationTypeNames["jsxAttributeStringLiteralValue"] = "jsx attribute string literal value";
+})(ClassificationTypeNames || (ClassificationTypeNames = {}));
+/**
+ * O tipo de um trecho na classificação codificada. Os valores são o protocolo com o editor, como na tag: os que a
+ * Linguagem não produz (a classe, o enum, a regex, a tag do JSDoc) ficam, sem renumerar os outros.
+ */
+export var ClassificationType;
+(function (ClassificationType) {
+    ClassificationType[ClassificationType["comment"] = 1] = "comment";
+    ClassificationType[ClassificationType["identifier"] = 2] = "identifier";
+    ClassificationType[ClassificationType["keyword"] = 3] = "keyword";
+    ClassificationType[ClassificationType["numericLiteral"] = 4] = "numericLiteral";
+    ClassificationType[ClassificationType["operator"] = 5] = "operator";
+    ClassificationType[ClassificationType["stringLiteral"] = 6] = "stringLiteral";
+    ClassificationType[ClassificationType["regularExpressionLiteral"] = 7] = "regularExpressionLiteral";
+    ClassificationType[ClassificationType["whiteSpace"] = 8] = "whiteSpace";
+    ClassificationType[ClassificationType["text"] = 9] = "text";
+    ClassificationType[ClassificationType["punctuation"] = 10] = "punctuation";
+    ClassificationType[ClassificationType["className"] = 11] = "className";
+    ClassificationType[ClassificationType["enumName"] = 12] = "enumName";
+    ClassificationType[ClassificationType["interfaceName"] = 13] = "interfaceName";
+    ClassificationType[ClassificationType["moduleName"] = 14] = "moduleName";
+    ClassificationType[ClassificationType["typeParameterName"] = 15] = "typeParameterName";
+    ClassificationType[ClassificationType["typeAliasName"] = 16] = "typeAliasName";
+    ClassificationType[ClassificationType["parameterName"] = 17] = "parameterName";
+    ClassificationType[ClassificationType["docCommentTagName"] = 18] = "docCommentTagName";
+    ClassificationType[ClassificationType["jsxOpenTagName"] = 19] = "jsxOpenTagName";
+    ClassificationType[ClassificationType["jsxCloseTagName"] = 20] = "jsxCloseTagName";
+    ClassificationType[ClassificationType["jsxSelfClosingTagName"] = 21] = "jsxSelfClosingTagName";
+    ClassificationType[ClassificationType["jsxAttribute"] = 22] = "jsxAttribute";
+    ClassificationType[ClassificationType["jsxText"] = 23] = "jsxText";
+    ClassificationType[ClassificationType["jsxAttributeStringLiteralValue"] = 24] = "jsxAttributeStringLiteralValue";
+    ClassificationType[ClassificationType["bigintLiteral"] = 25] = "bigintLiteral";
+})(ClassificationType || (ClassificationType = {}));

package/dist/utilities.d.ts

@@ -0,0 +1,283 @@
+import { Map, ScriptElementKind, ScriptKind, ScriptTarget, SymbolDisplayPartKind, SymbolFlags, SymbolFormatFlags, SyntaxKind, TypeFormatFlags } from "./_namespaces/ts.js";
+import type { BindingElement, CallExpression, CaseClause, CheckResult, CommentKind, CommentRange, Declaration, DisplayPartsSymbolWriter, EqualityOperator, Expression, FileTextChanges, FormatCodeSettings, FormattingHost, IScriptSnapshot, Identifier, ImportClause, ImportDeclaration, ImportSpecifier, LanguageServiceHost, Modifier, ModuleSpecifierResolutionHost, NoSubstitutionTemplateLiteral, Node, NodeArray, NumericLiteral, PropertyName, RefactorContext, Scanner, Signature, SourceFile, SourceFileLike, Statement, StringLiteral, StringLiteralLike, Symbol, SymbolDisplayPart, SyntaxList, TemplateExpression, TextChange, TextRange, TextSpan, Token, Type, TypeChecker, TypeNode, UserPreferences, __String } from "./_namespaces/ts.js";
+import type { textChanges } from "./_namespaces/edit.js";
+export declare const scanner: Scanner;
+export declare enum SemanticMeaning {
+    None = 0,
+    Value = 1,
+    Type = 2,
+    Namespace = 4,
+    All = 7
+}
+export declare function getMeaningFromDeclaration(node: Node): SemanticMeaning;
+export declare function getMeaningFromLocation(node: Node): SemanticMeaning;
+export declare function isCallExpressionTarget(node: Node, includeElementAccess?: boolean, skipPastOuterExpressions?: boolean): boolean;
+export declare function climbPastPropertyAccess(node: Node): Node;
+export declare function climbPastPropertyOrElementAccess(node: Node): Node;
+export declare function hasPropertyAccessExpressionWithName(node: CallExpression, funcName: string): boolean;
+export declare function isRightSideOfPropertyAccess(node: Node): boolean;
+export declare function isArgumentExpressionOfElementAccess(node: Node): boolean;
+/**
+ * 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 declare function isLiteralNameOfPropertyDeclarationOrIndexAccess(node: StringLiteral | NumericLiteral | NoSubstitutionTemplateLiteral): boolean;
+/**
+ * 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 declare function getContainerNode(node: Node): Declaration | undefined;
+/**
+ * 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 declare function getNodeKind(node: Node): ScriptElementKind;
+export interface ListItemInfo {
+    listItemIndex: number;
+    list: Node;
+}
+export declare function getLineStartPositionForPosition(position: number, sourceFile: SourceFileLike): number;
+export declare function rangeContainsRange(r1: TextRange, r2: TextRange): boolean;
+export declare function rangeContainsRangeExclusive(r1: TextRange, r2: TextRange): boolean;
+export declare function rangeContainsPositionExclusive(r: TextRange, pos: number): boolean;
+export declare function startEndContainsRange(start: number, end: number, range: TextRange): boolean;
+export declare function rangeContainsStartEnd(range: TextRange, start: number, end: number): boolean;
+export declare function rangeOverlapsWithStartEnd(r1: TextRange, start: number, end: number): boolean;
+export declare function startEndOverlapsWithStartEnd(start1: number, end1: number, start2: number, end2: number): boolean;
+/**
+ * Assumes `candidate.start <= position` holds.
+ */
+export declare function positionBelongsToNode(candidate: Node, position: number, sourceFile: SourceFile): boolean;
+export declare function findListItemInfo(node: Node): ListItemInfo | undefined;
+export declare function hasChildOfKind(n: Node, kind: SyntaxKind, sourceFile: SourceFile): boolean;
+export declare function findChildOfKind<T extends Node>(n: Node, kind: T["kind"], sourceFile: SourceFileLike): T | undefined;
+export declare function findContainingList(node: Node): SyntaxList | undefined;
+/**
+ * Adjusts the location used for "find references" and "go to definition" when the cursor was not
+ * on a property name.
+ */
+export declare function getAdjustedReferenceLocation(node: Node): Node;
+/**
+ * Adjusts the location used for "rename" when the cursor was not on a property name.
+ */
+export declare function getAdjustedRenameLocation(node: Node): Node;
+/**
+ * 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 declare function getTouchingPropertyName(sourceFile: SourceFile, position: number): Node;
+/**
+ * Returns the token if position is in [start, end).
+ * If position === end, returns the preceding token if includeItemAtEndPosition(previousToken) === true
+ */
+export declare function getTouchingToken(sourceFile: SourceFile, position: number, includePrecedingTokenAtEndPosition?: (n: Node) => boolean): Node;
+/** Returns a token if position is in [start-of-leading-trivia, end) */
+export declare function getTokenAtPosition(sourceFile: SourceFile, position: number): Node;
+/**
+ * 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 declare function findTokenOnLeftOfPosition(file: SourceFile, position: number): Node | undefined;
+export declare function findNextToken(previousToken: Node, parent: Node, sourceFile: SourceFileLike): Node | 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 declare function findPrecedingToken(position: number, sourceFile: SourceFile, startNode?: Node): Node | undefined;
+export declare function isInString(sourceFile: SourceFile, position: number, previousToken?: Node | undefined): boolean;
+/**
+ * returns true if the position is in between the open and close elements of an JSX expression.
+ */
+export declare function isInsideJsxElementOrAttribute(sourceFile: SourceFile, position: number): boolean;
+export declare function isInTemplateString(sourceFile: SourceFile, position: number): boolean;
+export declare function isInJSXText(sourceFile: SourceFile, position: number): boolean;
+export declare function findPrecedingMatchingToken(token: Node, matchingTokenKind: SyntaxKind, sourceFile: SourceFile): Node | undefined;
+export declare function removeOptionality(type: Type, isOptionalExpression: boolean, isOptionalChain: boolean): Type;
+export declare function isPossiblyTypeArgumentPosition(token: Node, sourceFile: SourceFile, checker: TypeChecker): boolean;
+export declare function getPossibleGenericSignatures(called: Expression, typeArgumentCount: number, checker: TypeChecker): readonly Signature[];
+export interface PossibleTypeArgumentInfo {
+    readonly called: Identifier;
+    readonly nTypeArguments: number;
+}
+export declare function getPossibleTypeArgumentsInfo(tokenIn: Node, sourceFile: SourceFile): PossibleTypeArgumentInfo | 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 declare function isInComment(sourceFile: SourceFile, position: number, tokenAtPosition?: Node): CommentRange | undefined;
+export declare function getNodeModifiers(node: Node): string;
+/** Na tag, também os parâmetros de tipo de uma classe e de uma interface declaradas (CK-02). */
+export declare function getTypeArgumentOrTypeParameterList(node: Node): NodeArray<Node> | undefined;
+export declare function isComment(kind: SyntaxKind): boolean;
+/** A string e o template. Na tag, também o literal de regex (CK-02). */
+export declare function isStringOrRegularExpressionOrTemplateLiteral(kind: SyntaxKind): boolean;
+export declare function isPunctuation(kind: SyntaxKind): boolean;
+export declare function isArrayLiteralOrObjectLiteralDestructuringPattern(node: Node): boolean;
+export declare function isInNonReferenceComment(sourceFile: SourceFile, position: number): boolean;
+export declare function getReplacementSpanForContextToken(contextToken: Node | undefined): TextSpan | undefined;
+export declare function createTextSpanFromNode(node: Node, sourceFile?: SourceFile, endNode?: Node): TextSpan;
+export declare function createTextSpanFromStringLiteralLikeContent(node: StringLiteralLike): TextSpan | undefined;
+export declare function createTextSpanFromRange(range: TextRange): TextSpan;
+export declare function createTextRangeFromSpan(span: TextSpan): TextRange;
+export declare function createTextChangeFromStartLength(start: number, length: number, newText: string): TextChange;
+export declare function createTextChange(span: TextSpan, newText: string): TextChange;
+export declare const typeKeywords: readonly SyntaxKind[];
+export declare function isTypeKeyword(kind: SyntaxKind): boolean;
+export declare function isTypeKeywordToken(node: Node): node is Token<SyntaxKind.TypeKeyword>;
+/** True if the symbol is for an external module, as opposed to a namespace. */
+export declare function isExternalModuleSymbol(moduleSymbol: Symbol): boolean;
+/** Returns `true` the first time it encounters a node and `false` afterwards. */
+export type NodeSeenTracker<T = Node> = (node: T) => boolean;
+export declare function nodeSeenTracker<T extends Node>(): NodeSeenTracker<T>;
+export declare function getSnapshotText(snap: IScriptSnapshot): string;
+export declare function repeatString(str: string, count: number): string;
+export declare function skipConstraint(type: Type): Type;
+export declare function getNameFromPropertyName(name: PropertyName): string | undefined;
+/**
+ * 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 declare function createModuleSpecifierResolutionHost(host: LanguageServiceHost): ModuleSpecifierResolutionHost;
+export declare function makeImportIfNecessary(defaultImport: Identifier | undefined, namedImports: readonly ImportSpecifier[] | undefined, moduleSpecifier: string, quotePreference: QuotePreference): ImportDeclaration | undefined;
+export declare function makeImport(defaultImport: Identifier | undefined, namedImports: readonly ImportSpecifier[] | undefined, moduleSpecifier: string | Expression, quotePreference: QuotePreference, isTypeOnly?: boolean): ImportDeclaration;
+export declare function makeStringLiteral(text: string, quotePreference: QuotePreference): StringLiteral;
+export declare enum QuotePreference {
+    Single = 0,
+    Double = 1
+}
+export declare function quotePreferenceFromString(str: StringLiteral, sourceFile: SourceFile): QuotePreference;
+export declare function getQuotePreference(sourceFile: SourceFile, preferences: UserPreferences): QuotePreference;
+export declare function symbolNameNoDefault(symbol: Symbol): string | undefined;
+export declare function symbolEscapedNameNoDefault(symbol: Symbol): __String | undefined;
+export type ObjectBindingElementWithoutPropertyName = BindingElement & {
+    name: Identifier;
+};
+export declare function isObjectBindingElementWithoutPropertyName(bindingElement: Node): bindingElement is ObjectBindingElementWithoutPropertyName;
+export declare function getPropertySymbolFromBindingElement(checker: TypeChecker, bindingElement: ObjectBindingElementWithoutPropertyName): Symbol | undefined;
+export declare function getParentNodeInSpan(node: Node | undefined, file: SourceFile, span: TextSpan): Node | undefined;
+export declare function findModifier(node: Node, kind: Modifier["kind"]): Modifier | undefined;
+export declare function insertImports(changes: textChanges.ChangeTracker, sourceFile: SourceFile, imports: Statement | readonly Statement[], blankLineBetween: boolean): void;
+export declare function getTypeKeywordOfTypeOnlyImport(importClause: ImportClause, sourceFile: SourceFile): Token<SyntaxKind.TypeKeyword>;
+export declare function textSpansEqual(a: TextSpan | undefined, b: TextSpan | undefined): boolean;
+export declare function isFirstDeclarationOfSymbolParameter(symbol: Symbol): boolean;
+export declare function symbolPart(text: string, symbol: Symbol): SymbolDisplayPart;
+export declare function displayPart(text: string, kind: SymbolDisplayPartKind): SymbolDisplayPart;
+export declare function spacePart(): SymbolDisplayPart;
+export declare function keywordPart(kind: SyntaxKind): SymbolDisplayPart;
+export declare function punctuationPart(kind: SyntaxKind): SymbolDisplayPart;
+export declare function operatorPart(kind: SyntaxKind): SymbolDisplayPart;
+export declare function textOrKeywordPart(text: string): SymbolDisplayPart;
+export declare function textPart(text: string): SymbolDisplayPart;
+/**
+ * The default is CRLF.
+ */
+export declare function getNewLineOrDefaultFromHost(host: FormattingHost, formatSettings?: FormatCodeSettings): string;
+export declare function lineBreakPart(): SymbolDisplayPart;
+export declare function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[];
+export declare function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[];
+export declare function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): SymbolDisplayPart[];
+export declare function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[];
+export declare function isImportOrExportSpecifierName(location: Node): location is Identifier;
+export declare function getScriptKind(fileName: string, host?: LanguageServiceHost): ScriptKind;
+export declare function getSymbolTarget(symbol: Symbol, checker: TypeChecker): Symbol;
+export declare function getUniqueSymbolId(symbol: Symbol, checker: TypeChecker): number;
+export declare function getFirstNonSpaceCharacterPosition(text: string, position: number): number;
+export declare function getPrecedingNonSpaceCharacterPosition(text: string, position: number): number;
+/**
+ * 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 declare function getSynthesizedDeepClone<T extends Node | undefined>(node: T, includeTrivia?: boolean): T;
+export declare function getSynthesizedDeepCloneWithRenames<T extends Node>(node: T, includeTrivia?: boolean, renameMap?: Map<Identifier>, checker?: TypeChecker, callback?: (originalNode: Node, clone: Node) => any): T;
+/**
+ * Sets EmitFlags to suppress leading and trailing trivia on the node.
+ */
+export declare function suppressLeadingAndTrailingTrivia(node: Node): void;
+/**
+ * Sets EmitFlags to suppress leading trivia on the node.
+ */
+export declare function suppressLeadingTrivia(node: Node): void;
+/**
+ * Sets EmitFlags to suppress trailing trivia on the node.
+ */
+export declare function suppressTrailingTrivia(node: Node): void;
+export declare function copyComments(sourceNode: Node, targetNode: Node): void;
+export declare function getUniqueName(baseName: string, sourceFile: SourceFile): string;
+/**
+ * @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 declare function getRenameLocation(edits: readonly FileTextChanges[], renameFilename: string, name: string, preferLastLocation: boolean): number;
+export declare function copyLeadingComments(sourceNode: Node, targetNode: Node, sourceFile: SourceFile, commentKind?: CommentKind, hasTrailingNewLine?: boolean): void;
+export declare function copyTrailingComments(sourceNode: Node, targetNode: Node, sourceFile: SourceFile, commentKind?: CommentKind, hasTrailingNewLine?: boolean): void;
+/**
+ * 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 declare function copyTrailingAsLeadingComments(sourceNode: Node, targetNode: Node, sourceFile: SourceFile, commentKind?: CommentKind, hasTrailingNewLine?: boolean): void;
+/** Na tag, também a expressão com o operador vírgula (CK-02). */
+export declare function needsParentheses(expression: Expression): expression is import("@tslite/parser").ObjectLiteralExpression;
+export declare function getContextualTypeFromParent(node: Expression, checker: TypeChecker): Type | undefined;
+export declare function quote(text: string, preferences: UserPreferences): string;
+/** A igualdade da Linguagem: o `==` e o `!=`. Na tag, também o `===` e o `!==`, que a Linguagem não tem (CK-70). */
+export declare function isEqualityOperatorKind(kind: SyntaxKind): kind is EqualityOperator;
+/** Na tag, também o template marcado (CK-02). */
+export declare function isStringLiteralOrTemplate(node: Node): node is StringLiteralLike | TemplateExpression;
+export declare function hasIndexSignature(type: Type): boolean;
+export declare function getSwitchedType(caseClause: CaseClause, checker: TypeChecker): Type | undefined;
+/**
+ * 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 declare function getTypeNodeIfAccessible(type: Type, enclosingScope: Node, program: CheckResult, host: LanguageServiceHost): TypeNode | undefined;
+/** Na tag, também a construct signature (CK-02) e a method signature (CK-36). */
+export declare function syntaxRequiresTrailingCommaOrSemicolonOrASI(kind: SyntaxKind): kind is SyntaxKind.PropertySignature | SyntaxKind.CallSignature | SyntaxKind.IndexSignature;
+export declare function syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(kind: SyntaxKind): kind is 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 declare function syntaxRequiresTrailingSemicolonOrASI(kind: SyntaxKind): kind is SyntaxKind.VariableStatement | SyntaxKind.ExpressionStatement | SyntaxKind.DoStatement | SyntaxKind.ContinueStatement | SyntaxKind.BreakStatement | SyntaxKind.ReturnStatement | SyntaxKind.ThrowStatement | SyntaxKind.TypeAliasDeclaration | SyntaxKind.ImportDeclaration | SyntaxKind.ExportAssignment | SyntaxKind.ExportDeclaration;
+export declare const syntaxMayBeASICandidate: (kind: SyntaxKind) => boolean;
+export declare function positionIsASICandidate(pos: number, context: Node, sourceFile: SourceFileLike): boolean;
+export declare function probablyUsesSemicolons(sourceFile: SourceFile): boolean;
+export declare function getRefactorContextSpan({ startPosition, endPosition }: RefactorContext): TextSpan;
+export declare function getNameForExportedSymbol(symbol: Symbol, scriptTarget: ScriptTarget): string;
+/**
+ * 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 declare function stringContainsAt(haystack: string, needle: string, startIndex: number): boolean;
+export declare function moduleSymbolToValidIdentifier(moduleSymbol: Symbol, target: ScriptTarget): string;
+export declare function moduleSpecifierToValidIdentifier(moduleSpecifier: string, target: ScriptTarget): string;
+/**
+ * @param precedingToken pass `null` if preceding token was already computed and result was `undefined`.
+ */
+export declare function getRangeOfEnclosingComment(sourceFile: SourceFile, position: number, precedingToken?: Node | null, tokenAtPosition?: Node): CommentRange | undefined;