veodl 1.12.1 → 2.0.0

package/src/interactive.js

@@ -1,120 +0,0 @@
-import { outputStream, formatOutput } from './output.js';
-import { createInterface } from 'node:readline/promises';
-import { availableHeights, cleanText, validateUrl } from './utils.js';
-import { applyProfile, selectedProfileName } from './config.js';
-import { fetchMetadata, prepareBackend, runBackend } from './downloader.js';
-import { describeEstimate, selectedEntries, sizeEstimate, validateItems } from './playlist.js';
-
-export async function interactiveArgs(config, { signal, input = process.stdin, output = process.stderr, ask, inspect, discover } = {}) {
-  const terminalOutput = output;
-  output = outputStream(output);
-  const rl = ask ? null : createInterface({ input, output: terminalOutput });
-  const controller = new AbortController();
-  signal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-  rl?.on('SIGINT', () => controller.abort());
-  const question = ask || (prompt => rl.question(formatOutput(prompt, terminalOutput), { signal }));
-  const choose = async (prompt, allowed, fallback) => {
-    while (true) {
-      const answer = (await question(prompt)).trim() || fallback;
-      if (allowed.includes(answer)) return answer;
-      output.write(`Choose: ${allowed.join(', ')}\n`);
-    }
-  };
-  try {
-    const args = [];
-    const profiles = Object.keys(config.profiles || {});
-    let defaults = applyProfile(config);
-    if (profiles.length) {
-      const selected = selectedProfileName(config);
-      const choices = selected ? profiles : [...profiles, 'none'];
-      const fallback = selected || 'none';
-      const profile = await choose(`Profile (${choices.join(', ')}) [${fallback}]: `, choices, fallback);
-      if (profile !== 'none') { args.push('--profile', profile); defaults = applyProfile(config, profile); }
-    }
-    const url = validateUrl((await question('Video or playlist URL: ')).trim());
-    args.push(url);
-    if (defaults.listSources) {
-      output.write('Listing page sources…\n');
-      args.push('--list-sources');
-      return args;
-    }
-    const type = await choose(`Download (video/audio) [${defaults.audio ? 'audio' : 'video'}]: `, ['video', 'audio'], defaults.audio ? 'audio' : 'video');
-    args.push(type === 'audio' ? '--audio' : '--no-audio');
-    output.write('Reading available media…\n');
-    // Inspect the collection first so ordinary video links do not need a playlist prompt.
-    const inspectionOptions = { ...defaults, url, playlist: true };
-    const backend = inspect ? null : await prepareBackend(inspectionOptions, { signal });
-    let metadata;
-    try {
-      metadata = inspect ? await inspect(inspectionOptions) : await fetchMetadata(inspectionOptions, { signal, backend, runner: runBackend });
-      if (Array.isArray(metadata.formats) && !metadata.formats.length && !metadata.entries?.length && !metadata.url) {
-        throw new Error('No downloadable video formats found.');
-      }
-    } catch (originalError) {
-      const { discoverSources, formatSource, parseSourceTimeout, shouldOfferSourceDiscovery } = await import('./source-discovery.js');
-      if (!shouldOfferSourceDiscovery(originalError)) throw originalError;
-      if (defaults.autoListSources === false) throw originalError;
-      const inspectSource = (mediaUrl, _page, { signal: scanSignal = signal } = {}) => inspect
-        ? inspect({ ...inspectionOptions, playlist: false, mediaUrl }, scanSignal)
-        : fetchMetadata({ ...inspectionOptions, playlist: false, mediaUrl }, { signal: scanSignal, backend, runner: runBackend });
-      const sources = await (discover || discoverSources)(url, { signal, inspect: inspectSource,
-        deepScan: defaults.deepScan, timeoutMs: defaults.timeout ? parseSourceTimeout(defaults.timeout) : undefined }).catch(() => []);
-      if (!sources.length) throw originalError;
-      let selection = sources[0];
-      if (sources.length > 1) {
-        for (const source of sources) output.write(`${formatSource(source)}\n`);
-        selection = null;
-        while (!selection) {
-          const answer = (await question('Source number: ')).trim();
-          const index = Number(answer);
-          if (/^[1-9]\d*$/.test(answer) && sources[index - 1]) selection = sources[index - 1];
-          else output.write(`Choose a number from 1 to ${sources.length}.\n`);
-        }
-      } else output.write(`Found video source: ${formatSource(selection)}\n`);
-      args.push('--source', String(selection.index));
-      metadata = await inspectSource(selection.url);
-    }
-    const isCollection = metadata._type === 'playlist' || Boolean(metadata.entries);
-    const collection = isCollection
-      ? await choose(`Download the playlist? (y/n) [${defaults.playlist === false ? 'n' : 'y'}]: `,
-        ['y', 'n'], defaults.playlist === false ? 'n' : 'y')
-      : 'n';
-    args.push(collection === 'y' ? '--playlist' : '--no-playlist');
-    output.write(`${cleanText(metadata.title || metadata.id || 'Media')}\n`);
-    if (collection === 'y' && metadata.entries) {
-      for (const { entry, index } of selectedEntries(metadata)) output.write(`${index}. ${cleanText(entry?.title || 'Unavailable entry')}\n`);
-      let selection;
-      while (true) {
-        const preferred = defaults.playlistItems || '';
-        selection = (await question(`Entries (e.g. 1,3-5; Enter = ${preferred || 'all'}): `)).trim() || preferred;
-        try { if (selection) validateItems(selection); selectedEntries(metadata, selection); break; }
-        catch (error) { output.write(`${error.message}\n`); }
-      }
-      if (selection) args.push('--playlist-items', selection);
-      output.write(`${describeEstimate(sizeEstimate(selectedEntries(metadata, selection)))}\n`);
-    }
-    if (type === 'video') {
-      const heights = availableHeights(metadata.formats).sort((a, b) => b - a).map(height => `${height}p`);
-      const choices = ['best', ...heights];
-      if (!heights.length) output.write('Resolution metadata unavailable; using best. Set a quality cap with -q in command mode.\n');
-      const fallback = choices.includes(defaults.quality) ? defaults.quality : 'best';
-      args.push('-q', await choose(`Quality (${choices.join(', ')}) [${fallback}]: `, choices, fallback));
-    }
-    // Switching the media type must not leave an incompatible format from a profile.
-    if (type === 'video' && ['mp3', 'm4a', 'aac', 'opus', 'flac', 'wav'].includes(defaults.format)) args.push('--format', 'mp4');
-    if (type === 'audio' && ['mp4', 'mkv', 'webm', 'mov'].includes(defaults.format)) args.push('--format', 'mp3');
-    const directory = (await question(`Output directory [${defaults.output || process.cwd()}]: `)).trim() || defaults.output || process.cwd();
-    args.push('-o', directory);
-    if (defaults.incognito) {
-      args.push('--no-resume', '--no-skip-existing');
-    } else {
-      args.push('--resume');
-      const skipDefault = defaults.skipExisting === false ? 'n' : 'y';
-      const skip = await choose(`Skip previously downloaded videos? (y/n) [${skipDefault}]: `, ['y', 'n'], skipDefault);
-      args.push(skip === 'y' ? '--skip-existing' : '--no-skip-existing');
-    }
-    output.write(`Ready: ${type}, ${directory}\n`);
-    if (await choose('Start download? (y/n) [y]: ', ['y', 'n'], 'y') === 'n') return null;
-    return args;
-  } finally { rl?.close(); }
-}

package/src/jobs.js

@@ -1,218 +0,0 @@
-import { runPool, serialQueue, reducedLimit, formatTimings } from './execution.js';
-import { styleText, terminalText } from './progress.js';
-import path from 'node:path';
-import { lstat, mkdtemp, readdir, rm } from 'node:fs/promises';
-import os from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { cacheBase } from './paths.js';
-import { publicOptions, readJson, writeJson } from './state.js';
-import { cleanText, readableError, validateUrl } from './utils.js';
-import { RUN_ARCHIVE_ID } from './run-archive.js';
-import { folderLink } from './path-links.js';
-
-export async function retryOptions(file, root = cacheBase()) {
-  if (RUN_ARCHIVE_ID.test(file)) file = await retryJobForRun(file, root);
-  const job = await readJson(path.resolve(file), null);
-  if (job?.version !== 1 || !Array.isArray(job.items)) throw new Error('Invalid retry job file.');
-  const pending = job.items.filter(item => !['saved', 'skipped'].includes(item.status));
-  if (!pending.length) throw new Error('This job has no failed or unfinished downloads.');
-  return pending.map(item => {
-    validateUrl(item.url);
-    const entries = item.entries || [];
-    // After interruption, retry the original selection; resume history skips completed entries.
-    const failures = entries.filter(entry => entry.status === 'failed');
-    return { ...job.options, ...item.options, url: item.url, resume: true,
-      ...(item.status === 'failed' && failures.length && item.finished ? { playlistItems: failures.map(entry => entry.index).join(',') } : {}) };
-  });
-}
-
-/** Resolve a persistent run ID using its original retry job, including older runs. */
-async function retryJobForRun(id, root) {
-  const { listRuns } = await import('./runs.js');
-  const runs = await listRuns(root);
-  if (runs.some(run => run.id === id && run.alive)) throw new Error(`Run ${id} is still active. Stop it before retrying.`);
-  const directory = path.join(path.resolve(root), 'jobs');
-  const entries = await readdir(directory, { withFileTypes: true }).catch(error => {
-    if (error.code === 'ENOENT') return [];
-    throw error;
-  });
-  for (const entry of entries.filter(entry => entry.isFile() && /^\d{13}-[a-f0-9-]{36}\.json$/.test(entry.name)).sort((a, b) => b.name.localeCompare(a.name))) {
-    const file = path.join(directory, entry.name);
-    const job = await readJson(file, null).catch(error => { if (error instanceof SyntaxError) return null; throw error; });
-    if (job?.runId === id) return file;
-  }
-  throw new Error(`No retry job found for run ${id}. Retry jobs may have been removed by veo flush.`);
-}
-
-/**
- * Location of one run's job file. It is created before the first download starts
- * so `veo runs <id>` can report per-item progress from it.
- */
-export function jobFilePath(root = cacheBase()) {
-  return path.join(root, 'jobs', `${Date.now()}-${randomUUID()}.json`);
-}
-
-/** Find the newest retryable job, skipping finished jobs and active runs. */
-export async function latestFailedJob(root = cacheBase()) {
-  const directory = path.join(path.resolve(root), 'jobs');
-  const info = await lstat(directory).catch(error => { if (error.code === 'ENOENT') return null; throw error; });
-  if (!info) throw new Error('No retry jobs found. Run a download first.');
-  if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Invalid retry job directory: ${directory}`);
-  const { listRuns } = await import('./runs.js');
-  const active = new Set((await listRuns(root)).filter(run => run.alive && run.job).map(run => path.resolve(run.job)));
-  const names = (await readdir(directory, { withFileTypes: true }))
-    .filter(entry => entry.isFile() && /^\d{13}-[a-f0-9-]{36}\.json$/.test(entry.name))
-    .map(entry => entry.name).sort().reverse();
-  for (const name of names) {
-    const file = path.join(directory, name);
-    if (active.has(file)) continue;
-    const job = await readJson(file, null).catch(error => { if (error instanceof SyntaxError) return null; throw error; });
-    if (job?.version === 1 && job.options && typeof job.options === 'object' && !Array.isArray(job.options)
-      && Array.isArray(job.items) && job.items.every(item => item && typeof item.url === 'string' && typeof item.status === 'string')
-      && job.items.some(item => !['saved', 'skipped'].includes(item.status))) return file;
-  }
-  throw new Error('No failed or unfinished retry job found.');
-}
-
-export async function runJob(options, { download, reporter, signal, openFile, stdout = process.stdout, stderr = process.stderr, jobFile, items, recordStats, recordHistory, runId, archiveRoot } = {}) {
-  if (options.incognito) {
-    runId = undefined;
-    recordStats = undefined;
-    recordHistory = undefined;
-  }
-  const concurrency = options.concurrentDownloads ?? 2;
-  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 4) throw new Error('Concurrent downloads must be between 1 and 4.');
-  const file = jobFile || jobFilePath();
-  const requests = items || options.urls.map(url => ({ ...options, url }));
-  const job = { version: 1, ...(runId ? { runId } : {}), startedAt: new Date().toISOString(), options: publicOptions({ ...options, output: path.resolve(options.output) }),
-    items: requests.map(item => ({ url: item.url, status: 'pending', entries: [] })) };
-  // Each retry item can have its own playlist selection.
-  job.items.forEach((item, index) => { item.options = publicOptions(requests[index]); });
-  const { cleanupDownloadCache } = await import('./download-cache.js');
-  if (!options.incognito) await cleanupDownloadCache();
-  const privateRoot = options.incognito ? await mkdtemp(path.join(os.tmpdir(), 'veo-incognito-')) : null;
-  const queue = serialQueue();
-  const persist = () => options.incognito ? Promise.resolve() : queue(() => writeJson(file, job));
-  await persist();
-  const activeTargets = new Map();
-  const totals = { saved: 0, skipped: 0, failed: 0 };
-  const adaptiveState = { divisor: 1 };
-  const archiveTools = runId ? await import('./run-archive.js') : null;
-  try {
-    await runPool(requests, () => reducedLimit(concurrency, adaptiveState), async (request, index) => {
-    const targetKey = JSON.stringify([request.url, path.resolve(request.output)]);
-    const previous = activeTargets.get(targetKey);
-    let release;
-    const current = new Promise(resolve => { release = resolve; });
-    activeTargets.set(targetKey, current);
-    try {
-      await previous;
-      signal?.throwIfAborted();
-      let saved = 0, skipped = 0, failed = 0;
-      const itemReporter = concurrency > 1 && requests.length > 1 ? reporter.scoped?.(index + 1, requests.length, request.url) || reporter : reporter;
-      const item = job.items[index];
-      const captureFiles = async files => {
-        if (!archiveTools) return;
-        item.fingerprints ||= {};
-        for (const target of files || []) {
-          if (!archiveTools.isMediaFile(target) || item.fingerprints[target]) continue;
-          item.fingerprints[target] = await archiveTools.fileFingerprint(target).catch(() => null);
-        }
-      };
-      const started = performance.now();
-      const published = new Set();
-      let opened = false;
-      let title;
-      const publish = async files => {
-        if (!options.json) for (const target of files) {
-          if (!published.has(target)) {
-            const display = terminalText(stdout, `Saved: ${cleanText(target)}`);
-            stdout.write(styleText(stdout, display.startsWith('Saved: ') ? `Saved: ${folderLink(stdout, target, display.slice(7))}` : display, 'success', options.color !== false) + '\n');
-          }
-          published.add(target);
-        }
-        if (request.open && !opened && files.length) {
-          opened = true;
-          try { await openFile(files[0]); }
-          catch (error) { stderr.write(`veo: File saved, but could not launch the default app: ${readableError(error)}\n`); }
-        }
-      };
-      if (itemReporter === reporter) reporter.item?.(index + 1, requests.length, request.url);
-      try {
-        item.status = 'running';
-        await persist();
-        const result = await download(request, { reporter: itemReporter, signal, adaptiveState, skipCacheCleanup: true,
-          ...(privateRoot ? { localRoot: privateRoot } : {}), onEntry: async entry => {
-          await captureFiles(entry.files);
-          item.entries.push(entry);
-          await persist();
-          if (entry.status === 'saved') saved++;
-          if (entry.status === 'skipped') skipped++;
-          if (entry.status === 'failed') failed++;
-          await publish(entry.files || []);
-        } });
-        await captureFiles(result.files);
-        Object.assign(item, { status: result.status || 'saved', files: result.files, timings: result.timings, entryTimings: result.entryTimings, finished: true });
-        title = result.title;
-        if (!item.entries.length) {
-          saved += result.saved ?? (item.status === 'saved' ? 1 : 0);
-          skipped += result.skipped ?? 0;
-          failed += result.failures?.length ?? (item.status === 'failed' ? 1 : 0);
-        }
-        if (options.json) stdout.write(`${JSON.stringify({ ...result, status: item.status, profile: request.profile || null, ...(runId ? { runId } : {}) })}\n`);
-        await publish(result.files);
-      } catch (error) {
-        item.status = signal?.aborted ? 'cancelled' : 'failed';
-        item.error = readableError(error);
-        if (!signal?.aborted) failed++;
-        item.files = [...new Set([...item.entries.flatMap(entry => entry.files || []), ...(error.files || [])])];
-        if (options.json) stdout.write(`${JSON.stringify({ url: request.url, status: item.status, profile: request.profile || null, error: item.error, files: item.files, ...(runId ? { runId } : {}) })}\n`);
-        else stderr.write(styleText(stderr, terminalText(stderr, `veo: ${item.error} (${request.url})`), 'error', options.color !== false) + '\n');
-        if (error.verificationFailed && !options.json) for (const file of item.files) stderr.write(`Saved file retained: ${cleanText(file)}\n`);
-      }
-      if (recordStats) {
-        try {
-          await recordStats({ videos: request.audio ? 0 : saved,
-            audio: request.audio ? saved : 0, failed: failed,
-            skipped: skipped, cancelled: item.status === 'cancelled' ? 1 : 0,
-            elapsedMs: Math.round(performance.now() - started) });
-        } catch (error) { stderr.write(`veo: Could not save statistics: ${readableError(error)}\n`); }
-      }
-      // History is written per finished item, so `veo history` never reports an
-      // attempt that is still running.
-      if (recordHistory) {
-        try {
-          await recordHistory({ url: request.url, title, status: item.status, runId, job: ['failed', 'cancelled'].includes(item.status) ? file : null, audio: Boolean(request.audio),
-            quality: request.quality, format: request.format, files: item.files || [], error: item.error,
-            elapsedMs: Math.round(performance.now() - started) });
-        } catch (error) { stderr.write(`veo: Could not save download history: ${readableError(error)}\n`); }
-      }
-      await persist();
-      totals.saved += saved; totals.skipped += skipped; totals.failed += failed;
-    } finally { release(); if (activeTargets.get(targetKey) === current) activeTargets.delete(targetKey); }
-    }, { signal }).catch(error => { if (!signal?.aborted) throw error; });
-  } finally {
-    if (privateRoot) await rm(privateRoot, { recursive: true, force: true });
-  }
-  const { saved, skipped, failed } = totals;
-  if (runId) {
-    try {
-      await archiveTools.archiveRun(job, { ...(archiveRoot ? { root: archiveRoot } : {}) });
-    } catch (error) { stderr.write(`veo: Could not archive run ${runId}: ${readableError(error)}\n`); }
-    stderr.write(`Run ID: ${runId}\n`);
-  }
-  const unfinished = job.items.some(item => !['saved', 'skipped'].includes(item.status));
-  const downloadCount = job.items.reduce((count, item) => count + Math.max(1, item.entries?.length || 0), 0);
-  if (downloadCount > 1) stderr.write(styleText(stderr, `Summary: ${saved} saved, ${skipped} skipped, ${failed} failed${signal?.aborted ? ', cancelled' : ''}.`, unfinished ? 'error' : 'success', options.color !== false && !options.json) + '\n');
-  if (options.timings !== false) {
-    const totals = {};
-    for (const item of job.items) for (const timings of [item.timings, ...(item.entryTimings || []).map(entry => entry.timings)]) {
-      if (!timings) continue;
-      for (const [phase, ms] of Object.entries(timings)) totals[phase] = (totals[phase] || 0) + ms;
-    }
-    if (Object.keys(totals).length) stderr.write(styleText(stderr, formatTimings(totals), 'muted', options.color !== false && !options.json) + '\n');
-  }
-  if (unfinished && !options.incognito) stderr.write(`Retry failed/unfinished downloads: veo --retry-failed ${runId || `"${file}"`}\n`);
-  if (unfinished) reporter.fail(Boolean(signal?.aborted)); else reporter.complete();
-  return signal?.aborted ? 130 : unfinished ? 1 : 0;
-}

package/src/legacy-config-comments.js

@@ -1,106 +0,0 @@
-// Compatibility data for comments generated by the former German template.
-// These strings are recognized during migration, never emitted as new UI text.
-const translations = new Map([
-  [
-    "// veo: kommentierte Konfigurationsvorlage",
-    "// veo: commented configuration template"
-  ],
-  [
-    "// Speichern und den Editor schliessen. Beim naechsten Aufruf gelten die Einstellungen.",
-    "// Save and close the editor. Settings apply the next time you run veo."
-  ],
-  [
-    "// Kommentare mit // oder /* ... */ sind erlaubt. CLI-Optionen haben Vorrang.",
-    "// Comments using // or /* ... */ are supported. Command-line options take priority."
-  ],
-  [
-    "// Option aktivieren: die beiden // davor entfernen und den Wert anpassen.",
-    "// To enable an option, remove its leading // and adjust the value."
-  ],
-  [
-    "// Zwischen aktiven Eintraegen steht ein Komma, nach dem letzten keines.",
-    "// Separate active entries with commas. Do not add a comma after the last entry."
-  ],
-  [
-    "// Zielordner: / oder doppelte Backslashes verwenden, z.B. \"D:\\\\Videos\".",
-    "// Output directory: use / or double backslashes, for example \"D:\\\\Videos\"."
-  ],
-  [
-    "// Ohne output wird im aktuellen Arbeitsordner gespeichert.",
-    "// Without output, downloads are saved in the current working directory."
-  ],
-  [
-    "// Maximale Videoaufloesung: best, 2160p, 1440p, 1080p, 720p, ...",
-    "// Maximum video resolution: best, 2160p, 1440p, 1080p, 720p, ..."
-  ],
-  [
-    "// Videoformat: mp4, mkv, webm, mov. Konvertierung kann Zeit brauchen.",
-    "// Video format: mp4, mkv, webm, mov. Conversion can take time."
-  ],
-  [
-    "// \"open\": false,              // Fertige Datei automatisch oeffnen",
-    "// \"open\": false,              // Open the completed file automatically"
-  ],
-  [
-    "// \"resume\": true,             // Abgebrochene Downloads fortsetzen",
-    "// \"resume\": true,             // Resume interrupted downloads"
-  ],
-  [
-    "// \"skipExisting\": true,       // Bereits gespeicherte Downloads ueberspringen",
-    "// \"skipExisting\": true,       // Skip previously saved downloads"
-  ],
-  [
-    "// \"concurrentFragments\": 4,   // Gleichzeitige Fragmente: 1 bis 16",
-    "// \"concurrentFragments\": 4,   // Concurrent fragments: 1 to 16"
-  ],
-  [
-    "// Untertitel und Zusatzinformationen:",
-    "// Subtitles and additional information:"
-  ],
-  [
-    "// \"subLangs\": \"de,en\",        // Aktiviert Untertitel fuer diese Sprachen",
-    "// \"subLangs\": \"de,en\",        // Enable subtitles for these languages"
-  ],
-  [
-    "// \"embedSubs\": true,          // Untertitel ins Video einbetten",
-    "// \"embedSubs\": true,          // Embed subtitles in the video"
-  ],
-  [
-    "// \"embedMetadata\": true,      // Titel, Datum usw. einbetten",
-    "// \"embedMetadata\": true,      // Embed the title, date and other metadata"
-  ],
-  [
-    "// \"embedThumbnail\": true,     // Vorschaubild einbetten",
-    "// \"embedThumbnail\": true,     // Embed the thumbnail"
-  ],
-  [
-    "// Profile werden nur mit --profile NAME oder im interaktiven Dialog aktiviert.",
-    "// Profiles are activated only with --profile NAME or in the interactive wizard."
-  ],
-  [
-    "// Beispiel: veo \"https://example.com/video.mp4\" --profile musik",
-    "// Example: veo \"https://example.com/video.mp4\" --profile music"
-  ],
-  [
-    "// Nur Audio. Formate: mp3, m4a, aac, opus, flac, wav.",
-    "// Audio only. Formats: mp3, m4a, aac, opus, flac, wav."
-  ],
-  [
-    "// Referenz: Beispiele bei Bedarf in die bestehende Konfiguration unten uebernehmen.",
-    "// Reference: copy any examples you need into your existing configuration below."
-  ],
-  [
-    "// Deine bestehenden Einstellungen:",
-    "// Your existing settings:"
-  ]
-]);
-
-export function translateLegacyConfigComments(text) {
-  if (!text.replace(/^\uFEFF/, '').startsWith('// veo: kommentierte Konfigurationsvorlage')) return text;
-  return text.replace(/^([ \t]*(?:\/\/[ \t]*)?)(\/\/[^\r\n]*)/gm, (line, prefix, comment) => {
-    const translated = translations.get(comment);
-    if (translated) return prefix + translated.replace('--profile music', '--profile NAME');
-    // Profile names in the commented reference are examples, not active settings.
-    return prefix + comment.replace(/^(\/\/[ \t]*")musik("\s*:)/, '$1music$2').replace(/^(\/\/[ \t]*")archiv("\s*:)/, '$1archive$2');
-  });
-}