getraw 0.1.0

package/src/networking/proxy.ts

@@ -0,0 +1,132 @@
+export type ProxyProtocol = "http" | "https" | "socks5";
+
+export interface ParsedProxy {
+  protocol: ProxyProtocol;
+  host: string;
+  port: number;
+  username?: string;
+  password?: string;
+}
+
+export class ProxyParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ProxyParseError";
+  }
+}
+
+export function parseProxyUrl(proxyUrl: string): ParsedProxy {
+  let url: URL;
+  try {
+    url = new URL(proxyUrl);
+  } catch {
+    throw new ProxyParseError(`Invalid proxy URL: ${proxyUrl}`);
+  }
+
+  const protocol = url.protocol.replace(":", "") as ProxyProtocol;
+  if (!["http", "https", "socks5"].includes(protocol)) {
+    throw new ProxyParseError(
+      `Unsupported proxy protocol: ${protocol}. Supported: http, https, socks5`,
+    );
+  }
+
+  const host = url.hostname;
+  if (!host) {
+    throw new ProxyParseError(`Proxy URL missing host: ${proxyUrl}`);
+  }
+
+  const port = url.port ? parseInt(url.port, 10) : protocol === "https" ? 443 : 1080;
+  if (isNaN(port) || port < 1 || port > 65535) {
+    throw new ProxyParseError(`Invalid proxy port: ${url.port}`);
+  }
+
+  const result: ParsedProxy = { protocol, host, port };
+  if (url.username) result.username = decodeURIComponent(url.username);
+  if (url.password) result.password = decodeURIComponent(url.password);
+
+  return result;
+}
+
+export function buildProxyAuthHeader(proxy: ParsedProxy): string | undefined {
+  if (!proxy.username) return undefined;
+  const creds = `${proxy.username}:${proxy.password ?? ""}`;
+  return `Basic ${btoa(creds)}`;
+}
+
+export interface ProxyAgent {
+  proxy: ParsedProxy;
+  getProxyUrl(): string;
+  getAuthHeader(): string | undefined;
+}
+
+export function createProxyAgent(proxyUrl: string): ProxyAgent {
+  const proxy = parseProxyUrl(proxyUrl);
+
+  return {
+    proxy,
+    getProxyUrl(): string {
+      const auth =
+        proxy.username
+          ? `${encodeURIComponent(proxy.username)}:${encodeURIComponent(proxy.password ?? "")}@`
+          : "";
+      return `${proxy.protocol}://${auth}${proxy.host}:${proxy.port}`;
+    },
+    getAuthHeader(): string | undefined {
+      return buildProxyAuthHeader(proxy);
+    },
+  };
+}
+
+export interface HttpConnectOptions {
+  targetHost: string;
+  targetPort: number;
+  proxy: ParsedProxy;
+}
+
+export function buildConnectRequest(opts: HttpConnectOptions): string {
+  const target = `${opts.targetHost}:${opts.targetPort}`;
+  const authHeader = buildProxyAuthHeader(opts.proxy);
+  const lines = [
+    `CONNECT ${target} HTTP/1.1`,
+    `Host: ${target}`,
+    "Proxy-Connection: keep-alive",
+  ];
+  if (authHeader) {
+    lines.push(`Proxy-Authorization: ${authHeader}`);
+  }
+  lines.push("", "");
+  return lines.join("\r\n");
+}
+
+export interface Socks5ConnectOptions {
+  targetHost: string;
+  targetPort: number;
+  proxy: ParsedProxy;
+}
+
+export function buildSocks5Greeting(proxy: ParsedProxy): Uint8Array {
+  if (proxy.username) {
+    return new Uint8Array([0x05, 0x02, 0x00, 0x02]);
+  }
+  return new Uint8Array([0x05, 0x01, 0x00]);
+}
+
+export function buildSocks5ConnectRequest(
+  opts: Socks5ConnectOptions,
+): Uint8Array {
+  const encoder = new TextEncoder();
+  const hostBytes = encoder.encode(opts.targetHost);
+  const buf = new Uint8Array(4 + 1 + hostBytes.length + 2);
+  let i = 0;
+  buf[i++] = 0x05;
+  buf[i++] = 0x01;
+  buf[i++] = 0x00;
+  buf[i++] = 0x03;
+  buf[i++] = hostBytes.length;
+  buf.set(hostBytes, i);
+  i += hostBytes.length;
+  const port = opts.targetPort;
+  buf[i++] = (port >> 8) & 0xff;
+  buf[i++] = port & 0xff;
+  return buf;
+}

package/src/networking/tls.ts

@@ -0,0 +1,67 @@
+export interface TlsFingerprint {
+  ja3?: string;
+  ja4?: string;
+  userAgent: string;
+}
+
+export interface TlsProfile {
+  name: string;
+  userAgent: string;
+  fingerprint?: TlsFingerprint;
+}
+
+export const TLS_PROFILES: Record<string, TlsProfile> = {
+  chrome_131: {
+    name: "Chrome 131",
+    userAgent:
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    fingerprint: {
+      ja3: "771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513-21,29-23-24,0",
+      userAgent:
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    },
+  },
+  firefox_133: {
+    name: "Firefox 133",
+    userAgent:
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0",
+    fingerprint: {
+      ja3: "771,4865-4867-4866-49195-49199-52393-52392-49196-49200-49162-49161-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-34-51-43-13-45-28-65037,29-23-24-25-256-257,0",
+      userAgent:
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0",
+    },
+  },
+  safari_18: {
+    name: "Safari 18",
+    userAgent:
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15",
+    fingerprint: {
+      userAgent:
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15",
+    },
+  },
+};
+
+export function getTlsProfileForUserAgent(
+  userAgent: string,
+): TlsProfile | undefined {
+  for (const profile of Object.values(TLS_PROFILES)) {
+    if (profile.userAgent === userAgent) return profile;
+  }
+  if (userAgent.includes("Chrome")) return TLS_PROFILES["chrome_131"];
+  if (userAgent.includes("Firefox")) return TLS_PROFILES["firefox_133"];
+  if (userAgent.includes("Safari")) return TLS_PROFILES["safari_18"];
+  return undefined;
+}
+
+export const TLS_IMPLEMENTATION_NOTE = `
+TLS fingerprinting (JA3/JA4) requires low-level TLS control not available through
+standard fetch()/WebSocket APIs. Full impersonation requires:
+1. A native Bun binding or FFI to BoringSSL/uTLS
+2. Custom cipher suite ordering matching the target browser
+3. Custom TLS extensions ordering
+
+For now, dlpx sets a matching User-Agent header which satisfies most sites.
+Sites that perform JA3 fingerprint checking (e.g., some CDN bot detection) may
+require a future implementation using Bun FFI + uTLS or a headless browser approach.
+`;

package/src/networking/user-agents.ts

@@ -0,0 +1,88 @@
+export interface UserAgentEntry {
+  ua: string;
+  platform: "macos" | "windows" | "linux";
+  browser: "chrome" | "firefox" | "safari" | "edge";
+}
+
+export const USER_AGENTS: UserAgentEntry[] = [
+  {
+    ua: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    platform: "macos",
+    browser: "chrome",
+  },
+  {
+    ua: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    platform: "windows",
+    browser: "chrome",
+  },
+  {
+    ua: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    platform: "linux",
+    browser: "chrome",
+  },
+  {
+    ua: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:133.0) Gecko/20100101 Firefox/133.0",
+    platform: "macos",
+    browser: "firefox",
+  },
+  {
+    ua: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:133.0) Gecko/20100101 Firefox/133.0",
+    platform: "windows",
+    browser: "firefox",
+  },
+  {
+    ua: "Mozilla/5.0 (X11; Linux x86_64; rv:133.0) Gecko/20100101 Firefox/133.0",
+    platform: "linux",
+    browser: "firefox",
+  },
+  {
+    ua: "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15",
+    platform: "macos",
+    browser: "safari",
+  },
+  {
+    ua: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0",
+    platform: "windows",
+    browser: "edge",
+  },
+  {
+    ua: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0",
+    platform: "macos",
+    browser: "edge",
+  },
+];
+
+let roundRobinIndex = 0;
+
+export function getRandomUserAgent(): string {
+  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)].ua;
+}
+
+export function getRoundRobinUserAgent(): string {
+  const ua = USER_AGENTS[roundRobinIndex % USER_AGENTS.length].ua;
+  roundRobinIndex++;
+  return ua;
+}
+
+export function getUserAgentByBrowser(
+  browser: UserAgentEntry["browser"],
+  platform?: UserAgentEntry["platform"],
+): string {
+  const filtered = USER_AGENTS.filter(
+    (e) => e.browser === browser && (!platform || e.platform === platform),
+  );
+  if (filtered.length === 0) {
+    return getRandomUserAgent();
+  }
+  return filtered[Math.floor(Math.random() * filtered.length)].ua;
+}
+
+export function getUserAgentByPlatform(
+  platform: UserAgentEntry["platform"],
+): string {
+  const filtered = USER_AGENTS.filter((e) => e.platform === platform);
+  if (filtered.length === 0) {
+    return getRandomUserAgent();
+  }
+  return filtered[Math.floor(Math.random() * filtered.length)].ua;
+}

package/src/postprocessors/base.ts

@@ -0,0 +1,44 @@
+import { PostProcessor } from "../core/types";
+import type { InfoDict, Options, PostProcessResult } from "../core/types";
+import { logger } from "../core/logger";
+
+export { PostProcessor };
+
+const postProcessors: PostProcessor[] = [];
+
+export function registerPostProcessor(pp: PostProcessor): void {
+  postProcessors.push(pp);
+}
+
+export async function runPostProcessors(
+  info: InfoDict,
+  filepath: string,
+  _options: Options,
+): Promise<string> {
+  let currentPath = filepath;
+  const filesToDelete: string[] = [];
+
+  for (const pp of postProcessors) {
+    logger.debug(`Running post-processor: ${pp._NAME}`);
+    try {
+      const result: PostProcessResult = await pp.run(info, currentPath);
+      currentPath = result.filepath;
+      filesToDelete.push(...result.files_to_delete);
+    } catch (err) {
+      logger.warn(
+        `Post-processor ${pp._NAME} failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  for (const file of filesToDelete) {
+    try {
+      const { unlink } = await import("node:fs/promises");
+      await unlink(file);
+    } catch {
+      logger.debug(`Could not delete temp file: ${file}`);
+    }
+  }
+
+  return currentPath;
+}

package/src/postprocessors/extract-audio.ts

@@ -0,0 +1,98 @@
+import { PostProcessor, PostProcessError } from "../core/types";
+import type { InfoDict, PostProcessResult } from "../core/types";
+import { FFmpegRunner } from "./ffmpeg";
+import { dirname, basename, extname, join } from "node:path";
+
+export type AudioFormat = "mp3" | "flac" | "wav" | "aac" | "opus" | "vorbis" | "m4a";
+
+const FORMAT_CODEC: Record<AudioFormat, string> = {
+  mp3: "libmp3lame",
+  flac: "flac",
+  wav: "pcm_s16le",
+  aac: "aac",
+  opus: "libopus",
+  vorbis: "libvorbis",
+  m4a: "aac",
+};
+
+const FORMAT_EXT: Record<AudioFormat, string> = {
+  mp3: "mp3",
+  flac: "flac",
+  wav: "wav",
+  aac: "aac",
+  opus: "opus",
+  vorbis: "ogg",
+  m4a: "m4a",
+};
+
+export interface ExtractAudioOptions {
+  format?: AudioFormat;
+  quality?: number;
+  preserveMetadata?: boolean;
+  ffmpegLocation?: string | null;
+  onProgress?: (percent: number) => void;
+}
+
+export class ExtractAudioPostProcessor extends PostProcessor {
+  readonly _NAME = "ExtractAudio";
+
+  private opts: ExtractAudioOptions;
+
+  constructor(opts: ExtractAudioOptions = {}) {
+    super();
+    this.opts = opts;
+  }
+
+  async run(info: InfoDict, filepath: string): Promise<PostProcessResult> {
+    const format: AudioFormat = this.opts.format ?? "mp3";
+    const codec = FORMAT_CODEC[format];
+    const ext = FORMAT_EXT[format];
+
+    const dir = dirname(filepath);
+    const stem = basename(filepath, extname(filepath));
+    const outputPath = join(dir, `${stem}.${ext}`);
+
+    const runner = await FFmpegRunner.detect(this.opts.ffmpegLocation);
+
+    const args: string[] = ["-i", filepath, "-vn", "-acodec", codec];
+
+    const quality = this.opts.quality ?? 5;
+
+    if (format === "mp3") {
+      args.push("-q:a", String(quality));
+    } else if (format === "opus") {
+      const bitrate = qualityToBitrate(quality, 32, 320);
+      args.push("-b:a", `${bitrate}k`);
+    } else if (format === "vorbis") {
+      args.push("-q:a", String(quality));
+    } else if (format === "aac" || format === "m4a") {
+      const bitrate = qualityToBitrate(quality, 32, 320);
+      args.push("-b:a", `${bitrate}k`);
+    }
+
+    if (this.opts.preserveMetadata !== false) {
+      args.push("-map_metadata", "0");
+    }
+
+    args.push(outputPath);
+
+    await runner.run(
+      args,
+      this.opts.onProgress
+        ? (p) => { if (p.percent !== undefined) this.opts.onProgress!(p.percent); }
+        : undefined,
+      info.duration,
+    );
+
+    return {
+      filepath: outputPath,
+      info,
+      files_to_delete: outputPath !== filepath ? [filepath] : [],
+    };
+  }
+}
+
+function qualityToBitrate(quality: number, min: number, max: number): number {
+  const clamped = Math.max(0, Math.min(10, quality));
+  return Math.round(min + ((10 - clamped) / 10) * (max - min));
+}

package/src/postprocessors/ffmpeg.ts

@@ -0,0 +1,146 @@
+import { PostProcessError } from "../core/types";
+
+export interface FFmpegProgress {
+  frame?: number;
+  fps?: number;
+  time?: string;
+  speed?: string;
+  percent?: number;
+}
+
+export type ProgressCallback = (progress: FFmpegProgress) => void;
+
+export class FFmpegRunner {
+  private binary: string;
+
+  constructor(binary: string = "ffmpeg") {
+    this.binary = binary;
+  }
+
+  static async detect(ffmpegLocation?: string | null): Promise<FFmpegRunner> {
+    const candidates = ffmpegLocation
+      ? [ffmpegLocation, "ffmpeg"]
+      : ["ffmpeg", "/usr/local/bin/ffmpeg", "/opt/homebrew/bin/ffmpeg", "/usr/bin/ffmpeg"];
+
+    for (const candidate of candidates) {
+      try {
+        const result = await Bun.$`${candidate} -version`.quiet();
+        if (result.exitCode === 0) {
+          return new FFmpegRunner(candidate);
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    throw new PostProcessError(
+      "FFmpeg not found. Install FFmpeg or pass --ffmpeg-location.",
+    );
+  }
+
+  async checkCapabilities(): Promise<{ codecs: string[]; formats: string[] }> {
+    const [codecResult, formatResult] = await Promise.all([
+      Bun.$`${this.binary} -codecs -v quiet`.quiet(),
+      Bun.$`${this.binary} -formats -v quiet`.quiet(),
+    ]);
+
+    const codecs = codecResult.stdout
+      .toString()
+      .split("\n")
+      .filter((l) => /^\s*[D.][E.][VASD.][I.][L.][S.]/.test(l))
+      .map((l) => l.trim().split(/\s+/)[1])
+      .filter(Boolean) as string[];
+
+    const formats = formatResult.stdout
+      .toString()
+      .split("\n")
+      .filter((l) => /^\s*[D.][E.]/.test(l))
+      .map((l) => l.trim().split(/\s+/)[1])
+      .filter(Boolean) as string[];
+
+    return { codecs, formats };
+  }
+
+  async run(
+    args: string[],
+    onProgress?: ProgressCallback,
+    durationSeconds?: number,
+  ): Promise<void> {
+    const proc = Bun.spawn([this.binary, "-y", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stderrChunks: Uint8Array[] = [];
+    const decoder = new TextDecoder();
+    let partialLine = "";
+
+    if (proc.stderr) {
+      const reader = proc.stderr.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        stderrChunks.push(value);
+
+        if (onProgress) {
+          partialLine += decoder.decode(value, { stream: true });
+          const lines = partialLine.split("\r");
+          partialLine = lines[lines.length - 1];
+          for (const line of lines.slice(0, -1)) {
+            const progress = parseFFmpegProgress(line, durationSeconds);
+            if (progress) onProgress(progress);
+          }
+        }
+      }
+    }
+
+    await proc.exited;
+
+    if (proc.exitCode !== 0) {
+      const stderr = stderrChunks.map((c) => decoder.decode(c)).join("");
+      const lastLines = stderr.split("\n").slice(-5).join("\n");
+      throw new PostProcessError(`FFmpeg failed (exit ${proc.exitCode}):\n${lastLines}`);
+    }
+  }
+
+  getBinary(): string {
+    return this.binary;
+  }
+}
+
+function parseFFmpegProgress(line: string, durationSeconds?: number): FFmpegProgress | null {
+  if (!line.includes("time=") && !line.includes("frame=")) return null;
+
+  const progress: FFmpegProgress = {};
+
+  const frameMatch = line.match(/frame=\s*(\d+)/);
+  if (frameMatch) progress.frame = parseInt(frameMatch[1], 10);
+
+  const fpsMatch = line.match(/fps=\s*([\d.]+)/);
+  if (fpsMatch) progress.fps = parseFloat(fpsMatch[1]);
+
+  const timeMatch = line.match(/time=\s*([\d:]+\.?\d*)/);
+  if (timeMatch) {
+    progress.time = timeMatch[1];
+    if (durationSeconds && durationSeconds > 0) {
+      const elapsed = parseTimeToSeconds(timeMatch[1]);
+      progress.percent = Math.min(100, (elapsed / durationSeconds) * 100);
+    }
+  }
+
+  const speedMatch = line.match(/speed=\s*([\d.]+x)/);
+  if (speedMatch) progress.speed = speedMatch[1];
+
+  return Object.keys(progress).length > 0 ? progress : null;
+}
+
+function parseTimeToSeconds(time: string): number {
+  const parts = time.split(":").map(parseFloat);
+  if (parts.length === 3) {
+    return (parts[0] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[2] ?? 0);
+  }
+  if (parts.length === 2) {
+    return (parts[0] ?? 0) * 60 + (parts[1] ?? 0);
+  }
+  return parts[0] ?? 0;
+}

package/src/postprocessors/merge.ts

@@ -0,0 +1,102 @@
+import { PostProcessor, PostProcessError } from "../core/types";
+import type { InfoDict, PostProcessResult } from "../core/types";
+import { FFmpegRunner } from "./ffmpeg";
+import { join, dirname, extname, basename } from "node:path";
+
+type MergeContainer = "mkv" | "mp4" | "webm";
+
+const COPY_COMPATIBLE: Record<MergeContainer, { video: string[]; audio: string[] }> = {
+  mkv: {
+    video: ["h264", "hevc", "vp8", "vp9", "av1", "mpeg4", "theora"],
+    audio: ["aac", "mp3", "opus", "vorbis", "flac", "ac3", "eac3", "truehd", "dts"],
+  },
+  mp4: {
+    video: ["h264", "hevc", "av1"],
+    audio: ["aac", "mp3", "ac3", "eac3"],
+  },
+  webm: {
+    video: ["vp8", "vp9", "av1"],
+    audio: ["opus", "vorbis"],
+  },
+};
+
+export interface MergeOptions {
+  outputContainer?: MergeContainer;
+  audioFilepath?: string;
+  ffmpegLocation?: string | null;
+  onProgress?: (percent: number) => void;
+}
+
+export class MergePostProcessor extends PostProcessor {
+  readonly _NAME = "Merger";
+
+  private opts: MergeOptions;
+
+  constructor(opts: MergeOptions = {}) {
+    super();
+    this.opts = opts;
+  }
+
+  async run(info: InfoDict, filepath: string): Promise<PostProcessResult> {
+    const audioPath = this.opts.audioFilepath;
+    if (!audioPath) {
+      return { filepath, info, files_to_delete: [] };
+    }
+
+    const container = this.opts.outputContainer ?? inferContainer(filepath);
+    const dir = dirname(filepath);
+    const stem = basename(filepath, extname(filepath));
+    const outputPath = join(dir, `${stem}.${container}`);
+
+    const runner = await FFmpegRunner.detect(this.opts.ffmpegLocation);
+
+    const vcodec = info.requested_formats?.[0]?.vcodec?.split(".")[0] ?? "";
+    const acodec = info.requested_formats?.[1]?.acodec?.split(".")[0] ?? "";
+
+    const compatible = COPY_COMPATIBLE[container];
+    const canCopyVideo = compatible.video.includes(vcodec);
+    const canCopyAudio = compatible.audio.includes(acodec);
+
+    const args: string[] = [
+      "-i", filepath,
+      "-i", audioPath,
+    ];
+
+    if (canCopyVideo && canCopyAudio) {
+      args.push("-c", "copy");
+    } else {
+      args.push(
+        "-c:v", canCopyVideo ? "copy" : "libx264",
+        "-c:a", canCopyAudio ? "copy" : "aac",
+      );
+    }
+
+    if (container === "mp4") {
+      args.push("-movflags", "+faststart");
+    }
+
+    args.push(outputPath);
+
+    await runner.run(
+      args,
+      this.opts.onProgress
+        ? (p) => { if (p.percent !== undefined) this.opts.onProgress!(p.percent); }
+        : undefined,
+      info.duration,
+    );
+
+    return {
+      filepath: outputPath,
+      info,
+      files_to_delete: outputPath !== filepath ? [filepath, audioPath] : [],
+    };
+  }
+}
+
+function inferContainer(filepath: string): MergeContainer {
+  const ext = extname(filepath).slice(1).toLowerCase();
+  if (ext === "mkv" || ext === "mp4" || ext === "webm") {
+    return ext as MergeContainer;
+  }
+  return "mkv";
+}