@tslite/parser 1.10.0 → 1.13.0

package/dist/utilities.d.ts

@@ -0,0 +1,473 @@
+import { AssignmentDeclarationKind, CharacterCodes, Comparison, EmitFlags, Extension, Map, ModifierFlags, ScriptKind, SymbolFlags, SyntaxKind } from "./_namespaces/ts.js";
+import type { AccessExpression, AmbientModuleDeclaration, AnyImportOrReExport, AnyImportSyntax, AnyValidImportOrReExport, AssignmentExpression, AssignmentOperatorToken, BinaryExpression, BindableObjectDefinePropertyCall, BindableStaticAccessExpression, BindableStaticElementAccessExpression, BindableStaticNameExpression, Block, CallExpression, CallLikeExpression, CompilerOptions, Declaration, DeclarationName, DeclarationWithTypeParameterChildren, DeclarationWithTypeParameters, Diagnostic, DiagnosticMessage, DiagnosticMessageChain, DiagnosticRelatedInformation, DiagnosticWithLocation, DynamicNamedBinaryExpression, DynamicNamedDeclaration, ElementAccessExpression, EntityName, EntityNameExpression, EntityNameOrEntityNameExpression, EqualityComparer, EqualsToken, ExportAssignment, ExportDeclaration, Expression, FunctionLikeDeclaration, GetCanonicalFileName, HasExpressionInitializer, Identifier, ImportCall, ImportDeclaration, ImportMetaProperty, ImportTypeNode, JsonSourceFile, LateVisibilityPaintedStatement, LiteralImportTypeNode, LiteralLikeElementAccessExpression, LiteralLikeNode, MapLike, ModuleDeclaration, NamedImportsOrExports, Node, NodeArray, NumericLiteral, ObjectLiteralElement, ObjectTypeDeclaration, ParameterDeclaration, PrefixUnaryExpression, PrologueDirective, PropertyAccessEntityNameExpression, PropertyAccessExpression, PropertyName, PseudoBigInt, QualifiedName, ReadonlyMap, ReadonlyUnderscoreEscapedMap, RequireOrImportCall, ResolvedModuleFull, ReturnStatement, SignatureDeclaration, SourceFile, SourceFileLike, SourceMapSource, Statement, StringLiteralLike, Symbol, SymbolTable, TextRange, TextSpan, Token, TypeElement, TypeNode, TypeParameterDeclaration, TypeReferenceNode, UnderscoreEscapedMap, VariableDeclaration, VariableDeclarationList, VariableLikeDeclaration, WellKnownSymbolExpression, __String } from "./_namespaces/ts.js";
+export declare const defaultMaximumTruncationLength = 160;
+export declare const noTruncationMaximumTruncationLength = 1000000;
+export declare function getDeclarationOfKind<T extends Declaration>(symbol: Symbol, kind: T["kind"]): T | undefined;
+/** Create a new escaped identifier map. */
+export declare function createUnderscoreEscapedMap<T>(): UnderscoreEscapedMap<T>;
+export declare function hasEntries(map: ReadonlyUnderscoreEscapedMap<any> | undefined): map is ReadonlyUnderscoreEscapedMap<any>;
+export declare function createSymbolTable(symbols?: readonly Symbol[]): SymbolTable;
+/**
+ * Iterates through the parent chain of a node and performs the callback on each parent until the callback
+ * returns a truthy value, then returns that value.
+ * If no such value is found, it applies the callback until the parent pointer is undefined or the callback returns "quit"
+ * At that point findAncestor returns undefined.
+ */
+export declare function findAncestor<T extends Node>(node: Node | undefined, callback: (element: Node) => element is T): T | undefined;
+export declare function findAncestor(node: Node | undefined, callback: (element: Node) => boolean | "quit"): Node | undefined;
+/**
+ * Calls `callback` for each entry in the map, returning the first truthy result.
+ * Use `map.forEach` instead for normal iteration.
+ */
+export declare function forEachEntry<T, U>(map: ReadonlyUnderscoreEscapedMap<T>, callback: (value: T, key: __String) => U | undefined): U | undefined;
+export declare function forEachEntry<T, U>(map: ReadonlyMap<T>, callback: (value: T, key: string) => U | undefined): U | undefined;
+/** `forEachEntry` for just keys. */
+export declare function forEachKey<T>(map: ReadonlyUnderscoreEscapedMap<unknown>, callback: (key: __String) => T | undefined): T | undefined;
+export declare function forEachKey<T>(map: ReadonlyMap<unknown>, callback: (key: string) => T | undefined): T | undefined;
+/** Copy entries from `source` to `target`. */
+export declare function copyEntries<T>(source: ReadonlyUnderscoreEscapedMap<T>, target: UnderscoreEscapedMap<T>): void;
+export declare function copyEntries<T>(source: ReadonlyMap<T>, target: Map<T>): void;
+/** O conjunto dos elementos de um array, ou das chaves que o `makeKey` dá a eles. */
+export declare function arrayToSet(array: readonly string[]): Map<true>;
+export declare function arrayToSet<T>(array: readonly T[], makeKey: (value: T) => string | undefined): Map<true>;
+export declare function arrayToSet<T>(array: readonly T[], makeKey: (value: T) => __String | undefined): UnderscoreEscapedMap<true>;
+export declare function cloneMap(map: SymbolTable): SymbolTable;
+export declare function cloneMap<T>(map: ReadonlyMap<T>): Map<T>;
+export declare function cloneMap<T>(map: ReadonlyUnderscoreEscapedMap<T>): UnderscoreEscapedMap<T>;
+export declare function getFullWidth(node: Node): number;
+export declare function getResolvedModule(sourceFile: SourceFile | undefined, moduleNameText: string): ResolvedModuleFull | undefined;
+export declare function setResolvedModule(sourceFile: SourceFile, moduleNameText: string, resolvedModule: ResolvedModuleFull): void;
+export declare function containsParseError(node: Node): boolean;
+/** O id do nó, dado na primeira vez que alguém pede: indexa as tabelas laterais do binder e do checker. */
+export declare function getNodeId(node: Node): number;
+export declare function getSourceFileOfNode(node: Node): SourceFile;
+export declare function getSourceFileOfNode(node: Node | undefined): SourceFile | undefined;
+export declare function getStartPositionOfLine(line: number, sourceFile: SourceFileLike): number;
+export declare function getEndLinePosition(line: number, sourceFile: SourceFileLike): number;
+export declare function nodeIsMissing(node: Node | undefined): boolean;
+export declare function nodeIsPresent(node: Node | undefined): boolean;
+/**
+ * Determine if the given comment is a triple-slash
+ *
+ * @return true if the comment is a triple-slash comment else false
+ */
+export declare function isRecognizedTripleSlashComment(text: string, commentPos: number, commentEnd: number): boolean;
+export declare function isPinnedComment(text: string, start: number): boolean;
+export declare function getTokenPosOfNode(node: Node, sourceFile?: SourceFileLike): number;
+export declare function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node, includeTrivia?: boolean): string;
+export declare function getTextOfNodeFromSourceText(sourceText: string, node: Node, includeTrivia?: boolean): string;
+export declare function getTextOfNode(node: Node, includeTrivia?: boolean): string;
+/**
+ * Note: it is expected that the `nodeArray` and the `node` are within the same file.
+ * For example, searching for a `SourceFile` in a `SourceFile[]` wouldn't work.
+ */
+export declare function indexOfNode(nodeArray: readonly Node[], node: Node): number;
+/**
+ * Gets flags that control emit behavior of a node.
+ */
+export declare function getEmitFlags(node: Node): EmitFlags;
+export declare function getLiteralText(node: LiteralLikeNode, sourceFile: SourceFile, neverAsciiEscape: boolean | undefined, jsxAttributeEscape: boolean): string;
+export declare function makeIdentifierFromModuleName(moduleName: string): string;
+export declare function isBlockOrCatchScoped(declaration: Declaration): boolean;
+export declare function isCatchClauseVariableDeclarationOrBindingElement(declaration: Declaration): boolean;
+/** O módulo ambiente é só o `declare global`: o de nome em string (`declare module "x"`) saiu (CK-02, princípio 4). */
+export declare function isAmbientModule(node: Node): node is AmbientModuleDeclaration;
+/**
+ * An effective module (namespace) declaration is either
+ * 1. An actual declaration: namespace X { ... }
+ * 2. A Javascript declaration, which is:
+ *    An identifier in a nested property access expression: Y in `X.Y.Z = { ... }`
+ */
+export declare function isEffectiveModuleDeclaration(node: Node): node is Identifier | ModuleDeclaration;
+export declare function isGlobalScopeAugmentation(module: ModuleDeclaration): boolean;
+export declare function isExternalModuleAugmentation(node: Node): node is AmbientModuleDeclaration;
+export declare function isModuleAugmentationExternal(node: AmbientModuleDeclaration): boolean;
+export declare function getNonAugmentationDeclaration(symbol: Symbol): Declaration | undefined;
+export declare function isBlockScope(node: Node, parentNode: Node): boolean;
+/** Na tag, também o callback, o typedef e a assinatura do JSDoc, que têm parâmetros de tipo sem filhos (CK-03). */
+export declare function isDeclarationWithTypeParameters(node: Node): node is DeclarationWithTypeParameters;
+export declare function isDeclarationWithTypeParameterChildren(node: Node): node is DeclarationWithTypeParameterChildren;
+export declare function isAnyImportSyntax(node: Node): node is AnyImportSyntax;
+export declare function isLateVisibilityPaintedStatement(node: Node): node is LateVisibilityPaintedStatement;
+export declare function isAnyImportOrReExport(node: Node): node is AnyImportOrReExport;
+export declare function getEnclosingBlockScopeContainer(node: Node): Node;
+export declare function declarationNameToString(name: DeclarationName | QualifiedName | undefined): string;
+export declare function isComputedNonLiteralName(name: PropertyName): boolean;
+export declare function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): DiagnosticWithLocation;
+export declare function createDiagnosticForNodeArray(sourceFile: SourceFile, nodes: NodeArray<Node>, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): DiagnosticWithLocation;
+export declare function createDiagnosticForNodeInSourceFile(sourceFile: SourceFile, node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): DiagnosticWithLocation;
+export declare function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain, relatedInformation?: DiagnosticRelatedInformation[]): DiagnosticWithLocation;
+export declare function createDiagnosticForRange(sourceFile: SourceFile, range: TextRange, message: DiagnosticMessage): DiagnosticWithLocation;
+export declare function getSpanOfTokenAtPosition(sourceFile: SourceFile, pos: number): TextSpan;
+export declare function getErrorSpanForNode(sourceFile: SourceFile, node: Node): TextSpan;
+export declare function isExternalOrCommonJsModule(file: SourceFile): boolean;
+export declare function isJsonSourceFile(file: SourceFile): file is JsonSourceFile;
+export declare function isDeclarationReadonly(declaration: Declaration): boolean;
+export declare function isVarConst(node: VariableDeclaration | VariableDeclarationList): boolean;
+export declare function isLet(node: Node): boolean;
+export declare function isImportCall(n: Node): n is ImportCall;
+export declare function isImportMeta(n: Node): n is ImportMetaProperty;
+export declare function isLiteralImportTypeNode(n: Node): n is LiteralImportTypeNode;
+export declare function isPrologueDirective(node: Node): node is PrologueDirective;
+export declare function isCustomPrologue(node: Statement): boolean;
+export declare function isHoistedVariableStatement(node: Statement): boolean;
+export declare function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode: SourceFile): import("./types.js").CommentRange[] | undefined;
+export declare function isPartOfTypeNode(node: Node): boolean;
+export declare function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T | undefined;
+export declare function getMembersOfDeclaration(node: Declaration): NodeArray<TypeElement | ObjectLiteralElement> | undefined;
+export declare function isVariableLike(node: Node): node is VariableLikeDeclaration;
+export declare function isFunctionBlock(node: Node): boolean;
+export declare function getContainingFunction(node: Node): SignatureDeclaration | undefined;
+export declare function getContainingFunctionDeclaration(node: Node): FunctionLikeDeclaration | undefined;
+export declare function getThisContainer(node: Node, includeArrowFunctions: boolean): Node;
+export declare function getImmediatelyInvokedFunctionExpression(func: Node): CallExpression | undefined;
+/** O nome de uma referência de tipo. Na tag, também o de um `extends` ou de um `implements` (CK-02). */
+export declare function getEntityNameFromTypeNode(node: TypeNode): EntityNameOrEntityNameExpression | undefined;
+/** A expressão chamada: a de uma chamada, ou a tag de um elemento JSX. Na tag, também a de um template marcado (CK-02). */
+export declare function getInvokedExpression(node: CallLikeExpression): Expression;
+export declare function isJSXTagName(node: Node): boolean;
+export declare function isExpressionNode(node: Node): boolean;
+export declare function isInExpressionContext(node: Node): boolean;
+export declare function isPartOfTypeQuery(node: Node): boolean;
+export declare function isSourceFileJS(file: SourceFile): boolean;
+export declare function isInJSFile(node: Node | undefined): boolean;
+/**
+ * Returns true if the node is a CallExpression to the identifier 'require' with
+ * exactly one argument (of the form 'require("name")').
+ * This function does not test if the node is in a JavaScript file or not.
+ */
+export declare function isRequireCall(callExpression: Node, requireStringLiteralLikeArgument: true): callExpression is RequireOrImportCall & {
+    expression: Identifier;
+    arguments: [StringLiteralLike];
+};
+export declare function isRequireCall(callExpression: Node, requireStringLiteralLikeArgument: boolean): callExpression is CallExpression;
+export declare function isSingleOrDoubleQuote(charCode: number): charCode is CharacterCodes.doubleQuote | CharacterCodes.singleQuote;
+export declare function isStringDoubleQuoted(str: StringLiteralLike, sourceFile: SourceFile): boolean;
+export declare function isAssignmentDeclaration(decl: Declaration): decl is Identifier | CallExpression | PropertyAccessExpression | BinaryExpression;
+export declare function getEffectiveInitializer(node: HasExpressionInitializer): Expression | undefined;
+/**
+ * Os inicializadores de expando reconhecidos: a arrow chamada na hora (`(() => {})()`), a arrow, o object literal vazio
+ * e, quando inicializa um protótipo, o object literal com membros.
+ *
+ * Devolve o inicializador, ou `undefined` se ele não for um desses.
+ */
+export declare function getExpandoInitializer(initializer: Node, isPrototypeAssignment: boolean): Expression | undefined;
+export declare function isDefaultedExpandoInitializer(node: BinaryExpression): boolean | undefined;
+export declare function isExportsIdentifier(node: Node): boolean;
+export declare function isModuleIdentifier(node: Node): boolean;
+export declare function isModuleExportsAccessExpression(node: Node): node is LiteralLikeElementAccessExpression & {
+    expression: Identifier;
+};
+export declare function getAssignmentDeclarationKind(expr: BinaryExpression | CallExpression): AssignmentDeclarationKind;
+export declare function isBindableObjectDefinePropertyCall(expr: CallExpression): expr is BindableObjectDefinePropertyCall;
+/** x.y OR x[0] */
+export declare function isLiteralLikeAccess(node: Node): node is LiteralLikeElementAccessExpression | PropertyAccessExpression;
+/** x[0] OR x['a'] OR x[Symbol.y] */
+export declare function isLiteralLikeElementAccess(node: Node): node is LiteralLikeElementAccessExpression;
+/** Any series of property and element accesses. */
+export declare function isBindableStaticAccessExpression(node: Node): node is BindableStaticAccessExpression;
+/** Any series of property and element accesses, ending in a literal element access */
+export declare function isBindableStaticElementAccessExpression(node: Node): node is BindableStaticElementAccessExpression;
+export declare function isBindableStaticNameExpression(node: Node): node is BindableStaticNameExpression;
+export declare function getNameOrArgument(expr: PropertyAccessExpression | LiteralLikeElementAccessExpression): Identifier | (Expression & (NumericLiteral | StringLiteralLike | WellKnownSymbolExpression));
+/**
+ * Does not handle signed numeric names like `a[+0]` - handling those would require handling prefix unary expressions
+ * throughout late binding handling as well, which is awkward (but ultimately probably doable if there is demand)
+ */
+export declare function getElementOrPropertyAccessArgumentExpressionOrName(node: AccessExpression): Identifier | StringLiteralLike | NumericLiteral | ElementAccessExpression | undefined;
+export declare function getElementOrPropertyAccessName(node: LiteralLikeElementAccessExpression | PropertyAccessExpression): __String;
+export declare function getElementOrPropertyAccessName(node: AccessExpression): __String | undefined;
+export declare function getAssignmentDeclarationPropertyAccessKind(lhs: AccessExpression): AssignmentDeclarationKind;
+export declare function getInitializerOfBinaryExpression(expr: BinaryExpression): Expression;
+export declare function setValueDeclaration(symbol: Symbol, node: Declaration): void;
+export declare function importFromModuleSpecifier(node: StringLiteralLike): AnyValidImportOrReExport;
+export declare function tryGetImportFromModuleSpecifier(node: StringLiteralLike): AnyValidImportOrReExport | undefined;
+export declare function getExternalModuleName(node: AnyImportOrReExport | ImportTypeNode): Expression | undefined;
+/** Na tag, também o `import =` (CK-03), que nunca é import default. */
+export declare function isDefaultImport(node: ImportDeclaration | ExportDeclaration): boolean;
+export declare function hasQuestionToken(node: Node): boolean;
+/** Na tag, também o inicializador de uma propriedade de classe (CK-02). */
+export declare function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node: Node): Expression | undefined;
+export declare function hasRestParameter(s: SignatureDeclaration): boolean;
+export declare function isRestParameter(node: ParameterDeclaration): boolean;
+export declare enum AssignmentKind {
+    None = 0,
+    Definite = 1,
+    Compound = 2
+}
+export declare function getAssignmentTargetKind(node: Node): AssignmentKind;
+export declare function isAssignmentTarget(node: Node): boolean;
+export declare function walkUpParenthesizedExpressions(node: Node): Node;
+export declare function skipParentheses(node: Expression): Expression;
+export declare function skipParentheses(node: Node): Node;
+export declare function isDeleteTarget(node: Node): boolean;
+export declare function isNodeDescendantOf(node: Node, ancestor: Node | undefined): boolean;
+export declare function isDeclarationName(name: Node): boolean;
+/**
+ * A declaração de que o nome é o nome. Na tag, também o parâmetro do JSDoc num nome qualificado (CK-03) e o nome
+ * `#private` (CK-02).
+ */
+export declare function getDeclarationFromName(name: Node): Declaration | undefined;
+export declare function isLiteralComputedPropertyDeclarationName(node: Node): boolean;
+export declare function isIdentifierName(node: Identifier): boolean;
+/**
+ * A declaração que cria um símbolo alias: `import x from`, `import * as x from`, `import { a as x } from`,
+ * `export { a as x }`, `export * as x from`, `export default` de um nome, e o shorthand e a propriedade de objeto cujo
+ * valor é um nome.
+ */
+export declare function isAliasSymbolDeclaration(node: Node): boolean;
+export declare function getAliasDeclarationFromName(node: EntityName): Declaration | undefined;
+export declare function isAliasableExpression(e: Expression): e is EntityNameExpression;
+export declare function exportAssignmentIsAlias(node: ExportAssignment | BinaryExpression): boolean;
+export declare function getExportAssignmentExpression(node: ExportAssignment | BinaryExpression): Expression;
+export declare function getAncestor(node: Node | undefined, kind: SyntaxKind): Node | undefined;
+export declare function isKeyword(token: SyntaxKind): boolean;
+export declare function isContextualKeyword(token: SyntaxKind): boolean;
+export declare function isNonContextualKeyword(token: SyntaxKind): boolean;
+export declare function isStringANonContextualKeyword(name: string): boolean;
+export declare function isIdentifierANonContextualKeyword({ originalKeywordKind }: Identifier): boolean;
+export type TriviaKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia;
+export declare function isTrivia(token: SyntaxKind): token is TriviaKind;
+export declare enum FunctionFlags {
+    Normal = 0,// Function is a normal function
+    Async = 2,// Function is an async function
+    Invalid = 4
+}
+export declare function getFunctionFlags(node: SignatureDeclaration | undefined): FunctionFlags;
+export declare function isAsyncFunction(node: Node): boolean;
+export declare function isStringOrNumericLiteralLike(node: Node): node is StringLiteralLike | NumericLiteral;
+export declare function isSignedNumericLiteral(node: Node): node is PrefixUnaryExpression & {
+    operand: NumericLiteral;
+};
+/**
+ * A declaration has a dynamic name if all of the following are true:
+ *   1. The declaration has a computed property name.
+ *   2. The computed name is *not* expressed as a StringLiteral.
+ *   3. The computed name is *not* expressed as a NumericLiteral.
+ *   4. The computed name is *not* expressed as a PlusToken or MinusToken
+ *      immediately followed by a NumericLiteral.
+ *   5. The computed name is *not* expressed as `Symbol.<name>`, where `<name>`
+ *      is a property of the Symbol constructor that denotes a built-in
+ *      Symbol.
+ */
+export declare function hasDynamicName(declaration: Declaration): declaration is DynamicNamedDeclaration | DynamicNamedBinaryExpression;
+export declare function isDynamicName(name: DeclarationName): boolean;
+/**
+ * Checks if the expression is of the form:
+ *    Symbol.name
+ * where Symbol is literally the word "Symbol", and name is any identifierName
+ */
+export declare function isWellKnownSymbolSyntactically(node: Node): node is WellKnownSymbolExpression;
+export declare function getPropertyNameForPropertyNameNode(name: PropertyName): __String | undefined;
+export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral;
+export declare function isPropertyNameLiteral(node: Node): node is PropertyNameLiteral;
+export declare function getTextOfIdentifierOrLiteral(node: PropertyNameLiteral): string;
+export declare function getEscapedTextOfIdentifierOrLiteral(node: PropertyNameLiteral): __String;
+export declare function getPropertyNameForKnownSymbolName(symbolName: string): __String;
+export declare function isKnownSymbol(symbol: Symbol): boolean;
+/**
+ * Includes the word "Symbol" with unicode escapes
+ */
+export declare function isESSymbolIdentifier(node: Node): boolean;
+export declare function isParameterDeclaration(node: Node): boolean;
+export declare function getRootDeclaration(node: Node): Node;
+export declare function nodeIsSynthesized(range: TextRange): boolean;
+export declare enum Associativity {
+    Left = 0,
+    Right = 1
+}
+export declare function getExpressionAssociativity(expression: Expression): Associativity;
+export declare function getOperatorAssociativity(kind: SyntaxKind, operator: SyntaxKind): Associativity;
+export declare function getExpressionPrecedence(expression: Expression): number;
+export declare function getOperator(expression: Expression): SyntaxKind;
+export declare function getOperatorPrecedence(nodeKind: SyntaxKind, operatorKind: SyntaxKind): number;
+export declare function getBinaryOperatorPrecedence(kind: SyntaxKind): number;
+/**
+ * Based heavily on the abstract 'Quote'/'QuoteJSONString' operation from ECMA-262 (24.3.2.2),
+ * but augmented for a few select characters (e.g. lineSeparator, paragraphSeparator, nextLine)
+ * Note that this doesn't actually wrap the input in double quotes.
+ */
+export declare function escapeString(s: string, quoteChar?: CharacterCodes.doubleQuote | CharacterCodes.singleQuote | CharacterCodes.backtick): string;
+export declare function escapeNonAsciiString(s: string, quoteChar?: CharacterCodes.doubleQuote | CharacterCodes.singleQuote | CharacterCodes.backtick): string;
+export declare function escapeJsxAttributeString(s: string, quoteChar?: CharacterCodes.doubleQuote | CharacterCodes.singleQuote): string;
+/** O texto sem as aspas simples, as duplas ou as crases que o cercam, quando as duas pontas são iguais. */
+export declare function stripQuotes(name: string): string;
+export declare function isIntrinsicJsxName(name: __String | string): boolean;
+export declare function getIndentString(level: number): string;
+export declare function getIndentSize(): number;
+export declare function hostUsesCaseSensitiveFileNames(host: {
+    useCaseSensitiveFileNames?(): boolean;
+}): boolean;
+export declare function getLineOfLocalPosition(sourceFile: SourceFile, pos: number): number;
+export declare function getLineOfLocalPositionFromLineMap(lineMap: readonly number[], pos: number): number;
+/** A anotação de tipo de uma variável, de um parâmetro ou de uma propriedade. */
+export declare function getEffectiveTypeAnnotationNode(node: Node): TypeNode | undefined;
+/** A anotação do retorno de uma assinatura. */
+export declare function getEffectiveReturnTypeNode(node: SignatureDeclaration): TypeNode | undefined;
+export declare function hasModifiers(node: Node): boolean;
+export declare function hasModifier(node: Node, flags: ModifierFlags): boolean;
+export declare function hasReadonlyModifier(node: Node): boolean;
+export declare function getSelectedModifierFlags(node: Node, flags: ModifierFlags): ModifierFlags;
+export declare function getModifierFlags(node: Node): ModifierFlags;
+export declare function getModifierFlagsNoCache(node: Node): ModifierFlags;
+export declare function modifierToFlag(token: SyntaxKind): ModifierFlags;
+export declare function isAssignmentOperator(token: SyntaxKind): boolean;
+export declare function isAssignmentExpression(node: Node, excludeCompoundAssignment: true): node is AssignmentExpression<EqualsToken>;
+export declare function isAssignmentExpression(node: Node, excludeCompoundAssignment?: false): node is AssignmentExpression<AssignmentOperatorToken>;
+export declare function isEntityNameExpression(node: Node): node is EntityNameExpression;
+export declare function getFirstIdentifier(node: EntityNameOrEntityNameExpression): Identifier;
+export declare function isDottedName(node: Expression): boolean;
+export declare function isPropertyAccessEntityNameExpression(node: Node): node is PropertyAccessEntityNameExpression;
+export declare function tryGetPropertyAccessOrIdentifierToString(expr: Expression): string | undefined;
+export declare function isPrototypeAccess(node: Node): node is BindableStaticAccessExpression;
+export declare function isRightSideOfQualifiedNameOrPropertyAccess(node: Node): boolean;
+export declare function isEmptyArrayLiteral(expression: Node): boolean;
+/** Return ".ts", ".d.ts", or ".tsx", if that is the extension. */
+export declare function tryExtractTSExtension(fileName: string): string | undefined;
+export declare function createRange(pos: number, end?: number): TextRange;
+export declare function rangeIsOnSingleLine(range: TextRange, sourceFile: SourceFile): boolean;
+export declare function rangeStartPositionsAreOnSameLine(range1: TextRange, range2: TextRange, sourceFile: SourceFile): boolean;
+export declare function rangeEndPositionsAreOnSameLine(range1: TextRange, range2: TextRange, sourceFile: SourceFile): boolean;
+export declare function rangeStartIsOnSameLineAsRangeEnd(range1: TextRange, range2: TextRange, sourceFile: SourceFile): boolean;
+export declare function rangeEndIsOnSameLineAsRangeStart(range1: TextRange, range2: TextRange, sourceFile: SourceFile): boolean;
+export declare function getLinesBetweenRangeEndAndRangeStart(range1: TextRange, range2: TextRange, sourceFile: SourceFile, includeSecondRangeComments: boolean): number;
+export declare function isNodeArrayMultiLine(list: NodeArray<Node>, sourceFile: SourceFile): boolean;
+export declare function positionsAreOnSameLine(pos1: number, pos2: number, sourceFile: SourceFile): boolean;
+export declare function getStartPositionOfRange(range: TextRange, sourceFile: SourceFile, includeComments: boolean): number;
+export declare function getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(pos: number, stopPos: number, sourceFile: SourceFile, includeComments?: boolean): number;
+export declare function getLinesBetweenPositionAndNextNonWhitespaceCharacter(pos: number, stopPos: number, sourceFile: SourceFile, includeComments?: boolean): number;
+/**
+ * Os modificadores da declaração de valor do símbolo. A propriedade sintética de uma união e o protótipo não têm
+ * declaração, e a acessibilidade e o `static` que o `tsc` dava a eles eram da classe.
+ */
+export declare function getDeclarationModifierFlagsFromSymbol(s: Symbol): ModifierFlags;
+/**
+ * As flags do símbolo somadas às do exportado dele: o membro exportado de um módulo ganha um símbolo local só com o
+ * `ExportValue`, e as flags de verdade ficam no de exportação (o `declareModuleMember` do binder).
+ */
+export declare function getCombinedLocalAndExportSymbolFlags(symbol: Symbol): SymbolFlags;
+export declare function isWriteOnlyAccess(node: Node): boolean;
+export declare function isWriteAccess(node: Node): boolean;
+export declare function compareDataObjects(dst: any, src: any): boolean;
+export declare function showModuleSpecifier({ moduleSpecifier }: ImportDeclaration): string;
+export declare function getLastChild(node: Node): Node | undefined;
+/** Põe a chave no mapa, com o valor ou `true`, e diz se ela ainda não estava lá. */
+export declare function addToSeen(seen: Map<true>, key: string | number): boolean;
+export declare function addToSeen<T>(seen: Map<T>, key: string | number, value: T): boolean;
+export declare function isObjectTypeDeclaration(node: Node): node is ObjectTypeDeclaration;
+export declare function isTypeNodeKind(kind: SyntaxKind): boolean;
+export declare function isAccessExpression(node: Node): node is AccessExpression;
+export declare function isNamedImportsOrExports(node: Node): node is NamedImportsOrExports;
+export interface ObjectAllocator {
+    getNodeConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Node;
+    getTokenConstructor(): new <TKind extends SyntaxKind>(kind: TKind, pos?: number, end?: number) => Token<TKind>;
+    getIdentifierConstructor(): new (kind: SyntaxKind.Identifier, pos?: number, end?: number) => Identifier;
+    getSourceFileConstructor(): new (kind: SyntaxKind.SourceFile, pos?: number, end?: number) => SourceFile;
+    getSymbolConstructor(): new (flags: SymbolFlags, name: __String) => Symbol;
+    getSourceMapSourceConstructor(): new (fileName: string, text: string, skipTrivia?: (pos: number) => number) => SourceMapSource;
+}
+declare function Symbol(this: Symbol, flags: SymbolFlags, name: __String): void;
+declare function Node(this: Node, kind: SyntaxKind, pos: number, end: number): void;
+declare function Token(this: Node, kind: SyntaxKind, pos: number, end: number): void;
+declare function Identifier(this: Node, kind: SyntaxKind, pos: number, end: number): void;
+declare function SourceMapSource(this: SourceMapSource, fileName: string, text: string, skipTrivia?: (pos: number) => number): void;
+export declare let objectAllocator: ObjectAllocator;
+/**
+ * Troca os construtores da árvore. O language service troca os de cada nó e o do símbolo pelos dele, que têm os métodos
+ * que os serviços chamam (`node.getStart()`, `symbol.getDocumentationComment()`), ao carregar.
+ */
+export declare function setObjectAllocator(alloc: ObjectAllocator): void;
+export declare function formatStringFromArgs(text: string, args: ArrayLike<string | number>, baseIndex?: number): string;
+export declare let localizedDiagnosticMessages: MapLike<string> | undefined;
+export declare function setLocalizedDiagnosticMessages(messages: typeof localizedDiagnosticMessages): void;
+export declare function getLocaleSpecificMessage(message: DiagnosticMessage): string;
+export declare function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ...args: (string | number | undefined)[]): DiagnosticWithLocation;
+export declare function formatMessage(_dummy: any, message: DiagnosticMessage, ...args: (string | number | undefined)[]): string;
+export declare function createCompilerDiagnostic(message: DiagnosticMessage, ...args: (string | number | undefined)[]): Diagnostic;
+export declare function chainDiagnosticMessages(details: DiagnosticMessageChain | DiagnosticMessageChain[] | undefined, message: DiagnosticMessage, ...args: (string | number | undefined)[]): DiagnosticMessageChain;
+export declare function concatenateDiagnosticMessageChains(headChain: DiagnosticMessageChain, tailChain: DiagnosticMessageChain): void;
+/** O texto inteiro de uma mensagem encadeada: cada elo numa linha, indentado de dois em dois espaços pela profundidade. */
+export declare function flattenDiagnosticMessageText(diag: string | DiagnosticMessageChain | undefined, newLine: string, indent?: number): string;
+export declare function compareDiagnostics(d1: Diagnostic, d2: Diagnostic): Comparison;
+export declare function compareDiagnosticsSkipRelatedInformation(d1: Diagnostic, d2: Diagnostic): Comparison;
+export declare function unreachableCodeIsError(options: CompilerOptions): boolean;
+export declare function tryRemoveDirectoryPrefix(path: string, dirPath: string, getCanonicalFileName: GetCanonicalFileName): string | undefined;
+export declare function ensureScriptKind(fileName: string, scriptKind: ScriptKind | undefined): ScriptKind;
+export declare function getScriptKindFromFileName(fileName: string): ScriptKind;
+/** Must have ".d.ts" first because if ".ts" goes first, that will be detected as the extension instead of ".d.ts". */
+export declare const supportedTSExtensionsForExtractExtension: readonly Extension[];
+export declare const supportedJSExtensions: readonly Extension[];
+export declare function hasJSFileExtension(fileName: string): boolean;
+export declare function removeFileExtension(path: string): string;
+export declare function tryRemoveExtension(path: string, extension: string): string | undefined;
+export declare function removeExtension(path: string, extension: string): string;
+export declare function positionIsSynthesized(pos: number): boolean;
+/** True if an extension is one of the supported TypeScript extensions. */
+export declare function extensionIsTS(ext: Extension): boolean;
+export declare function resolutionExtensionIsTSOrJson(ext: Extension): boolean;
+/**
+ * O diagnóstico de um módulo resolvido que a extensão não deixa entrar no programa, ou `undefined`. Os parâmetros dele
+ * são o nome do módulo importado e o arquivo a que resolveu; vale também para o módulo que fica sem tipo.
+ */
+export declare function getResolutionDiagnostic({ extension }: ResolvedModuleFull): DiagnosticMessage | undefined;
+/**
+ * Gets the extension from a path.
+ * Path must have a valid extension.
+ */
+export declare function extensionFromPath(path: string): Extension;
+export declare function tryGetExtensionFromPath(path: string): Extension | undefined;
+export type Mutable<T extends object> = {
+    -readonly [K in keyof T]: T[K];
+};
+export declare function sliceAfter<T>(arr: readonly T[], value: T): readonly T[];
+export declare function addRelatedInfo<T extends Diagnostic>(diagnostic: T, ...relatedInformation: DiagnosticRelatedInformation[]): T;
+export declare function minAndMax<T>(arr: readonly T[], getValue: (value: T) => number): {
+    readonly min: number;
+    readonly max: number;
+};
+export interface ReadonlyNodeSet<TNode extends Node> {
+    has(node: TNode): boolean;
+    forEach(cb: (node: TNode) => void): void;
+    some(pred: (node: TNode) => boolean): boolean;
+}
+export declare class NodeSet<TNode extends Node> implements ReadonlyNodeSet<TNode> {
+    private map;
+    add(node: TNode): void;
+    tryAdd(node: TNode): boolean;
+    has(node: TNode): boolean;
+    forEach(cb: (node: TNode) => void): void;
+    some(pred: (node: TNode) => boolean): boolean;
+}
+export interface ReadonlyNodeMap<TNode extends Node, TValue> {
+    get(node: TNode): TValue | undefined;
+    has(node: TNode): boolean;
+}
+export declare class NodeMap<TNode extends Node, TValue> implements ReadonlyNodeMap<TNode, TValue> {
+    private map;
+    get(node: TNode): TValue | undefined;
+    getOrUpdate(node: TNode, setValue: () => TValue): TValue;
+    set(node: TNode, value: TValue): void;
+    has(node: TNode): boolean;
+    forEach(cb: (value: TValue, node: TNode) => void): void;
+}
+export declare function rangeOfNode(node: Node): TextRange;
+export declare function rangeOfTypeParameters(typeParameters: NodeArray<TypeParameterDeclaration>): TextRange;
+/**
+ * Se o arquivo fica sem checagem: o que tem a diretiva `/// <reference no-default-lib="true"/>`, a lib, que se usa e
+ * não se checa (o `skipDefaultLibCheck` da configuração fixa, CK-24; o `skipLibCheck` é desligado).
+ */
+export declare function skipTypeChecking(sourceFile: SourceFile): boolean;
+export declare function getOrUpdate<T>(map: Map<T>, key: string, getDefault: () => T): T;
+/**
+ * Converts a bigint literal string, e.g. `0x1234n`,
+ * to its decimal string representation, e.g. `4660`.
+ */
+export declare function parsePseudoBigInt(stringValue: string): string;
+export declare function pseudoBigIntToString({ negative, base10Value }: PseudoBigInt): string;
+export declare function isValidTypeOnlyAliasUseSite(useSite: Node): boolean;
+export declare function typeOnlyDeclarationIsExport(typeOnlyDeclaration: Node): boolean;
+export declare function isIdentifierTypeReference(node: Node): node is TypeReferenceNode & {
+    typeName: Identifier;
+};
+export declare function arrayIsHomogeneous<T>(array: readonly T[], comparer?: EqualityComparer<T>): boolean;
+export {};