@tslite/parser 1.9.0 → 1.12.0

package/dist/utilitiesPublic.d.ts

@@ -0,0 +1,274 @@
+import { ModifierFlags, NodeFlags, SyntaxKind } from "./_namespaces/ts.js";
+import type { ArrayBindingElement, ArrayBindingPattern, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AssertionExpression, AssignmentPattern, AwaitExpression, BigIntLiteral, BinaryExpression, BindingElement, BindingName, BindingOrAssignmentElement, BindingPattern, Block, BreakOrContinueStatement, CallChain, CallExpression, CallLikeExpression, CallSignatureDeclaration, CaseBlock, CaseClause, CaseOrDefaultClause, CatchClause, CompilerOptions, ComputedPropertyName, ConciseBody, ConditionalTypeNode, Declaration, DeclarationName, DeclarationWithTypeParameters, DefaultClause, DeleteExpression, Diagnostic, ElementAccessChain, ElementAccessExpression, EmptyStatement, EntityName, ExportAssignment, ExportDeclaration, ExportSpecifier, Expression, ExpressionStatement, ForInOrOfStatement, ForInStatement, ForInitializer, ForOfStatement, FunctionLikeDeclaration, FunctionTypeNode, GeneratedIdentifier, HasInitializer, HasType, Identifier, IfStatement, ImportClause, ImportDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, IterationStatement, JsxAttribute, JsxAttributeLike, JsxAttributes, JsxChild, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxOpeningElement, JsxOpeningFragment, JsxOpeningLikeElement, JsxSelfClosingElement, JsxSpreadAttribute, JsxTagNameExpression, JsxText, LeftHandSideExpression, LiteralExpression, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodSignature, Modifier, ModuleBlock, ModuleBody, ModuleDeclaration, NamedDeclaration, NamedExportBindings, NamedExports, NamedImportBindings, NamedImports, NamespaceExport, NamespaceImport, NoSubstitutionTemplateLiteral, Node, NodeArray, NotEmittedStatement, NumericLiteral, ObjectBindingPattern, ObjectLiteralElement, ObjectLiteralElementLike, ObjectLiteralExpression, OmittedExpression, OptionalChain, OptionalChainRoot, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessChain, PropertyAccessExpression, PropertyAssignment, PropertyName, PropertySignature, QualifiedName, ReturnStatement, ShorthandPropertyAssignment, SignatureDeclaration, SortedReadonlyArray, SourceFile, SpreadAssignment, SpreadElement, Statement, StringLiteral, StringLiteralLike, SwitchStatement, Symbol, SyntaxList, TemplateHead, TemplateLiteral, TemplateMiddle, TemplateSpan, TemplateTail, TextChangeRange, TextSpan, ThrowStatement, TryStatement, TypeAliasDeclaration, TypeElement, TypeLiteralNode, TypeNode, TypeOfExpression, TypeOnlyCompatibleAliasDeclaration, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnaryExpression, UnionTypeNode, UnparsedNode, UnparsedPrepend, UnparsedSource, UnparsedTextLike, VariableDeclaration, VariableDeclarationList, VariableStatement, __String } from "./_namespaces/ts.js";
+export declare function isExternalModuleNameRelative(moduleName: string): boolean;
+export declare function sortAndDeduplicateDiagnostics<T extends Diagnostic>(diagnostics: readonly T[]): SortedReadonlyArray<T>;
+export declare function getDefaultLibFileName(options: CompilerOptions): string;
+export declare function textSpanEnd(span: TextSpan): number;
+export declare function textSpanIsEmpty(span: TextSpan): boolean;
+export declare function textSpanContainsPosition(span: TextSpan, position: number): boolean;
+export declare function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean;
+export declare function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean;
+export declare function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean;
+export declare function createTextSpan(start: number, length: number): TextSpan;
+export declare function createTextSpanFromBounds(start: number, end: number): TextSpan;
+export declare function textChangeRangeNewSpan(range: TextChangeRange): TextSpan;
+export declare function textChangeRangeIsUnchanged(range: TextChangeRange): boolean;
+export declare function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange;
+export declare function isEmptyBindingPattern(node: BindingName): node is BindingPattern;
+export declare function isEmptyBindingElement(node: BindingElement | ArrayBindingElement): boolean;
+export declare function walkUpBindingElementsAndPatterns(binding: BindingElement): VariableDeclaration | ParameterDeclaration;
+export declare function getCombinedModifierFlags(node: Declaration): ModifierFlags;
+export declare function getCombinedNodeFlags(node: Node): NodeFlags;
+export declare function getOriginalNode(node: Node): Node;
+export declare function getOriginalNode<T extends Node>(node: Node, nodeTest: (node: Node) => node is T): T;
+export declare function getOriginalNode(node: Node | undefined): Node | undefined;
+export declare function getOriginalNode<T extends Node>(node: Node | undefined, nodeTest: (node: Node) => node is T): T | undefined;
+/**
+ * Gets a value indicating whether a node originated in the parse tree.
+ *
+ * @param node The node to test.
+ */
+export declare function isParseTreeNode(node: Node): boolean;
+/**
+ * Gets the original parse tree node for a node.
+ *
+ * @param node The original node.
+ * @returns The original parse tree node if found; otherwise, undefined.
+ */
+export declare function getParseTreeNode(node: Node): Node;
+/**
+ * Gets the original parse tree node for a node.
+ *
+ * @param node The original node.
+ * @param nodeTest A callback used to ensure the correct type of parse tree node is returned.
+ * @returns The original parse tree node if found; otherwise, undefined.
+ */
+export declare function getParseTreeNode<T extends Node>(node: Node | undefined, nodeTest?: (node: Node) => node is T): T | undefined;
+/** Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' */
+export declare function escapeLeadingUnderscores(identifier: string): __String;
+/**
+ * Remove extra underscore from escaped identifier text content.
+ *
+ * @param identifier The escaped identifier text.
+ * @returns The unescaped identifier text.
+ */
+export declare function unescapeLeadingUnderscores(identifier: __String): string;
+export declare function idText(identifierOrPrivateName: Identifier): string;
+export declare function symbolName(symbol: Symbol): string;
+export declare function nodeHasName(statement: Node, name: Identifier): boolean;
+export declare function isNamedDeclaration(node: Node): node is NamedDeclaration & {
+    name: DeclarationName;
+};
+export declare function getNonAssignedNameOfDeclaration(declaration: Declaration | Expression): DeclarationName | undefined;
+export declare function getNameOfDeclaration(declaration: Declaration | Expression): DeclarationName | undefined;
+/** Os parâmetros de tipo que a declaração escreve. */
+export declare function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters): readonly TypeParameterDeclaration[];
+/** A constraint que o parâmetro de tipo escreve. */
+export declare function getEffectiveConstraintOfTypeParameter(node: TypeParameterDeclaration): TypeNode | undefined;
+export declare function isNumericLiteral(node: Node): node is NumericLiteral;
+export declare function isBigIntLiteral(node: Node): node is BigIntLiteral;
+export declare function isStringLiteral(node: Node): node is StringLiteral;
+export declare function isJsxText(node: Node): node is JsxText;
+export declare function isTemplateHead(node: Node): node is TemplateHead;
+export declare function isTemplateTail(node: Node): node is TemplateTail;
+export declare function isIdentifier(node: Node): node is Identifier;
+export declare function isQualifiedName(node: Node): node is QualifiedName;
+export declare function isComputedPropertyName(node: Node): node is ComputedPropertyName;
+export declare function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration;
+export declare function isParameter(node: Node): node is ParameterDeclaration;
+export declare function isPropertySignature(node: Node): node is PropertySignature;
+export declare function isMethodSignature(node: Node): node is MethodSignature;
+export declare function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration;
+export declare function isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration;
+export declare function isTypePredicateNode(node: Node): node is TypePredicateNode;
+export declare function isTypeReferenceNode(node: Node): node is TypeReferenceNode;
+export declare function isFunctionTypeNode(node: Node): node is FunctionTypeNode;
+export declare function isTypeQueryNode(node: Node): node is TypeQueryNode;
+export declare function isTypeLiteralNode(node: Node): node is TypeLiteralNode;
+export declare function isArrayTypeNode(node: Node): node is ArrayTypeNode;
+export declare function isUnionTypeNode(node: Node): node is UnionTypeNode;
+export declare function isConditionalTypeNode(node: Node): node is ConditionalTypeNode;
+export declare function isInferTypeNode(node: Node): node is InferTypeNode;
+export declare function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode;
+export declare function isTypeOperatorNode(node: Node): node is TypeOperatorNode;
+export declare function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode;
+export declare function isMappedTypeNode(node: Node): node is MappedTypeNode;
+export declare function isLiteralTypeNode(node: Node): node is LiteralTypeNode;
+export declare function isImportTypeNode(node: Node): node is ImportTypeNode;
+export declare function isObjectBindingPattern(node: Node): node is ObjectBindingPattern;
+export declare function isArrayBindingPattern(node: Node): node is ArrayBindingPattern;
+export declare function isBindingElement(node: Node): node is BindingElement;
+export declare function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression;
+export declare function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression;
+export declare function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression;
+export declare function isPropertyAccessChain(node: Node): node is PropertyAccessChain;
+export declare function isElementAccessExpression(node: Node): node is ElementAccessExpression;
+export declare function isCallExpression(node: Node): node is CallExpression;
+export declare function isCallChain(node: Node): node is CallChain;
+export declare function isOptionalChain(node: Node): node is PropertyAccessChain | ElementAccessChain | CallChain;
+export declare function isOptionalChainRoot(node: Node): node is OptionalChainRoot;
+/**
+ * Determines whether a node is the expression preceding an optional chain (i.e. `a` in `a?.b`).
+ */
+export declare function isExpressionOfOptionalChainRoot(node: Node): node is Expression & {
+    parent: OptionalChainRoot;
+};
+/**
+ * Determines whether a node is the outermost `OptionalChain` in an ECMAScript `OptionalExpression`:
+ *
+ * 1. For `a?.b.c`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.`)
+ * 2. For `a?.b!`, the outermost chain is `a?.b` (`b` is the end of the chain starting at `a?.`)
+ * 3. For `(a?.b.c).d`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.` since parens end the chain)
+ * 4. For `a?.b.c?.d`, both `a?.b.c` and `a?.b.c?.d` are outermost (`c` is the end of the chain starting at `a?.`, and `d` is
+ *   the end of the chain starting at `c?.`)
+ * 5. For `a?.(b?.c).d`, both `b?.c` and `a?.(b?.c)d` are outermost (`c` is the end of the chain starting at `b`, and `d` is
+ *   the end of the chain starting at `a?.`)
+ */
+export declare function isOutermostOptionalChain(node: OptionalChain): boolean;
+export declare function isNullishCoalesce(node: Node): boolean;
+export declare function isParenthesizedExpression(node: Node): node is ParenthesizedExpression;
+export declare function skipPartiallyEmittedExpressions(node: Expression): Expression;
+export declare function skipPartiallyEmittedExpressions(node: Node): Node;
+export declare function isArrowFunction(node: Node): node is ArrowFunction;
+export declare function isDeleteExpression(node: Node): node is DeleteExpression;
+export declare function isTypeOfExpression(node: Node): node is TypeOfExpression;
+export declare function isAwaitExpression(node: Node): node is AwaitExpression;
+export declare function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression;
+export declare function isBinaryExpression(node: Node): node is BinaryExpression;
+export declare function isSpreadElement(node: Node): node is SpreadElement;
+export declare function isOmittedExpression(node: Node): node is OmittedExpression;
+export declare function isAsExpression(node: Node): node is AsExpression;
+export declare function isMetaProperty(node: Node): node is MetaProperty;
+export declare function isTemplateSpan(node: Node): node is TemplateSpan;
+export declare function isBlock(node: Node): node is Block;
+export declare function isVariableStatement(node: Node): node is VariableStatement;
+export declare function isEmptyStatement(node: Node): node is EmptyStatement;
+export declare function isExpressionStatement(node: Node): node is ExpressionStatement;
+export declare function isIfStatement(node: Node): node is IfStatement;
+export declare function isForInStatement(node: Node): node is ForInStatement;
+export declare function isForOfStatement(node: Node): node is ForOfStatement;
+export declare function isBreakOrContinueStatement(node: Node): node is BreakOrContinueStatement;
+export declare function isReturnStatement(node: Node): node is ReturnStatement;
+export declare function isSwitchStatement(node: Node): node is SwitchStatement;
+export declare function isThrowStatement(node: Node): node is ThrowStatement;
+export declare function isTryStatement(node: Node): node is TryStatement;
+export declare function isVariableDeclaration(node: Node): node is VariableDeclaration;
+export declare function isVariableDeclarationList(node: Node): node is VariableDeclarationList;
+export declare function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration;
+export declare function isModuleDeclaration(node: Node): node is ModuleDeclaration;
+export declare function isModuleBlock(node: Node): node is ModuleBlock;
+export declare function isCaseBlock(node: Node): node is CaseBlock;
+export declare function isImportDeclaration(node: Node): node is ImportDeclaration;
+export declare function isImportClause(node: Node): node is ImportClause;
+export declare function isNamespaceImport(node: Node): node is NamespaceImport;
+export declare function isNamespaceExport(node: Node): node is NamespaceExport;
+export declare function isNamedExportBindings(node: Node): node is NamedExportBindings;
+export declare function isNamedImports(node: Node): node is NamedImports;
+export declare function isImportSpecifier(node: Node): node is ImportSpecifier;
+export declare function isExportAssignment(node: Node): node is ExportAssignment;
+export declare function isExportDeclaration(node: Node): node is ExportDeclaration;
+export declare function isNamedExports(node: Node): node is NamedExports;
+export declare function isExportSpecifier(node: Node): node is ExportSpecifier;
+export declare function isJsxElement(node: Node): node is JsxElement;
+export declare function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement;
+export declare function isJsxOpeningElement(node: Node): node is JsxOpeningElement;
+export declare function isJsxClosingElement(node: Node): node is JsxClosingElement;
+export declare function isJsxOpeningFragment(node: Node): node is JsxOpeningFragment;
+export declare function isJsxClosingFragment(node: Node): node is JsxClosingFragment;
+export declare function isJsxAttribute(node: Node): node is JsxAttribute;
+export declare function isJsxAttributes(node: Node): node is JsxAttributes;
+export declare function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute;
+export declare function isJsxExpression(node: Node): node is JsxExpression;
+export declare function isCaseClause(node: Node): node is CaseClause;
+export declare function isDefaultClause(node: Node): node is DefaultClause;
+export declare function isCatchClause(node: Node): node is CatchClause;
+export declare function isPropertyAssignment(node: Node): node is PropertyAssignment;
+export declare function isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment;
+export declare function isSpreadAssignment(node: Node): node is SpreadAssignment;
+export declare function isSourceFile(node: Node): node is SourceFile;
+export declare function isUnparsedSource(node: Node): node is UnparsedSource;
+export declare function isUnparsedPrepend(node: Node): node is UnparsedPrepend;
+export declare function isUnparsedTextLike(node: Node): node is UnparsedTextLike;
+export declare function isUnparsedNode(node: Node): node is UnparsedNode;
+export declare function isSyntaxList(n: Node): n is SyntaxList;
+export declare function isNodeKind(kind: SyntaxKind): boolean;
+/**
+ * True if node is of some token syntax kind.
+ * For example, this is true for an IfKeyword but not for an IfStatement.
+ * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail.
+ */
+export declare function isToken(n: Node): boolean;
+export declare function isNodeArray<T extends Node>(array: readonly T[]): array is NodeArray<T>;
+export declare function isLiteralKind(kind: SyntaxKind): boolean;
+export declare function isLiteralExpression(node: Node): node is LiteralExpression;
+export declare function isTemplateLiteralKind(kind: SyntaxKind): boolean;
+export type TemplateLiteralToken = NoSubstitutionTemplateLiteral | TemplateHead | TemplateMiddle | TemplateTail;
+export declare function isTemplateMiddleOrTemplateTail(node: Node): node is TemplateMiddle | TemplateTail;
+export declare function isImportOrExportSpecifier(node: Node): node is ImportSpecifier | ExportSpecifier;
+export declare function isTypeOnlyImportOrExportDeclaration(node: Node): node is TypeOnlyCompatibleAliasDeclaration;
+export declare function isStringTextContainingNode(node: Node): node is StringLiteral | TemplateLiteralToken;
+export declare function isGeneratedIdentifier(node: Node): node is GeneratedIdentifier;
+export declare function isModifierKind(token: SyntaxKind): token is Modifier["kind"];
+export declare function isModifier(node: Node): node is Modifier;
+export declare function isEntityName(node: Node): node is EntityName;
+export declare function isPropertyName(node: Node): node is PropertyName;
+export declare function isBindingName(node: Node): node is BindingName;
+export declare function isFunctionLike(node: Node): node is SignatureDeclaration;
+export declare function isFunctionLikeDeclaration(node: Node): node is FunctionLikeDeclaration;
+export declare function isFunctionLikeKind(kind: SyntaxKind): boolean;
+export declare function isFunctionOrModuleBlock(node: Node): boolean;
+export declare function isTypeElement(node: Node): node is TypeElement;
+export declare function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike;
+/**
+ * Node test that determines whether a node is a valid type node.
+ * This differs from the `isPartOfTypeNode` function which determines whether a node is *part*
+ * of a TypeNode.
+ */
+export declare function isTypeNode(node: Node): node is TypeNode;
+export declare function isBindingPattern(node: Node | undefined): node is BindingPattern;
+export declare function isAssignmentPattern(node: Node): node is AssignmentPattern;
+export declare function isArrayBindingElement(node: Node): node is ArrayBindingElement;
+/**
+ * Determines whether the BindingOrAssignmentElement is a BindingElement-like declaration
+ */
+export declare function isDeclarationBindingElement(bindingElement: BindingOrAssignmentElement): bindingElement is VariableDeclaration | ParameterDeclaration | BindingElement;
+export declare function isPropertyAccessOrQualifiedNameOrImportTypeNode(node: Node): node is PropertyAccessExpression | QualifiedName | ImportTypeNode;
+export declare function isPropertyAccessOrQualifiedName(node: Node): node is PropertyAccessExpression | QualifiedName;
+export declare function isCallLikeExpression(node: Node): node is CallLikeExpression;
+/** A chamada. Na tag, também o `new` (CK-02). */
+export declare function isCallOrNewExpression(node: Node): node is CallExpression;
+export declare function isTemplateLiteral(node: Node): node is TemplateLiteral;
+export declare function isLeftHandSideExpression(node: Node): node is LeftHandSideExpression;
+export declare function isUnaryExpression(node: Node): node is UnaryExpression;
+export declare function isUnaryExpressionWithWrite(expr: Node): expr is PrefixUnaryExpression | PostfixUnaryExpression;
+/**
+ * Determines whether a node is an expression based only on its kind.
+ * Use `isExpressionNode` if not in transforms.
+ */
+export declare function isExpression(node: Node): node is Expression;
+export declare function isAssertionExpression(node: Node): node is AssertionExpression;
+export declare function isNotEmittedStatement(node: Node): node is NotEmittedStatement;
+export declare function isIterationStatement(node: Node): node is IterationStatement;
+export declare function isForInOrOfStatement(node: Node): node is ForInOrOfStatement;
+export declare function isConciseBody(node: Node): node is ConciseBody;
+export declare function isForInitializer(node: Node): node is ForInitializer;
+export declare function isModuleBody(node: Node): node is ModuleBody;
+export declare function isNamedImportBindings(node: Node): node is NamedImportBindings;
+export declare function isDeclaration(node: Node): node is NamedDeclaration;
+/**
+ * Determines whether the node is a statement that is not also a declaration
+ */
+export declare function isStatementButNotDeclaration(node: Node): node is Statement;
+export declare function isStatement(node: Node): node is Statement;
+export declare function isJsxTagNameExpression(node: Node): node is JsxTagNameExpression;
+export declare function isJsxChild(node: Node): node is JsxChild;
+export declare function isJsxAttributeLike(node: Node): node is JsxAttributeLike;
+export declare function isStringLiteralOrJsxExpression(node: Node): node is StringLiteral | JsxExpression;
+export declare function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement;
+export declare function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause;
+/** True if has type node attached to it. */
+export declare function hasType(node: Node): node is HasType;
+/** True if has initializer node attached to it. */
+export declare function hasInitializer(node: Node): node is HasInitializer;
+export declare function isObjectLiteralElement(node: Node): node is ObjectLiteralElement;
+export declare function isStringLiteralLike(node: Node): node is StringLiteralLike;