pdf-codec 1.7.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,13 +6,15 @@ 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";
 import { ResolvedFont, resolveStandardFont } from "./fonts.cjs";
-import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-YSQUTviw.cjs";
+import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction } from "./math-table-gFNB8DmQ.cjs";
+import { a as assembleStretchyGlyph, i as MathStretchPlacement, n as MathStretchConstruction, o as scaleMathStretchConstruction, r as MathStretchOptions, t as MathStretchAxis } from "./math-stretch-DXWjs8gL.cjs";
+import { a as MathGlyphMetrics, c as MathLayoutItem, d as MathStretchResult, f as MathStroke, i as MathFontMetrics, l as MathRule, n as MathBox, o as MathGlyphPlacement, r as MathColor, s as MathGlyphRun, t as MathAssembledGlyphs, u as MathStretchGlyph } from "./math-types-BZkWO5Ow.cjs";
 import { PositionedFormula } from "./formula.cjs";
 import { CcittFaxImage, CcittFaxOptions, decodeCcittFax } from "./image/ccitt.cjs";
 import { n as Jbig2UnsupportedError, t as Jbig2ParseError } from "./jbig2-errors-Bj6MPxrx.cjs";
@@ -27,8 +29,6 @@ import { PngEncodeOptions, encodePng } from "./image/png-encode.cjs";
 import { PngFilterType, filterScanlines, unfilterScanlines } from "./image/png-filter.cjs";
 import { ReadPdfOptions, readPdf } from "./read.cjs";
 import { WritePdfOptions, writePdf } from "./write.cjs";
-import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction } from "./math-table-gFNB8DmQ.cjs";
-import { a as assembleStretchyGlyph, i as MathStretchPlacement, n as MathStretchConstruction, o as scaleMathStretchConstruction, r as MathStretchOptions, t as MathStretchAxis } from "./math-stretch-DXWjs8gL.cjs";
 import { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont } from "./math-font.cjs";
 import { StyledFragment, StyledRun, WrapOptions, WrappedLine, wrapRunsToWidth } from "./text-layout.cjs";
-export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type DeflateLevel, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type InflateResult, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchOptions, type MathStretchPlacement, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type ProvidedFont, type RawImage, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readJpeg2000Metadata, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, scaleMathStretchConstruction, unfilterScanlines, wrapRunsToWidth, writePdf };
+export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type DeflateLevel, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type InflateResult, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathAssembledGlyphs, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphPlacement, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchGlyph, type MathStretchOptions, type MathStretchPlacement, type MathStretchResult, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type ProvidedFont, type RawImage, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readJpeg2000Metadata, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, scaleMathStretchConstruction, unfilterScanlines, wrapRunsToWidth, writePdf };

package/dist/index.d.ts

@@ -6,13 +6,15 @@ 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";
 import { ResolvedFont, resolveStandardFont } from "./fonts.js";
-import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-YSQUTviw.js";
+import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction } from "./math-table-DhPrNoPa.js";
+import { a as assembleStretchyGlyph, i as MathStretchPlacement, n as MathStretchConstruction, o as scaleMathStretchConstruction, r as MathStretchOptions, t as MathStretchAxis } from "./math-stretch-Bwk_bxh1.js";
+import { a as MathGlyphMetrics, c as MathLayoutItem, d as MathStretchResult, f as MathStroke, i as MathFontMetrics, l as MathRule, n as MathBox, o as MathGlyphPlacement, r as MathColor, s as MathGlyphRun, t as MathAssembledGlyphs, u as MathStretchGlyph } from "./math-types-Bq7tyV4g.js";
 import { PositionedFormula } from "./formula.js";
 import { CcittFaxImage, CcittFaxOptions, decodeCcittFax } from "./image/ccitt.js";
 import { n as Jbig2UnsupportedError, t as Jbig2ParseError } from "./jbig2-errors-Bj6MPxrx.js";
@@ -27,8 +29,6 @@ import { PngEncodeOptions, encodePng } from "./image/png-encode.js";
 import { PngFilterType, filterScanlines, unfilterScanlines } from "./image/png-filter.js";
 import { ReadPdfOptions, readPdf } from "./read.js";
 import { WritePdfOptions, writePdf } from "./write.js";
-import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction } from "./math-table-DhPrNoPa.js";
-import { a as assembleStretchyGlyph, i as MathStretchPlacement, n as MathStretchConstruction, o as scaleMathStretchConstruction, r as MathStretchOptions, t as MathStretchAxis } from "./math-stretch-Bwk_bxh1.js";
 import { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont } from "./math-font.js";
 import { StyledFragment, StyledRun, WrapOptions, WrappedLine, wrapRunsToWidth } from "./text-layout.js";
-export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type DeflateLevel, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type InflateResult, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchOptions, type MathStretchPlacement, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type ProvidedFont, type RawImage, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readJpeg2000Metadata, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, scaleMathStretchConstruction, unfilterScanlines, wrapRunsToWidth, writePdf };
+export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type DeflateLevel, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type InflateResult, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathAssembledGlyphs, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphPlacement, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchGlyph, type MathStretchOptions, type MathStretchPlacement, type MathStretchResult, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type ProvidedFont, type RawImage, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readJpeg2000Metadata, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, scaleMathStretchConstruction, unfilterScanlines, wrapRunsToWidth, writePdf };

package/dist/math-content-write.cjs

@@ -40,6 +40,37 @@ function writeGlyphRun(writer, positioned, item, ctx) {
 	writer.writeAscii(" Tj\n");
 	writer.writeAscii("ET\n");
 }
+function cidBytes(glyphId) {
+	return new Uint8Array([glyphId >> 8 & 255, glyphId & 255]);
+}
+function utf16BeWithBom(text) {
+	const bytes = new Uint8Array(2 + text.length * 2);
+	bytes[0] = 254;
+	bytes[1] = 255;
+	for (let i = 0; i < text.length; i++) {
+		const unit = text.charCodeAt(i);
+		bytes[2 + i * 2] = unit >> 8 & 255;
+		bytes[3 + i * 2] = unit & 255;
+	}
+	return bytes;
+}
+function writeAssembledGlyphs(writer, positioned, item, ctx) {
+	if (item.placements.length === 0) return;
+	require_serialize.writeObject(writer, require_objects.pdfName("Span"));
+	writer.writeAscii(" ");
+	require_serialize.writeObject(writer, require_objects.pdfDict({ ActualText: require_objects.pdfHexString(utf16BeWithBom(item.text)) }));
+	writer.writeAscii(" BDC\n");
+	for (const placement of item.placements) {
+		writer.writeAscii("BT\n");
+		writer.writeAscii(`/${ctx.resourceName} ${require_serialize.formatNumber(item.sizePt)} Tf\n`);
+		writeRgbOperator(writer, item.color, "rg");
+		writer.writeAscii(`1 0 0 1 ${require_serialize.formatNumber(toPdfX(positioned, placement.xPt))} ${require_serialize.formatNumber(toPdfY(positioned, placement.yPt))} Tm\n`);
+		require_serialize.writeObject(writer, require_objects.pdfHexString(cidBytes(placement.glyphId)));
+		writer.writeAscii(" Tj\n");
+		writer.writeAscii("ET\n");
+	}
+	writer.writeAscii("EMC\n");
+}
 function writeRule(writer, positioned, item) {
 	const x = toPdfX(positioned, item.xPt);
 	const topY = toPdfY(positioned, item.yPt);
@@ -62,18 +93,23 @@ function writeFormulaContentStream(formulas, ctx) {
 	const writer = new require_bytes_writer.ByteWriter();
 	for (const positioned of formulas) for (const item of positioned.box.items) if (item.kind === "glyphs") writeGlyphRun(writer, positioned, item, ctx);
 	else if (item.kind === "rule") writeRule(writer, positioned, item);
+	else if (item.kind === "assembled-glyphs") writeAssembledGlyphs(writer, positioned, item, ctx);
 	else writeStroke(writer, positioned, item);
 	return writer.toBytes();
 }
 function collectUsedGlyphs(formulas, font) {
 	const used = /* @__PURE__ */ new Map();
 	for (const positioned of formulas) for (const item of positioned.box.items) {
+		if (item.kind === "assembled-glyphs") {
+			for (const placement of item.placements) if (!used.has(placement.glyphId)) used.set(placement.glyphId, void 0);
+			continue;
+		}
 		if (item.kind !== "glyphs") continue;
 		for (const ch of item.text) {
 			const codePoint = ch.codePointAt(0);
 			if (codePoint === void 0) continue;
 			const glyphId = font.glyphId(codePoint);
-			if (glyphId !== void 0 && !used.has(glyphId)) used.set(glyphId, codePoint);
+			if (glyphId !== void 0 && used.get(glyphId) === void 0) used.set(glyphId, codePoint);
 		}
 	}
 	return used;

package/dist/math-content-write.d.cts

@@ -6,6 +6,6 @@ interface MathContentWriteContext {
   readonly resourceName: string;
 }
 declare function writeFormulaContentStream(formulas: readonly PositionedFormula[], ctx: MathContentWriteContext): Uint8Array<ArrayBuffer>;
-declare function collectUsedGlyphs(formulas: readonly PositionedFormula[], font: MathFont): ReadonlyMap<number, number>;
+declare function collectUsedGlyphs(formulas: readonly PositionedFormula[], font: MathFont): ReadonlyMap<number, number | undefined>;
 //#endregion
 export { MathContentWriteContext, collectUsedGlyphs, writeFormulaContentStream };

package/dist/math-content-write.d.ts

@@ -6,6 +6,6 @@ interface MathContentWriteContext {
   readonly resourceName: string;
 }
 declare function writeFormulaContentStream(formulas: readonly PositionedFormula[], ctx: MathContentWriteContext): Uint8Array<ArrayBuffer>;
-declare function collectUsedGlyphs(formulas: readonly PositionedFormula[], font: MathFont): ReadonlyMap<number, number>;
+declare function collectUsedGlyphs(formulas: readonly PositionedFormula[], font: MathFont): ReadonlyMap<number, number | undefined>;
 //#endregion
 export { MathContentWriteContext, collectUsedGlyphs, writeFormulaContentStream };

package/dist/math-content-write.js

@@ -1,5 +1,5 @@
 import { ByteWriter } from "./bytes/writer.js";
-import { pdfHexString } from "./objects.js";
+import { pdfDict, pdfHexString, pdfName } from "./objects.js";
 import { formatNumber, writeObject } from "./serialize.js";
 //#region src/math-content-write.ts
 function toPdfX(positioned, itemXPt) {
@@ -39,6 +39,37 @@ function writeGlyphRun(writer, positioned, item, ctx) {
 	writer.writeAscii(" Tj\n");
 	writer.writeAscii("ET\n");
 }
+function cidBytes(glyphId) {
+	return new Uint8Array([glyphId >> 8 & 255, glyphId & 255]);
+}
+function utf16BeWithBom(text) {
+	const bytes = new Uint8Array(2 + text.length * 2);
+	bytes[0] = 254;
+	bytes[1] = 255;
+	for (let i = 0; i < text.length; i++) {
+		const unit = text.charCodeAt(i);
+		bytes[2 + i * 2] = unit >> 8 & 255;
+		bytes[3 + i * 2] = unit & 255;
+	}
+	return bytes;
+}
+function writeAssembledGlyphs(writer, positioned, item, ctx) {
+	if (item.placements.length === 0) return;
+	writeObject(writer, pdfName("Span"));
+	writer.writeAscii(" ");
+	writeObject(writer, pdfDict({ ActualText: pdfHexString(utf16BeWithBom(item.text)) }));
+	writer.writeAscii(" BDC\n");
+	for (const placement of item.placements) {
+		writer.writeAscii("BT\n");
+		writer.writeAscii(`/${ctx.resourceName} ${formatNumber(item.sizePt)} Tf\n`);
+		writeRgbOperator(writer, item.color, "rg");
+		writer.writeAscii(`1 0 0 1 ${formatNumber(toPdfX(positioned, placement.xPt))} ${formatNumber(toPdfY(positioned, placement.yPt))} Tm\n`);
+		writeObject(writer, pdfHexString(cidBytes(placement.glyphId)));
+		writer.writeAscii(" Tj\n");
+		writer.writeAscii("ET\n");
+	}
+	writer.writeAscii("EMC\n");
+}
 function writeRule(writer, positioned, item) {
 	const x = toPdfX(positioned, item.xPt);
 	const topY = toPdfY(positioned, item.yPt);
@@ -61,18 +92,23 @@ function writeFormulaContentStream(formulas, ctx) {
 	const writer = new ByteWriter();
 	for (const positioned of formulas) for (const item of positioned.box.items) if (item.kind === "glyphs") writeGlyphRun(writer, positioned, item, ctx);
 	else if (item.kind === "rule") writeRule(writer, positioned, item);
+	else if (item.kind === "assembled-glyphs") writeAssembledGlyphs(writer, positioned, item, ctx);
 	else writeStroke(writer, positioned, item);
 	return writer.toBytes();
 }
 function collectUsedGlyphs(formulas, font) {
 	const used = /* @__PURE__ */ new Map();
 	for (const positioned of formulas) for (const item of positioned.box.items) {
+		if (item.kind === "assembled-glyphs") {
+			for (const placement of item.placements) if (!used.has(placement.glyphId)) used.set(placement.glyphId, void 0);
+			continue;
+		}
 		if (item.kind !== "glyphs") continue;
 		for (const ch of item.text) {
 			const codePoint = ch.codePointAt(0);
 			if (codePoint === void 0) continue;
 			const glyphId = font.glyphId(codePoint);
-			if (glyphId !== void 0 && !used.has(glyphId)) used.set(glyphId, codePoint);
+			if (glyphId !== void 0 && used.get(glyphId) === void 0) used.set(glyphId, codePoint);
 		}
 	}
 	return used;

package/dist/math-font-write.cjs

@@ -38,6 +38,11 @@ function buildFontFileStream(font, compress) {
 	} : { Subtype: require_objects.pdfName("CIDFontType0C") });
 	return require_objects.pdfStream(dict, compress ? require_bytes_flate.deflate(font.cffBytes) : font.cffBytes);
 }
+function toUnicodeEntries(usedGlyphs) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, codePoint);
+	return entries;
+}
 function buildMathFontObjects(font, usedGlyphs, refs, compress) {
 	const cidFont = require_objects.pdfDict({
 		Type: require_objects.pdfName("Font"),
@@ -64,7 +69,7 @@ function buildMathFontObjects(font, usedGlyphs, refs, compress) {
 		cidFont,
 		descriptor: buildFontDescriptor(font, refs.fontFileRef),
 		fontFile: buildFontFileStream(font, compress),
-		toUnicode: require_tounicode.buildToUnicodeCMap(usedGlyphs)
+		toUnicode: require_tounicode.buildToUnicodeCMap(toUnicodeEntries(usedGlyphs))
 	};
 }
 //#endregion