@apify/mcpc 0.2.4 → 0.3.0-beta.0

package/dist/cli/output.js

@@ -1,8 +1,9 @@
 import chalk from 'chalk';
-import { extractSingleTextContent } from './tool-result.js';
-import { isValidSessionName } from '../lib/utils.js';
+import { extractAllTextContent } from './tool-result.js';
+import { join } from 'node:path';
+import { getLogsDir } from '../lib/utils.js';
 import { getSession } from '../lib/sessions.js';
-export { extractSingleTextContent } from './tool-result.js';
+export { extractAllTextContent } from './tool-result.js';
 function hslToHex(h, s, l) {
     s /= 100;
     l /= 100;
@@ -16,6 +17,19 @@ function hslToHex(h, s, l) {
     };
     return `#${f(0)}${f(8)}${f(4)}`;
 }
+const RAINBOW_HUE_START = 12;
+const RAINBOW_HUE_SPAN = 270;
+const RAINBOW_SATURATION = 45;
+const RAINBOW_LIGHTNESS = 62;
+const themeHex = (hue) => hslToHex(hue, RAINBOW_SATURATION, RAINBOW_LIGHTNESS);
+export const theme = {
+    red: chalk.hex(themeHex(12)),
+    yellow: chalk.hex(themeHex(60)),
+    green: chalk.hex(hslToHex(135, 65, 52)),
+    cyan: chalk.hex(themeHex(190)),
+    blue: chalk.hex(themeHex(230)),
+    magenta: chalk.hex(themeHex(282)),
+};
 export function rainbow(text) {
     const len = text.length;
     if (len === 0)
@@ -23,9 +37,8 @@ export function rainbow(text) {
     return text
         .split('')
         .map((char, i) => {
-        const hue = 12 + (i / (len - 1)) * 270;
-        const hex = hslToHex(hue, 45, 62);
-        return chalk.hex(hex)(char);
+        const hue = RAINBOW_HUE_START + (i / (len - 1)) * RAINBOW_HUE_SPAN;
+        return chalk.hex(themeHex(hue))(char);
     })
         .join('');
 }
@@ -33,9 +46,12 @@ export function formatOutput(data, mode = 'human', options) {
     if (mode === 'json') {
         return formatJson(data);
     }
-    const output = formatHuman(data, options);
+    let output = formatHuman(data, options);
     if (!output.endsWith('````') && !output.endsWith('\n')) {
-        return output + '\n';
+        output += '\n';
+    }
+    if (options?.maxChars) {
+        output = truncateOutput(output, options.maxChars);
     }
     return output;
 }
@@ -49,16 +65,16 @@ export function formatJson(data) {
 function highlightJson(json) {
     return json.replace(/("(?:\\.|[^"\\])*")\s*:|("(?:\\.|[^"\\])*")|(\b(?:true|false|null)\b)|(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/g, (match, key, str, bool, num) => {
         if (key) {
-            return chalk.cyan(key) + ':';
+            return theme.cyan(key) + ':';
         }
         if (str) {
-            return chalk.green(str);
+            return theme.green(str);
         }
         if (bool) {
-            return chalk.magenta(bool);
+            return theme.magenta(bool);
         }
         if (num) {
-            return chalk.yellow(num);
+            return theme.yellow(num);
         }
         return match;
     });
@@ -67,9 +83,9 @@ export function formatHuman(data, options) {
     if (data === null || data === undefined) {
         return chalk.gray('(no data)');
     }
-    const singleText = extractSingleTextContent(data);
-    if (singleText !== undefined) {
-        return `${chalk.gray('````')}\n${singleText}\n${chalk.gray('````')}`;
+    const textContent = extractAllTextContent(data);
+    if (textContent !== undefined) {
+        return `${chalk.gray('````')}\n${textContent}\n${chalk.gray('````')}`;
     }
     if (Array.isArray(data)) {
         if (data.length === 0) {
@@ -111,7 +127,7 @@ export function formatToolAnnotations(annotations) {
         parts.push('read-only');
     }
     else if (annotations.destructiveHint === true) {
-        parts.push(chalk.red('destructive'));
+        parts.push(theme.red('destructive'));
     }
     if (annotations.idempotentHint === true) {
         parts.push('idempotent');
@@ -121,6 +137,21 @@ export function formatToolAnnotations(annotations) {
     }
     return parts.length > 0 ? parts.join(', ') : null;
 }
+export function getToolTaskSupport(tool) {
+    const toolAny = tool;
+    const execution = toolAny.execution;
+    return execution?.taskSupport;
+}
+export function formatToolHints(tool) {
+    const parts = [];
+    const annotationsStr = formatToolAnnotations(tool.annotations);
+    if (annotationsStr)
+        parts.push(annotationsStr);
+    const taskSupport = getToolTaskSupport(tool);
+    if (taskSupport && taskSupport !== 'forbidden')
+        parts.push(`task:${taskSupport}`);
+    return parts.length > 0 ? parts.join(', ') : null;
+}
 export function formatSchemaType(schema) {
     if (!schema || typeof schema !== 'object') {
         return 'any';
@@ -161,7 +192,7 @@ export function grayBacktick() {
     return chalk.gray('`');
 }
 export function inBackticks(text) {
-    return `${grayBacktick()}${chalk.cyan(text)}${grayBacktick()}`;
+    return `${grayBacktick()}${theme.cyan(text)}${grayBacktick()}`;
 }
 export function formatSimplifiedArgs(schema, indent = '') {
     const lines = [];
@@ -181,9 +212,9 @@ export function formatSimplifiedArgs(schema, indent = '') {
         const isRequired = required.includes(name);
         const description = propSchema.description;
         const defaultValue = propSchema.default;
-        let line = `${indent}${bullet} ${inBackticks(name)}: ${chalk.yellow(typeStr)}`;
+        let line = `${indent}${bullet} ${inBackticks(name)}: ${theme.yellow(typeStr)}`;
         if (isRequired) {
-            line += ` ${chalk.red('[required]')}`;
+            line += ` ${theme.red('[required]')}`;
         }
         if (defaultValue !== undefined) {
             line += chalk.dim(` (default: ${JSON.stringify(defaultValue)})`);
@@ -262,17 +293,9 @@ export function formatToolParamsInline(schema) {
 export function formatToolLine(tool) {
     const bullet = chalk.dim('*');
     const params = formatToolParamsInline(tool.inputSchema);
-    const parts = [];
-    const annotationsStr = formatToolAnnotations(tool.annotations);
-    if (annotationsStr)
-        parts.push(annotationsStr);
-    const toolAny = tool;
-    const execution = toolAny.execution;
-    const taskSupport = execution?.taskSupport;
-    if (taskSupport)
-        parts.push(`task:${taskSupport}`);
-    const suffix = parts.length > 0 ? ` ${chalk.gray(`[${parts.join(', ')}]`)}` : '';
-    return `${bullet} ${grayBacktick()}${chalk.cyan(tool.name)} ${params}${grayBacktick()}${suffix}`;
+    const hintsStr = formatToolHints(tool);
+    const suffix = hintsStr ? ` ${chalk.gray(`[${hintsStr}]`)}` : '';
+    return `${bullet} ${grayBacktick()}${theme.cyan(tool.name)} ${params}${grayBacktick()}${suffix}`;
 }
 function formatToolsSummary(tools) {
     const lines = [];
@@ -304,9 +327,9 @@ export function formatToolDetail(tool) {
     if (title) {
         lines.push(chalk.bold(`# ${title}`));
     }
-    const annotationsStr = formatToolAnnotations(tool.annotations);
-    const annotationsSuffix = annotationsStr ? ` ${chalk.gray(`[${annotationsStr}]`)}` : '';
-    lines.push(`${chalk.bold('Tool:')} ${inBackticks(tool.name)}${annotationsSuffix}`);
+    const hintsStr = formatToolHints(tool);
+    const hintsSuffix = hintsStr ? ` ${chalk.gray(`[${hintsStr}]`)}` : '';
+    lines.push(`${chalk.bold('Tool:')} ${inBackticks(tool.name)}${hintsSuffix}`);
     lines.push('');
     lines.push(chalk.bold('Input:'));
     const inputArgs = formatSimplifiedArgs(tool.inputSchema, '');
@@ -327,6 +350,69 @@ export function formatToolDetail(tool) {
     }
     return lines.join('\n');
 }
+function exampleValue(propSchema) {
+    if (propSchema.default !== undefined) {
+        return JSON.stringify(propSchema.default);
+    }
+    if (propSchema.enum && Array.isArray(propSchema.enum) && propSchema.enum.length > 0) {
+        return JSON.stringify(propSchema.enum[0]);
+    }
+    const schemaType = propSchema.type;
+    if (schemaType === 'string')
+        return '"something"';
+    if (schemaType === 'number')
+        return '1';
+    if (schemaType === 'integer') {
+        const min = propSchema.minimum;
+        return String(min ?? 1);
+    }
+    if (schemaType === 'boolean')
+        return 'true';
+    if (Array.isArray(schemaType)) {
+        const nonNull = schemaType.filter((t) => t !== 'null');
+        if (nonNull.includes('string'))
+            return '"something"';
+        if (nonNull.includes('number') || nonNull.includes('integer'))
+            return '1';
+        if (nonNull.includes('boolean'))
+            return 'true';
+    }
+    return '"something"';
+}
+function shellSafeExampleValue(jsonValue) {
+    if (/^[a-zA-Z0-9_.+-]+$/.test(jsonValue)) {
+        return jsonValue;
+    }
+    return `'${jsonValue.replace(/'/g, `'\\''`)}'`;
+}
+export function formatToolCallExample(tool, sessionName) {
+    const schema = tool.inputSchema;
+    const properties = schema?.properties;
+    const session = sessionName || '<@session>';
+    const taskSupport = getToolTaskSupport(tool);
+    const taskFlag = taskSupport === 'required' ? ' --task' : taskSupport === 'optional' ? ' [--task]' : '';
+    const bullet = chalk.dim('*');
+    if (!properties || Object.keys(properties).length === 0) {
+        const cmd = `mcpc ${session} tools-call ${tool.name}${taskFlag}`;
+        return `${chalk.bold('Call example:')}\n${bullet} ${grayBacktick()}${theme.cyan(cmd)}${grayBacktick()}`;
+    }
+    const requiredNames = schema?.required || [];
+    const allNames = Object.keys(properties);
+    const requiredInOrder = allNames.filter((n) => requiredNames.includes(n));
+    const optionalInOrder = allNames.filter((n) => !requiredNames.includes(n));
+    const MAX_EXAMPLE_PARAMS = 3;
+    const params = [...requiredInOrder];
+    if (params.length < MAX_EXAMPLE_PARAMS) {
+        const remaining = MAX_EXAMPLE_PARAMS - params.length;
+        params.push(...optionalInOrder.slice(0, remaining));
+    }
+    const argParts = params.map((name) => {
+        const val = shellSafeExampleValue(exampleValue(properties[name] ?? {}));
+        return `${name}:=${val}`;
+    });
+    const cmd = `mcpc ${session} tools-call ${tool.name} ${argParts.join(' ')}${taskFlag}`;
+    return `${chalk.bold('Call example:')}\n${bullet} ${grayBacktick()}${theme.cyan(cmd)}${grayBacktick()}`;
+}
 export function formatResources(resources) {
     const lines = [];
     lines.push(chalk.bold(`Resources (${resources.length}):`));
@@ -348,7 +434,7 @@ export function formatResourceDetail(resource) {
         lines.push(`${chalk.bold('Name:')} ${resource.name}`);
     }
     if (resource.mimeType) {
-        lines.push(`${chalk.bold('MIME type:')} ${chalk.yellow(resource.mimeType)}`);
+        lines.push(`${chalk.bold('MIME type:')} ${theme.yellow(resource.mimeType)}`);
     }
     const description = (resource.description || '').trim();
     if (description) {
@@ -381,7 +467,7 @@ export function formatResourceTemplateDetail(template) {
         lines.push(`${chalk.bold('Name:')} ${template.name}`);
     }
     if (template.mimeType) {
-        lines.push(`${chalk.bold('MIME type:')} ${chalk.yellow(template.mimeType)}`);
+        lines.push(`${chalk.bold('MIME type:')} ${theme.yellow(template.mimeType)}`);
     }
     const description = (template.description || '').trim();
     if (description) {
@@ -414,8 +500,8 @@ export function formatPromptDetail(prompt) {
     lines.push(chalk.bold('Arguments:'));
     if (prompt.arguments && prompt.arguments.length > 0) {
         for (const arg of prompt.arguments) {
-            const typePart = chalk.yellow('string');
-            const requiredPart = arg.required ? ` ${chalk.red('[required]')}` : '';
+            const typePart = theme.yellow('string');
+            const requiredPart = arg.required ? ` ${theme.red('[required]')}` : '';
             const description = arg.description ? ` ${chalk.dim('-')} ${arg.description}` : '';
             lines.push(`  ${inBackticks(arg.name)}: ${typePart}${requiredPart}${description}`);
         }
@@ -457,7 +543,7 @@ function formatPromptResult(result) {
     lines.push(chalk.bold(`Messages (${result.messages.length}):`));
     for (const message of result.messages) {
         lines.push('');
-        lines.push(`${chalk.bold('Role:')} ${chalk.cyan(message.role)}`);
+        lines.push(`${chalk.bold('Role:')} ${theme.cyan(message.role)}`);
         lines.push(formatPromptContent(message.content));
     }
     return lines.join('\n');
@@ -509,26 +595,27 @@ function formatPromptContent(content) {
     }
     return lines.join('\n');
 }
-function taskStatusIcon(status) {
+function taskStatusLabel(status) {
+    const label = (icon) => `${icon} ${status}`;
     switch (status) {
         case 'working':
-            return chalk.cyan('⟳');
+            return theme.cyan(label('⟳'));
         case 'input_required':
-            return chalk.yellow('?');
+            return theme.yellow(label('?'));
         case 'completed':
-            return chalk.green('✔');
+            return theme.green(label('✔'));
         case 'failed':
-            return chalk.red('✖');
+            return theme.red(label('✖'));
         case 'cancelled':
-            return chalk.gray('⊘');
+            return chalk.gray(label('⊘'));
         default:
-            return chalk.gray('·');
+            return chalk.gray(label('·'));
     }
 }
 export function formatTask(task) {
     const lines = [];
-    lines.push(`${chalk.bold('Task:')} ${inBackticks(task.taskId)}`);
-    lines.push(`${chalk.bold('Status:')} ${taskStatusIcon(task.status)} ${task.status}`);
+    lines.push(`${chalk.bold('Task ID:')} ${inBackticks(task.taskId)}`);
+    lines.push(`${chalk.bold('Status:')} ${taskStatusLabel(task.status)}`);
     if (task.statusMessage) {
         lines.push(`${chalk.bold('Message:')} ${task.statusMessage}`);
     }
@@ -545,16 +632,115 @@ export function formatTasks(taskList) {
     lines.push(chalk.bold(`Tasks (${taskList.length}):`));
     const bullet = chalk.dim('*');
     for (const task of taskList) {
-        const statusStr = `${taskStatusIcon(task.status)} ${task.status}`;
+        const statusStr = taskStatusLabel(task.status);
         const msgStr = task.statusMessage ? chalk.dim(` - ${task.statusMessage}`) : '';
         lines.push(`${bullet} ${inBackticks(task.taskId)}  ${statusStr}${msgStr}`);
     }
     return lines.join('\n');
 }
+function formatContentBlock(block, lines) {
+    const bullet = chalk.dim('*');
+    switch (block.type) {
+        case 'text':
+            lines.push(chalk.gray('````'));
+            lines.push(block.text);
+            lines.push(chalk.gray('````'));
+            break;
+        case 'resource_link':
+            lines.push(chalk.bold('Resource link'));
+            lines.push(`${bullet} URI: ${block.uri}`);
+            if (block.name)
+                lines.push(`${bullet} Name: ${block.name}`);
+            if (block.description) {
+                lines.push(`${bullet} Description: ${chalk.gray('````')}${block.description}${chalk.gray('````')}`);
+            }
+            if (block.mimeType)
+                lines.push(`${bullet} MIME type: ${block.mimeType}`);
+            break;
+        case 'image':
+            lines.push(`[Image: ${block.mimeType || 'unknown type'}${block.data ? `, ${block.data.length} chars base64` : ''}]`);
+            break;
+        case 'audio':
+            lines.push(`[Audio: ${block.mimeType || 'unknown type'}${block.data ? `, ${block.data.length} chars base64` : ''}]`);
+            break;
+        case 'resource':
+            lines.push(chalk.bold('Embedded resource'));
+            if (block.resource) {
+                lines.push(`${bullet} URI: ${block.resource.uri}`);
+                if (block.resource.mimeType)
+                    lines.push(`${bullet} MIME type: ${block.resource.mimeType}`);
+                if ('text' in block.resource && block.resource.text) {
+                    lines.push(chalk.gray('````'));
+                    lines.push(block.resource.text);
+                    lines.push(chalk.gray('````'));
+                }
+            }
+            break;
+        default:
+            lines.push(JSON.stringify(block, null, 2));
+    }
+}
+function findDuplicateTextBlocks(content, structuredContent) {
+    const dupes = new Set();
+    const canonical = JSON.stringify(structuredContent);
+    for (let i = 0; i < content.length; i++) {
+        const block = content[i];
+        if (!block || block.type !== 'text')
+            continue;
+        try {
+            const parsed = JSON.parse(block.text.trim());
+            if (JSON.stringify(parsed) === canonical)
+                dupes.add(i);
+        }
+        catch {
+        }
+    }
+    return dupes;
+}
+export function formatCallToolResultHuman(result) {
+    const lines = [];
+    const sc = result.structuredContent;
+    const hasStructuredContent = !!sc && Object.keys(sc).length > 0;
+    const content = result.content;
+    let skipIndices = new Set();
+    if (hasStructuredContent && content && sc) {
+        skipIndices = findDuplicateTextBlocks(content, sc);
+    }
+    if (content && content.length > 0) {
+        const visible = content.filter((_, i) => !skipIndices.has(i));
+        if (visible.length > 0) {
+            lines.push(chalk.bold('Content:'));
+            for (let i = 0; i < visible.length; i++) {
+                if (i > 0)
+                    lines.push('');
+                formatContentBlock(visible[i], lines);
+            }
+        }
+    }
+    if (hasStructuredContent) {
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(chalk.bold('Structured content:'));
+        const scJson = JSON.stringify(sc, null, 2);
+        lines.push(process.stdout.isTTY ? highlightJson(scJson) : scJson);
+    }
+    const meta = result._meta;
+    if (meta && typeof meta === 'object' && Object.keys(meta).length > 0) {
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(chalk.bold('Metadata:'));
+        const metaJson = JSON.stringify(meta, null, 2);
+        lines.push(process.stdout.isTTY ? highlightJson(metaJson) : metaJson);
+    }
+    if (lines.length === 0) {
+        return chalk.gray('(no content)');
+    }
+    return lines.join('\n');
+}
 export function formatObject(obj) {
     const lines = [];
     for (const [key, value] of Object.entries(obj)) {
-        const formattedKey = chalk.cyan(`${key}:`);
+        const formattedKey = theme.cyan(`${key}:`);
         let formattedValue;
         if (value === null || value === undefined) {
             formattedValue = chalk.gray(String(value));
@@ -575,16 +761,35 @@ export function formatObject(obj) {
     return lines.join('\n');
 }
 export function formatSuccess(message) {
-    return chalk.green(`✓ ${message}`);
+    return theme.green(`✓ ${message}`);
 }
 export function formatError(message) {
-    return chalk.red(`✗ ${message}`);
+    return theme.red(`✗ ${message}`);
 }
 export function formatWarning(message) {
-    return chalk.yellow(`⚠ ${message}`);
+    return theme.yellow(`⚠ ${message}`);
 }
 export function formatInfo(message) {
-    return chalk.cyan(`ℹ ${message}`);
+    return theme.cyan(`ℹ ${message}`);
+}
+export function formatTaskCommandsHint(target, taskId, status) {
+    const id = taskId ?? '<taskId>';
+    const lines = [
+        '\nAvailable commands:',
+        `  mcpc ${target} tasks-get ${id}`,
+        `  mcpc ${target} tasks-result ${id}`,
+    ];
+    if (status === undefined || status === 'working' || status === 'input_required') {
+        lines.push(`  mcpc ${target} tasks-cancel ${id}`);
+    }
+    return lines.join('\n');
+}
+export function truncateOutput(output, maxChars) {
+    if (output.length <= maxChars)
+        return output;
+    const truncated = output.substring(0, maxChars);
+    const totalSize = output.length >= 1024 ? `${(output.length / 1024).toFixed(1)}KB` : `${output.length} chars`;
+    return `${truncated}\n\n... output truncated (${totalSize} total, showing first ${maxChars} chars). Use --max-chars to adjust.`;
 }
 function truncateWithEllipsis(str, maxLen) {
     if (str.length <= maxLen + 3)
@@ -592,7 +797,7 @@ function truncateWithEllipsis(str, maxLen) {
     return str.substring(0, maxLen - 1) + '…';
 }
 export function formatSessionLine(session) {
-    const nameStr = chalk.cyan(session.name);
+    const nameStr = theme.cyan(session.name);
     let target;
     if (session.server.url) {
         target = session.server.url;
@@ -604,54 +809,29 @@ export function formatSessionLine(session) {
         }
     }
     const targetStr = truncateWithEllipsis(target, 80);
-    const parts = [];
-    if (session.server.command) {
-        parts.push('stdio');
+    let infoStr = '';
+    if (!session.server.command && session.profileName) {
+        infoStr = chalk.dim('(OAuth: ') + theme.magenta(session.profileName) + chalk.dim(')');
     }
-    else {
-        parts.push('HTTP');
-        if (session.profileName) {
-            parts.push('OAuth: ' + chalk.magenta(session.profileName) + chalk.dim(''));
-        }
-    }
-    const infoStr = chalk.dim('(') + chalk.dim(parts.join(', ')) + chalk.dim(')');
     let proxyStr = '';
     if (session.proxy) {
         proxyStr =
             ' ' +
-                chalk.green('[proxy: ') +
+                theme.green('[proxy: ') +
                 chalk.greenBright(`${session.proxy.host}:${session.proxy.port}`) +
-                chalk.green(']');
+                theme.green(']');
     }
-    return `${nameStr} → ${targetStr} ${infoStr}${proxyStr}`;
+    const suffix = [infoStr, proxyStr].filter(Boolean).join(' ');
+    return `${nameStr} → ${targetStr}${suffix ? ' ' + suffix : ''}`;
 }
 export async function logTarget(target, options) {
     if (options.outputMode !== 'human' || options.hide) {
         return;
     }
-    if (isValidSessionName(target)) {
-        const session = await getSession(target);
-        if (session) {
-            console.log(`[${formatSessionLine(session)}]\n`);
-        }
-        return;
-    }
-    const tc = options.serverConfig;
-    if (tc?.command) {
-        let targetStr = tc.command;
-        if (tc.args && tc.args.length > 0) {
-            targetStr += ' ' + tc.args.join(' ');
-        }
-        targetStr = truncateWithEllipsis(targetStr, 80);
-        console.log(`[→ ${targetStr} ${chalk.dim('(stdio)')}]`);
-        return;
-    }
-    const serverStr = tc?.url || target;
-    const parts = ['HTTP'];
-    if (options.profileName) {
-        parts.push('OAuth: ' + chalk.magenta(options.profileName));
+    const session = await getSession(target);
+    if (session) {
+        console.log(`[${formatSessionLine(session)}]\n`);
     }
-    console.log(`[→ ${serverStr} ${chalk.dim('(' + parts.join(', ') + ')')}]\n`);
 }
 export function formatJsonError(error, code) {
     return formatJson({
@@ -736,6 +916,7 @@ export function formatServerDetails(details, target, tools) {
     if (capabilities?.tasks) {
         commands.push(`${bullet} ${bt}mcpc ${target} tasks-list${bt}`);
         commands.push(`${bullet} ${bt}mcpc ${target} tasks-get <taskId>${bt}`);
+        commands.push(`${bullet} ${bt}mcpc ${target} tasks-result <taskId>${bt}`);
         commands.push(`${bullet} ${bt}mcpc ${target} tasks-cancel <taskId>${bt}`);
     }
     if (capabilities?.logging) {
@@ -744,6 +925,11 @@ export function formatServerDetails(details, target, tools) {
     commands.push(`${bullet} ${bt}mcpc ${target} shell${bt}`);
     lines.push(commands.join('\n'));
     lines.push('');
+    if (target.startsWith('@')) {
+        const logPath = join(getLogsDir(), `bridge-${target}.log`);
+        lines.push(chalk.dim(`Session log for debugging: ${logPath}`));
+        lines.push('');
+    }
     return lines.join('\n');
 }
 //# sourceMappingURL=output.js.map