Batch Convert TTF to WOFF in a Build Script

The core loop. Reads each sfnt, deflates each table (keeping the smaller of compressed/original), and writes a WOFF 1.0. This is the same algorithm the browser tool runs.

import { readdir, readFile, writeFile } from "node:fs/promises";
import { deflate } from "pako";

function sfntToWoff(buf) {
  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
  const flavor = dv.getUint32(0), numTables = dv.getUint16(4);
  const dir = [];
  for (let i = 0; i < numTables; i++) {
    const o = 12 + i * 16;
    dir.push({
      tag: dv.getUint32(o), csum: dv.getUint32(o + 4),
      off: dv.getUint32(o + 8), len: dv.getUint32(o + 12),
    });
  }
  const comp = dir.map(e => {
    const raw = buf.subarray(e.off, e.off + e.len);
    const z = deflate(raw);
    return z.length < e.len
      ? { ...e, data: z, clen: z.length }
      : { ...e, data: raw, clen: e.len };
  });
  // ...write 44-byte header + 20-byte dir entries + padded data (see byte-layout table)
  // returns a WOFF buffer with magic 0x774F4646
}

for (const name of (await readdir("src/fonts")).filter(n => /\.(ttf|otf)$/i.test(n))) {
  const out = sfntToWoff(await readFile(`src/fonts/${name}`));
  await writeFile(`public/fonts/${name.replace(/\.\w+$/, ".woff")}`, out);
}

If the local runner is paired, POST each font to its ttf-to-woff endpoint and save the WOFF response. No npm dependency, fonts never leave your machine. Loop in your shell of choice.

for f in src/fonts/*.ttf src/fonts/*.otf; do
  [ -e "$f" ] || continue
  out="public/fonts/$(basename "${f%.*}").woff"
  curl -sS -X POST http://127.0.0.1:9789/v1/tools/ttf-to-woff/run \
    -F "file=@${f}" \
    -o "$out"
  echo "wrote $out"
done

Only reconvert when the source TTF is newer than the existing WOFF. Keeps the prebuild near-instant when nothing changed.

import { stat } from "node:fs/promises";

async function needsConvert(src, dst) {
  try {
    const [a, b] = await Promise.all([stat(src), stat(dst)]);
    return a.mtimeMs > b.mtimeMs;   // source newer → reconvert
  } catch {
    return true;                    // dst missing → convert
  }
}

if (await needsConvert(srcPath, woffPath)) {
  await writeFile(woffPath, sfntToWoff(await readFile(srcPath)));
}

Run the conversion in CI, then assert the working tree is clean. A committed TTF without its matching WOFF fails the check.

# .github/workflows/fonts.yml (excerpt)
- run: npm run fonts        # converts src/fonts → public/fonts
- name: Ensure WOFF artifacts are committed
  run: |
    git diff --exit-code public/fonts/ \
      || (echo '::error::Run npm run fonts and commit the WOFF files' && exit 1)

Run both conversions together so every weight ships both formats. They're independent and write to the same output directory.

// package.json
{
  "scripts": {
    "fonts": "node scripts/to-woff2.mjs && node scripts/to-woff.mjs",
    "prebuild": "npm run fonts"
  }
}

// result in public/fonts/:
//   inter.woff2   inter.woff
//   inter-bold.woff2   inter-bold.woff   ...

If your fonts/ directory already has WOFF2 files and you feed one in, the converter decodes it back to sfnt and re-wraps as WOFF — which is larger than the WOFF2 (zlib can't beat Brotli). For a build pipeline, always convert from the original TTF/OTF source, not from a previously-built web format, so each WOFF gets the smallest possible bytes.

The converter rejects ttcf with Unsupported font format: ttc — it wraps single faces only. Filter .ttc out of your glob, or split the collection into individual TTF/OTF faces (fonttools ttx or FontForge) before the batch step. Failing to filter will abort the run on that file.

The WOFF wrap has no timestamps, so output should be byte-identical run to run. If you see diffs, pin the pako version in package-lock.json — a different zlib build can produce different (still valid) compressed streams. Pinning keeps CI caches and git diff guards stable.

When using the runner API, the same per-tier file caps apply: 5 MB free, 50 MB pro, 1 GB developer. A font over the cap is rejected. Large CJK fonts can hit this — make sure the machine running the runner is on a tier that covers your largest face. The pure-pako Node path has no such cap (it's your own process).

pako deflate is single-threaded pure JS, so Promise.all over hundreds of fonts at once oversubscribes cores and can thrash memory. Cap concurrency to your core count (8-16) with a simple pool. Conversion is CPU-bound, not I/O-bound, so unbounded parallelism gives no speedup and risks OOM on huge fonts.

Variable fonts wrap to WOFF exactly like static fonts — the fvar/gvar tables ride through untouched and font-variation-settings still works after conversion in capable browsers. No special handling needed in the script. (If you want to freeze a variable font to a static instance first, that's the separate Variable Font Freezer tool.)

For each table the encoder keeps the smaller of the deflated stream or the original bytes, so tiny/dense tables are stored uncompressed with compLength === origLength. This is spec-correct and means the WOFF never inflates an individual table. Your size diffs will reflect this — it's normal, not a script bug.

The first time you add the git diff --exit-code guard, it fails because the WOFF artifacts don't exist yet. Run the conversion locally, commit the generated WOFF files, then the guard passes. Thereafter it only fails when a TTF changes without its WOFF being regenerated and committed.