peasy-video 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,307 @@
+# peasy-video-js
+
+[![npm](https://img.shields.io/npm/v/peasy-video-js)](https://www.npmjs.com/package/peasy-video-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)
+
+Video processing library for Node.js -- trim, resize, rotate, extract audio, generate thumbnails, convert to GIF, concatenate clips, adjust speed, and reverse video. FFmpeg-powered, TypeScript-first with full type safety. Handles MP4, WebM, MKV, AVI, MOV, and any container format supported by FFmpeg.
+
+Built from [PeasyVideo](https://peasyvideo.com), a free online video toolkit with 15 browser-based tools for trimming, resizing, format conversion, thumbnail extraction, and GIF creation.
+
+> **Try the interactive tools at [peasyvideo.com](https://peasyvideo.com)** -- video trimming, resizing, audio extraction, GIF conversion, and thumbnail generation
+
+<p align="center">
+  <img src="demo.gif" alt="peasy-video-js demo — video info, thumbnail extraction, and format 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)
+  - [Video Info & Metadata](#video-info--metadata)
+  - [Trimming & Concatenation](#trimming--concatenation)
+  - [Resize & Transform](#resize--transform)
+  - [Audio Extraction](#audio-extraction)
+  - [Thumbnails](#thumbnails)
+  - [GIF Conversion](#gif-conversion)
+  - [Speed & Reverse](#speed--reverse)
+- [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-video-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-video-js
+```
+
+## Quick Start
+
+```typescript
+import { info, trim, resize, thumbnail, videoToGif } from "peasy-video-js";
+
+// Get video metadata
+const meta = await info("movie.mp4");
+console.log(meta.width, meta.height, meta.duration); // 1920 1080 7200
+
+// Trim to a 30-second clip
+const clip = await trim("movie.mp4", { start: 60, duration: 30 });
+
+// Resize to 720p
+const resized = await resize("movie.mp4", { width: 1280, height: 720 });
+
+// Extract a thumbnail at 5 seconds
+const thumb = await thumbnail("movie.mp4", { time: 5 });
+
+// Convert a clip to GIF
+const gif = await videoToGif("clip.mp4", { fps: 15, width: 480 });
+```
+
+## What You Can Do
+
+### Video Info & Metadata
+
+Extract comprehensive metadata from video files without decoding frames. FFprobe reads container headers and stream information to report resolution, frame rate, codec, bitrate, duration, and whether an audio track is present.
+
+```typescript
+import { info } from "peasy-video-js";
+
+// Extract video metadata using FFprobe
+const meta = await info("presentation.mp4");
+console.log(meta.width);     // 1920
+console.log(meta.height);    // 1080
+console.log(meta.fps);       // 30
+console.log(meta.duration);  // 3600.5 (seconds)
+console.log(meta.codec);     // "h264"
+console.log(meta.hasAudio);  // true
+console.log(meta.bitrate);   // 5000000
+```
+
+Learn more: [Peasy Video Tools](https://peasyvideo.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Trimming & Concatenation
+
+Video trimming extracts a segment using keyframe-accurate seeking. Concatenation joins multiple clips sequentially using the FFmpeg concat demuxer, maintaining codec compatibility across segments.
+
+```typescript
+import { trim, concatenate } from "peasy-video-js";
+
+// Extract a 30-second clip starting at 1 minute
+const clip = await trim("lecture.mp4", { start: 60, duration: 30 });
+
+// Trim from start to end time
+const intro = await trim("movie.mp4", { start: 0, end: 15 });
+
+// Join multiple clips into one video
+const combined = await concatenate([
+  "chapter1.mp4",
+  "chapter2.mp4",
+  "chapter3.mp4",
+]);
+```
+
+Learn more: [Peasy Video Tools](https://peasyvideo.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Resize & Transform
+
+Video resizing scales frames to target dimensions while maintaining aspect ratio. Rotation applies transpose filters for 90/180/270 degree rotations, handling both the video stream and any embedded rotation metadata.
+
+| Resolution | Dimensions | Common Name |
+|-----------|------------|-------------|
+| 4K UHD | 3840 x 2160 | Ultra HD |
+| 1080p | 1920 x 1080 | Full HD |
+| 720p | 1280 x 720 | HD |
+| 480p | 854 x 480 | SD |
+
+```typescript
+import { resize, rotate } from "peasy-video-js";
+
+// Resize to 720p (maintains aspect ratio)
+const hd = await resize("4k-video.mp4", { width: 1280, height: 720 });
+
+// Resize by width only (auto-calculates height)
+const small = await resize("video.mp4", { width: 640 });
+
+// Rotate 90 degrees clockwise
+const rotated = await rotate("portrait.mp4", { degrees: 90 });
+
+// Rotate 180 degrees (flip upside down)
+const flipped = await rotate("upside-down.mp4", { degrees: 180 });
+```
+
+Learn more: [Peasy Video Tools](https://peasyvideo.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Audio Extraction
+
+Extract the audio track from a video file as a standalone audio file, or strip the audio track entirely to produce a silent video. Audio extraction preserves the original codec when possible, avoiding re-encoding for faster processing.
+
+```typescript
+import { extractAudio, stripAudio } from "peasy-video-js";
+
+// Extract audio as MP3
+const audio = await extractAudio("interview.mp4", "mp3");
+
+// Extract audio as WAV (lossless)
+const wav = await extractAudio("concert.mp4", "wav");
+
+// Remove audio track from video (silent output)
+const silent = await stripAudio("presentation.mp4");
+```
+
+Learn more: [Peasy Video Tools](https://peasyvideo.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Thumbnails
+
+Extract individual frames as images for preview thumbnails, video galleries, or content analysis. Single-frame extraction uses precise seeking, while multi-frame extraction distributes captures evenly across the video duration.
+
+```typescript
+import { thumbnail, thumbnails } from "peasy-video-js";
+
+// Extract a frame at 5 seconds as PNG
+const frame = await thumbnail("video.mp4", { time: 5 });
+
+// Extract a frame with custom dimensions
+const small = await thumbnail("video.mp4", {
+  time: 10,
+  width: 320,
+  height: 180,
+});
+
+// Generate 10 evenly-spaced thumbnails
+const frames = await thumbnails("video.mp4", 10, { width: 320 });
+// Returns array of paths: ["/tmp/peasy-video-xxx-0.png", ...]
+```
+
+Learn more: [Peasy Video Tools](https://peasyvideo.com) · [Glossary](https://peasytools.com/glossary/)
+
+### GIF Conversion
+
+Convert video clips to animated GIFs with palette optimization for smaller file sizes and better color reproduction. Convert GIFs back to MP4 for efficient playback and embedding.
+
+```typescript
+import { videoToGif, gifToVideo } from "peasy-video-js";
+
+// Convert video to GIF with custom settings
+const gif = await videoToGif("clip.mp4", {
+  fps: 15,       // frames per second
+  width: 480,    // pixel width
+  start: 2,      // start at 2 seconds
+  duration: 5,   // 5-second GIF
+});
+
+// Convert GIF back to MP4 (much smaller file size)
+const mp4 = await gifToVideo("animation.gif");
+```
+
+Learn more: [Peasy Video Tools](https://peasyvideo.com) · [Glossary](https://peasytools.com/glossary/)
+
+### Speed & Reverse
+
+Adjust playback speed using FFmpeg's `setpts` (video) and `atempo` (audio) filters. Speed factors below 1.0 create slow motion, above 1.0 create fast motion. Reverse plays the video backwards, re-encoding all frames.
+
+```typescript
+import { speed, reverseVideo } from "peasy-video-js";
+
+// Double the playback speed
+const fast = await speed("lecture.mp4", { factor: 2.0 });
+
+// Slow motion at half speed
+const slow = await speed("action.mp4", { factor: 0.5 });
+
+// Reverse the entire video
+const reversed = await reverseVideo("clip.mp4");
+```
+
+Learn more: [Peasy Video Tools](https://peasyvideo.com) · [Glossary](https://peasytools.com/glossary/)
+
+## TypeScript Types
+
+```typescript
+import type {
+  VideoFormat,
+  VideoInfo,
+  TrimOptions,
+  ResizeOptions,
+  RotateOptions,
+  ThumbnailOptions,
+  GifOptions,
+  SpeedOptions,
+  ThumbnailResult,
+} from "peasy-video-js";
+
+// VideoFormat — "mp4" | "webm" | "mkv" | "avi" | "mov" | "gif"
+const format: VideoFormat = "mp4";
+
+// VideoInfo — metadata from info()
+const meta: VideoInfo = {
+  duration: 120.5,
+  width: 1920,
+  height: 1080,
+  fps: 30,
+  codec: "h264",
+  format: "mov,mp4,m4a,3gp,3g2,mj2",
+  bitrate: 5_000_000,
+  size: 75_000_000,
+  hasAudio: true,
+};
+```
+
+## API Reference
+
+| Function | Description |
+|----------|-------------|
+| `info(input)` | Get video metadata (resolution, fps, codec, duration, bitrate) |
+| `trim(input, options)` | Extract a segment by start/end/duration |
+| `resize(input, options)` | Scale video to target dimensions |
+| `rotate(input, options)` | Rotate video 90/180/270 degrees |
+| `concatenate(inputs)` | Join multiple video files sequentially |
+| `extractAudio(input, format?)` | Extract audio track as standalone file |
+| `stripAudio(input)` | Remove audio track from video |
+| `thumbnail(input, options?)` | Extract a single frame as PNG |
+| `thumbnails(input, count, options?)` | Extract multiple evenly-spaced frames |
+| `videoToGif(input, options?)` | Convert video clip to animated GIF |
+| `gifToVideo(input)` | Convert GIF to MP4 |
+| `reverseVideo(input)` | Play video in reverse |
+| `speed(input, options)` | Adjust playback speed (0.5x to 4.0x) |
+
+## Also Available for Python
+
+```bash
+pip install peasy-video
+```
+
+The Python package provides the same 13 video operations with CLI and moviepy engine. See [peasy-video on PyPI](https://pypi.org/project/peasy-video/).
+
+## 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,264 @@
+/**
+ * peasy-video-js — Type definitions for video processing.
+ *
+ * @packageDocumentation
+ */
+/** Supported video container formats. */
+type VideoFormat = "mp4" | "webm" | "mkv" | "avi" | "mov" | "gif";
+/** Video file metadata. */
+interface VideoInfo {
+    duration: number;
+    width: number;
+    height: number;
+    fps: number;
+    codec: string;
+    format: string;
+    bitrate: number;
+    size: number;
+    hasAudio: boolean;
+}
+/** Options for video trimming. */
+interface TrimOptions {
+    start?: number;
+    end?: number;
+    duration?: number;
+}
+/** Options for video resizing. */
+interface ResizeOptions {
+    width?: number;
+    height?: number;
+    fit?: "contain" | "cover" | "fill";
+}
+/** Options for video rotation. */
+interface RotateOptions {
+    degrees: 90 | 180 | 270;
+}
+/** Options for thumbnail extraction. */
+interface ThumbnailOptions {
+    time?: number;
+    width?: number;
+    height?: number;
+}
+/** Options for GIF conversion. */
+interface GifOptions {
+    fps?: number;
+    width?: number;
+    start?: number;
+    duration?: number;
+}
+/** Options for speed adjustment. */
+interface SpeedOptions {
+    factor: number;
+}
+/** Thumbnail result. */
+interface ThumbnailResult {
+    path: string;
+    time: number;
+    width: number;
+    height: number;
+}
+
+/**
+ * peasy-video-js — Video processing engine powered by FFmpeg.
+ *
+ * 13 functions: info, trim, resize, rotate, concatenate, extractAudio,
+ * stripAudio, thumbnail, thumbnails, videoToGif, gifToVideo, reverseVideo, speed.
+ * All output functions return the path to the generated file.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Get metadata for a video file using ffprobe.
+ *
+ * @param input - Path to the video file
+ * @returns Video metadata including duration, dimensions, fps, codec, and more
+ *
+ * @example
+ * ```typescript
+ * const metadata = await info("sample.mp4");
+ * console.log(metadata.duration); // 120.5
+ * console.log(metadata.width);    // 1920
+ * console.log(metadata.height);   // 1080
+ * ```
+ */
+declare function info(input: string): Promise<VideoInfo>;
+/**
+ * Trim a video to a specific time range.
+ *
+ * @param input - Path to the input video
+ * @param options - Trim options: start, end, and/or duration in seconds
+ * @returns Path to the trimmed output file
+ *
+ * @example
+ * ```typescript
+ * // Trim from 10s to 30s
+ * const trimmed = await trim("input.mp4", { start: 10, end: 30 });
+ *
+ * // Trim first 5 seconds
+ * const first5 = await trim("input.mp4", { duration: 5 });
+ * ```
+ */
+declare function trim(input: string, options: TrimOptions): Promise<string>;
+/**
+ * Resize a video to the specified dimensions.
+ *
+ * @param input - Path to the input video
+ * @param options - Resize options: width, height, and fit mode
+ * @returns Path to the resized output file
+ *
+ * @example
+ * ```typescript
+ * // Resize to 1280x720
+ * const resized = await resize("input.mp4", { width: 1280, height: 720 });
+ *
+ * // Scale width to 640, maintain aspect ratio
+ * const scaled = await resize("input.mp4", { width: 640 });
+ * ```
+ */
+declare function resize(input: string, options: ResizeOptions): Promise<string>;
+/**
+ * Rotate a video by 90, 180, or 270 degrees.
+ *
+ * @param input - Path to the input video
+ * @param options - Rotation options: degrees (90, 180, or 270)
+ * @returns Path to the rotated output file
+ *
+ * @example
+ * ```typescript
+ * const rotated = await rotate("input.mp4", { degrees: 90 });
+ * ```
+ */
+declare function rotate(input: string, options: RotateOptions): Promise<string>;
+/**
+ * Concatenate multiple video files into one.
+ *
+ * @param inputs - Array of paths to video files (in order)
+ * @returns Path to the concatenated output file
+ *
+ * @example
+ * ```typescript
+ * const joined = await concatenate(["part1.mp4", "part2.mp4", "part3.mp4"]);
+ * ```
+ */
+declare function concatenate(inputs: string[]): Promise<string>;
+/**
+ * Extract the audio track from a video file.
+ *
+ * @param input - Path to the input video
+ * @param format - Audio output format (default: "mp3")
+ * @returns Path to the extracted audio file
+ *
+ * @example
+ * ```typescript
+ * const audio = await extractAudio("video.mp4");          // MP3
+ * const wav = await extractAudio("video.mp4", "wav");     // WAV
+ * ```
+ */
+declare function extractAudio(input: string, format?: string): Promise<string>;
+/**
+ * Remove the audio track from a video, producing a silent video.
+ *
+ * @param input - Path to the input video
+ * @returns Path to the silent output video
+ *
+ * @example
+ * ```typescript
+ * const silent = await stripAudio("video-with-music.mp4");
+ * ```
+ */
+declare function stripAudio(input: string): Promise<string>;
+/**
+ * Extract a single thumbnail frame from a video.
+ *
+ * @param input - Path to the input video
+ * @param options - Thumbnail options: time (seconds), width, height
+ * @returns Path to the generated thumbnail image (PNG)
+ *
+ * @example
+ * ```typescript
+ * // Thumbnail at 5 seconds
+ * const thumb = await thumbnail("video.mp4", { time: 5 });
+ *
+ * // Thumbnail at start with custom size
+ * const small = await thumbnail("video.mp4", { width: 320, height: 180 });
+ * ```
+ */
+declare function thumbnail(input: string, options?: ThumbnailOptions): Promise<string>;
+/**
+ * Extract multiple evenly-spaced thumbnails from a video.
+ *
+ * @param input - Path to the input video
+ * @param count - Number of thumbnails to extract
+ * @param options - Optional width and height for the thumbnails
+ * @returns Array of paths to the generated thumbnail images (PNG)
+ *
+ * @example
+ * ```typescript
+ * // Extract 5 thumbnails spread across the video
+ * const thumbs = await thumbnails("video.mp4", 5);
+ * ```
+ */
+declare function thumbnails(input: string, count: number, options?: Pick<ThumbnailOptions, "width" | "height">): Promise<string[]>;
+/**
+ * Convert a video to an animated GIF.
+ *
+ * Uses a two-pass palette generation for high-quality GIF output.
+ *
+ * @param input - Path to the input video
+ * @param options - GIF options: fps, width, start time, duration
+ * @returns Path to the generated GIF file
+ *
+ * @example
+ * ```typescript
+ * // Convert full video to GIF at 10fps
+ * const gif = await videoToGif("input.mp4", { fps: 10, width: 480 });
+ *
+ * // Convert a 3-second segment starting at 5s
+ * const clip = await videoToGif("input.mp4", { start: 5, duration: 3 });
+ * ```
+ */
+declare function videoToGif(input: string, options?: GifOptions): Promise<string>;
+/**
+ * Convert a GIF to a video (MP4).
+ *
+ * @param input - Path to the input GIF file
+ * @returns Path to the generated MP4 video file
+ *
+ * @example
+ * ```typescript
+ * const video = await gifToVideo("animation.gif");
+ * ```
+ */
+declare function gifToVideo(input: string): Promise<string>;
+/**
+ * Reverse a video so it plays backwards.
+ *
+ * @param input - Path to the input video
+ * @returns Path to the reversed output video
+ *
+ * @example
+ * ```typescript
+ * const reversed = await reverseVideo("input.mp4");
+ * ```
+ */
+declare function reverseVideo(input: string): Promise<string>;
+/**
+ * Change the playback speed of a video.
+ *
+ * @param input - Path to the input video
+ * @param options - Speed options: factor (>1 = faster, <1 = slower)
+ * @returns Path to the speed-adjusted output video
+ *
+ * @example
+ * ```typescript
+ * // 2x speed
+ * const fast = await speed("input.mp4", { factor: 2 });
+ *
+ * // Half speed (slow motion)
+ * const slow = await speed("input.mp4", { factor: 0.5 });
+ * ```
+ */
+declare function speed(input: string, options: SpeedOptions): Promise<string>;
+
+export { type GifOptions, type ResizeOptions, type RotateOptions, type SpeedOptions, type ThumbnailOptions, type ThumbnailResult, type TrimOptions, type VideoFormat, type VideoInfo, concatenate, extractAudio, gifToVideo, info, resize, reverseVideo, rotate, speed, stripAudio, thumbnail, thumbnails, trim, videoToGif };

package/dist/index.js

@@ -0,0 +1,218 @@
+// src/engine.ts
+import ffmpeg from "fluent-ffmpeg";
+import { tmpdir } from "os";
+import { join, extname } from "path";
+import { randomUUID } from "crypto";
+import { writeFileSync } from "fs";
+function tmpOutput(ext) {
+  return join(tmpdir(), `peasy-video-${randomUUID()}.${ext}`);
+}
+function parseFps(rate) {
+  if (!rate) return 0;
+  const parts = rate.split("/");
+  if (parts.length === 2) {
+    const num = Number(parts[0]);
+    const den = Number(parts[1]);
+    return den > 0 ? num / den : 0;
+  }
+  return Number(rate) || 0;
+}
+function run(command, outputPath) {
+  return new Promise((resolve, reject) => {
+    command.output(outputPath).on("end", () => resolve(outputPath)).on("error", (err) => reject(err)).run();
+  });
+}
+function getExt(filePath) {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  return ext || "mp4";
+}
+function info(input) {
+  return new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(input, (err, metadata) => {
+      if (err) return reject(err);
+      const video = metadata.streams.find((s) => s.codec_type === "video");
+      const audio = metadata.streams.find((s) => s.codec_type === "audio");
+      resolve({
+        duration: metadata.format.duration ?? 0,
+        width: video?.width ?? 0,
+        height: video?.height ?? 0,
+        fps: parseFps(video?.r_frame_rate),
+        codec: video?.codec_name ?? "unknown",
+        format: metadata.format.format_name ?? "unknown",
+        bitrate: metadata.format.bit_rate ? Number(metadata.format.bit_rate) : 0,
+        size: metadata.format.size ? Number(metadata.format.size) : 0,
+        hasAudio: !!audio
+      });
+    });
+  });
+}
+function trim(input, options) {
+  const output = tmpOutput(getExt(input));
+  const cmd = ffmpeg(input);
+  if (options.start !== void 0) {
+    cmd.setStartTime(options.start);
+  }
+  if (options.end !== void 0 && options.start !== void 0) {
+    cmd.setDuration(options.end - options.start);
+  } else if (options.duration !== void 0) {
+    cmd.setDuration(options.duration);
+  }
+  cmd.outputOptions("-c", "copy");
+  return run(cmd, output);
+}
+function resize(input, options) {
+  const output = tmpOutput(getExt(input));
+  const cmd = ffmpeg(input);
+  let scaleFilter;
+  if (options.width && options.height) {
+    if (options.fit === "cover") {
+      scaleFilter = `scale=${options.width}:${options.height}:force_original_aspect_ratio=increase,crop=${options.width}:${options.height}`;
+    } else if (options.fit === "contain") {
+      scaleFilter = `scale=${options.width}:${options.height}:force_original_aspect_ratio=decrease,pad=${options.width}:${options.height}:(ow-iw)/2:(oh-ih)/2`;
+    } else {
+      scaleFilter = `scale=${options.width}:${options.height}`;
+    }
+  } else if (options.width) {
+    scaleFilter = `scale=${options.width}:-2`;
+  } else if (options.height) {
+    scaleFilter = `scale=-2:${options.height}`;
+  } else {
+    return run(cmd, output);
+  }
+  cmd.videoFilter(scaleFilter);
+  return run(cmd, output);
+}
+function rotate(input, options) {
+  const output = tmpOutput(getExt(input));
+  const cmd = ffmpeg(input);
+  switch (options.degrees) {
+    case 90:
+      cmd.videoFilter("transpose=1");
+      break;
+    case 180:
+      cmd.videoFilter("transpose=1,transpose=1");
+      break;
+    case 270:
+      cmd.videoFilter("transpose=2");
+      break;
+  }
+  return run(cmd, output);
+}
+function concatenate(inputs) {
+  if (inputs.length < 2) {
+    return Promise.reject(new Error("At least 2 inputs are required for concatenation"));
+  }
+  const output = tmpOutput(getExt(inputs[0]));
+  const listPath = tmpOutput("txt");
+  const listContent = inputs.map((f) => `file '${f}'`).join("\n");
+  writeFileSync(listPath, listContent, "utf-8");
+  const cmd = ffmpeg().input(listPath).inputOptions("-f", "concat", "-safe", "0").outputOptions("-c", "copy");
+  return run(cmd, output);
+}
+function extractAudio(input, format = "mp3") {
+  const output = tmpOutput(format);
+  const cmd = ffmpeg(input).noVideo();
+  return run(cmd, output);
+}
+function stripAudio(input) {
+  const output = tmpOutput(getExt(input));
+  const cmd = ffmpeg(input).noAudio().outputOptions("-c:v", "copy");
+  return run(cmd, output);
+}
+function thumbnail(input, options = {}) {
+  const output = tmpOutput("png");
+  const cmd = ffmpeg(input);
+  if (options.time !== void 0) {
+    cmd.seekInput(options.time);
+  }
+  cmd.frames(1);
+  if (options.width || options.height) {
+    const w = options.width ?? -2;
+    const h = options.height ?? -2;
+    cmd.videoFilter(`scale=${w}:${h}`);
+  }
+  return run(cmd, output);
+}
+async function thumbnails(input, count, options = {}) {
+  const meta = await info(input);
+  const duration = meta.duration;
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    const time = count > 1 ? i / (count - 1) * duration : 0;
+    const clampedTime = Math.min(time, Math.max(0, duration - 0.01));
+    const thumbPath = await thumbnail(input, {
+      time: clampedTime,
+      ...options
+    });
+    results.push(thumbPath);
+  }
+  return results;
+}
+function videoToGif(input, options = {}) {
+  const output = tmpOutput("gif");
+  const cmd = ffmpeg(input);
+  if (options.start !== void 0) {
+    cmd.setStartTime(options.start);
+  }
+  if (options.duration !== void 0) {
+    cmd.setDuration(options.duration);
+  }
+  const filters = [];
+  if (options.fps) {
+    filters.push(`fps=${options.fps}`);
+  }
+  if (options.width) {
+    filters.push(`scale=${options.width}:-1:flags=lanczos`);
+  }
+  if (filters.length > 0) {
+    cmd.videoFilter(filters.join(","));
+  }
+  return run(cmd, output);
+}
+function gifToVideo(input) {
+  const output = tmpOutput("mp4");
+  const cmd = ffmpeg(input).outputOptions("-movflags", "+faststart").outputOptions("-pix_fmt", "yuv420p");
+  return run(cmd, output);
+}
+function reverseVideo(input) {
+  const output = tmpOutput(getExt(input));
+  const cmd = ffmpeg(input).videoFilter("reverse").audioFilter("areverse");
+  return run(cmd, output);
+}
+function speed(input, options) {
+  if (options.factor <= 0) {
+    return Promise.reject(new Error("Speed factor must be positive"));
+  }
+  const output = tmpOutput(getExt(input));
+  const cmd = ffmpeg(input);
+  const ptsFactor = 1 / options.factor;
+  cmd.videoFilter(`setpts=${ptsFactor}*PTS`);
+  const atempoFilters = [];
+  let remaining = options.factor;
+  while (remaining > 100) {
+    atempoFilters.push("atempo=100.0");
+    remaining /= 100;
+  }
+  while (remaining < 0.5) {
+    atempoFilters.push("atempo=0.5");
+    remaining /= 0.5;
+  }
+  atempoFilters.push(`atempo=${remaining}`);
+  cmd.audioFilter(atempoFilters.join(","));
+  return run(cmd, output);
+}
+export {
+  concatenate,
+  extractAudio,
+  gifToVideo,
+  info,
+  resize,
+  reverseVideo,
+  rotate,
+  speed,
+  stripAudio,
+  thumbnail,
+  thumbnails,
+  trim,
+  videoToGif
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "peasy-video",
+  "version": "0.1.1",
+  "description": "Video processing library for Node.js \u2014 trim, resize, rotate, thumbnails, GIF conversion. 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": [
+    "video",
+    "mp4",
+    "ffmpeg",
+    "trim",
+    "resize",
+    "thumbnail",
+    "gif",
+    "peasy"
+  ],
+  "author": "Peasy Tools",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/peasytools/peasy-video-js.git"
+  },
+  "homepage": "https://peasyvideo.com",
+  "dependencies": {
+    "fluent-ffmpeg": "^2.1"
+  },
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1",
+    "tsup": "^8.0",
+    "typescript": "^5.7",
+    "vitest": "^3.0"
+  }
+}