reamkit 1.30.0 → 1.31.0

package/dist/esm/core/font/ttf-build.js

@@ -0,0 +1,1224 @@
+import { directoryGeometry, paddedChecksum } from "./ttf-subset.js";
+//#region src/core/font/ttf-build.ts
+/**
+* The most pairs a `kern` subtable holds: its length is a 16-bit count of bytes,
+* six to a pair after a fourteen-byte header.
+*/
+var MAX_KERN_PAIRS = Math.floor(65521 / 6);
+/** OS/2 `fsType` bits (ISO/IEC 14496-22, OS/2 table). */
+var USAGE_BITS = 14;
+var EDITABLE_EMBEDDING = 8;
+var NO_SUBSETTING = 256;
+var BITMAP_ONLY = 512;
+/**
+* Whether a face's licence lets it be embedded, as outlines and subset, in a
+* document that stays EDITABLE: OS/2 `fsType` states installable embedding (no
+* usage bit) or grants editable embedding, and neither forbids subsetting nor
+* allows bitmaps only. Restricted-licence and preview-and-print faces are
+* refused — the second may travel only in a document opened read-only.
+*
+* Several usage bits at once is an old font's way of stating permissions, and
+* the least restrictive of them applies (OS/2 versions 0–2).
+*
+* @param fsType The field, or `undefined` where the program states none —
+*               which restricts nothing.
+* @returns Whether an editable document may carry the face.
+*/
+function editableEmbedding(fsType) {
+	if (fsType === void 0) return true;
+	if ((fsType & (NO_SUBSETTING | BITMAP_ONLY)) !== 0) return false;
+	const usage = fsType & USAGE_BITS;
+	return usage === 0 || (usage & EDITABLE_EMBEDDING) !== 0;
+}
+/** Units per em. */
+var UPEM = 1e3;
+/**
+* How far, in font units, a quadratic may stray from the cubic it replaces.
+* Half a unit is the rounding every coordinate takes anyway.
+*/
+var CURVE_TOLERANCE = .5;
+/** No cubic is cut into more quadratics than this. */
+var MAX_CURVE_PIECES = 16;
+/**
+* The most glyphs a built face holds. A `cmap` format 4 subtable is limited to
+* 64 KB, and past this many characters it may not fit; a face that large is a
+* whole CJK font, which is no subset.
+*/
+var MAX_BUILT_GLYPHS = 8e3;
+/**
+* Build a TrueType font from outlines (ISO/IEC 14496-22): `.notdef` first, then
+* one glyph per {@link BuiltGlyph} in the order given, reachable through a
+* Unicode `cmap`.
+*
+* Cubic curves become quadratic ones. A cubic that is a raised quadratic — what
+* a TrueType source's outline arrives as — comes back as exactly that
+* quadratic; any other is cut into as many quadratics as keep within half a
+* unit of it. Each glyph's contours are turned to run clockwise round their
+* ink, as TrueType's are.
+*
+* @param face The face: its names, metrics, licence and glyphs.
+* @returns The font program's bytes.
+* @throws When the face holds more than {@link MAX_BUILT_GLYPHS} glyphs.
+*/
+function buildTrueType(face) {
+	const ligatures = reachableLigatures(face);
+	if (face.glyphs.length + ligatures.length > 8e3) throw new Error(`A built face holds at most ${MAX_BUILT_GLYPHS} glyphs`);
+	const drawn = [...face.glyphs, ...ligatures];
+	const encoded = [emptyGlyph(), ...drawn.map((g) => encodeGlyph(contoursOf(g.outline)))];
+	const advances = [0, ...drawn.map((g) => clamp(Math.round(g.advance), 0, 65535))];
+	const inked = encoded.filter((g) => g.contours > 0);
+	const bounds = {
+		xMin: Math.min(0, ...inked.map((g) => g.xMin)),
+		yMin: Math.min(0, ...inked.map((g) => g.yMin)),
+		xMax: Math.max(0, ...inked.map((g) => g.xMax)),
+		yMax: Math.max(0, ...inked.map((g) => g.yMax))
+	};
+	const ascent = clamp(Math.round(face.ascent), 1, 32767);
+	const descent = clamp(Math.round(face.descent), -32767, 0);
+	const metrics = {
+		ascent,
+		descent,
+		winAscent: Math.max(ascent, bounds.yMax),
+		winDescent: Math.max(-descent, -bounds.yMin),
+		bounds
+	};
+	const cmap = cmapTable(face.glyphs);
+	return assembleSfnt([
+		["OS/2", os2Table(face, encoded, advances, metrics)],
+		["cmap", cmap],
+		["glyf", concat(encoded.map((g) => g.bytes))],
+		["head", headTable(face, bounds)],
+		["hhea", hheaTable(face, encoded, advances, metrics)],
+		["hmtx", hmtxTable(encoded, advances)],
+		...kerningTables(face),
+		...ligatureTable(face, ligatures),
+		["loca", locaTable(encoded)],
+		["maxp", maxpTable(encoded)],
+		["name", nameTable(face)],
+		["post", postTable(face)]
+	]);
+}
+/**
+* The outline as TrueType contours, in font units and rounded: each closed,
+* quadratic, and running clockwise round its ink.
+*/
+function contoursOf(outline) {
+	const out = [];
+	let current = [];
+	let x = 0;
+	let y = 0;
+	let startX = 0;
+	let startY = 0;
+	const finish = () => {
+		const contour = tidy(current);
+		if (contour.length >= 3) out.push(contour);
+		current = [];
+	};
+	for (const seg of outline) if (seg.op === "move") {
+		finish();
+		x = seg.x * UPEM;
+		y = seg.y * UPEM;
+		startX = x;
+		startY = y;
+		current.push({
+			x,
+			y,
+			on: true
+		});
+	} else if (seg.op === "line") {
+		if (current.length === 0) current.push({
+			x,
+			y,
+			on: true
+		});
+		x = seg.x * UPEM;
+		y = seg.y * UPEM;
+		current.push({
+			x,
+			y,
+			on: true
+		});
+	} else if (seg.op === "cubic") {
+		if (current.length === 0) current.push({
+			x,
+			y,
+			on: true
+		});
+		const to = {
+			x: seg.x * UPEM,
+			y: seg.y * UPEM
+		};
+		quadraticsOf({
+			x,
+			y
+		}, {
+			x: seg.x1 * UPEM,
+			y: seg.y1 * UPEM
+		}, {
+			x: seg.x2 * UPEM,
+			y: seg.y2 * UPEM
+		}, to, current);
+		x = to.x;
+		y = to.y;
+	} else {
+		finish();
+		x = startX;
+		y = startY;
+	}
+	finish();
+	let biggest = 0;
+	for (const contour of out) {
+		const a = area(contour);
+		if (Math.abs(a) > Math.abs(biggest)) biggest = a;
+	}
+	if (biggest > 0) for (const contour of out) contour.reverse();
+	return out;
+}
+/**
+* One cubic as quadratics, appended to `out` (its start is already there).
+*
+* A cubic raised from a quadratic has both its controls two thirds of the way
+* to the same point, and that point is the quadratic's control. Any other
+* cubic is cut evenly into pieces, each replaced by the quadratic through its
+* ends whose control is the average of the two its controls imply — which
+* strays from the piece by at most √3/36 of |P3 − 3C2 + 3C1 − P0|, a length
+* that shrinks with the cube of the piece.
+*/
+function quadraticsOf(p0, c1, c2, p3, out) {
+	const q1 = {
+		x: (3 * c1.x - p0.x) / 2,
+		y: (3 * c1.y - p0.y) / 2
+	};
+	const q2 = {
+		x: (3 * c2.x - p3.x) / 2,
+		y: (3 * c2.y - p3.y) / 2
+	};
+	if (Math.hypot(q1.x - q2.x, q1.y - q2.y) <= RAISED_QUADRATIC) {
+		out.push({
+			x: (q1.x + q2.x) / 2,
+			y: (q1.y + q2.y) / 2,
+			on: false
+		});
+		out.push({
+			x: p3.x,
+			y: p3.y,
+			on: true
+		});
+		return;
+	}
+	const dx = p3.x - 3 * c2.x + 3 * c1.x - p0.x;
+	const dy = p3.y - 3 * c2.y + 3 * c1.y - p0.y;
+	const stray = Math.hypot(dx, dy) * Math.sqrt(3) / 36;
+	const pieces = clamp(Math.ceil(Math.cbrt(stray / CURVE_TOLERANCE)), 1, MAX_CURVE_PIECES);
+	const at = (t) => {
+		const u = 1 - t;
+		return {
+			x: u * u * u * p0.x + 3 * u * u * t * c1.x + 3 * u * t * t * c2.x + t * t * t * p3.x,
+			y: u * u * u * p0.y + 3 * u * u * t * c1.y + 3 * u * t * t * c2.y + t * t * t * p3.y
+		};
+	};
+	const lean = (t) => {
+		const u = 1 - t;
+		const k = 1 / pieces;
+		return {
+			x: k * (u * u * (c1.x - p0.x) + 2 * u * t * (c2.x - c1.x) + t * t * (p3.x - c2.x)),
+			y: k * (u * u * (c1.y - p0.y) + 2 * u * t * (c2.y - c1.y) + t * t * (p3.y - c2.y))
+		};
+	};
+	for (let i = 0; i < pieces; i++) {
+		const t0 = i / pieces;
+		const t1 = (i + 1) / pieces;
+		const a = at(t0);
+		const b = i + 1 === pieces ? p3 : at(t1);
+		const la = lean(t0);
+		const lb = lean(t1);
+		const s1 = {
+			x: a.x + la.x,
+			y: a.y + la.y
+		};
+		const s2 = {
+			x: b.x - lb.x,
+			y: b.y - lb.y
+		};
+		out.push({
+			x: (3 * (s1.x + s2.x) - (a.x + b.x)) / 4,
+			y: (3 * (s1.y + s2.y) - (a.y + b.y)) / 4,
+			on: false
+		});
+		out.push({
+			x: b.x,
+			y: b.y,
+			on: true
+		});
+	}
+}
+/** How near, in font units, a cubic's two implied controls must be to be one. */
+var RAISED_QUADRATIC = .01;
+/**
+* A contour rounded to whole units, with the points rounding merges into one
+* and the closing point that repeats the first taken out.
+*/
+function tidy(points) {
+	const out = [];
+	for (const p of points) {
+		const q = {
+			x: clamp(Math.round(p.x), -32768, 32767),
+			y: clamp(Math.round(p.y), -32768, 32767),
+			on: p.on
+		};
+		const last = out[out.length - 1];
+		if (last && last.x === q.x && last.y === q.y) last.on = last.on || q.on;
+		else out.push(q);
+	}
+	while (out.length > 1) {
+		const first = out[0];
+		const last = out[out.length - 1];
+		if (first.x !== last.x || first.y !== last.y) break;
+		first.on = first.on || last.on;
+		out.pop();
+	}
+	return out;
+}
+/** Twice the signed area a contour's points enclose — positive counter-clockwise. */
+function area(points) {
+	let sum = 0;
+	for (let i = 0; i < points.length; i++) {
+		const a = points[i];
+		const b = points[(i + 1) % points.length];
+		sum += a.x * b.y - b.x * a.y;
+	}
+	return sum;
+}
+function emptyGlyph() {
+	return {
+		bytes: new Uint8Array(0),
+		contours: 0,
+		points: 0,
+		xMin: 0,
+		yMin: 0,
+		xMax: 0,
+		yMax: 0
+	};
+}
+var ON_CURVE = 1;
+var X_SHORT = 2;
+var Y_SHORT = 4;
+var REPEAT = 8;
+var X_SAME_OR_POSITIVE = 16;
+var Y_SAME_OR_POSITIVE = 32;
+/**
+* A simple glyph as `glyf` stores it: the contours' last points, no
+* instructions, then flags and coordinate deltas packed as small as they go.
+*/
+function encodeGlyph(contours) {
+	const points = contours.flat();
+	if (points.length === 0) return emptyGlyph();
+	const xs = points.map((p) => p.x);
+	const ys = points.map((p) => p.y);
+	const box = {
+		xMin: Math.min(...xs),
+		yMin: Math.min(...ys),
+		xMax: Math.max(...xs),
+		yMax: Math.max(...ys)
+	};
+	const flags = [];
+	const xBytes = [];
+	const yBytes = [];
+	let px = 0;
+	let py = 0;
+	const delta = (d, short, same, bytes) => {
+		if (d === 0) return same;
+		if (Math.abs(d) <= 255) {
+			bytes.push(Math.abs(d));
+			return short | (d > 0 ? same : 0);
+		}
+		bytes.push(d >> 8 & 255, d & 255);
+		return 0;
+	};
+	for (const p of points) {
+		let flag = p.on ? ON_CURVE : 0;
+		flag |= delta(p.x - px, X_SHORT, X_SAME_OR_POSITIVE, xBytes);
+		flag |= delta(p.y - py, Y_SHORT, Y_SAME_OR_POSITIVE, yBytes);
+		flags.push(flag);
+		px = p.x;
+		py = p.y;
+	}
+	const packed = [];
+	for (let i = 0; i < flags.length;) {
+		let run = 1;
+		while (i + run < flags.length && flags[i + run] === flags[i] && run < 256) run++;
+		if (run > 1) packed.push(flags[i] | REPEAT, run - 1);
+		else packed.push(flags[i]);
+		i += run;
+	}
+	const size = 10 + contours.length * 2 + 2 + packed.length + xBytes.length + yBytes.length;
+	const out = new Writer(size + (4 - size % 4) % 4);
+	out.i16(contours.length);
+	out.i16(box.xMin);
+	out.i16(box.yMin);
+	out.i16(box.xMax);
+	out.i16(box.yMax);
+	let end = -1;
+	for (const contour of contours) {
+		end += contour.length;
+		out.u16(end);
+	}
+	out.u16(0);
+	out.bytes(packed);
+	out.bytes(xBytes);
+	out.bytes(yBytes);
+	return {
+		bytes: out.data,
+		contours: contours.length,
+		points: points.length,
+		...box
+	};
+}
+/**
+* `cmap`: the BMP through format 4, under both Unicode encodings a reader looks
+* for, and — where the face reaches past it — every character through format 12.
+*/
+function cmapTable(glyphs) {
+	const pairs = [];
+	glyphs.forEach((g, i) => {
+		for (const cp of g.codePoints) pairs.push([cp, i + 1]);
+	});
+	pairs.sort((a, b) => a[0] - b[0]);
+	const unique = pairs.filter((p, i) => i === 0 || p[0] !== pairs[i - 1][0]);
+	const format4 = cmapFormat4(unique.filter(([cp]) => cp <= 65535 && (cp < 55296 || cp > 57343)));
+	const wide = unique.some(([cp]) => cp > 65535) ? cmapFormat12(unique) : void 0;
+	const records = [
+		[
+			0,
+			3,
+			"bmp"
+		],
+		...wide ? [[
+			0,
+			4,
+			"wide"
+		]] : [],
+		[
+			3,
+			1,
+			"bmp"
+		],
+		...wide ? [[
+			3,
+			10,
+			"wide"
+		]] : []
+	];
+	const headerSize = 4 + records.length * 8;
+	const out = new Writer(headerSize + format4.length + (wide?.length ?? 0));
+	out.u16(0);
+	out.u16(records.length);
+	for (const [platform, encoding, which] of records) {
+		out.u16(platform);
+		out.u16(encoding);
+		out.u32(which === "bmp" ? headerSize : headerSize + format4.length);
+	}
+	out.bytes(format4);
+	if (wide) out.bytes(wide);
+	return out.data;
+}
+/** Format 4: segments of consecutive characters on consecutive glyphs. */
+function cmapFormat4(pairs) {
+	const segments = [];
+	for (const [cp, gid] of pairs) {
+		const last = segments[segments.length - 1];
+		if (last && cp === last.end + 1 && gid === last.gid + (cp - last.start)) last.end = cp;
+		else segments.push({
+			start: cp,
+			end: cp,
+			gid
+		});
+	}
+	if (segments[segments.length - 1]?.end !== 65535) segments.push({
+		start: 65535,
+		end: 65535,
+		gid: 0
+	});
+	const count = segments.length;
+	const entrySelector = Math.floor(Math.log2(count));
+	const searchRange = 2 * 2 ** entrySelector;
+	const length = 16 + count * 8;
+	const out = new Writer(length);
+	out.u16(4);
+	out.u16(length);
+	out.u16(0);
+	out.u16(count * 2);
+	out.u16(searchRange);
+	out.u16(entrySelector);
+	out.u16(count * 2 - searchRange);
+	for (const s of segments) out.u16(s.end);
+	out.u16(0);
+	for (const s of segments) out.u16(s.start);
+	for (const s of segments) out.u16(s.gid === 0 ? 1 : s.gid - s.start & 65535);
+	for (let i = 0; i < count; i++) out.u16(0);
+	return out.data;
+}
+/** Format 12: groups of consecutive characters on consecutive glyphs. */
+function cmapFormat12(pairs) {
+	const groups = [];
+	for (const [cp, gid] of pairs) {
+		if (cp >= 55296 && cp <= 57343) continue;
+		const last = groups[groups.length - 1];
+		if (last && cp === last.end + 1 && gid === last.gid + (cp - last.start)) last.end = cp;
+		else groups.push({
+			start: cp,
+			end: cp,
+			gid
+		});
+	}
+	const length = 16 + groups.length * 12;
+	const out = new Writer(length);
+	out.u16(12);
+	out.u16(0);
+	out.u32(length);
+	out.u32(0);
+	out.u32(groups.length);
+	for (const g of groups) {
+		out.u32(g.start);
+		out.u32(g.end);
+		out.u32(g.gid);
+	}
+	return out.data;
+}
+/** `head` — version 1.0, a thousand units to the em, long `loca` offsets. */
+function headTable(face, bounds) {
+	const out = new Writer(54);
+	out.u32(65536);
+	out.u32(65536);
+	out.u32(0);
+	out.u32(1594834165);
+	out.u16(11);
+	out.u16(UPEM);
+	out.u32(0);
+	out.u32(0);
+	out.u32(0);
+	out.u32(0);
+	out.i16(bounds.xMin);
+	out.i16(bounds.yMin);
+	out.i16(bounds.xMax);
+	out.i16(bounds.yMax);
+	out.u16((face.bold ? 1 : 0) | (face.italic ? 2 : 0));
+	out.u16(8);
+	out.i16(2);
+	out.i16(1);
+	out.i16(0);
+	return out.data;
+}
+/** `hhea` — the horizontal header, one metric per glyph. */
+function hheaTable(face, glyphs, advances, metrics) {
+	const inked = glyphs.map((g, i) => ({
+		g,
+		advance: advances[i]
+	})).filter((e) => e.g.contours > 0);
+	const slope = slopeOf(face.italicAngle ?? 0);
+	const out = new Writer(36);
+	out.u32(65536);
+	out.i16(metrics.ascent);
+	out.i16(metrics.descent);
+	out.i16(0);
+	out.u16(Math.max(0, ...advances));
+	out.i16(Math.min(0, ...inked.map((e) => e.g.xMin)));
+	out.i16(Math.min(0, ...inked.map((e) => e.advance - e.g.xMax)));
+	out.i16(Math.max(0, ...inked.map((e) => e.g.xMax)));
+	out.i16(slope.rise);
+	out.i16(slope.run);
+	out.i16(0);
+	for (let i = 0; i < 4; i++) out.i16(0);
+	out.i16(0);
+	out.u16(glyphs.length);
+	return out.data;
+}
+/** The caret's slope for a face slanted by `angle` degrees. */
+function slopeOf(angle) {
+	if (!Number.isFinite(angle) || angle === 0) return {
+		rise: 1,
+		run: 0
+	};
+	return {
+		rise: UPEM,
+		run: Math.round(-Math.tan(angle * Math.PI / 180) * UPEM)
+	};
+}
+function hmtxTable(glyphs, advances) {
+	const out = new Writer(glyphs.length * 4);
+	glyphs.forEach((g, i) => {
+		out.u16(advances[i]);
+		out.i16(g.contours > 0 ? g.xMin : 0);
+	});
+	return out.data;
+}
+function locaTable(glyphs) {
+	const out = new Writer((glyphs.length + 1) * 4);
+	let at = 0;
+	for (const g of glyphs) {
+		out.u32(at);
+		at += g.bytes.length;
+	}
+	out.u32(at);
+	return out.data;
+}
+/** Each character's glyph — the first that carries it — by code point. */
+function glyphsByCharacter(face) {
+	const glyphOf = /* @__PURE__ */ new Map();
+	face.glyphs.forEach((g, i) => {
+		for (const cp of g.codePoints) if (!glyphOf.has(cp)) glyphOf.set(cp, i + 1);
+	});
+	return glyphOf;
+}
+/**
+* The ligatures a substitution can reach: two characters or more, every one of
+* them a glyph of the face — a ligature of a letter the face does not carry
+* joins nothing a reader lays out in it — and each run of characters once.
+*/
+function reachableLigatures(face) {
+	const glyphOf = glyphsByCharacter(face);
+	const seen = /* @__PURE__ */ new Set();
+	return (face.ligatures ?? []).filter((ligature) => {
+		const key = ligature.codePoints.join(",");
+		if (ligature.codePoints.length < 2 || seen.has(key)) return false;
+		seen.add(key);
+		return ligature.codePoints.every((cp) => glyphOf.has(cp));
+	});
+}
+/**
+* GSUB 1.0 with one feature, `liga`, under the default script and Latin: one
+* ligature-substitution lookup (type 4, format 1) joining each run of
+* character glyphs into the glyph the page drew for it — the longest run
+* first, so "ffi" is tried before "ff".
+*
+* @param face      The face, for its character glyphs.
+* @param ligatures Its reachable ligatures, glyph `face.glyphs.length + 1` on.
+* @returns The table to add, or none where the face draws no ligature.
+*/
+function ligatureTable(face, ligatures) {
+	if (ligatures.length === 0) return [];
+	const glyphOf = glyphsByCharacter(face);
+	const byFirst = /* @__PURE__ */ new Map();
+	ligatures.forEach((ligature, i) => {
+		const [first, ...rest] = ligature.codePoints.map((cp) => glyphOf.get(cp));
+		const entry = {
+			glyph: face.glyphs.length + 1 + i,
+			rest
+		};
+		byFirst.set(first, [...byFirst.get(first) ?? [], entry]);
+	});
+	const firsts = [...byFirst.keys()].sort((a, b) => a - b);
+	const sets = firsts.map((first) => [...byFirst.get(first)].sort((a, b) => b.rest.length - a.rest.length || a.rest.join(",").localeCompare(b.rest.join(","))));
+	const substHeader = 6 + firsts.length * 2;
+	const coverageSize = 4 + firsts.length * 2;
+	const setSize = (set) => 2 + set.length * 2 + set.reduce((n, lig) => n + 4 + lig.rest.length * 2, 0);
+	const SUBST_AT = 62;
+	const out = new Writer(SUBST_AT + substHeader + coverageSize + sets.reduce((n, set) => n + setSize(set), 0));
+	out.u16(1);
+	out.u16(0);
+	out.u16(10);
+	out.u16(36);
+	out.u16(50);
+	out.u16(2);
+	for (const tag of ["DFLT", "latn"]) {
+		out.bytes([...tag].map((c) => c.charCodeAt(0)));
+		out.u16(14);
+	}
+	out.u16(4);
+	out.u16(0);
+	out.u16(0);
+	out.u16(65535);
+	out.u16(1);
+	out.u16(0);
+	out.u16(1);
+	out.bytes([..."liga"].map((c) => c.charCodeAt(0)));
+	out.u16(8);
+	out.u16(0);
+	out.u16(1);
+	out.u16(0);
+	out.u16(1);
+	out.u16(4);
+	out.u16(4);
+	out.u16(0);
+	out.u16(1);
+	out.u16(SUBST_AT - 54);
+	out.u16(1);
+	out.u16(substHeader);
+	out.u16(firsts.length);
+	let at = substHeader + coverageSize;
+	for (const set of sets) {
+		out.u16(at);
+		at += setSize(set);
+	}
+	out.u16(1);
+	out.u16(firsts.length);
+	for (const first of firsts) out.u16(first);
+	for (const set of sets) {
+		out.u16(set.length);
+		let lig = 2 + set.length * 2;
+		for (const entry of set) {
+			out.u16(lig);
+			lig += 4 + entry.rest.length * 2;
+		}
+		for (const entry of set) {
+			out.u16(entry.glyph);
+			out.u16(entry.rest.length + 1);
+			for (const g of entry.rest) out.u16(g);
+		}
+	}
+	return [["GSUB", out.data]];
+}
+/**
+* The face's kerning pairs by glyph — the first glyph of each character — in
+* the order a binary search expects them, less those of glyphs it does not
+* hold and those that move nothing.
+*/
+function glyphPairs(face) {
+	const glyphOf = glyphsByCharacter(face);
+	const byGlyphs = /* @__PURE__ */ new Map();
+	for (const pair of face.kerning ?? []) {
+		const left = glyphOf.get(pair.left);
+		const right = glyphOf.get(pair.right);
+		const value = Math.round(pair.value);
+		if (left === void 0 || right === void 0 || value === 0) continue;
+		const key = left * 65536 + right;
+		if (!byGlyphs.has(key)) byGlyphs.set(key, [
+			left,
+			right,
+			clamp(value, -32768, 32767)
+		]);
+	}
+	return [...byGlyphs.entries()].sort((a, b) => a[0] - b[0]).slice(0, MAX_KERN_PAIRS).map(([, pair]) => pair);
+}
+/**
+* The face's kerning, twice over: GPOS's `kern` feature, which is what a
+* shaper reads — Word's own, DirectWrite, HarfBuzz — and the legacy `kern`
+* table, for what reads nothing else. Word kerned the page's pairs from the
+* legacy table alone not at all: both are written, and a shaper that finds
+* GPOS leaves the other be.
+*
+* @returns The tables to add, or none where the face is kerned by no pair
+*          whose glyphs it holds.
+*/
+function kerningTables(face) {
+	const pairs = glyphPairs(face);
+	if (pairs.length === 0) return [];
+	return [["GPOS", gposTable(pairs)], ["kern", kernTable(pairs)]];
+}
+/** `kern` version 0 with one horizontal format 0 subtable. */
+function kernTable(pairs) {
+	const entrySelector = Math.floor(Math.log2(pairs.length));
+	const searchRange = 2 ** entrySelector * 6;
+	const length = 14 + pairs.length * 6;
+	const out = new Writer(4 + length);
+	out.u16(0);
+	out.u16(1);
+	out.u16(0);
+	out.u16(length);
+	out.u16(1);
+	out.u16(pairs.length);
+	out.u16(searchRange);
+	out.u16(entrySelector);
+	out.u16(pairs.length * 6 - searchRange);
+	for (const [left, right, value] of pairs) {
+		out.u16(left);
+		out.u16(right);
+		out.i16(value);
+	}
+	return out.data;
+}
+/**
+* GPOS 1.0 with one feature, `kern`, under the default script and Latin: one
+* pair-adjustment lookup (type 2, format 1) moving the first glyph's advance.
+*/
+function gposTable(pairs) {
+	const byLeft = /* @__PURE__ */ new Map();
+	for (const [left, right, value] of pairs) byLeft.set(left, [...byLeft.get(left) ?? [], [right, value]]);
+	const lefts = [...byLeft.keys()].sort((a, b) => a - b);
+	const pairPosHeader = 10 + lefts.length * 2;
+	const coverageSize = 4 + lefts.length * 2;
+	const pairSetsSize = lefts.reduce((n, left) => n + 2 + byLeft.get(left).length * 4, 0);
+	const PAIR_POS_AT = 62;
+	const out = new Writer(PAIR_POS_AT + pairPosHeader + coverageSize + pairSetsSize);
+	out.u16(1);
+	out.u16(0);
+	out.u16(10);
+	out.u16(36);
+	out.u16(50);
+	out.u16(2);
+	for (const tag of ["DFLT", "latn"]) {
+		out.bytes([...tag].map((c) => c.charCodeAt(0)));
+		out.u16(14);
+	}
+	out.u16(4);
+	out.u16(0);
+	out.u16(0);
+	out.u16(65535);
+	out.u16(1);
+	out.u16(0);
+	out.u16(1);
+	out.bytes([..."kern"].map((c) => c.charCodeAt(0)));
+	out.u16(8);
+	out.u16(0);
+	out.u16(1);
+	out.u16(0);
+	out.u16(1);
+	out.u16(4);
+	out.u16(2);
+	out.u16(0);
+	out.u16(1);
+	out.u16(PAIR_POS_AT - 54);
+	out.u16(1);
+	out.u16(pairPosHeader);
+	out.u16(4);
+	out.u16(0);
+	out.u16(lefts.length);
+	let at = pairPosHeader + coverageSize;
+	for (const left of lefts) {
+		out.u16(at);
+		at += 2 + byLeft.get(left).length * 4;
+	}
+	out.u16(1);
+	out.u16(lefts.length);
+	for (const left of lefts) out.u16(left);
+	for (const left of lefts) {
+		const set = [...byLeft.get(left)].sort((a, b) => a[0] - b[0]);
+		out.u16(set.length);
+		for (const [right, value] of set) {
+			out.u16(right);
+			out.i16(value);
+		}
+	}
+	return out.data;
+}
+/** `maxp` version 1.0: the most points and contours any glyph holds, and no hinting. */
+function maxpTable(glyphs) {
+	const out = new Writer(32);
+	out.u32(65536);
+	out.u16(glyphs.length);
+	out.u16(Math.max(0, ...glyphs.map((g) => g.points)));
+	out.u16(Math.max(0, ...glyphs.map((g) => g.contours)));
+	out.u16(0);
+	out.u16(0);
+	out.u16(2);
+	for (let i = 0; i < 8; i++) out.u16(0);
+	return out.data;
+}
+/** OS/2 version 4 — the metrics and the licence Windows reads. */
+function os2Table(face, glyphs, advances, metrics) {
+	const codePoints = face.glyphs.flatMap((g) => g.codePoints);
+	const inked = advances.filter((a, i) => a > 0 && (glyphs[i]?.contours ?? 0) > 0);
+	const average = inked.length > 0 ? inked.reduce((s, a) => s + a, 0) / inked.length : UPEM / 2;
+	const bmp = codePoints.filter((cp) => cp <= 65535);
+	const out = new Writer(96);
+	out.u16(4);
+	out.i16(Math.round(average));
+	out.u16(face.bold ? 700 : 400);
+	out.u16(5);
+	out.u16(face.fsType & 65535);
+	for (const v of [
+		650,
+		600,
+		0,
+		75,
+		650,
+		600,
+		0,
+		350
+	]) out.i16(v);
+	out.i16(50);
+	out.i16(Math.round((face.xHeight ?? 500) / 2));
+	out.i16(0);
+	out.bytes([
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	]);
+	const ranges = unicodeRanges(codePoints);
+	for (const r of ranges) out.u32(r);
+	out.bytes([
+		32,
+		32,
+		32,
+		32
+	]);
+	out.u16((face.italic ? 1 : 0) | (face.bold ? 32 : 0) | (!face.bold && !face.italic ? 64 : 0));
+	out.u16(bmp.length > 0 ? Math.min(...bmp) : 32);
+	out.u16(bmp.length > 0 ? Math.max(...bmp) : 32);
+	out.i16(metrics.ascent);
+	out.i16(metrics.descent);
+	out.i16(0);
+	out.u16(clamp(metrics.winAscent, 0, 65535));
+	out.u16(clamp(metrics.winDescent, 0, 65535));
+	const pages = codePages(codePoints);
+	out.u32(pages[0]);
+	out.u32(pages[1]);
+	out.i16(Math.round(face.xHeight ?? 500));
+	out.i16(Math.round(face.capHeight ?? 700));
+	out.u16(0);
+	out.u16(32);
+	out.u16(0);
+	return out.data;
+}
+/** OS/2 `ulUnicodeRange` bits for the blocks a face's characters fall in. */
+var UNICODE_RANGES = [
+	[
+		0,
+		0,
+		127
+	],
+	[
+		1,
+		128,
+		255
+	],
+	[
+		2,
+		256,
+		383
+	],
+	[
+		3,
+		384,
+		591
+	],
+	[
+		4,
+		592,
+		687
+	],
+	[
+		5,
+		688,
+		767
+	],
+	[
+		6,
+		768,
+		879
+	],
+	[
+		7,
+		880,
+		1023
+	],
+	[
+		9,
+		1024,
+		1327
+	],
+	[
+		10,
+		1328,
+		1423
+	],
+	[
+		11,
+		1424,
+		1535
+	],
+	[
+		13,
+		1536,
+		1791
+	],
+	[
+		24,
+		3584,
+		3711
+	],
+	[
+		29,
+		7680,
+		7935
+	],
+	[
+		30,
+		7936,
+		8191
+	],
+	[
+		31,
+		8192,
+		8303
+	],
+	[
+		32,
+		8304,
+		8351
+	],
+	[
+		33,
+		8352,
+		8399
+	],
+	[
+		35,
+		8448,
+		8527
+	],
+	[
+		36,
+		8528,
+		8591
+	],
+	[
+		37,
+		8592,
+		8703
+	],
+	[
+		38,
+		8704,
+		8959
+	],
+	[
+		39,
+		8960,
+		9215
+	],
+	[
+		43,
+		9472,
+		9599
+	],
+	[
+		44,
+		9600,
+		9631
+	],
+	[
+		45,
+		9632,
+		9727
+	],
+	[
+		46,
+		9728,
+		9983
+	],
+	[
+		47,
+		9984,
+		10175
+	],
+	[
+		48,
+		12288,
+		12351
+	],
+	[
+		49,
+		12352,
+		12447
+	],
+	[
+		50,
+		12448,
+		12543
+	],
+	[
+		56,
+		44032,
+		55215
+	],
+	[
+		59,
+		19968,
+		40959
+	],
+	[
+		60,
+		57344,
+		63743
+	],
+	[
+		62,
+		64256,
+		64335
+	],
+	[
+		68,
+		65280,
+		65519
+	]
+];
+function unicodeRanges(codePoints) {
+	const words = [
+		0,
+		0,
+		0,
+		0
+	];
+	const set = (bit) => {
+		words[bit >> 5] = (words[bit >> 5] | 1 << (bit & 31)) >>> 0;
+	};
+	for (const cp of codePoints) {
+		if (cp > 65535) set(57);
+		for (const [bit, from, to] of UNICODE_RANGES) if (cp >= from && cp <= to) set(bit);
+	}
+	return words;
+}
+/**
+* OS/2 `ulCodePageRange` — the Windows code pages a face's characters serve.
+* Latin 1 stands where nothing else does: a face that claims no code page at
+* all is one Windows may decline to use.
+*/
+function codePages(codePoints) {
+	let low = 0;
+	const has = (from, to) => codePoints.some((cp) => cp >= from && cp <= to);
+	if (has(32, 255)) low |= 1;
+	if (has(256, 383)) low |= 146;
+	if (has(1024, 1279)) low |= 4;
+	if (has(880, 1023)) low |= 8;
+	if (has(1424, 1535)) low |= 32;
+	if (has(1536, 1791)) low |= 64;
+	if (has(7840, 7929)) low |= 256;
+	if (has(3584, 3711)) low |= 65536;
+	if (has(12352, 12543)) low |= 1 << 17;
+	if (has(19968, 40959)) low |= 1310720;
+	if (has(44032, 55215)) low |= 1 << 19;
+	if (low === 0) low = 1;
+	return [low >>> 0, 0];
+}
+/** `name` — the family, style, full and PostScript names, in Windows' encoding. */
+function nameTable(face) {
+	const style = face.bold && face.italic ? "Bold Italic" : face.bold ? "Bold" : face.italic ? "Italic" : "Regular";
+	const family = face.family.trim() || "Embedded";
+	const postScript = face.postScriptName.replace(/[^!-~]|[[\](){}<>/%]/gu, "").slice(0, 63) || family.replace(/[^A-Za-z0-9-]/gu, "");
+	const full = style === "Regular" ? family : `${family} ${style}`;
+	const records = [
+		[1, family],
+		[2, style],
+		[3, `${postScript};${style}`],
+		[4, full],
+		[5, "Version 1.000"],
+		[6, postScript]
+	];
+	const strings = records.map(([, text]) => utf16be(text));
+	const storage = 6 + records.length * 12;
+	const out = new Writer(storage + strings.reduce((s, b) => s + b.length, 0));
+	out.u16(0);
+	out.u16(records.length);
+	out.u16(storage);
+	let offset = 0;
+	records.forEach(([id], i) => {
+		out.u16(3);
+		out.u16(1);
+		out.u16(1033);
+		out.u16(id);
+		out.u16(strings[i].length);
+		out.u16(offset);
+		offset += strings[i].length;
+	});
+	for (const s of strings) out.bytes(s);
+	return out.data;
+}
+/** `post` version 3.0: no glyph names, only the slant and the pitch. */
+function postTable(face) {
+	const out = new Writer(32);
+	out.u32(196608);
+	out.u32(Math.round((face.italicAngle ?? 0) * 65536) >>> 0);
+	out.i16(-100);
+	out.i16(50);
+	out.u32(face.fixedPitch === true ? 1 : 0);
+	for (let i = 0; i < 4; i++) out.u32(0);
+	return out.data;
+}
+/**
+* An sfnt from its tables: the directory sorted by tag, each table on a
+* four-byte boundary, and `head.checkSumAdjustment` set so the whole file sums
+* to the magic number.
+*/
+function assembleSfnt(tables) {
+	const sorted = [...tables].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+	const directory = 12 + sorted.length * 16;
+	const placed = [];
+	let cursor = directory;
+	for (const [tag, data] of sorted) {
+		placed.push({
+			tag,
+			data,
+			offset: cursor
+		});
+		cursor += data.length + (4 - data.length % 4) % 4;
+	}
+	const out = new Uint8Array(cursor);
+	const view = new DataView(out.buffer);
+	view.setUint32(0, 65536);
+	view.setUint16(4, sorted.length);
+	const geometry = directoryGeometry(sorted.length);
+	view.setUint16(6, geometry.searchRange);
+	view.setUint16(8, geometry.entrySelector);
+	view.setUint16(10, geometry.rangeShift);
+	placed.forEach((t, i) => {
+		const at = 12 + i * 16;
+		for (let k = 0; k < 4; k++) out[at + k] = t.tag.charCodeAt(k);
+		view.setUint32(at + 4, paddedChecksum(t.data));
+		view.setUint32(at + 8, t.offset);
+		view.setUint32(at + 12, t.data.length);
+		out.set(t.data, t.offset);
+	});
+	const head = placed.find((t) => t.tag === "head");
+	if (head) view.setUint32(head.offset + 8, 2981146554 - paddedChecksum(out) >>> 0);
+	return out;
+}
+/** Big-endian bytes, written in order into a buffer of known size. */
+var Writer = class {
+	data;
+	view;
+	at = 0;
+	constructor(size) {
+		this.data = new Uint8Array(size);
+		this.view = new DataView(this.data.buffer);
+	}
+	/** Write an unsigned 16-bit value. */
+	u16(v) {
+		this.view.setUint16(this.at, v & 65535);
+		this.at += 2;
+	}
+	/** Write a signed 16-bit value. */
+	i16(v) {
+		this.view.setInt16(this.at, clamp(Math.round(v), -32768, 32767));
+		this.at += 2;
+	}
+	/** Write an unsigned 32-bit value. */
+	u32(v) {
+		this.view.setUint32(this.at, v >>> 0);
+		this.at += 4;
+	}
+	/** Write raw bytes. */
+	bytes(values) {
+		for (let i = 0; i < values.length; i++) this.data[this.at + i] = values[i];
+		this.at += values.length;
+	}
+};
+function utf16be(text) {
+	const out = new Uint8Array(text.length * 2);
+	for (let i = 0; i < text.length; i++) {
+		out[i * 2] = text.charCodeAt(i) >> 8;
+		out[i * 2 + 1] = text.charCodeAt(i) & 255;
+	}
+	return out;
+}
+function concat(parts) {
+	const out = new Uint8Array(parts.reduce((s, p) => s + p.length, 0));
+	let at = 0;
+	for (const p of parts) {
+		out.set(p, at);
+		at += p.length;
+	}
+	return out;
+}
+function clamp(v, lo, hi) {
+	return Math.min(hi, Math.max(lo, v));
+}
+//#endregion
+export { MAX_BUILT_GLYPHS, buildTrueType, editableEmbedding };