pdf-codec 1.5.0 → 1.6.0

package/dist/font-tables.cjs

@@ -0,0 +1,127 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/font-tables.ts
+const HEAD_TABLE_SIZE = 54;
+const HEAD_MAGIC_NUMBER = 1594834165;
+const MIN_UNITS_PER_EM = 16;
+const MAX_UNITS_PER_EM = 16384;
+function parseHead(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "head");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, HEAD_TABLE_SIZE)) return;
+	if (require_sfnt.u32(bytes, 12) !== HEAD_MAGIC_NUMBER) return;
+	const unitsPerEm = require_sfnt.u16(bytes, 18);
+	if (unitsPerEm < MIN_UNITS_PER_EM || unitsPerEm > MAX_UNITS_PER_EM) return;
+	const indexToLocFormat = require_sfnt.i16(bytes, 50);
+	if (indexToLocFormat !== 0 && indexToLocFormat !== 1) return;
+	return {
+		unitsPerEm,
+		checkSumAdjustment: require_sfnt.u32(bytes, 8),
+		xMin: require_sfnt.i16(bytes, 36),
+		yMin: require_sfnt.i16(bytes, 38),
+		xMax: require_sfnt.i16(bytes, 40),
+		yMax: require_sfnt.i16(bytes, 42),
+		indexToLocFormat
+	};
+}
+const MAXP_HEADER_SIZE = 6;
+function parseMaxp(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "maxp");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, MAXP_HEADER_SIZE)) return;
+	return { numGlyphs: require_sfnt.u16(bytes, 4) };
+}
+const OS2_VERSION_0_SIZE = 78;
+const OS2_VERSION_2_SIZE = 96;
+const OS2_VERSION_WITH_HEIGHTS = 2;
+const OS2_PANOSE_OFFSET = 32;
+function parseOs2(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "OS/2");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, OS2_VERSION_0_SIZE)) return;
+	const version = require_sfnt.u16(bytes, 0);
+	const hasHeights = version >= OS2_VERSION_WITH_HEIGHTS && require_sfnt.hasBytes(bytes, 0, OS2_VERSION_2_SIZE);
+	return {
+		version,
+		fsSelection: require_sfnt.u16(bytes, 62),
+		panose: [...bytes.subarray(OS2_PANOSE_OFFSET, 42)],
+		sTypoAscender: require_sfnt.i16(bytes, 68),
+		sTypoDescender: require_sfnt.i16(bytes, 70),
+		sTypoLineGap: require_sfnt.i16(bytes, 72),
+		usWinAscent: require_sfnt.u16(bytes, 74),
+		usWinDescent: require_sfnt.u16(bytes, 76),
+		sxHeight: hasHeights ? require_sfnt.i16(bytes, 86) : void 0,
+		sCapHeight: hasHeights ? require_sfnt.i16(bytes, 88) : void 0
+	};
+}
+const POST_HEADER_SIZE = 32;
+const FIXED_16_16_SCALE = 65536;
+function parsePost(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "post");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, POST_HEADER_SIZE)) return;
+	return {
+		version: require_sfnt.u32(bytes, 0),
+		italicAngle: require_sfnt.i32(bytes, 4) / FIXED_16_16_SCALE,
+		underlinePosition: require_sfnt.i16(bytes, 8),
+		underlineThickness: require_sfnt.i16(bytes, 10)
+	};
+}
+const NAME_HEADER_SIZE = 6;
+const NAME_RECORD_SIZE = 12;
+const NAME_ID_FAMILY = 1;
+const NAME_ID_POSTSCRIPT = 6;
+const NAME_ID_TYPOGRAPHIC_FAMILY = 16;
+const PLATFORM_UNICODE = 0;
+const PLATFORM_MACINTOSH = 1;
+const PLATFORM_WINDOWS = 3;
+const WINDOWS_ENCODING_UNICODE_BMP = 1;
+const MACINTOSH_ENCODING_ROMAN = 0;
+function decodeUtf16Be(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i + 1 < length; i += 2) text += String.fromCharCode(bytes[offset + i] << 8 | bytes[offset + i + 1]);
+	return text;
+}
+function decodeMacRoman(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i < length; i++) text += String.fromCharCode(bytes[offset + i]);
+	return text;
+}
+function platformRank(record) {
+	if (record.platformId === PLATFORM_WINDOWS && record.encodingId === WINDOWS_ENCODING_UNICODE_BMP) return 0;
+	if (record.platformId === PLATFORM_UNICODE) return 1;
+	if (record.platformId === PLATFORM_MACINTOSH && record.encodingId === MACINTOSH_ENCODING_ROMAN) return 2;
+	return 3;
+}
+function readName(bytes, records, nameId) {
+	const matches = records.filter((record) => record.nameId === nameId && platformRank(record) < 3).sort((a, b) => platformRank(a) - platformRank(b));
+	for (const record of matches) {
+		if (!require_sfnt.hasBytes(bytes, record.stringOffset, record.length)) continue;
+		const text = record.platformId === PLATFORM_MACINTOSH ? decodeMacRoman(bytes, record.stringOffset, record.length) : decodeUtf16Be(bytes, record.stringOffset, record.length);
+		if (text.length > 0) return text;
+	}
+}
+function parseName(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "name");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, NAME_HEADER_SIZE)) return;
+	const count = require_sfnt.u16(bytes, 2);
+	const storageOffset = require_sfnt.u16(bytes, 4);
+	if (!require_sfnt.hasBytes(bytes, NAME_HEADER_SIZE, count * NAME_RECORD_SIZE)) return;
+	const records = [];
+	for (let i = 0; i < count; i++) {
+		const recordOffset = NAME_HEADER_SIZE + i * NAME_RECORD_SIZE;
+		records.push({
+			platformId: require_sfnt.u16(bytes, recordOffset),
+			encodingId: require_sfnt.u16(bytes, recordOffset + 2),
+			nameId: require_sfnt.u16(bytes, recordOffset + 6),
+			length: require_sfnt.u16(bytes, recordOffset + 8),
+			stringOffset: storageOffset + require_sfnt.u16(bytes, recordOffset + 10)
+		});
+	}
+	return {
+		postScriptName: readName(bytes, records, NAME_ID_POSTSCRIPT),
+		familyName: readName(bytes, records, NAME_ID_TYPOGRAPHIC_FAMILY) ?? readName(bytes, records, NAME_ID_FAMILY)
+	};
+}
+//#endregion
+exports.parseHead = parseHead;
+exports.parseMaxp = parseMaxp;
+exports.parseName = parseName;
+exports.parseOs2 = parseOs2;
+exports.parsePost = parsePost;

package/dist/font-tables.d.cts

@@ -0,0 +1,43 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/font-tables.d.ts
+interface HeadTable {
+  readonly unitsPerEm: number;
+  readonly checkSumAdjustment: number;
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+  readonly indexToLocFormat: 0 | 1;
+}
+declare function parseHead(font: SfntFont): HeadTable | undefined;
+interface MaxpTable {
+  readonly numGlyphs: number;
+}
+declare function parseMaxp(font: SfntFont): MaxpTable | undefined;
+interface Os2Table {
+  readonly version: number;
+  readonly fsSelection: number;
+  readonly panose: readonly number[];
+  readonly sTypoAscender: number;
+  readonly sTypoDescender: number;
+  readonly sTypoLineGap: number;
+  readonly usWinAscent: number;
+  readonly usWinDescent: number;
+  readonly sxHeight: number | undefined;
+  readonly sCapHeight: number | undefined;
+}
+declare function parseOs2(font: SfntFont): Os2Table | undefined;
+interface PostTable {
+  readonly version: number;
+  readonly italicAngle: number;
+  readonly underlinePosition: number;
+  readonly underlineThickness: number;
+}
+declare function parsePost(font: SfntFont): PostTable | undefined;
+interface NameTable {
+  readonly postScriptName: string | undefined;
+  readonly familyName: string | undefined;
+}
+declare function parseName(font: SfntFont): NameTable | undefined;
+//#endregion
+export { HeadTable, MaxpTable, NameTable, Os2Table, PostTable, parseHead, parseMaxp, parseName, parseOs2, parsePost };

package/dist/font-tables.d.ts

@@ -0,0 +1,43 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/font-tables.d.ts
+interface HeadTable {
+  readonly unitsPerEm: number;
+  readonly checkSumAdjustment: number;
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+  readonly indexToLocFormat: 0 | 1;
+}
+declare function parseHead(font: SfntFont): HeadTable | undefined;
+interface MaxpTable {
+  readonly numGlyphs: number;
+}
+declare function parseMaxp(font: SfntFont): MaxpTable | undefined;
+interface Os2Table {
+  readonly version: number;
+  readonly fsSelection: number;
+  readonly panose: readonly number[];
+  readonly sTypoAscender: number;
+  readonly sTypoDescender: number;
+  readonly sTypoLineGap: number;
+  readonly usWinAscent: number;
+  readonly usWinDescent: number;
+  readonly sxHeight: number | undefined;
+  readonly sCapHeight: number | undefined;
+}
+declare function parseOs2(font: SfntFont): Os2Table | undefined;
+interface PostTable {
+  readonly version: number;
+  readonly italicAngle: number;
+  readonly underlinePosition: number;
+  readonly underlineThickness: number;
+}
+declare function parsePost(font: SfntFont): PostTable | undefined;
+interface NameTable {
+  readonly postScriptName: string | undefined;
+  readonly familyName: string | undefined;
+}
+declare function parseName(font: SfntFont): NameTable | undefined;
+//#endregion
+export { HeadTable, MaxpTable, NameTable, Os2Table, PostTable, parseHead, parseMaxp, parseName, parseOs2, parsePost };

package/dist/font-tables.js

@@ -0,0 +1,122 @@
+import { hasBytes, i16, i32, sfntTableBytes, u16, u32 } from "./sfnt.js";
+//#region src/font-tables.ts
+const HEAD_TABLE_SIZE = 54;
+const HEAD_MAGIC_NUMBER = 1594834165;
+const MIN_UNITS_PER_EM = 16;
+const MAX_UNITS_PER_EM = 16384;
+function parseHead(font) {
+	const bytes = sfntTableBytes(font, "head");
+	if (bytes === void 0 || !hasBytes(bytes, 0, HEAD_TABLE_SIZE)) return;
+	if (u32(bytes, 12) !== HEAD_MAGIC_NUMBER) return;
+	const unitsPerEm = u16(bytes, 18);
+	if (unitsPerEm < MIN_UNITS_PER_EM || unitsPerEm > MAX_UNITS_PER_EM) return;
+	const indexToLocFormat = i16(bytes, 50);
+	if (indexToLocFormat !== 0 && indexToLocFormat !== 1) return;
+	return {
+		unitsPerEm,
+		checkSumAdjustment: u32(bytes, 8),
+		xMin: i16(bytes, 36),
+		yMin: i16(bytes, 38),
+		xMax: i16(bytes, 40),
+		yMax: i16(bytes, 42),
+		indexToLocFormat
+	};
+}
+const MAXP_HEADER_SIZE = 6;
+function parseMaxp(font) {
+	const bytes = sfntTableBytes(font, "maxp");
+	if (bytes === void 0 || !hasBytes(bytes, 0, MAXP_HEADER_SIZE)) return;
+	return { numGlyphs: u16(bytes, 4) };
+}
+const OS2_VERSION_0_SIZE = 78;
+const OS2_VERSION_2_SIZE = 96;
+const OS2_VERSION_WITH_HEIGHTS = 2;
+const OS2_PANOSE_OFFSET = 32;
+function parseOs2(font) {
+	const bytes = sfntTableBytes(font, "OS/2");
+	if (bytes === void 0 || !hasBytes(bytes, 0, OS2_VERSION_0_SIZE)) return;
+	const version = u16(bytes, 0);
+	const hasHeights = version >= OS2_VERSION_WITH_HEIGHTS && hasBytes(bytes, 0, OS2_VERSION_2_SIZE);
+	return {
+		version,
+		fsSelection: u16(bytes, 62),
+		panose: [...bytes.subarray(OS2_PANOSE_OFFSET, 42)],
+		sTypoAscender: i16(bytes, 68),
+		sTypoDescender: i16(bytes, 70),
+		sTypoLineGap: i16(bytes, 72),
+		usWinAscent: u16(bytes, 74),
+		usWinDescent: u16(bytes, 76),
+		sxHeight: hasHeights ? i16(bytes, 86) : void 0,
+		sCapHeight: hasHeights ? i16(bytes, 88) : void 0
+	};
+}
+const POST_HEADER_SIZE = 32;
+const FIXED_16_16_SCALE = 65536;
+function parsePost(font) {
+	const bytes = sfntTableBytes(font, "post");
+	if (bytes === void 0 || !hasBytes(bytes, 0, POST_HEADER_SIZE)) return;
+	return {
+		version: u32(bytes, 0),
+		italicAngle: i32(bytes, 4) / FIXED_16_16_SCALE,
+		underlinePosition: i16(bytes, 8),
+		underlineThickness: i16(bytes, 10)
+	};
+}
+const NAME_HEADER_SIZE = 6;
+const NAME_RECORD_SIZE = 12;
+const NAME_ID_FAMILY = 1;
+const NAME_ID_POSTSCRIPT = 6;
+const NAME_ID_TYPOGRAPHIC_FAMILY = 16;
+const PLATFORM_UNICODE = 0;
+const PLATFORM_MACINTOSH = 1;
+const PLATFORM_WINDOWS = 3;
+const WINDOWS_ENCODING_UNICODE_BMP = 1;
+const MACINTOSH_ENCODING_ROMAN = 0;
+function decodeUtf16Be(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i + 1 < length; i += 2) text += String.fromCharCode(bytes[offset + i] << 8 | bytes[offset + i + 1]);
+	return text;
+}
+function decodeMacRoman(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i < length; i++) text += String.fromCharCode(bytes[offset + i]);
+	return text;
+}
+function platformRank(record) {
+	if (record.platformId === PLATFORM_WINDOWS && record.encodingId === WINDOWS_ENCODING_UNICODE_BMP) return 0;
+	if (record.platformId === PLATFORM_UNICODE) return 1;
+	if (record.platformId === PLATFORM_MACINTOSH && record.encodingId === MACINTOSH_ENCODING_ROMAN) return 2;
+	return 3;
+}
+function readName(bytes, records, nameId) {
+	const matches = records.filter((record) => record.nameId === nameId && platformRank(record) < 3).sort((a, b) => platformRank(a) - platformRank(b));
+	for (const record of matches) {
+		if (!hasBytes(bytes, record.stringOffset, record.length)) continue;
+		const text = record.platformId === PLATFORM_MACINTOSH ? decodeMacRoman(bytes, record.stringOffset, record.length) : decodeUtf16Be(bytes, record.stringOffset, record.length);
+		if (text.length > 0) return text;
+	}
+}
+function parseName(font) {
+	const bytes = sfntTableBytes(font, "name");
+	if (bytes === void 0 || !hasBytes(bytes, 0, NAME_HEADER_SIZE)) return;
+	const count = u16(bytes, 2);
+	const storageOffset = u16(bytes, 4);
+	if (!hasBytes(bytes, NAME_HEADER_SIZE, count * NAME_RECORD_SIZE)) return;
+	const records = [];
+	for (let i = 0; i < count; i++) {
+		const recordOffset = NAME_HEADER_SIZE + i * NAME_RECORD_SIZE;
+		records.push({
+			platformId: u16(bytes, recordOffset),
+			encodingId: u16(bytes, recordOffset + 2),
+			nameId: u16(bytes, recordOffset + 6),
+			length: u16(bytes, recordOffset + 8),
+			stringOffset: storageOffset + u16(bytes, recordOffset + 10)
+		});
+	}
+	return {
+		postScriptName: readName(bytes, records, NAME_ID_POSTSCRIPT),
+		familyName: readName(bytes, records, NAME_ID_TYPOGRAPHIC_FAMILY) ?? readName(bytes, records, NAME_ID_FAMILY)
+	};
+}
+//#endregion
+export { parseHead, parseMaxp, parseName, parseOs2, parsePost };

package/dist/fonts.cjs

@@ -120,5 +120,6 @@ function resolveStandardFont(family, bold, italic) {
 	};
 }
 //#endregion
+exports.normalizeFamilyName = normalizeFamilyName;
 exports.resolveFontFamily = resolveFontFamily;
 exports.resolveStandardFont = resolveStandardFont;

package/dist/fonts.d.cts

@@ -1,6 +1,7 @@
 import { r as StandardFontName } from "./afm-widths-DyDq56Ph.cjs";
 //#region src/fonts.d.ts
 type StandardFamily = 'helvetica' | 'times' | 'courier';
+declare function normalizeFamilyName(raw: string): string;
 interface FontFamilyResolution {
   readonly family: StandardFamily;
   readonly matched: boolean;
@@ -12,4 +13,4 @@ interface ResolvedFont {
 }
 declare function resolveStandardFont(family: string, bold: boolean, italic: boolean): ResolvedFont;
 //#endregion
-export { FontFamilyResolution, ResolvedFont, resolveFontFamily, resolveStandardFont };
+export { FontFamilyResolution, ResolvedFont, normalizeFamilyName, resolveFontFamily, resolveStandardFont };

package/dist/fonts.d.ts

@@ -1,6 +1,7 @@
 import { r as StandardFontName } from "./afm-widths-DyDq56Ph.js";
 //#region src/fonts.d.ts
 type StandardFamily = 'helvetica' | 'times' | 'courier';
+declare function normalizeFamilyName(raw: string): string;
 interface FontFamilyResolution {
   readonly family: StandardFamily;
   readonly matched: boolean;
@@ -12,4 +13,4 @@ interface ResolvedFont {
 }
 declare function resolveStandardFont(family: string, bold: boolean, italic: boolean): ResolvedFont;
 //#endregion
-export { FontFamilyResolution, ResolvedFont, resolveFontFamily, resolveStandardFont };
+export { FontFamilyResolution, ResolvedFont, normalizeFamilyName, resolveFontFamily, resolveStandardFont };

package/dist/fonts.js

@@ -119,4 +119,4 @@ function resolveStandardFont(family, bold, italic) {
 	};
 }
 //#endregion
-export { resolveFontFamily, resolveStandardFont };
+export { normalizeFamilyName, resolveFontFamily, resolveStandardFont };

package/dist/glyf.cjs

@@ -0,0 +1,127 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/glyf.ts
+const LOCA_SHORT_ENTRY_SIZE = 2;
+const LOCA_LONG_ENTRY_SIZE = 4;
+const LOCA_SHORT_OFFSET_SCALE = 2;
+function parseLoca(font, options) {
+	const bytes = require_sfnt.sfntTableBytes(font, "loca");
+	if (bytes === void 0) return;
+	const entryCount = options.numGlyphs + 1;
+	const entrySize = options.indexToLocFormat === 0 ? LOCA_SHORT_ENTRY_SIZE : LOCA_LONG_ENTRY_SIZE;
+	if (!require_sfnt.hasBytes(bytes, 0, entryCount * entrySize)) return;
+	const offsets = [];
+	for (let i = 0; i < entryCount; i++) offsets.push(options.indexToLocFormat === 0 ? require_sfnt.u16(bytes, i * LOCA_SHORT_ENTRY_SIZE) * LOCA_SHORT_OFFSET_SCALE : require_sfnt.u32(bytes, i * LOCA_LONG_ENTRY_SIZE));
+	return offsets;
+}
+const GLYPH_HEADER_SIZE = 10;
+const ARG_1_AND_2_ARE_WORDS = 1;
+const ARGS_ARE_XY_VALUES = 2;
+const WE_HAVE_A_SCALE = 8;
+const MORE_COMPONENTS = 32;
+const WE_HAVE_AN_X_AND_Y_SCALE = 64;
+const WE_HAVE_A_TWO_BY_TWO = 128;
+const COMPONENT_RECORD_HEADER_SIZE = 4;
+function signedByte(value) {
+	return value >= 128 ? value - 256 : value;
+}
+function readComponents(glyph) {
+	const components = [];
+	let offset = GLYPH_HEADER_SIZE;
+	for (;;) {
+		if (!require_sfnt.hasBytes(glyph, offset, COMPONENT_RECORD_HEADER_SIZE)) return;
+		const flags = require_sfnt.u16(glyph, offset);
+		const glyphIndex = require_sfnt.u16(glyph, offset + 2);
+		offset += COMPONENT_RECORD_HEADER_SIZE;
+		const argsAreWords = (flags & ARG_1_AND_2_ARE_WORDS) !== 0;
+		const argsAreXyValues = (flags & ARGS_ARE_XY_VALUES) !== 0;
+		const argsSize = argsAreWords ? 4 : 2;
+		if (!require_sfnt.hasBytes(glyph, offset, argsSize)) return;
+		let argument1;
+		let argument2;
+		if (argsAreWords) {
+			argument1 = argsAreXyValues ? require_sfnt.i16(glyph, offset) : require_sfnt.u16(glyph, offset);
+			argument2 = argsAreXyValues ? require_sfnt.i16(glyph, offset + 2) : require_sfnt.u16(glyph, offset + 2);
+		} else {
+			argument1 = argsAreXyValues ? signedByte(require_sfnt.u8(glyph, offset)) : require_sfnt.u8(glyph, offset);
+			argument2 = argsAreXyValues ? signedByte(require_sfnt.u8(glyph, offset + 1)) : require_sfnt.u8(glyph, offset + 1);
+		}
+		offset += argsSize;
+		let transform;
+		if ((flags & WE_HAVE_A_SCALE) !== 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 2)) return;
+			const scale = require_sfnt.f2dot14(glyph, offset);
+			transform = [
+				scale,
+				0,
+				0,
+				scale
+			];
+			offset += 2;
+		} else if ((flags & WE_HAVE_AN_X_AND_Y_SCALE) !== 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 4)) return;
+			transform = [
+				require_sfnt.f2dot14(glyph, offset),
+				0,
+				0,
+				require_sfnt.f2dot14(glyph, offset + 2)
+			];
+			offset += 4;
+		} else if ((flags & WE_HAVE_A_TWO_BY_TWO) !== 0) {
+			if (!require_sfnt.hasBytes(glyph, offset, 8)) return;
+			transform = [
+				require_sfnt.f2dot14(glyph, offset),
+				require_sfnt.f2dot14(glyph, offset + 2),
+				require_sfnt.f2dot14(glyph, offset + 4),
+				require_sfnt.f2dot14(glyph, offset + 6)
+			];
+			offset += 8;
+		}
+		components.push({
+			flags,
+			glyphIndex,
+			argument1,
+			argument2,
+			argsAreXyValues,
+			transform
+		});
+		if ((flags & MORE_COMPONENTS) === 0) return components;
+	}
+}
+function parseGlyf(font, options) {
+	const glyfBytes = require_sfnt.sfntTableBytes(font, "glyf");
+	const loca = parseLoca(font, options);
+	if (glyfBytes === void 0 || loca === void 0) return;
+	const glyphBytes = (glyphId) => {
+		if (!Number.isInteger(glyphId) || glyphId < 0 || glyphId >= options.numGlyphs) return;
+		const start = loca[glyphId];
+		const end = loca[glyphId + 1];
+		if (end < start || !require_sfnt.hasBytes(glyfBytes, start, end - start)) return;
+		return glyfBytes.subarray(start, end);
+	};
+	const glyphHeader = (glyphId) => {
+		const glyph = glyphBytes(glyphId);
+		if (glyph === void 0 || !require_sfnt.hasBytes(glyph, 0, GLYPH_HEADER_SIZE)) return;
+		return {
+			numberOfContours: require_sfnt.i16(glyph, 0),
+			xMin: require_sfnt.i16(glyph, 2),
+			yMin: require_sfnt.i16(glyph, 4),
+			xMax: require_sfnt.i16(glyph, 6),
+			yMax: require_sfnt.i16(glyph, 8)
+		};
+	};
+	return {
+		numGlyphs: options.numGlyphs,
+		glyphBytes,
+		glyphHeader,
+		compositeComponents(glyphId) {
+			const header = glyphHeader(glyphId);
+			if (header === void 0 || header.numberOfContours >= 0) return;
+			const glyph = glyphBytes(glyphId);
+			return glyph === void 0 ? void 0 : readComponents(glyph);
+		}
+	};
+}
+//#endregion
+exports.parseGlyf = parseGlyf;
+exports.parseLoca = parseLoca;

package/dist/glyf.d.cts

@@ -0,0 +1,31 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/glyf.d.ts
+interface GlyphHeader {
+  readonly numberOfContours: number;
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+}
+interface CompositeComponent {
+  readonly flags: number;
+  readonly glyphIndex: number;
+  readonly argument1: number;
+  readonly argument2: number;
+  readonly argsAreXyValues: boolean;
+  readonly transform: readonly [number, number, number, number] | undefined;
+}
+interface GlyfTable {
+  readonly numGlyphs: number;
+  glyphBytes(glyphId: number): Uint8Array<ArrayBuffer> | undefined;
+  glyphHeader(glyphId: number): GlyphHeader | undefined;
+  compositeComponents(glyphId: number): readonly CompositeComponent[] | undefined;
+}
+interface GlyfOptions {
+  readonly numGlyphs: number;
+  readonly indexToLocFormat: 0 | 1;
+}
+declare function parseLoca(font: SfntFont, options: GlyfOptions): readonly number[] | undefined;
+declare function parseGlyf(font: SfntFont, options: GlyfOptions): GlyfTable | undefined;
+//#endregion
+export { CompositeComponent, GlyfOptions, GlyfTable, GlyphHeader, parseGlyf, parseLoca };

package/dist/glyf.d.ts

@@ -0,0 +1,31 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/glyf.d.ts
+interface GlyphHeader {
+  readonly numberOfContours: number;
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+}
+interface CompositeComponent {
+  readonly flags: number;
+  readonly glyphIndex: number;
+  readonly argument1: number;
+  readonly argument2: number;
+  readonly argsAreXyValues: boolean;
+  readonly transform: readonly [number, number, number, number] | undefined;
+}
+interface GlyfTable {
+  readonly numGlyphs: number;
+  glyphBytes(glyphId: number): Uint8Array<ArrayBuffer> | undefined;
+  glyphHeader(glyphId: number): GlyphHeader | undefined;
+  compositeComponents(glyphId: number): readonly CompositeComponent[] | undefined;
+}
+interface GlyfOptions {
+  readonly numGlyphs: number;
+  readonly indexToLocFormat: 0 | 1;
+}
+declare function parseLoca(font: SfntFont, options: GlyfOptions): readonly number[] | undefined;
+declare function parseGlyf(font: SfntFont, options: GlyfOptions): GlyfTable | undefined;
+//#endregion
+export { CompositeComponent, GlyfOptions, GlyfTable, GlyphHeader, parseGlyf, parseLoca };