pdfnative 1.3.0 → 1.4.0

package/dist/tools/build-emoji-font.js

@@ -0,0 +1,1139 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { createHash } from 'crypto';
+
+// src/fonts/colr-parser.ts
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+function compose(outer, inner) {
+  const [a1, b1, c1, d1, e1, f1] = outer;
+  const [a2, b2, c2, d2, e2, f2] = inner;
+  return [
+    a1 * a2 + c1 * b2,
+    b1 * a2 + d1 * b2,
+    a1 * c2 + c1 * d2,
+    b1 * c2 + d1 * d2,
+    a1 * e2 + c1 * f2 + e1,
+    b1 * e2 + d1 * f2 + f1
+  ];
+}
+var UnsupportedPaint = class extends Error {
+};
+function tableDirectory(view) {
+  const numTables = view.getUint16(4);
+  const tables = {};
+  for (let i = 0; i < numTables; i++) {
+    const rec = 12 + i * 16;
+    const tag = String.fromCharCode(
+      view.getUint8(rec),
+      view.getUint8(rec + 1),
+      view.getUint8(rec + 2),
+      view.getUint8(rec + 3)
+    );
+    tables[tag] = { offset: view.getUint32(rec + 8), length: view.getUint32(rec + 12) };
+  }
+  return tables;
+}
+function getUint24(view, pos) {
+  return view.getUint8(pos) << 16 | view.getUint8(pos + 1) << 8 | view.getUint8(pos + 2);
+}
+function f2dot14(view, pos) {
+  return view.getInt16(pos) / 16384;
+}
+function fixed(view, pos) {
+  return view.getInt32(pos) / 65536;
+}
+function parseCpal(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tables = tableDirectory(view);
+  const cpal = tables["CPAL"];
+  if (!cpal) return null;
+  const base = cpal.offset;
+  const numPaletteEntries = view.getUint16(base + 2);
+  const colorRecordsArrayOffset = view.getUint32(base + 8);
+  const firstIndex = view.getUint16(base + 12);
+  const recBase = base + colorRecordsArrayOffset + firstIndex * 4;
+  const colors = [];
+  for (let i = 0; i < numPaletteEntries; i++) {
+    const p = recBase + i * 4;
+    const b = view.getUint8(p);
+    const g = view.getUint8(p + 1);
+    const r = view.getUint8(p + 2);
+    const a = view.getUint8(p + 3);
+    colors.push([r, g, b, a]);
+  }
+  return colors;
+}
+function resolveColor(ctx, paletteIndex, alpha) {
+  const base = paletteIndex === 65535 ? [0, 0, 0, 255] : ctx.palette[paletteIndex] ?? [0, 0, 0, 255];
+  const a = Math.round(base[3] * Math.max(0, Math.min(1, alpha)));
+  return [base[0], base[1], base[2], a];
+}
+var EXTEND = ["pad", "repeat", "reflect"];
+function readColorLine(ctx, offset) {
+  const { view } = ctx;
+  const extend = EXTEND[view.getUint8(offset)] ?? "pad";
+  const numStops = view.getUint16(offset + 1);
+  const stops = [];
+  let p = offset + 3;
+  for (let i = 0; i < numStops; i++) {
+    const stopOffset = f2dot14(view, p);
+    const paletteIndex = view.getUint16(p + 2);
+    const alpha = f2dot14(view, p + 4);
+    stops.push({ offset: stopOffset, color: resolveColor(ctx, paletteIndex, alpha) });
+    p += 6;
+  }
+  return { stops, extend };
+}
+function apply(m, x, y) {
+  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+function avgScale(m) {
+  const sx = Math.hypot(m[0], m[1]);
+  const sy = Math.hypot(m[2], m[3]);
+  return (sx + sy) / 2 || 1;
+}
+function resolveFill(ctx, offset, m) {
+  const { view } = ctx;
+  const format = view.getUint8(offset);
+  switch (format) {
+    case 2: {
+      const paletteIndex = view.getUint16(offset + 1);
+      const alpha = f2dot14(view, offset + 3);
+      return { kind: "solid", color: resolveColor(ctx, paletteIndex, alpha) };
+    }
+    case 4: {
+      const colorLineOffset = getUint24(view, offset + 1);
+      const x0 = view.getInt16(offset + 4), y0 = view.getInt16(offset + 6);
+      const x1 = view.getInt16(offset + 8), y1 = view.getInt16(offset + 10);
+      const { stops, extend } = readColorLine(ctx, offset + colorLineOffset);
+      return { kind: "linear", p0: apply(m, x0, y0), p1: apply(m, x1, y1), stops, extend };
+    }
+    case 6: {
+      const colorLineOffset = getUint24(view, offset + 1);
+      const x0 = view.getInt16(offset + 4), y0 = view.getInt16(offset + 6);
+      const r0 = view.getUint16(offset + 8);
+      const x1 = view.getInt16(offset + 10), y1 = view.getInt16(offset + 12);
+      const r1 = view.getUint16(offset + 14);
+      const { stops, extend } = readColorLine(ctx, offset + colorLineOffset);
+      const s = avgScale(m);
+      return { kind: "radial", c0: apply(m, x0, y0), r0: r0 * s, c1: apply(m, x1, y1), r1: r1 * s, stops, extend };
+    }
+    case 8: {
+      const colorLineOffset = getUint24(view, offset + 1);
+      const cx = view.getInt16(offset + 4), cy = view.getInt16(offset + 6);
+      const startAngle = f2dot14(view, offset + 8) * 180;
+      const endAngle = f2dot14(view, offset + 10) * 180;
+      const { stops, extend } = readColorLine(ctx, offset + colorLineOffset);
+      const rot = Math.atan2(m[1], m[0]) * 180 / Math.PI;
+      return {
+        kind: "sweep",
+        center: apply(m, cx, cy),
+        startAngle: startAngle + rot,
+        endAngle: endAngle + rot,
+        stops,
+        extend
+      };
+    }
+    case 12: {
+      const subOffset = getUint24(view, offset + 1);
+      const transformOffset = getUint24(view, offset + 4);
+      const t = readAffine(view, offset + transformOffset);
+      return resolveFill(ctx, offset + subOffset, compose(m, t));
+    }
+    case 14: {
+      const subOffset = getUint24(view, offset + 1);
+      const dx = view.getInt16(offset + 4), dy = view.getInt16(offset + 6);
+      return resolveFill(ctx, offset + subOffset, compose(m, [1, 0, 0, 1, dx, dy]));
+    }
+    case 16: {
+      const subOffset = getUint24(view, offset + 1);
+      const sx = f2dot14(view, offset + 4), sy = f2dot14(view, offset + 6);
+      return resolveFill(ctx, offset + subOffset, compose(m, [sx, 0, 0, sy, 0, 0]));
+    }
+    default:
+      throw new UnsupportedPaint(`fill paint format ${format}`);
+  }
+}
+function readAffine(view, pos) {
+  const xx = fixed(view, pos);
+  const yx = fixed(view, pos + 4);
+  const xy = fixed(view, pos + 8);
+  const yy = fixed(view, pos + 12);
+  const dx = fixed(view, pos + 16);
+  const dy = fixed(view, pos + 20);
+  return [xx, yx, xy, yy, dx, dy];
+}
+function collectLayers(ctx, offset, m, out, depth, blendMode) {
+  if (depth > 16) throw new UnsupportedPaint("paint recursion too deep");
+  const { view } = ctx;
+  const format = view.getUint8(offset);
+  switch (format) {
+    case 1: {
+      const numLayers = view.getUint8(offset + 1);
+      const firstLayerIndex = view.getUint32(offset + 2);
+      if (!ctx.layerListBase) throw new UnsupportedPaint("PaintColrLayers without LayerList");
+      for (let i = 0; i < numLayers; i++) {
+        const idx = firstLayerIndex + i;
+        const paintOffset = view.getUint32(ctx.layerListBase + 4 + idx * 4);
+        collectLayers(ctx, ctx.layerListBase + paintOffset, m, out, depth + 1, blendMode);
+      }
+      return;
+    }
+    case 10: {
+      const subOffset = getUint24(view, offset + 1);
+      const glyphId = view.getUint16(offset + 4);
+      const paint = resolveFill(ctx, offset + subOffset, IDENTITY);
+      const layer = m === IDENTITY ? { glyphId, paint } : { glyphId, paint, transform: m };
+      out.push(blendMode ? { ...layer, blendMode } : layer);
+      return;
+    }
+    case 11: {
+      const glyphId = view.getUint16(offset + 1);
+      const paintOffset = baseGlyphPaintOffset(ctx, glyphId);
+      if (paintOffset === null) throw new UnsupportedPaint("PaintColrGlyph missing base");
+      collectLayers(ctx, paintOffset, m, out, depth + 1, blendMode);
+      return;
+    }
+    case 12: {
+      const subOffset = getUint24(view, offset + 1);
+      const transformOffset = getUint24(view, offset + 4);
+      const t = readAffine(view, offset + transformOffset);
+      collectLayers(ctx, offset + subOffset, compose(m, t), out, depth + 1, blendMode);
+      return;
+    }
+    case 14: {
+      const subOffset = getUint24(view, offset + 1);
+      const dx = view.getInt16(offset + 4), dy = view.getInt16(offset + 6);
+      collectLayers(ctx, offset + subOffset, compose(m, [1, 0, 0, 1, dx, dy]), out, depth + 1, blendMode);
+      return;
+    }
+    case 16: {
+      const subOffset = getUint24(view, offset + 1);
+      const sx = f2dot14(view, offset + 4), sy = f2dot14(view, offset + 6);
+      collectLayers(ctx, offset + subOffset, compose(m, [sx, 0, 0, sy, 0, 0]), out, depth + 1, blendMode);
+      return;
+    }
+    case 32: {
+      const sourceOffset = getUint24(view, offset + 1);
+      const mode = view.getUint8(offset + 4);
+      const backdropOffset = getUint24(view, offset + 5);
+      const bm = compositeModeToBlendMode(mode);
+      if (bm === null) throw new UnsupportedPaint(`composite mode ${mode}`);
+      collectLayers(ctx, offset + backdropOffset, m, out, depth + 1, blendMode);
+      collectLayers(ctx, offset + sourceOffset, m, out, depth + 1, bm === "Normal" ? blendMode : bm);
+      return;
+    }
+    default:
+      throw new UnsupportedPaint(`structural paint format ${format}`);
+  }
+}
+function compositeModeToBlendMode(mode) {
+  switch (mode) {
+    case 3:
+      return "Normal";
+    // SRC_OVER
+    case 13:
+      return "Screen";
+    case 14:
+      return "Overlay";
+    case 15:
+      return "Darken";
+    case 16:
+      return "Lighten";
+    case 17:
+      return "ColorDodge";
+    case 18:
+      return "ColorBurn";
+    case 19:
+      return "HardLight";
+    case 20:
+      return "SoftLight";
+    case 21:
+      return "Difference";
+    case 22:
+      return "Exclusion";
+    case 23:
+      return "Multiply";
+    case 24:
+      return "Hue";
+    case 25:
+      return "Saturation";
+    case 26:
+      return "Color";
+    case 27:
+      return "Luminosity";
+    // 0 CLEAR, 1 SRC, 2 DEST, 4 DEST_OVER, 5 SRC_IN, 6 DEST_IN, 7 SRC_OUT,
+    // 8 DEST_OUT, 9 SRC_ATOP, 10 DEST_ATOP, 11 XOR, 12 PLUS → unsupported.
+    default:
+      return null;
+  }
+}
+function baseGlyphPaintOffset(ctx, glyphId) {
+  const { view, colrBase } = ctx;
+  const baseGlyphListOffset = view.getUint32(colrBase + 14);
+  if (!baseGlyphListOffset) return null;
+  const listBase = colrBase + baseGlyphListOffset;
+  const numRecords = view.getUint32(listBase);
+  for (let i = 0; i < numRecords; i++) {
+    const rec = listBase + 4 + i * 6;
+    const gid = view.getUint16(rec);
+    if (gid === glyphId) {
+      return listBase + view.getUint32(rec + 2);
+    }
+  }
+  return null;
+}
+function parseColrCpal(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tables = tableDirectory(view);
+  const colr = tables["COLR"];
+  if (!colr) return null;
+  const palette = parseCpal(bytes) ?? [];
+  const colrBase = colr.offset;
+  const version = view.getUint16(colrBase);
+  const result = {};
+  const numBaseGlyphRecords = view.getUint16(colrBase + 2);
+  const baseGlyphRecordsOffset = view.getUint32(colrBase + 4);
+  const layerRecordsOffset = view.getUint32(colrBase + 8);
+  if (numBaseGlyphRecords && baseGlyphRecordsOffset && layerRecordsOffset) {
+    const recBase = colrBase + baseGlyphRecordsOffset;
+    const layerBase = colrBase + layerRecordsOffset;
+    for (let i = 0; i < numBaseGlyphRecords; i++) {
+      const rec = recBase + i * 6;
+      const gid = view.getUint16(rec);
+      const firstLayer = view.getUint16(rec + 2);
+      const numLayers = view.getUint16(rec + 4);
+      const layers = [];
+      for (let j = 0; j < numLayers; j++) {
+        const lr = layerBase + (firstLayer + j) * 4;
+        const layerGid = view.getUint16(lr);
+        const paletteIndex = view.getUint16(lr + 2);
+        const color = paletteIndex === 65535 ? [0, 0, 0, 255] : palette[paletteIndex] ?? [0, 0, 0, 255];
+        layers.push({ glyphId: layerGid, paint: { kind: "solid", color } });
+      }
+      if (layers.length) result[gid] = { layers };
+    }
+  }
+  if (version >= 1) {
+    const layerListOffset = view.getUint32(colrBase + 18);
+    const ctx = {
+      view,
+      palette,
+      colrBase,
+      layerListBase: layerListOffset ? colrBase + layerListOffset : 0
+    };
+    const baseGlyphListOffset = view.getUint32(colrBase + 14);
+    if (baseGlyphListOffset) {
+      const listBase = colrBase + baseGlyphListOffset;
+      const numRecords = view.getUint32(listBase);
+      for (let i = 0; i < numRecords; i++) {
+        const rec = listBase + 4 + i * 6;
+        const gid = view.getUint16(rec);
+        const paintOffset = listBase + view.getUint32(rec + 2);
+        try {
+          const layers = [];
+          collectLayers(ctx, paintOffset, IDENTITY, layers, 0);
+          if (layers.length) result[gid] = { layers };
+        } catch (e) {
+          if (!(e instanceof UnsupportedPaint)) throw e;
+        }
+      }
+    }
+  }
+  return Object.keys(result).length ? result : null;
+}
+
+// src/fonts/font-subsetter.ts
+function subsetTTF(ttfInput, usedGids) {
+  try {
+    let u8;
+    let len;
+    if (ttfInput instanceof Uint8Array) {
+      u8 = ttfInput;
+      len = u8.length;
+    } else {
+      len = ttfInput.length;
+      const buf = new ArrayBuffer(len);
+      u8 = new Uint8Array(buf);
+      for (let i = 0; i < len; i++) u8[i] = ttfInput.charCodeAt(i);
+    }
+    if (len < 12) return ttfInput instanceof Uint8Array ? uint8ToBinaryString(u8) : ttfInput;
+    const view = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+    const numTables = view.getUint16(4);
+    const dirEnd = 12 + numTables * 16;
+    if (dirEnd > len) return ttfInput instanceof Uint8Array ? uint8ToBinaryString(u8) : ttfInput;
+    const tables = {};
+    for (let i = 0; i < numTables; i++) {
+      const off = 12 + i * 16;
+      const tag = String.fromCharCode(u8[off], u8[off + 1], u8[off + 2], u8[off + 3]);
+      tables[tag] = {
+        offset: view.getUint32(off + 8),
+        length: view.getUint32(off + 12)
+      };
+    }
+    const head = tables["head"];
+    const maxp = tables["maxp"];
+    const loca = tables["loca"];
+    const glyf = tables["glyf"];
+    if (!head || !maxp || !loca || !glyf) return ttfInput instanceof Uint8Array ? uint8ToBinaryString(u8) : ttfInput;
+    const numGlyphs = view.getUint16(maxp.offset + 4);
+    const locaFormat = view.getInt16(head.offset + 50);
+    const origOffsets = new Uint32Array(numGlyphs + 1);
+    for (let i = 0; i <= numGlyphs; i++) {
+      origOffsets[i] = locaFormat === 0 ? view.getUint16(loca.offset + i * 2) * 2 : view.getUint32(loca.offset + i * 4);
+    }
+    const allGids = new Set(usedGids);
+    allGids.add(0);
+    const MAX_COMPOUND_ITERATIONS = 1e4;
+    let iterations = 0;
+    const queue = [...allGids];
+    while (queue.length > 0) {
+      if (++iterations > MAX_COMPOUND_ITERATIONS) break;
+      const gid = queue.pop();
+      if (gid === void 0 || gid >= numGlyphs) continue;
+      const off = origOffsets[gid];
+      const next = origOffsets[gid + 1];
+      if (off >= next) continue;
+      const glyfOff = glyf.offset + off;
+      if (glyfOff + 10 > len) continue;
+      if (view.getInt16(glyfOff) >= 0) continue;
+      let pos2 = glyfOff + 10;
+      let flags;
+      do {
+        if (pos2 + 4 > len) break;
+        flags = view.getUint16(pos2);
+        const componentGid = view.getUint16(pos2 + 2);
+        if (!allGids.has(componentGid)) {
+          allGids.add(componentGid);
+          queue.push(componentGid);
+        }
+        pos2 += 4;
+        if (flags & 1) pos2 += 4;
+        else pos2 += 2;
+        if (flags & 8) pos2 += 2;
+        else if (flags & 64) pos2 += 4;
+        else if (flags & 128) pos2 += 8;
+      } while (flags & 32);
+    }
+    const glyfChunks = [];
+    const newOffsets = new Uint32Array(numGlyphs + 1);
+    let curOff = 0;
+    for (let gid = 0; gid < numGlyphs; gid++) {
+      newOffsets[gid] = curOff;
+      if (allGids.has(gid)) {
+        const off = origOffsets[gid];
+        const next = origOffsets[gid + 1];
+        const glyphLen = next - off;
+        if (glyphLen > 0) {
+          glyfChunks.push(u8.slice(glyf.offset + off, glyf.offset + next));
+          curOff += glyphLen;
+          if (glyphLen & 1) {
+            glyfChunks.push(new Uint8Array(1));
+            curOff += 1;
+          }
+        }
+      }
+    }
+    newOffsets[numGlyphs] = curOff;
+    const newGlyf = new Uint8Array(curOff);
+    let pos = 0;
+    for (const chunk of glyfChunks) {
+      newGlyf.set(chunk, pos);
+      pos += chunk.length;
+    }
+    const newLocaBuf = new ArrayBuffer((numGlyphs + 1) * 4);
+    const newLocaView = new DataView(newLocaBuf);
+    for (let i = 0; i <= numGlyphs; i++) newLocaView.setUint32(i * 4, newOffsets[i]);
+    const newLoca = new Uint8Array(newLocaBuf);
+    const PDF_TABLES = /* @__PURE__ */ new Set(["head", "hhea", "maxp", "OS/2", "cmap", "hmtx", "loca", "glyf", "name", "post"]);
+    const tableTags = Object.keys(tables).filter((t) => PDF_TABLES.has(t)).sort();
+    const newTableData = {};
+    for (const tag of tableTags) {
+      const t = tables[tag];
+      newTableData[tag] = u8.slice(t.offset, t.offset + t.length);
+    }
+    newTableData["glyf"] = newGlyf;
+    newTableData["loca"] = newLoca;
+    const headCopy = new Uint8Array(newTableData["head"]);
+    new DataView(headCopy.buffer, headCopy.byteOffset, headCopy.byteLength).setInt16(50, 1);
+    new DataView(headCopy.buffer, headCopy.byteOffset, headCopy.byteLength).setUint32(8, 0);
+    newTableData["head"] = headCopy;
+    const numNewTables = tableTags.length;
+    const headerSize = 12 + numNewTables * 16;
+    let totalSize = headerSize;
+    const tableFileOffsets = {};
+    for (const tag of tableTags) {
+      tableFileOffsets[tag] = totalSize;
+      totalSize += newTableData[tag].length;
+      if (totalSize & 3) totalSize += 4 - (totalSize & 3);
+    }
+    const output = new Uint8Array(totalSize);
+    const outView = new DataView(output.buffer);
+    outView.setUint32(0, 65536);
+    outView.setUint16(4, numNewTables);
+    let entrySelector = 0, searchRange = 1;
+    while (searchRange * 2 <= numNewTables) {
+      searchRange *= 2;
+      entrySelector++;
+    }
+    searchRange *= 16;
+    outView.setUint16(6, searchRange);
+    outView.setUint16(8, entrySelector);
+    outView.setUint16(10, numNewTables * 16 - searchRange);
+    for (let i = 0; i < tableTags.length; i++) {
+      const tag = tableTags[i];
+      const off = 12 + i * 16;
+      for (let j = 0; j < 4; j++) output[off + j] = tag.charCodeAt(j);
+      outView.setUint32(off + 4, ttfChecksum(newTableData[tag]));
+      outView.setUint32(off + 8, tableFileOffsets[tag]);
+      outView.setUint32(off + 12, newTableData[tag].length);
+    }
+    for (const tag of tableTags) output.set(newTableData[tag], tableFileOffsets[tag]);
+    let result = "";
+    for (let i = 0; i < output.length; i += 8192) {
+      const end = Math.min(i + 8192, output.length);
+      result += String.fromCharCode.apply(null, Array.from(output.subarray(i, end)));
+    }
+    return result;
+  } catch {
+    return ttfInput instanceof Uint8Array ? uint8ToBinaryString(ttfInput) : ttfInput;
+  }
+}
+function uint8ToBinaryString(u8) {
+  let result = "";
+  for (let i = 0; i < u8.length; i += 8192) {
+    const end = Math.min(i + 8192, u8.length);
+    result += String.fromCharCode.apply(null, Array.from(u8.subarray(i, end)));
+  }
+  return result;
+}
+function ttfChecksum(data) {
+  const len = data.length;
+  const padded = len & 3 ? new Uint8Array([...data, ...new Uint8Array(4 - (len & 3))]) : data;
+  const view = new DataView(padded.buffer, padded.byteOffset, padded.byteLength);
+  let sum = 0;
+  for (let i = 0; i < padded.length; i += 4) sum = sum + view.getUint32(i) >>> 0;
+  return sum;
+}
+
+// scripts/lib/emoji-font-core.ts
+function readTables(view) {
+  const numTables = view.getUint16(4);
+  const tables = {};
+  for (let i = 0; i < numTables; i++) {
+    const rec = 12 + i * 16;
+    const tag = String.fromCharCode(
+      view.getUint8(rec),
+      view.getUint8(rec + 1),
+      view.getUint8(rec + 2),
+      view.getUint8(rec + 3)
+    );
+    tables[tag] = { offset: view.getUint32(rec + 8), length: view.getUint32(rec + 12) };
+  }
+  return tables;
+}
+function parseCmap(view, base) {
+  const cmap = /* @__PURE__ */ new Map();
+  const numSub = view.getUint16(base + 2);
+  let bestOff = -1;
+  let bestFmt = 0;
+  for (let i = 0; i < numSub; i++) {
+    const rec = base + 4 + i * 8;
+    const plat = view.getUint16(rec);
+    const enc = view.getUint16(rec + 2);
+    const off = view.getUint32(rec + 4);
+    if (plat === 3 && (enc === 1 || enc === 10) || plat === 0 && (enc === 3 || enc === 4 || enc === 6)) {
+      const fmt = view.getUint16(base + off);
+      if (fmt === 12 && bestFmt < 12) {
+        bestOff = base + off;
+        bestFmt = 12;
+      } else if (fmt === 4 && bestFmt < 4) {
+        bestOff = base + off;
+        bestFmt = 4;
+      }
+    }
+  }
+  if (bestOff < 0) return cmap;
+  if (bestFmt === 12) {
+    const nGroups = view.getUint32(bestOff + 12);
+    for (let g = 0; g < nGroups; g++) {
+      const rec = bestOff + 16 + g * 12;
+      const start = view.getUint32(rec);
+      const end = view.getUint32(rec + 4);
+      const startGid = view.getUint32(rec + 8);
+      for (let c = start; c <= end; c++) cmap.set(c, startGid + (c - start));
+    }
+  } else {
+    const segX2 = view.getUint16(bestOff + 6);
+    const segCount = segX2 / 2;
+    const endBase = bestOff + 14;
+    const startBase = endBase + segX2 + 2;
+    const deltaBase = startBase + segX2;
+    const rangeBase = deltaBase + segX2;
+    for (let s = 0; s < segCount; s++) {
+      const end = view.getUint16(endBase + s * 2);
+      const start = view.getUint16(startBase + s * 2);
+      const delta = view.getInt16(deltaBase + s * 2);
+      const rangeOff = view.getUint16(rangeBase + s * 2);
+      if (start === 65535) break;
+      for (let c = start; c <= end; c++) {
+        let gid;
+        if (rangeOff === 0) gid = c + delta & 65535;
+        else {
+          const gi = rangeBase + s * 2 + rangeOff + (c - start) * 2;
+          gid = view.getUint16(gi);
+          if (gid !== 0) gid = gid + delta & 65535;
+        }
+        if (gid !== 0) cmap.set(c, gid);
+      }
+    }
+  }
+  return cmap;
+}
+function buildEmojiFontModule(ttf, codepoints, opts) {
+  const view = new DataView(ttf.buffer, ttf.byteOffset, ttf.byteLength);
+  const tables = readTables(view);
+  const unitsPerEm = view.getUint16(tables["head"].offset + 18);
+  const xMin = view.getInt16(tables["head"].offset + 36);
+  const yMin = view.getInt16(tables["head"].offset + 38);
+  const xMax = view.getInt16(tables["head"].offset + 40);
+  const yMax = view.getInt16(tables["head"].offset + 42);
+  const ascent = view.getInt16(tables["hhea"].offset + 4);
+  const descent = view.getInt16(tables["hhea"].offset + 6);
+  const numberOfHMetrics = view.getUint16(tables["hhea"].offset + 34);
+  const numGlyphs = view.getUint16(tables["maxp"].offset + 4);
+  let capHeight = Math.round(ascent * 0.7);
+  if (tables["OS/2"] && tables["OS/2"].length >= 90) {
+    capHeight = view.getInt16(tables["OS/2"].offset + 88);
+  }
+  const widthsAll = new Array(numGlyphs).fill(0);
+  let lastW = 0;
+  for (let i = 0; i < numGlyphs; i++) {
+    if (i < numberOfHMetrics) {
+      lastW = view.getUint16(tables["hmtx"].offset + i * 4);
+    }
+    widthsAll[i] = lastW;
+  }
+  const cmap = parseCmap(view, tables["cmap"].offset);
+  const colorGlyphs = parseColrCpal(ttf);
+  if (!colorGlyphs) throw new Error("Font has no COLR/CPAL table");
+  const subCmap = {};
+  const subWidths = {};
+  const subColor = {};
+  const usedGids = /* @__PURE__ */ new Set([0]);
+  let kept = 0;
+  let missing = 0;
+  const missingCodepoints = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const cp of codepoints) {
+    if (seen.has(cp)) continue;
+    seen.add(cp);
+    const gid = cmap.get(cp);
+    if (gid === void 0 || !colorGlyphs[gid]) {
+      missing++;
+      missingCodepoints.push(cp);
+      continue;
+    }
+    subCmap[cp] = gid;
+    subWidths[gid] = widthsAll[gid];
+    subColor[gid] = colorGlyphs[gid];
+    usedGids.add(gid);
+    for (const layer of colorGlyphs[gid].layers) usedGids.add(layer.glyphId);
+    kept++;
+  }
+  const subBinary = subsetTTF(ttf, usedGids);
+  const ttfBase64 = Buffer.from(subBinary, "latin1").toString("base64");
+  const defaultWidth = widthsAll[cmap.get(32) ?? 0] || widthsAll[0] || unitsPerEm;
+  const cids = Object.keys(subWidths).map(Number).sort((a, b) => a - b);
+  const wParts = [];
+  for (const cid of cids) wParts.push(`${cid} [${subWidths[cid]}]`);
+  const pdfWidthArray = wParts.join(" ");
+  const metrics = {
+    unitsPerEm,
+    ascent,
+    descent,
+    capHeight,
+    stemV: 80,
+    bbox: [xMin, yMin, xMax, yMax],
+    defaultWidth,
+    numGlyphs
+  };
+  const fontName = opts.fontName ?? "NotoColorEmoji-Regular";
+  const fontNameLiteral = fontName.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const banner = opts.makeBanner(kept);
+  const js = `${banner}
+
+export const metrics = ${JSON.stringify(metrics)};
+export const fontName = '${fontNameLiteral}';
+export const cmap = ${JSON.stringify(subCmap)};
+export const defaultWidth = ${defaultWidth};
+export const widths = ${JSON.stringify(subWidths)};
+export const pdfWidthArray = ${JSON.stringify(pdfWidthArray)};
+export const gsub = {};
+export const ligatures = null;
+export const markAnchors = null;
+export const mark2mark = null;
+export const colorGlyphs = ${JSON.stringify(subColor)};
+export const ttfBase64 = ${JSON.stringify(ttfBase64)};
+`;
+  const dts = `${banner}
+
+import type { FontData } from '${opts.dtsTypeImport.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}';
+
+export declare const metrics: FontData['metrics'];
+export declare const fontName: string;
+export declare const cmap: Record<number, number>;
+export declare const defaultWidth: number;
+export declare const widths: Record<number, number>;
+export declare const pdfWidthArray: string;
+export declare const gsub: Record<number, number>;
+export declare const ligatures: null;
+export declare const markAnchors: null;
+export declare const mark2mark: null;
+export declare const colorGlyphs: NonNullable<FontData['colorGlyphs']>;
+export declare const ttfBase64: string;
+`;
+  const sizeKb = Math.round(Buffer.byteLength(js) / 1024);
+  return { js, dts, stats: { kept, missing, usedGids: usedGids.size, sizeKb, missingCodepoints } };
+}
+function allColorCodepoints(ttf) {
+  const view = new DataView(ttf.buffer, ttf.byteOffset, ttf.byteLength);
+  const tables = readTables(view);
+  const cmap = parseCmap(view, tables["cmap"].offset);
+  const colorGlyphs = parseColrCpal(ttf);
+  if (!colorGlyphs) throw new Error("Font has no COLR/CPAL table");
+  const out = [];
+  for (const [cp, gid] of cmap) {
+    if (colorGlyphs[gid]) out.push(cp);
+  }
+  return out.sort((a, b) => a - b);
+}
+
+// scripts/lib/curated-emoji.ts
+var CURATED_EMOJI = [
+  // Smileys & emotion
+  128512,
+  128513,
+  128514,
+  128515,
+  128516,
+  128517,
+  128518,
+  128519,
+  128521,
+  128522,
+  128523,
+  128524,
+  128525,
+  128526,
+  128527,
+  128528,
+  128530,
+  128531,
+  128532,
+  128533,
+  128534,
+  128536,
+  128537,
+  128538,
+  128540,
+  128541,
+  128542,
+  128544,
+  128545,
+  128546,
+  128547,
+  128548,
+  128549,
+  128552,
+  128553,
+  128554,
+  128555,
+  128556,
+  128557,
+  128558,
+  128559,
+  128560,
+  128561,
+  128562,
+  128563,
+  128564,
+  128565,
+  128566,
+  128567,
+  128577,
+  128578,
+  128579,
+  128580,
+  129296,
+  129297,
+  129298,
+  129299,
+  129300,
+  129301,
+  129303,
+  129312,
+  129313,
+  129314,
+  129315,
+  129316,
+  129317,
+  129319,
+  129320,
+  129321,
+  129322,
+  129323,
+  129324,
+  129325,
+  129326,
+  129327,
+  129392,
+  129395,
+  129396,
+  129397,
+  129398,
+  129402,
+  129400,
+  129401,
+  // Hearts & symbols
+  10084,
+  129505,
+  128155,
+  128154,
+  128153,
+  128156,
+  128420,
+  129293,
+  129294,
+  128148,
+  128149,
+  128150,
+  128151,
+  128152,
+  128157,
+  128158,
+  128159,
+  11088,
+  127775,
+  10024,
+  128165,
+  128171,
+  128293,
+  128175,
+  9989,
+  10060,
+  10071,
+  10067,
+  9888,
+  9851,
+  // Hands & people
+  128077,
+  128078,
+  128076,
+  128074,
+  9994,
+  9995,
+  128075,
+  128080,
+  128588,
+  128591,
+  128079,
+  128400,
+  129304,
+  129305,
+  129306,
+  129307,
+  129308,
+  129309,
+  129310,
+  129311,
+  128405,
+  128170,
+  // Animals & nature
+  128054,
+  128049,
+  128045,
+  128057,
+  128048,
+  128059,
+  128060,
+  128040,
+  128047,
+  129409,
+  128046,
+  128055,
+  128056,
+  128053,
+  128020,
+  128039,
+  128038,
+  128029,
+  129419,
+  128012,
+  128030,
+  128034,
+  128013,
+  128051,
+  128044,
+  128031,
+  127812,
+  127802,
+  127799,
+  127800,
+  127801,
+  127803,
+  127811,
+  127794,
+  127795,
+  127796,
+  // Food & drink
+  127822,
+  127820,
+  127815,
+  127817,
+  127827,
+  127826,
+  127825,
+  127818,
+  127813,
+  129365,
+  127805,
+  127828,
+  127829,
+  127839,
+  127789,
+  127871,
+  127846,
+  127856,
+  127851,
+  127850,
+  9749,
+  127866,
+  127863,
+  // Activity, travel & objects
+  9917,
+  127936,
+  127944,
+  127934,
+  127952,
+  127928,
+  127925,
+  127912,
+  128663,
+  128661,
+  128652,
+  9992,
+  128640,
+  128674,
+  8986,
+  128241,
+  128187,
+  128161,
+  128214,
+  9999,
+  128204,
+  128274,
+  128273,
+  127968,
+  127873,
+  127880,
+  127881,
+  127926,
+  128176,
+  128181
+];
+
+// scripts/lib/emoji-cli.ts
+var DEFAULT_OUT = "noto-color-emoji-data.js";
+var DEFAULT_TYPES = "pdfnative";
+function parseArgs(argv) {
+  const opts = {
+    download: false,
+    all: false,
+    out: DEFAULT_OUT,
+    types: DEFAULT_TYPES,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = () => {
+      const v = argv[++i];
+      if (v === void 0) throw new Error(`Missing value for ${arg}`);
+      return v;
+    };
+    switch (arg) {
+      case "-h":
+      case "--help":
+        opts.help = true;
+        break;
+      case "--ttf":
+        opts.ttf = next();
+        break;
+      case "--download":
+        opts.download = true;
+        break;
+      case "--all":
+        opts.all = true;
+        break;
+      case "--preset":
+        opts.preset = next();
+        break;
+      case "--codepoints":
+        opts.codepoints = next();
+        break;
+      case "--ranges":
+        opts.ranges = next();
+        break;
+      case "--out":
+        opts.out = next();
+        break;
+      case "--font-name":
+        opts.fontName = next();
+        break;
+      case "--types":
+        opts.types = next();
+        break;
+      default:
+        throw new Error(`Unknown option: ${arg} (try --help)`);
+    }
+  }
+  return opts;
+}
+function parseHex(token) {
+  const t = token.trim().replace(/^(u\+|0x|#)/i, "");
+  if (!/^[0-9a-f]+$/i.test(t)) throw new Error(`Invalid codepoint: "${token}"`);
+  const cp = parseInt(t, 16);
+  if (!Number.isFinite(cp) || cp < 0 || cp > 1114111) {
+    throw new Error(`Codepoint out of range: "${token}"`);
+  }
+  return cp;
+}
+function resolveCodepoints(opts, allColor) {
+  if (opts.all || opts.preset === "all") return [...allColor()].sort((a, b) => a - b);
+  if (opts.preset && opts.preset !== "curated") {
+    throw new Error(`Unknown preset: "${opts.preset}" (use 'curated' or 'all')`);
+  }
+  const set = /* @__PURE__ */ new Set();
+  let explicit = false;
+  if (opts.preset === "curated") {
+    for (const cp of CURATED_EMOJI) set.add(cp);
+    explicit = true;
+  }
+  if (opts.codepoints) {
+    for (const tok of opts.codepoints.split(",")) {
+      if (tok.trim()) {
+        set.add(parseHex(tok));
+        explicit = true;
+      }
+    }
+  }
+  if (opts.ranges) {
+    for (const tok of opts.ranges.split(",")) {
+      if (!tok.trim()) continue;
+      const [a, b] = tok.split("-");
+      if (a === void 0 || b === void 0) throw new Error(`Invalid range: "${tok}"`);
+      const lo = parseHex(a);
+      const hi = parseHex(b);
+      if (hi < lo) throw new Error(`Range end before start: "${tok}"`);
+      if (hi - lo > 131072) throw new Error(`Range too large: "${tok}"`);
+      for (let cp = lo; cp <= hi; cp++) set.add(cp);
+      explicit = true;
+    }
+  }
+  if (!explicit) for (const cp of CURATED_EMOJI) set.add(cp);
+  return [...set].sort((a, b) => a - b);
+}
+
+// scripts/build-emoji-font.ts
+var DOWNLOAD_URL = "https://raw.githubusercontent.com/google/fonts/main/ofl/notocoloremoji/NotoColorEmoji-Regular.ttf";
+var DOWNLOAD_SHA256 = "be73479ba4fa277c89b85cd6c71717df30d9d0eff6da8c1e1a201e5b95459299";
+var HELP = `pdfnative-build-emoji-font \u2014 colour-emoji font data module generator
+
+Source font (one of):
+  --ttf <path>            Path to a COLRv1/CPAL colour font (NotoColorEmoji-Regular.ttf).
+  --download              Fetch the official Noto Color Emoji (OFL-1.1) and verify checksum.
+
+Glyph selection (combine freely; default: --preset curated):
+  --all                   Every colour glyph in the font (large module).
+  --preset <curated|all>  Named selection ('curated' = pdfnative's lean 221-glyph set).
+  --codepoints <list>     Comma-separated hex scalars, e.g. 1F600,1F680,2764.
+  --ranges <list>         Comma-separated inclusive hex ranges, e.g. 1F600-1F64F.
+
+Output:
+  --out <path>            Output .js path (a sibling .d.ts is written). Default ./noto-color-emoji-data.js
+  --font-name <name>      Embedded PostScript font name.
+  --types <path>          Type import used in the generated .d.ts. Default 'pdfnative'.
+
+Other:
+  -h, --help              Show this help.
+
+Examples:
+  pdfnative-build-emoji-font --download --all
+  pdfnative-build-emoji-font --ttf ./NotoColorEmoji-Regular.ttf --codepoints 1F600,1F680
+  pdfnative-build-emoji-font --download --ranges 1F600-1F64F,2600-27BF --out ./emoji.js
+`;
+async function fetchFont() {
+  console.log(`Downloading Noto Color Emoji (OFL-1.1) \u2026`);
+  console.log(`  ${DOWNLOAD_URL}`);
+  const res = await fetch(DOWNLOAD_URL);
+  if (!res.ok) throw new Error(`Download failed \u2014 HTTP ${res.status}`);
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  const hash = createHash("sha256").update(bytes).digest("hex");
+  if (hash === DOWNLOAD_SHA256) {
+    console.log(`  checksum OK (sha256 ${hash.slice(0, 16)}\u2026)`);
+  } else {
+    console.warn(`  WARNING: checksum differs from the tested build.`);
+    console.warn(`    expected ${DOWNLOAD_SHA256}`);
+    console.warn(`    actual   ${hash}`);
+    console.warn(`  Upstream may have shipped a newer Unicode revision; proceeding.`);
+  }
+  return bytes;
+}
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    console.log(HELP);
+    return;
+  }
+  if (!opts.ttf && !opts.download) {
+    throw new Error("Provide a source font with --ttf <path> or --download (try --help)");
+  }
+  if (opts.ttf && opts.download) {
+    throw new Error("Use either --ttf or --download, not both");
+  }
+  const ttf = opts.download ? await fetchFont() : new Uint8Array(readFileSync(resolve(opts.ttf)));
+  const codepoints = resolveCodepoints(opts, () => allColorCodepoints(ttf));
+  if (codepoints.length === 0) {
+    throw new Error("No codepoints selected \u2014 use --all, --preset, --codepoints or --ranges");
+  }
+  const outJs = resolve(opts.out);
+  const outDts = outJs.replace(/\.js$/i, "") + ".d.ts";
+  const fontName = opts.fontName ?? "NotoColorEmoji-Regular";
+  const { js, dts, stats } = buildEmojiFontModule(ttf, codepoints, {
+    fontName,
+    dtsTypeImport: opts.types,
+    makeBanner: (kept) => `/**
+ * COLOUR-EMOJI FONT DATA \u2014 ${fontName}
+ * Generated by: pdfnative-build-emoji-font
+ * Source: Noto Color Emoji (OFL-1.1). Colour glyphs: ${kept}.
+ *
+ * Opt in:
+ *   import { registerFont } from 'pdfnative';
+ *   registerFont('emoji', () => import('./${outJs.split(/[\\/]/).pop()}'));
+ */`
+  });
+  writeFileSync(outJs, js);
+  writeFileSync(outDts, dts);
+  console.log(`Colour-emoji data module written:`);
+  console.log(`  requested codepoints: ${codepoints.length}`);
+  console.log(`  colour glyphs kept:   ${stats.kept}  (missing: ${stats.missing})`);
+  console.log(`  embedded glyph ids:   ${stats.usedGids}`);
+  console.log(`  module size:          ${stats.sizeKb} KB`);
+  console.log(`  ${outJs}`);
+  console.log(`  ${outDts}`);
+}
+main().catch((err) => {
+  console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});