@tslite/services 0.0.0-stage → 1.12.0

package/dist/formatting/rules.js

@@ -0,0 +1,610 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/services/formatting/rules.ts: o namespace virou módulo ES, com os imports explícitos.
+import { SemicolonPreference, SyntaxKind, contains, findAncestor, findNextToken, isArray, isFunctionLikeKind, isPropertySignature, isTrivia, positionIsASICandidate, typeKeywords, } from "../_namespaces/edit.js";
+import { anyContext, } from "../_namespaces/ts.formatting.js";
+export function getAllRules() {
+    const allTokens = [];
+    for (let token = SyntaxKind.FirstToken; token <= SyntaxKind.LastToken; token++) {
+        if (token !== SyntaxKind.EndOfFileToken) {
+            allTokens.push(token);
+        }
+    }
+    function anyTokenExcept(...tokens) {
+        return { tokens: allTokens.filter(t => !tokens.some(t2 => t2 === t)), isSpecific: false };
+    }
+    const anyToken = { tokens: allTokens, isSpecific: false };
+    const anyTokenIncludingMultilineComments = tokenRangeFrom([...allTokens, SyntaxKind.MultiLineCommentTrivia]);
+    const anyTokenIncludingEOF = tokenRangeFrom([...allTokens, SyntaxKind.EndOfFileToken]);
+    const keywords = tokenRangeFromRange(SyntaxKind.FirstKeyword, SyntaxKind.LastKeyword);
+    const binaryOperators = tokenRangeFromRange(SyntaxKind.FirstBinaryOperator, SyntaxKind.LastBinaryOperator);
+    // Nas listas de palavras, na tag, também as que saíram do scanner com o que a Linguagem não tem (CK-56): aqui, o
+    // `instanceof`, o `this` e o `new` (CK-02).
+    const binaryKeywordOperators = [SyntaxKind.InKeyword, SyntaxKind.OfKeyword, SyntaxKind.AsKeyword, SyntaxKind.IsKeyword];
+    const unaryPrefixOperators = [SyntaxKind.PlusPlusToken, SyntaxKind.MinusMinusToken, SyntaxKind.TildeToken, SyntaxKind.ExclamationToken];
+    const unaryPrefixExpressions = [
+        SyntaxKind.NumericLiteral, SyntaxKind.BigIntLiteral, SyntaxKind.Identifier, SyntaxKind.OpenParenToken,
+        SyntaxKind.OpenBracketToken, SyntaxKind.OpenBraceToken
+    ];
+    const unaryPreincrementExpressions = [SyntaxKind.Identifier, SyntaxKind.OpenParenToken];
+    const unaryPostincrementExpressions = [SyntaxKind.Identifier, SyntaxKind.CloseParenToken, SyntaxKind.CloseBracketToken];
+    const unaryPredecrementExpressions = [SyntaxKind.Identifier, SyntaxKind.OpenParenToken];
+    const unaryPostdecrementExpressions = [SyntaxKind.Identifier, SyntaxKind.CloseParenToken, SyntaxKind.CloseBracketToken];
+    const comments = [SyntaxKind.SingleLineCommentTrivia, SyntaxKind.MultiLineCommentTrivia];
+    const typeNames = [SyntaxKind.Identifier, ...typeKeywords];
+    // Place a space before open brace in a function declaration
+    // TypeScript: Function can have return types, which can be made of tons of different token kinds
+    const functionOpenBraceLeftTokenRange = anyTokenIncludingMultilineComments;
+    // Place a space before open brace in a TypeScript declaration that has braces as children (class, module, enum, etc)
+    // Na tag, também depois do `class` (CK-02).
+    const typeScriptOpenBraceLeftTokenRange = tokenRangeFrom([SyntaxKind.Identifier, SyntaxKind.MultiLineCommentTrivia, SyntaxKind.ExportKeyword, SyntaxKind.ImportKeyword]);
+    // Place a space before open brace in a control flow construct
+    const controlOpenBraceLeftTokenRange = tokenRangeFrom([SyntaxKind.CloseParenToken, SyntaxKind.MultiLineCommentTrivia, SyntaxKind.DoKeyword, SyntaxKind.TryKeyword, SyntaxKind.FinallyKeyword, SyntaxKind.ElseKeyword]);
+    // These rules are higher in priority than user-configurable
+    const highPriorityCommonRules = [
+        // Leave comments alone
+        rule("IgnoreBeforeComment", anyToken, comments, anyContext, 1 /* RuleAction.StopProcessingSpaceActions */),
+        rule("IgnoreAfterLineComment", SyntaxKind.SingleLineCommentTrivia, anyToken, anyContext, 1 /* RuleAction.StopProcessingSpaceActions */),
+        rule("NotSpaceBeforeColon", anyToken, SyntaxKind.ColonToken, [isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNotTypeAnnotationContext], 16 /* RuleAction.DeleteSpace */),
+        rule("SpaceAfterColon", SyntaxKind.ColonToken, anyToken, [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBeforeQuestionMark", anyToken, SyntaxKind.QuestionToken, [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 16 /* RuleAction.DeleteSpace */),
+        // insert space after '?' only when it is used in conditional operator
+        rule("SpaceAfterQuestionMarkInConditionalOperator", SyntaxKind.QuestionToken, anyToken, [isNonJsxSameLineTokenContext, isConditionalOperatorContext], 4 /* RuleAction.InsertSpace */),
+        // in other cases there should be no space between '?' and next token
+        rule("NoSpaceAfterQuestionMark", SyntaxKind.QuestionToken, anyToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeDot", anyToken, [SyntaxKind.DotToken, SyntaxKind.QuestionDotToken], [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterDot", [SyntaxKind.DotToken, SyntaxKind.QuestionDotToken], anyToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBetweenImportParenInImportType", SyntaxKind.ImportKeyword, SyntaxKind.OpenParenToken, [isNonJsxSameLineTokenContext, isImportTypeContext], 16 /* RuleAction.DeleteSpace */),
+        // Special handling of unary operators.
+        // Prefix operators generally shouldn't have a space between
+        // them and their target unary expression.
+        rule("NoSpaceAfterUnaryPrefixOperator", unaryPrefixOperators, unaryPrefixExpressions, [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterUnaryPreincrementOperator", SyntaxKind.PlusPlusToken, unaryPreincrementExpressions, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterUnaryPredecrementOperator", SyntaxKind.MinusMinusToken, unaryPredecrementExpressions, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeUnaryPostincrementOperator", unaryPostincrementExpressions, SyntaxKind.PlusPlusToken, [isNonJsxSameLineTokenContext, isNotStatementConditionContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeUnaryPostdecrementOperator", unaryPostdecrementExpressions, SyntaxKind.MinusMinusToken, [isNonJsxSameLineTokenContext, isNotStatementConditionContext], 16 /* RuleAction.DeleteSpace */),
+        // More unary operator special-casing.
+        // DevDiv 181814: Be careful when removing leading whitespace
+        // around unary operators.  Examples:
+        //      1 - -2  --X--> 1--2
+        //      a + ++b --X--> a+++b
+        rule("SpaceAfterPostincrementWhenFollowedByAdd", SyntaxKind.PlusPlusToken, SyntaxKind.PlusToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterAddWhenFollowedByUnaryPlus", SyntaxKind.PlusToken, SyntaxKind.PlusToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterAddWhenFollowedByPreincrement", SyntaxKind.PlusToken, SyntaxKind.PlusPlusToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterPostdecrementWhenFollowedBySubtract", SyntaxKind.MinusMinusToken, SyntaxKind.MinusToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterSubtractWhenFollowedByUnaryMinus", SyntaxKind.MinusToken, SyntaxKind.MinusToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterSubtractWhenFollowedByPredecrement", SyntaxKind.MinusToken, SyntaxKind.MinusMinusToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceAfterCloseBrace", SyntaxKind.CloseBraceToken, [SyntaxKind.CommaToken, SyntaxKind.SemicolonToken], [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // For functions and control block place } on a new line [multi-line rule]
+        rule("NewLineBeforeCloseBraceInBlockContext", anyTokenIncludingMultilineComments, SyntaxKind.CloseBraceToken, [isMultilineBlockContext], 8 /* RuleAction.InsertNewLine */),
+        // Space/new line after }.
+        rule("SpaceAfterCloseBrace", SyntaxKind.CloseBraceToken, anyTokenExcept(SyntaxKind.CloseParenToken), [isNonJsxSameLineTokenContext, isAfterCodeBlockContext], 4 /* RuleAction.InsertSpace */),
+        // Special case for (}, else) and (}, while) since else & while tokens are not part of the tree which makes SpaceAfterCloseBrace rule not applied
+        // Also should not apply to })
+        rule("SpaceBetweenCloseBraceAndElse", SyntaxKind.CloseBraceToken, SyntaxKind.ElseKeyword, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBetweenCloseBraceAndWhile", SyntaxKind.CloseBraceToken, SyntaxKind.WhileKeyword, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBetweenEmptyBraceBrackets", SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken, [isNonJsxSameLineTokenContext, isObjectContext], 16 /* RuleAction.DeleteSpace */),
+        // Add a space after control dec context if the next character is an open bracket ex: 'if (false)[a, b] = [1, 2];' -> 'if (false) [a, b] = [1, 2];'
+        rule("SpaceAfterConditionalClosingParen", SyntaxKind.CloseParenToken, SyntaxKind.OpenBracketToken, [isControlDeclContext], 4 /* RuleAction.InsertSpace */),
+        // Na tag, também o espaço do `function` e da estrela do generator (CK-02).
+        // Insert new line after { and before } in multi-line contexts.
+        rule("NewLineAfterOpenBraceInBlockContext", SyntaxKind.OpenBraceToken, anyToken, [isMultilineBlockContext], 8 /* RuleAction.InsertNewLine */),
+        // Na tag, também o espaço depois do `get` e do `set` de um acessor, e o do `yield` (CK-02).
+        rule("NoSpaceBetweenReturnAndSemicolon", SyntaxKind.ReturnKeyword, SyntaxKind.SemicolonToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // Na tag, também depois do `var` (CK-54) e do `new` (CK-02).
+        rule("SpaceAfterCertainKeywords", [SyntaxKind.ThrowKeyword, SyntaxKind.DeleteKeyword, SyntaxKind.ReturnKeyword, SyntaxKind.TypeOfKeyword, SyntaxKind.AwaitKeyword], anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterLetConstInVariableDeclaration", [SyntaxKind.LetKeyword, SyntaxKind.ConstKeyword], anyToken, [isNonJsxSameLineTokenContext, isStartOfVariableDeclarationList], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBeforeOpenParenInFuncCall", anyToken, SyntaxKind.OpenParenToken, [isNonJsxSameLineTokenContext, isFunctionCallOrNewContext, isPreviousTokenNotComma], 16 /* RuleAction.DeleteSpace */),
+        // Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options.
+        rule("SpaceBeforeBinaryKeywordOperator", anyToken, binaryKeywordOperators, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterBinaryKeywordOperator", binaryKeywordOperators, anyToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        // Na tag, também o espaço depois do operador `void` (CK-63).
+        // Async-await
+        rule("SpaceBetweenAsyncAndOpenParen", SyntaxKind.AsyncKeyword, SyntaxKind.OpenParenToken, [isArrowFunctionContext, isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        // Na tag, também o espaço entre o `async` e o `function` (CK-02).
+        rule("SpaceBetweenAsyncAndFunctionKeyword", SyntaxKind.AsyncKeyword, [SyntaxKind.Identifier], [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        // Na tag, também o espaço entre a tag e o template marcado (CK-02).
+        // JSX opening elements
+        rule("SpaceBeforeJsxAttribute", anyToken, SyntaxKind.Identifier, [isNextTokenParentJsxAttribute, isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBeforeSlashInJsxOpeningElement", anyToken, SyntaxKind.SlashToken, [isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBeforeGreaterThanTokenInJsxOpeningElement", SyntaxKind.SlashToken, SyntaxKind.GreaterThanToken, [isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeEqualInJsxAttribute", anyToken, SyntaxKind.EqualsToken, [isJsxAttributeContext, isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterEqualInJsxAttribute", SyntaxKind.EqualsToken, anyToken, [isJsxAttributeContext, isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // TypeScript-specific rules
+        // Na tag, também o `module("m")` e o `require("m")` de um `import =` (CK-03).
+        // Add a space around certain TypeScript keywords
+        // Na tag, também depois das palavras da classe, da interface, do enum, do acessor e do `module` (CK-02, CK-56).
+        rule("SpaceAfterCertainTypeScriptKeywords", [
+            SyntaxKind.DeclareKeyword,
+            SyntaxKind.DefaultKeyword,
+            SyntaxKind.ExportKeyword,
+            SyntaxKind.ExtendsKeyword,
+            SyntaxKind.ImportKeyword,
+            SyntaxKind.NamespaceKeyword,
+            SyntaxKind.ReadonlyKeyword,
+            SyntaxKind.TypeKeyword,
+            SyntaxKind.FromKeyword,
+            SyntaxKind.KeyOfKeyword,
+            SyntaxKind.InferKeyword,
+        ], anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        // Na tag, também antes do `implements` (CK-02).
+        rule("SpaceBeforeCertainTypeScriptKeywords", anyToken, [SyntaxKind.ExtendsKeyword, SyntaxKind.FromKeyword], [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        // Na tag, também o espaço depois do nome em string de um `module "m" {` (CK-02).
+        // Lambda expressions
+        rule("SpaceBeforeArrow", anyToken, SyntaxKind.EqualsGreaterThanToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterArrow", SyntaxKind.EqualsGreaterThanToken, anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        // Optional parameters and let args
+        rule("NoSpaceAfterEllipsis", SyntaxKind.DotDotDotToken, SyntaxKind.Identifier, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterOptionalParameters", SyntaxKind.QuestionToken, [SyntaxKind.CloseParenToken, SyntaxKind.CommaToken], [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 16 /* RuleAction.DeleteSpace */),
+        // Remove spaces in empty interface literals. e.g.: x: {}
+        rule("NoSpaceBetweenEmptyInterfaceBraceBrackets", SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken, [isNonJsxSameLineTokenContext, isObjectTypeContext], 16 /* RuleAction.DeleteSpace */),
+        // generics and type assertions
+        rule("NoSpaceBeforeOpenAngularBracket", typeNames, SyntaxKind.LessThanToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBetweenCloseParenAndAngularBracket", SyntaxKind.CloseParenToken, SyntaxKind.LessThanToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterOpenAngularBracket", SyntaxKind.LessThanToken, anyToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeCloseAngularBracket", anyToken, SyntaxKind.GreaterThanToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterCloseAngularBracket", SyntaxKind.GreaterThanToken, [SyntaxKind.OpenParenToken, SyntaxKind.OpenBracketToken, SyntaxKind.GreaterThanToken, SyntaxKind.CommaToken], [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext, isNotFunctionDeclContext /*To prevent an interference with the SpaceBeforeOpenParenInFuncDecl rule*/], 16 /* RuleAction.DeleteSpace */),
+        // Na tag, também os espaços do decorator, o do `x!` e o do `new` de uma construct signature (CK-02).
+        rule("SpaceLessThanAndNonJSXTypeAnnotation", SyntaxKind.LessThanToken, SyntaxKind.LessThanToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+    ];
+    // These rules are applied after high priority
+    const userConfigurableRules = [
+        // Na tag, também o espaço depois do `constructor` (CK-02).
+        rule("SpaceAfterComma", SyntaxKind.CommaToken, anyToken, [isOptionEnabled("insertSpaceAfterCommaDelimiter"), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNextTokenNotCloseBracket, isNextTokenNotCloseParen], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceAfterComma", SyntaxKind.CommaToken, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterCommaDelimiter"), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext], 16 /* RuleAction.DeleteSpace */),
+        // Na tag, também o espaço depois do `function` e da estrela do generator de uma function expression (CK-02).
+        // Insert space after keywords in control flow statements
+        rule("SpaceAfterKeywordInControl", keywords, SyntaxKind.OpenParenToken, [isOptionEnabled("insertSpaceAfterKeywordsInControlFlowStatements"), isControlDeclContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceAfterKeywordInControl", keywords, SyntaxKind.OpenParenToken, [isOptionDisabledOrUndefined("insertSpaceAfterKeywordsInControlFlowStatements"), isControlDeclContext], 16 /* RuleAction.DeleteSpace */),
+        // Insert space after opening and before closing nonempty parenthesis
+        rule("SpaceAfterOpenParen", SyntaxKind.OpenParenToken, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBeforeCloseParen", anyToken, SyntaxKind.CloseParenToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBetweenOpenParens", SyntaxKind.OpenParenToken, SyntaxKind.OpenParenToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBetweenParens", SyntaxKind.OpenParenToken, SyntaxKind.CloseParenToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterOpenParen", SyntaxKind.OpenParenToken, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeCloseParen", anyToken, SyntaxKind.CloseParenToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // Insert space after opening and before closing nonempty brackets
+        rule("SpaceAfterOpenBracket", SyntaxKind.OpenBracketToken, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBeforeCloseBracket", anyToken, SyntaxKind.CloseBracketToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBetweenBrackets", SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterOpenBracket", SyntaxKind.OpenBracketToken, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeCloseBracket", anyToken, SyntaxKind.CloseBracketToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}.
+        rule("SpaceAfterOpenBrace", SyntaxKind.OpenBraceToken, anyToken, [isOptionEnabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isBraceWrappedContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBeforeCloseBrace", anyToken, SyntaxKind.CloseBraceToken, [isOptionEnabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isBraceWrappedContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBetweenEmptyBraceBrackets", SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken, [isNonJsxSameLineTokenContext, isObjectContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterOpenBrace", SyntaxKind.OpenBraceToken, anyToken, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeCloseBrace", anyToken, SyntaxKind.CloseBraceToken, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // Insert a space after opening and before closing empty brace brackets
+        rule("SpaceBetweenEmptyBraceBrackets", SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces")], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBetweenEmptyBraceBrackets", SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // Insert space after opening and before closing template string braces
+        rule("SpaceAfterTemplateHeadAndMiddle", [SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle], anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBeforeTemplateMiddleAndTail", anyToken, [SyntaxKind.TemplateMiddle, SyntaxKind.TemplateTail], [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceAfterTemplateHeadAndMiddle", [SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle], anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeTemplateMiddleAndTail", anyToken, [SyntaxKind.TemplateMiddle, SyntaxKind.TemplateTail], [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // No space after { and before } in JSX expression
+        rule("SpaceAfterOpenBraceInJsxExpression", SyntaxKind.OpenBraceToken, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceBeforeCloseBraceInJsxExpression", anyToken, SyntaxKind.CloseBraceToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceAfterOpenBraceInJsxExpression", SyntaxKind.OpenBraceToken, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceBeforeCloseBraceInJsxExpression", anyToken, SyntaxKind.CloseBraceToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 16 /* RuleAction.DeleteSpace */),
+        // Insert space after semicolon in for statement
+        rule("SpaceAfterSemicolonInFor", SyntaxKind.SemicolonToken, anyToken, [isOptionEnabled("insertSpaceAfterSemicolonInForStatements"), isNonJsxSameLineTokenContext, isForContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceAfterSemicolonInFor", SyntaxKind.SemicolonToken, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterSemicolonInForStatements"), isNonJsxSameLineTokenContext, isForContext], 16 /* RuleAction.DeleteSpace */),
+        // Insert space before and after binary operators
+        rule("SpaceBeforeBinaryOperator", anyToken, binaryOperators, [isOptionEnabled("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("SpaceAfterBinaryOperator", binaryOperators, anyToken, [isOptionEnabled("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBeforeBinaryOperator", anyToken, binaryOperators, [isOptionDisabledOrUndefined("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterBinaryOperator", binaryOperators, anyToken, [isOptionDisabledOrUndefined("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 16 /* RuleAction.DeleteSpace */),
+        rule("SpaceBeforeOpenParenInFuncDecl", anyToken, SyntaxKind.OpenParenToken, [isOptionEnabled("insertSpaceBeforeFunctionParenthesis"), isNonJsxSameLineTokenContext, isFunctionDeclContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBeforeOpenParenInFuncDecl", anyToken, SyntaxKind.OpenParenToken, [isOptionDisabledOrUndefined("insertSpaceBeforeFunctionParenthesis"), isNonJsxSameLineTokenContext, isFunctionDeclContext], 16 /* RuleAction.DeleteSpace */),
+        // Open Brace braces after control block
+        rule("NewLineBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken, [isOptionEnabled("placeOpenBraceOnNewLineForControlBlocks"), isControlDeclContext, isBeforeMultilineBlockContext], 8 /* RuleAction.InsertNewLine */, 1 /* RuleFlags.CanDeleteNewLines */),
+        // Open Brace braces after function
+        // TypeScript: Function can have return types, which can be made of tons of different token kinds
+        rule("NewLineBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken, [isOptionEnabled("placeOpenBraceOnNewLineForFunctions"), isFunctionDeclContext, isBeforeMultilineBlockContext], 8 /* RuleAction.InsertNewLine */, 1 /* RuleFlags.CanDeleteNewLines */),
+        // Open Brace braces after TypeScript module/class/interface
+        rule("NewLineBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken, [isOptionEnabled("placeOpenBraceOnNewLineForFunctions"), isTypeScriptDeclWithBlockContext, isBeforeMultilineBlockContext], 8 /* RuleAction.InsertNewLine */, 1 /* RuleFlags.CanDeleteNewLines */),
+        // Na tag, também o espaço depois da asserção de tipo `<T>x` (CK-02).
+        rule("SpaceBeforeTypeAnnotation", anyToken, SyntaxKind.ColonToken, [isOptionEnabled("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], 4 /* RuleAction.InsertSpace */),
+        rule("NoSpaceBeforeTypeAnnotation", anyToken, SyntaxKind.ColonToken, [isOptionDisabledOrUndefined("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoOptionalSemicolon", SyntaxKind.SemicolonToken, anyTokenIncludingEOF, [optionEquals("semicolons", SemicolonPreference.Remove), isSemicolonDeletionContext], 32 /* RuleAction.DeleteToken */),
+        rule("OptionalSemicolon", anyToken, anyTokenIncludingEOF, [optionEquals("semicolons", SemicolonPreference.Insert), isSemicolonInsertionContext], 64 /* RuleAction.InsertTrailingSemicolon */),
+    ];
+    // These rules are lower in priority than user-configurable. Rules earlier in this list have priority over rules later in the list.
+    const lowPriorityCommonRules = [
+        // Space after keyword but not before ; or : or ?
+        rule("NoSpaceBeforeSemicolon", anyToken, SyntaxKind.SemicolonToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("SpaceBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForControlBlocks"), isControlDeclContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* RuleAction.InsertSpace */, 1 /* RuleFlags.CanDeleteNewLines */),
+        rule("SpaceBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), isFunctionDeclContext, isBeforeBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* RuleAction.InsertSpace */, 1 /* RuleFlags.CanDeleteNewLines */),
+        rule("SpaceBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), isTypeScriptDeclWithBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* RuleAction.InsertSpace */, 1 /* RuleFlags.CanDeleteNewLines */),
+        rule("NoSpaceBeforeComma", anyToken, SyntaxKind.CommaToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        // No space before and after indexer `x[]`
+        rule("NoSpaceBeforeOpenBracket", anyTokenExcept(SyntaxKind.AsyncKeyword, SyntaxKind.CaseKeyword), SyntaxKind.OpenBracketToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */),
+        rule("NoSpaceAfterCloseBracket", SyntaxKind.CloseBracketToken, anyToken, [isNonJsxSameLineTokenContext, isNotBeforeBlockInFunctionDeclarationContext], 16 /* RuleAction.DeleteSpace */),
+        rule("SpaceAfterSemicolon", SyntaxKind.SemicolonToken, anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        // Remove extra space between for and await
+        rule("SpaceBetweenForAndAwaitKeyword", SyntaxKind.ForKeyword, SyntaxKind.AwaitKeyword, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+        // Add a space between statements. All keywords except (do,else,case) has open/close parens after them.
+        // So, we have a rule to add a space for [),Any], [do,Any], [else,Any], and [case,Any]
+        rule("SpaceBetweenStatements", [SyntaxKind.CloseParenToken, SyntaxKind.DoKeyword, SyntaxKind.ElseKeyword, SyntaxKind.CaseKeyword], anyToken, [isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNotForContext], 4 /* RuleAction.InsertSpace */),
+        // This low-pri rule takes care of "try {" and "finally {" in case the rule SpaceBeforeOpenBraceInControl didn't execute on FormatOnEnter.
+        rule("SpaceAfterTryFinally", [SyntaxKind.TryKeyword, SyntaxKind.FinallyKeyword], SyntaxKind.OpenBraceToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */),
+    ];
+    return [
+        ...highPriorityCommonRules,
+        ...userConfigurableRules,
+        ...lowPriorityCommonRules,
+    ];
+}
+/**
+ * A rule takes a two tokens (left/right) and a particular context
+ * for which you're meant to look at them. You then declare what should the
+ * whitespace annotation be between these tokens via the action param.
+ *
+ * @param debugName Name to print
+ * @param left The left side of the comparison
+ * @param right The right side of the comparison
+ * @param context A set of filters to narrow down the space in which this formatter rule applies
+ * @param action a declaration of the expected whitespace
+ * @param flags whether the rule deletes a line or not, defaults to no-op
+ */
+function rule(debugName, left, right, context, action, flags = 0 /* RuleFlags.None */) {
+    return { leftTokenRange: toTokenRange(left), rightTokenRange: toTokenRange(right), rule: { debugName, context, action, flags } };
+}
+function tokenRangeFrom(tokens) {
+    return { tokens, isSpecific: true };
+}
+function toTokenRange(arg) {
+    return typeof arg === "number" ? tokenRangeFrom([arg]) : isArray(arg) ? tokenRangeFrom(arg) : arg;
+}
+function tokenRangeFromRange(from, to, except = []) {
+    const tokens = [];
+    for (let token = from; token <= to; token++) {
+        if (!contains(except, token)) {
+            tokens.push(token);
+        }
+    }
+    return tokenRangeFrom(tokens);
+}
+///
+/// Contexts
+///
+function optionEquals(optionName, optionValue) {
+    return (context) => context.options && context.options[optionName] === optionValue;
+}
+function isOptionEnabled(optionName) {
+    return (context) => context.options && context.options.hasOwnProperty(optionName) && !!context.options[optionName];
+}
+function isOptionDisabled(optionName) {
+    return (context) => context.options && context.options.hasOwnProperty(optionName) && !context.options[optionName];
+}
+function isOptionDisabledOrUndefined(optionName) {
+    return (context) => !context.options || !context.options.hasOwnProperty(optionName) || !context.options[optionName];
+}
+function isOptionDisabledOrUndefinedOrTokensOnSameLine(optionName) {
+    return (context) => !context.options || !context.options.hasOwnProperty(optionName) || !context.options[optionName] || context.TokensAreOnSameLine();
+}
+function isOptionEnabledOrUndefined(optionName) {
+    return (context) => !context.options || !context.options.hasOwnProperty(optionName) || !!context.options[optionName];
+}
+function isForContext(context) {
+    return context.contextNode.kind === SyntaxKind.ForStatement;
+}
+function isNotForContext(context) {
+    return !isForContext(context);
+}
+function isBinaryOpContext(context) {
+    switch (context.contextNode.kind) {
+        case SyntaxKind.BinaryExpression:
+            return context.contextNode.operatorToken.kind !== SyntaxKind.CommaToken;
+        case SyntaxKind.ConditionalExpression:
+        case SyntaxKind.ConditionalType:
+        case SyntaxKind.AsExpression:
+        case SyntaxKind.ExportSpecifier:
+        case SyntaxKind.ImportSpecifier:
+        case SyntaxKind.TypePredicate:
+        case SyntaxKind.UnionType:
+        case SyntaxKind.IntersectionType:
+            return true;
+        // equals in binding elements: function foo([[x, y] = [1, 2]])
+        case SyntaxKind.BindingElement:
+        // equals in type X = ...
+        // falls through
+        case SyntaxKind.TypeAliasDeclaration:
+        // Na tag, também o `=` do `import =` (CK-03).
+        // equal in let a = 0
+        // falls through
+        case SyntaxKind.VariableDeclaration:
+        // equal in p = 0
+        // falls through
+        case SyntaxKind.Parameter:
+        // Na tag, também o membro de enum e a propriedade de classe (CK-02).
+        case SyntaxKind.PropertySignature:
+            return context.currentTokenSpan.kind === SyntaxKind.EqualsToken || context.nextTokenSpan.kind === SyntaxKind.EqualsToken;
+        // "in" keyword in for (let x in []) { }
+        case SyntaxKind.ForInStatement:
+        // "in" keyword in [P in keyof T]: T[P]
+        // falls through
+        case SyntaxKind.TypeParameter:
+            return context.currentTokenSpan.kind === SyntaxKind.InKeyword || context.nextTokenSpan.kind === SyntaxKind.InKeyword || context.currentTokenSpan.kind === SyntaxKind.EqualsToken || context.nextTokenSpan.kind === SyntaxKind.EqualsToken;
+        // Technically, "of" is not a binary operator, but format it the same way as "in"
+        case SyntaxKind.ForOfStatement:
+            return context.currentTokenSpan.kind === SyntaxKind.OfKeyword || context.nextTokenSpan.kind === SyntaxKind.OfKeyword;
+    }
+    return false;
+}
+function isNotBinaryOpContext(context) {
+    return !isBinaryOpContext(context);
+}
+function isNotTypeAnnotationContext(context) {
+    return !isTypeAnnotationContext(context);
+}
+function isTypeAnnotationContext(context) {
+    const contextKind = context.contextNode.kind;
+    // Na tag, também a propriedade de classe (CK-02).
+    return contextKind === SyntaxKind.PropertySignature ||
+        contextKind === SyntaxKind.Parameter ||
+        contextKind === SyntaxKind.VariableDeclaration ||
+        isFunctionLikeKind(contextKind);
+}
+function isConditionalOperatorContext(context) {
+    return context.contextNode.kind === SyntaxKind.ConditionalExpression ||
+        context.contextNode.kind === SyntaxKind.ConditionalType;
+}
+function isSameLineTokenOrBeforeBlockContext(context) {
+    return context.TokensAreOnSameLine() || isBeforeBlockContext(context);
+}
+function isBraceWrappedContext(context) {
+    return context.contextNode.kind === SyntaxKind.ObjectBindingPattern ||
+        context.contextNode.kind === SyntaxKind.MappedType ||
+        isSingleLineBlockContext(context);
+}
+// This check is done before an open brace in a control construct, a function, or a typescript block declaration
+function isBeforeMultilineBlockContext(context) {
+    return isBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine());
+}
+function isMultilineBlockContext(context) {
+    return isBlockContext(context) && !(context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine());
+}
+function isSingleLineBlockContext(context) {
+    return isBlockContext(context) && (context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine());
+}
+function isBlockContext(context) {
+    return nodeIsBlockContext(context.contextNode);
+}
+function isBeforeBlockContext(context) {
+    return nodeIsBlockContext(context.nextTokenParent);
+}
+// IMPORTANT!!! This method must return true ONLY for nodes with open and close braces as immediate children
+function nodeIsBlockContext(node) {
+    if (nodeIsTypeScriptDeclWithBlockContext(node)) {
+        // This means we are in a context that looks like a block to the user, but in the grammar is actually not a node (it's a class, module, enum, object type literal, etc).
+        return true;
+    }
+    switch (node.kind) {
+        case SyntaxKind.Block:
+        case SyntaxKind.CaseBlock:
+        case SyntaxKind.ObjectLiteralExpression:
+        case SyntaxKind.ModuleBlock:
+            return true;
+    }
+    return false;
+}
+function isFunctionDeclContext(context) {
+    switch (context.contextNode.kind) {
+        // Na tag, também a `function`, o método, a method signature, o acessor, a function expression, o construtor e a
+        // interface, que para a formatação agia como uma função (CK-02, CK-36).
+        case SyntaxKind.CallSignature:
+        case SyntaxKind.ArrowFunction:
+            return true;
+    }
+    return false;
+}
+function isNotFunctionDeclContext(context) {
+    return !isFunctionDeclContext(context);
+}
+// Na tag, também o contexto da `function` e da function expression, que só as regras da estrela do generator liam (CK-02).
+function isTypeScriptDeclWithBlockContext(context) {
+    return nodeIsTypeScriptDeclWithBlockContext(context.contextNode);
+}
+function nodeIsTypeScriptDeclWithBlockContext(node) {
+    switch (node.kind) {
+        // Na tag, também a classe, a class expression, a interface e o enum (CK-02).
+        case SyntaxKind.TypeLiteral:
+        case SyntaxKind.ModuleDeclaration:
+        case SyntaxKind.ExportDeclaration:
+        case SyntaxKind.NamedExports:
+        case SyntaxKind.ImportDeclaration:
+        case SyntaxKind.NamedImports:
+            return true;
+    }
+    return false;
+}
+function isAfterCodeBlockContext(context) {
+    switch (context.currentTokenParent.kind) {
+        // Na tag, também a classe e o enum (CK-02).
+        case SyntaxKind.ModuleDeclaration:
+        case SyntaxKind.CatchClause:
+        case SyntaxKind.ModuleBlock:
+        case SyntaxKind.SwitchStatement:
+            return true;
+        case SyntaxKind.Block: {
+            const blockParent = context.currentTokenParent.parent;
+            // In a codefix scenario, we can't rely on parents being set. So just always return true.
+            // Na tag, também o corpo de uma function expression (CK-02).
+            if (!blockParent || blockParent.kind !== SyntaxKind.ArrowFunction) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isControlDeclContext(context) {
+    switch (context.contextNode.kind) {
+        case SyntaxKind.IfStatement:
+        case SyntaxKind.SwitchStatement:
+        case SyntaxKind.ForStatement:
+        case SyntaxKind.ForInStatement:
+        case SyntaxKind.ForOfStatement:
+        case SyntaxKind.WhileStatement:
+        case SyntaxKind.TryStatement:
+        case SyntaxKind.DoStatement:
+        // Na tag, também o `with` (CK-02).
+        // TODO
+        // case SyntaxKind.ElseClause:
+        // falls through
+        case SyntaxKind.CatchClause:
+            return true;
+        default:
+            return false;
+    }
+}
+function isObjectContext(context) {
+    return context.contextNode.kind === SyntaxKind.ObjectLiteralExpression;
+}
+function isFunctionCallContext(context) {
+    return context.contextNode.kind === SyntaxKind.CallExpression;
+}
+/** A chamada. Na tag, também o `new` (CK-02). */
+function isFunctionCallOrNewContext(context) {
+    return isFunctionCallContext(context);
+}
+function isPreviousTokenNotComma(context) {
+    return context.currentTokenSpan.kind !== SyntaxKind.CommaToken;
+}
+function isNextTokenNotCloseBracket(context) {
+    return context.nextTokenSpan.kind !== SyntaxKind.CloseBracketToken;
+}
+function isNextTokenNotCloseParen(context) {
+    return context.nextTokenSpan.kind !== SyntaxKind.CloseParenToken;
+}
+function isArrowFunctionContext(context) {
+    return context.contextNode.kind === SyntaxKind.ArrowFunction;
+}
+function isImportTypeContext(context) {
+    return context.contextNode.kind === SyntaxKind.ImportType;
+}
+function isNonJsxSameLineTokenContext(context) {
+    return context.TokensAreOnSameLine() && context.contextNode.kind !== SyntaxKind.JsxText;
+}
+function isNonJsxElementOrFragmentContext(context) {
+    return context.contextNode.kind !== SyntaxKind.JsxElement && context.contextNode.kind !== SyntaxKind.JsxFragment;
+}
+function isJsxExpressionContext(context) {
+    return context.contextNode.kind === SyntaxKind.JsxExpression || context.contextNode.kind === SyntaxKind.JsxSpreadAttribute;
+}
+function isNextTokenParentJsxAttribute(context) {
+    return context.nextTokenParent.kind === SyntaxKind.JsxAttribute;
+}
+function isJsxAttributeContext(context) {
+    return context.contextNode.kind === SyntaxKind.JsxAttribute;
+}
+function isJsxSelfClosingElementContext(context) {
+    return context.contextNode.kind === SyntaxKind.JsxSelfClosingElement;
+}
+function isNotBeforeBlockInFunctionDeclarationContext(context) {
+    return !isFunctionDeclContext(context) && !isBeforeBlockContext(context);
+}
+// Na tag, também o contexto do fim de um decorator (CK-02).
+function isStartOfVariableDeclarationList(context) {
+    return context.currentTokenParent.kind === SyntaxKind.VariableDeclarationList &&
+        context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos;
+}
+function isNotFormatOnEnter(context) {
+    return context.formattingRequestKind !== 2 /* FormattingRequestKind.FormatOnEnter */;
+}
+// Na tag, também o contexto do `module "m"`, que só a regra do nome em string lia (CK-02).
+function isObjectTypeContext(context) {
+    return context.contextNode.kind === SyntaxKind.TypeLiteral; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration;
+}
+// Na tag, também o contexto da construct signature (CK-02).
+function isTypeArgumentOrParameterOrAssertion(token, parent) {
+    if (token.kind !== SyntaxKind.LessThanToken && token.kind !== SyntaxKind.GreaterThanToken) {
+        return false;
+    }
+    switch (parent.kind) {
+        // Na tag, também a asserção de tipo `<T>x`, a classe, a class expression, a interface, a `function`, a function
+        // expression, o método, a construct signature, o `new` e a herança (CK-02), e a method signature (CK-36).
+        case SyntaxKind.TypeReference:
+        case SyntaxKind.TypeAliasDeclaration:
+        case SyntaxKind.ArrowFunction:
+        case SyntaxKind.CallSignature:
+        case SyntaxKind.CallExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+function isTypeArgumentOrParameterOrAssertionContext(context) {
+    return isTypeArgumentOrParameterOrAssertion(context.currentTokenSpan, context.currentTokenParent) ||
+        isTypeArgumentOrParameterOrAssertion(context.nextTokenSpan, context.nextTokenParent);
+}
+// Na tag, também os contextos da asserção de tipo `<T>x`, do operador `void`, do `yield` e do `x!` (CK-02, CK-63).
+function isNotStatementConditionContext(context) {
+    return !isStatementConditionContext(context);
+}
+function isStatementConditionContext(context) {
+    switch (context.contextNode.kind) {
+        case SyntaxKind.IfStatement:
+        case SyntaxKind.ForStatement:
+        case SyntaxKind.ForInStatement:
+        case SyntaxKind.ForOfStatement:
+        case SyntaxKind.DoStatement:
+        case SyntaxKind.WhileStatement:
+            return true;
+        default:
+            return false;
+    }
+}
+function isSemicolonDeletionContext(context) {
+    let nextTokenKind = context.nextTokenSpan.kind;
+    let nextTokenStart = context.nextTokenSpan.pos;
+    if (isTrivia(nextTokenKind)) {
+        const nextRealToken = context.nextTokenParent === context.currentTokenParent
+            ? findNextToken(context.currentTokenParent, findAncestor(context.currentTokenParent, a => !a.parent), context.sourceFile)
+            : context.nextTokenParent.getFirstToken(context.sourceFile);
+        if (!nextRealToken) {
+            return true;
+        }
+        nextTokenKind = nextRealToken.kind;
+        nextTokenStart = nextRealToken.getStart(context.sourceFile);
+    }
+    const startLine = context.sourceFile.getLineAndCharacterOfPosition(context.currentTokenSpan.pos).line;
+    const endLine = context.sourceFile.getLineAndCharacterOfPosition(nextTokenStart).line;
+    if (startLine === endLine) {
+        return nextTokenKind === SyntaxKind.CloseBraceToken
+            || nextTokenKind === SyntaxKind.EndOfFileToken;
+    }
+    // Na tag, também o `;` solto no corpo de uma classe (CK-02).
+    if (nextTokenKind === SyntaxKind.SemicolonToken) {
+        return false;
+    }
+    // Na tag, também o corpo de uma interface (CK-02).
+    if (context.contextNode.kind === SyntaxKind.TypeAliasDeclaration) {
+        // Can’t remove semicolon after `foo`; it would parse as a method declaration:
+        //
+        // interface I {
+        //   foo;
+        //   (): void
+        // }
+        return !isPropertySignature(context.currentTokenParent)
+            || !!context.currentTokenParent.type
+            || nextTokenKind !== SyntaxKind.OpenParenToken;
+    }
+    // Na tag, também a propriedade de classe sem inicializador (CK-02).
+    // Na tag, também o `;` solto no corpo de uma classe e o literal de regex (CK-02).
+    return context.currentTokenParent.kind !== SyntaxKind.ForStatement
+        && context.currentTokenParent.kind !== SyntaxKind.EmptyStatement
+        && nextTokenKind !== SyntaxKind.OpenBracketToken
+        && nextTokenKind !== SyntaxKind.OpenParenToken
+        && nextTokenKind !== SyntaxKind.PlusToken
+        && nextTokenKind !== SyntaxKind.MinusToken
+        && nextTokenKind !== SyntaxKind.SlashToken
+        && nextTokenKind !== SyntaxKind.CommaToken
+        && nextTokenKind !== SyntaxKind.TemplateExpression
+        && nextTokenKind !== SyntaxKind.TemplateHead
+        && nextTokenKind !== SyntaxKind.NoSubstitutionTemplateLiteral
+        && nextTokenKind !== SyntaxKind.DotToken;
+}
+function isSemicolonInsertionContext(context) {
+    return positionIsASICandidate(context.currentTokenSpan.end, context.currentTokenParent, context.sourceFile);
+}

package/dist/formatting/rulesMap.d.ts

@@ -0,0 +1,5 @@
+import type { FormatCodeSettings, FormattingHost } from "../_namespaces/edit.js";
+import { FormattingContext } from "../_namespaces/ts.formatting.js";
+import type { FormatContext, Rule } from "../_namespaces/ts.formatting.js";
+export declare function getFormatContext(options: FormatCodeSettings, host: FormattingHost): FormatContext;
+export type RulesMap = (context: FormattingContext) => readonly Rule[] | undefined;