peasy-audio-js 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peasy Tools
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,263 @@
+# peasy-audio-js
+
+[![npm](https://img.shields.io/npm/v/peasy-audio-js)](https://www.npmjs.com/package/peasy-audio-js)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+Audio processing library for Node.js -- convert between 6 formats (MP3, WAV, OGG, FLAC, AAC, M4A), trim segments, merge files, normalize volume, apply fade effects, adjust speed, and generate silence. FFmpeg-powered, TypeScript-first with full type safety.
+
+Built from [PeasyAudio](https://peasyaudio.com), a free online audio toolkit with 10 browser-based tools for converting, trimming, merging, normalizing, and analyzing audio files.
+
+> **Try the interactive tools at [peasyaudio.com](https://peasyaudio.com)** -- audio conversion, trimming, merging, normalization, and analysis
+
+<p align="center">
+  <img src="demo.gif" alt="peasy-audio-js demo — audio info, format conversion, and volume operations in Node.js" width="800">
+</p>
+
+## Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [What You Can Do](#what-you-can-do)
+  - [Audio Info & Metadata](#audio-info--metadata)
+  - [Format Conversion](#format-conversion)
+  - [Trimming & Merging](#trimming--merging)
+  - [Volume & Normalization](#volume--normalization)
+  - [Audio Effects](#audio-effects)
+- [TypeScript Types](#typescript-types)
+- [API Reference](#api-reference)
+- [Also Available for Python](#also-available-for-python)
+- [Peasy Developer Tools](#peasy-developer-tools)
+- [License](#license)
+
+## Prerequisites
+
+peasy-audio-js uses FFmpeg under the hood. Install it before using this library:
+
+| Platform | Command |
+|----------|---------|
+| **macOS** | `brew install ffmpeg` |
+| **Ubuntu/Debian** | `sudo apt install ffmpeg` |
+| **Fedora/RHEL** | `sudo dnf install ffmpeg-free` |
+| **Windows** | `choco install ffmpeg` |
+
+## Install
+
+```bash
+npm install peasy-audio-js
+```
+
+## Quick Start
+
+```typescript
+import { info, convert, trim, merge, normalize } from "peasy-audio-js";
+
+// Get audio file metadata
+const metadata = await info("song.mp3");
+console.log(metadata.duration, metadata.sampleRate); // 240.5 44100
+
+// Convert MP3 to WAV
+const wavPath = await convert("song.mp3", { format: "wav" });
+
+// Trim to 30-second clip
+const clip = await trim("song.mp3", { start: 10, duration: 30 });
+
+// Merge multiple audio files
+const combined = await merge(["intro.mp3", "main.mp3", "outro.mp3"]);
+
+// Normalize volume to consistent levels
+const normalized = await normalize("quiet-recording.mp3");
+```
+
+## What You Can Do
+
+### Audio Info & Metadata
+
+Every audio file has metadata -- duration, sample rate, channels, bitrate, and codec information. The `info()` function uses FFprobe to extract this data without decoding the entire file, making it fast even for large files.
+
+```typescript
+import { info } from "peasy-audio-js";
+
+// Extract audio metadata using FFprobe
+const meta = await info("podcast.mp3");
+console.log(meta.duration);   // 3600.5 (seconds)
+console.log(meta.sampleRate); // 44100 (Hz)
+console.log(meta.channels);   // 2 (stereo)
+console.log(meta.bitrate);    // 320000 (bits/sec)
+console.log(meta.format);     // "mp3"
+```
+
+Learn more: [Peasy Audio Tools](https://peasyaudio.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Format Conversion
+
+Audio format conversion transforms audio data between container formats and codecs. Common conversions include MP3 to WAV (for editing), WAV to FLAC (lossless archiving), and any format to AAC/M4A (Apple ecosystem compatibility).
+
+| Format | Extension | Use Case |
+|--------|-----------|----------|
+| MP3 | `.mp3` | Universal playback, streaming |
+| WAV | `.wav` | Editing, uncompressed quality |
+| OGG | `.ogg` | Open-source, web audio |
+| FLAC | `.flac` | Lossless archiving |
+| AAC | `.aac` | Apple ecosystem, efficient |
+| M4A | `.m4a` | iTunes, Apple Music |
+
+```typescript
+import { convert } from "peasy-audio-js";
+
+// Convert MP3 to WAV for editing
+const wav = await convert("music.mp3", { format: "wav" });
+
+// Convert to FLAC with custom sample rate
+const flac = await convert("music.mp3", {
+  format: "flac",
+  sampleRate: 48000,
+});
+
+// Downmix stereo to mono
+const mono = await convert("stereo.wav", {
+  format: "mp3",
+  channels: 1,
+  bitrate: "128k",
+});
+```
+
+Learn more: [Peasy Audio Tools](https://peasyaudio.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Trimming & Merging
+
+Audio trimming extracts a segment by specifying start time and duration or end time. Merging concatenates multiple audio files sequentially into a single output file.
+
+```typescript
+import { trim, merge } from "peasy-audio-js";
+
+// Extract a 30-second segment starting at 1 minute
+const clip = await trim("podcast.mp3", { start: 60, duration: 30 });
+
+// Trim from start to end time
+const intro = await trim("song.mp3", { start: 0, end: 15 });
+
+// Merge multiple files into one
+const combined = await merge([
+  "chapter1.mp3",
+  "chapter2.mp3",
+  "chapter3.mp3",
+]);
+```
+
+Learn more: [Peasy Audio Tools](https://peasyaudio.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Volume & Normalization
+
+Audio normalization adjusts the overall volume level to a target loudness, measured in dBFS (decibels relative to full scale). The EBU R128 standard defines target loudness at -23 LUFS for broadcast, while streaming platforms typically target -14 LUFS.
+
+```typescript
+import { normalize, changeVolume } from "peasy-audio-js";
+
+// Normalize volume using FFmpeg loudnorm filter
+const normalized = await normalize("quiet-recording.mp3");
+
+// Increase volume by 6dB (roughly doubles perceived loudness)
+const louder = await changeVolume("track.mp3", { change: 6 });
+
+// Decrease volume by 3dB
+const softer = await changeVolume("loud-track.mp3", { change: -3 });
+```
+
+Learn more: [Peasy Audio Tools](https://peasyaudio.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Audio Effects
+
+Apply fade effects, speed changes, reversal, and generate silence programmatically. These operations use FFmpeg audio filters for sample-accurate processing.
+
+```typescript
+import { fade, speed, reverseAudio, silence } from "peasy-audio-js";
+
+// Apply 3-second fade in and 5-second fade out
+const faded = await fade("song.mp3", { fadeIn: 3, fadeOut: 5 });
+
+// Double the playback speed (pitch shifts)
+const fast = await speed("podcast.mp3", { factor: 2.0 });
+
+// Slow down to 75% speed
+const slow = await speed("audiobook.mp3", { factor: 0.75 });
+
+// Reverse audio
+const reversed = await reverseAudio("sample.mp3");
+
+// Generate 5 seconds of silence as WAV
+const gap = await silence({ duration: 5, format: "wav", sampleRate: 44100 });
+```
+
+Learn more: [Peasy Audio Tools](https://peasyaudio.com) · [Glossary](https://peasytools.com/glossary/)
+
+## TypeScript Types
+
+```typescript
+import type {
+  AudioFormat,
+  AudioInfo,
+  ConvertOptions,
+  TrimOptions,
+  FadeOptions,
+  SpeedOptions,
+  VolumeOptions,
+  SilenceOptions,
+} from "peasy-audio-js";
+
+// AudioFormat — "mp3" | "wav" | "ogg" | "flac" | "aac" | "m4a"
+const format: AudioFormat = "mp3";
+
+// AudioInfo — metadata from info()
+const meta: AudioInfo = {
+  duration: 240.5,
+  format: "mp3",
+  sampleRate: 44100,
+  channels: 2,
+  bitrate: 320000,
+  size: 9_600_000,
+};
+```
+
+## API Reference
+
+| Function | Description |
+|----------|-------------|
+| `info(input)` | Get audio metadata (duration, format, sample rate, channels, bitrate) |
+| `convert(input, options)` | Convert between audio formats (MP3, WAV, OGG, FLAC, AAC, M4A) |
+| `trim(input, options)` | Extract a segment by start/end/duration |
+| `merge(inputs)` | Concatenate multiple audio files sequentially |
+| `normalize(input)` | Normalize volume using EBU R128 loudnorm filter |
+| `changeVolume(input, options)` | Adjust volume by dB amount |
+| `fade(input, options)` | Apply fade in/out effects |
+| `speed(input, options)` | Change playback speed (0.5x to 4.0x) |
+| `reverseAudio(input)` | Reverse audio playback |
+| `silence(options)` | Generate silence of specified duration |
+
+## Also Available for Python
+
+```bash
+pip install peasy-audio
+```
+
+The Python package provides the same 12 audio operations with CLI and pydub engine. See [peasy-audio on PyPI](https://pypi.org/project/peasy-audio/).
+
+## Peasy Developer Tools
+
+| Package | PyPI | npm | Description |
+|---------|------|-----|-------------|
+| peasy-pdf | [PyPI](https://pypi.org/project/peasy-pdf/) | [npm](https://www.npmjs.com/package/peasy-pdf-js) | PDF merge, split, compress, rotate, watermark |
+| peasy-image | [PyPI](https://pypi.org/project/peasy-image/) | [npm](https://www.npmjs.com/package/peasy-image-js) | Image resize, crop, compress, convert, watermark |
+| peasytext | [PyPI](https://pypi.org/project/peasytext/) | [npm](https://www.npmjs.com/package/peasytext-js) | Text analysis, case conversion, slugs, word count |
+| peasy-css | [PyPI](https://pypi.org/project/peasy-css/) | [npm](https://www.npmjs.com/package/peasy-css-js) | CSS gradients, shadows, flexbox, grid generators |
+| peasy-compress | [PyPI](https://pypi.org/project/peasy-compress/) | [npm](https://www.npmjs.com/package/peasy-compress-js) | ZIP, gzip, brotli, deflate compression |
+| peasy-document | [PyPI](https://pypi.org/project/peasy-document/) | [npm](https://www.npmjs.com/package/peasy-document-js) | Markdown, HTML, CSV, JSON, YAML conversion |
+| **peasy-audio** | [PyPI](https://pypi.org/project/peasy-audio/) | **[npm](https://www.npmjs.com/package/peasy-audio-js)** | **Audio convert, trim, merge, normalize, effects** |
+| peasy-video | [PyPI](https://pypi.org/project/peasy-video/) | [npm](https://www.npmjs.com/package/peasy-video-js) | Video trim, resize, thumbnails, GIF conversion |
+
+Part of the [Peasy](https://peasytools.com) developer tools ecosystem.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,238 @@
+/**
+ * peasy-audio-js — Audio processing types.
+ *
+ * @packageDocumentation
+ */
+/** Supported audio formats. */
+type AudioFormat = "mp3" | "wav" | "ogg" | "flac" | "aac" | "m4a";
+/** Audio file metadata. */
+interface AudioInfo {
+    /** Duration in seconds. */
+    duration: number;
+    /** Container format name (e.g. "mp3", "wav"). */
+    format: string;
+    /** Sample rate in Hz (e.g. 44100, 48000). */
+    sampleRate: number;
+    /** Number of audio channels (1 = mono, 2 = stereo). */
+    channels: number;
+    /** Bitrate in bits per second. */
+    bitrate: number;
+    /** File size in bytes. */
+    size: number;
+}
+/** Options for audio conversion. */
+interface ConvertOptions {
+    /** Target audio format. */
+    format: AudioFormat;
+    /** Target bitrate (e.g. "128k", "320k"). */
+    bitrate?: string;
+    /** Target sample rate in Hz (e.g. 44100, 48000). */
+    sampleRate?: number;
+    /** Number of output channels (1 = mono, 2 = stereo). */
+    channels?: number;
+}
+/** Options for audio trimming. */
+interface TrimOptions {
+    /** Start time in seconds. */
+    start?: number;
+    /** End time in seconds. */
+    end?: number;
+    /** Duration in seconds (alternative to end). */
+    duration?: number;
+}
+/** Options for fade effects. */
+interface FadeOptions {
+    /** Fade-in duration in seconds. */
+    fadeIn?: number;
+    /** Fade-out duration in seconds. */
+    fadeOut?: number;
+}
+/** Options for speed adjustment. */
+interface SpeedOptions {
+    /** Speed factor (e.g. 0.5 = half speed, 2.0 = double speed). */
+    factor: number;
+}
+/** Options for volume adjustment. */
+interface VolumeOptions {
+    /** Volume change in dB (e.g., 3 for +3dB, -5 for -5dB). */
+    change: number;
+}
+/** Options for silence generation. */
+interface SilenceOptions {
+    /** Duration of silence in seconds. */
+    duration: number;
+    /** Output format (default: "wav"). */
+    format?: AudioFormat;
+    /** Sample rate in Hz (default: 44100). */
+    sampleRate?: number;
+}
+
+/**
+ * peasy-audio-js — Audio processing engine.
+ *
+ * All operations use fluent-ffmpeg to invoke FFmpeg for audio processing.
+ * Functions take file paths and return Promises that resolve to output paths.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Get metadata for an audio file using ffprobe.
+ *
+ * @param input - Path to the audio file
+ * @returns Audio metadata including duration, format, sample rate, channels
+ *
+ * @example
+ * ```typescript
+ * const metadata = await info("song.mp3");
+ * console.log(metadata.duration);   // 180.5
+ * console.log(metadata.sampleRate); // 44100
+ * ```
+ */
+declare function info(input: string): Promise<AudioInfo>;
+/**
+ * Convert an audio file to a different format.
+ *
+ * @param input - Path to the source audio file
+ * @param options - Conversion options (format, bitrate, sampleRate, channels)
+ * @returns Path to the converted output file
+ *
+ * @example
+ * ```typescript
+ * // Convert MP3 to WAV
+ * const wav = await convert("song.mp3", { format: "wav" });
+ *
+ * // Convert with specific bitrate and sample rate
+ * const mp3 = await convert("song.wav", {
+ *   format: "mp3",
+ *   bitrate: "320k",
+ *   sampleRate: 48000,
+ * });
+ * ```
+ */
+declare function convert(input: string, options: ConvertOptions): Promise<string>;
+/**
+ * Trim an audio file to a specific time range.
+ *
+ * @param input - Path to the source audio file
+ * @param options - Trim options (start, end, duration)
+ * @returns Path to the trimmed output file
+ *
+ * @example
+ * ```typescript
+ * // Trim from 10s to 30s
+ * const trimmed = await trim("song.mp3", { start: 10, end: 30 });
+ *
+ * // Trim first 5 seconds
+ * const intro = await trim("song.mp3", { start: 0, duration: 5 });
+ * ```
+ */
+declare function trim(input: string, options: TrimOptions): Promise<string>;
+/**
+ * Merge multiple audio files into a single file.
+ *
+ * Files are concatenated in the order provided. All files should have
+ * compatible formats (same sample rate and channels for best results).
+ *
+ * @param inputs - Array of paths to audio files to merge
+ * @returns Path to the merged output file
+ *
+ * @example
+ * ```typescript
+ * const merged = await merge(["intro.mp3", "main.mp3", "outro.mp3"]);
+ * ```
+ */
+declare function merge(inputs: string[]): Promise<string>;
+/**
+ * Normalize audio loudness using the EBU R128 loudnorm filter.
+ *
+ * @param input - Path to the source audio file
+ * @returns Path to the normalized output file
+ *
+ * @example
+ * ```typescript
+ * const normalized = await normalize("quiet-recording.mp3");
+ * ```
+ */
+declare function normalize(input: string): Promise<string>;
+/**
+ * Adjust the volume of an audio file.
+ *
+ * @param input - Path to the source audio file
+ * @param options - Volume options with change in dB
+ * @returns Path to the volume-adjusted output file
+ *
+ * @example
+ * ```typescript
+ * // Increase volume by 3 dB
+ * const louder = await changeVolume("song.mp3", { change: 3 });
+ *
+ * // Decrease volume by 5 dB
+ * const quieter = await changeVolume("song.mp3", { change: -5 });
+ * ```
+ */
+declare function changeVolume(input: string, options: VolumeOptions): Promise<string>;
+/**
+ * Apply fade-in and/or fade-out effects to an audio file.
+ *
+ * @param input - Path to the source audio file
+ * @param options - Fade options with fadeIn and/or fadeOut durations in seconds
+ * @returns Path to the output file with fade effects
+ *
+ * @example
+ * ```typescript
+ * // Fade in over 2 seconds and fade out over 3 seconds
+ * const faded = await fade("song.mp3", { fadeIn: 2, fadeOut: 3 });
+ * ```
+ */
+declare function fade(input: string, options: FadeOptions): Promise<string>;
+/**
+ * Change the playback speed of an audio file.
+ *
+ * Uses the atempo filter which supports factors between 0.5 and 100.0.
+ * For factors outside the 0.5-2.0 range, multiple atempo filters are chained.
+ *
+ * @param input - Path to the source audio file
+ * @param options - Speed options with factor (e.g. 0.5 = half, 2.0 = double)
+ * @returns Path to the speed-adjusted output file
+ *
+ * @example
+ * ```typescript
+ * // Double speed
+ * const fast = await speed("podcast.mp3", { factor: 2.0 });
+ *
+ * // Half speed
+ * const slow = await speed("podcast.mp3", { factor: 0.5 });
+ * ```
+ */
+declare function speed(input: string, options: SpeedOptions): Promise<string>;
+/**
+ * Reverse an audio file.
+ *
+ * @param input - Path to the source audio file
+ * @returns Path to the reversed output file
+ *
+ * @example
+ * ```typescript
+ * const reversed = await reverseAudio("message.mp3");
+ * ```
+ */
+declare function reverseAudio(input: string): Promise<string>;
+/**
+ * Generate a silent audio file.
+ *
+ * @param options - Silence options including duration, format, and sample rate
+ * @returns Path to the generated silence file
+ *
+ * @example
+ * ```typescript
+ * // Generate 5 seconds of silence as WAV
+ * const gap = await silence({ duration: 5 });
+ *
+ * // Generate 2 seconds of silence as MP3 at 48kHz
+ * const gap48 = await silence({ duration: 2, format: "mp3", sampleRate: 48000 });
+ * ```
+ */
+declare function silence(options: SilenceOptions): Promise<string>;
+
+export { type AudioFormat, type AudioInfo, type ConvertOptions, type FadeOptions, type SilenceOptions, type SpeedOptions, type TrimOptions, type VolumeOptions, changeVolume, convert, fade, info, merge, normalize, reverseAudio, silence, speed, trim };

package/dist/index.js

@@ -0,0 +1,150 @@
+// src/engine.ts
+import ffmpeg from "fluent-ffmpeg";
+import { tmpdir } from "os";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { extname } from "path";
+function tmpOutput(ext) {
+  return join(tmpdir(), `peasy-audio-${randomUUID()}.${ext}`);
+}
+function run(command, output) {
+  return new Promise((resolve, reject) => {
+    command.output(output).on("end", () => resolve(output)).on("error", (err) => reject(err)).run();
+  });
+}
+function getExt(filePath) {
+  return extname(filePath).slice(1) || "wav";
+}
+function info(input) {
+  return new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(input, (err, metadata) => {
+      if (err) return reject(err);
+      const audio = metadata.streams.find((s) => s.codec_type === "audio");
+      resolve({
+        duration: metadata.format.duration ?? 0,
+        format: metadata.format.format_name ?? "unknown",
+        sampleRate: audio?.sample_rate ? Number(audio.sample_rate) : 0,
+        channels: audio?.channels ?? 0,
+        bitrate: metadata.format.bit_rate ? Number(metadata.format.bit_rate) : 0,
+        size: metadata.format.size ?? 0
+      });
+    });
+  });
+}
+function convert(input, options) {
+  const output = tmpOutput(options.format);
+  const cmd = ffmpeg(input);
+  if (options.bitrate) {
+    cmd.audioBitrate(options.bitrate);
+  }
+  if (options.sampleRate) {
+    cmd.audioFrequency(options.sampleRate);
+  }
+  if (options.channels) {
+    cmd.audioChannels(options.channels);
+  }
+  return run(cmd, output);
+}
+function trim(input, options) {
+  const ext = getExt(input);
+  const output = tmpOutput(ext);
+  const cmd = ffmpeg(input);
+  if (options.start !== void 0) {
+    cmd.setStartTime(options.start);
+  }
+  if (options.duration !== void 0) {
+    cmd.setDuration(options.duration);
+  } else if (options.end !== void 0 && options.start !== void 0) {
+    cmd.setDuration(options.end - options.start);
+  } else if (options.end !== void 0) {
+    cmd.setDuration(options.end);
+  }
+  return run(cmd, output);
+}
+function merge(inputs) {
+  if (inputs.length === 0) {
+    return Promise.reject(new Error("At least one input file is required"));
+  }
+  const ext = getExt(inputs[0]);
+  const output = tmpOutput(ext);
+  return new Promise((resolve, reject) => {
+    const cmd = ffmpeg();
+    for (const input of inputs) {
+      cmd.input(input);
+    }
+    cmd.on("end", () => resolve(output)).on("error", (err) => reject(err)).mergeToFile(output, tmpdir());
+  });
+}
+function normalize(input) {
+  const ext = getExt(input);
+  const output = tmpOutput(ext);
+  const cmd = ffmpeg(input).audioFilters("loudnorm");
+  return run(cmd, output);
+}
+function changeVolume(input, options) {
+  const ext = getExt(input);
+  const output = tmpOutput(ext);
+  const cmd = ffmpeg(input).audioFilters(`volume=${options.change}dB`);
+  return run(cmd, output);
+}
+async function fade(input, options) {
+  const ext = getExt(input);
+  const output = tmpOutput(ext);
+  const filters = [];
+  if (options.fadeIn !== void 0 && options.fadeIn > 0) {
+    filters.push(`afade=t=in:st=0:d=${options.fadeIn}`);
+  }
+  if (options.fadeOut !== void 0 && options.fadeOut > 0) {
+    const metadata = await info(input);
+    const fadeStart = metadata.duration - options.fadeOut;
+    filters.push(`afade=t=out:st=${fadeStart}:d=${options.fadeOut}`);
+  }
+  const cmd = ffmpeg(input);
+  if (filters.length > 0) {
+    cmd.audioFilters(filters);
+  }
+  return run(cmd, output);
+}
+function speed(input, options) {
+  const ext = getExt(input);
+  const output = tmpOutput(ext);
+  const filters = [];
+  let remaining = options.factor;
+  while (remaining > 2) {
+    filters.push("atempo=2.0");
+    remaining /= 2;
+  }
+  while (remaining < 0.5) {
+    filters.push("atempo=0.5");
+    remaining /= 0.5;
+  }
+  filters.push(`atempo=${remaining}`);
+  const cmd = ffmpeg(input).audioFilters(filters);
+  return run(cmd, output);
+}
+function reverseAudio(input) {
+  const ext = getExt(input);
+  const output = tmpOutput(ext);
+  const cmd = ffmpeg(input).audioFilters("areverse");
+  return run(cmd, output);
+}
+function silence(options) {
+  const format = options.format ?? "wav";
+  const sampleRate = options.sampleRate ?? 44100;
+  const output = tmpOutput(format);
+  return new Promise((resolve, reject) => {
+    ffmpeg().input("anullsrc").inputFormat("lavfi").inputOptions([`-channel_layout=stereo`, `-sample_rate=${sampleRate}`]).duration(options.duration).output(output).on("end", () => resolve(output)).on("error", (err) => reject(err)).run();
+  });
+}
+export {
+  changeVolume,
+  convert,
+  fade,
+  info,
+  merge,
+  normalize,
+  reverseAudio,
+  silence,
+  speed,
+  trim
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "peasy-audio-js",
+  "version": "0.1.1",
+  "description": "Audio processing library for Node.js — convert, trim, merge, normalize, fade, speed. FFmpeg-powered, TypeScript-first.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "audio",
+    "mp3",
+    "wav",
+    "ffmpeg",
+    "convert",
+    "trim",
+    "merge",
+    "peasy"
+  ],
+  "author": "Peasy Tools",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/peasytools/peasy-audio-js.git"
+  },
+  "homepage": "https://peasyaudio.com",
+  "dependencies": {
+    "fluent-ffmpeg": "^2.1"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1",
+    "tsup": "^8.0",
+    "typescript": "^5.7",
+    "vitest": "^3.0"
+  }
+}