@nestia/factory 12.0.0-dev.20260520.1

package/lib/printers/internal/NodePrinter.js

@@ -0,0 +1,627 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodePrinter = void 0;
+const NodeFlags_1 = require("../../constants/NodeFlags");
+const SyntaxKind_1 = require("../../constants/SyntaxKind");
+class NodePrinter {
+    printFile(file) {
+        var _a;
+        const script = this.printStatementList((_a = file.statements) !== null && _a !== void 0 ? _a : []);
+        return script.length ? `${script}\n` : "";
+    }
+    printNode(node) {
+        return this.printAny(node);
+    }
+    printStatements(statements) {
+        const script = this.printStatementList(statements);
+        return script.length ? `${script}\n` : "";
+    }
+    printStatementList(statements) {
+        return statements
+            .map((stmt) => this.printWithLeadingComments(stmt, () => this.printStatement(stmt)))
+            .join("\n")
+            .replace(/\n{3,}/g, "\n\n");
+    }
+    printMemberList(members) {
+        return members
+            .map((member) => this.printWithLeadingComments(member, () => this.printMember(member)))
+            .join("\n");
+    }
+    printWithLeadingComments(node, body) {
+        var _a;
+        var _b;
+        const comments = (_b = (_a = node === null || node === void 0 ? void 0 : node.emitNode) === null || _a === void 0 ? void 0 : _a.leadingComments) !== null && _b !== void 0 ? _b : [];
+        if (comments.length === 0)
+            return body();
+        return [
+            ...comments.map((comment) => comment.kind === SyntaxKind_1.SyntaxKind.MultiLineCommentTrivia
+                ? `/*${comment.text}*/`
+                : `//${comment.text}`),
+            body(),
+        ].join("\n");
+    }
+    printStatement(stmt) {
+        var _a;
+        var _b;
+        switch (stmt.kind) {
+            case SyntaxKind_1.SyntaxKind.SourceFile:
+                return this.printStatementList((_b = stmt.statements) !== null && _b !== void 0 ? _b : []);
+            case SyntaxKind_1.SyntaxKind.ImportDeclaration:
+                return this.printImportDeclaration(stmt);
+            case SyntaxKind_1.SyntaxKind.ExportDeclaration:
+                return this.printExportDeclaration(stmt);
+            case SyntaxKind_1.SyntaxKind.ModuleDeclaration:
+                return this.printModuleDeclaration(stmt);
+            case SyntaxKind_1.SyntaxKind.ClassDeclaration:
+                return this.printClassDeclaration(stmt);
+            case SyntaxKind_1.SyntaxKind.FunctionDeclaration:
+                return this.printFunctionDeclaration(stmt);
+            case SyntaxKind_1.SyntaxKind.TypeAliasDeclaration:
+                return this.printTypeAliasDeclaration(stmt);
+            case SyntaxKind_1.SyntaxKind.VariableStatement:
+                return `${this.printModifierPrefix(stmt.modifiers)}${this.printVariableDeclarationList(stmt.declarationList)};`;
+            case SyntaxKind_1.SyntaxKind.ExpressionStatement:
+                if (((_a = stmt.expression) === null || _a === void 0 ? void 0 : _a.kind) === SyntaxKind_1.SyntaxKind.Identifier &&
+                    stmt.expression.text === "\n")
+                    return "";
+                return `${this.printExpression(stmt.expression)};`;
+            case SyntaxKind_1.SyntaxKind.ReturnStatement:
+                return stmt.expression
+                    ? `return ${this.printExpression(stmt.expression)};`
+                    : "return;";
+            case SyntaxKind_1.SyntaxKind.IfStatement:
+                return this.printIfStatement(stmt);
+            case SyntaxKind_1.SyntaxKind.ForOfStatement:
+                return this.printForOfStatement(stmt);
+            case SyntaxKind_1.SyntaxKind.ContinueStatement:
+                return "continue;";
+            case SyntaxKind_1.SyntaxKind.ThrowStatement:
+                return `throw ${this.printExpression(stmt.expression)};`;
+            case SyntaxKind_1.SyntaxKind.TryStatement:
+                return this.printTryStatement(stmt);
+            case SyntaxKind_1.SyntaxKind.Block:
+                return this.printBlock(stmt);
+            default:
+                return `${this.printExpression(stmt)};`;
+        }
+    }
+    printMember(member) {
+        if (this.isNewLine(member))
+            return "";
+        switch (member.kind) {
+            case SyntaxKind_1.SyntaxKind.MethodDeclaration:
+                return this.printMethodDeclaration(member);
+            case SyntaxKind_1.SyntaxKind.PropertySignature:
+            case SyntaxKind_1.SyntaxKind.IndexSignature:
+                return this.printTypeMember(member);
+            case SyntaxKind_1.SyntaxKind.TypeAliasDeclaration:
+            case SyntaxKind_1.SyntaxKind.VariableStatement:
+            case SyntaxKind_1.SyntaxKind.FunctionDeclaration:
+            case SyntaxKind_1.SyntaxKind.ModuleDeclaration:
+            case SyntaxKind_1.SyntaxKind.ClassDeclaration:
+                return this.printStatement(member);
+            default:
+                return this.printStatement(member);
+        }
+    }
+    printImportDeclaration(node) {
+        const clause = node.importClause === undefined
+            ? ""
+            : `${this.printImportClause(node.importClause)} `;
+        return `${this.printModifierPrefix(node.modifiers)}import ${clause}from ${this.printExpression(node.moduleSpecifier)};`;
+    }
+    printImportClause(node) {
+        const chunks = [];
+        if (node.name !== undefined)
+            chunks.push(`${node.isTypeOnly ? "type " : ""}${this.printName(node.name)}`);
+        if (node.namedBindings !== undefined)
+            chunks.push(this.printImportBindings(node.namedBindings));
+        return chunks.join(", ");
+    }
+    printImportBindings(node) {
+        var _a;
+        if (node.kind === SyntaxKind_1.SyntaxKind.NamespaceImport)
+            return `* as ${this.printName(node.name)}`;
+        if (node.kind === SyntaxKind_1.SyntaxKind.NamedImports)
+            return `{ ${((_a = node.elements) !== null && _a !== void 0 ? _a : [])
+                .map((elem) => this.printImportSpecifier(elem))
+                .join(", ")} }`;
+        return this.printAny(node);
+    }
+    printImportSpecifier(node) {
+        const prefix = node.isTypeOnly ? "type " : "";
+        const name = this.printName(node.name);
+        return node.propertyName === undefined
+            ? `${prefix}${name}`
+            : `${prefix}${this.printName(node.propertyName)} as ${name}`;
+    }
+    printExportDeclaration(node) {
+        const clause = node.exportClause === undefined
+            ? "*"
+            : this.printExportClause(node.exportClause);
+        const specifier = node.moduleSpecifier === undefined
+            ? ""
+            : ` from ${this.printExpression(node.moduleSpecifier)}`;
+        return `${this.printModifierPrefix(node.modifiers)}export ${node.isTypeOnly ? "type " : ""}${clause}${specifier};`;
+    }
+    printExportClause(node) {
+        if (node.kind === SyntaxKind_1.SyntaxKind.NamespaceExport)
+            return `* as ${this.printName(node.name)}`;
+        return this.printAny(node);
+    }
+    printModuleDeclaration(node) {
+        const header = `${this.printModifierPrefix(node.modifiers)}${node.flags & NodeFlags_1.NodeFlags.Namespace ? "namespace" : "module"} ${this.printName(node.name)}`;
+        if (node.body === undefined)
+            return `${header};`;
+        return `${header} ${this.printModuleBody(node.body)}`;
+    }
+    printModuleBody(node) {
+        var _a;
+        const statements = (_a = node.statements) !== null && _a !== void 0 ? _a : [];
+        if (statements.length === 0)
+            return "{}";
+        return `{\n${this.indent(this.printStatementList(statements))}\n}`;
+    }
+    printClassDeclaration(node) {
+        var _a;
+        const decorators = this.printDecorators(node.modifiers);
+        const modifiers = this.printModifierKeywords(node.modifiers);
+        const header = `${modifiers ? `${modifiers} ` : ""}class ${node.name === undefined ? "" : this.printName(node.name)}${this.printTypeParameters(node.typeParameters)}`;
+        const members = (_a = node.members) !== null && _a !== void 0 ? _a : [];
+        const body = members.length === 0
+            ? "{}"
+            : `{\n${this.indent(this.printMemberList(members))}\n}`;
+        return [decorators, `${header} ${body}`].filter(Boolean).join("\n");
+    }
+    printFunctionDeclaration(node) {
+        const decorators = this.printDecorators(node.modifiers);
+        const modifiers = this.printModifierKeywords(node.modifiers);
+        const prefix = modifiers ? `${modifiers} ` : "";
+        const name = node.name === undefined ? "" : this.printName(node.name);
+        const signature = `${prefix}function ${node.asteriskToken ? "*" : ""}${name}${this.printTypeParameters(node.typeParameters)}(${this.printParameters(node.parameters)})${this.printReturnType(node.type)}`;
+        const body = node.body === undefined ? ";" : ` ${this.printBlock(node.body)}`;
+        return [decorators, `${signature}${body}`].filter(Boolean).join("\n");
+    }
+    printMethodDeclaration(node) {
+        const decorators = this.printDecorators(node.modifiers);
+        const modifiers = this.printModifierKeywords(node.modifiers);
+        const prefix = modifiers ? `${modifiers} ` : "";
+        const signature = `${prefix}${node.asteriskToken ? "*" : ""}${this.printName(node.name)}${node.questionToken ? "?" : ""}${this.printTypeParameters(node.typeParameters)}(${this.printParameters(node.parameters)})${this.printReturnType(node.type)}`;
+        const body = node.body === undefined ? ";" : ` ${this.printBlock(node.body)}`;
+        return [decorators, `${signature}${body}`].filter(Boolean).join("\n");
+    }
+    printTypeAliasDeclaration(node) {
+        return `${this.printModifierPrefix(node.modifiers)}type ${this.printName(node.name)}${this.printTypeParameters(node.typeParameters)} = ${this.printType(node.type)};`;
+    }
+    printIfStatement(node) {
+        const elseText = node.elseStatement === undefined
+            ? ""
+            : ` else ${this.printStatementBody(node.elseStatement)}`;
+        return `if (${this.printExpression(node.expression)}) ${this.printStatementBody(node.thenStatement)}${elseText}`;
+    }
+    printForOfStatement(node) {
+        const awaitText = node.awaitModifier ? "await " : "";
+        return `for ${awaitText}(${this.printForInitializer(node.initializer)} of ${this.printExpression(node.expression)}) ${this.printStatementBody(node.statement)}`;
+    }
+    printTryStatement(node) {
+        const catchText = node.catchClause === undefined
+            ? ""
+            : ` ${this.printCatchClause(node.catchClause)}`;
+        const finallyText = node.finallyBlock === undefined
+            ? ""
+            : ` finally ${this.printBlock(node.finallyBlock)}`;
+        return `try ${this.printBlock(node.tryBlock)}${catchText}${finallyText}`;
+    }
+    printCatchClause(node) {
+        const variable = node.variableDeclaration === undefined
+            ? ""
+            : ` (${this.printVariableDeclaration(node.variableDeclaration)})`;
+        return `catch${variable} ${this.printBlock(node.block)}`;
+    }
+    printStatementBody(node) {
+        if (node.kind === SyntaxKind_1.SyntaxKind.Block)
+            return this.printBlock(node);
+        return `{\n${this.indent(this.printWithLeadingComments(node, () => this.printStatement(node)))}\n}`;
+    }
+    printBlock(node) {
+        var _a;
+        const statements = (_a = node.statements) !== null && _a !== void 0 ? _a : [];
+        if (statements.length === 0)
+            return "{}";
+        return `{\n${this.indent(this.printStatementList(statements))}\n}`;
+    }
+    printForInitializer(node) {
+        return node.kind === SyntaxKind_1.SyntaxKind.VariableDeclarationList
+            ? this.printVariableDeclarationList(node)
+            : this.printExpression(node);
+    }
+    printVariableDeclarationList(node) {
+        var _a;
+        const keyword = node.flags & NodeFlags_1.NodeFlags.Const
+            ? "const"
+            : node.flags & NodeFlags_1.NodeFlags.Let
+                ? "let"
+                : "var";
+        return `${keyword} ${((_a = node.declarations) !== null && _a !== void 0 ? _a : [])
+            .map((decl) => this.printVariableDeclaration(decl))
+            .join(", ")}`;
+    }
+    printVariableDeclaration(node) {
+        return [
+            this.printBindingName(node.name),
+            node.type === undefined ? "" : `: ${this.printType(node.type)}`,
+            node.initializer === undefined
+                ? ""
+                : ` = ${this.printExpression(node.initializer)}`,
+        ].join("");
+    }
+    printExpression(node) {
+        var _a;
+        var _b, _c, _d, _e;
+        if (node === undefined)
+            return "";
+        switch (node.kind) {
+            case SyntaxKind_1.SyntaxKind.Identifier:
+                return (_c = (_b = node.text) !== null && _b !== void 0 ? _b : node.escapedText) !== null && _c !== void 0 ? _c : "";
+            case SyntaxKind_1.SyntaxKind.StringLiteral:
+                return this.printStringLiteral(node);
+            case SyntaxKind_1.SyntaxKind.NumericLiteral:
+                return String(node.text);
+            case SyntaxKind_1.SyntaxKind.BigIntLiteral:
+                return `${node.text}n`;
+            case SyntaxKind_1.SyntaxKind.TrueKeyword:
+                return "true";
+            case SyntaxKind_1.SyntaxKind.FalseKeyword:
+                return "false";
+            case SyntaxKind_1.SyntaxKind.NullKeyword:
+                return "null";
+            case SyntaxKind_1.SyntaxKind.PropertyAccessExpression:
+                return `${this.printExpression(node.expression)}${node.questionDotToken ? "?." : "."}${this.printName(node.name)}`;
+            case SyntaxKind_1.SyntaxKind.CallExpression:
+                return `${this.printExpression(node.expression)}${node.questionDotToken ? "?." : ""}${this.printTypeArguments(node.typeArguments)}(${((_d = node.arguments) !== null && _d !== void 0 ? _d : [])
+                    .map((arg) => this.printExpression(arg))
+                    .join(", ")})`;
+            case SyntaxKind_1.SyntaxKind.NewExpression:
+                return `new ${this.printExpression(node.expression)}${this.printTypeArguments(node.typeArguments)}(${((_e = node.arguments) !== null && _e !== void 0 ? _e : [])
+                    .map((arg) => this.printExpression(arg))
+                    .join(", ")})`;
+            case SyntaxKind_1.SyntaxKind.ArrayLiteralExpression:
+                return this.printArrayLiteral(node);
+            case SyntaxKind_1.SyntaxKind.ObjectLiteralExpression:
+                return this.printObjectLiteral(node);
+            case SyntaxKind_1.SyntaxKind.PropertyAssignment:
+                return `${this.printName(node.name)}: ${this.printExpression(node.initializer)}`;
+            case SyntaxKind_1.SyntaxKind.ShorthandPropertyAssignment:
+                return node.objectAssignmentInitializer === undefined
+                    ? this.printName(node.name)
+                    : `${this.printName(node.name)} = ${this.printExpression(node.objectAssignmentInitializer)}`;
+            case SyntaxKind_1.SyntaxKind.SpreadAssignment:
+                return `...${this.printExpression(node.expression)}`;
+            case SyntaxKind_1.SyntaxKind.AwaitExpression:
+                return `await ${this.printExpression(node.expression)}`;
+            case SyntaxKind_1.SyntaxKind.AsExpression:
+                return `${this.printExpression(node.expression)} as ${this.printType(node.type)}`;
+            case SyntaxKind_1.SyntaxKind.ConditionalExpression:
+                return `${this.printExpression(node.condition)} ? ${this.printExpression(node.whenTrue)} : ${this.printExpression(node.whenFalse)}`;
+            case SyntaxKind_1.SyntaxKind.BinaryExpression:
+                return `${this.printExpression(node.left)} ${this.printToken(node.operatorToken)} ${this.printExpression(node.right)}`;
+            case SyntaxKind_1.SyntaxKind.PrefixUnaryExpression:
+                return `${this.printToken(node.operator)}${this.printExpression(node.operand)}`;
+            case SyntaxKind_1.SyntaxKind.ArrowFunction:
+                return `${this.printModifierKeywords(node.modifiers)}${((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.length) ? " " : ""}(${this.printParameters(node.parameters)})${this.printReturnType(node.type)} => ${this.printArrowBody(node.body)}`;
+            case SyntaxKind_1.SyntaxKind.TemplateExpression:
+                return this.printTemplateExpression(node);
+            default:
+                return this.printType(node);
+        }
+    }
+    printArrayLiteral(node) {
+        var _a;
+        const elements = ((_a = node.elements) !== null && _a !== void 0 ? _a : []).map((elem) => this.printExpression(elem));
+        if (elements.length === 0)
+            return "[]";
+        if (!node.multiLine)
+            return `[${elements.join(", ")}]`;
+        return `[\n${this.indent(elements.join(",\n"))},\n]`;
+    }
+    printObjectLiteral(node) {
+        var _a;
+        const properties = ((_a = node.properties) !== null && _a !== void 0 ? _a : []).map((property) => this.printWithLeadingComments(property, () => this.printExpression(property)));
+        if (properties.length === 0)
+            return "{}";
+        if (!node.multiLine && properties.length === 1)
+            return `{ ${properties[0]} }`;
+        return `{\n${this.indent(properties.join(",\n"))},\n}`;
+    }
+    printArrowBody(node) {
+        return node.kind === SyntaxKind_1.SyntaxKind.Block
+            ? this.printBlock(node)
+            : this.printExpression(node);
+    }
+    printTemplateExpression(node) {
+        var _a;
+        return `\`${this.printTemplateText(node.head)}${((_a = node.templateSpans) !== null && _a !== void 0 ? _a : [])
+            .map((span) => `\${${this.printExpression(span.expression)}}${this.printTemplateText(span.literal)}`)
+            .join("")}\``;
+    }
+    printType(node) {
+        var _a, _b, _c;
+        if (node === undefined)
+            return "";
+        switch (node.kind) {
+            case SyntaxKind_1.SyntaxKind.AnyKeyword:
+            case SyntaxKind_1.SyntaxKind.BigIntKeyword:
+            case SyntaxKind_1.SyntaxKind.BooleanKeyword:
+            case SyntaxKind_1.SyntaxKind.NumberKeyword:
+            case SyntaxKind_1.SyntaxKind.StringKeyword:
+            case SyntaxKind_1.SyntaxKind.VoidKeyword:
+            case SyntaxKind_1.SyntaxKind.KeyOfKeyword:
+            case SyntaxKind_1.SyntaxKind.UniqueKeyword:
+                return this.printToken(node.kind);
+            case SyntaxKind_1.SyntaxKind.Identifier:
+            case SyntaxKind_1.SyntaxKind.QualifiedName:
+                return this.printName(node);
+            case SyntaxKind_1.SyntaxKind.StringLiteral:
+            case SyntaxKind_1.SyntaxKind.NumericLiteral:
+            case SyntaxKind_1.SyntaxKind.BigIntLiteral:
+            case SyntaxKind_1.SyntaxKind.TrueKeyword:
+            case SyntaxKind_1.SyntaxKind.FalseKeyword:
+            case SyntaxKind_1.SyntaxKind.NullKeyword:
+            case SyntaxKind_1.SyntaxKind.PrefixUnaryExpression:
+                return this.printExpression(node);
+            case SyntaxKind_1.SyntaxKind.TypeReference:
+                return `${this.printName(node.typeName)}${this.printTypeArguments(node.typeArguments)}`;
+            case SyntaxKind_1.SyntaxKind.TypeQuery:
+                return `typeof ${this.printName(node.exprName)}`;
+            case SyntaxKind_1.SyntaxKind.TypeLiteral:
+                return this.printTypeLiteral(node);
+            case SyntaxKind_1.SyntaxKind.ArrayType:
+                return `${this.wrapArrayElementType(node.elementType)}[]`;
+            case SyntaxKind_1.SyntaxKind.ParenthesizedType:
+                return `(${this.printType(node.type)})`;
+            case SyntaxKind_1.SyntaxKind.TupleType:
+                return `[${((_a = node.elements) !== null && _a !== void 0 ? _a : [])
+                    .map((elem) => this.printType(elem))
+                    .join(", ")}]`;
+            case SyntaxKind_1.SyntaxKind.UnionType:
+                return ((_b = node.types) !== null && _b !== void 0 ? _b : [])
+                    .map((elem) => this.printType(elem))
+                    .join(" | ");
+            case SyntaxKind_1.SyntaxKind.IntersectionType:
+                return ((_c = node.types) !== null && _c !== void 0 ? _c : [])
+                    .map((elem) => this.wrapIntersectionType(elem))
+                    .join(" & ");
+            case SyntaxKind_1.SyntaxKind.LiteralType:
+                return this.printExpression(node.literal);
+            case SyntaxKind_1.SyntaxKind.RestType:
+                return `...${this.printType(node.type)}`;
+            case SyntaxKind_1.SyntaxKind.OptionalType:
+                return `${this.printType(node.type)}?`;
+            case SyntaxKind_1.SyntaxKind.FunctionType:
+                return `${this.printTypeParameters(node.typeParameters)}(${this.printParameters(node.parameters)}) => ${this.printType(node.type)}`;
+            case SyntaxKind_1.SyntaxKind.TemplateLiteralType:
+                return this.printTemplateLiteralType(node);
+            default:
+                return this.printExpression(node);
+        }
+    }
+    printTypeLiteral(node) {
+        var _a;
+        const members = (_a = node.members) !== null && _a !== void 0 ? _a : [];
+        if (members.length === 0)
+            return "{}";
+        return `{\n${this.indent(this.printMemberList(members))}\n}`;
+    }
+    printTypeMember(node) {
+        switch (node.kind) {
+            case SyntaxKind_1.SyntaxKind.PropertySignature:
+                return `${this.printModifierPrefix(node.modifiers)}${this.printName(node.name)}${node.questionToken ? "?" : ""}${node.type === undefined ? "" : `: ${this.printType(node.type)}`};`;
+            case SyntaxKind_1.SyntaxKind.IndexSignature:
+                return `${this.printModifierPrefix(node.modifiers)}[${this.printParameters(node.parameters)}]: ${this.printType(node.type)};`;
+            default:
+                return this.printType(node);
+        }
+    }
+    printTemplateLiteralType(node) {
+        var _a;
+        return `\`${this.printTemplateText(node.head)}${((_a = node.templateSpans) !== null && _a !== void 0 ? _a : [])
+            .map((span) => `\${${this.printType(span.type)}}${this.printTemplateText(span.literal)}`)
+            .join("")}\``;
+    }
+    wrapArrayElementType(node) {
+        return node.kind === SyntaxKind_1.SyntaxKind.UnionType ||
+            node.kind === SyntaxKind_1.SyntaxKind.IntersectionType
+            ? `(${this.printType(node)})`
+            : this.printType(node);
+    }
+    wrapIntersectionType(node) {
+        return node.kind === SyntaxKind_1.SyntaxKind.UnionType
+            ? `(${this.printType(node)})`
+            : this.printType(node);
+    }
+    printParameters(parameters) {
+        return (parameters !== null && parameters !== void 0 ? parameters : [])
+            .map((param) => this.printParameter(param))
+            .join(", ");
+    }
+    printParameter(node) {
+        return [
+            this.printInlineDecorators(node.modifiers),
+            this.printModifierPrefix(node.modifiers),
+            node.dotDotDotToken ? "..." : "",
+            this.printBindingName(node.name),
+            node.questionToken ? "?" : "",
+            node.type === undefined ? "" : `: ${this.printType(node.type)}`,
+            node.initializer === undefined
+                ? ""
+                : ` = ${this.printExpression(node.initializer)}`,
+        ].join("");
+    }
+    printBindingName(node) {
+        var _a;
+        if (node.kind === SyntaxKind_1.SyntaxKind.ArrayBindingPattern)
+            return `[${((_a = node.elements) !== null && _a !== void 0 ? _a : [])
+                .map((elem) => this.printBindingElement(elem))
+                .join(", ")}]`;
+        return this.printName(node);
+    }
+    printBindingElement(node) {
+        return [
+            node.dotDotDotToken ? "..." : "",
+            node.propertyName === undefined
+                ? ""
+                : `${this.printName(node.propertyName)}: `,
+            this.printBindingName(node.name),
+            node.initializer === undefined
+                ? ""
+                : ` = ${this.printExpression(node.initializer)}`,
+        ].join("");
+    }
+    printName(node) {
+        var _a, _b;
+        if (node.kind === SyntaxKind_1.SyntaxKind.Identifier)
+            return (_b = (_a = node.text) !== null && _a !== void 0 ? _a : node.escapedText) !== null && _b !== void 0 ? _b : "";
+        if (node.kind === SyntaxKind_1.SyntaxKind.StringLiteral)
+            return this.printStringLiteral(node);
+        if (node.kind === SyntaxKind_1.SyntaxKind.QualifiedName)
+            return `${this.printName(node.left)}.${this.printName(node.right)}`;
+        return this.printExpression(node);
+    }
+    printTypeParameters(typeParameters) {
+        return (typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters.length)
+            ? `<${typeParameters.map((param) => this.printType(param)).join(", ")}>`
+            : "";
+    }
+    printTypeArguments(typeArguments) {
+        return (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length)
+            ? `<${typeArguments.map((param) => this.printType(param)).join(", ")}>`
+            : "";
+    }
+    printReturnType(type) {
+        return type === undefined ? "" : `: ${this.printType(type)}`;
+    }
+    printModifierPrefix(modifiers) {
+        const text = this.printModifierKeywords(modifiers);
+        return text ? `${text} ` : "";
+    }
+    printModifierKeywords(modifiers) {
+        return (modifiers !== null && modifiers !== void 0 ? modifiers : [])
+            .filter((modifier) => modifier.kind !== SyntaxKind_1.SyntaxKind.Decorator)
+            .map((modifier) => this.printToken(modifier.kind))
+            .filter(Boolean)
+            .join(" ");
+    }
+    printDecorators(modifiers) {
+        return (modifiers !== null && modifiers !== void 0 ? modifiers : [])
+            .filter((modifier) => modifier.kind === SyntaxKind_1.SyntaxKind.Decorator)
+            .map((decorator) => `@${this.printExpression(decorator.expression)}`)
+            .join("\n");
+    }
+    printInlineDecorators(modifiers) {
+        const text = (modifiers !== null && modifiers !== void 0 ? modifiers : [])
+            .filter((modifier) => modifier.kind === SyntaxKind_1.SyntaxKind.Decorator)
+            .map((decorator) => `@${this.printExpression(decorator.expression)}`)
+            .join(" ");
+        return text ? `${text} ` : "";
+    }
+    printAny(node) {
+        if (this.isNewLine(node))
+            return "";
+        switch (node.kind) {
+            case SyntaxKind_1.SyntaxKind.PropertySignature:
+            case SyntaxKind_1.SyntaxKind.IndexSignature:
+                return this.printTypeMember(node);
+            case SyntaxKind_1.SyntaxKind.SourceFile:
+            case SyntaxKind_1.SyntaxKind.ImportDeclaration:
+            case SyntaxKind_1.SyntaxKind.ExportDeclaration:
+            case SyntaxKind_1.SyntaxKind.ModuleDeclaration:
+            case SyntaxKind_1.SyntaxKind.ClassDeclaration:
+            case SyntaxKind_1.SyntaxKind.FunctionDeclaration:
+            case SyntaxKind_1.SyntaxKind.TypeAliasDeclaration:
+            case SyntaxKind_1.SyntaxKind.VariableStatement:
+            case SyntaxKind_1.SyntaxKind.ExpressionStatement:
+            case SyntaxKind_1.SyntaxKind.ReturnStatement:
+            case SyntaxKind_1.SyntaxKind.IfStatement:
+            case SyntaxKind_1.SyntaxKind.ForOfStatement:
+            case SyntaxKind_1.SyntaxKind.ContinueStatement:
+            case SyntaxKind_1.SyntaxKind.ThrowStatement:
+            case SyntaxKind_1.SyntaxKind.TryStatement:
+            case SyntaxKind_1.SyntaxKind.Block:
+                return this.printStatement(node);
+            default:
+                return this.printExpression(node);
+        }
+    }
+    printTemplateText(node) {
+        var _a, _b;
+        return (_b = (_a = node.rawText) !== null && _a !== void 0 ? _a : node.text) !== null && _b !== void 0 ? _b : "";
+    }
+    printStringLiteral(node) {
+        var _a;
+        return JSON.stringify((_a = node.text) !== null && _a !== void 0 ? _a : "");
+    }
+    isNewLine(node) {
+        return node.kind === SyntaxKind_1.SyntaxKind.Identifier && node.text === "\n";
+    }
+    printToken(token) {
+        const kind = typeof token === "number" ? token : token === null || token === void 0 ? void 0 : token.kind;
+        switch (kind) {
+            case SyntaxKind_1.SyntaxKind.DotDotDotToken:
+                return "...";
+            case SyntaxKind_1.SyntaxKind.QuestionDotToken:
+                return "?.";
+            case SyntaxKind_1.SyntaxKind.EqualsEqualsEqualsToken:
+                return "===";
+            case SyntaxKind_1.SyntaxKind.EqualsGreaterThanToken:
+                return "=>";
+            case SyntaxKind_1.SyntaxKind.MinusToken:
+                return "-";
+            case SyntaxKind_1.SyntaxKind.ExclamationToken:
+                return "!";
+            case SyntaxKind_1.SyntaxKind.QuestionToken:
+                return "?";
+            case SyntaxKind_1.SyntaxKind.ColonToken:
+                return ":";
+            case SyntaxKind_1.SyntaxKind.QuestionQuestionToken:
+                return "??";
+            case SyntaxKind_1.SyntaxKind.EqualsToken:
+                return "=";
+            case SyntaxKind_1.SyntaxKind.QuestionQuestionEqualsToken:
+                return "??=";
+            case SyntaxKind_1.SyntaxKind.ExportKeyword:
+                return "export";
+            case SyntaxKind_1.SyntaxKind.AsyncKeyword:
+                return "async";
+            case SyntaxKind_1.SyntaxKind.PublicKeyword:
+                return "public";
+            case SyntaxKind_1.SyntaxKind.ReadonlyKeyword:
+                return "readonly";
+            case SyntaxKind_1.SyntaxKind.AnyKeyword:
+                return "any";
+            case SyntaxKind_1.SyntaxKind.BigIntKeyword:
+                return "bigint";
+            case SyntaxKind_1.SyntaxKind.BooleanKeyword:
+                return "boolean";
+            case SyntaxKind_1.SyntaxKind.NumberKeyword:
+                return "number";
+            case SyntaxKind_1.SyntaxKind.StringKeyword:
+                return "string";
+            case SyntaxKind_1.SyntaxKind.VoidKeyword:
+                return "void";
+            case SyntaxKind_1.SyntaxKind.KeyOfKeyword:
+                return "keyof";
+            case SyntaxKind_1.SyntaxKind.UniqueKeyword:
+                return "unique";
+            default:
+                return "";
+        }
+    }
+    indent(text) {
+        return text
+            .split("\n")
+            .map((line) => (line.length ? `  ${line}` : line))
+            .join("\n");
+    }
+}
+exports.NodePrinter = NodePrinter;
+//# sourceMappingURL=NodePrinter.js.map