@ttsc/factory 0.15.6

package/lib/TsPrinter.js

@@ -0,0 +1,976 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsPrinter = void 0;
+const doc_1 = require("./internal/doc");
+const syntax_1 = require("./syntax");
+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
+ * 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;
+ * no `typescript` module is involved.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   import factory, { TsPrinter } from "@ttsc/factory";
+ *
+ *   const printer = new TsPrinter({ printWidth: 80, indent: "  " });
+ *   printer.print(factory.createStringLiteral("hello")); // "hello"
+ *   ```;
+ */
+class TsPrinter {
+    printWidth_;
+    indent_;
+    newLine_;
+    constructor(options = {}) {
+        this.printWidth_ = options.printWidth ?? 80;
+        this.indent_ = options.indent ?? "  ";
+        this.newLine_ = options.newLine ?? "\n";
+    }
+    /** Print a single node (or a whole {@link SourceFile}) into source text. */
+    print(node) {
+        return this.layout(this.emit(node));
+    }
+    /** Print multiple nodes, joining them with new lines. */
+    printNodes(nodes) {
+        return this.layout((0, doc_1.join)(doc_1.hardline, nodes.map((n) => this.emit(n))));
+    }
+    /**
+     * Print an entire source file.
+     *
+     * @param sourceFile A {@link SourceFile}. When omitted, one is composed from
+     *   the given `statements`.
+     * @param statements Statements to compose a source file from when no
+     *   `sourceFile` is provided.
+     */
+    printFile(sourceFile, statements = []) {
+        const list = sourceFile
+            ? sourceFile.statements
+            : statements;
+        return (this.layout((0, doc_1.join)(doc_1.hardline, list.map((s) => this.emit(s)))) + this.newLine_);
+    }
+    /* ----------------------------------------------------------------------- */
+    /*  INTERNAL                                                               */
+    /* ----------------------------------------------------------------------- */
+    layout(doc) {
+        return (0, doc_1.printDocToString)(doc, {
+            printWidth: this.printWidth_,
+            indent: this.indent_,
+            newLine: this.newLine_,
+        });
+    }
+    /** Comma-separated, width-aware delimited list (`(...)`, `[...]`, `<...>`). */
+    delim(open, items, close, opts = {}) {
+        if (items.length === 0)
+            return open + close;
+        const ln = opts.space ? doc_1.line : doc_1.softline;
+        return (0, doc_1.group)((0, doc_1.concat)([
+            open,
+            (0, doc_1.indent)((0, doc_1.concat)([ln, (0, doc_1.join)((0, doc_1.concat)([",", doc_1.line]), items)])),
+            opts.trailingComma ? (0, doc_1.ifBreak)(",") : "",
+            ln,
+            close,
+        ]), opts.forceBreak === true);
+    }
+    /** Semicolon-separated member block (`{ a; b }`), e.g. interfaces. */
+    memberBlock(items, forceBreak) {
+        if (items.length === 0)
+            return "{}";
+        return (0, doc_1.group)((0, doc_1.concat)([
+            "{",
+            (0, doc_1.indent)((0, doc_1.concat)([doc_1.line, (0, doc_1.join)((0, doc_1.concat)([";", doc_1.line]), items)])),
+            (0, doc_1.ifBreak)(";"),
+            doc_1.line,
+            "}",
+        ]), forceBreak);
+    }
+    /** Always-broken statement block (`{ ... }`). */
+    statementBlock(items) {
+        if (items.length === 0)
+            return "{}";
+        return (0, doc_1.concat)([
+            "{",
+            (0, doc_1.indent)((0, doc_1.concat)([doc_1.hardline, (0, doc_1.join)(doc_1.hardline, items)])),
+            doc_1.hardline,
+            "}",
+        ]);
+    }
+    typeArguments(args) {
+        return args && args.length
+            ? this.delim("<", args.map((a) => this.emit(a)), ">", {
+                trailingComma: true,
+            })
+            : "";
+    }
+    params(params) {
+        return this.delim("(", params.map((p) => this.emit(p)), ")", {
+            trailingComma: true,
+        });
+    }
+    modifiers(mods, decoratorsOnNewLine) {
+        if (!mods || mods.length === 0)
+            return "";
+        const decorators = mods.filter((m) => m.kind === "Decorator");
+        const tokens = mods.filter((m) => m.kind !== "Decorator");
+        const parts = [];
+        const gap = decoratorsOnNewLine ? doc_1.hardline : " ";
+        if (decorators.length)
+            parts.push((0, doc_1.join)(gap, decorators.map((d) => this.emit(d))), gap);
+        if (tokens.length)
+            parts.push((0, doc_1.join)(" ", tokens.map((t) => this.emit(t))), " ");
+        return (0, doc_1.concat)(parts);
+    }
+    heritage(clauses) {
+        return clauses && clauses.length
+            ? (0, doc_1.concat)([
+                " ",
+                (0, doc_1.join)(" ", clauses.map((c) => this.emit(c))),
+            ])
+            : "";
+    }
+    optType(type) {
+        return type ? (0, doc_1.concat)([": ", this.emit(type)]) : "";
+    }
+    optBody(body) {
+        return body ? (0, doc_1.concat)([" ", this.emit(body)]) : ";";
+    }
+    emit(node) {
+        switch (node.kind) {
+            /* names & tokens */
+            case "Identifier":
+                return node.text;
+            case "PrivateIdentifier":
+                return node.text;
+            case "QualifiedName":
+                return (0, doc_1.concat)([this.emit(node.left), ".", this.emit(node.right)]);
+            case "Token":
+                return (0, syntax_1.tokenToString)(node.token);
+            case "Decorator":
+                return (0, doc_1.concat)(["@", this.emit(node.expression)]);
+            /* literals */
+            case "StringLiteral":
+                return escapeString(node.text, node.singleQuote);
+            case "NumericLiteral":
+                return node.text;
+            case "BigIntLiteral":
+                return node.text;
+            /* expressions */
+            case "ArrayLiteralExpression":
+                return this.delim("[", node.elements.map((e) => this.emit(e)), "]", { trailingComma: true, forceBreak: node.multiLine === true });
+            case "ObjectLiteralExpression":
+                return this.delim("{", node.properties.map((p) => this.emit(p)), "}", {
+                    space: true,
+                    trailingComma: true,
+                    forceBreak: node.multiLine === true,
+                });
+            case "PropertyAssignment":
+                return (0, doc_1.concat)([
+                    this.emit(node.name),
+                    ": ",
+                    this.emit(node.initializer),
+                ]);
+            case "ShorthandPropertyAssignment":
+                return (0, doc_1.concat)([
+                    this.emit(node.name),
+                    node.objectAssignmentInitializer
+                        ? (0, doc_1.concat)([" = ", this.emit(node.objectAssignmentInitializer)])
+                        : "",
+                ]);
+            case "SpreadAssignment":
+                return (0, doc_1.concat)(["...", this.emit(node.expression)]);
+            case "PropertyAccessExpression":
+                return (0, doc_1.concat)([this.emit(node.expression), ".", this.emit(node.name)]);
+            case "ElementAccessExpression":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    "[",
+                    this.emit(node.argumentExpression),
+                    "]",
+                ]);
+            case "CallExpression":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    this.typeArguments(node.typeArguments),
+                    this.params(node.arguments),
+                ]);
+            case "NewExpression":
+                return (0, doc_1.concat)([
+                    "new ",
+                    this.emit(node.expression),
+                    this.typeArguments(node.typeArguments),
+                    this.params(node.arguments ?? []),
+                ]);
+            case "ParenthesizedExpression":
+                return (0, doc_1.concat)(["(", this.emit(node.expression), ")"]);
+            case "BinaryExpression":
+                return (0, doc_1.group)((0, doc_1.concat)([
+                    this.emit(node.left),
+                    " ",
+                    (0, syntax_1.tokenToString)(node.operator),
+                    (0, doc_1.indent)((0, doc_1.concat)([doc_1.line, this.emit(node.right)])),
+                ]));
+            case "PrefixUnaryExpression":
+                return (0, doc_1.concat)([(0, syntax_1.tokenToString)(node.operator), this.emit(node.operand)]);
+            case "PostfixUnaryExpression":
+                return (0, doc_1.concat)([this.emit(node.operand), (0, syntax_1.tokenToString)(node.operator)]);
+            case "ConditionalExpression":
+                return (0, doc_1.group)((0, doc_1.concat)([
+                    this.emit(node.condition),
+                    (0, doc_1.indent)((0, doc_1.concat)([
+                        doc_1.line,
+                        "? ",
+                        this.emit(node.whenTrue),
+                        doc_1.line,
+                        ": ",
+                        this.emit(node.whenFalse),
+                    ])),
+                ]));
+            case "ArrowFunction":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                    " => ",
+                    this.emit(node.body),
+                ]);
+            case "FunctionExpression":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    "function",
+                    node.asteriskToken ? "*" : "",
+                    node.name ? (0, doc_1.concat)([" ", this.emit(node.name)]) : " ",
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                    " ",
+                    this.emit(node.body),
+                ]);
+            case "AsExpression":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    " as ",
+                    this.emit(node.type),
+                ]);
+            case "SatisfiesExpression":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    " satisfies ",
+                    this.emit(node.type),
+                ]);
+            case "NonNullExpression":
+                return (0, doc_1.concat)([this.emit(node.expression), "!"]);
+            case "SpreadElement":
+                return (0, doc_1.concat)(["...", this.emit(node.expression)]);
+            case "AwaitExpression":
+                return (0, doc_1.concat)(["await ", this.emit(node.expression)]);
+            case "TypeOfExpression":
+                return (0, doc_1.concat)(["typeof ", this.emit(node.expression)]);
+            /* types */
+            case "KeywordTypeNode":
+                return (0, syntax_1.tokenToString)(node.keyword);
+            case "TypeReferenceNode":
+                return (0, doc_1.concat)([
+                    this.emit(node.typeName),
+                    this.typeArguments(node.typeArguments),
+                ]);
+            case "ArrayTypeNode":
+                return (0, doc_1.concat)([this.emit(node.elementType), "[]"]);
+            case "UnionTypeNode":
+                return this.binaryType("|", node.types.map((t) => this.emit(t)));
+            case "IntersectionTypeNode":
+                return this.binaryType("&", node.types.map((t) => this.emit(t)));
+            case "LiteralTypeNode":
+                return this.emit(node.literal);
+            case "TypeLiteralNode":
+                return this.memberBlock(node.members.map((m) => this.emit(m)), false);
+            case "FunctionTypeNode":
+                return (0, doc_1.concat)([
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    " => ",
+                    this.emit(node.type),
+                ]);
+            case "TupleTypeNode":
+                return this.delim("[", node.elements.map((e) => this.emit(e)), "]", {
+                    trailingComma: true,
+                });
+            case "ParenthesizedTypeNode":
+                return (0, doc_1.concat)(["(", this.emit(node.type), ")"]);
+            case "TypeOperatorNode":
+                return (0, doc_1.concat)([
+                    (0, syntax_1.tokenToString)(node.operator),
+                    " ",
+                    this.emit(node.type),
+                ]);
+            case "IndexedAccessTypeNode":
+                return (0, doc_1.concat)([
+                    this.emit(node.objectType),
+                    "[",
+                    this.emit(node.indexType),
+                    "]",
+                ]);
+            case "TypeQueryNode":
+                return (0, doc_1.concat)(["typeof ", this.emit(node.exprName)]);
+            case "ExpressionWithTypeArguments":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    this.typeArguments(node.typeArguments),
+                ]);
+            case "PropertySignature":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    this.emit(node.name),
+                    node.questionToken ? "?" : "",
+                    this.optType(node.type),
+                ]);
+            case "IndexSignature":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    "[",
+                    (0, doc_1.join)(", ", node.parameters.map((p) => this.emit(p))),
+                    "]: ",
+                    this.emit(node.type),
+                ]);
+            case "MethodSignature":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    this.emit(node.name),
+                    node.questionToken ? "?" : "",
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                ]);
+            case "TypeParameterDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    this.emit(node.name),
+                    node.constraint
+                        ? (0, doc_1.concat)([" extends ", this.emit(node.constraint)])
+                        : "",
+                    node.default ? (0, doc_1.concat)([" = ", this.emit(node.default)]) : "",
+                ]);
+            /* support */
+            case "ParameterDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    node.dotDotDotToken ? "..." : "",
+                    this.emit(node.name),
+                    node.questionToken ? "?" : "",
+                    this.optType(node.type),
+                    node.initializer ? (0, doc_1.concat)([" = ", this.emit(node.initializer)]) : "",
+                ]);
+            case "HeritageClause":
+                return (0, doc_1.concat)([
+                    (0, syntax_1.tokenToString)(node.token),
+                    " ",
+                    (0, doc_1.join)(", ", node.types.map((t) => this.emit(t))),
+                ]);
+            /* statements */
+            case "VariableStatement":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    this.emit(node.declarationList),
+                    ";",
+                ]);
+            case "VariableDeclarationList": {
+                const keyword = node.flags === 2 ? "const" : node.flags === 1 ? "let" : "var";
+                return (0, doc_1.concat)([
+                    keyword,
+                    " ",
+                    (0, doc_1.join)(", ", node.declarations.map((d) => this.emit(d))),
+                ]);
+            }
+            case "VariableDeclaration":
+                return (0, doc_1.concat)([
+                    this.emit(node.name),
+                    node.exclamationToken ? "!" : "",
+                    this.optType(node.type),
+                    node.initializer ? (0, doc_1.concat)([" = ", this.emit(node.initializer)]) : "",
+                ]);
+            case "ExpressionStatement":
+                return (0, doc_1.concat)([this.emit(node.expression), ";"]);
+            case "ReturnStatement":
+                return node.expression
+                    ? (0, doc_1.concat)(["return ", this.emit(node.expression), ";"])
+                    : "return;";
+            case "ThrowStatement":
+                return (0, doc_1.concat)(["throw ", this.emit(node.expression), ";"]);
+            case "IfStatement":
+                return (0, doc_1.concat)([
+                    "if (",
+                    this.emit(node.expression),
+                    ") ",
+                    this.emit(node.thenStatement),
+                    node.elseStatement
+                        ? (0, doc_1.concat)([" else ", this.emit(node.elseStatement)])
+                        : "",
+                ]);
+            case "Block":
+                return this.statementBlock(node.statements.map((s) => this.emit(s)));
+            /* declarations */
+            case "FunctionDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "function",
+                    node.asteriskToken ? "*" : "",
+                    " ",
+                    node.name ? this.emit(node.name) : "",
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                    this.optBody(node.body),
+                ]);
+            case "ClassDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "class",
+                    node.name ? (0, doc_1.concat)([" ", this.emit(node.name)]) : "",
+                    this.typeArguments(node.typeParameters),
+                    this.heritage(node.heritageClauses),
+                    " ",
+                    this.statementBlock(node.members.map((m) => this.emit(m))),
+                ]);
+            case "PropertyDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    this.emit(node.name),
+                    node.questionOrExclamationToken
+                        ? this.emit(node.questionOrExclamationToken)
+                        : "",
+                    this.optType(node.type),
+                    node.initializer ? (0, doc_1.concat)([" = ", this.emit(node.initializer)]) : "",
+                    ";",
+                ]);
+            case "MethodDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    node.asteriskToken ? "*" : "",
+                    this.emit(node.name),
+                    node.questionToken ? "?" : "",
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                    this.optBody(node.body),
+                ]);
+            case "ConstructorDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "constructor",
+                    this.params(node.parameters),
+                    this.optBody(node.body),
+                ]);
+            case "GetAccessorDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "get ",
+                    this.emit(node.name),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                    this.optBody(node.body),
+                ]);
+            case "SetAccessorDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "set ",
+                    this.emit(node.name),
+                    this.params(node.parameters),
+                    this.optBody(node.body),
+                ]);
+            case "InterfaceDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "interface ",
+                    this.emit(node.name),
+                    this.typeArguments(node.typeParameters),
+                    this.heritage(node.heritageClauses),
+                    " ",
+                    this.memberBlock(node.members.map((m) => this.emit(m)), true),
+                ]);
+            case "TypeAliasDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "type ",
+                    this.emit(node.name),
+                    this.typeArguments(node.typeParameters),
+                    " = ",
+                    this.emit(node.type),
+                    ";",
+                ]);
+            case "EnumDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "enum ",
+                    this.emit(node.name),
+                    " ",
+                    node.members.length === 0
+                        ? "{}"
+                        : (0, doc_1.concat)([
+                            "{",
+                            (0, doc_1.indent)((0, doc_1.concat)([
+                                doc_1.hardline,
+                                (0, doc_1.join)((0, doc_1.concat)([",", doc_1.hardline]), node.members.map((m) => this.emit(m))),
+                                ",",
+                            ])),
+                            doc_1.hardline,
+                            "}",
+                        ]),
+                ]);
+            case "EnumMember":
+                return (0, doc_1.concat)([
+                    this.emit(node.name),
+                    node.initializer ? (0, doc_1.concat)([" = ", this.emit(node.initializer)]) : "",
+                ]);
+            /* imports & exports */
+            case "ImportDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    "import ",
+                    node.importClause
+                        ? (0, doc_1.concat)([this.emit(node.importClause), " from "])
+                        : "",
+                    this.emit(node.moduleSpecifier),
+                    ";",
+                ]);
+            case "ImportClause": {
+                const named = [];
+                if (node.name)
+                    named.push(this.emit(node.name));
+                if (node.namedBindings)
+                    named.push(this.emit(node.namedBindings));
+                return (0, doc_1.concat)([node.isTypeOnly ? "type " : "", (0, doc_1.join)(", ", named)]);
+            }
+            case "NamedImports":
+                return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: true });
+            case "ImportSpecifier":
+                return (0, doc_1.concat)([
+                    node.isTypeOnly ? "type " : "",
+                    node.propertyName
+                        ? (0, doc_1.concat)([this.emit(node.propertyName), " as "])
+                        : "",
+                    this.emit(node.name),
+                ]);
+            case "NamespaceImport":
+                return (0, doc_1.concat)(["* as ", this.emit(node.name)]);
+            case "ExportDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    "export ",
+                    node.isTypeOnly ? "type " : "",
+                    node.exportClause ? this.emit(node.exportClause) : "*",
+                    node.moduleSpecifier
+                        ? (0, doc_1.concat)([" from ", this.emit(node.moduleSpecifier)])
+                        : "",
+                    ";",
+                ]);
+            case "NamedExports":
+                return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: true });
+            case "ExportSpecifier":
+                return (0, doc_1.concat)([
+                    node.isTypeOnly ? "type " : "",
+                    node.propertyName
+                        ? (0, doc_1.concat)([this.emit(node.propertyName), " as "])
+                        : "",
+                    this.emit(node.name),
+                ]);
+            case "ExportAssignment":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    node.isExportEquals ? "export = " : "export default ",
+                    this.emit(node.expression),
+                    ";",
+                ]);
+            /* source file */
+            case "SourceFile":
+                return (0, doc_1.concat)([
+                    (0, doc_1.join)(doc_1.hardline, node.statements.map((s) => this.emit(s))),
+                    doc_1.hardline,
+                ]);
+            /* loops & flow */
+            case "ForStatement":
+                return (0, doc_1.concat)([
+                    "for (",
+                    node.initializer ? this.emit(node.initializer) : "",
+                    "; ",
+                    node.condition ? this.emit(node.condition) : "",
+                    "; ",
+                    node.incrementor ? this.emit(node.incrementor) : "",
+                    ") ",
+                    this.emit(node.statement),
+                ]);
+            case "ForInStatement":
+                return (0, doc_1.concat)([
+                    "for (",
+                    this.emit(node.initializer),
+                    " in ",
+                    this.emit(node.expression),
+                    ") ",
+                    this.emit(node.statement),
+                ]);
+            case "ForOfStatement":
+                return (0, doc_1.concat)([
+                    "for ",
+                    node.awaitModifier ? "await " : "",
+                    "(",
+                    this.emit(node.initializer),
+                    " of ",
+                    this.emit(node.expression),
+                    ") ",
+                    this.emit(node.statement),
+                ]);
+            case "WhileStatement":
+                return (0, doc_1.concat)([
+                    "while (",
+                    this.emit(node.expression),
+                    ") ",
+                    this.emit(node.statement),
+                ]);
+            case "DoStatement":
+                return (0, doc_1.concat)([
+                    "do ",
+                    this.emit(node.statement),
+                    " while (",
+                    this.emit(node.expression),
+                    ");",
+                ]);
+            case "SwitchStatement":
+                return (0, doc_1.concat)([
+                    "switch (",
+                    this.emit(node.expression),
+                    ") ",
+                    this.emit(node.caseBlock),
+                ]);
+            case "CaseBlock":
+                return node.clauses.length === 0
+                    ? "{}"
+                    : (0, doc_1.concat)([
+                        "{",
+                        (0, doc_1.indent)((0, doc_1.concat)([
+                            doc_1.hardline,
+                            (0, doc_1.join)(doc_1.hardline, node.clauses.map((c) => this.emit(c))),
+                        ])),
+                        doc_1.hardline,
+                        "}",
+                    ]);
+            case "CaseClause":
+                return (0, doc_1.concat)([
+                    "case ",
+                    this.emit(node.expression),
+                    ":",
+                    node.statements.length
+                        ? (0, doc_1.indent)((0, doc_1.concat)([
+                            doc_1.hardline,
+                            (0, doc_1.join)(doc_1.hardline, node.statements.map((s) => this.emit(s))),
+                        ]))
+                        : "",
+                ]);
+            case "DefaultClause":
+                return (0, doc_1.concat)([
+                    "default:",
+                    node.statements.length
+                        ? (0, doc_1.indent)((0, doc_1.concat)([
+                            doc_1.hardline,
+                            (0, doc_1.join)(doc_1.hardline, node.statements.map((s) => this.emit(s))),
+                        ]))
+                        : "",
+                ]);
+            case "BreakStatement":
+                return node.label
+                    ? (0, doc_1.concat)(["break ", this.emit(node.label), ";"])
+                    : "break;";
+            case "ContinueStatement":
+                return node.label
+                    ? (0, doc_1.concat)(["continue ", this.emit(node.label), ";"])
+                    : "continue;";
+            case "TryStatement":
+                return (0, doc_1.concat)([
+                    "try ",
+                    this.emit(node.tryBlock),
+                    node.catchClause ? (0, doc_1.concat)([" ", this.emit(node.catchClause)]) : "",
+                    node.finallyBlock
+                        ? (0, doc_1.concat)([" finally ", this.emit(node.finallyBlock)])
+                        : "",
+                ]);
+            case "CatchClause":
+                return node.variableDeclaration
+                    ? (0, doc_1.concat)([
+                        "catch (",
+                        this.emit(node.variableDeclaration),
+                        ") ",
+                        this.emit(node.block),
+                    ])
+                    : (0, doc_1.concat)(["catch ", this.emit(node.block)]);
+            case "LabeledStatement":
+                return (0, doc_1.concat)([this.emit(node.label), ": ", this.emit(node.statement)]);
+            case "WithStatement":
+                return (0, doc_1.concat)([
+                    "with (",
+                    this.emit(node.expression),
+                    ") ",
+                    this.emit(node.statement),
+                ]);
+            case "DebuggerStatement":
+                return "debugger;";
+            case "EmptyStatement":
+                return ";";
+            /* modules & namespaces */
+            case "ModuleDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    node.name.kind === "StringLiteral" ? "module " : "namespace ",
+                    this.emit(node.name),
+                    node.body ? (0, doc_1.concat)([" ", this.emit(node.body)]) : ";",
+                ]);
+            case "ModuleBlock":
+                return this.statementBlock(node.statements.map((s) => this.emit(s)));
+            case "ClassStaticBlockDeclaration":
+                return (0, doc_1.concat)(["static ", this.emit(node.body)]);
+            case "ImportEqualsDeclaration":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    "import ",
+                    node.isTypeOnly ? "type " : "",
+                    this.emit(node.name),
+                    " = ",
+                    this.emit(node.moduleReference),
+                    ";",
+                ]);
+            case "ExternalModuleReference":
+                return (0, doc_1.concat)(["require(", this.emit(node.expression), ")"]);
+            case "NamespaceExportDeclaration":
+                return (0, doc_1.concat)(["export as namespace ", this.emit(node.name), ";"]);
+            case "SemicolonClassElement":
+                return ";";
+            case "NamespaceExport":
+                return (0, doc_1.concat)(["* as ", this.emit(node.name)]);
+            /* advanced types */
+            case "ThisTypeNode":
+                return "this";
+            case "ConstructorTypeNode":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, false),
+                    "new ",
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    " => ",
+                    this.emit(node.type),
+                ]);
+            case "TypePredicateNode":
+                return (0, doc_1.concat)([
+                    node.assertsModifier ? "asserts " : "",
+                    this.emit(node.parameterName),
+                    node.type ? (0, doc_1.concat)([" is ", this.emit(node.type)]) : "",
+                ]);
+            case "ConditionalTypeNode":
+                return (0, doc_1.concat)([
+                    this.emit(node.checkType),
+                    " extends ",
+                    this.emit(node.extendsType),
+                    " ? ",
+                    this.emit(node.trueType),
+                    " : ",
+                    this.emit(node.falseType),
+                ]);
+            case "InferTypeNode":
+                return (0, doc_1.concat)(["infer ", this.emit(node.typeParameter)]);
+            case "MappedTypeNode": {
+                const ro = node.readonlyToken
+                    ? (0, syntax_1.tokenToString)(node.readonlyToken.token) === "readonly"
+                        ? "readonly "
+                        : `${(0, syntax_1.tokenToString)(node.readonlyToken.token)}readonly `
+                    : "";
+                const q = node.questionToken
+                    ? (0, syntax_1.tokenToString)(node.questionToken.token) === "?"
+                        ? "?"
+                        : `${(0, syntax_1.tokenToString)(node.questionToken.token)}?`
+                    : "";
+                return (0, doc_1.concat)([
+                    "{ ",
+                    ro,
+                    "[",
+                    this.emit(node.typeParameter.name),
+                    " in ",
+                    node.typeParameter.constraint
+                        ? this.emit(node.typeParameter.constraint)
+                        : "",
+                    node.nameType ? (0, doc_1.concat)([" as ", this.emit(node.nameType)]) : "",
+                    "]",
+                    q,
+                    node.type ? (0, doc_1.concat)([": ", this.emit(node.type)]) : "",
+                    " }",
+                ]);
+            }
+            case "TemplateLiteralType":
+                return (0, doc_1.concat)([
+                    this.emit(node.head),
+                    (0, doc_1.concat)(node.templateSpans.map((s) => this.emit(s))),
+                ]);
+            case "TemplateLiteralTypeSpan":
+                return (0, doc_1.concat)([this.emit(node.type), this.emit(node.literal)]);
+            case "NamedTupleMember":
+                return (0, doc_1.concat)([
+                    node.dotDotDotToken ? "..." : "",
+                    this.emit(node.name),
+                    node.questionToken ? "?" : "",
+                    ": ",
+                    this.emit(node.type),
+                ]);
+            case "OptionalTypeNode":
+                return (0, doc_1.concat)([this.emit(node.type), "?"]);
+            case "RestTypeNode":
+                return (0, doc_1.concat)(["...", this.emit(node.type)]);
+            case "ImportTypeNode":
+                return (0, doc_1.concat)([
+                    node.isTypeOf ? "typeof " : "",
+                    "import(",
+                    this.emit(node.argument),
+                    ")",
+                    node.qualifier ? (0, doc_1.concat)([".", this.emit(node.qualifier)]) : "",
+                    this.typeArguments(node.typeArguments),
+                ]);
+            case "CallSignature":
+                return (0, doc_1.concat)([
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                ]);
+            case "ConstructSignature":
+                return (0, doc_1.concat)([
+                    "new ",
+                    this.typeArguments(node.typeParameters),
+                    this.params(node.parameters),
+                    this.optType(node.type),
+                ]);
+            /* template literals */
+            case "TemplateHead":
+                return (0, doc_1.concat)(["`", node.text, "${"]);
+            case "TemplateMiddle":
+                return (0, doc_1.concat)(["}", node.text, "${"]);
+            case "TemplateTail":
+                return (0, doc_1.concat)(["}", node.text, "`"]);
+            case "NoSubstitutionTemplateLiteral":
+                return (0, doc_1.concat)(["`", node.text, "`"]);
+            /* template & misc expressions */
+            case "TemplateExpression":
+                return (0, doc_1.concat)([
+                    this.emit(node.head),
+                    (0, doc_1.concat)(node.templateSpans.map((s) => this.emit(s))),
+                ]);
+            case "TemplateSpan":
+                return (0, doc_1.concat)([this.emit(node.expression), this.emit(node.literal)]);
+            case "TaggedTemplateExpression":
+                return (0, doc_1.concat)([
+                    this.emit(node.tag),
+                    this.typeArguments(node.typeArguments),
+                    this.emit(node.template),
+                ]);
+            case "YieldExpression":
+                return (0, doc_1.concat)([
+                    "yield",
+                    node.asteriskToken ? "*" : "",
+                    node.expression ? (0, doc_1.concat)([" ", this.emit(node.expression)]) : "",
+                ]);
+            case "DeleteExpression":
+                return (0, doc_1.concat)(["delete ", this.emit(node.expression)]);
+            case "VoidExpression":
+                return (0, doc_1.concat)(["void ", this.emit(node.expression)]);
+            case "RegularExpressionLiteral":
+                return node.text;
+            case "ClassExpression":
+                return (0, doc_1.concat)([
+                    this.modifiers(node.modifiers, true),
+                    "class",
+                    node.name ? (0, doc_1.concat)([" ", this.emit(node.name)]) : "",
+                    this.typeArguments(node.typeParameters),
+                    this.heritage(node.heritageClauses),
+                    " ",
+                    this.statementBlock(node.members.map((m) => this.emit(m))),
+                ]);
+            case "MetaProperty":
+                return (0, doc_1.concat)([
+                    (0, syntax_1.tokenToString)(node.keywordToken),
+                    ".",
+                    this.emit(node.name),
+                ]);
+            case "CommaListExpression":
+                return (0, doc_1.join)(", ", node.elements.map((e) => this.emit(e)));
+            case "ComputedPropertyName":
+                return (0, doc_1.concat)(["[", this.emit(node.expression), "]"]);
+            case "OmittedExpression":
+                return "";
+            case "BindingElement":
+                return (0, doc_1.concat)([
+                    node.dotDotDotToken ? "..." : "",
+                    node.propertyName ? (0, doc_1.concat)([this.emit(node.propertyName), ": "]) : "",
+                    this.emit(node.name),
+                    node.initializer ? (0, doc_1.concat)([" = ", this.emit(node.initializer)]) : "",
+                ]);
+            case "ObjectBindingPattern":
+                return this.delim("{", node.elements.map((e) => this.emit(e)), "}", { space: true, trailingComma: true });
+            case "ArrayBindingPattern":
+                return this.delim("[", node.elements.map((e) => this.emit(e)), "]", { trailingComma: true });
+            case "TypeAssertion":
+                return (0, doc_1.concat)([
+                    "<",
+                    this.emit(node.type),
+                    ">",
+                    this.emit(node.expression),
+                ]);
+            case "PropertyAccessChain":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    node.questionDotToken ? "?." : ".",
+                    this.emit(node.name),
+                ]);
+            case "ElementAccessChain":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    node.questionDotToken ? "?." : "",
+                    "[",
+                    this.emit(node.argumentExpression),
+                    "]",
+                ]);
+            case "CallChain":
+                return (0, doc_1.concat)([
+                    this.emit(node.expression),
+                    node.questionDotToken ? "?." : "",
+                    this.typeArguments(node.typeArguments),
+                    this.params(node.arguments),
+                ]);
+            case "NonNullChain":
+                return (0, doc_1.concat)([this.emit(node.expression), "!"]);
+            default:
+                return this.unsupported(node);
+        }
+    }
+    /** Width-aware `|` / `&` type list with leading-operator breaks. */
+    binaryType(operator, parts) {
+        if (parts.length === 1)
+            return parts[0];
+        return (0, doc_1.group)((0, doc_1.indent)((0, doc_1.concat)([
+            (0, doc_1.ifBreak)((0, doc_1.concat)([doc_1.line, operator, " "])),
+            (0, doc_1.join)((0, doc_1.concat)([doc_1.line, operator, " "]), parts),
+        ])));
+    }
+    unsupported(node) {
+        throw new Error(`@ttsc/factory: TsPrinter cannot print node of kind "${node.kind}".`);
+    }
+}
+exports.TsPrinter = TsPrinter;
+//# sourceMappingURL=TsPrinter.js.map