@ttsc/factory 0.15.7 → 0.15.9

package/lib/TsPrinter.mjs

@@ -1,1342 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TsPrinter = void 0;
-const comments_1 = require("./comments");
-const doc_1 = require("./internal/doc");
-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.
-     *
-     * A bare {@link import("./ast").Identifier} member acts as a blank-line spacer
-     * (the legacy `createIdentifier("\n")` codegen idiom): it inserts an empty
-     * line between members and carries no `;` terminator, matching the legacy
-     * printer.
-     */
-    memberBlock(members, forceBreak) {
-        const inner = [];
-        let first = true;
-        let blank = false;
-        for (const member of members) {
-            if (member.kind === "Identifier") {
-                blank = true;
-                continue;
-            }
-            if (!first)
-                inner.push(";", doc_1.line);
-            if (blank) {
-                inner.push(doc_1.hardline);
-                blank = false;
-            }
-            inner.push(this.emit(member));
-            first = false;
-        }
-        if (inner.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.concat)(inner)])),
-            (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) {
-        // type-argument / type-parameter lists disallow a trailing comma (TS1009)
-        return args && args.length
-            ? this.delim("<", args.map((a) => this.emit(a)), ">", {
-                trailingComma: false,
-            })
-            : "";
-    }
-    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) {
-        const body = this.emitNode(node);
-        const leading = (0, comments_1.getSyntheticLeadingComments)(node);
-        const trailing = (0, comments_1.getSyntheticTrailingComments)(node);
-        if ((leading === undefined || leading.length === 0) &&
-            (trailing === undefined || trailing.length === 0))
-            return body;
-        const parts = [];
-        if (leading !== undefined)
-            for (const comment of leading)
-                parts.push(this.leadingComment(comment));
-        parts.push(body);
-        if (trailing !== undefined)
-            for (const comment of trailing)
-                parts.push(this.trailingComment(comment));
-        return (0, doc_1.concat)(parts);
-    }
-    /** Render a leading comment followed by its node separator. */
-    leadingComment(comment) {
-        // a `//` comment must terminate the line; a `/* */` honours its own flag
-        const newLine = comment.kind === "//" /* SyntaxKind.SingleLineCommentTrivia */ ||
-            comment.hasTrailingNewLine === true;
-        return (0, doc_1.concat)([this.commentBody(comment), newLine ? doc_1.hardline : " "]);
-    }
-    /** Render a trailing comment preceded by its node separator. */
-    trailingComment(comment) {
-        const newLine = comment.kind === "//" /* SyntaxKind.SingleLineCommentTrivia */ ||
-            comment.hasTrailingNewLine === true;
-        return (0, doc_1.concat)([
-            comment.hasLeadingNewLine === true ? doc_1.hardline : " ",
-            this.commentBody(comment),
-            newLine ? doc_1.hardline : "",
-        ]);
-    }
-    /** Render the delimited comment body, re-flowing embedded line breaks. */
-    commentBody(comment) {
-        if (comment.kind === "//" /* SyntaxKind.SingleLineCommentTrivia */)
-            return (0, doc_1.concat)(["//", comment.text]);
-        // re-emit embedded newlines as hardlines so each line re-indents in place
-        return (0, doc_1.concat)([
-            "/*",
-            (0, doc_1.join)(doc_1.hardline, comment.text.replace(/\r\n?/g, "\n").split("\n")),
-            "*/",
-        ]);
-    }
-    emitNode(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 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),
-                    " ",
-                    node.operator,
-                    (0, doc_1.indent)((0, doc_1.concat)([doc_1.line, this.emit(node.right)])),
-                ]));
-            case "PrefixUnaryExpression":
-                return (0, doc_1.concat)([node.operator, this.emit(node.operand)]);
-            case "PostfixUnaryExpression":
-                return (0, doc_1.concat)([this.emit(node.operand), 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 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.postfixTypeOperand(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, 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)([node.operator, " ", this.emit(node.type)]);
-            case "IndexedAccessTypeNode":
-                return (0, doc_1.concat)([
-                    this.postfixTypeOperand(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)([
-                    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 === "const" /* NodeFlags.Const */
-                    ? "const"
-                    : node.flags === "let" /* NodeFlags.Let */
-                        ? "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, 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
-                    ? node.readonlyToken.token === "readonly"
-                        ? "readonly "
-                        : `${node.readonlyToken.token}readonly `
-                    : "";
-                const q = node.questionToken
-                    ? node.questionToken.token === "?"
-                        ? "?"
-                        : `${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)([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), "!"]);
-            /* jsx */
-            case "JsxElement":
-                return (0, doc_1.group)((0, doc_1.concat)([
-                    this.emit(node.openingElement),
-                    (0, doc_1.indent)((0, doc_1.concat)(node.children.map((c) => (0, doc_1.concat)([doc_1.softline, this.emit(c)])))),
-                    doc_1.softline,
-                    this.emit(node.closingElement),
-                ]));
-            case "JsxSelfClosingElement":
-                return (0, doc_1.concat)([
-                    "<",
-                    this.emit(node.tagName),
-                    this.typeArguments(node.typeArguments),
-                    this.emit(node.attributes),
-                    " />",
-                ]);
-            case "JsxOpeningElement":
-                return (0, doc_1.concat)([
-                    "<",
-                    this.emit(node.tagName),
-                    this.typeArguments(node.typeArguments),
-                    this.emit(node.attributes),
-                    ">",
-                ]);
-            case "JsxClosingElement":
-                return (0, doc_1.concat)(["</", this.emit(node.tagName), ">"]);
-            case "JsxFragment":
-                return (0, doc_1.group)((0, doc_1.concat)([
-                    this.emit(node.openingFragment),
-                    (0, doc_1.indent)((0, doc_1.concat)(node.children.map((c) => (0, doc_1.concat)([doc_1.softline, this.emit(c)])))),
-                    doc_1.softline,
-                    this.emit(node.closingFragment),
-                ]));
-            case "JsxOpeningFragment":
-                return "<>";
-            case "JsxClosingFragment":
-                return "</>";
-            case "JsxText":
-                return node.text;
-            case "JsxAttribute":
-                return node.initializer === undefined
-                    ? this.emit(node.name)
-                    : (0, doc_1.concat)([this.emit(node.name), "=", this.emit(node.initializer)]);
-            case "JsxAttributes":
-                return node.properties.length === 0
-                    ? ""
-                    : (0, doc_1.concat)(node.properties.map((p) => (0, doc_1.concat)([" ", this.emit(p)])));
-            case "JsxSpreadAttribute":
-                return (0, doc_1.concat)(["{...", this.emit(node.expression), "}"]);
-            case "JsxExpression":
-                return (0, doc_1.concat)([
-                    "{",
-                    node.dotDotDotToken ? "..." : "",
-                    node.expression ? this.emit(node.expression) : "",
-                    "}",
-                ]);
-            case "JsxNamespacedName":
-                return (0, doc_1.concat)([this.emit(node.namespace), ":", this.emit(node.name)]);
-            /* synthetic / emit-internal */
-            case "Bundle":
-                return (0, doc_1.join)(doc_1.hardline, node.sourceFiles.map((s) => this.emit(s)));
-            case "PartiallyEmittedExpression":
-                return this.emit(node.expression);
-            case "ImportAttribute":
-                return (0, doc_1.concat)([this.emit(node.name), ": ", this.emit(node.value)]);
-            case "ImportAttributes":
-                return node.elements.length === 0
-                    ? (0, doc_1.concat)([node.token, " {}"])
-                    : (0, doc_1.concat)([
-                        node.token,
-                        " { ",
-                        (0, doc_1.join)(", ", node.elements.map((e) => this.emit(e))),
-                        " }",
-                    ]);
-            case "NotEmittedStatement":
-            case "NotEmittedTypeElement":
-                return "";
-            /* jsdoc — types */
-            case "JSDocAllType":
-                return "*";
-            case "JSDocUnknownType":
-                return "?";
-            case "JSDocNonNullableType":
-                return node.postfix
-                    ? (0, doc_1.concat)([this.emit(node.type), "!"])
-                    : (0, doc_1.concat)(["!", this.emit(node.type)]);
-            case "JSDocNullableType":
-                return node.postfix
-                    ? (0, doc_1.concat)([this.emit(node.type), "?"])
-                    : (0, doc_1.concat)(["?", this.emit(node.type)]);
-            case "JSDocOptionalType":
-                return (0, doc_1.concat)([this.emit(node.type), "="]);
-            case "JSDocVariadicType":
-                return (0, doc_1.concat)(["...", this.emit(node.type)]);
-            case "JSDocNamepathType":
-                return this.emit(node.type);
-            case "JSDocFunctionType":
-                return (0, doc_1.concat)([
-                    "function(",
-                    (0, doc_1.join)(", ", node.parameters.map((p) => this.emit(p))),
-                    ")",
-                    node.type ? (0, doc_1.concat)([": ", this.emit(node.type)]) : "",
-                ]);
-            case "JSDocTypeExpression":
-                return (0, doc_1.concat)(["{", this.emit(node.type), "}"]);
-            case "JSDocNameReference":
-                return this.emit(node.name);
-            case "JSDocMemberName":
-                return (0, doc_1.concat)([this.emit(node.left), "#", this.emit(node.right)]);
-            case "JSDocLink":
-                return (0, doc_1.concat)([
-                    "{@link ",
-                    node.name ? this.emit(node.name) : "",
-                    node.text,
-                    "}",
-                ]);
-            case "JSDocLinkCode":
-                return (0, doc_1.concat)([
-                    "{@linkcode ",
-                    node.name ? this.emit(node.name) : "",
-                    node.text,
-                    "}",
-                ]);
-            case "JSDocLinkPlain":
-                return (0, doc_1.concat)([
-                    "{@linkplain ",
-                    node.name ? this.emit(node.name) : "",
-                    node.text,
-                    "}",
-                ]);
-            case "JSDocText":
-                return node.text;
-            case "JSDocTypeLiteral":
-                return (0, doc_1.concat)([
-                    (0, doc_1.join)(doc_1.hardline, (node.jsDocPropertyTags ?? []).map((t) => this.emit(t))),
-                    node.isArrayType ? "[]" : "",
-                ]);
-            case "JSDocSignature":
-                return (0, doc_1.join)(doc_1.hardline, [
-                    ...(node.typeParameters ?? []),
-                    ...node.parameters,
-                    ...(node.type ? [node.type] : []),
-                ].map((t) => this.emit(t)));
-            case "JSDoc": {
-                const body = node.comment === undefined
-                    ? ""
-                    : typeof node.comment === "string"
-                        ? node.comment
-                        : (0, doc_1.concat)(node.comment.map((c) => this.emit(c)));
-                const lines = [(0, doc_1.concat)([" * ", body])];
-                for (const tag of node.tags ?? [])
-                    lines.push((0, doc_1.concat)([" * ", this.emit(tag)]));
-                return (0, doc_1.concat)([
-                    "/**",
-                    doc_1.hardline,
-                    (0, doc_1.join)(doc_1.hardline, lines),
-                    doc_1.hardline,
-                    " */",
-                ]);
-            }
-            /* jsdoc — tags */
-            case "JSDocTypeTag":
-            case "JSDocThisTag":
-            case "JSDocEnumTag":
-            case "JSDocSatisfiesTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    " ",
-                    this.emit(node.typeExpression),
-                    this.jsDocComment(node.comment),
-                ]);
-            case "JSDocReturnTag":
-            case "JSDocThrowsTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    node.typeExpression
-                        ? (0, doc_1.concat)([" ", this.emit(node.typeExpression)])
-                        : "",
-                    this.jsDocComment(node.comment),
-                ]);
-            case "JSDocAuthorTag":
-            case "JSDocClassTag":
-            case "JSDocPublicTag":
-            case "JSDocPrivateTag":
-            case "JSDocProtectedTag":
-            case "JSDocReadonlyTag":
-            case "JSDocOverrideTag":
-            case "JSDocDeprecatedTag":
-            case "JSDocUnknownTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    this.jsDocComment(node.comment),
-                ]);
-            case "JSDocAugmentsTag":
-            case "JSDocImplementsTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    " {",
-                    this.emit(node.class),
-                    "}",
-                    this.jsDocComment(node.comment),
-                ]);
-            case "JSDocParameterTag":
-            case "JSDocPropertyTag": {
-                const name = node.isBracketed
-                    ? (0, doc_1.concat)(["[", this.emit(node.name), "]"])
-                    : this.emit(node.name);
-                const type = node.typeExpression
-                    ? this.emit(node.typeExpression)
-                    : undefined;
-                const main = node.isNameFirst
-                    ? (0, doc_1.concat)([name, type ? (0, doc_1.concat)([" ", type]) : ""])
-                    : (0, doc_1.concat)([type ? (0, doc_1.concat)([type, " "]) : "", name]);
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    " ",
-                    main,
-                    this.jsDocComment(node.comment),
-                ]);
-            }
-            case "JSDocSeeTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    node.name ? (0, doc_1.concat)([" ", this.emit(node.name)]) : "",
-                    this.jsDocComment(node.comment),
-                ]);
-            case "JSDocOverloadTag":
-            case "JSDocCallbackTag": {
-                const full = node.kind === "JSDocCallbackTag" && node.fullName
-                    ? (0, doc_1.concat)([" ", this.emit(node.fullName)])
-                    : "";
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    full,
-                    doc_1.hardline,
-                    this.emit(node.typeExpression),
-                    this.jsDocComment(node.comment),
-                ]);
-            }
-            case "JSDocImportTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    " ",
-                    node.importClause
-                        ? (0, doc_1.concat)([this.emit(node.importClause), " from "])
-                        : "",
-                    this.emit(node.moduleSpecifier),
-                    this.jsDocComment(node.comment),
-                ]);
-            case "JSDocTemplateTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    node.constraint ? (0, doc_1.concat)([" ", this.emit(node.constraint)]) : "",
-                    " ",
-                    (0, doc_1.join)(", ", node.typeParameters.map((t) => this.emit(t))),
-                    this.jsDocComment(node.comment),
-                ]);
-            case "JSDocTypedefTag":
-                return (0, doc_1.concat)([
-                    "@",
-                    this.emit(node.tagName),
-                    node.typeExpression
-                        ? (0, doc_1.concat)([" ", this.emit(node.typeExpression)])
-                        : "",
-                    node.fullName ? (0, doc_1.concat)([" ", this.emit(node.fullName)]) : "",
-                    this.jsDocComment(node.comment),
-                ]);
-            default:
-                return this.unsupported(node);
-        }
-    }
-    /**
-     * Emit a type in the operand position of a postfix type (`T[]`, `T[K]`),
-     * 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" ||
-            type.kind === "IntersectionTypeNode" ||
-            type.kind === "FunctionTypeNode" ||
-            type.kind === "ConstructorTypeNode" ||
-            type.kind === "ConditionalTypeNode" ||
-            type.kind === "InferTypeNode" ||
-            type.kind === "TypeOperatorNode";
-        return parenthesize ? (0, doc_1.concat)(["(", this.emit(type), ")"]) : this.emit(type);
-    }
-    /** Render a JSDoc tag's trailing comment, prefixed with a space when present. */
-    jsDocComment(comment) {
-        if (comment === undefined)
-            return "";
-        if (typeof comment === "string")
-            return comment.length ? (0, doc_1.concat)([" ", comment]) : "";
-        return comment.length
-            ? (0, doc_1.concat)([" ", (0, doc_1.concat)(comment.map((c) => this.emit(c)))])
-            : "";
-    }
-    /** 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.mjs.map