fontmin-rs 0.1.1 → 0.2.0

package/bin/fontmin-rs.mjs

@@ -1,2007 +1,5 @@
 #!/usr/bin/env node
 
-import { createHash } from 'node:crypto'
-import {
-  mkdir,
-  lstat,
-  readFile,
-  realpath,
-  rename,
-  rm,
-  stat,
-  writeFile,
-} from 'node:fs/promises'
-import {
-  basename,
-  dirname,
-  extname,
-  isAbsolute,
-  join,
-  parse,
-  relative,
-  resolve,
-  sep,
-} from 'node:path'
-import { pathToFileURL } from 'node:url'
-import {
-  analyzeCoverage,
-  eotToTtf,
-  generateFontFaceCss,
-  inspectFont,
-  otfToTtf,
-  subsetTtf,
-  svgsToTtf,
-  ttfToEot,
-  ttfToSvg,
-  ttfToWoff,
-  ttfToWoff2,
-  woff2ToTtf,
-  woffToTtf,
-} from '@fontmin-rs/binding'
-import { parse as parseJsonc } from 'jsonc-parser'
-import { glob } from 'tinyglobby'
-import { withCacheLock } from './cache-lock.mjs'
+import { runCli } from '../dist/cli.mjs'
 
-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.1'
-const DEFAULT_CACHE_DIR = 'node_modules/.cache/fontmin-rs'
-let emitWarnings = true
-let temporaryFileCounter = 0
-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 === undefined ||
-    command === '--help' ||
-    command === '-h' ||
-    commandArgs.includes('--help') ||
-    commandArgs.includes('-h')
-  ) {
-    usage(process.stdout)
-  } else if (command === '--version' || command === '-V') {
-    process.stdout.write(`${FONTMIN_VERSION}\n`)
-  } else if (command === 'doctor') {
-    assertNoUnexpectedArgs(commandArgs, 0)
-    process.stdout.write('fontmin-rs doctor ok\n')
-  } else if (command === 'subset') {
-    await subsetCommand(commandArgs)
-  } else if (command === 'coverage') {
-    await coverageCommand(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') {
-    assertNoUnexpectedArgs(commandArgs, 0)
-    await initCommand()
-  } else if (command === 'bench') {
-    await benchCommand(commandArgs)
-  } else {
-    usage(process.stderr)
-    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'])
-  assertNoUnexpectedArgs(args)
-  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 = subsetWithCoverage(contents, {
-    basicText,
-    missingGlyphs: subsetOptions.missingGlyphs,
-    text: subsetOptions.text,
-    unicodes: subsetOptions.unicodes,
-  })
-
-  await writeOutput(output, subset)
-}
-
-async function coverageCommand(args) {
-  const json = readFlag(args, ['--json'])
-  const basicText = readFlag(args, ['-b', '--basic-text'])
-  const options = await subsetOptionsFromArgs(args)
-  assertNoUnexpectedArgs(args)
-  const [input] = args
-
-  requireValue(input, 'coverage requires an input font')
-  if (
-    options.text === undefined &&
-    options.unicodes.length === 0 &&
-    !basicText
-  ) {
-    throw new Error(
-      'coverage requires --text, --text-file, --unicodes, or --basic-text',
-    )
-  }
-
-  const report = analyzeCoverage(await readFile(input), {
-    basicText,
-    text: options.text,
-    unicodes: options.unicodes,
-  })
-
-  if (json) {
-    process.stdout.write(`${JSON.stringify(report, undefined, 2)}\n`)
-    return
-  }
-
-  process.stdout.write(
-    `coverage: ${report.coveragePercent.toFixed(2)}% (${report.supported.length}/${report.requested.length})\nrequested: ${report.requested.length}\nsupported: ${report.supported.length}\nmissing: ${report.missing.length}\n`,
-  )
-  const warning = missingGlyphMessage(report)
-  if (warning !== undefined) {
-    process.stdout.write(`${warning}\n`)
-  }
-}
-
-async function convertCommand(args) {
-  const output = readOption(args, ['-o', '--output'])
-  const format = readOption(args, ['-f', '--format'])
-  const variationCoordinates = parseVariations(
-    readOptions(args, ['--variation']),
-  )
-  assertNoUnexpectedArgs(args)
-  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, { variationCoordinates })
-
-  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)
-  assertNoUnexpectedArgs(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 = subsetWithCoverage(contents, {
-    basicText,
-    missingGlyphs: subsetOptions.missingGlyphs,
-    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
-
-  emitWarnings = !silent
-  try {
-    await runBuildCommand(args)
-    reportShowTime(startedAt)
-  } finally {
-    emitWarnings = true
-  }
-}
-
-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 cssUnicodeRanges = parseUnicodeRanges(
-    readOptions(args, ['--css-unicode-range']),
-  )
-  const deliverySlices = parseDeliverySlices(
-    readOptions(args, ['--delivery-slice']),
-  )
-  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 variationCoordinates = parseVariations(
-    readOptions(args, ['--variation']),
-  )
-  const subsetOptions = await subsetOptionsFromArgs(args)
-  assertNoUnknownOptions(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,
-        cssUnicodeRanges,
-        deliverySlices,
-        outDir,
-        variationCoordinates,
-      })
-      return
-    }
-
-    await buildConfigCommand(configPath, {
-      basicText,
-      cacheOverride,
-      cssGlyph,
-      cssUnicodeRanges,
-      deliverySlices,
-      fontFamily,
-      fontPath,
-      formats,
-      inputs: [...args],
-      noOriginal,
-      outDir,
-      preset,
-      subsetOptions,
-      variationCoordinates,
-    })
-    return
-  }
-
-  if (args.length === 0) {
-    const foundConfigPath = await findConfig()
-
-    if (isIconfontPreset(preset)) {
-      await buildIconfontConfigCommand(foundConfigPath, {
-        fontFamily,
-        fontPath,
-        formats,
-        cacheOverride,
-        cssUnicodeRanges,
-        deliverySlices,
-        outDir,
-        variationCoordinates,
-      })
-      return
-    }
-
-    await buildConfigCommand(foundConfigPath, {
-      basicText,
-      cacheOverride,
-      cssGlyph,
-      cssUnicodeRanges,
-      deliverySlices,
-      fontFamily,
-      fontPath,
-      formats,
-      noOriginal,
-      outDir,
-      preset,
-      subsetOptions,
-      variationCoordinates,
-    })
-    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,
-      cssUnicodeRanges,
-    )
-    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,
-      cssUnicodeRanges,
-      deliverySlices,
-      fontFamily,
-      fontPath,
-      outputFormats,
-      subsetOptions,
-      variationCoordinates,
-    })
-  }
-}
-
-async function buildDirectInput(
-  input,
-  outDir,
-  {
-    basicText,
-    cacheOptions,
-    cssGlyph,
-    cssUnicodeRanges,
-    deliverySlices,
-    fontFamily,
-    fontPath,
-    outputFormats,
-    subsetOptions,
-    variationCoordinates,
-  },
-) {
-  const contents = await readFile(input)
-  const ttfContents = convertFont(contents, 'ttf', { variationCoordinates })
-  const baseName = basename(input, extname(input))
-  const cacheKey = cacheOptions.enabled
-    ? cacheKeyForBuildInput({
-        contents,
-        input,
-        kind: 'direct',
-        options: {
-          basicText,
-          cssGlyph,
-          cssUnicodeRanges,
-          deliverySlices,
-          fontFamily,
-          fontPath,
-          outputFormats,
-          subset: subsetOptions,
-          variationCoordinates,
-        },
-      })
-    : 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
-      ? ttfContents
-      : subsetWithCoverage(ttfContents, {
-          basicText,
-          missingGlyphs: subsetOptions.missingGlyphs,
-          text: subsetOptions.text,
-          unicodes: subsetOptions.unicodes,
-        })
-  const cssGlyphs = cssGlyph ? cssGlyphsFromSubset(subsetOptions) : []
-  const fontSources =
-    deliverySlices.length === 0
-      ? [{ baseName, contents: source }]
-      : deliverySlices.map(slice => ({
-          baseName: `${baseName}-${slice.name}`,
-          contents: subsetTtf(source, {
-            missingGlyphs: 'ignore',
-            unicodeRanges: slice.unicodeRanges,
-          }),
-          unicodeRanges: slice.unicodeRanges,
-        }))
-  const cssSources = []
-  const outputs = []
-
-  for (const fontSource of fontSources) {
-    for (const format of outputFormats.filter(format => format !== 'css')) {
-      const fileName = `${fontSource.baseName}.${format}`
-      const output = convertFont(fontSource.contents, format)
-
-      outputs.push({ contents: output, fileName })
-      cssSources.push({
-        ...(cssGlyphs.length > 0 && { glyphs: cssGlyphs }),
-        ...(fontSource.unicodeRanges !== undefined && {
-          unicodeRanges: fontSource.unicodeRanges,
-        }),
-        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,
-          unicodeRanges: cssUnicodeRanges,
-        }),
-      ),
-      fileName: `${fontSources[0].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()),
-  cssUnicodeRanges = css.unicodeRanges ?? [],
-) {
-  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,
-            unicodeRanges: cssUnicodeRanges,
-          },
-        ),
-      ),
-      fileName: cssFileName,
-    },
-  ]
-
-  await writeBuildOutputs(outDir, buildOutputs)
-
-  if (cacheKey !== undefined) {
-    await writeCachedBuildOutputs(cacheOptions.dir, cacheKey, buildOutputs)
-  }
-}
-
-async function buildConfigCommand(
-  configPath,
-  {
-    basicText,
-    cacheOverride,
-    cssGlyph,
-    cssUnicodeRanges = [],
-    deliverySlices = [],
-    fontFamily,
-    fontPath,
-    formats,
-    inputs: inputOverrides = [],
-    noOriginal,
-    outDir: outDirOverride,
-    preset,
-    subsetOptions,
-    variationCoordinates = {},
-  } = {},
-) {
-  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)
-  const resolvedVariationCoordinates = {
-    ...config.otf?.variationCoordinates,
-    ...variationCoordinates,
-  }
-
-  if (inputs.length === 0) {
-    throw new Error('build config requires at least one input')
-  }
-
-  const inputPaths = await expandInputPaths(inputs, cwd)
-
-  if (
-    fontFamily !== undefined ||
-    fontPath !== undefined ||
-    cssGlyph === true ||
-    cssUnicodeRanges.length > 0
-  ) {
-    config.css = {
-      ...config.css,
-      ...(cssGlyph === true && { glyph: true }),
-      ...(cssUnicodeRanges.length > 0 && {
-        unicodeRanges: cssUnicodeRanges,
-      }),
-      ...(fontFamily !== undefined && { fontFamily }),
-      ...(fontPath !== undefined && { fontPath }),
-    }
-  }
-  if (deliverySlices.length > 0) {
-    config.delivery = { slices: deliverySlices }
-  }
-
-  applySubsetOverrides(config, { basicText, subsetOptions })
-
-  if (config.clean === true) {
-    await cleanOutputDirectory(cwd, outDir, [resolvedConfigPath, ...inputPaths])
-  }
-
-  await mkdir(outDir, { recursive: true })
-
-  for (const inputPath of inputPaths) {
-    await buildConfigInput(
-      inputPath,
-      outDir,
-      outputFormats,
-      config,
-      cwd,
-      cacheOptions,
-      resolvedVariationCoordinates,
-    )
-  }
-}
-
-async function buildIconfontConfigCommand(
-  configPath,
-  {
-    cacheOverride,
-    cssUnicodeRanges = [],
-    deliverySlices = [],
-    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 (cssUnicodeRanges.length > 0) {
-    css.unicodeRanges = cssUnicodeRanges
-  }
-  if (deliverySlices.length > 0) {
-    config.delivery = { slices: deliverySlices }
-  }
-
-  if (config.clean === true) {
-    await cleanOutputDirectory(cwd, outDir, [resolvedConfigPath, ...inputs])
-  }
-
-  await buildIconfontCommand(
-    inputs,
-    outDir,
-    fontFamily ?? css.fontFamily,
-    fontPath ?? css.fontPath ?? './',
-    config.outputs ?? [],
-    css,
-    cacheOptions,
-    css.unicodeRanges,
-  )
-}
-
-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))}.${normalizeExtension(output.ext)}`
-  }
-
-  return fallback
-}
-
-function applySubsetOverrides(config, { basicText, subsetOptions } = {}) {
-  if (
-    subsetOptions === undefined ||
-    (subsetOptions.text === undefined &&
-      subsetOptions.unicodes.length === 0 &&
-      basicText !== true &&
-      subsetOptions.missingGlyphs === undefined)
-  ) {
-    return
-  }
-
-  config.subset = {
-    ...config.subset,
-    ...(subsetOptions.text !== undefined && { text: subsetOptions.text }),
-    ...(subsetOptions.unicodes.length > 0 && {
-      unicodes: subsetOptions.unicodes,
-    }),
-    ...(basicText === true && { basicText }),
-    ...(subsetOptions.missingGlyphs !== undefined && {
-      missingGlyphs: subsetOptions.missingGlyphs,
-    }),
-  }
-}
-
-async function buildConfigInput(
-  input,
-  outDir,
-  outputFormats,
-  config,
-  cwd,
-  cacheOptions,
-  variationCoordinates,
-) {
-  const contents = await readFile(input)
-  const ttfContents = convertFont(contents, 'ttf', { variationCoordinates })
-  const subset = await resolveSubsetTextFile(config.subset ?? {}, cwd)
-  const unicodes = subset.unicodes ?? []
-  const deliverySlices = normalizeDeliverySlices(config.delivery?.slices ?? [])
-  const cacheKey = cacheOptions.enabled
-    ? cacheKeyForBuildInput({
-        contents,
-        input,
-        kind: 'config',
-        options: {
-          css: config.css,
-          deliverySlices,
-          outputFormats,
-          outputs: config.outputs,
-          subset,
-          variationCoordinates,
-        },
-      })
-    : 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
-      ? ttfContents
-      : subsetWithCoverage(ttfContents, {
-          basicText: subset.basicText,
-          missingGlyphs: subset.missingGlyphs,
-          text: subset.text,
-          unicodes,
-        })
-  const baseName = basename(input, extname(input))
-  const css = config.css ?? {}
-  const cssGlyphs = css.glyph === true ? cssGlyphsFromSubset(subset) : []
-  const fontSources =
-    deliverySlices.length === 0
-      ? [{ baseName, contents: source }]
-      : deliverySlices.map(slice => ({
-          baseName: `${baseName}-${slice.name}`,
-          contents: subsetTtf(source, {
-            missingGlyphs: 'ignore',
-            unicodeRanges: slice.unicodeRanges,
-          }),
-          unicodeRanges: slice.unicodeRanges,
-        }))
-  const cssSources = []
-  const outputs = config.outputs ?? []
-  const buildOutputs = []
-
-  for (const fontSource of fontSources) {
-    for (const format of outputFormats.filter(format => format !== 'css')) {
-      const fileName = outputFileName(
-        outputs,
-        format,
-        `${fontSource.baseName}.${format}`,
-      )
-      const output = convertFont(fontSource.contents, format)
-
-      buildOutputs.push({ contents: output, fileName })
-      cssSources.push({
-        ...(css.base64 === true && { contents: output }),
-        ...(cssGlyphs.length > 0 && { glyphs: cssGlyphs }),
-        ...(fontSource.unicodeRanges !== undefined && {
-          unicodeRanges: fontSource.unicodeRanges,
-        }),
-        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,
-          unicodeRanges: css.unicodeRanges,
-        }),
-      ),
-      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) {
-    const outputPath = resolveContainedPath(
-      outDir,
-      output.fileName,
-      'output file name',
-    )
-
-    await mkdir(dirname(outputPath), { recursive: true })
-    await ensureRealPathContained(
-      outDir,
-      dirname(outputPath),
-      'output file name',
-    )
-    await rejectSymbolicLink(outputPath)
-    await writeFile(outputPath, 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) {
-      const cacheFile = resolveContainedPath(
-        entryDir,
-        record.cacheFileName,
-        'cache file name',
-      )
-
-      await ensureRealPathContained(entryDir, cacheFile, 'cache file name')
-      outputs.push({
-        contents: await readFile(cacheFile),
-        fileName: record.fileName,
-      })
-    }
-  } catch {
-    return
-  }
-
-  return outputs
-}
-
-async function writeCachedBuildOutputs(cacheDir, key, outputs) {
-  await withCacheLock(cacheRoot(cacheDir), async () => {
-    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 atomicWriteFile(join(entryDir, cacheFileName), output.contents)
-      records.push({
-        cacheFileName,
-        fileName: output.fileName,
-      })
-    }
-
-    await atomicWriteFile(
-      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 atomicWriteFile(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'])
-  assertNoUnexpectedArgs(args)
-  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,
-    missingGlyphs: parseMissingGlyphPolicy(
-      readOption(args, ['--missing-glyphs']),
-    ),
-    unicodes: subset.unicodes ?? [],
-  }
-}
-
-function subsetWithCoverage(contents, options) {
-  const policy = options.missingGlyphs ?? 'warn'
-
-  if (policy === 'warn') {
-    const report = analyzeCoverage(contents, options)
-    const warning = missingGlyphMessage(report)
-
-    if (warning !== undefined && emitWarnings) {
-      process.stderr.write(`warning: ${warning}\n`)
-    }
-  }
-
-  return subsetTtf(contents, {
-    ...options,
-    missingGlyphs: policy === 'warn' ? 'ignore' : policy,
-  })
-}
-
-function missingGlyphMessage(report) {
-  if (report.missing.length === 0) {
-    return
-  }
-
-  const visible = report.missing
-    .slice(0, 16)
-    .map(
-      codePoint => `U+${codePoint.toString(16).toUpperCase().padStart(4, '0')}`,
-    )
-    .join(', ')
-  const remaining = report.missing.length - 16
-
-  return `missing glyphs for requested Unicode code points: ${visible}${remaining > 0 ? `, and ${remaining} more` : ''}`
-}
-
-function parseMissingGlyphPolicy(value) {
-  if (value === undefined) {
-    return
-  }
-
-  const policy = value.trim().toLowerCase()
-
-  if (policy === 'ignore' || policy === 'warn' || policy === 'error') {
-    return policy
-  }
-
-  throw new Error(
-    `missing glyph policy must be \`ignore\`, \`warn\`, or \`error\`: ${value}`,
-  )
-}
-
-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 {
-    const stats = await stat(path)
-    return stats.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
-  )
-}
-
-async function cleanOutputDirectory(cwd, outDir, protectedPaths) {
-  const root = resolve(cwd)
-  const target = resolve(outDir)
-  const targetIsInsideRoot = pathContains(root, target) && target !== root
-  const targetContainsInput = protectedPaths.some(path =>
-    pathContains(target, resolve(path)),
-  )
-
-  if (
-    target === parse(target).root ||
-    pathContains(target, root) ||
-    targetContainsInput
-  ) {
-    throw new Error(
-      `refusing to clean output directory ${target} because it is the project directory, an input ancestor, or a filesystem root`,
-    )
-  }
-
-  try {
-    const [realRoot, realTarget, ...realProtectedPaths] = await Promise.all([
-      realpath(root),
-      realpath(target),
-      ...protectedPaths.map(path => realpath(resolve(path))),
-    ])
-
-    if (
-      realTarget === parse(realTarget).root ||
-      pathContains(realTarget, realRoot) ||
-      realProtectedPaths.some(path => pathContains(realTarget, path)) ||
-      (targetIsInsideRoot && !pathContains(realRoot, realTarget))
-    ) {
-      throw new Error(
-        `refusing to clean output directory ${target} because its resolved location is unsafe for project ${root}`,
-      )
-    }
-  } catch (error) {
-    if (!hasErrorCode(error, 'ENOENT')) {
-      throw error
-    }
-  }
-
-  await rm(target, { recursive: true, force: true })
-}
-
-function pathContains(parent, candidate) {
-  const childPath = relative(parent, candidate)
-
-  return (
-    childPath === '' ||
-    (childPath !== '..' &&
-      !childPath.startsWith(`..${sep}`) &&
-      !isAbsolute(childPath))
-  )
-}
-
-function resolveContainedPath(root, path, label) {
-  if (typeof path !== 'string' || path.length === 0 || isAbsolute(path)) {
-    throw new Error(`${label} must be a non-empty relative path: ${path}`)
-  }
-
-  const resolvedRoot = resolve(root)
-  const resolvedPath = resolve(resolvedRoot, path)
-  const relativePath = relative(resolvedRoot, resolvedPath)
-
-  if (
-    relativePath === '' ||
-    relativePath === '..' ||
-    relativePath.startsWith(`..${sep}`) ||
-    isAbsolute(relativePath)
-  ) {
-    throw new Error(
-      `${label} must stay within its destination directory: ${path}`,
-    )
-  }
-
-  return resolvedPath
-}
-
-async function ensureRealPathContained(root, path, label) {
-  const [realRoot, realPath] = await Promise.all([
-    realpath(root),
-    realpath(path),
-  ])
-  const relativePath = relative(realRoot, realPath)
-
-  if (
-    relativePath === '..' ||
-    relativePath.startsWith(`..${sep}`) ||
-    isAbsolute(relativePath)
-  ) {
-    throw new Error(`${label} resolves outside its destination directory`)
-  }
-}
-
-async function rejectSymbolicLink(path) {
-  try {
-    const metadata = await lstat(path)
-
-    if (metadata.isSymbolicLink()) {
-      throw new Error(`refusing to write output through symbolic link: ${path}`)
-    }
-  } catch (error) {
-    if (!hasErrorCode(error, 'ENOENT')) {
-      throw error
-    }
-  }
-}
-
-function normalizeExtension(extension) {
-  const normalized = extension.replace(/^\.+/u, '')
-
-  if (
-    normalized.length === 0 ||
-    normalized === '..' ||
-    normalized.includes('/') ||
-    normalized.includes('\\')
-  ) {
-    throw new Error(`output extension must be a file extension: ${extension}`)
-  }
-
-  return normalized
-}
-
-async function atomicWriteFile(path, contents) {
-  const temporaryPath = `${path}.${process.pid}.${temporaryFileCounter}.tmp`
-  temporaryFileCounter += 1
-
-  try {
-    await writeFile(temporaryPath, contents)
-    await rename(temporaryPath, path)
-  } finally {
-    await rm(temporaryPath, { force: true })
-  }
-}
-
-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 parseUnicodeRanges(values) {
-  return values.map(value => parseUnicodeRange(value))
-}
-
-function formatUnicodeEndpoint(codePoint) {
-  return codePoint.toString(16).toUpperCase().padStart(4, '0')
-}
-
-function parseUnicodeRange(value) {
-  const match =
-    /^u\+(?<start>[0-9a-f]{1,6})(?:-(?<end>[0-9a-f]{1,6}))?$/iu.exec(value)
-
-  if (match?.groups === undefined) {
-    throw new Error(`invalid Unicode range: ${value}`)
-  }
-
-  const start = Number.parseInt(match.groups.start, 16)
-  const end = Number.parseInt(match.groups.end ?? match.groups.start, 16)
-
-  if (start > end || end > 0x10_ff_ff || (start <= 0xdf_ff && end >= 0xd8_00)) {
-    throw new Error(`invalid Unicode range: ${value}`)
-  }
-
-  return start === end
-    ? `U+${formatUnicodeEndpoint(start)}`
-    : `U+${formatUnicodeEndpoint(start)}-${formatUnicodeEndpoint(end)}`
-}
-
-function parseDeliverySlices(values) {
-  const slices = []
-
-  for (const value of values) {
-    const separator = value.indexOf(':')
-
-    if (separator === -1) {
-      throw new Error(`delivery slice must use NAME:RANGE[,RANGE...]: ${value}`)
-    }
-
-    const name = value.slice(0, separator)
-    const unicodeRanges = value.slice(separator + 1).split(',')
-    const existing = slices.find(slice => slice.name === name)
-
-    if (existing === undefined) {
-      slices.push({ name, unicodeRanges })
-    } else {
-      existing.unicodeRanges.push(...unicodeRanges)
-    }
-  }
-
-  return normalizeDeliverySlices(slices)
-}
-
-function normalizeDeliverySlices(values) {
-  if (!Array.isArray(values)) {
-    throw new TypeError('delivery slices must be an array')
-  }
-
-  const names = new Set()
-
-  return values.map((value, index) => {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-      throw new Error(`delivery slice ${index + 1} must be an object`)
-    }
-
-    const { name, unicodeRanges } = value
-
-    if (
-      typeof name !== 'string' ||
-      name.length === 0 ||
-      !/^[A-Za-z0-9_-]+$/u.test(name)
-    ) {
-      throw new Error(`invalid delivery slice name: ${name}`)
-    }
-    if (names.has(name)) {
-      throw new Error(`duplicate delivery slice name: ${name}`)
-    }
-    if (!Array.isArray(unicodeRanges) || unicodeRanges.length === 0) {
-      throw new Error(
-        `delivery slice \`${name}\` requires at least one Unicode range`,
-      )
-    }
-
-    names.add(name)
-
-    return {
-      name,
-      unicodeRanges: parseUnicodeRanges(unicodeRanges),
-    }
-  })
-}
-
-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, options = {}) {
-  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)
-    }
-
-    if (isOtf(contents)) {
-      return otfToTtf(contents, {
-        variationCoordinates: options.variationCoordinates ?? {},
-      })
-    }
-
-    throw new Error('unsupported input format for TTF conversion')
-  }
-
-  const ttf = convertFont(contents, 'ttf', options)
-
-  if (normalized === 'woff') {
-    return ttfToWoff(ttf)
-  }
-
-  if (normalized === 'woff2') {
-    return ttfToWoff2(ttf)
-  }
-
-  if (normalized === 'eot') {
-    return ttfToEot(ttf)
-  }
-
-  if (normalized === 'svg') {
-    return ttfToSvg(ttf)
-  }
-
-  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 isOtf(contents) {
-  return contents.subarray(0, 4).toString('ascii') === 'OTTO'
-}
-
-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 readOptions(args, names) {
-  const values = []
-
-  while (args.some(arg => names.includes(arg))) {
-    values.push(readOption(args, names))
-  }
-
-  return values
-}
-
-function readFlag(args, names) {
-  const index = args.findIndex(arg => names.includes(arg))
-
-  if (index === -1) {
-    return false
-  }
-
-  args.splice(index, 1)
-  return true
-}
-
-function assertNoUnknownOptions(args) {
-  const option = args.find(arg => arg.startsWith('-'))
-
-  if (option !== undefined) {
-    throw new Error(`unknown option \`${option}\``)
-  }
-}
-
-function assertNoUnexpectedArgs(args, maximumPositionals = 1) {
-  assertNoUnknownOptions(args)
-
-  if (args.length > maximumPositionals) {
-    throw new Error(`unexpected argument \`${args[maximumPositionals]}\``)
-  }
-}
-
-function parseVariations(values) {
-  const coordinates = {}
-
-  for (const value of values) {
-    const separator = value.indexOf('=')
-
-    if (separator === -1) {
-      throw new Error(`invalid variation \`${value}\`; expected TAG=VALUE`)
-    }
-
-    const tag = value.slice(0, separator)
-    const rawNumber = value.slice(separator + 1)
-
-    if (
-      tag.length !== 4 ||
-      [...tag].some(character => (character.codePointAt(0) ?? 128) > 127)
-    ) {
-      throw new Error(
-        `invalid variation axis \`${tag}\`; expected four ASCII characters`,
-      )
-    }
-    if (Object.hasOwn(coordinates, tag)) {
-      throw new Error(`duplicate variation axis \`${tag}\``)
-    }
-
-    const number = Number(rawNumber)
-
-    if (rawNumber.length === 0 || !Number.isFinite(number)) {
-      throw new Error(
-        `invalid variation value \`${rawNumber}\` for axis \`${tag}\``,
-      )
-    }
-
-    coordinates[tag] = number
-  }
-
-  return coordinates
-}
-
-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(stream) {
-  stream.write(`Usage:
-  fontmin-rs subset <INPUT> -o|--output <OUTPUT> (-t|--text <TEXT> | --text-file <FILE> | --unicodes <LIST> | -b|--basic-text) [--missing-glyphs <ignore|warn|error>]
-  fontmin-rs coverage <INPUT> (-t|--text <TEXT> | --text-file <FILE> | --unicodes <LIST> | -b|--basic-text) [--json]
-  fontmin-rs convert <INPUT> -f|--format <ttf|woff|woff2|eot|svg> -o|--output <OUTPUT> [--variation <TAG=VALUE>]...
-  fontmin-rs build <INPUT...> [-c|--config <CONFIG>] [-o|--out-dir <OUT_DIR>] [-t|--text <TEXT>] [--text-file <FILE>] [--unicodes <LIST>] [-b|--basic-text] [--missing-glyphs <ignore|warn|error>] [-d|--deflate-woff] [-T|--show-time] [--silent] [--cache] [--no-cache] [--css-glyph] [--css-unicode-range <RANGE>]... [--delivery-slice <NAME:RANGE[,RANGE...]>]... [--variation <TAG=VALUE>]... [--formats <FORMATS>] [--preset <compat|modern-web|iconfont>] [--no-original] [--font-family <FONT_FAMILY>] [--font-path <FONT_PATH>]
-  fontmin-rs bench <INPUT> [-t|--text <TEXT>] [--text-file <FILE>] [--unicodes <LIST>] [-b|--basic-text] [--json]
-  fontmin-rs inspect <INPUT> [--json]
-  fontmin-rs init
-  fontmin-rs doctor
-`)
-}
+await runCli()