@ttsc/factory 0.15.10 → 0.16.0

package/lib/TsPrinter.mjs

@@ -3,23 +3,13 @@ import { join, hardline, printDocToString, line, softline, group, concat, indent
 import { SyntaxKind } from './syntax/SyntaxKind.mjs';
 import { NodeFlags } from './syntax/NodeFlags.mjs';
 
-const escapeString = (text, singleQuote) => {
-    const escaped = text
-        .replace(/\\/g, "\\\\")
-        .replace(/\n/g, "\\n")
-        .replace(/\r/g, "\\r")
-        .replace(/\t/g, "\\t");
-    return singleQuote === true
-        ? `'${escaped.replace(/'/g, "\\'")}'`
-        : `"${escaped.replace(/"/g, '\\"')}"`;
-};
 /**
  * Printer turning {@link factory} produced AST nodes into TypeScript source
  * text.
  *
  * The printer is a width-aware pretty-printer: it builds a Prettier-style
  * document for the {@link Node} discriminated union and lays it out against
- * {@link TsPrinterOptions.printWidth}. Lists (arguments, parameters, generic
+ * {@link TsPrinter.IProps.printWidth}. Lists (arguments, parameters, generic
  * arguments, array / object members, ...) print on one line when they fit and
  * break onto indented lines — with trailing commas — when they do not. Every
  * `node.kind` narrows to its concrete type, so the walk is fully type-checked;
@@ -148,6 +138,11 @@ class TsPrinter {
             trailingComma: true,
         });
     }
+    args(args) {
+        return this.delim("(", args.map((a) => this.expressionForDisallowedComma(a)), ")", {
+            trailingComma: true,
+        });
+    }
     modifiers(mods, decoratorsOnNewLine) {
         if (!mods || mods.length === 0)
             return "";
@@ -232,7 +227,7 @@ class TsPrinter {
             case "Token":
                 return node.token;
             case "Decorator":
-                return concat(["@", this.emit(node.expression)]);
+                return concat(["@", this.leftSideExpression(node.expression)]);
             /* literals */
             case "StringLiteral":
                 return escapeString(node.text, node.singleQuote);
@@ -242,7 +237,7 @@ class TsPrinter {
                 return node.text;
             /* expressions */
             case "ArrayLiteralExpression":
-                return this.delim("[", node.elements.map((e) => this.emit(e)), "]", { trailingComma: true, forceBreak: node.multiLine === true });
+                return this.delim("[", node.elements.map((e) => this.expressionForDisallowedComma(e)), "]", { trailingComma: true, forceBreak: node.multiLine === true });
             case "ObjectLiteralExpression":
                 return this.delim("{", node.properties.map((p) => this.emit(p)), "}", {
                     space: true,
@@ -253,62 +248,78 @@ class TsPrinter {
                 return concat([
                     this.emit(node.name),
                     ": ",
-                    this.emit(node.initializer),
+                    this.expressionForDisallowedComma(node.initializer),
                 ]);
             case "ShorthandPropertyAssignment":
                 return concat([
                     this.emit(node.name),
                     node.objectAssignmentInitializer
-                        ? concat([" = ", this.emit(node.objectAssignmentInitializer)])
+                        ? concat([
+                            " = ",
+                            this.expressionForDisallowedComma(node.objectAssignmentInitializer),
+                        ])
                         : "",
                 ]);
             case "SpreadAssignment":
-                return concat(["...", this.emit(node.expression)]);
+                return concat([
+                    "...",
+                    this.expressionForDisallowedComma(node.expression),
+                ]);
             case "PropertyAccessExpression":
-                return concat([this.emit(node.expression), ".", this.emit(node.name)]);
+                return concat([
+                    this.leftSideExpression(node.expression),
+                    ".",
+                    this.emit(node.name),
+                ]);
             case "ElementAccessExpression":
                 return concat([
-                    this.emit(node.expression),
+                    this.leftSideExpression(node.expression),
                     "[",
-                    this.emit(node.argumentExpression),
+                    this.expressionForDisallowedComma(node.argumentExpression),
                     "]",
                 ]);
             case "CallExpression":
                 return concat([
-                    this.emit(node.expression),
+                    this.leftSideExpression(node.expression),
                     this.typeArguments(node.typeArguments),
-                    this.params(node.arguments),
+                    this.args(node.arguments),
                 ]);
             case "NewExpression":
                 return concat([
                     "new ",
-                    this.emit(node.expression),
+                    this.newExpressionTarget(node.expression),
                     this.typeArguments(node.typeArguments),
-                    this.params(node.arguments ?? []),
+                    this.args(node.arguments ?? []),
                 ]);
             case "ParenthesizedExpression":
                 return concat(["(", this.emit(node.expression), ")"]);
             case "BinaryExpression":
                 return group(concat([
-                    this.emit(node.left),
+                    this.binaryOperand(node.operator, node.left, true),
                     " ",
                     node.operator,
-                    indent(concat([line, this.emit(node.right)])),
+                    indent(concat([
+                        line,
+                        this.binaryOperand(node.operator, node.right, false, node.left),
+                    ])),
                 ]));
             case "PrefixUnaryExpression":
-                return concat([node.operator, this.emit(node.operand)]);
+                return concat([
+                    node.operator,
+                    this.prefixUnaryOperand(node.operand, node.operator),
+                ]);
             case "PostfixUnaryExpression":
-                return concat([this.emit(node.operand), node.operator]);
+                return concat([this.postfixUnaryOperand(node.operand), node.operator]);
             case "ConditionalExpression":
                 return group(concat([
-                    this.emit(node.condition),
+                    this.conditionalCondition(node.condition),
                     indent(concat([
                         line,
                         "? ",
-                        this.emit(node.whenTrue),
+                        this.conditionalBranch(node.whenTrue),
                         line,
                         ": ",
-                        this.emit(node.whenFalse),
+                        this.conditionalBranch(node.whenFalse),
                     ])),
                 ]));
             case "ArrowFunction":
@@ -318,7 +329,7 @@ class TsPrinter {
                     this.params(node.parameters),
                     this.optType(node.type),
                     " => ",
-                    this.emit(node.body),
+                    this.arrowFunctionBody(node.body),
                 ]);
             case "FunctionExpression":
                 return concat([
@@ -334,24 +345,27 @@ class TsPrinter {
                 ]);
             case "AsExpression":
                 return concat([
-                    this.emit(node.expression),
+                    this.assertionExpressionOperand(node.expression),
                     " as ",
                     this.emit(node.type),
                 ]);
             case "SatisfiesExpression":
                 return concat([
-                    this.emit(node.expression),
+                    this.assertionExpressionOperand(node.expression),
                     " satisfies ",
                     this.emit(node.type),
                 ]);
             case "NonNullExpression":
-                return concat([this.emit(node.expression), "!"]);
+                return concat([this.leftSideExpression(node.expression), "!"]);
             case "SpreadElement":
-                return concat(["...", this.emit(node.expression)]);
+                return concat([
+                    "...",
+                    this.expressionForDisallowedComma(node.expression),
+                ]);
             case "AwaitExpression":
-                return concat(["await ", this.emit(node.expression)]);
+                return concat(["await ", this.prefixUnaryOperand(node.expression)]);
             case "TypeOfExpression":
-                return concat(["typeof ", this.emit(node.expression)]);
+                return concat(["typeof ", this.prefixUnaryOperand(node.expression)]);
             /* types */
             case "KeywordTypeNode":
                 return node.keyword;
@@ -363,9 +377,9 @@ class TsPrinter {
             case "ArrayTypeNode":
                 return concat([this.postfixTypeOperand(node.elementType), "[]"]);
             case "UnionTypeNode":
-                return this.binaryType("|", node.types.map((t) => this.emit(t)));
+                return this.binaryType("|", node.types);
             case "IntersectionTypeNode":
-                return this.binaryType("&", node.types.map((t) => this.emit(t)));
+                return this.binaryType("&", node.types);
             case "LiteralTypeNode":
                 return this.emit(node.literal);
             case "TypeLiteralNode":
@@ -384,7 +398,11 @@ class TsPrinter {
             case "ParenthesizedTypeNode":
                 return concat(["(", this.emit(node.type), ")"]);
             case "TypeOperatorNode":
-                return concat([node.operator, " ", this.emit(node.type)]);
+                return concat([
+                    node.operator,
+                    " ",
+                    this.typeOperatorOperand(node.type, node.operator),
+                ]);
             case "IndexedAccessTypeNode":
                 return concat([
                     this.postfixTypeOperand(node.objectType),
@@ -440,7 +458,12 @@ class TsPrinter {
                     this.emit(node.name),
                     node.questionToken ? "?" : "",
                     this.optType(node.type),
-                    node.initializer ? concat([" = ", this.emit(node.initializer)]) : "",
+                    node.initializer
+                        ? concat([
+                            " = ",
+                            this.expressionForDisallowedComma(node.initializer),
+                        ])
+                        : "",
                 ]);
             case "HeritageClause":
                 return concat([
@@ -472,10 +495,18 @@ class TsPrinter {
                     this.emit(node.name),
                     node.exclamationToken ? "!" : "",
                     this.optType(node.type),
-                    node.initializer ? concat([" = ", this.emit(node.initializer)]) : "",
+                    node.initializer
+                        ? concat([
+                            " = ",
+                            this.expressionForDisallowedComma(node.initializer),
+                        ])
+                        : "",
                 ]);
             case "ExpressionStatement":
-                return concat([this.emit(node.expression), ";"]);
+                return concat([
+                    this.expressionStatementExpression(node.expression),
+                    ";",
+                ]);
             case "ReturnStatement":
                 return node.expression
                     ? concat(["return ", this.emit(node.expression), ";"])
@@ -525,7 +556,12 @@ class TsPrinter {
                         ? this.emit(node.questionOrExclamationToken)
                         : "",
                     this.optType(node.type),
-                    node.initializer ? concat([" = ", this.emit(node.initializer)]) : "",
+                    node.initializer
+                        ? concat([
+                            " = ",
+                            this.expressionForDisallowedComma(node.initializer),
+                        ])
+                        : "",
                     ";",
                 ]);
             case "MethodDeclaration":
@@ -605,7 +641,12 @@ class TsPrinter {
             case "EnumMember":
                 return concat([
                     this.emit(node.name),
-                    node.initializer ? concat([" = ", this.emit(node.initializer)]) : "",
+                    node.initializer
+                        ? concat([
+                            " = ",
+                            this.expressionForDisallowedComma(node.initializer),
+                        ])
+                        : "",
                 ]);
             /* imports & exports */
             case "ImportDeclaration":
@@ -663,7 +704,7 @@ class TsPrinter {
                 return concat([
                     this.modifiers(node.modifiers, false),
                     node.isExportEquals ? "export = " : "export default ",
-                    this.emit(node.expression),
+                    this.exportAssignmentExpression(node.expression, node.isExportEquals === true),
                     ";",
                 ]);
             /* source file */
@@ -849,9 +890,9 @@ class TsPrinter {
                 ]);
             case "ConditionalTypeNode":
                 return concat([
-                    this.emit(node.checkType),
+                    this.conditionalTypeCheckOperand(node.checkType),
                     " extends ",
-                    this.emit(node.extendsType),
+                    this.conditionalTypeExtendsOperand(node.extendsType),
                     " ? ",
                     this.emit(node.trueType),
                     " : ",
@@ -902,9 +943,9 @@ class TsPrinter {
                     this.emit(node.type),
                 ]);
             case "OptionalTypeNode":
-                return concat([this.emit(node.type), "?"]);
+                return concat([this.postfixTypeOperand(node.type), "?"]);
             case "RestTypeNode":
-                return concat(["...", this.emit(node.type)]);
+                return concat(["...", this.postfixTypeOperand(node.type)]);
             case "ImportTypeNode":
                 return concat([
                     node.isTypeOf ? "typeof " : "",
@@ -943,10 +984,13 @@ class TsPrinter {
                     concat(node.templateSpans.map((s) => this.emit(s))),
                 ]);
             case "TemplateSpan":
-                return concat([this.emit(node.expression), this.emit(node.literal)]);
+                return concat([
+                    this.expressionForDisallowedComma(node.expression),
+                    this.emit(node.literal),
+                ]);
             case "TaggedTemplateExpression":
                 return concat([
-                    this.emit(node.tag),
+                    this.leftSideExpression(node.tag),
                     this.typeArguments(node.typeArguments),
                     this.emit(node.template),
                 ]);
@@ -954,12 +998,14 @@ class TsPrinter {
                 return concat([
                     "yield",
                     node.asteriskToken ? "*" : "",
-                    node.expression ? concat([" ", this.emit(node.expression)]) : "",
+                    node.expression
+                        ? concat([" ", this.expressionForDisallowedComma(node.expression)])
+                        : "",
                 ]);
             case "DeleteExpression":
-                return concat(["delete ", this.emit(node.expression)]);
+                return concat(["delete ", this.prefixUnaryOperand(node.expression)]);
             case "VoidExpression":
-                return concat(["void ", this.emit(node.expression)]);
+                return concat(["void ", this.prefixUnaryOperand(node.expression)]);
             case "RegularExpressionLiteral":
                 return node.text;
             case "ClassExpression":
@@ -977,7 +1023,11 @@ class TsPrinter {
             case "CommaListExpression":
                 return join(", ", node.elements.map((e) => this.emit(e)));
             case "ComputedPropertyName":
-                return concat(["[", this.emit(node.expression), "]"]);
+                return concat([
+                    "[",
+                    this.expressionForDisallowedComma(node.expression),
+                    "]",
+                ]);
             case "OmittedExpression":
                 return "";
             case "BindingElement":
@@ -985,7 +1035,12 @@ class TsPrinter {
                     node.dotDotDotToken ? "..." : "",
                     node.propertyName ? concat([this.emit(node.propertyName), ": "]) : "",
                     this.emit(node.name),
-                    node.initializer ? concat([" = ", this.emit(node.initializer)]) : "",
+                    node.initializer
+                        ? concat([
+                            " = ",
+                            this.expressionForDisallowedComma(node.initializer),
+                        ])
+                        : "",
                 ]);
             case "ObjectBindingPattern":
                 return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: true });
@@ -996,31 +1051,31 @@ class TsPrinter {
                     "<",
                     this.emit(node.type),
                     ">",
-                    this.emit(node.expression),
+                    this.prefixUnaryOperand(node.expression),
                 ]);
             case "PropertyAccessChain":
                 return concat([
-                    this.emit(node.expression),
+                    this.leftSideExpression(node.expression),
                     node.questionDotToken ? "?." : ".",
                     this.emit(node.name),
                 ]);
             case "ElementAccessChain":
                 return concat([
-                    this.emit(node.expression),
+                    this.leftSideExpression(node.expression),
                     node.questionDotToken ? "?." : "",
                     "[",
-                    this.emit(node.argumentExpression),
+                    this.expressionForDisallowedComma(node.argumentExpression),
                     "]",
                 ]);
             case "CallChain":
                 return concat([
-                    this.emit(node.expression),
+                    this.leftSideExpression(node.expression),
                     node.questionDotToken ? "?." : "",
                     this.typeArguments(node.typeArguments),
-                    this.params(node.arguments),
+                    this.args(node.arguments),
                 ]);
             case "NonNullChain":
-                return concat([this.emit(node.expression), "!"]);
+                return concat([this.leftSideExpression(node.expression), "!"]);
             /* jsx */
             case "JsxElement":
                 return group(concat([
@@ -1306,15 +1361,382 @@ class TsPrinter {
      * parenthesizing the lower-precedence type forms that would otherwise
      * re-associate — matching the legacy printer's parenthesizer rules.
      */
-    postfixTypeOperand(type) {
-        const parenthesize = type.kind === "UnionTypeNode" ||
+    parenthesizedExpression(expression) {
+        return expression.kind === "ParenthesizedExpression"
+            ? this.emit(expression)
+            : concat(["(", this.emit(expression), ")"]);
+    }
+    expressionForDisallowedComma(expression) {
+        return this.expressionPrecedence(expression) > ExpressionPrecedence.Comma
+            ? this.emit(expression)
+            : this.parenthesizedExpression(expression);
+    }
+    leftSideExpression(expression) {
+        return this.isLeftHandSideExpression(expression)
+            ? this.emit(expression)
+            : this.parenthesizedExpression(expression);
+    }
+    newExpressionTarget(expression) {
+        return expression.kind !== "CallExpression" &&
+            expression.kind !== "CallChain" &&
+            (expression.kind !== "NewExpression" ||
+                expression.arguments !== undefined) &&
+            this.isLeftHandSideExpression(expression)
+            ? this.emit(expression)
+            : this.parenthesizedExpression(expression);
+    }
+    prefixUnaryOperand(operand, operator) {
+        const body = this.isUnaryExpression(operand)
+            ? this.emit(operand)
+            : this.parenthesizedExpression(operand);
+        return this.needsPrefixUnaryGap(operator, operand)
+            ? concat([" ", body])
+            : body;
+    }
+    postfixUnaryOperand(operand) {
+        return this.isLeftHandSideExpression(operand)
+            ? this.emit(operand)
+            : this.parenthesizedExpression(operand);
+    }
+    conditionalCondition(condition) {
+        return this.expressionPrecedence(condition) >
+            ExpressionPrecedence.Conditional
+            ? this.emit(condition)
+            : this.parenthesizedExpression(condition);
+    }
+    conditionalBranch(branch) {
+        return this.expressionForDisallowedComma(branch);
+    }
+    arrowFunctionBody(body) {
+        return body.kind === "Block"
+            ? this.emit(body)
+            : this.expressionNeedsConciseBodyParentheses(body)
+                ? this.parenthesizedExpression(body)
+                : this.emit(body);
+    }
+    expressionStatementExpression(expression) {
+        return this.expressionNeedsStatementParentheses(expression)
+            ? this.parenthesizedExpression(expression)
+            : this.emit(expression);
+    }
+    exportAssignmentExpression(expression, isExportEquals) {
+        return isExportEquals
+            ? this.expressionForDisallowedComma(expression)
+            : this.expressionNeedsExportDefaultParentheses(expression)
+                ? this.parenthesizedExpression(expression)
+                : this.emit(expression);
+    }
+    assertionExpressionOperand(expression) {
+        return this.expressionPrecedence(expression) >=
+            ExpressionPrecedence.Relational
+            ? this.expressionForDisallowedComma(expression)
+            : this.parenthesizedExpression(expression);
+    }
+    binaryOperand(operator, operand, isLeftSide, leftOperand) {
+        return this.binaryOperandNeedsParentheses(operator, operand, isLeftSide, leftOperand)
+            ? this.parenthesizedExpression(operand)
+            : this.emit(operand);
+    }
+    binaryOperandNeedsParentheses(operator, operand, isLeftSide, leftOperand) {
+        if (operand.kind === "ParenthesizedExpression")
+            return false;
+        if (operator === SyntaxKind.AsteriskAsteriskToken &&
+            isLeftSide &&
+            this.expressionPrecedence(operand) === ExpressionPrecedence.Unary)
+            return true;
+        if (operand.kind === "BinaryExpression" &&
+            this.mixingBinaryOperatorsRequiresParentheses(operator, operand.operator))
+            return true;
+        const operatorPrecedence = this.binaryOperatorPrecedence(operator);
+        const operandPrecedence = this.expressionPrecedence(operand);
+        if (!isLeftSide &&
+            operand.kind === "ArrowFunction" &&
+            operatorPrecedence > ExpressionPrecedence.Assignment)
+            return true;
+        if (operandPrecedence < operatorPrecedence)
+            return true;
+        if (operandPrecedence > operatorPrecedence)
+            return false;
+        if (isLeftSide)
+            return this.binaryOperatorAssociativity(operator) === Associativity.Right;
+        if (operand.kind === "BinaryExpression" && operand.operator === operator) {
+            if (this.operatorHasAssociativeProperty(operator))
+                return false;
+            if (operator === SyntaxKind.PlusToken &&
+                leftOperand !== undefined &&
+                this.literalKindOfBinaryPlusOperand(leftOperand) !== undefined &&
+                this.literalKindOfBinaryPlusOperand(leftOperand) ===
+                    this.literalKindOfBinaryPlusOperand(operand))
+                return false;
+        }
+        return this.expressionAssociativity(operand) === Associativity.Left;
+    }
+    expressionPrecedence(expression) {
+        switch (expression.kind) {
+            case "CommaListExpression":
+                return ExpressionPrecedence.Comma;
+            case "YieldExpression":
+                return ExpressionPrecedence.Yield;
+            case "ConditionalExpression":
+                return ExpressionPrecedence.Conditional;
+            case "BinaryExpression":
+                return this.binaryOperatorPrecedence(expression.operator);
+            case "AsExpression":
+            case "SatisfiesExpression":
+                return ExpressionPrecedence.Relational;
+            case "TypeAssertion":
+            case "PrefixUnaryExpression":
+            case "TypeOfExpression":
+            case "VoidExpression":
+            case "DeleteExpression":
+            case "AwaitExpression":
+            case "NonNullExpression":
+            case "NonNullChain":
+                return ExpressionPrecedence.Unary;
+            case "PostfixUnaryExpression":
+                return ExpressionPrecedence.Update;
+            case "CallExpression":
+            case "CallChain":
+                return ExpressionPrecedence.LeftHandSide;
+            case "NewExpression":
+            case "TaggedTemplateExpression":
+            case "PropertyAccessExpression":
+            case "PropertyAccessChain":
+            case "ElementAccessExpression":
+            case "ElementAccessChain":
+            case "MetaProperty":
+                return ExpressionPrecedence.Member;
+            default:
+                return ExpressionPrecedence.Primary;
+        }
+    }
+    expressionAssociativity(expression) {
+        switch (expression.kind) {
+            case "NewExpression":
+                return expression.arguments === undefined
+                    ? Associativity.Right
+                    : Associativity.Left;
+            case "PrefixUnaryExpression":
+            case "TypeOfExpression":
+            case "VoidExpression":
+            case "DeleteExpression":
+            case "AwaitExpression":
+            case "ConditionalExpression":
+            case "YieldExpression":
+                return Associativity.Right;
+            case "BinaryExpression":
+                return this.binaryOperatorAssociativity(expression.operator);
+            default:
+                return Associativity.Left;
+        }
+    }
+    binaryOperatorPrecedence(operator) {
+        switch (operator) {
+            case SyntaxKind.CommaToken:
+                return ExpressionPrecedence.Comma;
+            case SyntaxKind.EqualsToken:
+            case SyntaxKind.PlusEqualsToken:
+            case SyntaxKind.MinusEqualsToken:
+            case SyntaxKind.AsteriskEqualsToken:
+            case SyntaxKind.SlashEqualsToken:
+            case SyntaxKind.QuestionQuestionEqualsToken:
+                return ExpressionPrecedence.Assignment;
+            case SyntaxKind.QuestionQuestionToken:
+            case SyntaxKind.BarBarToken:
+                return ExpressionPrecedence.LogicalOR;
+            case SyntaxKind.AmpersandAmpersandToken:
+                return ExpressionPrecedence.LogicalAND;
+            case SyntaxKind.BarToken:
+                return ExpressionPrecedence.BitwiseOR;
+            case SyntaxKind.CaretToken:
+                return ExpressionPrecedence.BitwiseXOR;
+            case SyntaxKind.AmpersandToken:
+                return ExpressionPrecedence.BitwiseAND;
+            case SyntaxKind.EqualsEqualsToken:
+            case SyntaxKind.ExclamationEqualsToken:
+            case SyntaxKind.EqualsEqualsEqualsToken:
+            case SyntaxKind.ExclamationEqualsEqualsToken:
+                return ExpressionPrecedence.Equality;
+            case SyntaxKind.LessThanToken:
+            case SyntaxKind.LessThanEqualsToken:
+            case SyntaxKind.GreaterThanToken:
+            case SyntaxKind.GreaterThanEqualsToken:
+            case SyntaxKind.InstanceOfKeyword:
+            case SyntaxKind.InKeyword:
+            case SyntaxKind.AsKeyword:
+            case SyntaxKind.SatisfiesKeyword:
+                return ExpressionPrecedence.Relational;
+            case SyntaxKind.LessThanLessThanToken:
+            case SyntaxKind.GreaterThanGreaterThanToken:
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+                return ExpressionPrecedence.Shift;
+            case SyntaxKind.PlusToken:
+            case SyntaxKind.MinusToken:
+                return ExpressionPrecedence.Additive;
+            case SyntaxKind.AsteriskToken:
+            case SyntaxKind.SlashToken:
+            case SyntaxKind.PercentToken:
+                return ExpressionPrecedence.Multiplicative;
+            case SyntaxKind.AsteriskAsteriskToken:
+                return ExpressionPrecedence.Exponentiation;
+            default:
+                return ExpressionPrecedence.Invalid;
+        }
+    }
+    binaryOperatorAssociativity(operator) {
+        switch (operator) {
+            case SyntaxKind.AsteriskAsteriskToken:
+            case SyntaxKind.EqualsToken:
+            case SyntaxKind.PlusEqualsToken:
+            case SyntaxKind.MinusEqualsToken:
+            case SyntaxKind.AsteriskEqualsToken:
+            case SyntaxKind.SlashEqualsToken:
+            case SyntaxKind.QuestionQuestionEqualsToken:
+                return Associativity.Right;
+            default:
+                return Associativity.Left;
+        }
+    }
+    mixingBinaryOperatorsRequiresParentheses(left, right) {
+        return ((left === SyntaxKind.QuestionQuestionToken &&
+            (right === SyntaxKind.AmpersandAmpersandToken ||
+                right === SyntaxKind.BarBarToken)) ||
+            (right === SyntaxKind.QuestionQuestionToken &&
+                (left === SyntaxKind.AmpersandAmpersandToken ||
+                    left === SyntaxKind.BarBarToken)));
+    }
+    operatorHasAssociativeProperty(operator) {
+        return (operator === SyntaxKind.AsteriskToken ||
+            operator === SyntaxKind.BarToken ||
+            operator === SyntaxKind.AmpersandToken ||
+            operator === SyntaxKind.CaretToken ||
+            operator === SyntaxKind.CommaToken);
+    }
+    literalKindOfBinaryPlusOperand(expression) {
+        switch (expression.kind) {
+            case "StringLiteral":
+            case "NumericLiteral":
+            case "BigIntLiteral":
+                return expression.kind;
+            case "BinaryExpression": {
+                if (expression.operator !== SyntaxKind.PlusToken)
+                    return undefined;
+                const left = this.literalKindOfBinaryPlusOperand(expression.left);
+                return left !== undefined &&
+                    left === this.literalKindOfBinaryPlusOperand(expression.right)
+                    ? left
+                    : undefined;
+            }
+            default:
+                return undefined;
+        }
+    }
+    isUnaryExpression(expression) {
+        return this.expressionPrecedence(expression) >= ExpressionPrecedence.Unary;
+    }
+    isLeftHandSideExpression(expression) {
+        switch (expression.kind) {
+            case "ArrowFunction":
+            case "ClassExpression":
+            case "FunctionExpression":
+            case "NumericLiteral":
+            case "ObjectLiteralExpression":
+                return false;
+        }
+        return (this.expressionPrecedence(expression) >=
+            ExpressionPrecedence.LeftHandSide ||
+            expression.kind === "NonNullExpression" ||
+            expression.kind === "NonNullChain");
+    }
+    expressionNeedsStatementParentheses(expression) {
+        const leftmost = this.leftmostExpression(expression);
+        return (leftmost.kind === "FunctionExpression" ||
+            leftmost.kind === "ObjectLiteralExpression");
+    }
+    expressionNeedsConciseBodyParentheses(expression) {
+        return (this.expressionPrecedence(expression) <= ExpressionPrecedence.Comma ||
+            this.leftmostExpression(expression).kind === "ObjectLiteralExpression");
+    }
+    expressionNeedsExportDefaultParentheses(expression) {
+        const leftmost = this.leftmostExpression(expression);
+        return (this.expressionPrecedence(expression) <= ExpressionPrecedence.Comma ||
+            leftmost.kind === "ClassExpression" ||
+            leftmost.kind === "FunctionExpression");
+    }
+    leftmostExpression(expression) {
+        switch (expression.kind) {
+            case "AsExpression":
+            case "CallExpression":
+            case "CallChain":
+            case "ElementAccessExpression":
+            case "ElementAccessChain":
+            case "NonNullExpression":
+            case "NonNullChain":
+            case "PropertyAccessExpression":
+            case "PropertyAccessChain":
+            case "SatisfiesExpression":
+                return this.leftmostExpression(expression.expression);
+            case "BinaryExpression":
+                return this.leftmostExpression(expression.left);
+            case "ConditionalExpression":
+                return this.leftmostExpression(expression.condition);
+            case "TaggedTemplateExpression":
+                return this.leftmostExpression(expression.tag);
+            default:
+                return expression;
+        }
+    }
+    needsPrefixUnaryGap(operator, operand) {
+        if (operator === undefined || operand.kind !== "PrefixUnaryExpression")
+            return false;
+        return ((operator === SyntaxKind.PlusToken &&
+            (operand.operator === SyntaxKind.PlusToken ||
+                operand.operator === SyntaxKind.PlusPlusToken)) ||
+            (operator === SyntaxKind.MinusToken &&
+                (operand.operator === SyntaxKind.MinusToken ||
+                    operand.operator === SyntaxKind.MinusMinusToken)));
+    }
+    parenthesizedType(type) {
+        return type.kind === "ParenthesizedTypeNode"
+            ? this.emit(type)
+            : concat(["(", this.emit(type), ")"]);
+    }
+    conditionalTypeCheckOperand(type) {
+        return type.kind === "FunctionTypeNode" ||
+            type.kind === "ConstructorTypeNode" ||
+            type.kind === "ConditionalTypeNode"
+            ? this.parenthesizedType(type)
+            : this.emit(type);
+    }
+    conditionalTypeExtendsOperand(type) {
+        return type.kind === "ConditionalTypeNode"
+            ? this.parenthesizedType(type)
+            : this.emit(type);
+    }
+    typeOperatorOperand(type, operator) {
+        return this.typeOperatorOperandNeedsParentheses(type, operator)
+            ? this.parenthesizedType(type)
+            : this.emit(type);
+    }
+    typeOperatorOperandNeedsParentheses(type, operator) {
+        return (type.kind === "UnionTypeNode" ||
             type.kind === "IntersectionTypeNode" ||
             type.kind === "FunctionTypeNode" ||
             type.kind === "ConstructorTypeNode" ||
             type.kind === "ConditionalTypeNode" ||
-            type.kind === "InferTypeNode" ||
-            type.kind === "TypeOperatorNode";
-        return parenthesize ? concat(["(", this.emit(type), ")"]) : this.emit(type);
+            (operator === SyntaxKind.ReadonlyKeyword &&
+                type.kind === "TypeOperatorNode"));
+    }
+    postfixTypeOperand(type) {
+        return this.postfixTypeOperandNeedsParentheses(type)
+            ? this.parenthesizedType(type)
+            : this.emit(type);
+    }
+    postfixTypeOperandNeedsParentheses(type) {
+        return (type.kind === "InferTypeNode" ||
+            type.kind === "TypeOperatorNode" ||
+            type.kind === "TypeQueryNode" ||
+            this.typeOperatorOperandNeedsParentheses(type));
     }
     /** Render a JSDoc tag's trailing comment, prefixed with a space when present. */
     jsDocComment(comment) {
@@ -1327,7 +1749,8 @@ class TsPrinter {
             : "";
     }
     /** Width-aware `|` / `&` type list with leading-operator breaks. */
-    binaryType(operator, parts) {
+    binaryType(operator, types) {
+        const parts = this.flattenBinaryTypes(operator, types).map((type) => this.binaryTypeOperand(operator, type));
         if (parts.length === 1)
             return parts[0];
         return group(indent(concat([
@@ -1335,10 +1758,70 @@ class TsPrinter {
             join(concat([line, operator, " "]), parts),
         ])));
     }
+    flattenBinaryTypes(operator, types) {
+        const flattened = [];
+        for (const type of types)
+            if (operator === "|" && type.kind === "UnionTypeNode")
+                flattened.push(...this.flattenBinaryTypes(operator, type.types));
+            else if (operator === "&" && type.kind === "IntersectionTypeNode")
+                flattened.push(...this.flattenBinaryTypes(operator, type.types));
+            else
+                flattened.push(type);
+        return flattened;
+    }
+    binaryTypeOperand(operator, type) {
+        return this.binaryTypeOperandNeedsParentheses(operator, type)
+            ? this.parenthesizedType(type)
+            : this.emit(type);
+    }
+    binaryTypeOperandNeedsParentheses(operator, type) {
+        return (type.kind === "FunctionTypeNode" ||
+            type.kind === "ConstructorTypeNode" ||
+            type.kind === "ConditionalTypeNode" ||
+            type.kind === "UnionTypeNode" ||
+            (operator === "|" && type.kind === "IntersectionTypeNode"));
+    }
     unsupported(node) {
         throw new Error(`@ttsc/factory: TsPrinter cannot print node of kind "${node.kind}".`);
     }
 }
+const escapeString = (text, singleQuote) => {
+    const escaped = text
+        .replace(/\\/g, "\\\\")
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+    return singleQuote === true
+        ? `'${escaped.replace(/'/g, "\\'")}'`
+        : `"${escaped.replace(/"/g, '\\"')}"`;
+};
+const ExpressionPrecedence = {
+    Comma: 0,
+    Yield: 2,
+    Assignment: 3,
+    Conditional: 4,
+    LogicalOR: 5,
+    LogicalAND: 6,
+    BitwiseOR: 7,
+    BitwiseXOR: 8,
+    BitwiseAND: 9,
+    Equality: 10,
+    Relational: 11,
+    Shift: 12,
+    Additive: 13,
+    Multiplicative: 14,
+    Exponentiation: 15,
+    Unary: 16,
+    Update: 17,
+    LeftHandSide: 18,
+    Member: 19,
+    Primary: 20,
+    Invalid: -1,
+};
+const Associativity = {
+    Left: "left",
+    Right: "right",
+};
 
 export { TsPrinter };
 //# sourceMappingURL=TsPrinter.mjs.map