@stll/folio-core 0.32.2 → 0.33.1

package/dist/fonts/sfnt/subset.js

@@ -0,0 +1,350 @@
+import { SFNT_TABLE, SFNT_VERSION, fitsInView, readLocaOffsets, readSfntDirectory } from "./tables.js";
+import { Result, TaggedError, panic } from "better-result";
+//#region src/fonts/sfnt/subset.ts
+/**
+* TrueType (`glyf`) subsetting.
+*
+* The output is what a PDF CIDFontType2 needs and nothing else: glyph
+* outlines, metrics, and the hinting tables that go with them. `cmap`, `name`
+* and `post` are dropped, because a CIDFontType2 addresses glyphs by index
+* through its own CIDToGIDMap and never consults the font's own character
+* mapping.
+*
+* Determinism contract: `subsetTrueType(font, glyphIds)` is a pure function of
+* its arguments and produces byte-identical output across runs. Glyph ids are
+* iterated in ascending numeric order and tables are written in tag order, so
+* nothing depends on a Set's or Map's insertion order.
+*/
+var SubsetError = class extends TaggedError("SubsetError") {};
+const fail = (message) => Result.err(new SubsetError({ message }));
+/** .notdef is glyph 0 in every font and is always kept. */
+const NOTDEF_GLYPH_ID = 0;
+const HEAD = {
+	checkSumAdjustment: 8,
+	indexToLocFormat: 50,
+	size: 54
+};
+const HHEA = {
+	numberOfHMetrics: 34,
+	size: 36
+};
+const MAXP = {
+	numGlyphs: 4,
+	size: 6
+};
+/** One hmtx `longHorMetric`: advanceWidth (uint16) then lsb (int16). */
+const HMTX_METRIC_SIZE = 4;
+/** Glyph header: numberOfContours, then the four bounding-box int16s. */
+const GLYPH_HEADER_SIZE = 10;
+const COMPOSITE_CONTOUR_COUNT = -1;
+/** Flags of a composite glyph component record. */
+const COMPONENT_FLAG = {
+	arg1And2AreWords: 1,
+	weHaveAScale: 8,
+	moreComponents: 32,
+	weHaveAnXAndYScale: 64,
+	weHaveATwoByTwo: 128
+};
+/**
+* Short `loca` stores offsets halved in a uint16, so it can only address
+* 0x1FFFE bytes of `glyf`. Beyond that the long format is mandatory.
+*/
+const MAX_SHORT_LOCA_GLYF_LENGTH = 131070;
+/** `head.checkSumAdjustment` is this constant minus the whole-file checksum. */
+const CHECKSUM_ADJUSTMENT_MAGIC = 2981146554;
+const UINT32_MODULUS = 4294967296;
+/** Tables copied byte for byte when the source font has them. */
+const VERBATIM_TABLES = [
+	SFNT_TABLE.cvt,
+	SFNT_TABLE.fpgm,
+	SFNT_TABLE.prep
+];
+const alignUp = (value) => Math.ceil(value / 4) * 4;
+const readCompositeComponents = (view, start, end) => {
+	const glyphIndexOffsets = [];
+	const glyphIds = [];
+	let at = start + GLYPH_HEADER_SIZE;
+	for (;;) {
+		if (at + 4 > end || !fitsInView(view, at, 4)) return;
+		const flags = view.getUint16(at);
+		glyphIndexOffsets.push(at + 2);
+		glyphIds.push(view.getUint16(at + 2));
+		at += 4;
+		at += (flags & COMPONENT_FLAG.arg1And2AreWords) === 0 ? 2 : 4;
+		if ((flags & COMPONENT_FLAG.weHaveAScale) !== 0) at += 2;
+		else if ((flags & COMPONENT_FLAG.weHaveAnXAndYScale) !== 0) at += 4;
+		else if ((flags & COMPONENT_FLAG.weHaveATwoByTwo) !== 0) at += 8;
+		if (at > end) return;
+		if ((flags & COMPONENT_FLAG.moreComponents) === 0) return {
+			glyphIndexOffsets,
+			glyphIds
+		};
+	}
+};
+/** Byte range of one glyph inside `glyf`, or `undefined` for an empty glyph. */
+const glyphRange = ({ glyf, offsets }, glyphId) => {
+	const start = offsets[glyphId];
+	const end = offsets[glyphId + 1];
+	if (start === void 0 || end === void 0 || end <= start || end > glyf.length) return;
+	return {
+		start: glyf.offset + start,
+		end: glyf.offset + end
+	};
+};
+/**
+* The requested glyphs plus every glyph reachable through composite component
+* references, plus .notdef, sorted ascending.
+*/
+const closeOverComponents = (source, requested) => {
+	const selected = /* @__PURE__ */ new Set([NOTDEF_GLYPH_ID]);
+	const queue = [NOTDEF_GLYPH_ID];
+	for (const glyphId of [...requested].sort((left, right) => left - right)) {
+		if (!Number.isInteger(glyphId) || glyphId < 0 || glyphId >= source.numGlyphs) return fail(`glyph id ${glyphId} is outside 0..${source.numGlyphs - 1}`);
+		if (!selected.has(glyphId)) {
+			selected.add(glyphId);
+			queue.push(glyphId);
+		}
+	}
+	for (let glyphId = queue.pop(); glyphId !== void 0; glyphId = queue.pop()) {
+		const range = glyphRange(source, glyphId);
+		if (!range) continue;
+		if (range.end - range.start < GLYPH_HEADER_SIZE || !fitsInView(source.view, range.start, GLYPH_HEADER_SIZE)) return fail(`glyph ${glyphId} is shorter than its ${GLYPH_HEADER_SIZE}-byte header`);
+		if (source.view.getInt16(range.start) > COMPOSITE_CONTOUR_COUNT) continue;
+		const components = readCompositeComponents(source.view, range.start, range.end);
+		if (!components) return fail(`composite glyph ${glyphId} has a truncated component record`);
+		for (const component of components.glyphIds) {
+			if (component >= source.numGlyphs) return fail(`composite glyph ${glyphId} references glyph ${component}, which does not exist`);
+			if (!selected.has(component)) {
+				selected.add(component);
+				queue.push(component);
+			}
+		}
+	}
+	return Result.ok([...selected].sort((left, right) => left - right));
+};
+/**
+* Copies the selected glyphs into a new `glyf`, renumbering the component
+* glyph index of every composite record on the way. That uint16 sits directly
+* after each component's flags word, and leaving it pointing at an old id is
+* the classic way a subset renders as garbage.
+*/
+const buildGlyf = (source, glyphIds, glyphIdMap) => {
+	const parts = [];
+	const locaOffsets = [];
+	let total = 0;
+	for (const glyphId of glyphIds) {
+		locaOffsets.push(total);
+		const range = glyphRange(source, glyphId);
+		if (!range) continue;
+		const length = range.end - range.start;
+		const data = new Uint8Array(alignUp(length));
+		data.set(new Uint8Array(source.view.buffer, source.view.byteOffset + range.start, length));
+		if (source.view.getInt16(range.start) <= COMPOSITE_CONTOUR_COUNT) {
+			const components = readCompositeComponents(source.view, range.start, range.end);
+			if (!components) return fail(`composite glyph ${glyphId} has a truncated component record`);
+			const copied = new DataView(data.buffer);
+			for (const offset of components.glyphIndexOffsets) {
+				const oldComponent = source.view.getUint16(offset);
+				const newComponent = glyphIdMap.get(oldComponent);
+				if (newComponent === void 0) panic(`component glyph ${oldComponent} escaped the subset closure`);
+				copied.setUint16(offset - range.start, newComponent);
+			}
+		}
+		parts.push(data);
+		total += data.byteLength;
+	}
+	locaOffsets.push(total);
+	const glyf = new Uint8Array(total);
+	let at = 0;
+	for (const part of parts) {
+		glyf.set(part, at);
+		at += part.byteLength;
+	}
+	return Result.ok({
+		glyf,
+		locaOffsets
+	});
+};
+const buildLoca = (offsets, longFormat) => {
+	const entrySize = longFormat ? 4 : 2;
+	const loca = new Uint8Array(offsets.length * entrySize);
+	const view = new DataView(loca.buffer);
+	for (const [index, offset] of offsets.entries()) if (longFormat) view.setUint32(index * entrySize, offset);
+	else view.setUint16(index * entrySize, offset / 2);
+	return loca;
+};
+/**
+* Left side bearing of one glyph in the source font: from its longHorMetric
+* when it has one, else from the trailing int16 array. Returns 0 when the
+* table is too short, which is what a monospaced tail with no lsb array means.
+*/
+const sourceLeftSideBearing = ({ view, hmtx, numberOfHMetrics }, glyphId) => {
+	const at = glyphId < numberOfHMetrics ? hmtx.offset + glyphId * HMTX_METRIC_SIZE + 2 : hmtx.offset + numberOfHMetrics * HMTX_METRIC_SIZE + (glyphId - numberOfHMetrics) * 2;
+	if (at + 2 > hmtx.offset + hmtx.length || !fitsInView(view, at, 2)) return 0;
+	return view.getInt16(at);
+};
+/** Sums a table as big-endian uint32s, zero-padded, modulo 2^32. */
+const checksumOf = (bytes) => {
+	let sum = 0;
+	for (let at = 0; at < bytes.byteLength; at += 4) {
+		const word = (bytes[at] ?? 0) << 24 | (bytes[at + 1] ?? 0) << 16 | (bytes[at + 2] ?? 0) << 8 | (bytes[at + 3] ?? 0);
+		sum = (sum + (word >>> 0)) % UINT32_MODULUS;
+	}
+	return sum >>> 0;
+};
+const searchParametersFor = (numTables) => {
+	let entrySelector = 0;
+	while (1 << entrySelector + 1 <= numTables) entrySelector += 1;
+	const searchRange = (1 << entrySelector) * 16;
+	return {
+		searchRange,
+		entrySelector,
+		rangeShift: numTables * 16 - searchRange
+	};
+};
+/**
+* Writes the sfnt and stamps `head.checkSumAdjustment`: the field is zero
+* while the file checksum is taken, then set to the magic constant minus that
+* sum, so a validator summing the finished file lands on the magic.
+*/
+const assembleSfnt = (tables) => {
+	const sorted = [...tables].sort((left, right) => left.tag < right.tag ? -1 : 1);
+	const directorySize = sorted.length * 16;
+	const bodySize = sorted.reduce((total, table) => total + alignUp(table.data.byteLength), 0);
+	const output = new Uint8Array(12 + directorySize + bodySize);
+	const view = new DataView(output.buffer);
+	const { searchRange, entrySelector, rangeShift } = searchParametersFor(sorted.length);
+	view.setUint32(0, SFNT_VERSION.trueType);
+	view.setUint16(4, sorted.length);
+	view.setUint16(6, searchRange);
+	view.setUint16(8, entrySelector);
+	view.setUint16(10, rangeShift);
+	let entry = 12;
+	let dataOffset = 12 + directorySize;
+	let headOffset = -1;
+	for (const table of sorted) {
+		for (let index = 0; index < table.tag.length; index++) view.setUint8(entry + index, table.tag.charCodeAt(index));
+		view.setUint32(entry + 4, checksumOf(table.data));
+		view.setUint32(entry + 8, dataOffset);
+		view.setUint32(entry + 12, table.data.byteLength);
+		output.set(table.data, dataOffset);
+		if (table.tag === SFNT_TABLE.head) headOffset = dataOffset;
+		dataOffset += alignUp(table.data.byteLength);
+		entry += 16;
+	}
+	if (headOffset >= 0) view.setUint32(headOffset + HEAD.checkSumAdjustment, CHECKSUM_ADJUSTMENT_MAGIC - checksumOf(output) >>> 0);
+	return output;
+};
+/** A copy of a source table, so edits never touch the caller's buffer. */
+const copyTable = (directory, record) => new Uint8Array(directory.view.buffer.slice(directory.view.byteOffset + record.offset, directory.view.byteOffset + record.offset + record.length));
+const requireTable = (directory, tag, size) => {
+	const record = directory.tables.get(tag);
+	if (!record) return fail(`font has no '${tag}' table, which a TrueType subset needs`);
+	if (record.length < size || !fitsInView(directory.view, record.offset, size)) return fail(`'${tag}' table is ${record.length} bytes, needs at least ${size}`);
+	return Result.ok(record);
+};
+/**
+* Build a `glyf`-flavoured subset containing `glyphIds` plus the components
+* they reference transitively, plus .notdef.
+*/
+const subsetTrueType = (font, glyphIds) => {
+	if (font.isCff) return fail("cannot subset a CFF font: its outlines are charstrings, not glyf data; embed the font whole instead");
+	const directoryResult = readSfntDirectory(font.bytes).mapError((error) => new SubsetError({ message: error.message }));
+	if (directoryResult.isErr()) return Result.err(directoryResult.error);
+	const directory = directoryResult.value;
+	const { view } = directory;
+	const headResult = requireTable(directory, SFNT_TABLE.head, HEAD.size);
+	if (headResult.isErr()) return Result.err(headResult.error);
+	const hheaResult = requireTable(directory, SFNT_TABLE.hhea, HHEA.size);
+	if (hheaResult.isErr()) return Result.err(hheaResult.error);
+	const maxpResult = requireTable(directory, SFNT_TABLE.maxp, MAXP.size);
+	if (maxpResult.isErr()) return Result.err(maxpResult.error);
+	const hmtxResult = requireTable(directory, SFNT_TABLE.hmtx, HMTX_METRIC_SIZE);
+	if (hmtxResult.isErr()) return Result.err(hmtxResult.error);
+	const glyfResult = requireTable(directory, SFNT_TABLE.glyf, 0);
+	if (glyfResult.isErr()) return Result.err(glyfResult.error);
+	const locaResult = requireTable(directory, SFNT_TABLE.loca, 0);
+	if (locaResult.isErr()) return Result.err(locaResult.error);
+	const head = headResult.value;
+	const offsets = readLocaOffsets({
+		view,
+		loca: locaResult.value,
+		numGlyphs: font.numGlyphs,
+		longFormat: view.getInt16(head.offset + HEAD.indexToLocFormat) === 1
+	});
+	if (!offsets) return fail("'loca' is truncated or its offsets are not monotonic");
+	const source = {
+		view,
+		glyf: glyfResult.value,
+		offsets,
+		numGlyphs: font.numGlyphs
+	};
+	const selectedResult = closeOverComponents(source, glyphIds);
+	if (selectedResult.isErr()) return Result.err(selectedResult.error);
+	const selected = selectedResult.value;
+	const glyphIdMap = /* @__PURE__ */ new Map();
+	for (const [newId, oldId] of selected.entries()) glyphIdMap.set(oldId, newId);
+	const glyfResultBuilt = buildGlyf(source, selected, glyphIdMap);
+	if (glyfResultBuilt.isErr()) return Result.err(glyfResultBuilt.error);
+	const { glyf, locaOffsets } = glyfResultBuilt.value;
+	const longLoca = glyf.byteLength > MAX_SHORT_LOCA_GLYF_LENGTH;
+	const loca = buildLoca(locaOffsets, longLoca);
+	const newHead = copyTable(directory, head);
+	const headView = new DataView(newHead.buffer);
+	headView.setInt16(HEAD.indexToLocFormat, longLoca ? 1 : 0);
+	headView.setUint32(HEAD.checkSumAdjustment, 0);
+	const newHhea = copyTable(directory, hheaResult.value);
+	new DataView(newHhea.buffer).setUint16(HHEA.numberOfHMetrics, selected.length);
+	const newMaxp = copyTable(directory, maxpResult.value);
+	new DataView(newMaxp.buffer).setUint16(MAXP.numGlyphs, selected.length);
+	const sourceMetrics = {
+		view,
+		hmtx: hmtxResult.value,
+		numberOfHMetrics: view.getUint16(hheaResult.value.offset + HHEA.numberOfHMetrics)
+	};
+	const newHmtx = new Uint8Array(selected.length * HMTX_METRIC_SIZE);
+	const hmtxView = new DataView(newHmtx.buffer);
+	for (const [newId, oldId] of selected.entries()) {
+		hmtxView.setUint16(newId * HMTX_METRIC_SIZE, font.advanceWidthFor(oldId));
+		hmtxView.setInt16(newId * HMTX_METRIC_SIZE + 2, sourceLeftSideBearing(sourceMetrics, oldId));
+	}
+	const tables = [
+		{
+			tag: SFNT_TABLE.head,
+			data: newHead
+		},
+		{
+			tag: SFNT_TABLE.hhea,
+			data: newHhea
+		},
+		{
+			tag: SFNT_TABLE.maxp,
+			data: newMaxp
+		},
+		{
+			tag: SFNT_TABLE.hmtx,
+			data: newHmtx
+		},
+		{
+			tag: SFNT_TABLE.loca,
+			data: loca
+		},
+		{
+			tag: SFNT_TABLE.glyf,
+			data: glyf
+		}
+	];
+	for (const tag of VERBATIM_TABLES) {
+		const record = directory.tables.get(tag);
+		if (record) tables.push({
+			tag,
+			data: copyTable(directory, record)
+		});
+	}
+	return Result.ok({
+		bytes: assembleSfnt(tables),
+		glyphIdMap
+	});
+};
+//#endregion
+export { SubsetError, subsetTrueType };

package/dist/fonts/sfnt/tables.d.ts

@@ -0,0 +1,88 @@
+import { Result } from "better-result";
+//#region src/fonts/sfnt/tables.d.ts
+/** Four-character table tags this package addresses by name. */
+declare const SFNT_TABLE: {
+  readonly cff: "CFF ";
+  readonly cmap: "cmap";
+  readonly cvt: "cvt ";
+  readonly fpgm: "fpgm";
+  readonly glyf: "glyf";
+  readonly head: "head";
+  readonly hhea: "hhea";
+  readonly hmtx: "hmtx";
+  readonly loca: "loca";
+  readonly maxp: "maxp";
+  readonly name: "name";
+  readonly os2: "OS/2";
+  readonly post: "post";
+  readonly prep: "prep";
+};
+/**
+ * sfnt `version` words (the same field WOFF calls `flavor`), plus the
+ * container magics that are *not* a bare sfnt and must be reported as such.
+ */
+declare const SFNT_VERSION: {
+  /** `0x00010000`: TrueType outlines. */
+  readonly trueType: 65536;
+  /** `true`: the legacy Apple spelling of the same thing. */
+  readonly trueMac: 1953658213;
+  /** `OTTO`: OpenType with CFF outlines. */
+  readonly openTypeCff: 1330926671;
+  /** `ttcf`: a font collection, not a single font. */
+  readonly collection: 1953784678;
+  /** `wOFF`: WOFF 1.0 container. */
+  readonly woff: 2001684038;
+  /** `wOF2`: WOFF 2.0 container. */
+  readonly woff2: 2001684018;
+};
+/** sfnt header: version, numTables, searchRange, entrySelector, rangeShift. */
+declare const SFNT_HEADER_SIZE = 12;
+/** Directory entry: tag, checksum, offset, length. */
+declare const SFNT_DIRECTORY_ENTRY_SIZE = 16;
+/** Every table starts on a four-byte boundary and is zero-padded to one. */
+declare const SFNT_TABLE_ALIGNMENT = 4;
+declare const SfntDirectoryError_base: import("better-result").TaggedErrorClass<"SfntDirectoryError">;
+/** A structural problem in the container: bad header, or a table out of bounds. */
+declare class SfntDirectoryError extends SfntDirectoryError_base<{
+  message: string;
+}> {}
+/** One entry of the table directory, already bounds-checked against the buffer. */
+type SfntTableRecord = {
+  readonly tag: string;
+  readonly offset: number;
+  readonly length: number;
+};
+type SfntDirectory = {
+  readonly version: number;
+  readonly view: DataView;
+  readonly tables: ReadonlyMap<string, SfntTableRecord>;
+};
+/** Whether `[offset, offset + length)` lies wholly inside `view`. */
+declare const fitsInView: (view: DataView, offset: number, length: number) => boolean;
+/** The four-byte tag at `offset`, or `""` when it does not fit. */
+declare const readTag: (view: DataView, offset: number) => string;
+/** The leading version word, or `undefined` when the buffer is shorter than it. */
+declare const readSfntVersion: (bytes: Uint8Array) => number | undefined;
+/**
+ * Reads the table directory, validating every entry against the buffer.
+ *
+ * The caller is expected to have rejected non-sfnt magics first: a collection
+ * or WOFF header parsed as a directory yields nonsense offsets and a much
+ * worse error message than the container check gives.
+ */
+declare const readSfntDirectory: (bytes: Uint8Array) => Result<SfntDirectory, SfntDirectoryError>;
+type LocaOffsetsOptions = {
+  readonly view: DataView;
+  readonly loca: SfntTableRecord;
+  readonly numGlyphs: number;
+  /** `head.indexToLocFormat === 1`: offsets are uint32, not uint16 halves. */
+  readonly longFormat: boolean;
+};
+/**
+ * The `numGlyphs + 1` glyph offsets from `loca`, or `undefined` when the table
+ * is too short or its offsets run backwards (either makes glyph extraction
+ * meaningless).
+ */
+declare const readLocaOffsets: ({ view, loca, numGlyphs, longFormat }: LocaOffsetsOptions) => readonly number[] | undefined;
+//#endregion
+export { SFNT_DIRECTORY_ENTRY_SIZE, SFNT_HEADER_SIZE, SFNT_TABLE, SFNT_TABLE_ALIGNMENT, SFNT_VERSION, SfntDirectory, SfntDirectoryError, SfntTableRecord, fitsInView, readLocaOffsets, readSfntDirectory, readSfntVersion, readTag };

package/dist/fonts/sfnt/tables.js

@@ -0,0 +1,131 @@
+import { Result, TaggedError } from "better-result";
+//#region src/fonts/sfnt/tables.ts
+/**
+* Shared sfnt container primitives: table tags, the container magics, the
+* table directory, and the `loca` offset array.
+*
+* `parse.ts`, `woff.ts` and `subset.ts` all address tables through the same
+* directory, and both the parser (deriving cap height from glyph bounds) and
+* the subsetter (copying glyph data) read `loca`. Keeping one reader here
+* means the two cannot disagree about what a truncated or non-monotonic
+* table means.
+*/
+/** Four-character table tags this package addresses by name. */
+const SFNT_TABLE = {
+	cff: "CFF ",
+	cmap: "cmap",
+	cvt: "cvt ",
+	fpgm: "fpgm",
+	glyf: "glyf",
+	head: "head",
+	hhea: "hhea",
+	hmtx: "hmtx",
+	loca: "loca",
+	maxp: "maxp",
+	name: "name",
+	os2: "OS/2",
+	post: "post",
+	prep: "prep"
+};
+/**
+* sfnt `version` words (the same field WOFF calls `flavor`), plus the
+* container magics that are *not* a bare sfnt and must be reported as such.
+*/
+const SFNT_VERSION = {
+	/** `0x00010000`: TrueType outlines. */
+	trueType: 65536,
+	/** `true`: the legacy Apple spelling of the same thing. */
+	trueMac: 1953658213,
+	/** `OTTO`: OpenType with CFF outlines. */
+	openTypeCff: 1330926671,
+	/** `ttcf`: a font collection, not a single font. */
+	collection: 1953784678,
+	/** `wOFF`: WOFF 1.0 container. */
+	woff: 2001684038,
+	/** `wOF2`: WOFF 2.0 container. */
+	woff2: 2001684018
+};
+/** sfnt header: version, numTables, searchRange, entrySelector, rangeShift. */
+const SFNT_HEADER_SIZE = 12;
+/** Directory entry: tag, checksum, offset, length. */
+const SFNT_DIRECTORY_ENTRY_SIZE = 16;
+/** Every table starts on a four-byte boundary and is zero-padded to one. */
+const SFNT_TABLE_ALIGNMENT = 4;
+const DIRECTORY_ENTRY = {
+	tag: 0,
+	checkSum: 4,
+	offset: 8,
+	length: 12
+};
+const TAG_LENGTH = 4;
+/** A structural problem in the container: bad header, or a table out of bounds. */
+var SfntDirectoryError = class extends TaggedError("SfntDirectoryError") {};
+/** Whether `[offset, offset + length)` lies wholly inside `view`. */
+const fitsInView = (view, offset, length) => Number.isInteger(offset) && Number.isInteger(length) && offset >= 0 && length >= 0 && offset + length <= view.byteLength;
+/** The four-byte tag at `offset`, or `""` when it does not fit. */
+const readTag = (view, offset) => {
+	if (!fitsInView(view, offset, TAG_LENGTH)) return "";
+	let tag = "";
+	for (let index = 0; index < TAG_LENGTH; index++) tag += String.fromCharCode(view.getUint8(offset + index));
+	return tag;
+};
+/** The leading version word, or `undefined` when the buffer is shorter than it. */
+const readSfntVersion = (bytes) => {
+	if (bytes.byteLength < TAG_LENGTH) return;
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0);
+};
+/**
+* Reads the table directory, validating every entry against the buffer.
+*
+* The caller is expected to have rejected non-sfnt magics first: a collection
+* or WOFF header parsed as a directory yields nonsense offsets and a much
+* worse error message than the container check gives.
+*/
+const readSfntDirectory = (bytes) => {
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (!fitsInView(view, 0, 12)) return Result.err(new SfntDirectoryError({ message: `sfnt header needs 12 bytes, buffer has ${view.byteLength}` }));
+	const version = view.getUint32(0);
+	const numTables = view.getUint16(4);
+	const directorySize = numTables * 16;
+	if (!fitsInView(view, 12, directorySize)) return Result.err(new SfntDirectoryError({ message: `table directory declares ${numTables} tables, which does not fit in ${view.byteLength} bytes` }));
+	const tables = /* @__PURE__ */ new Map();
+	for (let index = 0; index < numTables; index++) {
+		const entry = 12 + index * 16;
+		const tag = readTag(view, entry + DIRECTORY_ENTRY.tag);
+		const offset = view.getUint32(entry + DIRECTORY_ENTRY.offset);
+		const length = view.getUint32(entry + DIRECTORY_ENTRY.length);
+		if (!fitsInView(view, offset, length)) return Result.err(new SfntDirectoryError({ message: `table '${tag}' spans [${offset}, ${offset + length}) outside the ${view.byteLength}-byte font` }));
+		if (!tables.has(tag)) tables.set(tag, {
+			tag,
+			offset,
+			length
+		});
+	}
+	return Result.ok({
+		version,
+		view,
+		tables
+	});
+};
+/**
+* The `numGlyphs + 1` glyph offsets from `loca`, or `undefined` when the table
+* is too short or its offsets run backwards (either makes glyph extraction
+* meaningless).
+*/
+const readLocaOffsets = ({ view, loca, numGlyphs, longFormat }) => {
+	const entrySize = longFormat ? 4 : 2;
+	const count = numGlyphs + 1;
+	if (loca.length < count * entrySize || !fitsInView(view, loca.offset, count * entrySize)) return;
+	const offsets = [];
+	let previous = -1;
+	for (let index = 0; index < count; index++) {
+		const at = loca.offset + index * entrySize;
+		const offset = longFormat ? view.getUint32(at) : view.getUint16(at) * 2;
+		if (offset < previous) return;
+		previous = offset;
+		offsets.push(offset);
+	}
+	return offsets;
+};
+//#endregion
+export { SFNT_DIRECTORY_ENTRY_SIZE, SFNT_HEADER_SIZE, SFNT_TABLE, SFNT_TABLE_ALIGNMENT, SFNT_VERSION, SfntDirectoryError, fitsInView, readLocaOffsets, readSfntDirectory, readSfntVersion, readTag };

package/dist/fonts/sfnt/woff.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "better-result";
+//#region src/fonts/sfnt/woff.d.ts
+declare const WoffDecodeError_base: import("better-result").TaggedErrorClass<"WoffDecodeError">;
+declare class WoffDecodeError extends WoffDecodeError_base<{
+  message: string;
+}> {}
+declare const decodeWoff: (bytes: Uint8Array) => Result<Uint8Array, WoffDecodeError>;
+/**
+ * The entry point a caller with bytes of unknown provenance wants: plain sfnt
+ * passes through untouched, WOFF is decoded, WOFF2 is refused by name.
+ */
+declare const toSfntBytes: (bytes: Uint8Array) => Result<Uint8Array, WoffDecodeError>;
+//#endregion
+export { WoffDecodeError, decodeWoff, toSfntBytes };