fontmin-rs 0.1.0-beta.1

package/bin/fontmin-rs.mjs

@@ -0,0 +1,1425 @@
+#!/usr/bin/env node
+
+import { createHash } from 'node:crypto'
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import { basename, dirname, extname, join, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import {
+  eotToTtf,
+  generateFontFaceCss,
+  inspectFont,
+  subsetTtf,
+  svgsToTtf,
+  ttfToEot,
+  ttfToSvg,
+  ttfToWoff,
+  ttfToWoff2,
+  woff2ToTtf,
+  woffToTtf,
+} from '@fontmin-rs/binding'
+import { parse as parseJsonc } from 'jsonc-parser'
+import { glob } from 'tinyglobby'
+
+const DEFAULT_CONFIG_FILES = [
+  'fontmin.config.ts',
+  'fontmin.config.mts',
+  'fontmin.config.mjs',
+  'fontmin.config.cjs',
+  'fontmin.config.json',
+  'fontmin.config.jsonc',
+]
+const MODULE_CONFIG_EXTENSIONS = new Set(['.ts', '.mts', '.mjs', '.cjs'])
+const INIT_CONFIG_FILE = 'fontmin.config.jsonc'
+const CACHE_SCHEMA_VERSION = 'v1'
+const FONTMIN_VERSION = '0.1.0-beta.1'
+const DEFAULT_CACHE_DIR = 'node_modules/.cache/fontmin-rs'
+const DEFAULT_INIT_CONFIG = `{
+  // Generated by fontmin-rs init.
+  "input": ["fonts/*.ttf"],
+  "outDir": "build",
+  "subset": {
+    "text": "Hello",
+    "basicText": true
+  },
+  "outputs": [
+    { "format": "woff2" },
+    { "format": "woff" },
+    { "format": "css" }
+  ],
+  "css": {
+    "fontFamily": "MyFont",
+    "fontPath": "./",
+    "fontDisplay": "swap"
+  },
+  "cache": {
+    "enabled": true
+  }
+}
+`
+
+const argv = process.argv.slice(2)
+const command = argv[0]
+const commandArgs = argv.slice(1)
+
+try {
+  if (command === 'subset') {
+    await subsetCommand(commandArgs)
+  } else if (command === 'convert') {
+    await convertCommand(commandArgs)
+  } else if (command === 'build') {
+    await buildCommand(commandArgs)
+  } else if (command === 'inspect') {
+    await inspectCommand(commandArgs)
+  } else if (command === 'init') {
+    await initCommand()
+  } else if (command === 'bench') {
+    await benchCommand(commandArgs)
+  } else {
+    usage()
+    process.exitCode = 1
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error))
+  process.exitCode = 1
+}
+
+async function subsetCommand(args) {
+  const output = readOption(args, ['-o', '--output'])
+  const subsetOptions = await subsetOptionsFromArgs(args)
+  const basicText = readFlag(args, ['-b', '--basic-text'])
+  const [input] = args
+
+  requireValue(input, 'subset requires an input font')
+  requireValue(output, 'subset requires -o, --output')
+  if (
+    subsetOptions.text === undefined &&
+    subsetOptions.unicodes.length === 0 &&
+    !basicText
+  ) {
+    throw new Error(
+      'subset requires --text, --text-file, --unicodes, or --basic-text',
+    )
+  }
+
+  const contents = await readFile(input)
+  const subset = subsetTtf(contents, {
+    basicText,
+    text: subsetOptions.text,
+    unicodes: subsetOptions.unicodes,
+  })
+
+  await writeOutput(output, subset)
+}
+
+async function convertCommand(args) {
+  const output = readOption(args, ['-o', '--output'])
+  const format = readOption(args, ['-f', '--format'])
+  const [input] = args
+
+  requireValue(input, 'convert requires an input font')
+  requireValue(output, 'convert requires -o, --output')
+  requireValue(format, 'convert requires -f, --format')
+
+  const contents = await readFile(input)
+  const converted = convertFont(contents, format)
+
+  await writeOutput(output, converted)
+}
+
+async function benchCommand(args) {
+  const json = readFlag(args, ['--json'])
+  const basicText = readFlag(args, ['-b', '--basic-text'])
+  const subsetOptions = await subsetOptionsFromArgs(args)
+  const [input] = args
+
+  requireValue(input, 'bench requires an input font')
+  if (
+    subsetOptions.text === undefined &&
+    subsetOptions.unicodes.length === 0 &&
+    !basicText
+  ) {
+    throw new Error(
+      'bench requires --text, --text-file, --unicodes, or --basic-text',
+    )
+  }
+
+  const contents = await readFile(input)
+  const startedAt = process.hrtime.bigint()
+  const subset = subsetTtf(contents, {
+    basicText,
+    text: subsetOptions.text,
+    unicodes: subsetOptions.unicodes,
+  })
+  const elapsedMs = Math.round(
+    Number(process.hrtime.bigint() - startedAt) / 1_000_000,
+  )
+  const report = {
+    elapsedMs,
+    inputBytes: contents.byteLength,
+    operation: 'subset',
+    outputBytes: subset.byteLength,
+  }
+
+  if (json) {
+    process.stdout.write(`${JSON.stringify(report)}\n`)
+  } else {
+    process.stdout.write(
+      `fontmin-rs bench subset completed in ${elapsedMs} ms\ninput: ${report.inputBytes} bytes\noutput: ${report.outputBytes} bytes\n`,
+    )
+  }
+}
+
+async function buildCommand(args) {
+  const showTime = readFlag(args, ['-T', '--show-time'])
+  const silent = readFlag(args, ['--silent'])
+  const startedAt = showTime && !silent ? process.hrtime.bigint() : undefined
+
+  await runBuildCommand(args)
+  reportShowTime(startedAt)
+}
+
+async function runBuildCommand(args) {
+  const configPath = readOption(args, ['-c', '--config'])
+  const cache = readFlag(args, ['--cache'])
+  const noCache = readFlag(args, ['--no-cache'])
+  const noOriginal = readFlag(args, ['--no-original'])
+  readFlag(args, ['-d', '--deflate-woff'])
+  const cssGlyph = readFlag(args, ['--css-glyph'])
+  const outDir = readOption(args, ['-o', '--out-dir'])
+  const formats = readOption(args, ['--formats'])
+  const preset = readOption(args, ['--preset'])
+  const basicText = readFlag(args, ['-b', '--basic-text'])
+  const fontFamily = readOption(args, ['--font-family'])
+  const fontPath = readOption(args, ['--font-path'])
+  const subsetOptions = await subsetOptionsFromArgs(args)
+
+  if (cache && noCache) {
+    throw new Error('build accepts only one of --cache or --no-cache')
+  }
+
+  const cacheOverride = cacheOverrideFromFlags(cache, noCache)
+
+  if (configPath !== undefined) {
+    if (isIconfontPreset(preset)) {
+      await buildIconfontConfigCommand(configPath, {
+        fontFamily,
+        fontPath,
+        formats,
+        inputs: [...args],
+        cacheOverride,
+        outDir,
+      })
+      return
+    }
+
+    await buildConfigCommand(configPath, {
+      basicText,
+      cacheOverride,
+      cssGlyph,
+      fontFamily,
+      fontPath,
+      formats,
+      inputs: [...args],
+      noOriginal,
+      outDir,
+      preset,
+      subsetOptions,
+    })
+    return
+  }
+
+  if (args.length === 0) {
+    const foundConfigPath = await findConfig()
+
+    if (isIconfontPreset(preset)) {
+      await buildIconfontConfigCommand(foundConfigPath, {
+        fontFamily,
+        fontPath,
+        formats,
+        cacheOverride,
+        outDir,
+      })
+      return
+    }
+
+    await buildConfigCommand(foundConfigPath, {
+      basicText,
+      cacheOverride,
+      cssGlyph,
+      fontFamily,
+      fontPath,
+      formats,
+      noOriginal,
+      outDir,
+      preset,
+      subsetOptions,
+    })
+    return
+  }
+
+  const inputPatterns = [...args]
+  const [input] = inputPatterns
+
+  requireValue(input, 'build requires an input font')
+  requireValue(outDir, 'build requires -o, --out-dir')
+
+  if (isIconfontPreset(preset)) {
+    if (formats !== undefined) {
+      throw new Error('build accepts only one of --formats or --preset')
+    }
+
+    const inputs = await expandInputPaths(inputPatterns, process.cwd())
+    const cacheOptions = normalizeCacheOptions(
+      undefined,
+      process.cwd(),
+      cacheOverride,
+    )
+
+    await buildIconfontCommand(
+      inputs,
+      outDir,
+      fontFamily,
+      fontPath ?? './',
+      [],
+      {},
+      cacheOptions,
+    )
+    return
+  }
+
+  const inputs = await expandInputPaths(inputPatterns, process.cwd())
+  const outputFormats = filterOriginalOutput(
+    outputFormatsFromArgs(formats, preset),
+    noOriginal,
+  )
+  const cacheOptions = normalizeCacheOptions(
+    undefined,
+    process.cwd(),
+    cacheOverride,
+  )
+  if (outputFormats.length === 0) {
+    throw new Error('build requires at least one non-original output format')
+  }
+
+  await mkdir(outDir, { recursive: true })
+
+  for (const input of inputs) {
+    await buildDirectInput(input, outDir, {
+      basicText,
+      cacheOptions,
+      cssGlyph,
+      fontFamily,
+      fontPath,
+      outputFormats,
+      subsetOptions,
+    })
+  }
+}
+
+async function buildDirectInput(
+  input,
+  outDir,
+  {
+    basicText,
+    cacheOptions,
+    cssGlyph,
+    fontFamily,
+    fontPath,
+    outputFormats,
+    subsetOptions,
+  },
+) {
+  const contents = await readFile(input)
+  const baseName = basename(input, extname(input))
+  const cacheKey = cacheOptions.enabled
+    ? cacheKeyForBuildInput({
+        contents,
+        input,
+        kind: 'direct',
+        options: {
+          basicText,
+          cssGlyph,
+          fontFamily,
+          fontPath,
+          outputFormats,
+          subset: subsetOptions,
+        },
+      })
+    : undefined
+  const cachedOutputs =
+    cacheKey === undefined
+      ? undefined
+      : await readCachedBuildOutputs(cacheOptions.dir, cacheKey)
+
+  if (cachedOutputs !== undefined) {
+    await writeBuildOutputs(outDir, cachedOutputs)
+    return
+  }
+
+  const source =
+    subsetOptions.text === undefined &&
+    subsetOptions.unicodes.length === 0 &&
+    !basicText
+      ? contents
+      : subsetTtf(contents, {
+          basicText,
+          text: subsetOptions.text,
+          unicodes: subsetOptions.unicodes,
+        })
+  const cssGlyphs = cssGlyph ? cssGlyphsFromSubset(subsetOptions) : []
+  const cssSources = []
+  const outputs = []
+
+  for (const format of outputFormats.filter(format => format !== 'css')) {
+    const fileName = `${baseName}.${format}`
+    const output = convertFont(source, format)
+
+    outputs.push({ contents: output, fileName })
+    cssSources.push({
+      ...(cssGlyphs.length > 0 && { glyphs: cssGlyphs }),
+      fileName,
+      format,
+    })
+  }
+
+  if (outputFormats.includes('css')) {
+    if (cssSources.length === 0) {
+      throw new Error('build CSS output requires at least one font format')
+    }
+
+    outputs.push({
+      contents: Buffer.from(
+        generateFontFaceCss(cssSources, {
+          fontFamily: fontFamily ?? baseName,
+          fontPath: fontPath ?? './',
+          glyph: cssGlyph,
+        }),
+      ),
+      fileName: `${baseName}.css`,
+    })
+  }
+
+  await writeBuildOutputs(outDir, outputs)
+
+  if (cacheKey !== undefined) {
+    await writeCachedBuildOutputs(cacheOptions.dir, cacheKey, outputs)
+  }
+}
+
+function reportShowTime(startedAt) {
+  if (startedAt === undefined) {
+    return
+  }
+
+  const elapsedMs = Number(process.hrtime.bigint() - startedAt) / 1_000_000
+
+  process.stdout.write(
+    `fontmin-rs build completed in ${Math.round(elapsedMs)} ms\n`,
+  )
+}
+
+async function buildIconfontCommand(
+  inputs,
+  outDir,
+  fontFamily,
+  fontPath,
+  outputs = [],
+  css = {},
+  cacheOptions = normalizeCacheOptions(undefined, process.cwd()),
+) {
+  if (inputs.length === 0) {
+    throw new Error('build requires at least one input font')
+  }
+
+  const family = fontFamily ?? 'iconfont'
+  const icons = await Promise.all(
+    inputs.map(async input => ({
+      contents: await readFile(input, 'utf8'),
+      name: basename(input, extname(input)),
+    })),
+  )
+  const cacheKey = cacheOptions.enabled
+    ? cacheKeyForIconfontBuild({
+        icons,
+        inputs,
+        options: {
+          css,
+          fontFamily,
+          fontPath,
+          outputs,
+        },
+      })
+    : undefined
+  const cachedOutputs =
+    cacheKey === undefined
+      ? undefined
+      : await readCachedBuildOutputs(cacheOptions.dir, cacheKey)
+
+  if (cachedOutputs !== undefined) {
+    await writeBuildOutputs(outDir, cachedOutputs)
+    return
+  }
+
+  const ttf = svgsToTtf(icons, {
+    fontName: family,
+  })
+  const fileName = outputFileName(outputs, 'ttf', 'iconfont.ttf')
+  const cssFileName = outputFileName(
+    outputs,
+    'css',
+    `${basename(fileName, extname(fileName))}.${css.target ?? 'css'}`,
+  )
+  const glyphs = icons.map((icon, index) => ({
+    name: icon.name,
+    unicode: 57_345 + index,
+  }))
+  const buildOutputs = [
+    {
+      contents: ttf,
+      fileName,
+    },
+    {
+      contents: Buffer.from(
+        generateFontFaceCss(
+          [
+            {
+              ...(css.base64 === true && { contents: ttf }),
+              fileName,
+              format: 'ttf',
+              glyphs,
+            },
+          ],
+          {
+            asFileName: css.asFileName ?? true,
+            base64: css.base64,
+            fontDisplay: css.fontDisplay,
+            fontFamily: family,
+            fontPath,
+            glyph: true,
+            iconPrefix: css.iconPrefix,
+            local: css.local,
+          },
+        ),
+      ),
+      fileName: cssFileName,
+    },
+  ]
+
+  await writeBuildOutputs(outDir, buildOutputs)
+
+  if (cacheKey !== undefined) {
+    await writeCachedBuildOutputs(cacheOptions.dir, cacheKey, buildOutputs)
+  }
+}
+
+async function buildConfigCommand(
+  configPath,
+  {
+    basicText,
+    cacheOverride,
+    cssGlyph,
+    fontFamily,
+    fontPath,
+    formats,
+    inputs: inputOverrides = [],
+    noOriginal,
+    outDir: outDirOverride,
+    preset,
+    subsetOptions,
+  } = {},
+) {
+  const resolvedConfigPath = resolve(configPath)
+  const config = await readConfig(resolvedConfigPath)
+  const cwd =
+    typeof config.cwd === 'string'
+      ? resolve(config.cwd)
+      : dirname(resolvedConfigPath)
+  const inputs =
+    inputOverrides.length > 0 ? inputOverrides : (config.input ?? [])
+  const outDir = resolve(cwd, outDirOverride ?? config.outDir ?? 'build')
+  const outputFormats = outputFormatsForConfig(config.outputs, {
+    formats,
+    noOriginal,
+    preset,
+  })
+  const cacheOptions = normalizeCacheOptions(config.cache, cwd, cacheOverride)
+
+  if (inputs.length === 0) {
+    throw new Error('build config requires at least one input')
+  }
+
+  if (fontFamily !== undefined || fontPath !== undefined || cssGlyph === true) {
+    config.css = {
+      ...config.css,
+      ...(cssGlyph === true && { glyph: true }),
+      ...(fontFamily !== undefined && { fontFamily }),
+      ...(fontPath !== undefined && { fontPath }),
+    }
+  }
+
+  applySubsetOverrides(config, { basicText, subsetOptions })
+
+  if (config.clean === true) {
+    await rm(outDir, { recursive: true, force: true })
+  }
+
+  await mkdir(outDir, { recursive: true })
+
+  for (const input of inputs) {
+    if (typeof input !== 'string') {
+      throw new TypeError('build config input entries must be file paths')
+    }
+
+    for (const inputPath of await expandInputPath(input, cwd)) {
+      await buildConfigInput(
+        inputPath,
+        outDir,
+        outputFormats,
+        config,
+        cwd,
+        cacheOptions,
+      )
+    }
+  }
+}
+
+async function buildIconfontConfigCommand(
+  configPath,
+  {
+    cacheOverride,
+    fontFamily,
+    fontPath,
+    formats,
+    inputs: inputOverrides = [],
+    outDir: outDirOverride,
+  },
+) {
+  if (formats !== undefined) {
+    throw new Error('build accepts only one of --formats or --preset')
+  }
+
+  const resolvedConfigPath = resolve(configPath)
+  const config = await readConfig(resolvedConfigPath)
+  const cwd =
+    typeof config.cwd === 'string'
+      ? resolve(config.cwd)
+      : dirname(resolvedConfigPath)
+  const outDir = resolve(cwd, outDirOverride ?? config.outDir ?? 'build')
+  const inputs = await expandConfigInputPaths(
+    inputOverrides.length > 0 ? inputOverrides : (config.input ?? []),
+    cwd,
+  )
+  const css = config.css ?? {}
+  const cacheOptions = normalizeCacheOptions(config.cache, cwd, cacheOverride)
+
+  if (config.clean === true) {
+    await rm(outDir, { recursive: true, force: true })
+  }
+
+  await buildIconfontCommand(
+    inputs,
+    outDir,
+    fontFamily ?? css.fontFamily,
+    fontPath ?? css.fontPath ?? './',
+    config.outputs ?? [],
+    css,
+    cacheOptions,
+  )
+}
+
+function expandConfigInputPaths(inputs, cwd) {
+  return expandInputPaths(inputs, cwd)
+}
+
+async function expandInputPaths(inputs, cwd) {
+  if (inputs.length === 0) {
+    throw new Error('build config requires at least one input')
+  }
+
+  const paths = []
+
+  for (const input of inputs) {
+    if (typeof input !== 'string') {
+      throw new TypeError('build config input entries must be file paths')
+    }
+
+    paths.push(...(await expandInputPath(input, cwd)))
+  }
+
+  return paths
+}
+
+function outputFileName(outputs, format, fallback) {
+  const output = outputs.find(output => output?.format === format)
+
+  if (typeof output?.fileName === 'string') {
+    return output.fileName
+  }
+
+  if (typeof output?.ext === 'string') {
+    return `${basename(fallback, extname(fallback))}.${output.ext.replace(/^\./u, '')}`
+  }
+
+  return fallback
+}
+
+function applySubsetOverrides(config, { basicText, subsetOptions } = {}) {
+  if (
+    subsetOptions === undefined ||
+    (subsetOptions.text === undefined &&
+      subsetOptions.unicodes.length === 0 &&
+      basicText !== true)
+  ) {
+    return
+  }
+
+  config.subset = {
+    ...config.subset,
+    ...(subsetOptions.text !== undefined && { text: subsetOptions.text }),
+    ...(subsetOptions.unicodes.length > 0 && {
+      unicodes: subsetOptions.unicodes,
+    }),
+    ...(basicText === true && { basicText }),
+  }
+}
+
+async function buildConfigInput(
+  input,
+  outDir,
+  outputFormats,
+  config,
+  cwd,
+  cacheOptions,
+) {
+  const contents = await readFile(input)
+  const subset = await resolveSubsetTextFile(config.subset ?? {}, cwd)
+  const unicodes = subset.unicodes ?? []
+  const cacheKey = cacheOptions.enabled
+    ? cacheKeyForBuildInput({
+        contents,
+        input,
+        kind: 'config',
+        options: {
+          css: config.css,
+          outputFormats,
+          outputs: config.outputs,
+          subset,
+        },
+      })
+    : undefined
+  const cachedOutputs =
+    cacheKey === undefined
+      ? undefined
+      : await readCachedBuildOutputs(cacheOptions.dir, cacheKey)
+
+  if (cachedOutputs !== undefined) {
+    await writeBuildOutputs(outDir, cachedOutputs)
+    return
+  }
+
+  const source =
+    subset.text === undefined &&
+    unicodes.length === 0 &&
+    subset.basicText !== true
+      ? contents
+      : subsetTtf(contents, {
+          basicText: subset.basicText,
+          text: subset.text,
+          unicodes,
+        })
+  const baseName = basename(input, extname(input))
+  const css = config.css ?? {}
+  const cssGlyphs = css.glyph === true ? cssGlyphsFromSubset(subset) : []
+  const cssSources = []
+  const outputs = config.outputs ?? []
+  const buildOutputs = []
+
+  for (const format of outputFormats.filter(format => format !== 'css')) {
+    const fileName = outputFileName(outputs, format, `${baseName}.${format}`)
+    const output = convertFont(source, format)
+
+    buildOutputs.push({ contents: output, fileName })
+    cssSources.push({
+      ...(css.base64 === true && { contents: output }),
+      ...(cssGlyphs.length > 0 && { glyphs: cssGlyphs }),
+      fileName,
+      format,
+    })
+  }
+
+  if (outputFormats.includes('css')) {
+    if (cssSources.length === 0) {
+      throw new Error('build CSS output requires at least one font format')
+    }
+
+    const firstCssSource = cssSources[0]
+    const cssFileName = outputFileName(
+      outputs,
+      'css',
+      `${basename(firstCssSource.fileName, extname(firstCssSource.fileName))}.${css.target ?? 'css'}`,
+    )
+
+    buildOutputs.push({
+      contents: Buffer.from(
+        generateFontFaceCss(cssSources, {
+          asFileName: css.asFileName,
+          base64: css.base64,
+          fontDisplay: css.fontDisplay,
+          fontFamily: css.fontFamily ?? baseName,
+          fontPath: css.fontPath ?? './',
+          glyph: css.glyph,
+          iconPrefix: css.iconPrefix,
+          local: css.local,
+        }),
+      ),
+      fileName: cssFileName,
+    })
+  }
+
+  await writeBuildOutputs(outDir, buildOutputs)
+
+  if (cacheKey !== undefined) {
+    await writeCachedBuildOutputs(cacheOptions.dir, cacheKey, buildOutputs)
+  }
+}
+
+function cssGlyphsFromSubset(subset) {
+  const seen = new Set()
+  const glyphs = []
+
+  for (const character of subset.text ?? '') {
+    const unicode = character.codePointAt(0)
+
+    if (unicode !== undefined && !seen.has(unicode)) {
+      seen.add(unicode)
+      glyphs.push({ unicode })
+    }
+  }
+
+  for (const unicode of subset.unicodes ?? []) {
+    if (!seen.has(unicode)) {
+      seen.add(unicode)
+      glyphs.push({ unicode })
+    }
+  }
+
+  return glyphs
+}
+
+async function writeBuildOutputs(outDir, outputs) {
+  await mkdir(outDir, { recursive: true })
+
+  for (const output of outputs) {
+    await writeFile(join(outDir, output.fileName), output.contents)
+  }
+}
+
+async function readCachedBuildOutputs(cacheDir, key) {
+  let manifest = null
+
+  try {
+    manifest = JSON.parse(
+      await readFile(cacheManifestPath(cacheDir, key), 'utf8'),
+    )
+  } catch {
+    return
+  }
+
+  if (manifest.version !== CACHE_SCHEMA_VERSION || manifest.key !== key) {
+    return
+  }
+
+  const entryDir = cacheEntryDir(cacheDir, key)
+  const outputs = []
+
+  try {
+    for (const record of manifest.outputs) {
+      outputs.push({
+        contents: await readFile(join(entryDir, record.cacheFileName)),
+        fileName: record.fileName,
+      })
+    }
+  } catch {
+    return
+  }
+
+  return outputs
+}
+
+async function writeCachedBuildOutputs(cacheDir, key, outputs) {
+  const entryDir = cacheEntryDir(cacheDir, key)
+  const records = []
+
+  await mkdir(entryDir, { recursive: true })
+
+  for (const [index, output] of outputs.entries()) {
+    const extension = extname(output.fileName).replace(/^\./u, '') || 'bin'
+    const cacheFileName = `${String(index).padStart(3, '0')}.${extension}`
+
+    await writeFile(join(entryDir, cacheFileName), output.contents)
+    records.push({
+      cacheFileName,
+      fileName: output.fileName,
+    })
+  }
+
+  await writeFile(
+    cacheManifestPath(cacheDir, key),
+    `${JSON.stringify(
+      {
+        key,
+        outputs: records,
+        version: CACHE_SCHEMA_VERSION,
+      },
+      undefined,
+      2,
+    )}\n`,
+  )
+  await updateBuildCacheIndex(cacheDir, key, records)
+}
+
+async function updateBuildCacheIndex(cacheDir, key, outputs) {
+  const indexPath = cacheIndexPath(cacheDir)
+  let index = {
+    entries: {},
+    version: CACHE_SCHEMA_VERSION,
+  }
+
+  try {
+    index = JSON.parse(await readFile(indexPath, 'utf8'))
+  } catch {
+    // A missing or corrupted cache index can be rebuilt from the next writes.
+  }
+
+  if (index.version !== CACHE_SCHEMA_VERSION) {
+    index = {
+      entries: {},
+      version: CACHE_SCHEMA_VERSION,
+    }
+  }
+
+  index.entries[key] = {
+    outputs: outputs.map(output => output.fileName),
+    updatedAt: new Date().toISOString(),
+  }
+
+  await mkdir(dirname(indexPath), { recursive: true })
+  await writeFile(indexPath, `${JSON.stringify(index, undefined, 2)}\n`)
+}
+
+function normalizeCacheOptions(options, cwd, override) {
+  const configuredDir =
+    typeof options === 'object' &&
+    options !== null &&
+    typeof options.dir === 'string'
+      ? options.dir
+      : DEFAULT_CACHE_DIR
+
+  if (override === true) {
+    return {
+      dir: resolve(cwd, configuredDir),
+      enabled: true,
+    }
+  }
+
+  if (override === false || options === undefined || options === false) {
+    return {
+      dir: resolve(cwd, configuredDir),
+      enabled: false,
+    }
+  }
+
+  if (options === true) {
+    return {
+      dir: resolve(cwd, DEFAULT_CACHE_DIR),
+      enabled: true,
+    }
+  }
+
+  return {
+    dir: resolve(cwd, options.dir ?? DEFAULT_CACHE_DIR),
+    enabled: options.enabled ?? true,
+  }
+}
+
+function cacheOverrideFromFlags(cache, noCache) {
+  if (cache) {
+    return true
+  }
+
+  if (noCache) {
+    return false
+  }
+}
+
+function cacheKeyForBuildInput({ contents, input, kind, options }) {
+  return sha256(
+    stableStringify({
+      fontminVersion: FONTMIN_VERSION,
+      input: {
+        hash: sha256(contents),
+        path: input,
+      },
+      kind,
+      options,
+      schema: CACHE_SCHEMA_VERSION,
+    }),
+  )
+}
+
+function cacheKeyForIconfontBuild({ icons, inputs, options }) {
+  return sha256(
+    stableStringify({
+      fontminVersion: FONTMIN_VERSION,
+      icons: icons.map((icon, index) => ({
+        hash: sha256(icon.contents),
+        input: inputs[index],
+        name: icon.name,
+      })),
+      kind: 'iconfont',
+      options,
+      schema: CACHE_SCHEMA_VERSION,
+    }),
+  )
+}
+
+function cacheRoot(cacheDir) {
+  return join(cacheDir, CACHE_SCHEMA_VERSION)
+}
+
+function cacheIndexPath(cacheDir) {
+  return join(cacheRoot(cacheDir), 'index.json')
+}
+
+function cacheEntryDir(cacheDir, key) {
+  return join(cacheRoot(cacheDir), key)
+}
+
+function cacheManifestPath(cacheDir, key) {
+  return join(cacheEntryDir(cacheDir, key), 'index.json')
+}
+
+function sha256(input) {
+  return createHash('sha256').update(input).digest('hex')
+}
+
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value)
+  }
+
+  if (Array.isArray(value)) {
+    return `[${value.map(item => stableStringify(item)).join(',')}]`
+  }
+
+  const record = value
+  const entries = Object.keys(record)
+    .sort()
+    .map(key => {
+      return `${JSON.stringify(key)}:${stableStringify(record[key])}`
+    })
+
+  return `{${entries.join(',')}}`
+}
+
+async function inspectCommand(args) {
+  const json = readFlag(args, ['--json'])
+  const [input] = args
+
+  requireValue(input, 'inspect requires an input font')
+
+  const contents = await readFile(input)
+  const info = inspectFont(contents)
+
+  if (json) {
+    console.log(JSON.stringify(info, undefined, 2))
+  } else {
+    console.log(
+      `${input}: ${info.format}, ${info.size} bytes, ${info.metadata.glyphCount} glyphs`,
+    )
+  }
+}
+
+async function initCommand() {
+  try {
+    await writeFile(INIT_CONFIG_FILE, DEFAULT_INIT_CONFIG, { flag: 'wx' })
+  } catch (error) {
+    if (hasErrorCode(error, 'EEXIST')) {
+      throw new Error(`${INIT_CONFIG_FILE} already exists`, { cause: error })
+    }
+
+    throw error
+  }
+
+  process.stdout.write(`created ${INIT_CONFIG_FILE}\n`)
+}
+
+async function subsetOptionsFromArgs(args) {
+  const subset = await resolveSubsetTextFile(
+    {
+      text: readOption(args, ['-t', '--text']),
+      textFile: readOption(args, ['--text-file']),
+      unicodes: parseUnicodes(readOption(args, ['--unicodes'])),
+    },
+    process.cwd(),
+  )
+
+  return {
+    ...subset,
+    unicodes: subset.unicodes ?? [],
+  }
+}
+
+async function resolveSubsetTextFile(subset, cwd) {
+  if (subset.textFile === undefined) {
+    return subset
+  }
+
+  const fileText = await readFile(resolve(cwd, subset.textFile), 'utf8')
+
+  return {
+    ...subset,
+    text: subset.text === undefined ? fileText : `${subset.text}${fileText}`,
+  }
+}
+
+async function readConfig(configPath) {
+  const contents = await readFile(configPath, 'utf8')
+  const extension = extname(configPath)
+
+  if (extension === '.json') {
+    return JSON.parse(contents)
+  }
+
+  if (extension === '.jsonc') {
+    return parseJsonc(contents)
+  }
+
+  if (MODULE_CONFIG_EXTENSIONS.has(extension)) {
+    const configModule = await import(pathToFileURL(configPath).href)
+    const loadedConfig = configModule.default ?? configModule.config
+
+    if (loadedConfig === undefined) {
+      throw new Error(`config file \`${configPath}\` does not export a config`)
+    }
+
+    return typeof loadedConfig === 'function'
+      ? await loadedConfig()
+      : loadedConfig
+  }
+
+  throw new Error(`unsupported config extension \`${extension}\``)
+}
+
+async function findConfig(cwd = process.cwd()) {
+  for (const fileName of DEFAULT_CONFIG_FILES) {
+    const configPath = resolve(cwd, fileName)
+
+    if (await isFile(configPath)) {
+      return configPath
+    }
+  }
+
+  throw new Error(`could not find fontmin config in ${cwd}`)
+}
+
+async function isFile(path) {
+  try {
+    return (await stat(path)).isFile()
+  } catch {
+    return false
+  }
+}
+
+async function expandInputPath(input, cwd) {
+  if (!isGlobPattern(input)) {
+    return [resolve(cwd, input)]
+  }
+
+  const matches = await glob(input, {
+    absolute: true,
+    cwd,
+    onlyFiles: true,
+  })
+
+  if (matches.length === 0) {
+    throw new Error(`fontmin-rs input glob matched no files: ${input}`)
+  }
+
+  return matches.sort((left, right) => left.localeCompare(right))
+}
+
+function isGlobPattern(path) {
+  return /[*?[\]{}]/u.test(path)
+}
+
+function hasErrorCode(error, code) {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    error.code === code
+  )
+}
+
+function outputFormatsFromConfig(outputs) {
+  if (outputs === undefined) {
+    return ['eot', 'woff', 'woff2', 'svg', 'css']
+  }
+
+  const formats = outputs.map(output =>
+    typeof output === 'string' ? output : output.format,
+  )
+
+  return parseFormats(formats.join(','))
+}
+
+function outputFormatsForConfig(outputs, { formats, noOriginal, preset }) {
+  const outputFormats =
+    formats === undefined && preset === undefined
+      ? outputFormatsFromConfig(outputs)
+      : outputFormatsFromArgs(formats, preset)
+  const filtered = filterOriginalOutput(outputFormats, noOriginal)
+
+  if (filtered.length === 0) {
+    throw new Error('build requires at least one non-original output format')
+  }
+
+  return filtered
+}
+
+function outputFormatsFromArgs(formats, preset) {
+  if (formats !== undefined && preset !== undefined) {
+    throw new Error('build accepts only one of --formats or --preset')
+  }
+
+  if (formats !== undefined) {
+    return parseFormats(formats)
+  }
+
+  if (preset !== undefined) {
+    return outputFormatsFromPreset(preset)
+  }
+
+  throw new Error('build requires --formats or --preset')
+}
+
+function outputFormatsFromPreset(value) {
+  const preset = value.trim().toLowerCase()
+
+  if (preset === 'compat') {
+    return ['eot', 'svg', 'woff', 'woff2', 'css']
+  }
+
+  if (preset === 'modern-web') {
+    return ['woff2', 'woff', 'css']
+  }
+
+  if (preset === 'iconfont') {
+    return ['ttf', 'css']
+  }
+
+  throw new Error(`unsupported preset \`${preset}\``)
+}
+
+function isIconfontPreset(value) {
+  return value?.trim().toLowerCase() === 'iconfont'
+}
+
+function filterOriginalOutput(formats, noOriginal) {
+  return noOriginal ? formats.filter(format => format !== 'ttf') : formats
+}
+
+function parseUnicodes(value) {
+  if (value === undefined) {
+    return []
+  }
+
+  const unicodes = value.split(',').map(item => parseUnicodeCodePoint(item))
+
+  if (unicodes.length === 0) {
+    throw new Error('expected at least one unicode code point')
+  }
+
+  return unicodes
+}
+
+function parseUnicodeCodePoint(value) {
+  const item = value.trim()
+
+  if (item.length === 0) {
+    throw new Error('empty unicode code point in --unicodes')
+  }
+
+  let digits = item
+  let radix = 10
+
+  if (/^(?:0x|u\+)/iu.test(item)) {
+    digits = item.slice(2)
+    radix = 16
+  }
+
+  const validDigits = radix === 16 ? /^[0-9a-f]+$/iu : /^[0-9]+$/u
+
+  if (!validDigits.test(digits)) {
+    throw new Error(`invalid unicode code point \`${item}\``)
+  }
+
+  const codePoint = Number.parseInt(digits, radix)
+
+  if (!Number.isInteger(codePoint) || codePoint > 4_294_967_295) {
+    throw new Error(`invalid unicode code point \`${item}\``)
+  }
+
+  return codePoint
+}
+
+function parseFormats(value) {
+  const formats = value
+    .split(',')
+    .map(format => format.trim().toLowerCase())
+    .filter(format => format.length > 0)
+
+  if (formats.length === 0) {
+    throw new Error('expected at least one output format')
+  }
+
+  for (const format of formats) {
+    if (
+      format !== 'ttf' &&
+      format !== 'woff' &&
+      format !== 'woff2' &&
+      format !== 'eot' &&
+      format !== 'svg' &&
+      format !== 'css'
+    ) {
+      throw new Error(`unsupported output format \`${format}\``)
+    }
+  }
+
+  return formats
+}
+
+function convertFont(contents, format) {
+  const normalized = format.toLowerCase()
+
+  if (normalized === 'ttf') {
+    if (isTtf(contents)) {
+      return contents
+    }
+
+    if (isWoff(contents)) {
+      return woffToTtf(contents)
+    }
+
+    if (isWoff2(contents)) {
+      return woff2ToTtf(contents)
+    }
+
+    if (isEot(contents)) {
+      return eotToTtf(contents)
+    }
+
+    throw new Error('unsupported input format for TTF conversion')
+  }
+
+  if (normalized === 'woff') {
+    return ttfToWoff(contents)
+  }
+
+  if (normalized === 'woff2') {
+    return ttfToWoff2(contents)
+  }
+
+  if (normalized === 'eot') {
+    return ttfToEot(contents)
+  }
+
+  if (normalized === 'svg') {
+    return ttfToSvg(contents)
+  }
+
+  throw new Error(`unsupported output format \`${format}\``)
+}
+
+function isTtf(contents) {
+  return (
+    (contents[0] === 0x00 &&
+      contents[1] === 0x01 &&
+      contents[2] === 0x00 &&
+      contents[3] === 0x00) ||
+    contents.subarray(0, 4).toString('ascii') === 'true'
+  )
+}
+
+function isWoff(contents) {
+  return contents.subarray(0, 4).toString('ascii') === 'wOFF'
+}
+
+function isWoff2(contents) {
+  return contents.subarray(0, 4).toString('ascii') === 'wOF2'
+}
+
+function isEot(contents) {
+  return (
+    contents.byteLength >= 12 &&
+    ((contents[8] === 0x01 &&
+      contents[9] === 0x00 &&
+      contents[10] === 0x02 &&
+      contents[11] === 0x00) ||
+      (contents[8] === 0x02 &&
+        contents[9] === 0x00 &&
+        contents[10] === 0x02 &&
+        contents[11] === 0x00))
+  )
+}
+
+function readOption(args, names) {
+  const index = args.findIndex(arg => names.includes(arg))
+
+  if (index === -1) {
+    return
+  }
+
+  const [name] = args.splice(index, 1)
+  const [value] = args.splice(index, 1)
+
+  if (value === undefined || value.startsWith('-')) {
+    throw new Error(`${name} requires a value`)
+  }
+
+  return value
+}
+
+function readFlag(args, names) {
+  const index = args.findIndex(arg => names.includes(arg))
+
+  if (index === -1) {
+    return false
+  }
+
+  args.splice(index, 1)
+  return true
+}
+
+function requireValue(value, message) {
+  if (value === undefined || value.length === 0) {
+    throw new Error(message)
+  }
+}
+
+async function writeOutput(output, contents) {
+  await mkdir(dirname(output), { recursive: true })
+  await writeFile(output, contents)
+}
+
+function usage() {
+  console.error(`Usage:
+  fontmin-rs subset <input.ttf> -o <output.ttf> (-t|--text <text> | --text-file <file> | --unicodes <list> | -b|--basic-text)
+  fontmin-rs convert <input.ttf> -f <ttf|woff|woff2|eot|svg> -o <output>
+  fontmin-rs build <input.ttf> -o <out-dir> --formats <ttf,woff,woff2,eot,svg,css> [-t|--text <text>] [--text-file <file>] [--unicodes <list>] [-b|--basic-text] [-d|--deflate-woff] [-T|--show-time] [--silent] [--no-original] [--cache|--no-cache]
+  fontmin-rs build <input.ttf> -o <out-dir> --preset <compat|modern-web|iconfont> [-t|--text <text>] [--text-file <file>] [--unicodes <list>] [-b|--basic-text] [-d|--deflate-woff] [-T|--show-time] [--silent] [--no-original] [--cache|--no-cache]
+  fontmin-rs bench <input.ttf> [-t|--text <text>] [--text-file <file>] [--unicodes <list>] [-b|--basic-text] [--json]
+  fontmin-rs inspect <input.ttf> [--json]
+  fontmin-rs init`)
+}