"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  FFmpeg: () => FFmpeg,
  changeFFmpegFlags: () => changeFFmpegFlags,
  createFFmpegArgs: () => createFFmpegArgs,
  version: () => version
});
module.exports = __toCommonJS(src_exports);

// src/FFmpeg.ts
var import_node_child_process = require("child_process");
var import_node_stream = require("stream");
var VERSION_REGEX = /version (.+) Copyright/im;
var validatePathParam = /* @__PURE__ */ __name((path, displayName) => {
  if (!path) throw new Error(`Failed to resolve ${displayName}`);
  return path;
}, "validatePathParam");
var _FFmpeg = class _FFmpeg extends import_node_stream.Duplex {
  /**
   * Create FFmpeg duplex stream
   * @param options Options to initialize ffmpeg
   * @example ```typescript
   * const ffmpeg = new FFmpeg({
   *   args: [
   *     '-analyzeduration', '0',
   *     '-loglevel', '0',
   *     '-f', 's16le',
   *     '-ar', '48000',
   *     '-ac', '2',
   *     '-af', 'bass=g=10,acompressor'
   *   ]
   * });
   *
   * const pcm = input.pipe(ffmpeg);
   *
   * pcm.pipe(fs.createWriteStream('./audio.pcm'));
   * ```
   */
  constructor(options = {}) {
    super(options);
    /**
     * Current FFmpeg process
     */
    __publicField(this, "process");
    this.process = _FFmpeg.spawn(options);
    const EVENTS = {
      readable: this._reader,
      data: this._reader,
      end: this._reader,
      unpipe: this._reader,
      finish: this._writer,
      drain: this._writer
    };
    this._readableState = this._reader._readableState;
    this._writableState = this._writer._writableState;
    this._copy(["write", "end"], this._writer);
    this._copy(["read", "setEncoding", "pipe", "unpipe"], this._reader);
    for (const method of [
      "on",
      "once",
      "removeListener",
      "removeAllListeners",
      "listeners"
    ]) {
      this[method] = (ev, fn) => (
        // @ts-expect-error
        EVENTS[ev] ? (
          // @ts-expect-error
          EVENTS[ev][method](ev, fn)
        ) : (
          // @ts-expect-error
          import_node_stream.Duplex.prototype[method].call(this, ev, fn)
        )
      );
    }
    const processError = /* @__PURE__ */ __name((error) => this.emit("error", error), "processError");
    this._reader.on("error", processError);
    this._writer.on("error", processError);
  }
  /**
   * Checks if FFmpeg is loaded.
   */
  static isLoaded() {
    return _FFmpeg.cached != null;
  }
  /**
   * Adds a new FFmpeg source.
   * @param source FFmpeg source
   */
  static addSource(source) {
    if (_FFmpeg.sources.some((s) => s.name === source.name)) return false;
    _FFmpeg.sources.push(source);
    return true;
  }
  /**
   * Removes a FFmpeg source.
   * @param source FFmpeg source
   */
  static removeSource(source) {
    const index = _FFmpeg.sources.findIndex((s) => s.name === source.name);
    if (index === -1) return false;
    _FFmpeg.sources.splice(index, 1);
    return true;
  }
  /**
   * Resolves FFmpeg path. Throws an error if it fails to resolve.
   * @param force if it should relocate the command
   */
  static resolve(force = false) {
    if (!force && _FFmpeg.cached) return _FFmpeg.cached;
    const errors = [];
    for (const source of _FFmpeg.sources) {
      try {
        let path;
        if (source.module) {
          const mod = require(source.name);
          path = validatePathParam(
            mod.default?.path || mod.path || mod,
            source.name
          );
        } else {
          path = source.name;
        }
        const result = (0, import_node_child_process.spawnSync)(path, ["-v"], { windowsHide: true });
        const resolved = {
          result: result.stdout.toString(),
          command: path,
          module: source.module,
          name: source.name,
          path,
          version: VERSION_REGEX.exec(result.stderr.toString())?.[1] ?? "unknown"
        };
        _FFmpeg.cached = resolved;
        errors.length = 0;
        return resolved;
      } catch (e) {
        const err = e && e instanceof Error ? e.message : `${e}`;
        const msg = `Failed to load ffmpeg using ${source.module ? `require('${source.name}')` : `spawn('${source.name}')`}. Error: ${err}`;
        errors.push(msg);
      }
    }
    throw new Error(`Could not load ffmpeg. Errors:
${errors.join("\n")}`);
  }
  /**
   * Resolves FFmpeg path safely. Returns null if it fails to resolve.
   * @param force if it should relocate the command
   */
  static resolveSafe(force = false) {
    try {
      return _FFmpeg.resolve(force);
    } catch {
      return null;
    }
  }
  /**
   * Spawns ffmpeg process
   * @param options Spawn options
   */
  static spawn({ args = [], shell = false } = {}) {
    if (!args.includes("-i")) args.unshift("-i", "-");
    return (0, import_node_child_process.spawn)(_FFmpeg.resolve().command, args.concat(["pipe:1"]), {
      windowsHide: true,
      shell
    });
  }
  get _reader() {
    return this.process.stdout;
  }
  get _writer() {
    return this.process.stdin;
  }
  _copy(methods, target) {
    for (const method of methods) {
      this[method] = target[method].bind(target);
    }
  }
  _destroy(err, cb) {
    this._cleanup();
    if (cb) return cb(err);
  }
  _final(cb) {
    this._cleanup();
    cb();
  }
  _cleanup() {
    if (this.process) {
      this.once("error", () => {
      });
      this.process.kill("SIGKILL");
      this.process = null;
    }
  }
};
__name(_FFmpeg, "FFmpeg");
/**
 * Cached FFmpeg source.
 */
__publicField(_FFmpeg, "cached", null);
/**
 * Supported FFmpeg sources.
 */
__publicField(_FFmpeg, "sources", [
  // paths
  { name: "ffmpeg", module: false },
  { name: "./ffmpeg", module: false },
  { name: "avconv", module: false },
  { name: "./avconv", module: false },
  // modules
  { name: "ffmpeg-static", module: true },
  { name: "@ffmpeg-installer/ffmpeg", module: true },
  { name: "@node-ffmpeg/node-ffmpeg-installer", module: true },
  { name: "ffmpeg-binaries", module: true }
]);
var FFmpeg = _FFmpeg;

// src/common.ts
function changeFFmpegFlags(oldFlags, newFlags) {
  const updatedFlags = [...oldFlags];
  for (let i = 0; i < newFlags.length; i++) {
    const key = newFlags[i];
    const value = newFlags[i + 1];
    const oldIndex = updatedFlags.indexOf(key);
    if (oldIndex !== -1) {
      if (value && !value.startsWith("-")) {
        updatedFlags[oldIndex + 1] = value;
        i++;
      } else {
        updatedFlags.splice(oldIndex, 1);
      }
    } else {
      if (value && !value.startsWith("-")) {
        updatedFlags.push(key, value);
        i++;
      } else {
        updatedFlags.push(key);
      }
    }
  }
  return updatedFlags;
}
__name(changeFFmpegFlags, "changeFFmpegFlags");

// src/version.ts
var version = (
  /* @__MACRO__ getVersion */
  "7.2.0"
);

// src/index.ts
var createFFmpegArgs = /* @__PURE__ */ __name((input, post) => {
  const args = [];
  for (const [key, value] of Object.entries(input)) {
    if (value == null) continue;
    args.push(`-${key}`, String(value));
  }
  if (post) {
    Array.isArray(post) ? args.push(...post) : args.push(post);
  }
  return args;
}, "createFFmpegArgs");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  FFmpeg,
  changeFFmpegFlags,
  createFFmpegArgs,
  version
});
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/FFmpeg.ts", "../src/common.ts", "../src/version.ts"],
  "sourcesContent": ["export * from './FFmpeg';\n\nexport type ArgPrimitive = string | number | null;\n\n/**\n * Create FFmpeg arguments from an object.\n * @param input The input object.\n * @param post Additional arguments to append.\n * @returns The FFmpeg arguments.\n * @example createFFmpegArgs({ i: 'input.mp3', af: ['bass=g=10','acompressor'] }, './out.mp3');\n * // => ['-i', 'input.mp3', '-af', 'bass=g=10,acompressor', './out.mp3']\n */\nexport const createFFmpegArgs = (\ninput: Record<string, ArgPrimitive | ArgPrimitive[]>,\npost?: string | string[])\n: string[] => {\n  const args = [];\n\n  for (const [key, value] of Object.entries(input)) {\n    if (value == null) continue;\n    args.push(`-${key}`, String(value));\n  }\n\n  if (post) {\n    Array.isArray(post) ? args.push(...post) : args.push(post);\n  }\n\n  return args;\n};\n\nexport * from './common';\nexport { version } from './version';", "import {\n  ChildProcessWithoutNullStreams,\n  spawn,\n  spawnSync } from\n'node:child_process';\nimport { Duplex, DuplexOptions } from 'node:stream';\nimport { FFmpegCallback, FFmpegSource, ResolvedFFmpegSource } from './common';\n\nexport interface FFmpegOptions extends DuplexOptions {\n  args?: string[];\n  shell?: boolean;\n}\n\nconst VERSION_REGEX = /version (.+) Copyright/im;\n\nconst validatePathParam = (path: string, displayName: string) => {\n  if (!path) throw new Error(`Failed to resolve ${displayName}`);\n  return path;\n};\n\nexport class FFmpeg extends Duplex {\n  /**\n   * Cached FFmpeg source.\n   */\n  private static cached: ResolvedFFmpegSource | null = null;\n  /**\n   * Supported FFmpeg sources.\n   */\n  public static sources: FFmpegSource[] = [\n  // paths\n  { name: 'ffmpeg', module: false },\n  { name: './ffmpeg', module: false },\n  { name: 'avconv', module: false },\n  { name: './avconv', module: false },\n  // modules\n  { name: 'ffmpeg-static', module: true },\n  { name: '@ffmpeg-installer/ffmpeg', module: true },\n  { name: '@node-ffmpeg/node-ffmpeg-installer', module: true },\n  { name: 'ffmpeg-binaries', module: true }];\n\n\n  /**\n   * Checks if FFmpeg is loaded.\n   */\n  public static isLoaded() {\n    return FFmpeg.cached != null;\n  }\n\n  /**\n   * Adds a new FFmpeg source.\n   * @param source FFmpeg source\n   */\n  public static addSource(source: FFmpegSource) {\n    if (FFmpeg.sources.some((s) => s.name === source.name)) return false;\n    FFmpeg.sources.push(source);\n    return true;\n  }\n\n  /**\n   * Removes a FFmpeg source.\n   * @param source FFmpeg source\n   */\n  public static removeSource(source: FFmpegSource) {\n    const index = FFmpeg.sources.findIndex((s) => s.name === source.name);\n    if (index === -1) return false;\n    FFmpeg.sources.splice(index, 1);\n    return true;\n  }\n\n  /**\n   * Resolves FFmpeg path. Throws an error if it fails to resolve.\n   * @param force if it should relocate the command\n   */\n  public static resolve(force = false) {\n    if (!force && FFmpeg.cached) return FFmpeg.cached;\n\n    const errors: string[] = [];\n\n    for (const source of FFmpeg.sources) {\n      try {\n        let path: string;\n\n        if (source.module) {\n          // eslint-disable-next-line @typescript-eslint/no-var-requires\n          const mod = require(source.name);\n          path = validatePathParam(\n            mod.default?.path || mod.path || mod,\n            source.name\n          );\n        } else {\n          path = source.name;\n        }\n\n        const result = spawnSync(path, ['-v'], { windowsHide: true });\n\n        const resolved: ResolvedFFmpegSource = {\n          result: result.stdout.toString(),\n          command: path,\n          module: source.module,\n          name: source.name,\n          path,\n          version:\n          VERSION_REGEX.exec(result.stderr.toString())?.[1] ?? 'unknown'\n        };\n\n        FFmpeg.cached = resolved;\n\n        errors.length = 0;\n\n        return resolved;\n      } catch (e) {\n        const err = e && e instanceof Error ? e.message : `${e}`;\n        const msg = `Failed to load ffmpeg using ${\n        source.module ?\n        `require('${source.name}')` :\n        `spawn('${source.name}')`}. Error: ${\n        err}`;\n\n        errors.push(msg);\n      }\n    }\n\n    throw new Error(`Could not load ffmpeg. Errors:\\n${errors.join('\\n')}`);\n  }\n\n  /**\n   * Resolves FFmpeg path safely. Returns null if it fails to resolve.\n   * @param force if it should relocate the command\n   */\n  public static resolveSafe(force = false) {\n    try {\n      return FFmpeg.resolve(force);\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Spawns ffmpeg process\n   * @param options Spawn options\n   */\n  public static spawn({ args = [] as string[], shell = false } = {}) {\n    if (!args.includes('-i')) args.unshift('-i', '-');\n    return spawn(FFmpeg.resolve().command, args.concat(['pipe:1']), {\n      windowsHide: true,\n      shell\n    });\n  }\n\n  /**\n   * Current FFmpeg process\n   */\n  public process: ChildProcessWithoutNullStreams;\n\n  /**\n   * Create FFmpeg duplex stream\n   * @param options Options to initialize ffmpeg\n   * @example ```typescript\n   * const ffmpeg = new FFmpeg({\n   *   args: [\n   *     '-analyzeduration', '0',\n   *     '-loglevel', '0',\n   *     '-f', 's16le',\n   *     '-ar', '48000',\n   *     '-ac', '2',\n   *     '-af', 'bass=g=10,acompressor'\n   *   ]\n   * });\n   *\n   * const pcm = input.pipe(ffmpeg);\n   *\n   * pcm.pipe(fs.createWriteStream('./audio.pcm'));\n   * ```\n   */\n  public constructor(options: FFmpegOptions = {}) {\n    super(options);\n\n    this.process = FFmpeg.spawn(options);\n\n    const EVENTS = {\n      readable: this._reader,\n      data: this._reader,\n      end: this._reader,\n      unpipe: this._reader,\n      finish: this._writer,\n      drain: this._writer\n    } as const;\n\n    // @ts-expect-error\n    this._readableState = this._reader._readableState;\n    // @ts-expect-error\n    this._writableState = this._writer._writableState;\n\n    this._copy(['write', 'end'], this._writer);\n    this._copy(['read', 'setEncoding', 'pipe', 'unpipe'], this._reader);\n\n    for (const method of [\n    'on',\n    'once',\n    'removeListener',\n    'removeAllListeners',\n    'listeners'] as\n    const) {\n      // @ts-expect-error\n      this[method] = (ev, fn) =>\n      // @ts-expect-error\n      EVENTS[ev] ?\n      // @ts-expect-error\n      EVENTS[ev][method](ev, fn) :\n      // @ts-expect-error\n      Duplex.prototype[method].call(this, ev, fn);\n    }\n\n    const processError = (error: Error) => this.emit('error', error);\n\n    this._reader.on('error', processError);\n    this._writer.on('error', processError);\n  }\n\n  get _reader() {\n    return this.process!.stdout;\n  }\n  get _writer() {\n    return this.process!.stdin;\n  }\n\n  private _copy(methods: string[], target: unknown) {\n    for (const method of methods) {\n      // @ts-expect-error\n      this[method] = target[method].bind(target);\n    }\n  }\n\n  public _destroy(err: Error | null, cb: FFmpegCallback<[Error | null]>) {\n    this._cleanup();\n    if (cb) return cb(err);\n  }\n\n  public _final(cb: FFmpegCallback<[]>) {\n    this._cleanup();\n    cb();\n  }\n\n  private _cleanup() {\n    if (this.process) {\n      this.once('error', () => {\n\n        //\n      });this.process.kill('SIGKILL');\n      this.process = null as unknown as ChildProcessWithoutNullStreams;\n    }\n  }\n}", "export type FFmpegLib =\n'ffmpeg' |\n'./ffmpeg' |\n'avconv' |\n'./avconv' |\n'ffmpeg-static' |\n'@ffmpeg-installer/ffmpeg' |\n'@node-ffmpeg/node-ffmpeg-installer' |\n'ffmpeg-binaries';\n\nexport type FFmpegCallback<Args extends Array<unknown>> = (\n...args: Args)\n=> unknown;\n\n/**\n * FFmpeg source configuration\n */\nexport interface FFmpegSource {\n  /** Name or path of the FFmpeg executable */\n  name: FFmpegLib;\n  /** Whether this source is a Node.js module */\n  module: boolean;\n}\n\nexport interface ResolvedFFmpegSource extends FFmpegSource {\n  path: string;\n  version: string;\n  command: string;\n  result: string;\n}\n\n/**\n * Compares and updates FFmpeg flags as needed\n * @param oldFlags The old flags\n * @param newFlags The new flags\n * @returns The updated flags\n */\nexport function changeFFmpegFlags(oldFlags: string[], newFlags: string[]) {\n  const updatedFlags = [...oldFlags];\n\n  for (let i = 0; i < newFlags.length; i++) {\n    const key = newFlags[i];\n    const value = newFlags[i + 1];\n\n    const oldIndex = updatedFlags.indexOf(key);\n\n    if (oldIndex !== -1) {\n      if (value && !value.startsWith('-')) {\n        updatedFlags[oldIndex + 1] = value;\n        i++;\n      } else {\n        updatedFlags.splice(oldIndex, 1);\n      }\n    } else {\n      if (value && !value.startsWith('-')) {\n        updatedFlags.push(key, value);\n        i++;\n      } else {\n        updatedFlags.push(key);\n      }\n    }\n  }\n\n  return updatedFlags;\n}", "\n\n\n\n\n\nexport const version = /* @__MACRO__ getVersion */\"7.2.0\";"],
  "mappings": "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",
  "names": []
}
