reamkit 0.1.0-alpha.0

package/dist/esm/font/opentype-layout.d.ts

@@ -0,0 +1,21 @@
+export type LigatureMap = ReadonlyMap<string, number>;
+export type KerningMap = ReadonlyMap<string, number>;
+export interface ArabicJoiningForms {
+    readonly init: ReadonlyMap<number, number>;
+    readonly medi: ReadonlyMap<number, number>;
+    readonly fina: ReadonlyMap<number, number>;
+}
+export declare const EMPTY_JOINING_FORMS: ArabicJoiningForms;
+interface TableInfo {
+    readonly offset: number;
+    readonly length: number;
+}
+export declare function parseGsubLigatures(raw: Uint8Array, table: TableInfo | undefined): LigatureMap;
+export declare function parseGposKerning(raw: Uint8Array, table: TableInfo | undefined): KerningMap;
+export declare function parseGsubArabicForms(raw: Uint8Array, table: TableInfo | undefined): ArabicJoiningForms;
+export interface ShapedRun {
+    readonly gids: Array<number>;
+    readonly advances: Array<number>;
+}
+export declare function shapeText(text: string, glyphForCodepoint: (cp: number) => number, advanceWidths: ReadonlyArray<number>, ligatures: LigatureMap, kerning: KerningMap, joiningForms?: ArabicJoiningForms): ShapedRun;
+export {};

package/dist/esm/font/opentype-layout.js

@@ -0,0 +1,329 @@
+import { BigEndianReader } from "./binary-reader.js";
+import { assignArabicForms } from "./arabic-joining.js";
+//#region src/font/opentype-layout.ts
+var EMPTY_JOINING_FORMS = {
+	init: /* @__PURE__ */ new Map(),
+	medi: /* @__PURE__ */ new Map(),
+	fina: /* @__PURE__ */ new Map()
+};
+function parseGsubLigatures(raw, table) {
+	if (!table) return /* @__PURE__ */ new Map();
+	try {
+		const lookupOffsets = collectLookupOffsets(raw, table, ["liga", "clig"]);
+		const ligatures = /* @__PURE__ */ new Map();
+		for (const lookupOffset of lookupOffsets) readLookup(raw, lookupOffset, (lookupType, subtableOffset) => {
+			if (lookupType === 4) parseLigatureSubtable(raw, subtableOffset, ligatures);
+		});
+		return ligatures;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+function parseGposKerning(raw, table) {
+	if (!table) return /* @__PURE__ */ new Map();
+	try {
+		const lookupOffsets = collectLookupOffsets(raw, table, ["kern"]);
+		const kerning = /* @__PURE__ */ new Map();
+		for (const lookupOffset of lookupOffsets) readLookup(raw, lookupOffset, (lookupType, subtableOffset) => {
+			if (lookupType === 2) parsePairPosSubtable(raw, subtableOffset, kerning);
+		});
+		return kerning;
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+function parseGsubArabicForms(raw, table) {
+	if (!table) return EMPTY_JOINING_FORMS;
+	try {
+		const forFeature = (tag) => {
+			const map = /* @__PURE__ */ new Map();
+			for (const lookupOffset of collectLookupOffsets(raw, table, [tag])) readLookup(raw, lookupOffset, (lookupType, subtableOffset) => {
+				if (lookupType === 1) parseSingleSubstSubtable(raw, subtableOffset, map);
+			});
+			return map;
+		};
+		const forms = {
+			init: forFeature("init"),
+			medi: forFeature("medi"),
+			fina: forFeature("fina")
+		};
+		if (forms.init.size === 0 && forms.medi.size === 0 && forms.fina.size === 0) return EMPTY_JOINING_FORMS;
+		return forms;
+	} catch {
+		return EMPTY_JOINING_FORMS;
+	}
+}
+function parseSingleSubstSubtable(raw, subtableOffset, map) {
+	const r = new BigEndianReader(raw, subtableOffset);
+	const format = r.u16();
+	const coverage = readCoverage(raw, subtableOffset + r.u16());
+	if (format === 1) {
+		const raw16 = r.u16();
+		const delta = raw16 >= 32768 ? raw16 - 65536 : raw16;
+		for (const gid of coverage) map.set(gid, gid + delta & 65535);
+	} else if (format === 2) {
+		const count = r.u16();
+		for (let i = 0; i < count; i++) {
+			const sub = r.u16();
+			if (i < coverage.length) map.set(coverage[i], sub);
+		}
+	}
+}
+function collectLookupOffsets(raw, table, wantedFeatures) {
+	const base = table.offset;
+	const r = new BigEndianReader(raw, base);
+	r.u16();
+	r.u16();
+	r.u16();
+	const featureListOff = r.u16();
+	const lookupListOff = r.u16();
+	const featureListBase = base + featureListOff;
+	const featureWanted = /* @__PURE__ */ new Set();
+	{
+		const fr = new BigEndianReader(raw, featureListBase);
+		const featureCount = fr.u16();
+		for (let i = 0; i < featureCount; i++) {
+			const tag = fr.tag();
+			const featureOff = fr.u16();
+			if (wantedFeatures.includes(tag)) {
+				const fr2 = new BigEndianReader(raw, featureListBase + featureOff);
+				fr2.u16();
+				const lookupCount = fr2.u16();
+				for (let k = 0; k < lookupCount; k++) featureWanted.add(fr2.u16());
+			}
+		}
+	}
+	const lookupListBase = base + lookupListOff;
+	const lookupListReader = new BigEndianReader(raw, lookupListBase);
+	const lookupCount = lookupListReader.u16();
+	const lookupOffsets = [];
+	for (let i = 0; i < lookupCount; i++) {
+		const offset = lookupListReader.u16();
+		lookupOffsets.push(lookupListBase + offset);
+	}
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const idx of featureWanted) {
+		const off = lookupOffsets[idx];
+		if (off !== void 0 && !seen.has(off)) {
+			seen.add(off);
+			result.push(off);
+		}
+	}
+	return result;
+}
+function readLookup(raw, lookupOffset, visit) {
+	const r = new BigEndianReader(raw, lookupOffset);
+	const lookupType = r.u16();
+	r.u16();
+	const subTableCount = r.u16();
+	for (let i = 0; i < subTableCount; i++) visit(lookupType, lookupOffset + r.u16());
+}
+function parseLigatureSubtable(raw, subtableOffset, out) {
+	const r = new BigEndianReader(raw, subtableOffset);
+	if (r.u16() !== 1) return;
+	const coverageOff = r.u16();
+	const ligatureSetCount = r.u16();
+	const ligatureSetOffs = new Array(ligatureSetCount);
+	for (let i = 0; i < ligatureSetCount; i++) ligatureSetOffs[i] = r.u16();
+	const coverageGlyphs = readCoverage(raw, subtableOffset + coverageOff);
+	for (let i = 0; i < ligatureSetCount; i++) {
+		const firstGlyph = coverageGlyphs[i];
+		if (firstGlyph === void 0) continue;
+		parseLigatureSet(raw, subtableOffset + ligatureSetOffs[i], firstGlyph, out);
+	}
+}
+function parseLigatureSet(raw, setOffset, firstGlyph, out) {
+	const r = new BigEndianReader(raw, setOffset);
+	const ligatureCount = r.u16();
+	const ligOffsets = new Array(ligatureCount);
+	for (let i = 0; i < ligatureCount; i++) ligOffsets[i] = r.u16();
+	for (let i = 0; i < ligatureCount; i++) {
+		const r2 = new BigEndianReader(raw, setOffset + ligOffsets[i]);
+		const ligGlyph = r2.u16();
+		const componentCount = r2.u16();
+		const components = [firstGlyph];
+		for (let k = 1; k < componentCount; k++) components.push(r2.u16());
+		out.set(components.join(","), ligGlyph);
+	}
+}
+function parsePairPosSubtable(raw, subtableOffset, out) {
+	const posFormat = new BigEndianReader(raw, subtableOffset).u16();
+	if (posFormat === 1) parsePairPosFormat1(raw, subtableOffset, out);
+	else if (posFormat === 2) parsePairPosFormat2(raw, subtableOffset, out);
+}
+function parsePairPosFormat1(raw, subtableOffset, out) {
+	const r = new BigEndianReader(raw, subtableOffset);
+	r.u16();
+	const coverageOff = r.u16();
+	const valueFormat1 = r.u16();
+	const valueFormat2 = r.u16();
+	const pairSetCount = r.u16();
+	const pairSetOffs = new Array(pairSetCount);
+	for (let i = 0; i < pairSetCount; i++) pairSetOffs[i] = r.u16();
+	const value1Size = valueRecordSize(valueFormat1);
+	const value2Size = valueRecordSize(valueFormat2);
+	const coverage = readCoverage(raw, subtableOffset + coverageOff);
+	for (let i = 0; i < pairSetCount; i++) {
+		const first = coverage[i];
+		if (first === void 0) continue;
+		const psr = new BigEndianReader(raw, subtableOffset + pairSetOffs[i]);
+		const pairCount = psr.u16();
+		for (let j = 0; j < pairCount; j++) {
+			const second = psr.u16();
+			const v1 = readValueRecordAdvance(psr, valueFormat1);
+			psr.skip(value1Size - bytesRead(valueFormat1));
+			const v2 = readValueRecordAdvance(psr, valueFormat2);
+			psr.skip(value2Size - bytesRead(valueFormat2));
+			const adj = v1 !== 0 ? v1 : v2;
+			if (adj !== 0) out.set(`${first},${second}`, adj);
+		}
+	}
+}
+function parsePairPosFormat2(raw, subtableOffset, out) {
+	const r = new BigEndianReader(raw, subtableOffset);
+	r.u16();
+	const coverageOff = r.u16();
+	const valueFormat1 = r.u16();
+	const valueFormat2 = r.u16();
+	const classDef1Off = r.u16();
+	const classDef2Off = r.u16();
+	const class1Count = r.u16();
+	const class2Count = r.u16();
+	const value1Size = valueRecordSize(valueFormat1);
+	const value2Size = valueRecordSize(valueFormat2);
+	const pairRecordSize = value1Size + value2Size;
+	const coverage = readCoverage(raw, subtableOffset + coverageOff);
+	const class1 = readClassDef(raw, subtableOffset + classDef1Off);
+	const class2 = readClassDef(raw, subtableOffset + classDef2Off);
+	const recordsBase = r.offset;
+	for (let i = 0; i < class1Count; i++) for (let j = 0; j < class2Count; j++) {
+		const pr = new BigEndianReader(raw, recordsBase + (i * class2Count + j) * pairRecordSize);
+		const v1 = readValueRecordAdvance(pr, valueFormat1);
+		pr.skip(value1Size - bytesRead(valueFormat1));
+		const v2 = readValueRecordAdvance(pr, valueFormat2);
+		pr.skip(value2Size - bytesRead(valueFormat2));
+		const adj = v1 !== 0 ? v1 : v2;
+		if (adj === 0) continue;
+		const firsts = matchingGlyphs(coverage, class1, i);
+		const seconds = matchingGlyphs(void 0, class2, j);
+		for (const a of firsts) for (const b of seconds) out.set(`${a},${b}`, adj);
+	}
+}
+function valueRecordSize(valueFormat) {
+	let bits = valueFormat;
+	let count = 0;
+	while (bits) {
+		count += bits & 1;
+		bits >>>= 1;
+	}
+	return count * 2;
+}
+function readValueRecordAdvance(r, valueFormat) {
+	if (valueFormat & 1) r.i16();
+	if (valueFormat & 2) r.i16();
+	if (valueFormat & 4) return r.i16();
+	return 0;
+}
+function bytesRead(valueFormat) {
+	let n = 0;
+	if (valueFormat & 1) n += 2;
+	if (valueFormat & 2) n += 2;
+	if (valueFormat & 4) n += 2;
+	return n;
+}
+function readCoverage(raw, offset) {
+	const r = new BigEndianReader(raw, offset);
+	const format = r.u16();
+	if (format === 1) {
+		const glyphCount = r.u16();
+		const out = new Array(glyphCount);
+		for (let i = 0; i < glyphCount; i++) out[i] = r.u16();
+		return out;
+	}
+	if (format === 2) {
+		const rangeCount = r.u16();
+		const out = [];
+		for (let i = 0; i < rangeCount; i++) {
+			const startGlyph = r.u16();
+			const endGlyph = r.u16();
+			r.u16();
+			for (let g = startGlyph; g <= endGlyph; g++) out.push(g);
+		}
+		return out;
+	}
+	return [];
+}
+function readClassDef(raw, offset) {
+	const r = new BigEndianReader(raw, offset);
+	const format = r.u16();
+	const out = /* @__PURE__ */ new Map();
+	if (format === 1) {
+		const startGlyph = r.u16();
+		const glyphCount = r.u16();
+		for (let i = 0; i < glyphCount; i++) {
+			const cls = r.u16();
+			if (cls !== 0) out.set(startGlyph + i, cls);
+		}
+	} else if (format === 2) {
+		const classRangeCount = r.u16();
+		for (let i = 0; i < classRangeCount; i++) {
+			const startGlyph = r.u16();
+			const endGlyph = r.u16();
+			const cls = r.u16();
+			if (cls !== 0) for (let g = startGlyph; g <= endGlyph; g++) out.set(g, cls);
+		}
+	}
+	return out;
+}
+function matchingGlyphs(coverage, classMap, cls) {
+	if (coverage) {
+		const out = [];
+		for (const g of coverage) if ((classMap.get(g) ?? 0) === cls) out.push(g);
+		return out;
+	}
+	const out = [];
+	for (const [gid, c] of classMap) if (c === cls) out.push(gid);
+	return out;
+}
+function shapeText(text, glyphForCodepoint, advanceWidths, ligatures, kerning, joiningForms = EMPTY_JOINING_FORMS) {
+	const cps = [];
+	for (const ch of text) cps.push(ch.codePointAt(0));
+	const initialGids = cps.map(glyphForCodepoint);
+	if (joiningForms.init.size + joiningForms.medi.size + joiningForms.fina.size > 0) {
+		const forms = assignArabicForms(cps);
+		for (let k = 0; k < initialGids.length; k++) {
+			const sub = (forms[k] === "init" ? joiningForms.init : forms[k] === "medi" ? joiningForms.medi : forms[k] === "fina" ? joiningForms.fina : void 0)?.get(initialGids[k]);
+			if (sub !== void 0) initialGids[k] = sub;
+		}
+	}
+	const ligated = [];
+	let i = 0;
+	while (i < initialGids.length) {
+		let bestLen = 1;
+		let bestOut = initialGids[i];
+		const maxTry = Math.min(4, initialGids.length - i);
+		for (let len = 2; len <= maxTry; len++) {
+			const key = initialGids.slice(i, i + len).join(",");
+			const out = ligatures.get(key);
+			if (out !== void 0 && len > bestLen) {
+				bestLen = len;
+				bestOut = out;
+			}
+		}
+		ligated.push(bestOut);
+		i += bestLen;
+	}
+	const advances = new Array(ligated.length);
+	for (let j = 0; j < ligated.length; j++) advances[j] = advanceWidths[ligated[j]] ?? 0;
+	for (let j = 1; j < ligated.length; j++) {
+		const adj = kerning.get(`${ligated[j - 1]},${ligated[j]}`);
+		if (adj !== void 0 && adj !== 0) advances[j - 1] += adj;
+	}
+	return {
+		gids: ligated,
+		advances
+	};
+}
+//#endregion
+export { parseGposKerning, parseGsubArabicForms, parseGsubLigatures, shapeText };

package/dist/esm/font/ttf-parser.d.ts

@@ -0,0 +1,29 @@
+import { ArabicJoiningForms, KerningMap, LigatureMap } from './opentype-layout.js';
+export interface TtfTableInfo {
+    readonly offset: number;
+    readonly length: number;
+}
+export interface ParsedTtf {
+    readonly raw: Uint8Array;
+    readonly sfntVersion: number;
+    readonly tables: ReadonlyMap<string, TtfTableInfo>;
+    readonly postScriptName: string;
+    readonly unitsPerEm: number;
+    readonly fontBBox: readonly [number, number, number, number];
+    readonly ascender: number;
+    readonly descender: number;
+    readonly capHeight: number;
+    readonly xHeight: number;
+    readonly italicAngle: number;
+    readonly stemV: number;
+    readonly flags: number;
+    readonly numGlyphs: number;
+    readonly indexToLocFormat: 0 | 1;
+    readonly glyphOffsets: ReadonlyArray<number>;
+    readonly advanceWidths: ReadonlyArray<number>;
+    readonly glyphForCodepoint: (cp: number) => number;
+    readonly ligatures: LigatureMap;
+    readonly kerning: KerningMap;
+    readonly joiningForms: ArabicJoiningForms;
+}
+export declare function parseTtf(raw: Uint8Array): ParsedTtf;

package/dist/esm/font/ttf-parser.js

@@ -0,0 +1,290 @@
+import { BigEndianReader } from "./binary-reader.js";
+import { parseGposKerning, parseGsubArabicForms, parseGsubLigatures } from "./opentype-layout.js";
+//#region src/font/ttf-parser.ts
+var SFNT_TRUETYPE = 65536;
+var SFNT_OPENTYPE_CFF = 1330926671;
+function parseTtf(raw) {
+	const r = new BigEndianReader(raw);
+	const sfntVersion = r.u32();
+	if (sfntVersion !== SFNT_TRUETYPE && sfntVersion !== SFNT_OPENTYPE_CFF) throw new Error(`Not a TrueType or OpenType font (sfntVersion=0x${sfntVersion.toString(16).padStart(8, "0")})`);
+	const numTables = r.u16();
+	r.skip(6);
+	const tables = /* @__PURE__ */ new Map();
+	for (let i = 0; i < numTables; i++) {
+		const tag = r.tag();
+		r.u32();
+		const offset = r.u32();
+		const length = r.u32();
+		tables.set(tag, {
+			offset,
+			length
+		});
+	}
+	const require = (tag) => {
+		const t = tables.get(tag);
+		if (!t) throw new Error(`TTF missing required table: ${tag}`);
+		return t;
+	};
+	const head = require("head");
+	r.seek(head.offset + 18);
+	const unitsPerEm = r.u16();
+	r.skip(16);
+	const xMin = r.i16();
+	const yMin = r.i16();
+	const xMax = r.i16();
+	const yMax = r.i16();
+	r.skip(6);
+	const indexToLocFormatRaw = r.i16();
+	if (indexToLocFormatRaw !== 0 && indexToLocFormatRaw !== 1) throw new Error(`Invalid head.indexToLocFormat: ${indexToLocFormatRaw}`);
+	const indexToLocFormat = indexToLocFormatRaw;
+	const hhea = require("hhea");
+	r.seek(hhea.offset + 4);
+	const ascender = r.i16();
+	const descender = r.i16();
+	r.skip(2);
+	r.skip(24);
+	const numberOfHMetrics = r.u16();
+	const maxp = require("maxp");
+	r.seek(maxp.offset + 4);
+	const numGlyphs = r.u16();
+	const hmtx = require("hmtx");
+	r.seek(hmtx.offset);
+	const advanceWidths = new Array(numGlyphs);
+	let lastAdvance = 0;
+	const longCount = Math.min(numberOfHMetrics, numGlyphs);
+	for (let i = 0; i < longCount; i++) {
+		lastAdvance = r.u16();
+		r.skip(2);
+		advanceWidths[i] = lastAdvance;
+	}
+	for (let i = longCount; i < numGlyphs; i++) advanceWidths[i] = lastAdvance;
+	const glyphForCodepoint = buildCmap(raw, require("cmap").offset);
+	const postScriptName = readPostScriptName(raw, require("name").offset);
+	let italicAngle = 0;
+	let isFixedPitch = false;
+	const post = tables.get("post");
+	if (post) {
+		r.seek(post.offset);
+		r.skip(4);
+		italicAngle = r.i32() / 65536;
+		r.skip(4);
+		isFixedPitch = r.u32() !== 0;
+	}
+	let capHeight = 0;
+	let xHeight = 0;
+	let isItalic = false;
+	let usWeightClass = 400;
+	const os2 = tables.get("OS/2");
+	if (os2) {
+		r.seek(os2.offset);
+		const os2Version = r.u16();
+		r.skip(2);
+		usWeightClass = r.u16();
+		r.seek(os2.offset + 62);
+		isItalic = (r.u16() & 1) !== 0;
+		if (os2Version >= 2 && os2.length >= 90) {
+			r.seek(os2.offset + 86);
+			xHeight = r.i16();
+			capHeight = r.i16();
+		}
+	}
+	if (capHeight === 0) capHeight = Math.round(ascender * .7);
+	if (xHeight === 0) xHeight = Math.round(ascender * .5);
+	let flags = 0;
+	if (isFixedPitch) flags |= 1;
+	flags |= 32;
+	if (isItalic || italicAngle !== 0) flags |= 64;
+	const stemV = usWeightClass > 500 ? 120 : 80;
+	const glyphOffsets = readGlyphOffsets(raw, tables, numGlyphs, indexToLocFormat);
+	const ligatures = parseGsubLigatures(raw, tables.get("GSUB"));
+	const kerning = parseGposKerning(raw, tables.get("GPOS"));
+	const joiningForms = parseGsubArabicForms(raw, tables.get("GSUB"));
+	return {
+		raw,
+		sfntVersion,
+		tables,
+		postScriptName,
+		unitsPerEm,
+		fontBBox: [
+			xMin,
+			yMin,
+			xMax,
+			yMax
+		],
+		ascender,
+		descender,
+		capHeight,
+		xHeight,
+		italicAngle,
+		stemV,
+		flags,
+		numGlyphs,
+		indexToLocFormat,
+		glyphOffsets,
+		advanceWidths,
+		glyphForCodepoint,
+		ligatures,
+		kerning,
+		joiningForms
+	};
+}
+function readGlyphOffsets(raw, tables, numGlyphs, indexToLocFormat) {
+	const loca = tables.get("loca");
+	if (!loca) return [];
+	const r = new BigEndianReader(raw, loca.offset);
+	const out = new Array(numGlyphs + 1);
+	if (indexToLocFormat === 0) for (let i = 0; i <= numGlyphs; i++) out[i] = r.u16() * 2;
+	else for (let i = 0; i <= numGlyphs; i++) out[i] = r.u32();
+	return out;
+}
+function buildCmap(raw, cmapOffset) {
+	const r = new BigEndianReader(raw, cmapOffset);
+	r.u16();
+	const numTables = r.u16();
+	const subtables = [];
+	for (let i = 0; i < numTables; i++) {
+		const platform = r.u16();
+		const encoding = r.u16();
+		const absoluteOffset = cmapOffset + r.u32();
+		const format = new BigEndianReader(raw, absoluteOffset).u16();
+		subtables.push({
+			platform,
+			encoding,
+			absoluteOffset,
+			format
+		});
+	}
+	const priorities = [
+		{
+			platform: 3,
+			encoding: 10
+		},
+		{
+			platform: 0,
+			encoding: 4
+		},
+		{
+			platform: 0,
+			encoding: 6
+		},
+		{
+			platform: 3,
+			encoding: 1
+		},
+		{
+			platform: 0,
+			encoding: 3
+		},
+		{
+			platform: 0,
+			encoding: 1
+		},
+		{
+			platform: 0,
+			encoding: 0
+		}
+	];
+	let chosen;
+	for (const want of priorities) {
+		chosen = subtables.find((s) => s.platform === want.platform && s.encoding === want.encoding);
+		if (chosen) break;
+	}
+	if (!chosen) chosen = subtables[0];
+	if (!chosen) return () => 0;
+	if (chosen.format === 4) return buildCmapFormat4(raw, chosen.absoluteOffset);
+	if (chosen.format === 12) return buildCmapFormat12(raw, chosen.absoluteOffset);
+	throw new Error(`Unsupported cmap subtable format: ${chosen.format}`);
+}
+function buildCmapFormat4(raw, offset) {
+	const r = new BigEndianReader(raw, offset);
+	r.u16();
+	r.u16();
+	r.u16();
+	const segCount = r.u16() >> 1;
+	r.skip(6);
+	const endCode = new Uint16Array(segCount);
+	for (let i = 0; i < segCount; i++) endCode[i] = r.u16();
+	r.u16();
+	const startCode = new Uint16Array(segCount);
+	for (let i = 0; i < segCount; i++) startCode[i] = r.u16();
+	const idDelta = new Int16Array(segCount);
+	for (let i = 0; i < segCount; i++) idDelta[i] = r.i16();
+	const idRangeOffsetPos = r.offset;
+	const idRangeOffset = new Uint16Array(segCount);
+	for (let i = 0; i < segCount; i++) idRangeOffset[i] = r.u16();
+	return (cp) => {
+		if (cp > 65535) return 0;
+		let seg = -1;
+		for (let i = 0; i < segCount; i++) if (endCode[i] >= cp) {
+			seg = i;
+			break;
+		}
+		if (seg < 0) return 0;
+		if (startCode[seg] > cp) return 0;
+		if (idRangeOffset[seg] === 0) return cp + idDelta[seg] & 65535;
+		const glyphId = new BigEndianReader(raw, idRangeOffsetPos + seg * 2 + idRangeOffset[seg] + (cp - startCode[seg]) * 2).u16();
+		if (glyphId === 0) return 0;
+		return glyphId + idDelta[seg] & 65535;
+	};
+}
+function buildCmapFormat12(raw, offset) {
+	const r = new BigEndianReader(raw, offset);
+	r.u16();
+	r.u16();
+	r.u32();
+	r.u32();
+	const numGroups = r.u32();
+	const starts = new Uint32Array(numGroups);
+	const ends = new Uint32Array(numGroups);
+	const startGids = new Uint32Array(numGroups);
+	for (let i = 0; i < numGroups; i++) {
+		starts[i] = r.u32();
+		ends[i] = r.u32();
+		startGids[i] = r.u32();
+	}
+	return (cp) => {
+		let lo = 0;
+		let hi = numGroups - 1;
+		while (lo <= hi) {
+			const mid = lo + hi >>> 1;
+			if (cp < starts[mid]) hi = mid - 1;
+			else if (cp > ends[mid]) lo = mid + 1;
+			else return startGids[mid] + (cp - starts[mid]);
+		}
+		return 0;
+	};
+}
+function readPostScriptName(raw, offset) {
+	const r = new BigEndianReader(raw, offset);
+	r.u16();
+	const count = r.u16();
+	const stringsBase = offset + r.u16();
+	const records = [];
+	for (let i = 0; i < count; i++) records.push({
+		platform: r.u16(),
+		encoding: r.u16(),
+		language: r.u16(),
+		nameId: r.u16(),
+		length: r.u16(),
+		stringOffset: r.u16()
+	});
+	const filters = [
+		(rec) => rec.platform === 3 && rec.encoding === 1 && rec.language === 1033,
+		(rec) => rec.platform === 3 && rec.encoding === 1,
+		(rec) => rec.platform === 1 && rec.encoding === 0 && rec.language === 0,
+		(rec) => rec.platform === 0,
+		() => true
+	];
+	for (const filter of filters) {
+		const rec = records.find((x) => x.nameId === 6 && filter(x));
+		if (rec) return decodeNameRecord(raw, stringsBase + rec.stringOffset, rec.length, rec.platform);
+	}
+	throw new Error("TTF name table missing PostScript name (nameID 6)");
+}
+function decodeNameRecord(raw, offset, length, platform) {
+	const bytes = raw.subarray(offset, offset + length);
+	if (platform === 1) return new TextDecoder("macintosh", { fatal: false }).decode(bytes);
+	return new TextDecoder("utf-16be", { fatal: false }).decode(bytes);
+}
+//#endregion
+export { parseTtf };

package/dist/esm/font/ttf-subset.d.ts

@@ -0,0 +1,3 @@
+import { ParsedTtf } from './ttf-parser.js';
+export declare function subsetTtf(parsed: ParsedTtf, usedGids: Iterable<number>): Uint8Array;
+export declare function glyphClosure(parsed: ParsedTtf, usedGids: Iterable<number>): Set<number>;