@tslite/parser 1.10.0 → 1.13.0

package/dist/factory.d.ts

@@ -0,0 +1,78 @@
+import { SyntaxKind } from "./_namespaces/ts.js";
+import type { ArrayBindingOrAssignmentPattern, AsExpression, AssignmentPattern, BinaryExpression, BindingOrAssignmentElement, BindingOrAssignmentElementTarget, BindingOrAssignmentPattern, Block, CommaListExpression, ConciseBody, EntityName, Expression, LeftHandSideExpression, Node, NodeArray, ObjectBindingOrAssignmentPattern, ObjectLiteralElementLike, ParenthesizedExpression, PartiallyEmittedExpression, Statement, Token, TransformationContext, TypeNode } from "./_namespaces/ts.js";
+export declare const nullTransformationContext: TransformationContext;
+export declare function createExpressionFromEntityName(node: EntityName | Expression): Expression;
+export declare function convertToFunctionBody(node: ConciseBody, multiLine?: boolean): Block;
+export declare function findUseStrictPrologue(statements: readonly Statement[]): Statement | undefined;
+/**
+ * Ensures "use strict" directive is added
+ *
+ * @param statements An array of statements
+ */
+export declare function ensureUseStrict(statements: NodeArray<Statement>): NodeArray<Statement>;
+/**
+ * Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended
+ * order of operations.
+ *
+ * @param binaryOperator The operator for the BinaryExpression.
+ * @param operand The operand for the BinaryExpression.
+ * @param isLeftSideOfBinary A value indicating whether the operand is the left side of the
+ *                           BinaryExpression.
+ */
+export declare function parenthesizeBinaryOperand(binaryOperator: SyntaxKind, operand: Expression, isLeftSideOfBinary: boolean, leftOperand?: Expression): Expression;
+export declare function parenthesizeForConditionalHead(condition: Expression): Expression;
+export declare function parenthesizeSubexpressionOfConditionalExpression(e: Expression): Expression;
+/**
+ * O `export default` aceita uma AssignmentExpression: a sequência de vírgula, escrita ou sintética, vai entre
+ * parênteses.
+ */
+export declare function parenthesizeDefaultExpression(e: Expression): Expression;
+/**
+ * Wraps an expression in parentheses if it is needed in order to use the expression for
+ * property or element access.
+ *
+ * @param expr The expression node.
+ */
+export declare function parenthesizeForAccess(expression: Expression): LeftHandSideExpression;
+export declare function parenthesizePostfixOperand(operand: Expression): LeftHandSideExpression;
+export declare function parenthesizePrefixOperand(operand: Expression): import("./types.js").UnaryExpression;
+export declare function parenthesizeListElements(elements: NodeArray<Expression>): NodeArray<Expression>;
+export declare function parenthesizeExpressionForList(expression: Expression): Expression;
+export declare function parenthesizeExpressionForExpressionStatement(expression: Expression): Expression;
+export declare function parenthesizeConditionalTypeMember(member: TypeNode): TypeNode;
+export declare function parenthesizeElementTypeMember(member: TypeNode): TypeNode;
+export declare function parenthesizeArrayTypeMember(member: TypeNode): TypeNode;
+export declare function parenthesizeElementTypeMembers(members: readonly TypeNode[]): NodeArray<TypeNode>;
+export declare function parenthesizeTypeParameters(typeParameters: readonly TypeNode[] | undefined): import("./types.js").MutableNodeArray<TypeNode> | undefined;
+export declare function getLeftmostExpression(node: Expression): Expression;
+export declare function parenthesizeConciseBody(body: ConciseBody): ConciseBody;
+export declare function isCommaSequence(node: Expression): node is BinaryExpression & {
+    operatorToken: Token<SyntaxKind.CommaToken>;
+} | CommaListExpression;
+export declare enum OuterExpressionKinds {
+    Parentheses = 1,
+    TypeAssertions = 2,
+    PartiallyEmittedExpressions = 8,
+    Assertions = 2,
+    All = 11
+}
+export type OuterExpression = ParenthesizedExpression | AsExpression | PartiallyEmittedExpression;
+export declare function isOuterExpression(node: Node, kinds?: OuterExpressionKinds): node is OuterExpression;
+export declare function skipOuterExpressions(node: Expression, kinds?: OuterExpressionKinds): Expression;
+export declare function skipOuterExpressions(node: Node, kinds?: OuterExpressionKinds): Node;
+export declare function recreateOuterExpressions(outerExpression: Expression | undefined, innerExpression: Expression, kinds?: OuterExpressionKinds): Expression;
+export declare function startOnNewLine<T extends Node>(node: T): T;
+/**
+ * Gets the initializer of an BindingOrAssignmentElement.
+ */
+export declare function getInitializerOfBindingOrAssignmentElement(bindingElement: BindingOrAssignmentElement): Expression | undefined;
+/**
+ * Gets the name of an BindingOrAssignmentElement.
+ */
+export declare function getTargetOfBindingOrAssignmentElement(bindingElement: BindingOrAssignmentElement): BindingOrAssignmentElementTarget | undefined;
+export declare function convertToArrayAssignmentElement(element: BindingOrAssignmentElement): Expression;
+export declare function convertToObjectAssignmentElement(element: BindingOrAssignmentElement): ObjectLiteralElementLike;
+export declare function convertToAssignmentPattern(node: BindingOrAssignmentPattern): AssignmentPattern;
+export declare function convertToObjectAssignmentPattern(node: ObjectBindingOrAssignmentPattern): import("./types.js").ObjectLiteralExpression;
+export declare function convertToArrayAssignmentPattern(node: ArrayBindingOrAssignmentPattern): import("./types.js").ArrayLiteralExpression;
+export declare function convertToAssignmentElementTarget(node: BindingOrAssignmentElementTarget): Expression;