optimo 0.0.17 → 0.0.19

package/README.md

@@ -6,15 +6,16 @@
   <img alt="Last version" src="https://img.shields.io/github/tag/kikobeats/optimo.svg?style=flat-square">
   <a href="https://www.npmjs.org/package/optimo"><img alt="NPM Status" src="https://img.shields.io/npm/dm/optimo.svg?style=flat-square"></a>
   <br><br>
-  optimo reduces image file size aggressively, and safely.
+  optimo reduces media file size aggressively, and safely.
 </div>
 
 ## Highlights
 
 - Format-specific tuning for stronger size reduction.
 - Safety guard: if optimized output is not smaller, original file is kept.
-- Backed by proven tools: ImageMagick, SVGO, Gifsicle, and MozJPEG.
-- Resizing supports percentage values (`50%`), max file size targets (`100kB`), width (`w960`), & height (`h480`).
+- Backed by proven tools: ImageMagick, SVGO, Gifsicle, MozJPEG, and FFmpeg.
+- Supports image and video optimization.
+- Resizing supports percentage values (`50%`), max file size targets (`100kB`, images only), width (`w960`), & height (`h480`).
 
 ## Usage
 
@@ -27,7 +28,12 @@ npx -y optimo public/media/banner.png --resize 50% # resize + optimize
 npx -y optimo public/media/banner.png --resize 100kB # resize to max file size
 npx -y optimo public/media/banner.png --resize w960 # resize to max width
 npx -y optimo public/media/banner.png --resize h480 # resize to max height
+npx -y optimo public/media/banner.png --data-url # print optimized image as data URL
 npx -y optimo public/media/banner.heic --dry-run --verbose # inspect unsupported failures
+npx -y optimo public/media/clip.mp4 # optimize a video
+npx -y optimo public/media/clip.mp4 --mute # optimize and remove audio
+npx -y optimo public/media/clip.mp4 --mute false # optimize video and keep audio
+npx -y optimo public/media/clip.mov --format webm # convert + optimize video
 ```
 
 ## Pipelines
@@ -38,12 +44,15 @@ When `optimo` is executed, a pipeline of compressors is chosen based on the outp
 - `.svg` -> `svgo.svg`
 - `.jpg/.jpeg` -> `magick.jpg/jpeg` + `mozjpegtran.jpg/jpeg`
 - `.gif` -> `magick.gif` + `gifsicle.gif`
-- other formats (`webp`, `avif`, `heic`, `heif`, `jxl`, etc.) -> `magick.<format>`
+- other image formats (`webp`, `avif`, `heic`, `heif`, `jxl`, etc.) -> `magick.<format>`
+- video formats (`mp4`, `m4v`, `mov`, `webm`, `mkv`, `avi`, `ogv`) -> `ffmpeg.<format>`
 
 Mode behavior:
 
 - default: lossless-first pipeline.
 - `-l, --losy`: lossy + lossless pass per matching compressor.
+- `-m, --mute`: remove audio tracks from video outputs (default: `true`; use `--mute false` to keep audio).
+- `-u, --data-url`: return optimized image as data URL (single file only; image only).
 - `-v, --verbose`: print debug logs (selected pipeline, binaries, executed commands, and errors).
 
 
@@ -79,6 +88,22 @@ await optimo.file('/absolute/path/image.jpg', {
   onLogs: console.log
 })
 
+await optimo.file('/absolute/path/video.mp4', {
+  losy: true,
+  // mute defaults to true for videos; set false to keep audio
+  mute: false,
+  format: 'webm',
+  resize: 'w1280',
+  onLogs: console.log
+})
+
+const { dataUrl } = await optimo.file('/absolute/path/image.jpg', {
+  dataUrl: true,
+  onLogs: console.log
+})
+
+console.log(dataUrl) // data:image/jpeg;base64,...
+
 // optimize a dir recursively
 const result = await optimo.dir('/absolute/path/images')
 

package/bin/help.js

@@ -2,27 +2,34 @@
 
 const { gray, blue } = require('../src/util/colors')
 
-module.exports = gray(`Efortless image optimizer
+module.exports = gray(`Efortless media optimizer
 
 Usage
   $ ${blue('optimo')} <file|dir> [options]
 
 Options
-  -l, --losy  Enable lossy + lossless pass (ImgBot-style aggressive mode)
+  -l, --losy  Enable lossy + lossless passes (default: false)
+  -m, --mute  Remove audio tracks from videos (default: true)
+  -u, --data-url  Return optimized image as data URL (file input only)
   -d, --dry-run  Show what would be optimized without making changes
   -f, --format   Convert output format (e.g. jpeg, webp, avif)
-  -r, --resize   Resize by percentage (50%), size (100kB), width (w960), or height (h480)
+  -r, --resize   Resize by percentage (50%), size (100kB, images only), width (w960), or height (h480)
   -v, --verbose  Print debug logs (commands, pipeline, and errors)
 
 Examples
-  $ optimo image.jpg
-  $ optimo image.jpg --losy
-  $ optimo image.png --dry-run
-  $ optimo image.jpg -d
-  $ optimo image.png -f jpeg
-  $ optimo image.png -r 50%
-  $ optimo image.png -r 100kB
-  $ optimo image.png -r w960
-  $ optimo image.png -r h480
-  $ optimo image.heic -d -v
+  $ optimo image.jpg # optimize a single image in place
+  $ optimo image.jpg --losy # run lossy + lossless optimization passes
+  $ optimo clip.mp4 --mute # optimize video and remove audio track
+  $ optimo clip.mp4 --mute false # optimize video and keep audio track
+  $ optimo image.png --dry-run # preview optimization without writing files
+  $ optimo image.jpg -d # short alias for dry-run preview mode
+  $ optimo image.png -f jpeg # convert PNG to JPEG and optimize
+  $ optimo image.png -r 50% # resize image to 50 percent then optimize
+  $ optimo image.png -r 100kB # resize image to target max file size
+  $ optimo image.png -r w960 # resize image to max width of 960px
+  $ optimo image.png -r h480 # resize image to max height of 480px
+  $ optimo image.png --data-url # output optimized image as data URL
+  $ optimo image.heic -d -v # dry-run HEIC optimization with verbose logs
+  $ optimo clip.mp4 # optimize a single video in place
+  $ optimo clip.mov -f webm # convert MOV to WebM and optimize
 `)

package/bin/index.js

@@ -8,9 +8,11 @@ const mri = require('mri')
 async function main () {
   const argv = mri(process.argv.slice(2), {
     alias: {
+      'data-url': 'u',
       'dry-run': 'd',
       format: 'f',
       losy: 'l',
+      mute: 'm',
       resize: 'r',
       silent: 's',
       verbose: 'v'
@@ -18,6 +20,11 @@ async function main () {
   })
 
   const input = argv._[0]
+  const dataUrl = argv['data-url'] === true
+  const mute =
+    argv.mute === undefined
+      ? true
+      : !['false', '0', 'no', 'off'].includes(String(argv.mute).toLowerCase())
   let resize = argv.resize
 
   if (resize !== undefined && resize !== null) {
@@ -40,17 +47,23 @@ async function main () {
   const isDirectory = stats.isDirectory()
   const fn = isDirectory ? require('optimo').dir : require('optimo').file
 
-  const logger = argv.silent ? () => {} : logEntry => console.log(logEntry)
-  !argv.silent && console.log()
+  const logger = argv.silent ? () => {} : logEntry => console.error(logEntry)
+  !argv.silent && console.error()
 
-  await fn(input, {
+  const result = await fn(input, {
     losy: argv.losy,
+    mute,
     dryRun: argv['dry-run'],
+    dataUrl,
     format: argv.format,
     resize,
     onLogs: logger
   })
 
+  if (dataUrl && result?.dataUrl) {
+    console.log(result.dataUrl)
+  }
+
   process.exit(0)
 }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "optimo",
-  "description": "The no-brainer ImageMagick CLI for optimizing images",
+  "description": "The no-brainer CLI for optimizing images and videos",
   "homepage": "https://github.com/kikobeats/optimo",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "exports": {
     ".": "./src/index.js"
   },
@@ -23,13 +23,17 @@
     "url": "https://github.com/kikobeats/optimo/issues"
   },
   "keywords": [
+    "ffmpeg",
     "image",
     "image-optimization",
     "image-optimizer",
     "imagemagick",
     "images",
     "optimization",
-    "optimize"
+    "optimize",
+    "video",
+    "video-optimization",
+    "video-optimizer"
   ],
   "dependencies": {
     "debug-logfmt": "~1.4.7",

package/src/compressor/ffmpeg.js

@@ -0,0 +1,186 @@
+'use strict'
+
+const path = require('node:path')
+const $ = require('tinyspawn')
+
+const resolveBinary = require('../util/resolve-binary')
+
+const binaryPath = resolveBinary('ffmpeg')
+
+const withMeta = (format, fn) => {
+  const wrapped = async ctx => fn(ctx)
+  wrapped.binaryName = 'ffmpeg'
+  wrapped.binaryPath = binaryPath
+  wrapped.format = format
+  return wrapped
+}
+
+/**
+ * Translate optimo resize config to a FFmpeg `scale` filter.
+ *
+ * Output dimensions are normalized to even numbers because some codecs
+ * (notably H.264) require even width/height to encode correctly.
+ *
+ * @param {{ mode: string, value: string | number } | null} resizeConfig
+ * @returns {string | null}
+ */
+const getScaleFilter = resizeConfig => {
+  if (!resizeConfig) return null
+
+  if (resizeConfig.mode === 'max-size') {
+    throw new TypeError(
+      'Resize max size (e.g. 100kB) is image-only. For videos use percentage (50%), width (w960), or height (h480).'
+    )
+  }
+
+  if (resizeConfig.mode === 'percentage') {
+    const percentage = Number.parseFloat(resizeConfig.value.replace('%', ''))
+    const ratio = percentage / 100
+    return `scale=trunc(iw*${ratio}/2)*2:trunc(ih*${ratio}/2)*2`
+  }
+
+  if (resizeConfig.mode === 'dimension') {
+    if (resizeConfig.value.endsWith('x')) {
+      const width = Number.parseInt(resizeConfig.value.slice(0, -1), 10)
+      return `scale=${width}:-2:force_original_aspect_ratio=decrease`
+    }
+
+    const height = Number.parseInt(resizeConfig.value.slice(1), 10)
+    return `scale=-2:${height}:force_original_aspect_ratio=decrease`
+  }
+
+  return null
+}
+
+/**
+ * Build FFmpeg codec/muxing flags based on output extension.
+ *
+ * Flag glossary used below:
+ * - `-c:v <codec>`: video codec implementation.
+ * - `-crf <n>`: quality target for constant-quality encoders; higher = smaller/worse quality.
+ * - `-b:v 0`: disable target bitrate so CRF drives quality (VP9 mode).
+ * - `-preset <name>`: encoder speed/compression tradeoff.
+ * - `-tile-columns` / `-row-mt`: VP9 parallelism settings with better compression throughput.
+ * - `-frame-parallel 1`: improves VP9 decode compatibility for web playback.
+ * - `-pix_fmt yuv420p`: broadly compatible pixel format for playback.
+ * - `-c:a <codec>` and `-b:a <rate>` / `-q:a <n>`: audio codec and quality.
+ * - `-an`: drop audio entirely from output.
+ * - `-movflags +faststart`: move MP4 metadata (moov atom) to file start for faster streaming start.
+ *
+ * `losy=true` intentionally picks more aggressive values for smaller files.
+ *
+ * @param {{ ext: string, losy?: boolean, mute?: boolean }} params
+ * @returns {string[]}
+ */
+const getCodecArgsByExt = ({ ext, losy = false, mute = true }) => {
+  if (ext === '.webm') {
+    return [
+      '-c:v',
+      'libvpx-vp9',
+      '-b:v',
+      '0',
+      '-crf',
+      losy ? '35' : '31',
+      '-row-mt',
+      '1',
+      '-tile-columns',
+      '2',
+      '-frame-parallel',
+      '1',
+      '-deadline',
+      'good',
+      '-cpu-used',
+      losy ? '2' : '1',
+      '-pix_fmt',
+      'yuv420p',
+      ...(mute ? [] : ['-c:a', 'libopus', '-b:a', losy ? '64k' : '96k'])
+    ]
+  }
+
+  if (ext === '.ogv') {
+    return [
+      '-c:v',
+      'libtheora',
+      '-q:v',
+      losy ? '4' : '6',
+      ...(mute ? [] : ['-c:a', 'libvorbis', '-q:a', losy ? '3' : '4'])
+    ]
+  }
+
+  return [
+    '-c:v',
+    'libx264',
+    '-preset',
+    losy ? 'medium' : 'slow',
+    '-crf',
+    losy ? '28' : '23',
+    '-pix_fmt',
+    'yuv420p',
+    ...(mute ? [] : ['-c:a', 'aac', '-b:a', losy ? '96k' : '128k']),
+    ...(ext === '.mp4' || ext === '.m4v' || ext === '.mov'
+      ? ['-movflags', '+faststart']
+      : [])
+  ]
+}
+
+/**
+ * Encode a video file with conservative defaults:
+ * - strips metadata (`-map_metadata -1`)
+ * - strips chapters/subtitles/data streams for smaller web outputs
+ * - keeps the primary video stream and optional first audio stream (`0:a:0?`)
+ * - applies a resize filter when requested
+ *
+ * @param {{
+ *  inputPath: string,
+ *  outputPath: string,
+ *  resizeConfig?: { mode: string, value: string | number } | null,
+ *  losy?: boolean,
+ *  mute?: boolean
+ * }} params
+ */
+const run = async ({ inputPath, outputPath, resizeConfig, losy = false, mute = true }) => {
+  const ext = path.extname(outputPath).toLowerCase()
+  const scaleFilter = getScaleFilter(resizeConfig)
+  const codecArgs = getCodecArgsByExt({ ext, losy, mute })
+
+  await $(binaryPath, [
+    '-v',
+    'error',
+    '-y',
+    '-i',
+    inputPath,
+    ...(scaleFilter ? ['-vf', scaleFilter] : []),
+    '-map_metadata',
+    '-1',
+    '-map_chapters',
+    '-1',
+    '-dn',
+    '-sn',
+    '-map',
+    '0:v:0',
+    ...(mute ? ['-an'] : ['-map', '0:a:0?']),
+    ...codecArgs,
+    outputPath
+  ])
+}
+
+const mp4 = withMeta('mp4', run)
+const m4v = withMeta('m4v', run)
+const mov = withMeta('mov', run)
+const webm = withMeta('webm', run)
+const mkv = withMeta('mkv', run)
+const avi = withMeta('avi', run)
+const ogv = withMeta('ogv', run)
+const file = withMeta('file', run)
+
+module.exports = {
+  binaryPath,
+  mp4,
+  m4v,
+  mov,
+  webm,
+  mkv,
+  avi,
+  ogv,
+  file
+}

package/src/compressor/index.js

@@ -5,6 +5,7 @@ const path = require('node:path')
 const mozjpegtran = require('./mozjpegtran')
 const gifsicle = require('./gifsicle')
 const magick = require('./magick')
+const ffmpeg = require('./ffmpeg')
 const svgo = require('./svgo')
 
 const PIPELINES = {
@@ -17,7 +18,14 @@ const PIPELINES = {
   '.avif': [magick.avif],
   '.heic': [magick.heic],
   '.heif': [magick.heif],
-  '.jxl': [magick.jxl]
+  '.jxl': [magick.jxl],
+  '.mp4': [ffmpeg.mp4],
+  '.m4v': [ffmpeg.m4v],
+  '.mov': [ffmpeg.mov],
+  '.webm': [ffmpeg.webm],
+  '.mkv': [ffmpeg.mkv],
+  '.avi': [ffmpeg.avi],
+  '.ogv': [ffmpeg.ogv]
 }
 
 const getPipeline = filePath => {

package/src/compressor/magick.js

@@ -10,6 +10,7 @@ const resolveBinary = require('../util/resolve-binary')
 const binaryPath = resolveBinary('magick')
 
 const PNG_QUALITY_CANDIDATES = [91, 94, 95, 97]
+const PNG_COMPRESSION_STRATEGY_CANDIDATES = [null, 0]
 
 const withMeta = (format, fn) => {
   const wrapped = async ctx => fn(ctx)
@@ -89,31 +90,36 @@ const isAnimatedPng = ({ filePath }) => {
 }
 
 const writePng = async ({ inputPath, outputPath, flags, resizeGeometry }) => {
-  const writeCandidates = isAnimatedPng({ filePath: inputPath }) ? [90] : PNG_QUALITY_CANDIDATES
+  const animated = isAnimatedPng({ filePath: inputPath })
+  const writeCandidates = animated ? [90] : PNG_QUALITY_CANDIDATES
+  const strategyCandidates = animated ? [null] : PNG_COMPRESSION_STRATEGY_CANDIDATES
   const candidatePaths = []
   let bestPath = null
   let bestSize = Number.POSITIVE_INFINITY
 
   try {
     for (const quality of writeCandidates) {
-      const candidatePath = `${outputPath}.q${quality}.png`
-      candidatePaths.push(candidatePath)
-
-      const args = [
-        inputPath,
-        ...(resizeGeometry ? ['-resize', resizeGeometry] : []),
-        ...flags,
-        '-quality',
-        String(quality),
-        candidatePath
-      ]
-
-      await $(binaryPath, args)
-      const size = (await stat(candidatePath)).size
-
-      if (size < bestSize) {
-        bestSize = size
-        bestPath = candidatePath
+      for (const compressionStrategy of strategyCandidates) {
+        const candidatePath = `${outputPath}.q${quality}${compressionStrategy === null ? '' : `.s${compressionStrategy}`}.png`
+        candidatePaths.push(candidatePath)
+
+        const args = [
+          inputPath,
+          ...(resizeGeometry ? ['-resize', resizeGeometry] : []),
+          ...flags,
+          ...(compressionStrategy === null ? [] : ['-define', `png:compression-strategy=${compressionStrategy}`]),
+          '-quality',
+          String(quality),
+          candidatePath
+        ]
+
+        await $(binaryPath, args)
+        const size = (await stat(candidatePath)).size
+
+        if (size < bestSize) {
+          bestSize = size
+          bestPath = candidatePath
+        }
       }
     }
 

package/src/compressor/mozjpegtran.js

@@ -17,11 +17,12 @@ const withMeta = (format, fn) => {
   return wrapped
 }
 
-const run = async ({ inputPath, outputPath }) =>
+const run = async ({ inputPath, outputPath, losy = false }) =>
   $(mozjpegtranPath, [
     '-copy',
-    'none',
+    losy ? 'none' : 'all',
     '-optimize',
+    '-progressive',
     '-outfile',
     outputPath,
     inputPath

package/src/index.js

@@ -1,26 +1,29 @@
 'use strict'
 
-const { stat, unlink, rename, readdir, copyFile } = require('node:fs/promises')
+const { stat, unlink, rename, readdir, copyFile, readFile } = require('node:fs/promises')
 const path = require('node:path')
 
 const { getPipeline, getRequiredBinaries } = require('./compressor')
 const ensureBinaries = require('./util/ensure-binaries')
 const { yellow, gray, green } = require('./util/colors')
 const getOutputPath = require('./util/get-output-path')
+const getMediaKind = require('./util/get-media-kind')
 const formatBytes = require('./util/format-bytes')
 const parseResize = require('./util/parse-resize')
+const toDataUrl = require('./util/to-data-url')
 const percentage = require('./util/percentage')
 const formatLog = require('./util/format-log')
 const debug = require('./util/debug')
 
-const runStepInPlaceIfSmaller = async ({ currentPath, extension, step }) => {
+const runStepInPlaceIfSmaller = async ({ currentPath, extension, step, mute }) => {
   const candidatePath = `${currentPath}.candidate${extension}`
 
   await step({
     inputPath: currentPath,
     outputPath: candidatePath,
     resizeConfig: null,
-    losy: false
+    losy: false,
+    mute
   })
 
   const [currentSize, candidateSize] = await Promise.all([
@@ -36,20 +39,22 @@ const runStepInPlaceIfSmaller = async ({ currentPath, extension, step }) => {
   }
 }
 
-const executePipeline = async ({ pipeline, filePath, optimizedPath, resizeConfig, losy }) => {
+const executePipeline = async ({ pipeline, filePath, optimizedPath, resizeConfig, losy, mute }) => {
   const extension = path.extname(optimizedPath) || '.tmp'
 
   await pipeline[0]({
     inputPath: filePath,
     outputPath: optimizedPath,
     resizeConfig,
-    losy
+    losy,
+    mute
   })
 
   for (const step of pipeline.slice(1)) {
     await runStepInPlaceIfSmaller({
       currentPath: optimizedPath,
       extension,
+      mute,
       step: async args => step({ ...args, losy })
     })
   }
@@ -57,14 +62,42 @@ const executePipeline = async ({ pipeline, filePath, optimizedPath, resizeConfig
   return (await stat(optimizedPath)).size
 }
 
-const file = async (filePath, { onLogs = () => {}, dryRun, format: outputFormat, resize, losy = false } = {}) => {
+const file = async (
+  filePath,
+  { onLogs = () => {}, dryRun, format: outputFormat, resize, losy = false, mute = true, dataUrl = false } = {}
+) => {
   const outputPath = getOutputPath(filePath, outputFormat)
   const resizeConfig = parseResize(resize)
+  const mediaKind = getMediaKind(outputPath)
   const filePipeline = getPipeline(outputPath)
   const executionPipeline = [...filePipeline]
+  const isConverting = outputPath !== filePath
+  const outputExt = path.extname(outputPath).toLowerCase()
+
+  const canUseJpegLosslessFastPath =
+    !losy &&
+    !resizeConfig &&
+    !isConverting &&
+    (outputExt === '.jpg' || outputExt === '.jpeg') &&
+    executionPipeline[0]?.binaryName === 'magick' &&
+    executionPipeline[1]?.binaryName === 'mozjpegtran'
+
+  if (canUseJpegLosslessFastPath) {
+    executionPipeline.shift()
+  }
+
+  if (mediaKind === 'video' && resizeConfig?.mode === 'max-size') {
+    throw new TypeError(
+      'Resize max size (e.g. 100kB) is image-only. For videos use percentage (50%), width (w960), or height (h480).'
+    )
+  }
+
+  if (dataUrl && mediaKind !== 'image') {
+    throw new TypeError('Data URL output is only supported for images.')
+  }
 
   const needsMagickForTransform = Boolean(resizeConfig) || outputPath !== filePath
-  if (needsMagickForTransform && executionPipeline[0]?.binaryName !== 'magick') {
+  if (mediaKind === 'image' && needsMagickForTransform && executionPipeline[0]?.binaryName !== 'magick') {
     const magick = require('./compressor/magick')
     const ext = path.extname(outputPath).toLowerCase().replace(/^\./, '')
     const magickStep = magick[ext] || magick.file
@@ -78,7 +111,6 @@ const file = async (filePath, { onLogs = () => {}, dryRun, format: outputFormat,
   )
 
   const optimizedPath = `${outputPath}.optimized${path.extname(outputPath)}`
-  const isConverting = outputPath !== filePath
 
   let originalSize
   let optimizedSize
@@ -95,7 +127,8 @@ const file = async (filePath, { onLogs = () => {}, dryRun, format: outputFormat,
         filePath,
         optimizedPath,
         resizeConfig,
-        losy
+        losy,
+        mute
       })
     }
   } catch (error) {
@@ -123,7 +156,24 @@ const file = async (filePath, { onLogs = () => {}, dryRun, format: outputFormat,
   if (!isConverting && optimizedSize >= originalSize) {
     await unlink(optimizedPath)
     onLogs(formatLog('[optimized]', gray, filePath))
-    return { originalSize, optimizedSize: originalSize }
+
+    const result = { originalSize, optimizedSize: originalSize }
+    if (dataUrl) {
+      result.dataUrl = toDataUrl({
+        filePath,
+        content: await readFile(filePath)
+      })
+    }
+
+    return result
+  }
+
+  let outputDataUrl = null
+  if (dataUrl) {
+    outputDataUrl = toDataUrl({
+      filePath: outputPath,
+      content: await readFile(optimizedPath)
+    })
   }
 
   if (dryRun) {
@@ -154,10 +204,16 @@ const file = async (filePath, { onLogs = () => {}, dryRun, format: outputFormat,
     )
   )
 
-  return { originalSize, optimizedSize }
+  const result = { originalSize, optimizedSize }
+  if (outputDataUrl) result.dataUrl = outputDataUrl
+  return result
 }
 
 const dir = async (folderPath, opts) => {
+  if (opts?.dataUrl) {
+    throw new TypeError('Data URL output is only supported when optimizing a single image file.')
+  }
+
   const items = (await readdir(folderPath, { withFileTypes: true })).filter(item => !item.name.startsWith('.'))
   let totalOriginalSize = 0
   let totalOptimizedSize = 0

package/src/util/get-media-kind.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const path = require('node:path')
+
+const VIDEO_EXTENSIONS = new Set([
+  '.mp4',
+  '.m4v',
+  '.mov',
+  '.webm',
+  '.mkv',
+  '.avi',
+  '.ogv'
+])
+
+module.exports = filePath => {
+  const ext = path.extname(filePath).toLowerCase()
+  return VIDEO_EXTENSIONS.has(ext) ? 'video' : 'image'
+}

package/src/util/to-data-url.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const path = require('node:path')
+
+const MIME_TYPES_BY_EXTENSION = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.heic': 'image/heic',
+  '.heif': 'image/heif',
+  '.jxl': 'image/jxl',
+  '.svg': 'image/svg+xml',
+  '.bmp': 'image/bmp',
+  '.tif': 'image/tiff',
+  '.tiff': 'image/tiff'
+}
+
+const getMimeType = filePath => MIME_TYPES_BY_EXTENSION[path.extname(filePath).toLowerCase()] || 'application/octet-stream'
+
+module.exports = ({ filePath, content }) => {
+  const mimeType = getMimeType(filePath)
+  return `data:${mimeType};base64,${content.toString('base64')}`
+}