bctranslate 1.0.0-beta.1

package/src/generators/setup.js

@@ -0,0 +1,445 @@
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { getLocaleDir } from './locales.js';
+
+/**
+ * Ensure the i18n configuration file and locale files exist.
+ * Creates them if they don't.
+ *
+ * @param {string} cwd - Project root
+ * @param {object} project - Detected project info
+ * @param {string} from - Source language code
+ * @param {string} to - Target language code
+ * @param {string} [customLocaleDir] - Optional override for locale directory
+ */
+export async function ensureI18nSetup(cwd, project, from, to, customLocaleDir, options = {}) {
+  const { autoImport = true } = options;
+  const localeDir = customLocaleDir || getLocaleDir(cwd, project);
+  mkdirSync(localeDir, { recursive: true });
+
+  // Ensure locale JSON files exist
+  for (const lang of [from, to]) {
+    const localePath = join(localeDir, `${lang}.json`);
+    if (!existsSync(localePath)) {
+      writeFileSync(localePath, '{}\n', 'utf-8');
+      console.log(chalk.green(`  ✓ Created ${localePath}`));
+    }
+  }
+
+  if (project.type === 'vue') {
+    await ensureVueI18n(cwd, project, from, to, localeDir, { autoImport });
+  } else if (project.type === 'react') {
+    await ensureReactI18n(cwd, project, from, to, localeDir, { autoImport });
+  } else {
+    await ensureVanillaI18n(cwd, from, to, localeDir, { autoImport });
+  }
+}
+
+async function ensureVueI18n(cwd, project, from, to, localeDir, { autoImport }) {
+  const i18nFile = join(cwd, 'src', 'i18n.js');
+
+  if (existsSync(i18nFile)) {
+    console.log(chalk.gray('  → i18n.js already exists, skipping setup'));
+    return;
+  }
+
+  const isVue3 = project.usesCompositionApi;
+  const relLocale = localeDir.replace(cwd, '.').replace(/\\/g, '/');
+
+  let content;
+  if (isVue3) {
+    content = `import { createI18n } from 'vue-i18n';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+function nestMessages(input) {
+  if (!input || typeof input !== 'object') return {};
+  const out = Array.isArray(input) ? [] : {};
+  for (const [rawKey, value] of Object.entries(input)) {
+    if (!rawKey.includes('.')) {
+      out[rawKey] = value;
+      continue;
+    }
+    const parts = rawKey.split('.').filter(Boolean);
+    let cur = out;
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      if (i === parts.length - 1) {
+        cur[p] = value;
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur = cur[p];
+      }
+    }
+  }
+  return out;
+}
+
+const i18n = createI18n({
+  legacy: false,
+  locale: '${from}',
+  fallbackLocale: '${from}',
+  messages: {
+    ${from}: nestMessages(${from}),
+    ${to}: nestMessages(${to}),
+  },
+});
+
+export default i18n;
+`;
+  } else {
+    content = `import Vue from 'vue';
+import VueI18n from 'vue-i18n';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+Vue.use(VueI18n);
+
+function nestMessages(input) {
+  if (!input || typeof input !== 'object') return {};
+  const out = Array.isArray(input) ? [] : {};
+  for (const [rawKey, value] of Object.entries(input)) {
+    if (!rawKey.includes('.')) {
+      out[rawKey] = value;
+      continue;
+    }
+    const parts = rawKey.split('.').filter(Boolean);
+    let cur = out;
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      if (i === parts.length - 1) {
+        cur[p] = value;
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur = cur[p];
+      }
+    }
+  }
+  return out;
+}
+
+const i18n = new VueI18n({
+  locale: '${from}',
+  fallbackLocale: '${from}',
+  messages: {
+    ${from}: nestMessages(${from}),
+    ${to}: nestMessages(${to}),
+  },
+});
+
+export default i18n;
+`;
+  }
+
+  mkdirSync(join(cwd, 'src'), { recursive: true });
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+  console.log(chalk.yellow(`  ⚠ Don't forget to install vue-i18n: npm install vue-i18n`));
+
+  if (autoImport) {
+    const injected = injectVueEntrypoint(cwd, isVue3);
+    if (!injected) {
+      console.log(chalk.yellow(`  ⚠ Import and use i18n in your main.js/main.ts`));
+    }
+  } else {
+    console.log(chalk.yellow(`  ⚠ Import and use i18n in your main.js/main.ts`));
+  }
+}
+
+async function ensureReactI18n(cwd, project, from, to, localeDir, { autoImport }) {
+  const i18nFile = join(cwd, 'src', 'i18n.js');
+
+  if (existsSync(i18nFile)) {
+    console.log(chalk.gray('  → i18n.js already exists, skipping setup'));
+    return;
+  }
+
+  const relLocale = localeDir.replace(cwd, '.').replace(/\\/g, '/');
+
+  const content = `import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import ${from} from '${relLocale}/${from}.json';
+import ${to} from '${relLocale}/${to}.json';
+
+function nestMessages(input) {
+  if (!input || typeof input !== 'object') return {};
+  const out = Array.isArray(input) ? [] : {};
+  for (const [rawKey, value] of Object.entries(input)) {
+    if (!rawKey.includes('.')) {
+      out[rawKey] = value;
+      continue;
+    }
+    const parts = rawKey.split('.').filter(Boolean);
+    let cur = out;
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      if (i === parts.length - 1) {
+        cur[p] = value;
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur = cur[p];
+      }
+    }
+  }
+  return out;
+}
+
+i18n.use(initReactI18next).init({
+  resources: {
+    ${from}: { translation: nestMessages(${from}) },
+    ${to}: { translation: nestMessages(${to}) },
+  },
+  lng: '${from}',
+  fallbackLng: '${from}',
+  interpolation: {
+    escapeValue: false,
+  },
+});
+
+export default i18n;
+`;
+
+  mkdirSync(join(cwd, 'src'), { recursive: true });
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+  console.log(chalk.yellow(`  ⚠ Don't forget to install: npm install i18next react-i18next`));
+
+  if (autoImport) {
+    const injected = injectReactEntrypoint(cwd);
+    if (!injected) {
+      console.log(chalk.yellow(`  ⚠ Import './i18n' in your index.js/App.js`));
+    }
+  } else {
+    console.log(chalk.yellow(`  ⚠ Import './i18n' in your index.js/App.js`));
+  }
+}
+
+async function ensureVanillaI18n(cwd, from, to, localeDir, { autoImport }) {
+  const i18nFile = join(cwd, 'i18n.js');
+
+  if (existsSync(i18nFile)) {
+    console.log(chalk.gray('  → i18n.js already exists, skipping setup'));
+    return;
+  }
+
+  const content = `/**
+ * Simple i18n for vanilla JS — generated by bctranslate
+ */
+(function () {
+  const locales = {};
+  let currentLocale = '${from}';
+  const fallbackLocale = '${from}';
+
+  async function loadLocale(lang) {
+    if (locales[lang]) return;
+    const resp = await fetch('./locales/' + lang + '.json');
+    locales[lang] = await resp.json();
+  }
+
+  function t(key, params) {
+    // Support both flat keys ("home.submit") and nested objects ({ home: { submit: ... } })
+    const dict = locales[currentLocale] || {};
+    const dictFallback = locales[fallbackLocale] || {};
+
+    const lookup = (d) => {
+      const direct = Object.prototype.hasOwnProperty.call(d, key) ? d[key] : null;
+      return direct !== null && direct !== undefined
+        ? direct
+        : key.split('.').reduce((obj, i) => (obj ? obj[i] : null), d);
+    };
+
+    const msg = lookup(dict) ?? lookup(dictFallback) ?? key;
+
+    if (!params) return msg;
+    return String(msg).replace(/\\{(\\w+)\\}/g, (match, k) =>
+      params[k] !== undefined ? params[k] : match
+    );
+  }
+
+  async function setLocale(lang) {
+    await loadLocale(lang);
+    currentLocale = lang;
+    // Re-translate all elements with data-i18n attribute
+    document.querySelectorAll('[data-i18n]').forEach(function (el) {
+      const key = el.getAttribute('data-i18n');
+      const translated = t(key);
+      // Preserve markup translations (e.g. "Hello <strong>world</strong>")
+      if (el.children.length > 0 || /<[^>]+>/.test(String(translated))) {
+        el.innerHTML = translated;
+      } else {
+        el.textContent = translated;
+      }
+    });
+    document.querySelectorAll('[data-i18n-placeholder]').forEach(function (el) {
+      el.placeholder = t(el.getAttribute('data-i18n-placeholder'));
+    });
+    document.querySelectorAll('[data-i18n-title]').forEach(function (el) {
+      const translated = t(el.getAttribute('data-i18n-title'));
+      if (el.tagName === 'TITLE') {
+        document.title = translated;
+      } else {
+        el.title = translated;
+      }
+    });
+  }
+
+  // Auto-init
+  loadLocale('${from}');
+
+  const api = { t: t, setLocale: setLocale, loadLocale: loadLocale, ready: null };
+  window.i18n = api;
+  api.ready = setLocale('${to}');
+})();
+`;
+
+  writeFileSync(i18nFile, content, 'utf-8');
+  console.log(chalk.green(`  ✓ Created ${i18nFile}`));
+
+  if (autoImport) {
+    const injected = injectVanillaI18nEntrypoint(cwd);
+    if (!injected) {
+      console.log(chalk.yellow(`  ⚠ Add <script src="i18n.js"></script> to your HTML`));
+    }
+  } else {
+    console.log(chalk.yellow(`  ⚠ Add <script src="i18n.js"></script> to your HTML`));
+  }
+}
+
+function injectVueEntrypoint(cwd, isVue3) {
+  const candidates = [
+    join(cwd, 'src', 'main.ts'),
+    join(cwd, 'src', 'main.js'),
+    join(cwd, 'src', 'main.tsx'),
+    join(cwd, 'src', 'main.jsx'),
+  ];
+
+  const mainFile = candidates.find((p) => existsSync(p));
+  if (!mainFile) return false;
+
+  let code = readFileSync(mainFile, 'utf-8');
+
+  const hasI18nImport =
+    code.includes("from './i18n'") ||
+    code.includes('from "./i18n"') ||
+    code.includes("from './i18n.js'") ||
+    code.includes('from "./i18n.js"') ||
+    code.includes("import './i18n'") ||
+    code.includes('import "./i18n"');
+
+  if (!hasI18nImport) {
+    const importRe = /^import\s.+?;\s*$/gm;
+    let lastImportEnd = 0;
+    let m;
+    while ((m = importRe.exec(code)) !== null) lastImportEnd = m.index + m[0].length;
+    code =
+      code.slice(0, lastImportEnd) +
+      `\nimport i18n from './i18n';\n` +
+      code.slice(lastImportEnd);
+  }
+
+  if (isVue3) {
+    if (!code.includes('.use(i18n)') && !code.includes('use(i18n)')) {
+      const chained = /createApp\(([^)]*)\)\s*\.mount\(/;
+      if (chained.test(code)) {
+        code = code.replace(chained, 'createApp($1).use(i18n).mount(');
+      } else {
+        const hasAppVar =
+          /\bconst\s+app\s*=\s*createApp\(/.test(code) ||
+          /\blet\s+app\s*=\s*createApp\(/.test(code);
+        const mountIdx = code.indexOf('app.mount(');
+        if (hasAppVar && mountIdx !== -1 && !code.includes('app.use(i18n')) {
+          code = code.slice(0, mountIdx) + `app.use(i18n);\n` + code.slice(mountIdx);
+        } else {
+          return false;
+        }
+      }
+    }
+  } else {
+    if (!/\bi18n\s*[:,]/.test(code)) {
+      const newVue = /new\s+Vue\s*\(\s*\{/;
+      if (newVue.test(code)) {
+        code = code.replace(newVue, (m) => m + '\n  i18n,');
+      } else {
+        return false;
+      }
+    }
+  }
+
+  writeFileSync(mainFile, code, 'utf-8');
+  console.log(chalk.green(`  ✓ Updated ${mainFile} (wired i18n)`));
+  return true;
+}
+
+function injectReactEntrypoint(cwd) {
+  const candidates = [
+    join(cwd, 'src', 'index.tsx'),
+    join(cwd, 'src', 'index.js'),
+    join(cwd, 'src', 'main.tsx'),
+    join(cwd, 'src', 'main.jsx'),
+  ];
+
+  const entryFile = candidates.find((p) => existsSync(p));
+  if (!entryFile) return false;
+
+  let code = readFileSync(entryFile, 'utf-8');
+  if (
+    code.includes("from './i18n'") ||
+    code.includes('from "./i18n"') ||
+    code.includes("import './i18n'") ||
+    code.includes('import "./i18n"')
+  ) {
+    return true;
+  }
+
+  const importRe = /^import\s.+?;\s*$/gm;
+  let lastImportEnd = 0;
+  let m;
+  while ((m = importRe.exec(code)) !== null) lastImportEnd = m.index + m[0].length;
+  code = code.slice(0, lastImportEnd) + `\nimport './i18n';\n` + code.slice(lastImportEnd);
+
+  writeFileSync(entryFile, code, 'utf-8');
+  console.log(chalk.green(`  ✓ Updated ${entryFile} (imported i18n)`));
+  return true;
+}
+
+function injectVanillaI18nEntrypoint(cwd) {
+  // Prefer HTML entrypoint if present
+  const htmlPath = join(cwd, 'index.html');
+  if (existsSync(htmlPath)) {
+    const html = readFileSync(htmlPath, 'utf-8');
+    if (!/\bi18n\.js\b/.test(html)) {
+      const scriptTag = `  <script src="./i18n.js"></script>\n`;
+      let updated = html;
+
+      const firstScript = updated.match(/<script\b/i);
+      if (firstScript) {
+        updated = updated.replace(firstScript[0], scriptTag + firstScript[0]);
+      } else if (updated.includes('</body>')) {
+        updated = updated.replace('</body>', scriptTag + '</body>');
+      } else if (updated.includes('</head>')) {
+        updated = updated.replace('</head>', scriptTag + '</head>');
+      } else {
+        updated += '\n' + scriptTag;
+      }
+
+      writeFileSync(htmlPath, updated, 'utf-8');
+      console.log(chalk.green(`  ✓ Updated ${htmlPath} (added i18n.js script)`));
+    }
+    return true;
+  }
+
+  // Fallback: ESM entrypoint
+  const jsPath = join(cwd, 'index.js');
+  if (existsSync(jsPath)) {
+    const js = readFileSync(jsPath, 'utf-8');
+    const alreadyImports = js.includes("./i18n.js") || js.includes("'./i18n.js'") || js.includes("\"./i18n.js\"");
+    if (!alreadyImports && /\b(import|export)\b/.test(js)) {
+      writeFileSync(jsPath, `import './i18n.js';\n` + js, 'utf-8');
+      console.log(chalk.green(`  ✓ Updated ${jsPath} (imported i18n.js)`));
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/index.js

@@ -0,0 +1,233 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { extname, relative, basename, dirname, join } from 'path';
+import { parseVue } from './parsers/vue.js';
+import { parseReact } from './parsers/react.js';
+import { parseHtml } from './parsers/html.js';
+import { parseJs } from './parsers/js.js';
+import { parseJson, applyJsonTranslations } from './parsers/json.js';
+import { translateBatch } from './bridges/python.js';
+import { getLocaleDir, saveLocale, loadLocale } from './generators/locales.js';
+
+// ── Route source file to the correct parser ──────────────────────────────────
+
+function routeParser(ext, source, filePath, project, jsonMode) {
+  switch (ext) {
+    case '.vue':  return parseVue(source, filePath);
+    case '.jsx':
+    case '.tsx':  return parseReact(source, filePath);
+    case '.html':
+    case '.htm':  return parseHtml(source, filePath, project);
+    case '.js':
+    case '.ts':
+      if (source.includes('React') || source.includes('jsx') || /<\w+[\s>]/.test(source)) {
+        return parseReact(source, filePath);
+      }
+      return parseJs(source, filePath, project);
+    case '.json': return parseJson(source, filePath, { jsonMode });
+    default:      return null;
+  }
+}
+
+/**
+ * Parse a file — no translation, no disk writes.
+ * Returns extracted strings + modified source for later application.
+ */
+export function parseFileOnly(filePath, opts) {
+  const { project, jsonMode = 'values' } = opts;
+  const ext    = extname(filePath).toLowerCase();
+  const source = readFileSync(filePath, 'utf-8');
+
+  const result = routeParser(ext, source, filePath, project, jsonMode);
+  if (!result || !result.extracted?.length) {
+    return { source, modified: source, extracted: [], ext, filePath };
+  }
+  return {
+    source,
+    modified:  result.source,
+    extracted: result.extracted,
+    ext,
+    filePath,
+    jsonData: result.jsonData,
+  };
+}
+
+/**
+ * Apply a completed translations map to one parsed file and write to disk.
+ * The original file is NOT touched until an atomic rename succeeds.
+ */
+export async function writeFileResult(parseResult, translations, opts) {
+  const { source, modified, extracted, ext, filePath, jsonData } = parseResult;
+  const { from, to, dryRun, outdir, project, cwd, verbose, localesDir } = opts;
+
+  const relativePath = relative(cwd, filePath);
+  if (!extracted?.length) return { count: 0, skipped: 0, relativePath };
+
+  // Deduplicate extracted items by key
+  const seen   = new Set();
+  const unique = extracted.filter(({ key }) => {
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  const resolvedLocaleDir = localesDir || getLocaleDir(cwd, project);
+  const existingTarget    = loadLocale(resolvedLocaleDir, to);
+
+  const newCount = unique.filter(({ key }) => !(key in existingTarget)).length;
+  const skipped  = unique.length - newCount;
+
+  // Build locale entry maps
+  const fromEntries = {};
+  const toEntries   = {};
+  for (const { key, text } of unique) {
+    fromEntries[key] = text;
+    toEntries[key]   = translations[key] ?? existingTarget[key] ?? text;
+  }
+
+  if (!dryRun) {
+    saveLocale(resolvedLocaleDir, from, fromEntries);
+    saveLocale(resolvedLocaleDir, to,   toEntries);
+
+    if (ext === '.json') {
+      const translatedData = applyJsonTranslations(jsonData, toEntries);
+      const outName = basename(filePath, ext) + `.${to}${ext}`;
+      const outPath = outdir
+        ? join(outdir, outName)
+        : join(dirname(filePath), outName);
+      mkdirSync(dirname(outPath), { recursive: true });
+      writeFileSync(outPath, JSON.stringify(translatedData, null, 2) + '\n', 'utf-8');
+
+    } else if (modified !== source) {
+      // Only rewrite source when content actually changed
+      // Atomic: write .bctmp first, then rename — original untouched until swap
+      const outPath  = outdir ? join(outdir, basename(filePath)) : filePath;
+      const tmpPath  = outPath + '.bctmp';
+      if (outdir) mkdirSync(outdir, { recursive: true });
+      writeFileSync(tmpPath, modified, 'utf-8');
+      const { renameSync } = await import('fs');
+      renameSync(tmpPath, outPath);
+    }
+  }
+
+  return {
+    count:  newCount,
+    skipped,
+    relativePath,
+    diff: dryRun || verbose ? generateDiff(source, modified, relativePath) : null,
+  };
+}
+
+/**
+ * Translate ALL files in one Python invocation — model loads exactly once.
+ *
+ *  Phase 1: Parse every file (pure CPU — no network/Python)
+ *  Phase 2: Collect all unique keys not already in the target locale
+ *  Phase 3: translateBatch() once → Python starts, model loads, all strings translated
+ *  Phase 4: Write each file
+ */
+export async function translateAllFiles(files, opts) {
+  const { from, to, cwd, project, verbose, localesDir } = opts;
+  const prof0 = opts.profile ? Date.now() : 0;
+
+  const resolvedLocaleDir = opts.outdir ? join(opts.outdir, 'locales') : (localesDir || getLocaleDir(cwd, project));
+  const existingTarget    = loadLocale(resolvedLocaleDir, to);
+
+  // Phase 1 — parse
+  const profParse0 = opts.profile ? Date.now() : 0;
+  const parsed = [];
+  for (const file of files) {
+    try {
+      const result = parseFileOnly(file, opts);
+      if (result.extracted.length > 0) parsed.push(result);
+    } catch (err) {
+      if (verbose) console.error(`  Parse error ${file}: ${err.message}`);
+    }
+  }
+  const profParse1 = opts.profile ? Date.now() : 0;
+
+  if (parsed.length === 0) return [];
+
+  // Phase 2 — deduplicate across all files, skip already-translated keys
+  const seenKeys = new Set(Object.keys(existingTarget));
+  const needed   = [];
+  for (const { extracted } of parsed) {
+    for (const { key, text } of extracted) {
+      if (!seenKeys.has(key)) {
+        seenKeys.add(key);
+        needed.push({ key, text });
+      }
+    }
+  }
+
+  // Phase 3 — translate once (Python spawned exactly once, model loads once)
+  const profTrans0 = opts.profile ? Date.now() : 0;
+  let newTranslations = {};
+  if (needed.length > 0) {
+    newTranslations = await translateBatch(needed, from, to);
+  }
+  const profTrans1 = opts.profile ? Date.now() : 0;
+
+  const allTranslations = { ...existingTarget, ...newTranslations };
+
+  // Phase 4 — write files
+  const profWrite0 = opts.profile ? Date.now() : 0;
+  if (!opts.dryRun) {
+    console.log(`  → Locale dir: ${resolvedLocaleDir}`);
+  }
+  const results = [];
+  for (const parseResult of parsed) {
+    try {
+      const r = await writeFileResult(parseResult, allTranslations, {
+        ...opts,
+        localesDir: resolvedLocaleDir,
+      });
+      results.push(r);
+    } catch (err) {
+      console.error(`  ✗ Write error ${relative(cwd, parseResult.filePath)}: ${err.message}`);
+      results.push({ count: 0, skipped: 0, relativePath: relative(cwd, parseResult.filePath) });
+    }
+  }
+  const profWrite1 = opts.profile ? Date.now() : 0;
+
+  if (opts.profile) {
+    const total = Date.now() - prof0;
+    console.log(
+      `  Timing: parse ${profParse1 - profParse0}ms | translate ${profTrans1 - profTrans0}ms | write ${profWrite1 - profWrite0}ms | total ${total}ms`
+    );
+  }
+
+  return results;
+}
+
+/**
+ * Single-file convenience wrapper (for backward compatibility).
+ */
+export async function translateFile(filePath, opts) {
+  const results = await translateAllFiles([filePath], opts);
+  return results[0] ?? { count: 0, skipped: 0, relativePath: relative(opts.cwd, filePath) };
+}
+
+// ── Diff display ─────────────────────────────────────────────────────────────
+
+export function generateDiff(original, modified, label = '') {
+  if (!modified || original === modified) return '';
+
+  const origLines = original.split('\n');
+  const modLines  = modified.split('\n');
+  const out       = label ? [`--- ${label} ---`] : [];
+
+  const maxLines = Math.max(origLines.length, modLines.length);
+  for (let i = 0; i < maxLines; i++) {
+    const a = origLines[i] ?? '';
+    const b = modLines[i]  ?? '';
+    if (a !== b) {
+      out.push(`  ${String(i + 1).padStart(4)} - ${a.trimEnd()}`);
+      out.push(`  ${String(i + 1).padStart(4)} + ${b.trimEnd()}`);
+    }
+  }
+
+  if (out.length > 80) {
+    return out.slice(0, 80).join('\n') + `\n  ... (${out.length - 80} more lines truncated)`;
+  }
+  return out.join('\n');
+}