@bylqwjc/media-editor-react 1.0.12

package/node_modules/@media-editor/core/dist/index.js

@@ -0,0 +1,682 @@
+import { findFilterPreset, normalizeDeg, outputSize } from './chunk-USY6UDGL.js';
+export { DEG2RAD, FILTER_PRESETS, buildFilterCss, centeredMaxRect, clampRect, evenize, findFilterPreset, fitRects, normalizeDeg, outputSize, rotatedSize } from './chunk-USY6UDGL.js';
+export { AudioClip, Clip, MIN_CLIP, Overlay, VideoEditState, canRedo, canUndo, clampAudioClip, clipDuration, clipStartsAt, contentDuration, createHistory, defaultVideoEditState, duplicateClip, locateOutput, pushHistory, redo, remapSrcIndices, removeClip, reorderClips, replacePresent, splitAtOutput, totalDuration, trimClipEdge, undo, usedVideoSrcIndices } from './chunk-MGKYVYOH.js';
+export { DEFAULT_PLATFORM_TARGETS, EDITOR_MESSAGES, IMAGE_PLATFORM_PRESETS, IMAGE_RATIO_PRESETS, VIDEO_PLATFORM_RATIO_PRESETS, VIDEO_RATIO_PRESETS, VIDEO_SIZE_PRESETS, buildImagePlatformPresets, buildVideoPlatformRatioPresets, buildVideoSizePresets, compensateAnnotationRotation, parseRatio, tEditor, toHant } from './chunk-XCBM7P7N.js';
+
+// src/ffmpeg-args.ts
+function rotationFilters(deg) {
+  const norm = normalizeDeg(deg);
+  if (norm === 0) return [];
+  if (norm === 90) return ["transpose=1"];
+  if (norm === 180) return ["transpose=1", "transpose=1"];
+  if (norm === 270) return ["transpose=2"];
+  const rad = `${norm}*PI/180`;
+  return [`rotate=${rad}:ow=rotw(${rad}):oh=roth(${rad}):c=black`];
+}
+function clampFilterAdjustment(value) {
+  return Math.max(-1, Math.min(1, Number(value) || 0));
+}
+function clampFilterUnit(value) {
+  return Math.max(0, Math.min(1, Number(value) || 0));
+}
+function clampExportNumber(value, min, max, fallback) {
+  const next = Math.round(Number(value));
+  if (!Number.isFinite(next)) return fallback;
+  return Math.min(max, Math.max(min, next));
+}
+function clampAudioSpeed(value) {
+  return Math.min(Math.max(Number(value) || 1, 0.5), 2);
+}
+function buildAudioTempoFilters(speed) {
+  const filters = [];
+  let next = clampAudioSpeed(speed);
+  while (next < 0.5 - 1e-6 || next > 2 + 1e-6) {
+    if (next < 0.5) {
+      filters.push("atempo=0.5");
+      next /= 0.5;
+    } else {
+      filters.push("atempo=2");
+      next /= 2;
+    }
+  }
+  if (Math.abs(next - 1) > 1e-4) {
+    filters.push(`atempo=${next.toFixed(4).replace(/0+$/, "").replace(/\.$/, "")}`);
+  }
+  return filters;
+}
+function evenizeExportDimension(value, fallback) {
+  const normalized = clampExportNumber(value, 2, 8192, fallback);
+  return normalized % 2 === 0 ? normalized : normalized - 1;
+}
+function getExportSettings(state) {
+  return state?.exportSettings ?? null;
+}
+function getExportFormat(state) {
+  const value = String(getExportSettings(state)?.format ?? "mp4").toLowerCase();
+  return value === "mov" || value === "mxf" ? value : "mp4";
+}
+function getExportFrameRate(state) {
+  return clampExportNumber(getExportSettings(state)?.frameRate, 12, 120, 30);
+}
+function getExportOutputSize(state) {
+  const base = outputSize(state.canvas, state);
+  const settings = getExportSettings(state);
+  if (!settings) return base;
+  const hasWidth = Number.isFinite(Number(settings.width)) && Number(settings.width) > 0;
+  const hasHeight = Number.isFinite(Number(settings.height)) && Number(settings.height) > 0;
+  if (!hasWidth && !hasHeight) return base;
+  const aspect = base.w > 0 && base.h > 0 ? base.w / base.h : 1;
+  if (hasWidth && hasHeight) {
+    return {
+      w: evenizeExportDimension(settings.width, base.w),
+      h: evenizeExportDimension(settings.height, base.h)
+    };
+  }
+  if (hasWidth) {
+    const width = evenizeExportDimension(settings.width, base.w);
+    return {
+      w: width,
+      h: evenizeExportDimension(width / aspect, base.h)
+    };
+  }
+  const height = evenizeExportDimension(settings.height, base.h);
+  return {
+    w: evenizeExportDimension(height * aspect, base.w),
+    h: height
+  };
+}
+function getExportVideoBitrateKbps(state) {
+  const value = Number(getExportSettings(state)?.videoBitrateKbps);
+  return Number.isFinite(value) && value >= 100 ? Math.round(value) : 0;
+}
+function getExportAudioBitrateKbps(state) {
+  const value = Number(getExportSettings(state)?.audioBitrateKbps);
+  return Number.isFinite(value) && value >= 32 ? Math.round(value) : 0;
+}
+function getExportAudioCodec(state) {
+  return getExportSettings(state)?.audioCodec === "mp3" ? "libmp3lame" : "aac";
+}
+function getProjectOutputSize(state) {
+  return outputSize(state.canvas, state);
+}
+function buildExportScaleFilters(state) {
+  const baseOutput = getProjectOutputSize(state);
+  const exportOutput = getExportOutputSize(state);
+  if (exportOutput.w === baseOutput.w && exportOutput.h === baseOutput.h) return [];
+  return [`scale=${exportOutput.w}:${exportOutput.h}`];
+}
+function eqFilter(f) {
+  const brightness = clampFilterAdjustment(f?.brightness);
+  const contrast = clampFilterAdjustment(f?.contrast);
+  const saturation = clampFilterAdjustment(f?.saturation);
+  const gamma = clampFilterAdjustment(f?.gamma);
+  if (brightness === 0 && contrast === 0 && saturation === 0 && gamma === 0) return null;
+  const filters = [];
+  if (brightness !== 0 || contrast !== 0) {
+    const brightnessFactor = formatFilterNumber(Math.max(0, 1 + brightness));
+    const contrastFactor = formatFilterNumber(Math.max(0, 1 + contrast));
+    const rgbExpr = `clip(((val*${brightnessFactor})-128)*${contrastFactor}+128,0,255)`;
+    filters.push(`lutrgb=r='${rgbExpr}':g='${rgbExpr}':b='${rgbExpr}'`);
+  }
+  const eqParts = [];
+  if (saturation !== 0) eqParts.push(`saturation=${1 + saturation}`);
+  if (gamma !== 0) eqParts.push(`gamma=${(1 + gamma * (gamma > 0 ? 1 : 0.5)).toFixed(3)}`);
+  if (eqParts.length) filters.push(`eq=${eqParts.join(":")}`);
+  return filters.join(",");
+}
+function formatFilterNumber(value) {
+  return `${Math.round(value * 1e3) / 1e3}`;
+}
+function colorBalanceFilter(f) {
+  const temperature = clampFilterAdjustment(f?.temperature);
+  const tint = clampFilterAdjustment(f?.tint);
+  if (temperature === 0 && tint === 0) return null;
+  const rs = clampFilterAdjustment(temperature * 0.18 + tint * 0.08);
+  const gs = clampFilterAdjustment(temperature * 0.02 - tint * 0.12);
+  const bs = clampFilterAdjustment(-temperature * 0.18 + tint * 0.08);
+  return `colorbalance=rs=${formatFilterNumber(rs)}:gs=${formatFilterNumber(gs)}:bs=${formatFilterNumber(bs)}`;
+}
+function vibranceFilter(f) {
+  const vibrance = clampFilterAdjustment(f?.vibrance);
+  if (vibrance === 0) return null;
+  return `vibrance=intensity=${formatFilterNumber(vibrance)}`;
+}
+function smoothstep(edge0, edge1, value) {
+  if (edge0 === edge1) return value < edge0 ? 0 : 1;
+  const t = Math.max(0, Math.min(1, (value - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+}
+function midtoneWeight(value) {
+  const rise = smoothstep(0.08, 0.4, value);
+  const fall = 1 - smoothstep(0.6, 0.92, value);
+  return Math.max(0, Math.min(1, rise * fall * 2.2));
+}
+function toneCurveSample(value, adjustments) {
+  const shadowWeight = 1 - smoothstep(0.18, 0.62, value);
+  const blackWeight = 1 - smoothstep(0.04, 0.32, value);
+  const highlightWeight = smoothstep(0.38, 0.84, value);
+  const whiteWeight = smoothstep(0.7, 0.98, value);
+  const midWeight = midtoneWeight(value);
+  const delta = adjustments.shadows * shadowWeight * 0.28 + adjustments.highlights * highlightWeight * 0.24 + adjustments.blacks * blackWeight * 0.2 + adjustments.whites * whiteWeight * 0.2 + adjustments.lightSense * midWeight * 0.18 + adjustments.fade * (0.12 + shadowWeight * 0.06);
+  return Math.max(0, Math.min(1, value + delta));
+}
+function toneCurveFilter(f) {
+  const adjustments = {
+    highlights: clampFilterAdjustment(f?.highlights),
+    shadows: clampFilterAdjustment(f?.shadows),
+    whites: clampFilterAdjustment(f?.whites),
+    blacks: clampFilterAdjustment(f?.blacks),
+    lightSense: clampFilterAdjustment(f?.lightSense),
+    fade: clampFilterUnit(f?.fade)
+  };
+  const hasToneAdjustments = Object.values(adjustments).some((value) => Math.abs(value) > 1e-4);
+  if (!hasToneAdjustments) return null;
+  const points = [0, 0.18, 0.36, 0.5, 0.68, 0.84, 1].map((point) => `${formatFilterNumber(point)}/${formatFilterNumber(toneCurveSample(point, adjustments))}`);
+  return `curves=master='${points.join(" ")}'`;
+}
+function detailFilters(f) {
+  const filters = [];
+  const clarity = clampFilterUnit(f?.clarity);
+  const sharpen = clampFilterUnit(f?.sharpen);
+  if (clarity > 1e-4) {
+    filters.push(`unsharp=lx=7:ly=7:la=${formatFilterNumber(clarity * 1.8)}:cx=7:cy=7:ca=0`);
+  }
+  if (sharpen > 1e-4) {
+    filters.push(`unsharp=lx=3:ly=3:la=${formatFilterNumber(0.35 + sharpen * 2.1)}:cx=3:cy=3:ca=${formatFilterNumber(sharpen * 0.55)}`);
+  }
+  return filters;
+}
+function grainFilter(f) {
+  const grain = clampFilterUnit(f?.grain);
+  if (grain <= 1e-4) return null;
+  return `noise=alls=${Math.round(6 + grain * 26)}:allf=t`;
+}
+function vignetteFilter(f) {
+  const vignette = clampFilterUnit(f?.vignette);
+  if (vignette <= 1e-4) return null;
+  const angle = Math.max(0.12, 0.42 - vignette * 0.22);
+  return `vignette=angle=${formatFilterNumber(angle)}*PI`;
+}
+function buildVideoFilters(state, options = {}) {
+  const vf = [];
+  if (state.flipX) vf.push("hflip");
+  if (state.flipY) vf.push("vflip");
+  vf.push(...rotationFilters(state.rotation));
+  if (state.crop) {
+    const { x, y, width, height } = state.crop;
+    vf.push(`crop=${width}:${height}:${x}:${y}`);
+  }
+  if (state.scale) {
+    const { width, height, fit } = state.scale;
+    if (fit === "force") {
+      vf.push(`scale=${width}:${height}`);
+    } else if (fit === "cover") {
+      vf.push(`scale=${width}:${height}:force_original_aspect_ratio=increase`, `crop=${width}:${height}`);
+    } else {
+      vf.push(
+        `scale=${width}:${height}:force_original_aspect_ratio=decrease`,
+        `pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2`
+      );
+    }
+  }
+  const eq = eqFilter(state.filters);
+  if (eq) vf.push(eq);
+  const colorBalance = colorBalanceFilter(state.filters);
+  if (colorBalance) vf.push(colorBalance);
+  const vibrance = vibranceFilter(state.filters);
+  if (vibrance) vf.push(vibrance);
+  const toneCurve = toneCurveFilter(state.filters);
+  if (toneCurve) vf.push(toneCurve);
+  vf.push(...detailFilters(state.filters));
+  const grain = grainFilter(state.filters);
+  if (grain) vf.push(grain);
+  const vignette = vignetteFilter(state.filters);
+  if (vignette) vf.push(vignette);
+  const preset = findFilterPreset(state.filterPreset);
+  if (preset) vf.push(preset.vf);
+  if (options.includeExportScale !== false) vf.push(...buildExportScaleFilters(state));
+  vf.push(`fps=${getExportFrameRate(state)}`);
+  const norm = normalizeDeg(state.rotation);
+  if (norm % 90 !== 0 && !state.scale) {
+    vf.push("scale=trunc(iw/2)*2:trunc(ih/2)*2");
+  }
+  return vf;
+}
+var TRANSITION_FFMPEG_MAP = {
+  fade: "fade",
+  slide: "slideleft",
+  wipe: "wipeleft",
+  flip: "horzopen",
+  clockWipe: "radial",
+  star: "pixelize",
+  circle: "circleopen",
+  rectangle: "rectcrop"
+};
+var TRANSITION_AUDIO_CURVE_MAP = {
+  fade: "qsin",
+  slide: "tri",
+  wipe: "tri",
+  flip: "exp",
+  clockWipe: "qsin",
+  star: "tri",
+  circle: "qsin",
+  rectangle: "qsin"
+};
+function clipSpanDuration(clip) {
+  return clip.out - clip.in;
+}
+function resolveTransition(transition, leftDuration, rightDuration) {
+  const type = transition && typeof transition.type === "string" ? transition.type : "none";
+  const mapped = TRANSITION_FFMPEG_MAP[type] ? type : "none";
+  const maxDuration = Math.max(0, Math.min(1.2, leftDuration - 0.05, rightDuration - 0.05));
+  if (mapped === "none" || maxDuration <= 0.05) {
+    return { type: "none", duration: 0, effect: "fade", curve: "tri" };
+  }
+  const rawDuration = Number(transition?.duration);
+  const duration = Math.min(Math.max(Number.isFinite(rawDuration) ? rawDuration : 0.4, 0.1), maxDuration);
+  return {
+    type: mapped,
+    duration,
+    effect: TRANSITION_FFMPEG_MAP[mapped],
+    curve: TRANSITION_AUDIO_CURVE_MAP[mapped] ?? "tri"
+  };
+}
+function hasActiveTransitions(transitions, clips) {
+  if (!Array.isArray(clips) || clips.length < 2) return false;
+  for (let i = 0; i < clips.length - 1; i++) {
+    const transition = resolveTransition(transitions?.[i], clipSpanDuration(clips[i]), clipSpanDuration(clips[i + 1]));
+    if (transition.type !== "none" && transition.duration > 0) return true;
+  }
+  return false;
+}
+function buildTransitionSegments(clips, transitions) {
+  const segments = [];
+  let start = 0;
+  for (let i = 0; i < clips.length - 1; i++) {
+    const transition = resolveTransition(transitions?.[i], clipSpanDuration(clips[i]), clipSpanDuration(clips[i + 1]));
+    if (transition.type !== "none" && transition.duration > 0) {
+      segments.push({ start, end: i, transition });
+      start = i + 1;
+    }
+  }
+  segments.push({ start, end: clips.length - 1, transition: null });
+  return segments;
+}
+function segmentClipDuration(clips, start, end) {
+  let total = 0;
+  for (let i = start; i <= end; i++) total += clipSpanDuration(clips[i]);
+  return total;
+}
+function buildTransitionTimeline(parts, clips, transitions, keepAudio) {
+  const segments = buildTransitionSegments(clips, transitions);
+  const builtSegments = segments.map((segment, segmentIndex) => {
+    const duration = segmentClipDuration(clips, segment.start, segment.end);
+    if (segment.start === segment.end) {
+      return {
+        vLabel: `[v${segment.start}]`,
+        aLabel: keepAudio ? `[a${segment.start}]` : "",
+        duration,
+        transition: segment.transition
+      };
+    }
+    const inputs = [];
+    for (let i = segment.start; i <= segment.end; i++) {
+      inputs.push(keepAudio ? `[v${i}][a${i}]` : `[v${i}]`);
+    }
+    const vLabel = `[sgv${segmentIndex}]`;
+    const aLabel = keepAudio ? `[sga${segmentIndex}]` : "";
+    parts.push(
+      `${inputs.join("")}concat=n=${segment.end - segment.start + 1}:v=1:a=${keepAudio ? 1 : 0}${keepAudio ? `${vLabel}${aLabel}` : vLabel}`
+    );
+    return { vLabel, aLabel, duration, transition: segment.transition };
+  });
+  let currentV = builtSegments[0].vLabel;
+  let currentA = keepAudio ? builtSegments[0].aLabel : "";
+  let currentDuration = builtSegments[0].duration;
+  for (let i = 1; i < builtSegments.length; i++) {
+    const transition = builtSegments[i - 1].transition;
+    const next = builtSegments[i];
+    const vOut = `[vx${i}]`;
+    const offset = Math.max(0, currentDuration - transition.duration);
+    parts.push(`${currentV}${next.vLabel}xfade=transition=${transition.effect}:duration=${transition.duration}:offset=${offset}${vOut}`);
+    currentV = vOut;
+    if (keepAudio) {
+      const aOut = `[ax${i}]`;
+      parts.push(`${currentA}${next.aLabel}acrossfade=d=${transition.duration}:c1=${transition.curve}:c2=${transition.curve}${aOut}`);
+      currentA = aOut;
+    }
+    currentDuration = currentDuration + next.duration - transition.duration;
+  }
+  return { vLabel: currentV, aLabel: currentA, duration: currentDuration };
+}
+function codecArgs(withAudio, state) {
+  const format = getExportFormat(state);
+  const args = format === "mxf" ? ["-c:v", "mpeg2video", "-pix_fmt", "yuv422p"] : ["-c:v", "libx264", "-preset", "veryfast", "-pix_fmt", "yuv420p", "-movflags", "+faststart"];
+  const videoBitrateKbps = getExportVideoBitrateKbps(state);
+  if (videoBitrateKbps > 0) {
+    args.push("-b:v", `${videoBitrateKbps}k`, "-maxrate", `${videoBitrateKbps}k`, "-bufsize", `${Math.max(videoBitrateKbps * 2, 512)}k`);
+  } else if (format === "mxf") {
+    args.push("-q:v", "2");
+  }
+  if (withAudio) {
+    if (format === "mxf") {
+      args.push("-c:a", "pcm_s16le");
+    } else {
+      args.push("-c:a", getExportAudioCodec(state));
+      const audioBitrateKbps = getExportAudioBitrateKbps(state);
+      if (audioBitrateKbps > 0) args.push("-b:a", `${audioBitrateKbps}k`);
+    }
+  }
+  if (format === "mxf") args.push("-f", "mxf");
+  return args;
+}
+var AFORMAT = "aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo";
+var ANULL = "anullsrc=r=44100:cl=stereo";
+function declick(dur) {
+  if (!(dur > 0.02)) return "";
+  const st = Math.round((dur - 0.01) * 1e3) / 1e3;
+  return `,afade=t=in:st=0:d=0.01,afade=t=out:st=${st}:d=0.01`;
+}
+var LIMITER = "alimiter=limit=0.95:level=disabled:latency=1";
+var DEFAULT_TIMED_EFFECT_DURATION = 3;
+var MIN_TIMED_EFFECT_DURATION = 0.5;
+function evenFloor(value, min = 0) {
+  const next = Math.max(min, Math.floor(Number(value) || 0));
+  return next % 2 === 0 ? next : next - 1;
+}
+function normalizeTimedOverlayWindow(overlay) {
+  const startAt = Number.isFinite(overlay?.startAt) ? Math.max(0, Number(overlay.startAt)) : 0;
+  const explicitEnd = Number(overlay?.endAt);
+  if (Number.isFinite(explicitEnd)) {
+    return {
+      startAt,
+      endAt: Math.max(startAt + MIN_TIMED_EFFECT_DURATION, explicitEnd)
+    };
+  }
+  return {
+    startAt,
+    endAt: startAt + DEFAULT_TIMED_EFFECT_DURATION
+  };
+}
+function normalizeEffectOverlayRect(_overlay, bounds) {
+  const w = Math.max(2, evenFloor(bounds.w, 2));
+  const h = Math.max(2, evenFloor(bounds.h, 2));
+  if (!(w > 1) || !(h > 1)) return null;
+  return { x: 0, y: 0, w, h };
+}
+function buildEffectOverlayFilters(overlay) {
+  if (overlay?.type === "filter") {
+    const preset = findFilterPreset(overlay.filterPreset);
+    return preset ? [preset.vf] : [];
+  }
+  if (overlay?.type !== "adjust") return [];
+  const filters = [];
+  const eq = eqFilter(overlay);
+  if (eq) filters.push(eq);
+  const colorBalance = colorBalanceFilter(overlay);
+  if (colorBalance) filters.push(colorBalance);
+  const vibrance = vibranceFilter(overlay);
+  if (vibrance) filters.push(vibrance);
+  const toneCurve = toneCurveFilter(overlay);
+  if (toneCurve) filters.push(toneCurve);
+  filters.push(...detailFilters(overlay));
+  const grain = grainFilter(overlay);
+  if (grain) filters.push(grain);
+  const vignette = vignetteFilter(overlay);
+  if (vignette) filters.push(vignette);
+  return filters;
+}
+function listEffectOverlays(overlays, bounds) {
+  const next = [];
+  for (const overlay of overlays ?? []) {
+    if (overlay?.type !== "filter" && overlay?.type !== "adjust") continue;
+    const rect = normalizeEffectOverlayRect(overlay, bounds);
+    if (!rect) continue;
+    const filters = buildEffectOverlayFilters(overlay);
+    if (!filters.length) continue;
+    next.push({
+      rect,
+      filters,
+      ...normalizeTimedOverlayWindow(overlay)
+    });
+  }
+  return next;
+}
+function listTimedTextOverlayWindows(overlays, maxCount = Infinity) {
+  const next = [];
+  for (const overlay of overlays ?? []) {
+    if (overlay?.type !== "pen" && overlay?.type !== "line" && overlay?.type !== "arrow" && overlay?.type !== "rect" && overlay?.type !== "ellipse" && overlay?.type !== "text" && overlay?.type !== "sticker") continue;
+    const startAt = Number(overlay.startAt);
+    const endAt = Number(overlay.endAt);
+    if (!Number.isFinite(startAt) || !Number.isFinite(endAt) || endAt <= startAt) continue;
+    next.push({
+      startAt: Math.max(0, startAt),
+      endAt: Math.max(startAt + 0.01, endAt)
+    });
+    if (next.length >= maxCount) break;
+  }
+  return next;
+}
+function appendTimedTextOverlayFilters(parts, baseLabel, inputIndexStart, overlayWindows) {
+  let vLabel = baseLabel;
+  overlayWindows.forEach((overlay, index) => {
+    const nextLabel = `[vtxt${inputIndexStart + index}]`;
+    parts.push(
+      `${vLabel}[${inputIndexStart + index}:v]overlay=0:0:enable='between(t,${overlay.startAt.toFixed(3)},${overlay.endAt.toFixed(3)})'${nextLabel}`
+    );
+    vLabel = nextLabel;
+  });
+  return vLabel;
+}
+function appendEffectOverlayFilters(parts, baseLabel, overlays) {
+  let vLabel = baseLabel;
+  overlays.forEach((overlay, index) => {
+    const srcLabel = `[vfxsrc${index}]`;
+    const baseSplitLabel = `[vfxbase${index}]`;
+    const cropLabel = `[vfxcrop${index}]`;
+    const nextLabel = `[vfx${index}]`;
+    const { rect } = overlay;
+    parts.push(`${vLabel}split=2${srcLabel}${baseSplitLabel}`);
+    parts.push(`${srcLabel}crop=${rect.w}:${rect.h}:${rect.x}:${rect.y},${overlay.filters.join(",")}${cropLabel}`);
+    parts.push(
+      `${baseSplitLabel}${cropLabel}overlay=${rect.x}:${rect.y}:enable='between(t,${overlay.startAt.toFixed(3)},${overlay.endAt.toFixed(3)})'${nextLabel}`
+    );
+    vLabel = nextLabel;
+  });
+  return vLabel;
+}
+function buildSingleSourceArgs(state, input, output, overlayInput, hasAudio, textOverlayPaths = []) {
+  const vf = buildVideoFilters(state, { includeExportScale: false });
+  const clips = state.clips;
+  const keepAudio = state.keepAudio && hasAudio;
+  const multi = clips.length >= 2;
+  const effectOverlays = listEffectOverlays(state.overlays, getProjectOutputSize(state));
+  const timedTextOverlays = listTimedTextOverlayWindows(state.overlays, textOverlayPaths.length);
+  const activeTextOverlayPaths = textOverlayPaths.slice(0, timedTextOverlays.length);
+  if (multi || overlayInput || activeTextOverlayPaths.length || effectOverlays.length) {
+    const parts = [];
+    let vLabel;
+    if (multi) {
+      clips.forEach((c, i) => {
+        parts.push(`[0:v]trim=start=${c.in}:end=${c.out},setpts=PTS-STARTPTS[v${i}]`);
+        if (keepAudio) {
+          parts.push(`[0:a]atrim=start=${c.in}:end=${c.out},asetpts=PTS-STARTPTS${declick(c.out - c.in)}[a${i}]`);
+        }
+      });
+      const concatInputs = clips.map((_, i) => keepAudio ? `[v${i}][a${i}]` : `[v${i}]`).join("");
+      const concatOuts = keepAudio ? "[vcat][acat]" : "[vcat]";
+      parts.push(`${concatInputs}concat=n=${clips.length}:v=1:a=${keepAudio ? 1 : 0}${concatOuts}`);
+      vLabel = "[vcat]";
+    } else {
+      vLabel = "[0:v]";
+    }
+    if (vf.length) {
+      parts.push(`${vLabel}${vf.join(",")}[vflt]`);
+      vLabel = "[vflt]";
+    }
+    if (effectOverlays.length) {
+      vLabel = appendEffectOverlayFilters(parts, vLabel, effectOverlays);
+    }
+    if (overlayInput) {
+      parts.push(`${vLabel}[1:v]overlay=0:0[vout]`);
+      vLabel = "[vout]";
+    } else if (vLabel === "[0:v]") {
+      parts.push(`[0:v]null[vout]`);
+      vLabel = "[vout]";
+    }
+    if (activeTextOverlayPaths.length) {
+      const textInputStart = 1 + (overlayInput ? 1 : 0);
+      vLabel = appendTimedTextOverlayFilters(parts, vLabel, textInputStart, timedTextOverlays);
+    }
+    const exportScaleFilters = buildExportScaleFilters(state);
+    if (exportScaleFilters.length) {
+      parts.push(`${vLabel}${exportScaleFilters.join(",")}[vscaled]`);
+      vLabel = "[vscaled]";
+    }
+    const pre2 = [];
+    if (!multi && clips.length === 1) {
+      pre2.push("-ss", String(clips[0].in), "-t", String(clips[0].out - clips[0].in));
+    }
+    const args2 = ["-y", ...pre2, "-i", input];
+    if (overlayInput) args2.push("-i", overlayInput);
+    for (const textOverlayPath of activeTextOverlayPaths) args2.push("-i", textOverlayPath);
+    args2.push("-filter_complex", parts.join(";"), "-map", vLabel);
+    if (keepAudio) args2.push("-map", multi ? "[acat]" : "0:a?");
+    args2.push(...codecArgs(keepAudio, state));
+    args2.push(output);
+    return args2;
+  }
+  const fullVf = buildVideoFilters(state);
+  const pre = ["-ss", String(clips[0].in), "-t", String(clips[0].out - clips[0].in)];
+  const args = ["-y", ...pre, "-i", input];
+  if (fullVf.length) args.push("-vf", fullVf.join(","));
+  if (!keepAudio) args.push("-an");
+  args.push(...codecArgs(keepAudio, state));
+  args.push(output);
+  return args;
+}
+function buildFfmpegArgs(state, io, output) {
+  const { videoPaths, videoHasAudio, audioPaths, overlayPath, textOverlayPaths = [] } = io;
+  const music = state.audioClips ?? [];
+  const activeTransitions = hasActiveTransitions(state.transitions, state.clips);
+  const timedTextOverlays = listTimedTextOverlayWindows(state.overlays, textOverlayPaths.length);
+  const activeTextOverlayPaths = textOverlayPaths.slice(0, timedTextOverlays.length);
+  if (videoPaths.length === 1 && music.length === 0 && !activeTransitions) {
+    return buildSingleSourceArgs(state, videoPaths[0], output, overlayPath, videoHasAudio[0] ?? false, activeTextOverlayPaths);
+  }
+  const N = videoPaths.length;
+  const M = audioPaths.length;
+  const cw = state.canvas.w;
+  const ch = state.canvas.h;
+  const clips = state.clips;
+  const keepAudio = state.keepAudio && clips.some((c) => videoHasAudio[c.srcIdx]);
+  const frameRate = getExportFrameRate(state);
+  const total = clips.reduce((s, c) => s + (c.out - c.in), 0);
+  const parts = [];
+  clips.forEach((c, i) => {
+    parts.push(
+      `[${c.srcIdx}:v]trim=start=${c.in}:end=${c.out},setpts=PTS-STARTPTS,scale=${cw}:${ch}:force_original_aspect_ratio=increase,crop=${cw}:${ch},setsar=1,fps=${frameRate},format=yuv420p[v${i}]`
+    );
+    if (keepAudio) {
+      if (videoHasAudio[c.srcIdx]) {
+        parts.push(
+          `[${c.srcIdx}:a]atrim=start=${c.in}:end=${c.out},asetpts=PTS-STARTPTS${declick(c.out - c.in)},${AFORMAT}[a${i}]`
+        );
+      } else {
+        parts.push(`${ANULL},atrim=start=0:end=${c.out - c.in},asetpts=PTS-STARTPTS,${AFORMAT}[a${i}]`);
+      }
+    }
+  });
+  let vLabel = "[vcat]";
+  let aLabel = keepAudio ? "[acat]" : "";
+  let effectiveTotal = total;
+  if (activeTransitions) {
+    const timeline = buildTransitionTimeline(parts, clips, state.transitions ?? [], keepAudio);
+    vLabel = timeline.vLabel;
+    aLabel = keepAudio ? timeline.aLabel : "";
+    effectiveTotal = timeline.duration;
+  } else {
+    const concatInputs = clips.map((_, i) => keepAudio ? `[v${i}][a${i}]` : `[v${i}]`).join("");
+    parts.push(`${concatInputs}concat=n=${clips.length}:v=1:a=${keepAudio ? 1 : 0}${keepAudio ? "[vcat][acat]" : "[vcat]"}`);
+  }
+  if (!keepAudio && music.length) {
+    parts.push(`${ANULL},atrim=start=0:end=${effectiveTotal},asetpts=PTS-STARTPTS,${AFORMAT}[acat]`);
+    aLabel = "[acat]";
+  }
+  if (music.length) {
+    music.forEach((a, j) => {
+      const ms = Math.max(0, Math.round(a.startAt * 1e3));
+      const clipDuration = Math.max(0, a.out - a.in);
+      const speed = clampAudioSpeed(a.speed);
+      const fadeIn = Math.min(Math.max(Number(a.fadeIn) || 0, 0), clipDuration);
+      const fadeOut = Math.min(
+        Math.max(Number(a.fadeOut) || 0, 0),
+        Math.max(0, clipDuration - fadeIn)
+      );
+      const audioFilters = [
+        `atrim=start=${a.in}:end=${a.out}`,
+        "asetpts=PTS-STARTPTS",
+        ...buildAudioTempoFilters(speed),
+        `volume=${a.volume}`
+      ];
+      if (fadeIn > 1e-4) {
+        audioFilters.push(`afade=t=in:st=0:d=${fadeIn}`);
+      }
+      if (fadeOut > 1e-4) {
+        audioFilters.push(
+          `afade=t=out:st=${Math.max(0, clipDuration - fadeOut)}:d=${fadeOut}`
+        );
+      }
+      audioFilters.push(AFORMAT, `adelay=${ms}|${ms}`);
+      parts.push(
+        `[${N + j}:a]${audioFilters.join(",")}[mu${j}]`
+      );
+    });
+    const mixInputs = `${aLabel}${music.map((_, j) => `[mu${j}]`).join("")}`;
+    parts.push(
+      `${mixInputs}amix=inputs=${1 + music.length}:duration=first:dropout_transition=0:normalize=0,${LIMITER}[aout]`
+    );
+    aLabel = "[aout]";
+  }
+  const vf = buildVideoFilters(state, { includeExportScale: false });
+  const effectOverlays = listEffectOverlays(state.overlays, getProjectOutputSize(state));
+  if (vf.length) {
+    parts.push(`${vLabel}${vf.join(",")}[vflt]`);
+    vLabel = "[vflt]";
+  }
+  if (effectOverlays.length) {
+    vLabel = appendEffectOverlayFilters(parts, vLabel, effectOverlays);
+  }
+  if (overlayPath) {
+    parts.push(`${vLabel}[${N + M}:v]overlay=0:0[vout]`);
+    vLabel = "[vout]";
+  }
+  if (activeTextOverlayPaths.length) {
+    const textInputStart = N + M + (overlayPath ? 1 : 0);
+    vLabel = appendTimedTextOverlayFilters(parts, vLabel, textInputStart, timedTextOverlays);
+  }
+  const exportScaleFilters = buildExportScaleFilters(state);
+  if (exportScaleFilters.length) {
+    parts.push(`${vLabel}${exportScaleFilters.join(",")}[vscaled]`);
+    vLabel = "[vscaled]";
+  }
+  const args = ["-y"];
+  for (const p of videoPaths) args.push("-i", p);
+  for (const p of audioPaths) args.push("-i", p);
+  if (overlayPath) args.push("-i", overlayPath);
+  for (const textOverlayPath of activeTextOverlayPaths) args.push("-i", textOverlayPath);
+  args.push("-filter_complex", parts.join(";"), "-map", vLabel);
+  const withAudio = !!aLabel;
+  if (withAudio) args.push("-map", aLabel);
+  args.push(...codecArgs(withAudio, state));
+  if (withAudio) args.push("-ar", "44100", "-ac", "2");
+  args.push(output);
+  return args;
+}
+function buildPosterArgs(input, time, output) {
+  return ["-y", "-ss", String(time), "-i", input, "-frames:v", "1", "-q:v", "2", output];
+}
+
+export { buildFfmpegArgs, buildPosterArgs };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map