simple-ffmpegjs 0.4.4 → 0.5.1

package/README.md

@@ -68,7 +68,8 @@ _Click to watch a "Wonders of the World" video created with simple-ffmpeg — co
 
 **Video & Images**
 - **Video Concatenation** — Join multiple clips with optional xfade transitions
-- **Image Support** — Ken Burns effects (zoom, pan) for static images
+- **Image Support** — Ken Burns effects (zoom, pan) for static images with intelligent aspect ratio handling
+- **Image Fitting** — Automatic blur-fill, cover, or contain modes when image aspect ratio differs from output
 - **Color Clips** — Flat colors and gradients (linear, radial) as first-class timeline clips with full transition support
 
 **Audio**
@@ -76,12 +77,16 @@ _Click to watch a "Wonders of the World" video created with simple-ffmpeg — co
 
 **Overlays & Effects**
 - **Text Overlays** — Static, word-by-word, and cumulative text with animations
+- **Emoji Support** — Opt-in emoji rendering via custom font + libass; stripped by default for clean output
 - **Text Animations** — Typewriter, scale-in, pulse, fade effects
 - **Karaoke Mode** — Word-by-word highlighting with customizable colors
 - **Subtitle Import** — Load SRT, VTT, ASS/SSA subtitle files
 - **Watermarks** — Text or image overlays with positioning and timing control
 - **Effect Clips** — Timed overlay effects (vignette, film grain, blur, color adjust, sepia, black & white, sharpen, chromatic aberration, letterbox) with fade-in/out envelopes
 
+**Analysis & Extraction**
+- **Keyframe Extraction** — Scene-change detection or fixed-interval frame sampling, returning in-memory buffers or files on disk
+
 **Developer Experience**
 - **Platform Presets** — Quick configuration for TikTok, YouTube, Instagram, etc.
 - **Progress Tracking** — Real-time export progress callbacks
@@ -123,6 +128,20 @@ apk add --no-cache ffmpeg fontconfig ttf-dejavu
 apt-get install -y ffmpeg fontconfig fonts-dejavu-core
 ```
 
+**Emoji in text overlays** are handled gracefully: by default, emoji characters are automatically detected and silently stripped from text to prevent blank boxes (tofu). To render emoji, pass an `emojiFont` path in the constructor:
+
+```javascript
+const project = new SIMPLEFFMPEG({
+  width: 1920,
+  height: 1080,
+  emojiFont: '/path/to/NotoEmoji-Regular.ttf'
+});
+```
+
+Recommended font: [Noto Emoji](https://fonts.google.com/noto/specimen/Noto+Emoji) (B&W outline, ~2 MB, SIL OFL). Download from [Google Fonts](https://fonts.google.com/noto/specimen/Noto+Emoji) or [GitHub](https://github.com/google/fonts/raw/main/ofl/notoemoji/NotoEmoji%5Bwght%5D.ttf). When an emoji font is configured, emoji text is routed through libass (ASS subtitle path) with inline `\fn` font switching for per-glyph rendering.
+
+> **Note:** Emoji render as monochrome outlines because libass does not yet support color emoji font formats. The shapes are recognizable and correctly spaced, just not multi-colored. Without `emojiFont`, emoji are stripped and a one-time console warning is logged.
+
 ## Quick Start
 
 ```js
@@ -254,7 +273,7 @@ Available modules:
 | ---------- | ----------------------------------------------------------- |
 | `video`    | Video clips, transitions, volume, trimming                  |
 | `audio`    | Standalone audio clips                                      |
-| `image`    | Image clips, Ken Burns effects                              |
+| `image`    | Image clips, Ken Burns effects, image fitting modes         |
 | `color`    | Color clips — flat colors, linear/radial gradients          |
 | `effect`   | Overlay adjustment effects — vignette, grain, blur, color adjust, sepia, B&W, sharpen, chromatic aberration, letterbox |
 | `text`     | Text overlays — all modes, animations, positioning, styling |
@@ -296,9 +315,24 @@ new SIMPLEFFMPEG(options?: {
   validationMode?: 'warn' | 'strict';  // Validation behavior (default: 'warn')
   preset?: string;          // Platform preset (e.g., 'tiktok', 'youtube', 'instagram-post')
   fontFile?: string;        // Default font file for all text clips (individual clips can override)
+  emojiFont?: string;       // Path to emoji font .ttf for opt-in emoji rendering (stripped by default)
+  tempDir?: string;         // Custom temp directory for intermediate files (default: OS temp)
 })
 ```
 
+**Custom Temp Directory:**
+
+Set `tempDir` to route all temporary files (gradient images, unrotated videos, text/subtitle temp files, batch intermediate renders) to a custom location. Useful for fast SSDs, ramdisks, Docker containers with limited `/tmp`, or any environment where temp storage performance matters:
+
+```ts
+const project = new SIMPLEFFMPEG({
+  preset: "youtube",
+  tempDir: "/mnt/fast-nvme/tmp",
+});
+```
+
+When not set, temp files go to the OS default (`os.tmpdir()`) or next to the output file, depending on the operation. Cross-filesystem moves are handled automatically.
+
 When `fontFile` is set at the project level, every text clip (including karaoke) inherits it automatically. You can still override it on any individual clip:
 
 ```js
@@ -422,6 +456,67 @@ await SIMPLEFFMPEG.snapshot("./video.mp4", {
 });
 ```
 
+#### `SIMPLEFFMPEG.extractKeyframes(filePath, options)`
+
+Extract keyframes from a video using scene-change detection or fixed time intervals. This is a static method — no project instance needed.
+
+**Scene-change mode** (default) uses FFmpeg's `select=gt(scene,N)` filter to intelligently detect visual transitions and extract frames at cut points. **Interval mode** extracts frames at fixed time intervals.
+
+When `outputDir` is provided, frames are written to disk and the method returns an array of file paths. Without `outputDir`, frames are returned as in-memory `Buffer` objects (no temp files left behind).
+
+```ts
+// Scene-change detection — returns Buffer[]
+const frames = await SIMPLEFFMPEG.extractKeyframes("./video.mp4", {
+  mode: "scene-change",
+  sceneThreshold: 0.4,
+  maxFrames: 8,
+  format: "jpeg",
+});
+
+// Fixed interval — writes to disk, returns string[]
+const paths = await SIMPLEFFMPEG.extractKeyframes("./video.mp4", {
+  mode: "interval",
+  intervalSeconds: 5,
+  outputDir: "./frames/",
+  format: "png",
+});
+```
+
+**Keyframe Options:**
+
+| Option            | Type     | Default          | Description                                                                     |
+| ----------------- | -------- | ---------------- | ------------------------------------------------------------------------------- |
+| `mode`            | `string` | `'scene-change'` | `'scene-change'` for intelligent detection, `'interval'` for fixed time spacing |
+| `sceneThreshold`  | `number` | `0.3`            | Scene detection sensitivity 0-1 (lower = more frames). Scene-change mode only.  |
+| `intervalSeconds` | `number` | `5`              | Seconds between frames. Interval mode only.                                     |
+| `maxFrames`       | `number` | -                | Maximum number of frames to extract                                             |
+| `format`          | `string` | `'jpeg'`         | Output format: `'jpeg'` or `'png'`                                              |
+| `quality`         | `number` | -                | JPEG quality 1-31, lower is better (only applies to JPEG)                       |
+| `width`           | `number` | -                | Output width in pixels (maintains aspect ratio if height omitted)               |
+| `height`          | `number` | -                | Output height in pixels (maintains aspect ratio if width omitted)               |
+| `outputDir`       | `string` | -                | Directory to write frames to. If omitted, returns `Buffer[]` instead.           |
+| `tempDir`         | `string` | `os.tmpdir()`    | Custom temp directory (only when `outputDir` is not set). Useful for fast SSDs or ramdisks. |
+
+```ts
+// Scene-change with resize and JPEG quality
+const frames = await SIMPLEFFMPEG.extractKeyframes("./long-video.mp4", {
+  sceneThreshold: 0.25,
+  maxFrames: 12,
+  width: 640,
+  quality: 4,
+});
+
+// One frame every 10 seconds, saved as PNG
+const paths = await SIMPLEFFMPEG.extractKeyframes("./presentation.mp4", {
+  mode: "interval",
+  intervalSeconds: 10,
+  outputDir: "./thumbnails/",
+  format: "png",
+});
+```
+
+Throws `FFmpegError` if FFmpeg fails during extraction.
+
 #### `project.export(options)`
 
 Build and execute the FFmpeg command to render the final video.
@@ -540,6 +635,8 @@ All [xfade transitions](https://trac.ffmpeg.org/wiki/Xfade) are supported.
   duration?: number;        // Duration in seconds (alternative to end)
   width?: number;           // Optional: source image width (skip probe / override)
   height?: number;          // Optional: source image height (skip probe / override)
+  imageFit?: "cover" | "contain" | "blur-fill";  // How to handle aspect ratio mismatch (see below)
+  blurIntensity?: number;   // Blur strength for blur-fill background (default: 40, range: 10-80)
   kenBurns?:
     | "zoom-in" | "zoom-out" | "pan-left" | "pan-right" | "pan-up" | "pan-down"
     | "smart" | "custom"
@@ -557,6 +654,58 @@ All [xfade transitions](https://trac.ffmpeg.org/wiki/Xfade) are supported.
 }
 ```
 
+**Image Fitting (`imageFit`):**
+
+When an image's aspect ratio doesn't match the output (e.g., a landscape photo in a portrait video), `imageFit` controls how the mismatch is resolved:
+
+| Mode | Behavior | Default for |
+|---|---|---|
+| `blur-fill` | Scale to fit, fill empty space with a blurred version of the image | Static images (no Ken Burns) |
+| `cover` | Scale to fill the entire frame, center-crop any excess | Ken Burns images |
+| `contain` | Scale to fit within the frame, pad with black bars | — |
+
+If `imageFit` is not specified, the library picks the best default: **`blur-fill`** for static images (produces polished output similar to TikTok/Reels) and **`cover`** for Ken Burns images (ensures full-frame cinematic motion).
+
+```ts
+// Landscape photo in a portrait video — blurred background fills the bars (default)
+{ type: "image", url: "./landscape.jpg", duration: 5 }
+
+// Explicit cover — crops to fill the frame
+{ type: "image", url: "./landscape.jpg", duration: 5, imageFit: "cover" }
+
+// Black bars (letterbox/pillarbox)
+{ type: "image", url: "./landscape.jpg", duration: 5, imageFit: "contain" }
+
+// Stronger blur effect
+{ type: "image", url: "./landscape.jpg", duration: 5, imageFit: "blur-fill", blurIntensity: 70 }
+```
+
+**Ken Burns + imageFit:** When using Ken Burns with `blur-fill` or `contain`, the pan/zoom motion applies only to the image content — the blurred background or black bars remain static, matching the behavior of modern phone video editors. Source dimensions (`width`/`height`) are required for KB + `blur-fill`/`contain`; without them it falls back to `cover`.
+
+```ts
+// Ken Burns zoom on contained image with blurred background
+{
+  type: "image",
+  url: "./landscape.jpg",
+  duration: 5,
+  width: 1920,
+  height: 1080,
+  kenBurns: "zoom-in",
+  imageFit: "blur-fill",
+}
+
+// Ken Burns pan with black bars
+{
+  type: "image",
+  url: "./landscape.jpg",
+  duration: 5,
+  width: 1920,
+  height: 1080,
+  kenBurns: "pan-right",
+  imageFit: "contain",
+}
+```
+
 #### Color Clip
 
 Color clips add flat colors or gradients as first-class visual elements. They support transitions, text overlays, and all the same timeline features as video and image clips. Use them for intros, outros, title cards, or anywhere you need a background.
@@ -1066,6 +1215,7 @@ When `position` is omitted, clips are placed sequentially — see [Auto-Sequenci
 > **Note:** Ken Burns effects work best with images at least as large as your output resolution. Smaller images are automatically upscaled (with a validation warning). Use `strictKenBurns: true` in validation options to enforce size requirements instead.
 > If you pass `width`/`height`, they override probed dimensions (useful for remote or generated images).
 > `smart` mode uses source vs output aspect (when known) to choose pan direction.
+> Ken Burns defaults to `imageFit: "cover"` (full-frame motion). Set `imageFit: "blur-fill"` or `"contain"` for phone-style editing where the motion applies to the contained image while the background stays static.
 
 ### Text & Animations
 
@@ -1125,6 +1275,43 @@ await project.load([
 // Also available: fade-in, fade-out, fade-in-out, pop, pop-bounce, scale-in
 ```
 
+**Emoji in text overlays:**
+
+Emoji characters are automatically detected. By default they are stripped from text to prevent tofu (blank boxes). To render emoji, configure an `emojiFont` path in the constructor:
+
+```ts
+// Enable emoji rendering by providing a font path
+const project = new SIMPLEFFMPEG({
+  width: 1920,
+  height: 1080,
+  emojiFont: "./fonts/NotoEmoji-Regular.ttf",
+});
+
+await project.load([
+  { type: "video", url: "./bg.mp4", position: 0, end: 10 },
+  {
+    type: "text",
+    text: "small dog, big heart 🐾",
+    position: 1,
+    end: 5,
+    fontSize: 48,
+    fontColor: "#FFFFFF",
+    yPercent: 0.5,
+  },
+  {
+    type: "text",
+    text: "Movie night! 🎬🍿✨",
+    position: 5,
+    end: 9,
+    fontSize: 48,
+    fontColor: "#FFFFFF",
+    animation: { type: "fade-in-out", in: 0.5, out: 0.5 },
+  },
+]);
+```
+
+> **Note:** Without `emojiFont`, emoji are silently stripped (no tofu). With `emojiFont`, emoji render as monochrome outlines via the ASS path. Supports fade animations (`fade-in`, `fade-out`, `fade-in-out`) and static text. For other animation types (`pop`, `typewriter`, etc.), emoji are stripped and a console warning is logged.
+
 ### Karaoke
 
 Word-by-word highlighting with customizable colors. Use `highlightStyle: "instant"` for immediate color changes instead of the default smooth fill:
@@ -1526,7 +1713,7 @@ npm run test:watch
 For visual verification, run the demo suite to generate sample videos covering all major features. Each demo outputs to its own subfolder under `examples/output/` and includes annotated expected timelines so you know exactly what to look for:
 
 ```bash
-# Run all demos (color clips, effects, transitions, text, Ken Burns, audio, watermarks, karaoke, torture test)
+# Run all demos (color clips, effects, transitions, text, emoji, Ken Burns, audio, watermarks, karaoke, torture test)
 node examples/run-examples.js
 
 # Run a specific demo by name (partial match)
@@ -1542,10 +1729,12 @@ Available demo scripts (can also be run individually):
 | `demo-effects.js`               | Timed overlay effects (all 9 effects) with smooth fade ramps                           |
 | `demo-transitions.js`           | Fade, wipe, slide, dissolve, fadeblack/white, short/long durations, image transitions  |
 | `demo-text-and-animations.js`   | Positioning, fade, pop, pop-bounce, typewriter, scale-in, pulse, styling, word-replace |
+| `demo-emoji-text.js`            | Emoji stripping (default) and opt-in rendering via emojiFont, fade, styling, fallback |
 | `demo-ken-burns.js`             | All 6 presets, smart anchors, custom diagonal, slideshow with transitions              |
 | `demo-audio-mixing.js`          | Volume levels, background music, standalone audio, loop, multi-source mix              |
 | `demo-watermarks.js`            | Text/image watermarks, all positions, timed appearance, styled over transitions        |
 | `demo-karaoke-and-subtitles.js` | Smooth/instant karaoke, word timestamps, multiline, SRT, VTT, mixed text+karaoke       |
+| `demo-image-fit.js`             | Image fitting modes (blur-fill, cover, contain), Ken Burns + imageFit, mixed timelines |
 | `demo-torture-test.js`          | Kitchen sink, many clips+gaps+transitions, 6 simultaneous text animations, edge cases  |
 
 Each script header contains a `WHAT TO CHECK` section describing the expected visual output at every timestamp, making it easy to spot regressions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-ffmpegjs",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "description": "Declarative video composition for Node.js — define clips, transitions, text, and audio as simple objects, and let FFmpeg handle the rest.",
   "author": "Brayden Blackwell <braydenblackwell21@gmail.com> (https://github.com/Fats403)",
   "license": "MIT",

package/src/core/rotation.js

@@ -5,8 +5,6 @@ const { randomUUID } = require("crypto");
 const { spawn } = require("child_process");
 const { FFmpegError } = require("./errors");
 
-const tempDir = os.tmpdir();
-
 /** Default timeout for unrotate operations (5 minutes) */
 const DEFAULT_UNROTATE_TIMEOUT_MS = 5 * 60 * 1000;
 
@@ -14,13 +12,16 @@ const DEFAULT_UNROTATE_TIMEOUT_MS = 5 * 60 * 1000;
  * Unrotate a video (remove iPhone rotation metadata) using ffmpeg.
  * Uses spawn() with argument array to avoid command injection.
  * @param {string} inputUrl - Path to the input video file
- * @param {number} [timeoutMs] - Timeout in milliseconds (default: 5 minutes)
+ * @param {Object} [options] - Options
+ * @param {number} [options.timeoutMs] - Timeout in milliseconds (default: 5 minutes)
+ * @param {string} [options.tempDir] - Custom temp directory (default: os.tmpdir())
  * @returns {Promise<string>} Path to the unrotated temporary video file
  * @throws {FFmpegError} If ffmpeg fails or times out
  */
-function unrotateVideo(inputUrl, timeoutMs = DEFAULT_UNROTATE_TIMEOUT_MS) {
+function unrotateVideo(inputUrl, options = {}) {
+  const timeoutMs = options.timeoutMs || DEFAULT_UNROTATE_TIMEOUT_MS;
   return new Promise((resolve, reject) => {
-    const out = path.join(tempDir, `unrotated-${randomUUID()}.mp4`);
+    const out = path.join(options.tempDir || os.tmpdir(), `unrotated-${randomUUID()}.mp4`);
     const args = ["-y", "-i", inputUrl, out];
     let timedOut = false;
 

package/src/core/validation.js

@@ -970,6 +970,42 @@ function validateClip(clip, index, options = {}) {
 
   // Image clip validation
   if (clip.type === "image") {
+    if (clip.imageFit !== undefined) {
+      const validImageFit = ["cover", "contain", "blur-fill"];
+      if (!validImageFit.includes(clip.imageFit)) {
+        errors.push(
+          createIssue(
+            ValidationCodes.INVALID_VALUE,
+            `${path}.imageFit`,
+            `Invalid imageFit '${clip.imageFit}'. Expected: ${validImageFit.join(", ")}`,
+            clip.imageFit
+          )
+        );
+      }
+    }
+
+    if (clip.blurIntensity !== undefined) {
+      if (typeof clip.blurIntensity !== "number" || !Number.isFinite(clip.blurIntensity)) {
+        errors.push(
+          createIssue(
+            ValidationCodes.INVALID_TYPE,
+            `${path}.blurIntensity`,
+            `blurIntensity must be a finite number`,
+            clip.blurIntensity
+          )
+        );
+      } else if (clip.blurIntensity <= 0) {
+        errors.push(
+          createIssue(
+            ValidationCodes.INVALID_RANGE,
+            `${path}.blurIntensity`,
+            `blurIntensity must be > 0`,
+            clip.blurIntensity
+          )
+        );
+      }
+    }
+
     if (clip.kenBurns) {
       const validKenBurns = [
         "zoom-in",

package/src/ffmpeg/command_builder.js

@@ -310,11 +310,61 @@ function sanitizeFilterComplex(fc) {
   return sanitized;
 }
 
+/**
+ * Build FFmpeg command to extract keyframes from a video.
+ *
+ * Supports two modes:
+ * - "scene-change": uses select='gt(scene,N)' to detect visual transitions
+ * - "interval": uses fps=1/N to sample at fixed time intervals
+ */
+function buildKeyframeCommand({
+  inputPath,
+  outputPattern,
+  mode,
+  sceneThreshold,
+  intervalSeconds,
+  maxFrames,
+  width,
+  height,
+  quality,
+}) {
+  let cmd = `ffmpeg -y -i "${escapeFilePath(inputPath)}"`;
+
+  const filters = [];
+
+  if (mode === "scene-change") {
+    filters.push(`select='gt(scene,${sceneThreshold})'`);
+  } else {
+    filters.push(`fps=1/${intervalSeconds}`);
+  }
+
+  if (width || height) {
+    const w = width || -1;
+    const h = height || -1;
+    filters.push(`scale=${w}:${h}`);
+  }
+
+  cmd += ` -vf "${filters.join(",")}"`;
+  cmd += ` -vsync vfr`;
+
+  if (maxFrames != null) {
+    cmd += ` -frames:v ${maxFrames}`;
+  }
+
+  if (quality != null) {
+    cmd += ` -q:v ${quality}`;
+  }
+
+  cmd += ` "${escapeFilePath(outputPattern)}"`;
+  return cmd;
+}
+
 module.exports = {
   buildMainCommand,
   buildTextBatchCommand,
   buildThumbnailCommand,
   buildSnapshotCommand,
+  buildKeyframeCommand,
   escapeMetadata,
   sanitizeFilterComplex,
 };

package/src/ffmpeg/strings.js

@@ -68,6 +68,85 @@ function escapeTextFilePath(filePath) {
     .replace(/:/g, "\\:"); // Escape colons (for Windows drive letters)
 }
 
+/**
+ * Check if text contains emoji characters that require ASS-based rendering
+ * for proper font fallback (drawtext uses a single font with no fallback).
+ * Matches two classes:
+ *   1. \p{Emoji_Presentation} — inherently visual emoji (e.g. 🐾, 🎬)
+ *   2. \p{Emoji}\uFE0F — text-default emoji made visual by variation selector (e.g. ❤️)
+ * Does NOT match bare digits, #, * etc. which have \p{Emoji} but lack the selector.
+ */
+function hasEmoji(text) {
+  if (typeof text !== "string") return false;
+  return /\p{Emoji_Presentation}/u.test(text) || /\p{Emoji}\uFE0F/u.test(text);
+}
+
+const fs = require("fs");
+const path = require("path");
+
+const VISUAL_EMOJI_RE = /\p{Emoji_Presentation}|\p{Emoji}\uFE0F/gu;
+
+/**
+ * Remove visual emoji characters from text.
+ * Collapses any resulting double-spaces but preserves leading/trailing whitespace.
+ * @param {string} text
+ * @returns {string}
+ */
+function stripEmoji(text) {
+  if (typeof text !== "string") return text;
+  return text.replace(VISUAL_EMOJI_RE, "").replace(/ {2,}/g, " ").trim();
+}
+
+/**
+ * Parse the font family name from a TrueType/OpenType font file.
+ * Reads the 'name' table (nameID 1) directly — no dependencies needed.
+ * Returns the family name string or null if parsing fails.
+ * @param {string} fontPath - Absolute or relative path to a .ttf/.otf file
+ * @returns {string|null}
+ */
+function parseFontFamily(fontPath) {
+  try {
+    const buf = fs.readFileSync(fontPath);
+    if (buf.length < 12) return null;
+    const numTables = buf.readUInt16BE(4);
+    for (let i = 0; i < numTables; i++) {
+      const off = 12 + i * 16;
+      if (off + 16 > buf.length) return null;
+      const tag = buf.toString("ascii", off, off + 4);
+      if (tag !== "name") continue;
+      const tableOffset = buf.readUInt32BE(off + 8);
+      if (tableOffset + 6 > buf.length) return null;
+      const count = buf.readUInt16BE(tableOffset + 2);
+      const stringStorageOffset = tableOffset + buf.readUInt16BE(tableOffset + 4);
+      for (let j = 0; j < count; j++) {
+        const recOff = tableOffset + 6 + j * 12;
+        if (recOff + 12 > buf.length) return null;
+        const platformID = buf.readUInt16BE(recOff);
+        const nameID = buf.readUInt16BE(recOff + 6);
+        const length = buf.readUInt16BE(recOff + 8);
+        const strOff = buf.readUInt16BE(recOff + 10);
+        if (nameID !== 1) continue;
+        const start = stringStorageOffset + strOff;
+        if (start + length > buf.length) continue;
+        if (platformID === 1) {
+          return buf.toString("utf8", start, start + length);
+        }
+        if (platformID === 3) {
+          let name = "";
+          for (let k = 0; k < length; k += 2) {
+            name += String.fromCharCode(buf.readUInt16BE(start + k));
+          }
+          return name;
+        }
+      }
+      break;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
 function getClipAudioString(clip, inputIndex) {
   const adelay = Math.round(Math.max(0, (clip.position || 0) * 1000));
   const audioConcatInput = `[a${inputIndex}]`;
@@ -84,5 +163,8 @@ module.exports = {
   escapeDrawtextText,
   getClipAudioString,
   hasProblematicChars,
+  hasEmoji,
+  stripEmoji,
+  parseFontFamily,
   escapeTextFilePath,
 };