pdf-codec 1.8.0 → 1.9.0

package/dist/gpos-table.cjs

@@ -0,0 +1,189 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+const require_ot_layout_common = require("./ot-layout-common.cjs");
+//#region src/gpos-table.ts
+const GPOS_HEADER_SIZE = 10;
+const SCRIPT_RECORD_SIZE = 6;
+const FEATURE_RECORD_SIZE = 6;
+const LANG_SYS_HEADER_SIZE = 6;
+const FEATURE_HEADER_SIZE = 4;
+const LOOKUP_HEADER_SIZE = 6;
+const EXTENSION_POS_HEADER_SIZE = 8;
+const LOOKUP_TYPE_PAIR_POS = 2;
+const LOOKUP_TYPE_EXTENSION_POS = 9;
+const KERN_FEATURE_TAG = "kern";
+const PREFERRED_SCRIPT_TAGS = ["latn", "DFLT"];
+function readTag(bytes, offset) {
+	return String.fromCharCode(require_sfnt.u8(bytes, offset), require_sfnt.u8(bytes, offset + 1), require_sfnt.u8(bytes, offset + 2), require_sfnt.u8(bytes, offset + 3));
+}
+function valueRecordSize(valueFormat) {
+	let size = 0;
+	for (let bit = valueFormat; bit !== 0; bit >>= 1) size += (bit & 1) * 2;
+	return size;
+}
+const VALUE_FORMAT_X_ADVANCE = 4;
+function xAdvanceOffset(valueFormat) {
+	if ((valueFormat & VALUE_FORMAT_X_ADVANCE) === 0) return;
+	return valueRecordSize(valueFormat & 3);
+}
+const PAIR_POS_FORMAT_1_HEADER_SIZE = 10;
+const PAIR_VALUE_RECORD_GLYPH_SIZE = 2;
+function parsePairPosFormat1(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, PAIR_POS_FORMAT_1_HEADER_SIZE)) return;
+	const coverage = require_ot_layout_common.parseCoverage(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 2));
+	if (coverage === void 0) return;
+	const valueFormat1 = require_sfnt.u16(bytes, subtableOffset + 4);
+	const valueFormat2 = require_sfnt.u16(bytes, subtableOffset + 6);
+	const pairSetCount = require_sfnt.u16(bytes, subtableOffset + 8);
+	const pairSetOffsetsOffset = subtableOffset + PAIR_POS_FORMAT_1_HEADER_SIZE;
+	if (!require_sfnt.hasBytes(bytes, pairSetOffsetsOffset, pairSetCount * 2)) return;
+	const recordSize = PAIR_VALUE_RECORD_GLYPH_SIZE + valueRecordSize(valueFormat1) + valueRecordSize(valueFormat2);
+	const advanceOffset = xAdvanceOffset(valueFormat1);
+	return (leftGlyphId, rightGlyphId) => {
+		const coverageIndex = coverage.coverageIndex(leftGlyphId);
+		if (coverageIndex === void 0 || coverageIndex >= pairSetCount) return;
+		const pairSetOffset = subtableOffset + require_sfnt.u16(bytes, pairSetOffsetsOffset + coverageIndex * 2);
+		if (!require_sfnt.hasBytes(bytes, pairSetOffset, 2)) return;
+		const pairValueCount = require_sfnt.u16(bytes, pairSetOffset);
+		const recordsOffset = pairSetOffset + 2;
+		if (!require_sfnt.hasBytes(bytes, recordsOffset, pairValueCount * recordSize)) return;
+		let low = 0;
+		let high = pairValueCount - 1;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			const recordOffset = recordsOffset + mid * recordSize;
+			const secondGlyph = require_sfnt.u16(bytes, recordOffset);
+			if (rightGlyphId < secondGlyph) high = mid - 1;
+			else if (rightGlyphId > secondGlyph) low = mid + 1;
+			else return advanceOffset === void 0 ? 0 : require_sfnt.i16(bytes, recordOffset + PAIR_VALUE_RECORD_GLYPH_SIZE + advanceOffset);
+		}
+	};
+}
+const PAIR_POS_FORMAT_2_HEADER_SIZE = 16;
+function parsePairPosFormat2(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, PAIR_POS_FORMAT_2_HEADER_SIZE)) return;
+	const coverage = require_ot_layout_common.parseCoverage(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 2));
+	const classDef1 = require_ot_layout_common.parseClassDef(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 8));
+	const classDef2 = require_ot_layout_common.parseClassDef(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 10));
+	if (coverage === void 0 || classDef1 === void 0 || classDef2 === void 0) return;
+	const valueFormat1 = require_sfnt.u16(bytes, subtableOffset + 4);
+	const valueFormat2 = require_sfnt.u16(bytes, subtableOffset + 6);
+	const class1Count = require_sfnt.u16(bytes, subtableOffset + 12);
+	const class2Count = require_sfnt.u16(bytes, subtableOffset + 14);
+	const class2RecordSize = valueRecordSize(valueFormat1) + valueRecordSize(valueFormat2);
+	const class1RecordSize = class2Count * class2RecordSize;
+	const matrixOffset = subtableOffset + PAIR_POS_FORMAT_2_HEADER_SIZE;
+	if (!require_sfnt.hasBytes(bytes, matrixOffset, class1Count * class1RecordSize)) return;
+	const advanceOffset = xAdvanceOffset(valueFormat1);
+	return (leftGlyphId, rightGlyphId) => {
+		if (coverage.coverageIndex(leftGlyphId) === void 0) return;
+		const class1 = classDef1(leftGlyphId);
+		const class2 = classDef2(rightGlyphId);
+		if (class1 >= class1Count || class2 >= class2Count) return;
+		if (advanceOffset === void 0) return 0;
+		return require_sfnt.i16(bytes, matrixOffset + class1 * class1RecordSize + class2 * class2RecordSize + advanceOffset);
+	};
+}
+function parseSubtable(bytes, lookupType, subtableOffset) {
+	if (lookupType === LOOKUP_TYPE_EXTENSION_POS) {
+		if (!require_sfnt.hasBytes(bytes, subtableOffset, EXTENSION_POS_HEADER_SIZE) || require_sfnt.u16(bytes, subtableOffset) !== 1) return;
+		const extensionLookupType = require_sfnt.u16(bytes, subtableOffset + 2);
+		if (extensionLookupType === LOOKUP_TYPE_EXTENSION_POS) return;
+		return parseSubtable(bytes, extensionLookupType, subtableOffset + require_sfnt.u32(bytes, subtableOffset + 4));
+	}
+	if (lookupType !== LOOKUP_TYPE_PAIR_POS) return;
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, 2)) return;
+	const posFormat = require_sfnt.u16(bytes, subtableOffset);
+	if (posFormat === 1) return parsePairPosFormat1(bytes, subtableOffset);
+	if (posFormat === 2) return parsePairPosFormat2(bytes, subtableOffset);
+}
+function parseLookupSubtables(bytes, lookupOffset) {
+	if (!require_sfnt.hasBytes(bytes, lookupOffset, LOOKUP_HEADER_SIZE)) return [];
+	const lookupType = require_sfnt.u16(bytes, lookupOffset);
+	const subTableCount = require_sfnt.u16(bytes, lookupOffset + 4);
+	const offsetsOffset = lookupOffset + LOOKUP_HEADER_SIZE;
+	if (!require_sfnt.hasBytes(bytes, offsetsOffset, subTableCount * 2)) return [];
+	const subtables = [];
+	for (let i = 0; i < subTableCount; i++) {
+		const subtable = parseSubtable(bytes, lookupType, lookupOffset + require_sfnt.u16(bytes, offsetsOffset + i * 2));
+		if (subtable !== void 0) subtables.push(subtable);
+	}
+	return subtables;
+}
+function parseDefaultLangSysFeatureIndices(bytes, scriptOffset) {
+	if (!require_sfnt.hasBytes(bytes, scriptOffset, 2)) return [];
+	const defaultLangSysOffset = require_sfnt.u16(bytes, scriptOffset);
+	if (defaultLangSysOffset === 0) return [];
+	const langSysOffset = scriptOffset + defaultLangSysOffset;
+	if (!require_sfnt.hasBytes(bytes, langSysOffset, LANG_SYS_HEADER_SIZE)) return [];
+	const featureIndexCount = require_sfnt.u16(bytes, langSysOffset + 4);
+	const indicesOffset = langSysOffset + LANG_SYS_HEADER_SIZE;
+	if (!require_sfnt.hasBytes(bytes, indicesOffset, featureIndexCount * 2)) return [];
+	const indices = [];
+	for (let i = 0; i < featureIndexCount; i++) indices.push(require_sfnt.u16(bytes, indicesOffset + i * 2));
+	return indices;
+}
+function findScriptOffset(bytes, scriptListOffset) {
+	if (!require_sfnt.hasBytes(bytes, scriptListOffset, 2)) return;
+	const scriptCount = require_sfnt.u16(bytes, scriptListOffset);
+	const recordsOffset = scriptListOffset + 2;
+	if (!require_sfnt.hasBytes(bytes, recordsOffset, scriptCount * SCRIPT_RECORD_SIZE) || scriptCount === 0) return;
+	for (const wanted of PREFERRED_SCRIPT_TAGS) for (let i = 0; i < scriptCount; i++) {
+		const recordOffset = recordsOffset + i * SCRIPT_RECORD_SIZE;
+		if (readTag(bytes, recordOffset) === wanted) return scriptListOffset + require_sfnt.u16(bytes, recordOffset + 4);
+	}
+	return scriptListOffset + require_sfnt.u16(bytes, recordsOffset + 4);
+}
+function collectKernLookupIndices(bytes, featureListOffset, featureIndices) {
+	if (!require_sfnt.hasBytes(bytes, featureListOffset, 2)) return [];
+	const featureCount = require_sfnt.u16(bytes, featureListOffset);
+	const recordsOffset = featureListOffset + 2;
+	if (!require_sfnt.hasBytes(bytes, recordsOffset, featureCount * FEATURE_RECORD_SIZE)) return [];
+	const lookupIndices = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const featureIndex of featureIndices) {
+		if (featureIndex >= featureCount) continue;
+		const recordOffset = recordsOffset + featureIndex * FEATURE_RECORD_SIZE;
+		if (readTag(bytes, recordOffset) !== KERN_FEATURE_TAG) continue;
+		const featureOffset = featureListOffset + require_sfnt.u16(bytes, recordOffset + 4);
+		if (!require_sfnt.hasBytes(bytes, featureOffset, FEATURE_HEADER_SIZE)) continue;
+		const lookupIndexCount = require_sfnt.u16(bytes, featureOffset + 2);
+		const indicesOffset = featureOffset + FEATURE_HEADER_SIZE;
+		if (!require_sfnt.hasBytes(bytes, indicesOffset, lookupIndexCount * 2)) continue;
+		for (let i = 0; i < lookupIndexCount; i++) {
+			const lookupIndex = require_sfnt.u16(bytes, indicesOffset + i * 2);
+			if (!seen.has(lookupIndex)) {
+				seen.add(lookupIndex);
+				lookupIndices.push(lookupIndex);
+			}
+		}
+	}
+	return lookupIndices;
+}
+function buildGposKernLookup(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "GPOS");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, GPOS_HEADER_SIZE) || require_sfnt.u16(bytes, 0) !== 1) return;
+	const scriptOffset = findScriptOffset(bytes, require_sfnt.u16(bytes, 4));
+	if (scriptOffset === void 0) return;
+	const lookupIndices = collectKernLookupIndices(bytes, require_sfnt.u16(bytes, 6), parseDefaultLangSysFeatureIndices(bytes, scriptOffset));
+	if (lookupIndices.length === 0) return;
+	const lookupListOffset = require_sfnt.u16(bytes, 8);
+	if (!require_sfnt.hasBytes(bytes, lookupListOffset, 2)) return;
+	const lookupCount = require_sfnt.u16(bytes, lookupListOffset);
+	const lookupOffsetsOffset = lookupListOffset + 2;
+	if (!require_sfnt.hasBytes(bytes, lookupOffsetsOffset, lookupCount * 2)) return;
+	const subtables = [];
+	for (const lookupIndex of lookupIndices) {
+		if (lookupIndex >= lookupCount) continue;
+		subtables.push(...parseLookupSubtables(bytes, lookupListOffset + require_sfnt.u16(bytes, lookupOffsetsOffset + lookupIndex * 2)));
+	}
+	if (subtables.length === 0) return;
+	return (leftGlyphId, rightGlyphId) => {
+		for (const subtable of subtables) {
+			const adjustment = subtable(leftGlyphId, rightGlyphId);
+			if (adjustment !== void 0) return adjustment;
+		}
+	};
+}
+//#endregion
+exports.buildGposKernLookup = buildGposKernLookup;

package/dist/gpos-table.d.cts

@@ -0,0 +1,6 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/gpos-table.d.ts
+type GposKernLookup = (leftGlyphId: number, rightGlyphId: number) => number | undefined;
+declare function buildGposKernLookup(font: SfntFont): GposKernLookup | undefined;
+//#endregion
+export { GposKernLookup, buildGposKernLookup };

package/dist/gpos-table.d.ts

@@ -0,0 +1,6 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/gpos-table.d.ts
+type GposKernLookup = (leftGlyphId: number, rightGlyphId: number) => number | undefined;
+declare function buildGposKernLookup(font: SfntFont): GposKernLookup | undefined;
+//#endregion
+export { GposKernLookup, buildGposKernLookup };

package/dist/gpos-table.js

@@ -0,0 +1,188 @@
+import { hasBytes, i16, sfntTableBytes, u16, u32, u8 } from "./sfnt.js";
+import { parseClassDef, parseCoverage } from "./ot-layout-common.js";
+//#region src/gpos-table.ts
+const GPOS_HEADER_SIZE = 10;
+const SCRIPT_RECORD_SIZE = 6;
+const FEATURE_RECORD_SIZE = 6;
+const LANG_SYS_HEADER_SIZE = 6;
+const FEATURE_HEADER_SIZE = 4;
+const LOOKUP_HEADER_SIZE = 6;
+const EXTENSION_POS_HEADER_SIZE = 8;
+const LOOKUP_TYPE_PAIR_POS = 2;
+const LOOKUP_TYPE_EXTENSION_POS = 9;
+const KERN_FEATURE_TAG = "kern";
+const PREFERRED_SCRIPT_TAGS = ["latn", "DFLT"];
+function readTag(bytes, offset) {
+	return String.fromCharCode(u8(bytes, offset), u8(bytes, offset + 1), u8(bytes, offset + 2), u8(bytes, offset + 3));
+}
+function valueRecordSize(valueFormat) {
+	let size = 0;
+	for (let bit = valueFormat; bit !== 0; bit >>= 1) size += (bit & 1) * 2;
+	return size;
+}
+const VALUE_FORMAT_X_ADVANCE = 4;
+function xAdvanceOffset(valueFormat) {
+	if ((valueFormat & VALUE_FORMAT_X_ADVANCE) === 0) return;
+	return valueRecordSize(valueFormat & 3);
+}
+const PAIR_POS_FORMAT_1_HEADER_SIZE = 10;
+const PAIR_VALUE_RECORD_GLYPH_SIZE = 2;
+function parsePairPosFormat1(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, PAIR_POS_FORMAT_1_HEADER_SIZE)) return;
+	const coverage = parseCoverage(bytes, subtableOffset + u16(bytes, subtableOffset + 2));
+	if (coverage === void 0) return;
+	const valueFormat1 = u16(bytes, subtableOffset + 4);
+	const valueFormat2 = u16(bytes, subtableOffset + 6);
+	const pairSetCount = u16(bytes, subtableOffset + 8);
+	const pairSetOffsetsOffset = subtableOffset + PAIR_POS_FORMAT_1_HEADER_SIZE;
+	if (!hasBytes(bytes, pairSetOffsetsOffset, pairSetCount * 2)) return;
+	const recordSize = PAIR_VALUE_RECORD_GLYPH_SIZE + valueRecordSize(valueFormat1) + valueRecordSize(valueFormat2);
+	const advanceOffset = xAdvanceOffset(valueFormat1);
+	return (leftGlyphId, rightGlyphId) => {
+		const coverageIndex = coverage.coverageIndex(leftGlyphId);
+		if (coverageIndex === void 0 || coverageIndex >= pairSetCount) return;
+		const pairSetOffset = subtableOffset + u16(bytes, pairSetOffsetsOffset + coverageIndex * 2);
+		if (!hasBytes(bytes, pairSetOffset, 2)) return;
+		const pairValueCount = u16(bytes, pairSetOffset);
+		const recordsOffset = pairSetOffset + 2;
+		if (!hasBytes(bytes, recordsOffset, pairValueCount * recordSize)) return;
+		let low = 0;
+		let high = pairValueCount - 1;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			const recordOffset = recordsOffset + mid * recordSize;
+			const secondGlyph = u16(bytes, recordOffset);
+			if (rightGlyphId < secondGlyph) high = mid - 1;
+			else if (rightGlyphId > secondGlyph) low = mid + 1;
+			else return advanceOffset === void 0 ? 0 : i16(bytes, recordOffset + PAIR_VALUE_RECORD_GLYPH_SIZE + advanceOffset);
+		}
+	};
+}
+const PAIR_POS_FORMAT_2_HEADER_SIZE = 16;
+function parsePairPosFormat2(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, PAIR_POS_FORMAT_2_HEADER_SIZE)) return;
+	const coverage = parseCoverage(bytes, subtableOffset + u16(bytes, subtableOffset + 2));
+	const classDef1 = parseClassDef(bytes, subtableOffset + u16(bytes, subtableOffset + 8));
+	const classDef2 = parseClassDef(bytes, subtableOffset + u16(bytes, subtableOffset + 10));
+	if (coverage === void 0 || classDef1 === void 0 || classDef2 === void 0) return;
+	const valueFormat1 = u16(bytes, subtableOffset + 4);
+	const valueFormat2 = u16(bytes, subtableOffset + 6);
+	const class1Count = u16(bytes, subtableOffset + 12);
+	const class2Count = u16(bytes, subtableOffset + 14);
+	const class2RecordSize = valueRecordSize(valueFormat1) + valueRecordSize(valueFormat2);
+	const class1RecordSize = class2Count * class2RecordSize;
+	const matrixOffset = subtableOffset + PAIR_POS_FORMAT_2_HEADER_SIZE;
+	if (!hasBytes(bytes, matrixOffset, class1Count * class1RecordSize)) return;
+	const advanceOffset = xAdvanceOffset(valueFormat1);
+	return (leftGlyphId, rightGlyphId) => {
+		if (coverage.coverageIndex(leftGlyphId) === void 0) return;
+		const class1 = classDef1(leftGlyphId);
+		const class2 = classDef2(rightGlyphId);
+		if (class1 >= class1Count || class2 >= class2Count) return;
+		if (advanceOffset === void 0) return 0;
+		return i16(bytes, matrixOffset + class1 * class1RecordSize + class2 * class2RecordSize + advanceOffset);
+	};
+}
+function parseSubtable(bytes, lookupType, subtableOffset) {
+	if (lookupType === LOOKUP_TYPE_EXTENSION_POS) {
+		if (!hasBytes(bytes, subtableOffset, EXTENSION_POS_HEADER_SIZE) || u16(bytes, subtableOffset) !== 1) return;
+		const extensionLookupType = u16(bytes, subtableOffset + 2);
+		if (extensionLookupType === LOOKUP_TYPE_EXTENSION_POS) return;
+		return parseSubtable(bytes, extensionLookupType, subtableOffset + u32(bytes, subtableOffset + 4));
+	}
+	if (lookupType !== LOOKUP_TYPE_PAIR_POS) return;
+	if (!hasBytes(bytes, subtableOffset, 2)) return;
+	const posFormat = u16(bytes, subtableOffset);
+	if (posFormat === 1) return parsePairPosFormat1(bytes, subtableOffset);
+	if (posFormat === 2) return parsePairPosFormat2(bytes, subtableOffset);
+}
+function parseLookupSubtables(bytes, lookupOffset) {
+	if (!hasBytes(bytes, lookupOffset, LOOKUP_HEADER_SIZE)) return [];
+	const lookupType = u16(bytes, lookupOffset);
+	const subTableCount = u16(bytes, lookupOffset + 4);
+	const offsetsOffset = lookupOffset + LOOKUP_HEADER_SIZE;
+	if (!hasBytes(bytes, offsetsOffset, subTableCount * 2)) return [];
+	const subtables = [];
+	for (let i = 0; i < subTableCount; i++) {
+		const subtable = parseSubtable(bytes, lookupType, lookupOffset + u16(bytes, offsetsOffset + i * 2));
+		if (subtable !== void 0) subtables.push(subtable);
+	}
+	return subtables;
+}
+function parseDefaultLangSysFeatureIndices(bytes, scriptOffset) {
+	if (!hasBytes(bytes, scriptOffset, 2)) return [];
+	const defaultLangSysOffset = u16(bytes, scriptOffset);
+	if (defaultLangSysOffset === 0) return [];
+	const langSysOffset = scriptOffset + defaultLangSysOffset;
+	if (!hasBytes(bytes, langSysOffset, LANG_SYS_HEADER_SIZE)) return [];
+	const featureIndexCount = u16(bytes, langSysOffset + 4);
+	const indicesOffset = langSysOffset + LANG_SYS_HEADER_SIZE;
+	if (!hasBytes(bytes, indicesOffset, featureIndexCount * 2)) return [];
+	const indices = [];
+	for (let i = 0; i < featureIndexCount; i++) indices.push(u16(bytes, indicesOffset + i * 2));
+	return indices;
+}
+function findScriptOffset(bytes, scriptListOffset) {
+	if (!hasBytes(bytes, scriptListOffset, 2)) return;
+	const scriptCount = u16(bytes, scriptListOffset);
+	const recordsOffset = scriptListOffset + 2;
+	if (!hasBytes(bytes, recordsOffset, scriptCount * SCRIPT_RECORD_SIZE) || scriptCount === 0) return;
+	for (const wanted of PREFERRED_SCRIPT_TAGS) for (let i = 0; i < scriptCount; i++) {
+		const recordOffset = recordsOffset + i * SCRIPT_RECORD_SIZE;
+		if (readTag(bytes, recordOffset) === wanted) return scriptListOffset + u16(bytes, recordOffset + 4);
+	}
+	return scriptListOffset + u16(bytes, recordsOffset + 4);
+}
+function collectKernLookupIndices(bytes, featureListOffset, featureIndices) {
+	if (!hasBytes(bytes, featureListOffset, 2)) return [];
+	const featureCount = u16(bytes, featureListOffset);
+	const recordsOffset = featureListOffset + 2;
+	if (!hasBytes(bytes, recordsOffset, featureCount * FEATURE_RECORD_SIZE)) return [];
+	const lookupIndices = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const featureIndex of featureIndices) {
+		if (featureIndex >= featureCount) continue;
+		const recordOffset = recordsOffset + featureIndex * FEATURE_RECORD_SIZE;
+		if (readTag(bytes, recordOffset) !== KERN_FEATURE_TAG) continue;
+		const featureOffset = featureListOffset + u16(bytes, recordOffset + 4);
+		if (!hasBytes(bytes, featureOffset, FEATURE_HEADER_SIZE)) continue;
+		const lookupIndexCount = u16(bytes, featureOffset + 2);
+		const indicesOffset = featureOffset + FEATURE_HEADER_SIZE;
+		if (!hasBytes(bytes, indicesOffset, lookupIndexCount * 2)) continue;
+		for (let i = 0; i < lookupIndexCount; i++) {
+			const lookupIndex = u16(bytes, indicesOffset + i * 2);
+			if (!seen.has(lookupIndex)) {
+				seen.add(lookupIndex);
+				lookupIndices.push(lookupIndex);
+			}
+		}
+	}
+	return lookupIndices;
+}
+function buildGposKernLookup(font) {
+	const bytes = sfntTableBytes(font, "GPOS");
+	if (bytes === void 0 || !hasBytes(bytes, 0, GPOS_HEADER_SIZE) || u16(bytes, 0) !== 1) return;
+	const scriptOffset = findScriptOffset(bytes, u16(bytes, 4));
+	if (scriptOffset === void 0) return;
+	const lookupIndices = collectKernLookupIndices(bytes, u16(bytes, 6), parseDefaultLangSysFeatureIndices(bytes, scriptOffset));
+	if (lookupIndices.length === 0) return;
+	const lookupListOffset = u16(bytes, 8);
+	if (!hasBytes(bytes, lookupListOffset, 2)) return;
+	const lookupCount = u16(bytes, lookupListOffset);
+	const lookupOffsetsOffset = lookupListOffset + 2;
+	if (!hasBytes(bytes, lookupOffsetsOffset, lookupCount * 2)) return;
+	const subtables = [];
+	for (const lookupIndex of lookupIndices) {
+		if (lookupIndex >= lookupCount) continue;
+		subtables.push(...parseLookupSubtables(bytes, lookupListOffset + u16(bytes, lookupOffsetsOffset + lookupIndex * 2)));
+	}
+	if (subtables.length === 0) return;
+	return (leftGlyphId, rightGlyphId) => {
+		for (const subtable of subtables) {
+			const adjustment = subtable(leftGlyphId, rightGlyphId);
+			if (adjustment !== void 0) return adjustment;
+		}
+	};
+}
+//#endregion
+export { buildGposKernLookup };

package/dist/index.d.cts

@@ -6,8 +6,8 @@ import { ByteWriter, concatBytes } from "./bytes/writer.cjs";
 import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
 import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError } from "./diagnostics.cjs";
 import { PdfBytesSchema, pdfCodec } from "./codec.cjs";
-import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CLedn-mT.cjs";
-import { a as ResolvedFace, i as ProvidedFont, n as FontRegistryOptions, o as createFontRegistry, r as FontSubstitution, s as resolveFaceWithRegistry, t as FontRegistry } from "./font-registry-yby02snZ.cjs";
+import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
+import { a as ResolvedFace, i as ProvidedFont, n as FontRegistryOptions, o as createFontRegistry, r as FontSubstitution, s as resolveFaceWithRegistry, t as FontRegistry } from "./font-registry-B5qL0Vi0.cjs";
 import { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, VerticalMetricPolicy, createFontMeasurer, createStandardFontMeasurer } from "./measure.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { i as Point, u as rotatePointAboutCenter } from "./matrix-BHzJESll.cjs";

package/dist/index.d.ts

@@ -6,8 +6,8 @@ import { ByteWriter, concatBytes } from "./bytes/writer.js";
 import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
 import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError } from "./diagnostics.js";
 import { PdfBytesSchema, pdfCodec } from "./codec.js";
-import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CbqkKgBl.js";
-import { a as ResolvedFace, i as ProvidedFont, n as FontRegistryOptions, o as createFontRegistry, r as FontSubstitution, s as resolveFaceWithRegistry, t as FontRegistry } from "./font-registry-Cn7P9lAh.js";
+import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
+import { a as ResolvedFace, i as ProvidedFont, n as FontRegistryOptions, o as createFontRegistry, r as FontSubstitution, s as resolveFaceWithRegistry, t as FontRegistry } from "./font-registry-mgdbNP8_.js";
 import { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, VerticalMetricPolicy, createFontMeasurer, createStandardFontMeasurer } from "./measure.js";
 import { WinAnsiSubstitution } from "./winansi.js";
 import { i as Point, u as rotatePointAboutCenter } from "./matrix-BHzJESll.js";

package/dist/math-table.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sfnt = require("./sfnt.cjs");
+const require_ot_layout_common = require("./ot-layout-common.cjs");
 //#region src/math-table.ts
 const MATH_VALUE_RECORD_INDEX = {
 	axisHeight: 1,
@@ -72,28 +73,11 @@ function parseMathConstants(bytes, mathTableOffset) {
 		radicalDegreeBottomRaisePercent: require_sfnt.i16(bytes, constantsOffset + RADICAL_DEGREE_BOTTOM_RAISE_PERCENT_OFFSET)
 	};
 }
-function parseCoverageIndex(bytes, coverageOffset) {
-	const format = require_sfnt.u16(bytes, coverageOffset);
-	const index = /* @__PURE__ */ new Map();
-	if (format === 1) {
-		const glyphCount = require_sfnt.u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < glyphCount; i++) index.set(require_sfnt.u16(bytes, coverageOffset + 4 + i * 2), i);
-	} else if (format === 2) {
-		const rangeCount = require_sfnt.u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < rangeCount; i++) {
-			const recordOffset = coverageOffset + 4 + i * 6;
-			const startGlyphId = require_sfnt.u16(bytes, recordOffset);
-			const endGlyphId = require_sfnt.u16(bytes, recordOffset + 2);
-			const startCoverageIndex = require_sfnt.u16(bytes, recordOffset + 4);
-			for (let glyphId = startGlyphId; glyphId <= endGlyphId; glyphId++) index.set(glyphId, startCoverageIndex + (glyphId - startGlyphId));
-		}
-	}
-	return index;
-}
 function parseGlyphValueTable(bytes, tableOffset) {
-	const coverage = parseCoverageIndex(bytes, tableOffset + require_sfnt.u16(bytes, tableOffset));
+	const coverage = require_ot_layout_common.parseCoverage(bytes, tableOffset + require_sfnt.u16(bytes, tableOffset));
 	const values = /* @__PURE__ */ new Map();
-	for (const [glyphId, coverageIndex] of coverage) values.set(glyphId, require_sfnt.i16(bytes, tableOffset + 4 + coverageIndex * 4));
+	if (coverage === void 0) return values;
+	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, require_sfnt.i16(bytes, tableOffset + 4 + coverageIndex * 4));
 	return values;
 }
 function parseMathGlyphInfo(bytes, mathTableOffset) {
@@ -146,7 +130,9 @@ function parseGlyphConstruction(bytes, constructionOffset) {
 function parseConstructionsForAxis(bytes, variantsOffset, coverageOffset, count, constructionArrayOffset) {
 	const constructions = /* @__PURE__ */ new Map();
 	if (coverageOffset === 0) return constructions;
-	for (const [glyphId, coverageIndex] of parseCoverageIndex(bytes, variantsOffset + coverageOffset)) {
+	const coverage = require_ot_layout_common.parseCoverage(bytes, variantsOffset + coverageOffset);
+	if (coverage === void 0) return constructions;
+	for (const [glyphId, coverageIndex] of coverage.entries()) {
 		if (coverageIndex >= count) continue;
 		constructions.set(glyphId, parseGlyphConstruction(bytes, variantsOffset + require_sfnt.u16(bytes, constructionArrayOffset + coverageIndex * 2)));
 	}

package/dist/math-table.js

@@ -1,4 +1,5 @@
 import { i16, sfntTableBytes, u16 } from "./sfnt.js";
+import { parseCoverage } from "./ot-layout-common.js";
 //#region src/math-table.ts
 const MATH_VALUE_RECORD_INDEX = {
 	axisHeight: 1,
@@ -71,28 +72,11 @@ function parseMathConstants(bytes, mathTableOffset) {
 		radicalDegreeBottomRaisePercent: i16(bytes, constantsOffset + RADICAL_DEGREE_BOTTOM_RAISE_PERCENT_OFFSET)
 	};
 }
-function parseCoverageIndex(bytes, coverageOffset) {
-	const format = u16(bytes, coverageOffset);
-	const index = /* @__PURE__ */ new Map();
-	if (format === 1) {
-		const glyphCount = u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < glyphCount; i++) index.set(u16(bytes, coverageOffset + 4 + i * 2), i);
-	} else if (format === 2) {
-		const rangeCount = u16(bytes, coverageOffset + 2);
-		for (let i = 0; i < rangeCount; i++) {
-			const recordOffset = coverageOffset + 4 + i * 6;
-			const startGlyphId = u16(bytes, recordOffset);
-			const endGlyphId = u16(bytes, recordOffset + 2);
-			const startCoverageIndex = u16(bytes, recordOffset + 4);
-			for (let glyphId = startGlyphId; glyphId <= endGlyphId; glyphId++) index.set(glyphId, startCoverageIndex + (glyphId - startGlyphId));
-		}
-	}
-	return index;
-}
 function parseGlyphValueTable(bytes, tableOffset) {
-	const coverage = parseCoverageIndex(bytes, tableOffset + u16(bytes, tableOffset));
+	const coverage = parseCoverage(bytes, tableOffset + u16(bytes, tableOffset));
 	const values = /* @__PURE__ */ new Map();
-	for (const [glyphId, coverageIndex] of coverage) values.set(glyphId, i16(bytes, tableOffset + 4 + coverageIndex * 4));
+	if (coverage === void 0) return values;
+	for (const [glyphId, coverageIndex] of coverage.entries()) values.set(glyphId, i16(bytes, tableOffset + 4 + coverageIndex * 4));
 	return values;
 }
 function parseMathGlyphInfo(bytes, mathTableOffset) {
@@ -145,7 +129,9 @@ function parseGlyphConstruction(bytes, constructionOffset) {
 function parseConstructionsForAxis(bytes, variantsOffset, coverageOffset, count, constructionArrayOffset) {
 	const constructions = /* @__PURE__ */ new Map();
 	if (coverageOffset === 0) return constructions;
-	for (const [glyphId, coverageIndex] of parseCoverageIndex(bytes, variantsOffset + coverageOffset)) {
+	const coverage = parseCoverage(bytes, variantsOffset + coverageOffset);
+	if (coverage === void 0) return constructions;
+	for (const [glyphId, coverageIndex] of coverage.entries()) {
 		if (coverageIndex >= count) continue;
 		constructions.set(glyphId, parseGlyphConstruction(bytes, variantsOffset + u16(bytes, constructionArrayOffset + coverageIndex * 2)));
 	}

package/dist/measure.d.cts

@@ -1,4 +1,4 @@
-import { t as FontRegistry } from "./font-registry-yby02snZ.cjs";
+import { t as FontRegistry } from "./font-registry-B5qL0Vi0.cjs";
 import { LayoutFont } from "document-schema.js";
 //#region src/measure.d.ts
 interface UnderlineMetrics {

package/dist/measure.d.ts

@@ -1,4 +1,4 @@
-import { t as FontRegistry } from "./font-registry-Cn7P9lAh.js";
+import { t as FontRegistry } from "./font-registry-mgdbNP8_.js";
 import { LayoutFont } from "document-schema.js";
 //#region src/measure.d.ts
 interface UnderlineMetrics {

package/dist/ot-layout-common.cjs

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/ot-layout-common.ts
+function findRange(ranges, glyphId) {
+	let low = 0;
+	let high = ranges.length - 1;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		const range = ranges[mid];
+		if (glyphId < range.startGlyphId) high = mid - 1;
+		else if (glyphId > range.endGlyphId) low = mid + 1;
+		else return range;
+	}
+}
+function pushGlyph(ranges, glyphId, value, valueStep) {
+	const previous = ranges[ranges.length - 1];
+	if (previous !== void 0 && glyphId === previous.endGlyphId + 1 && value === previous.value + (previous.endGlyphId - previous.startGlyphId + 1) * valueStep) {
+		ranges[ranges.length - 1] = {
+			startGlyphId: previous.startGlyphId,
+			endGlyphId: glyphId,
+			value: previous.value
+		};
+		return;
+	}
+	ranges.push({
+		startGlyphId: glyphId,
+		endGlyphId: glyphId,
+		value
+	});
+}
+const RANGE_RECORD_SIZE = 6;
+function parseRangeRecords(bytes, recordsOffset, recordCount) {
+	if (!require_sfnt.hasBytes(bytes, recordsOffset, recordCount * RANGE_RECORD_SIZE)) return;
+	const ranges = [];
+	for (let i = 0; i < recordCount; i++) {
+		const recordOffset = recordsOffset + i * RANGE_RECORD_SIZE;
+		const startGlyphId = require_sfnt.u16(bytes, recordOffset);
+		const endGlyphId = require_sfnt.u16(bytes, recordOffset + 2);
+		if (endGlyphId < startGlyphId) continue;
+		ranges.push({
+			startGlyphId,
+			endGlyphId,
+			value: require_sfnt.u16(bytes, recordOffset + 4)
+		});
+	}
+	ranges.sort((a, b) => a.startGlyphId - b.startGlyphId);
+	return ranges;
+}
+const COVERAGE_HEADER_SIZE = 4;
+function parseCoverage(bytes, coverageOffset) {
+	if (!require_sfnt.hasBytes(bytes, coverageOffset, COVERAGE_HEADER_SIZE)) return;
+	const format = require_sfnt.u16(bytes, coverageOffset);
+	const count = require_sfnt.u16(bytes, coverageOffset + 2);
+	let ranges;
+	if (format === 1) {
+		const glyphArrayOffset = coverageOffset + COVERAGE_HEADER_SIZE;
+		if (!require_sfnt.hasBytes(bytes, glyphArrayOffset, count * 2)) return;
+		ranges = [];
+		for (let i = 0; i < count; i++) pushGlyph(ranges, require_sfnt.u16(bytes, glyphArrayOffset + i * 2), i, 1);
+		ranges.sort((a, b) => a.startGlyphId - b.startGlyphId);
+	} else if (format === 2) ranges = parseRangeRecords(bytes, coverageOffset + COVERAGE_HEADER_SIZE, count);
+	if (ranges === void 0) return;
+	const resolved = ranges;
+	return {
+		coverageIndex(glyphId) {
+			const range = findRange(resolved, glyphId);
+			return range === void 0 ? void 0 : range.value + (glyphId - range.startGlyphId);
+		},
+		*entries() {
+			for (const range of resolved) for (let glyphId = range.startGlyphId; glyphId <= range.endGlyphId; glyphId++) yield [glyphId, range.value + (glyphId - range.startGlyphId)];
+		}
+	};
+}
+const CLASS_DEF_FORMAT_1_HEADER_SIZE = 6;
+const CLASS_DEF_FORMAT_2_HEADER_SIZE = 4;
+function parseClassDef(bytes, classDefOffset) {
+	if (!require_sfnt.hasBytes(bytes, classDefOffset, CLASS_DEF_FORMAT_2_HEADER_SIZE)) return;
+	const format = require_sfnt.u16(bytes, classDefOffset);
+	let ranges;
+	if (format === 1) {
+		if (!require_sfnt.hasBytes(bytes, classDefOffset, CLASS_DEF_FORMAT_1_HEADER_SIZE)) return;
+		const startGlyphId = require_sfnt.u16(bytes, classDefOffset + 2);
+		const glyphCount = require_sfnt.u16(bytes, classDefOffset + 4);
+		const classArrayOffset = classDefOffset + CLASS_DEF_FORMAT_1_HEADER_SIZE;
+		if (!require_sfnt.hasBytes(bytes, classArrayOffset, glyphCount * 2)) return;
+		ranges = [];
+		for (let i = 0; i < glyphCount; i++) pushGlyph(ranges, startGlyphId + i, require_sfnt.u16(bytes, classArrayOffset + i * 2), 0);
+	} else if (format === 2) ranges = parseRangeRecords(bytes, classDefOffset + CLASS_DEF_FORMAT_2_HEADER_SIZE, require_sfnt.u16(bytes, classDefOffset + 2));
+	if (ranges === void 0) return;
+	const resolved = ranges;
+	return (glyphId) => findRange(resolved, glyphId)?.value ?? 0;
+}
+//#endregion
+exports.parseClassDef = parseClassDef;
+exports.parseCoverage = parseCoverage;

package/dist/ot-layout-common.d.cts

@@ -0,0 +1,10 @@
+//#region src/ot-layout-common.d.ts
+interface CoverageTable {
+  coverageIndex(glyphId: number): number | undefined;
+  entries(): IterableIterator<readonly [number, number]>;
+}
+declare function parseCoverage(bytes: Uint8Array<ArrayBuffer>, coverageOffset: number): CoverageTable | undefined;
+type ClassDefTable = (glyphId: number) => number;
+declare function parseClassDef(bytes: Uint8Array<ArrayBuffer>, classDefOffset: number): ClassDefTable | undefined;
+//#endregion
+export { ClassDefTable, CoverageTable, parseClassDef, parseCoverage };

package/dist/ot-layout-common.d.ts

@@ -0,0 +1,10 @@
+//#region src/ot-layout-common.d.ts
+interface CoverageTable {
+  coverageIndex(glyphId: number): number | undefined;
+  entries(): IterableIterator<readonly [number, number]>;
+}
+declare function parseCoverage(bytes: Uint8Array<ArrayBuffer>, coverageOffset: number): CoverageTable | undefined;
+type ClassDefTable = (glyphId: number) => number;
+declare function parseClassDef(bytes: Uint8Array<ArrayBuffer>, classDefOffset: number): ClassDefTable | undefined;
+//#endregion
+export { ClassDefTable, CoverageTable, parseClassDef, parseCoverage };