bytecut 0.0.0-stage → 0.1.0

package/dist/chunk-3DBJKHOD.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+// src/core/video/codecs.ts
+import { open } from "fs/promises";
+function* boxes(buf, start, end) {
+  let at = start;
+  while (at + 8 <= end) {
+    let size = buf.readUInt32BE(at);
+    const type = buf.toString("latin1", at + 4, at + 8);
+    let header = 8;
+    if (size === 1) {
+      if (at + 16 > end) return;
+      size = Number(buf.readBigUInt64BE(at + 8));
+      header = 16;
+    } else if (size === 0) {
+      size = end - at;
+    }
+    if (size < header || at + size > end) return;
+    yield { type, start: at + header, end: at + size };
+    at += size;
+  }
+}
+function find(buf, parent, type) {
+  for (const box of boxes(buf, parent.start, parent.end)) if (box.type === type) return box;
+  return void 0;
+}
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+function avcCodecString(avcC) {
+  if (avcC.length < 4) return null;
+  return `avc1.${hex2(avcC[1])}${hex2(avcC[2])}${hex2(avcC[3])}`;
+}
+function av1CodecString(av1C) {
+  if (av1C.length < 4 || (av1C[0] & 128) === 0) return null;
+  const profile = av1C[1] >> 5;
+  const level = av1C[1] & 31;
+  const tier = av1C[2] >> 7 & 1;
+  const highBitdepth = av1C[2] >> 6 & 1;
+  const twelveBit = av1C[2] >> 5 & 1;
+  const depth = highBitdepth ? twelveBit ? 12 : 10 : 8;
+  return `av01.${profile}.${String(level).padStart(2, "0")}${tier ? "H" : "M"}.${String(depth).padStart(2, "0")}`;
+}
+async function readVideoCodecString(path) {
+  const file = await open(path, "r");
+  try {
+    const { size } = await file.stat();
+    const header = Buffer.alloc(16);
+    let offset = 0;
+    for (let guard = 0; guard < 64 && offset + 8 <= size; guard++) {
+      const { bytesRead } = await file.read(header, 0, 16, offset);
+      if (bytesRead < 8) return null;
+      let boxSize = header.readUInt32BE(0);
+      const type = header.toString("latin1", 4, 8);
+      let headerSize = 8;
+      if (boxSize === 1) {
+        if (bytesRead < 16) return null;
+        boxSize = Number(header.readBigUInt64BE(8));
+        headerSize = 16;
+      } else if (boxSize === 0) {
+        boxSize = size - offset;
+      }
+      if (boxSize < headerSize) return null;
+      if (type === "moov") {
+        const payload = Buffer.alloc(boxSize - headerSize);
+        await file.read(payload, 0, payload.length, offset + headerSize);
+        return codecFromMoov(payload);
+      }
+      offset += boxSize;
+    }
+    return null;
+  } finally {
+    await file.close();
+  }
+}
+function codecFromMoov(moov) {
+  const root = { start: 0, end: moov.length };
+  for (const trak of boxes(moov, root.start, root.end)) {
+    if (trak.type !== "trak") continue;
+    const mdia = find(moov, trak, "mdia");
+    if (!mdia) continue;
+    const hdlr = find(moov, mdia, "hdlr");
+    if (!hdlr || moov.toString("latin1", hdlr.start + 8, hdlr.start + 12) !== "vide") continue;
+    const minf = find(moov, mdia, "minf");
+    const stbl = minf && find(moov, minf, "stbl");
+    const stsd = stbl && find(moov, stbl, "stsd");
+    if (!stsd) continue;
+    for (const entry of boxes(moov, stsd.start + 8, stsd.end)) {
+      const childStart = entry.start + 78;
+      if (entry.type === "avc1" || entry.type === "avc3") {
+        const avcC = find(moov, { start: childStart, end: entry.end }, "avcC");
+        if (avcC) return avcCodecString(moov.subarray(avcC.start, avcC.end));
+      }
+      if (entry.type === "av01") {
+        const av1C = find(moov, { start: childStart, end: entry.end }, "av1C");
+        if (av1C) return av1CodecString(moov.subarray(av1C.start, av1C.end));
+      }
+    }
+  }
+  return null;
+}
+function fallbackAv1CodecString(width, height) {
+  const pixels = width * height;
+  const level = pixels <= 147456 ? 0 : pixels <= 278784 ? 1 : pixels <= 665856 ? 4 : pixels <= 1065024 ? 5 : pixels <= 2359296 ? 8 : pixels <= 8912896 ? 12 : 16;
+  return `av01.0.${String(level).padStart(2, "0")}M.08`;
+}
+
+export {
+  readVideoCodecString,
+  fallbackAv1CodecString
+};

package/dist/chunk-3PF6BBFK.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+import {
+  BytecutError,
+  detectProject,
+  hint,
+  matchesGlob
+} from "./chunk-FY53B4NB.js";
+
+// src/core/presets/photo.ts
+var OTHER_ENCODERS = {
+  // PNG has no quality; `effort` is libpng's/oxipng-style effort (1–10).
+  png: { quality: 100, effort: 7 }
+};
+var PHOTO_PRESET = {
+  name: "photo",
+  widths: [],
+  maxEdge: 1920,
+  formats: ["jpg"],
+  encoders: {
+    ...OTHER_ENCODERS,
+    jpg: { quality: 80, effort: 0 },
+    avif: { quality: 60, effort: 4 },
+    webp: { quality: 78, effort: 4 }
+  }
+};
+
+// src/core/presets/hero.ts
+var HERO_PRESET = {
+  name: "hero",
+  widths: [],
+  maxEdge: 1920,
+  formats: ["jpg"],
+  encoders: {
+    ...OTHER_ENCODERS,
+    jpg: { quality: 85, effort: 0 },
+    avif: { quality: 65, effort: 4 },
+    webp: { quality: 82, effort: 4 }
+  },
+  priority: true
+};
+
+// src/core/presets/icon.ts
+var ICON_PRESET = {
+  name: "icon",
+  widths: [64, 128, 256, 512],
+  formats: ["png"],
+  encoders: {
+    ...OTHER_ENCODERS,
+    jpg: { quality: 90, effort: 0 },
+    avif: { quality: 80, effort: 4 },
+    webp: { quality: 90, effort: 4 }
+  },
+  lossless: true
+};
+
+// src/core/presets/index.ts
+var IMAGE_PRESETS = {
+  photo: PHOTO_PRESET,
+  hero: HERO_PRESET,
+  icon: ICON_PRESET
+};
+function getImagePreset(name, catalog) {
+  const presets = catalog?.image ?? IMAGE_PRESETS;
+  const preset = presets[name];
+  if (!preset) {
+    throw new BytecutError(
+      "BAD_ARGUMENTS",
+      `Unknown preset "${name}". Image presets: ${Object.keys(presets).join(", ")}.`
+    );
+  }
+  return preset;
+}
+
+// src/core/presets/video.ts
+var POSTER = { quality: 55, effort: 4, at: 0.1 };
+var BACKGROUND_VIDEO_PRESET = {
+  name: "background-video",
+  codecs: ["av1", "h264"],
+  audio: "strip",
+  audioBitrate: "96k",
+  maxWidth: 1920,
+  maxFps: 30,
+  crf: { av1: 38, h264: 28 },
+  speed: { av1: "6", h264: "slow" },
+  poster: POSTER
+};
+var CONTENT_VIDEO_PRESET = {
+  name: "content-video",
+  codecs: ["av1", "h264"],
+  audio: "keep",
+  audioBitrate: "128k",
+  maxWidth: null,
+  maxFps: null,
+  crf: { av1: 32, h264: 23 },
+  speed: { av1: "6", h264: "slow" },
+  poster: POSTER
+};
+var GIF_TO_VIDEO_PRESET = {
+  name: "gif-to-video",
+  codecs: ["av1", "h264"],
+  audio: "strip",
+  audioBitrate: "96k",
+  maxWidth: 1920,
+  maxFps: null,
+  crf: { av1: 36, h264: 26 },
+  speed: { av1: "6", h264: "slow" },
+  poster: POSTER
+};
+var VIDEO_PRESETS = {
+  "background-video": BACKGROUND_VIDEO_PRESET,
+  "content-video": CONTENT_VIDEO_PRESET,
+  "gif-to-video": GIF_TO_VIDEO_PRESET
+};
+function getVideoPreset(name, catalog) {
+  return (catalog?.video ?? VIDEO_PRESETS)[name];
+}
+
+// src/core/presets/catalog.ts
+var BUILTIN_CATALOG = {
+  image: IMAGE_PRESETS,
+  video: VIDEO_PRESETS,
+  root: Object.fromEntries(
+    [...Object.keys(IMAGE_PRESETS), ...Object.keys(VIDEO_PRESETS)].map((n) => [n, n])
+  ),
+  origin: {}
+};
+function rootPreset(catalog, name) {
+  return catalog?.root[name] ?? name;
+}
+var BUILTIN_POLICY = {
+  catalog: BUILTIN_CATALOG,
+  assetFor: () => void 0
+};
+
+// src/core/config/presets.ts
+var IMAGE_TARGETS = {
+  low: { jpg: 65, avif: 45, webp: 65 },
+  balanced: { jpg: 80, avif: 60, webp: 78 },
+  high: { jpg: 90, avif: 75, webp: 88 }
+};
+var VIDEO_TARGET_CRF_OFFSET = { low: 4, balanced: 0, high: -4 };
+var IMAGE_ONLY = [
+  "widths",
+  "maxEdge",
+  "formats",
+  "quality",
+  "effort",
+  "lossless",
+  "priority",
+  "floor",
+  "maxSize"
+];
+var VIDEO_ONLY = ["audio", "maxWidth", "maxFps", "codecs", "crf"];
+var METRICS = ["ssimulacra2", "vmaf"];
+function fail(message) {
+  throw new BytecutError("CONFIG_INVALID", `presets: ${message}`);
+}
+function applyImage(name, base, def) {
+  for (const key of VIDEO_ONLY) {
+    if (def[key] !== void 0) {
+      fail(`"${name}" extends an image preset, so \`${key}\` (a video setting) does not apply.`);
+    }
+  }
+  if (def.vmaf !== void 0) {
+    fail(`"${name}" extends an image preset, so \`vmaf\` (a video metric) does not apply.`);
+  }
+  const next = {
+    ...base,
+    name,
+    widths: [...base.widths],
+    formats: [...base.formats],
+    encoders: {
+      jpg: { ...base.encoders.jpg },
+      png: { ...base.encoders.png },
+      avif: { ...base.encoders.avif },
+      webp: { ...base.encoders.webp }
+    }
+  };
+  if (def.target === "lossless") next.lossless = true;
+  else if (def.target) {
+    next.encoders.jpg.quality = IMAGE_TARGETS[def.target].jpg;
+    next.encoders.avif.quality = IMAGE_TARGETS[def.target].avif;
+    next.encoders.webp.quality = IMAGE_TARGETS[def.target].webp;
+  }
+  if (def.widths) {
+    next.widths = [...new Set(def.widths)].sort((a, b) => a - b);
+    delete next.maxEdge;
+  }
+  if (def.maxEdge !== void 0) {
+    next.maxEdge = def.maxEdge;
+    next.widths = [];
+  }
+  if (def.formats) next.formats = [...new Set(def.formats)];
+  if (def.quality?.jpg !== void 0) next.encoders.jpg.quality = def.quality.jpg;
+  if (def.quality?.avif !== void 0) next.encoders.avif.quality = def.quality.avif;
+  if (def.quality?.webp !== void 0) next.encoders.webp.quality = def.quality.webp;
+  if (def.effort?.avif !== void 0) next.encoders.avif.effort = def.effort.avif;
+  if (def.effort?.webp !== void 0) next.encoders.webp.effort = def.effort.webp;
+  if (def.lossless !== void 0) next.lossless = def.lossless;
+  if (def.priority !== void 0) next.priority = def.priority;
+  if (def.ssimulacra2 !== void 0) {
+    next.search = {
+      metric: "ssimulacra2",
+      target: def.ssimulacra2,
+      ...def.floor !== void 0 ? { floor: def.floor } : {},
+      ...def.maxSize !== void 0 ? { maxBytes: def.maxSize } : {}
+    };
+  }
+  return next;
+}
+function applyVideo(name, base, def) {
+  for (const key of IMAGE_ONLY) {
+    if (def[key] !== void 0) {
+      fail(`"${name}" extends a video preset, so \`${key}\` (an image setting) does not apply.`);
+    }
+  }
+  if (def.target === "lossless") {
+    fail(`"${name}": \`target: "lossless"\` is not available for video; use "high".`);
+  }
+  const next = {
+    ...base,
+    name,
+    codecs: [...base.codecs],
+    crf: { ...base.crf },
+    speed: { ...base.speed },
+    poster: { ...base.poster }
+  };
+  if (def.target) {
+    const offset = VIDEO_TARGET_CRF_OFFSET[def.target];
+    next.crf = { av1: base.crf.av1 + offset, h264: base.crf.h264 + offset };
+  }
+  if (def.crf?.av1 !== void 0) next.crf.av1 = def.crf.av1;
+  if (def.crf?.h264 !== void 0) next.crf.h264 = def.crf.h264;
+  if (def.codecs) next.codecs = [...new Set(def.codecs)];
+  if (def.audio) next.audio = def.audio;
+  if (def.maxWidth !== void 0) next.maxWidth = def.maxWidth;
+  if (def.maxFps !== void 0) next.maxFps = def.maxFps;
+  if (def.ssimulacra2 !== void 0)
+    next.search = { metric: "ssimulacra2", target: def.ssimulacra2 };
+  if (def.vmaf !== void 0) next.search = { metric: "vmaf", target: def.vmaf };
+  return next;
+}
+var CHANGE_KEYS = [...IMAGE_ONLY, ...VIDEO_ONLY, ...METRICS, "target"];
+function buildCatalog(defs) {
+  const image = { ...BUILTIN_CATALOG.image };
+  const video = { ...BUILTIN_CATALOG.video };
+  const root = { ...BUILTIN_CATALOG.root };
+  const origin = {};
+  if (!defs) return { image, video, root, origin };
+  const builtinNames = new Set(Object.keys(BUILTIN_CATALOG.root));
+  const done = /* @__PURE__ */ new Set();
+  function resolve(name, stack) {
+    if (done.has(name)) return;
+    const def = defs[name];
+    if (!def) return;
+    if (stack.includes(name)) fail(`extends cycle: ${[...stack, name].join(" \u2192 ")}.`);
+    const parent = def.extends ?? (builtinNames.has(name) ? name : void 0);
+    if (parent === void 0) {
+      fail(
+        `"${name}" must say what it extends, e.g. { "extends": "photo" }. Built-ins: ${[...builtinNames].join(", ")}.`
+      );
+    }
+    if (parent === "svg") fail(`"${name}" extends "svg", which has no output yet.`);
+    if (parent === name) {
+      if (!builtinNames.has(name)) fail(`"${name}" extends itself.`);
+    } else if (defs[parent]) {
+      resolve(parent, [...stack, name]);
+    } else if (!builtinNames.has(parent)) {
+      const known = [...builtinNames, ...Object.keys(defs)];
+      fail(`"${name}" extends unknown preset "${parent}"${hint(parent, known)}.`);
+    }
+    const baseName = parent === name ? name : parent;
+    const chain = [];
+    if (parent === name) chain.push(name);
+    else chain.push(...origin[parent]?.chain ?? [parent], name);
+    if (image[baseName]) {
+      image[name] = applyImage(name, image[baseName], def);
+    } else if (video[baseName]) {
+      video[name] = applyVideo(name, video[baseName], def);
+    } else {
+      fail(`"${name}" extends "${baseName}", which is not an image or video preset.`);
+    }
+    root[name] = parent === name ? name : root[parent] ?? parent;
+    origin[name] = {
+      chain,
+      overrides: CHANGE_KEYS.filter((key) => def[key] !== void 0)
+    };
+    done.add(name);
+  }
+  for (const name of Object.keys(defs)) resolve(name, []);
+  return { image, video, root, origin };
+}
+
+// src/core/config/resolve.ts
+function resolveConfigData(config, project, loaded) {
+  const name = loaded?.name ?? "config";
+  const catalog = buildCatalog(config.presets);
+  const assets = Object.entries(config.assets ?? {}).map(([pattern, preset]) => ({
+    pattern,
+    preset
+  }));
+  for (const { pattern, preset } of assets) {
+    if (!catalog.image[preset] && !catalog.video[preset]) {
+      const known = [...Object.keys(catalog.image), ...Object.keys(catalog.video)];
+      throw new BytecutError(
+        "CONFIG_INVALID",
+        `${name}: assets["${pattern}"]: unknown preset "${preset}"${hint(preset, known)}. Known presets: ${known.join(", ")}.`
+      );
+    }
+  }
+  const rules = {};
+  for (const [id, setting] of Object.entries(config.audit?.rules ?? {})) {
+    rules[id] = setting;
+  }
+  const budgets = {};
+  if (config.budgets?.maxFileSize !== void 0) budgets.maxFileBytes = config.budgets.maxFileSize;
+  if (config.budgets?.maxTotalSize !== void 0)
+    budgets.maxTotalBytes = config.budgets.maxTotalSize;
+  return {
+    loaded,
+    project: {
+      ...project,
+      ...config.include ? { include: config.include } : {},
+      ...config.outDir ? { outDir: config.outDir } : {},
+      ...config.publicPath ? { publicPath: config.publicPath } : {}
+    },
+    provenance: {
+      framework: config.framework ? "config" : "detected",
+      include: config.include ? "config" : "detected",
+      outDir: config.outDir ? "config" : "detected",
+      publicPath: config.publicPath ? "config" : "detected"
+    },
+    exclude: config.exclude ?? [],
+    catalog,
+    policy: {
+      catalog,
+      assetFor: (source) => assets.find((rule) => matchesGlob(rule.pattern, source))
+    },
+    assets,
+    rules,
+    auditIgnore: config.audit?.ignore ?? [],
+    budgets,
+    placeholder: config.manifest?.placeholder,
+    concurrency: config.concurrency,
+    ffmpegPath: config.ffmpegPath,
+    ffprobePath: config.ffprobePath,
+    ssimulacra2Path: config.ssimulacra2Path
+  };
+}
+async function resolveConfig(projectRoot, loaded) {
+  const framework = loaded?.config.framework;
+  const project = await detectProject(projectRoot, { framework });
+  return resolveConfigData(loaded?.config ?? {}, project, loaded);
+}
+
+// src/core/ffmpeg/resolve.ts
+import { delimiter, dirname, join } from "path";
+var ENV_VAR = {
+  ffmpeg: "BYTECUT_FFMPEG",
+  ffprobe: "BYTECUT_FFPROBE",
+  ssimulacra2: "BYTECUT_SSIMULACRA2"
+};
+function executableNames(name, platform, env) {
+  if (platform !== "win32") return [name];
+  const exts = (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean);
+  return [name, ...exts.map((ext) => name + ext.toLowerCase())];
+}
+function resolveBinary(name, options, deps) {
+  const explicit = [
+    ["flag", options.flag],
+    ["env", options.env[ENV_VAR[name]]],
+    ["config", options.config]
+  ];
+  for (const [source, value] of explicit) {
+    if (value === void 0 || value === "") continue;
+    return deps.isFile(value) ? { found: true, path: value, source } : { found: false, source, attempted: value };
+  }
+  const names = executableNames(name, options.platform, options.env);
+  if (name === "ffprobe" && options.ffmpegDir) {
+    for (const candidate of names) {
+      const path = join(options.ffmpegDir, candidate);
+      if (deps.isFile(path)) return { found: true, path, source: "ffmpeg-dir" };
+    }
+  }
+  const dirs = (options.env.PATH ?? "").split(delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const candidate of names) {
+      const path = join(dir, candidate);
+      if (deps.isFile(path)) return { found: true, path, source: "path" };
+    }
+  }
+  return { found: false, source: null };
+}
+function ffmpegDirOf(resolved) {
+  return resolved.found ? dirname(resolved.path) : void 0;
+}
+
+// src/core/ffmpeg/capabilities.ts
+function parseVersion(output) {
+  const match = /^\w+ version (\S+)/m.exec(output);
+  return match?.[1] ?? null;
+}
+function parseListing(output, kind) {
+  const entry = kind === "encoders" ? /^\s*[VAS][A-Z.]{5}\s+(\S+)/ : /^\s*[T.][S.][C.]\s+(\S+)/;
+  const names = /* @__PURE__ */ new Set();
+  for (const line of output.split(/\r?\n/)) {
+    const name = entry.exec(line)?.[1];
+    if (name && name !== "=") names.add(name);
+  }
+  return names;
+}
+function toCapabilities(encoders, filters) {
+  return {
+    libsvtav1: encoders.has("libsvtav1"),
+    libaomAv1: encoders.has("libaom-av1"),
+    libx264: encoders.has("libx264"),
+    libvpxVp9: encoders.has("libvpx-vp9"),
+    libvmaf: filters.has("libvmaf")
+  };
+}
+function pickAv1Encoder(caps) {
+  if (caps.libsvtav1) return "libsvtav1";
+  if (caps.libaomAv1) return "libaom-av1";
+  return null;
+}
+async function probeFfmpeg(path, run, cache = /* @__PURE__ */ new Map()) {
+  const { stdout } = await run(path, ["-hide_banner", "-version"]);
+  const version = parseVersion(stdout) ?? "unknown";
+  const key = `${path}\0${version}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const [encoders, filters] = await Promise.all([
+    run(path, ["-hide_banner", "-encoders"]),
+    run(path, ["-hide_banner", "-filters"])
+  ]);
+  const info = {
+    path,
+    version,
+    capabilities: toCapabilities(
+      parseListing(encoders.stdout, "encoders"),
+      parseListing(filters.stdout, "filters")
+    )
+  };
+  cache.set(key, info);
+  return info;
+}
+async function probeFfprobeVersion(path, run) {
+  const { stdout } = await run(path, ["-hide_banner", "-version"]);
+  return parseVersion(stdout) ?? "unknown";
+}
+
+// src/core/ffmpeg/install-hint.ts
+function installHint(platform, osReleaseId) {
+  switch (platform) {
+    case "darwin":
+      return "brew install ffmpeg";
+    case "win32":
+      return "winget install ffmpeg";
+    default:
+      switch (osReleaseId) {
+        case "fedora":
+        case "rhel":
+        case "centos":
+          return "sudo dnf install ffmpeg";
+        case "arch":
+        case "manjaro":
+          return "sudo pacman -S ffmpeg";
+        case "alpine":
+          return "sudo apk add ffmpeg";
+        default:
+          return "sudo apt install ffmpeg";
+      }
+  }
+}
+
+export {
+  IMAGE_PRESETS,
+  getImagePreset,
+  getVideoPreset,
+  rootPreset,
+  BUILTIN_POLICY,
+  resolveBinary,
+  ffmpegDirOf,
+  pickAv1Encoder,
+  probeFfmpeg,
+  probeFfprobeVersion,
+  installHint,
+  resolveConfigData,
+  resolveConfig
+};

package/dist/chunk-4FIB6VNC.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import {
+  escapeGlob
+} from "./chunk-FY53B4NB.js";
+
+// src/core/config/choices.ts
+import { stringify as stringifyToml } from "smol-toml";
+function isEmpty(choices) {
+  return choices.outDir === void 0 && choices.publicPath === void 0 && choices.placeholder === void 0 && Object.keys(choices.presets ?? {}).length === 0;
+}
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function applyChoices(existing, choices) {
+  const next = isObject(existing) ? { ...existing } : {};
+  if (choices.outDir !== void 0) next.outDir = choices.outDir;
+  if (choices.publicPath !== void 0) next.publicPath = choices.publicPath;
+  if (choices.placeholder !== void 0) {
+    next.manifest = {
+      ...isObject(next.manifest) ? next.manifest : {},
+      placeholder: choices.placeholder
+    };
+  }
+  const presets = choices.presets ?? {};
+  if (Object.keys(presets).length > 0) {
+    const mine = Object.fromEntries(
+      Object.entries(presets).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([source, preset]) => [escapeGlob(source), preset])
+    );
+    const others = Object.entries(isObject(next.assets) ? next.assets : {}).filter(
+      ([pattern]) => !(pattern in mine)
+    );
+    next.assets = { ...mine, ...Object.fromEntries(others) };
+  }
+  return next;
+}
+function canRewrite(format) {
+  return format === "json";
+}
+function renderConfig(format, data) {
+  if (format === "json") return `${JSON.stringify(data, null, 2)}
+`;
+  if (format === "toml") return `${stringifyToml(data)}
+`;
+  return `export default ${JSON.stringify(data, null, 2)};
+`;
+}
+function renderChoicesSnippet(format, choices) {
+  const fragment = applyChoices({}, choices);
+  return renderConfig(
+    format === "toml" ? "toml" : format === "json" ? "json" : "ts",
+    fragment
+  ).trimEnd();
+}
+
+export {
+  isEmpty,
+  applyChoices,
+  canRewrite,
+  renderConfig,
+  renderChoicesSnippet
+};