Automate Emoji Removal in Your Font Build Pipeline

Same logic as JAD's browser Emoji Remover: walk every glyph, keep codepoints outside the four ranges, rebuild a TTF. Drops kerning/layout — use for display faces.

import fs from "node:fs";
import opentype from "opentype.js";

const RANGES = [[0x1f000,0x1ffff],[0x2600,0x27bf],[0xe000,0xf8ff],[0x1f300,0x1faff]];
const isEmoji = cp => RANGES.some(([lo,hi]) => cp >= lo && cp <= hi);

for (const name of fs.readdirSync("src/fonts")) {
  const font = opentype.loadSync(`src/fonts/${name}`);
  const keep = [font.glyphs.get(0)]; // .notdef
  for (let i = 1; i < font.glyphs.length; i++) {
    const g = font.glyphs.get(i);
    if (g.unicode != null && !isEmoji(g.unicode)) keep.push(g);
  }
  const out = new opentype.Font({
    familyName: font.getEnglishName("fontFamily"),
    styleName:  font.getEnglishName("fontSubfamily") || "Regular",
    unitsPerEm: font.unitsPerEm,
    ascender: font.ascender, descender: font.descender,
    glyphs: keep,
  });
  fs.writeFileSync(`dist/fonts/${name.replace(/\.\w+$/, "")}.no-emoji.ttf",
                   Buffer.from(out.toArrayBuffer()));
}
// NOTE: GPOS/GSUB are NOT carried -> kerning/ligatures gone.

When the font needs kerning, build a keep-list of Unicode ranges that excludes the emoji blocks and let harfbuzz preserve layout features.

# keep everything except the emoji ranges, keep all layout features
hb-subset src/fonts/Inter.ttf \
  --unicodes='0-25FF,2800-DFFF,F900-1F2FF,20000-2FFFF' \
  --layout-features='*' \
  --output-file=dist/fonts/Inter.no-emoji.ttf

# kerning + ligatures survive; emoji/dingbat/PUA glyphs are gone
woff2_compress dist/fonts/Inter.no-emoji.ttf

The runner runs the tool locally so the font never leaves your machine. emoji-remover takes no options, so the inputs object is empty.

curl -sS -X POST http://127.0.0.1:9789/v1/tools/emoji-remover/run \
  -F 'file=@src/fonts/Brand-Display.ttf' \
  -F 'inputs={}' \
  -o dist/fonts/Brand-Display.no-emoji.ttf

# Output is TTF (the tool always emits sfnt); compress afterwards:
curl -sS -X POST http://127.0.0.1:9789/v1/tools/ttf-to-woff2/run \
  -F 'file=@dist/fonts/Brand-Display.no-emoji.ttf' -F 'inputs={}' \
  -o dist/fonts/Brand-Display.no-emoji.woff2

Skip fonts with no emoji codepoints (nothing to gain) and run compression as a decoupled stage so each cache invalidates independently.

import opentype from "opentype.js";
const RANGES = [[0x1f000,0x1ffff],[0x2600,0x27bf],[0xe000,0xf8ff]];
const hasEmoji = f => {
  for (let i=0;i<f.glyphs.length;i++){
    const cp=f.glyphs.get(i).unicode;
    if (cp!=null && RANGES.some(([l,h])=>cp>=l&&cp<=h)) return true;
  } return false;
};
const font = opentype.loadSync(input);
if (!hasEmoji(font)) { console.log(`skip ${input}: no emoji block`); process.exit(0); }
// ...strip + write...  then in a SEPARATE step: woff2_compress out.ttf

opentype.js throws on some CFF/PostScript-outline fonts. Wrap the write so CI fails with a useful message instead of emitting a corrupt TTF.

try {
  fs.writeFileSync(outPath, Buffer.from(newFont.toArrayBuffer()));
} catch (err) {
  console.error(
    `Emoji strip failed for ${name}: ${err.message}\n` +
    `This usually means CFF/PostScript outlines. Convert to TTF first ` +
    `(fontforge / hb-subset) and re-run.`);
  process.exit(1);  // break the build, do not ship a broken font
}

The pure-JS script (and the hosted JAD tool) drop GPOS/GSUB. In a CI pipeline this is silent — the build passes, the font ships, and body text reflows because kerning is gone. Add an assertion that checks the output still has a GPOS table if your font needs it, or switch that font to the hb-subset path. This is the single most common automation mistake.

U+E000–U+F8FF is in the default ranges. If your monorepo ships both a text font and an icon font through the same step, the icon font is gutted. Exclude the PUA range for icon fonts, or route them away from the emoji step entirely. Run Character Coverage Map in a pre-flight check to flag PUA-heavy fonts.

Emoji live above U+FFFF. If your script iterates strings with charCodeAt or assumes BMP, you'll read surrogate halves and miss the emoji. Always walk the font's glyphs by index and read glyph.unicode (the numeric codepoint), exactly as the reference implementation does — don't reconstruct from strings.

The strip step emits uncompressed sfnt. If your source artefact was WOFF2, the intermediate TTF is much larger — that's normal. Always run compression as a downstream stage and compare final WOFF2 sizes, not the intermediate. Decouple the stages so you don't accidentally ship the TTF.

opentype.js's toArrayBuffer() can fail on CFF outlines. Without a try/catch your CI job dies with an opaque stack trace. Wrap it, print a clear message, and either pre-convert to TTF or route CFF fonts through hb-subset, which handles them natively.

Running the strip on an already-emoji-free font is harmless — the keep-set is the whole font — but the rebuild still drops layout each pass and re-emits glyf/loca, so size can drift on repeated runs. Make the step idempotent by skipping fonts whose cmap has no codepoints in the ranges.

If you route through the hosted tool or a free-tier runner, the 5 MB cap applies (Pro 50 MB, Developer 1 GB). A multi-megabyte colour-emoji font won't process on free. For pure local CI, the standalone opentype.js / hb-subset scripts have no such cap — they run in your own Node/shell.

If the deployed CSS font-stack doesn't end in a generic family, a browser with no OS emoji could render tofu (□) where emoji used to be. The Playwright diff catches this. Fix is in the stack, not the font: always end the family list with a generic so the OS emoji font is reachable.