pdf-codec 4.2.0 → 4.4.0

package/dist/gsub-table.cjs

@@ -0,0 +1,225 @@
+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/gsub-table.ts
+const LIGATURE_FEATURE_TAGS = ["liga", "rlig"];
+const GSUB_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 LOOKUP_TYPE_SINGLE_SUBST = 1;
+const LOOKUP_TYPE_LIGATURE_SUBST = 4;
+const LOOKUP_TYPE_EXTENSION_SUBST = 7;
+const EXTENSION_SUBST_HEADER_SIZE = 8;
+const PREFERRED_SCRIPT_TAGS = ["latn", "DFLT"];
+function readTag(bytes, offset) {
+	return String.fromCharCode(require_sfnt.u16(bytes, offset) >> 8, require_sfnt.u16(bytes, offset) & 255, require_sfnt.u16(bytes, offset + 2) >> 8, require_sfnt.u16(bytes, offset + 2) & 255);
+}
+const SINGLE_SUBST_FORMAT_1_SIZE = 6;
+function parseSingleSubstFormat1(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, SINGLE_SUBST_FORMAT_1_SIZE)) return;
+	const coverage = require_ot_layout_common.parseCoverage(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 2));
+	if (coverage === void 0) return;
+	const delta = require_sfnt.i16(bytes, subtableOffset + 4);
+	return {
+		kind: "single",
+		lookup: (glyphId) => {
+			if (coverage.coverageIndex(glyphId) === void 0) return;
+			return glyphId + delta;
+		}
+	};
+}
+const SINGLE_SUBST_FORMAT_2_HEADER_SIZE = 6;
+function parseSingleSubstFormat2(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, SINGLE_SUBST_FORMAT_2_HEADER_SIZE)) return;
+	const coverage = require_ot_layout_common.parseCoverage(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 2));
+	if (coverage === void 0) return;
+	const glyphCount = require_sfnt.u16(bytes, subtableOffset + 4);
+	const substitutesOffset = subtableOffset + SINGLE_SUBST_FORMAT_2_HEADER_SIZE;
+	if (!require_sfnt.hasBytes(bytes, substitutesOffset, glyphCount * 2)) return;
+	return {
+		kind: "single",
+		lookup: (glyphId) => {
+			const coverageIndex = coverage.coverageIndex(glyphId);
+			if (coverageIndex === void 0 || coverageIndex >= glyphCount) return;
+			return require_sfnt.u16(bytes, substitutesOffset + coverageIndex * 2);
+		}
+	};
+}
+const LIGATURE_SUBST_FORMAT_1_HEADER_SIZE = 6;
+const LIGATURE_SET_HEADER_SIZE = 2;
+const LIGATURE_HEADER_PREFIX_SIZE = 4;
+function parseLigatureSubstFormat1(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, LIGATURE_SUBST_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 ligSetCount = require_sfnt.u16(bytes, subtableOffset + 4);
+	const ligSetOffsetsOffset = subtableOffset + LIGATURE_SUBST_FORMAT_1_HEADER_SIZE;
+	if (!require_sfnt.hasBytes(bytes, ligSetOffsetsOffset, ligSetCount * 2)) return;
+	return {
+		kind: "ligature",
+		match: (glyphIds, index) => {
+			const coverageIndex = coverage.coverageIndex(glyphIds[index]);
+			if (coverageIndex === void 0 || coverageIndex >= ligSetCount) return;
+			const ligSetOffset = subtableOffset + require_sfnt.u16(bytes, ligSetOffsetsOffset + coverageIndex * 2);
+			if (!require_sfnt.hasBytes(bytes, ligSetOffset, LIGATURE_SET_HEADER_SIZE)) return;
+			const ligatureCount = require_sfnt.u16(bytes, ligSetOffset);
+			const ligatureOffsetsOffset = ligSetOffset + LIGATURE_SET_HEADER_SIZE;
+			if (!require_sfnt.hasBytes(bytes, ligatureOffsetsOffset, ligatureCount * 2)) return;
+			for (let i = 0; i < ligatureCount; i++) {
+				const ligatureOffset = ligSetOffset + require_sfnt.u16(bytes, ligatureOffsetsOffset + i * 2);
+				if (!require_sfnt.hasBytes(bytes, ligatureOffset, LIGATURE_HEADER_PREFIX_SIZE)) continue;
+				const ligatureGlyph = require_sfnt.u16(bytes, ligatureOffset);
+				const componentCount = require_sfnt.u16(bytes, ligatureOffset + 2);
+				if (componentCount === 0) continue;
+				const componentsOffset = ligatureOffset + LIGATURE_HEADER_PREFIX_SIZE;
+				if (!require_sfnt.hasBytes(bytes, componentsOffset, (componentCount - 1) * 2)) continue;
+				if (index + componentCount > glyphIds.length) continue;
+				let matches = true;
+				for (let c = 1; c < componentCount; c++) if (glyphIds[index + c] !== require_sfnt.u16(bytes, componentsOffset + (c - 1) * 2)) {
+					matches = false;
+					break;
+				}
+				if (matches) return {
+					ligatureGlyph,
+					componentCount
+				};
+			}
+		}
+	};
+}
+function parseSubtable(bytes, lookupType, subtableOffset) {
+	if (lookupType === LOOKUP_TYPE_EXTENSION_SUBST) {
+		if (!require_sfnt.hasBytes(bytes, subtableOffset, EXTENSION_SUBST_HEADER_SIZE) || require_sfnt.u16(bytes, subtableOffset) !== 1) return;
+		const extensionLookupType = require_sfnt.u16(bytes, subtableOffset + 2);
+		if (extensionLookupType === LOOKUP_TYPE_EXTENSION_SUBST) return;
+		return parseSubtable(bytes, extensionLookupType, subtableOffset + require_sfnt.u32(bytes, subtableOffset + 4));
+	}
+	if (lookupType === LOOKUP_TYPE_SINGLE_SUBST) {
+		if (!require_sfnt.hasBytes(bytes, subtableOffset, 2)) return;
+		const substFormat = require_sfnt.u16(bytes, subtableOffset);
+		if (substFormat === 1) return parseSingleSubstFormat1(bytes, subtableOffset);
+		if (substFormat === 2) return parseSingleSubstFormat2(bytes, subtableOffset);
+		return;
+	}
+	if (lookupType === LOOKUP_TYPE_LIGATURE_SUBST) {
+		if (!require_sfnt.hasBytes(bytes, subtableOffset, 2)) return;
+		if (require_sfnt.u16(bytes, subtableOffset) !== 1) return;
+		return parseLigatureSubstFormat1(bytes, subtableOffset);
+	}
+}
+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 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 collectLigatureLookupIndices(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;
+		const tag = readTag(bytes, recordOffset);
+		if (!LIGATURE_FEATURE_TAGS.includes(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 buildGsubShaper(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "GSUB");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, GSUB_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 = collectLigatureLookupIndices(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;
+		const lookupOffset = lookupListOffset + require_sfnt.u16(bytes, lookupOffsetsOffset + lookupIndex * 2);
+		if (!require_sfnt.hasBytes(bytes, lookupOffset, LOOKUP_HEADER_SIZE)) continue;
+		if (require_sfnt.u16(bytes, lookupOffset + 2) !== 0) continue;
+		const lookupType = require_sfnt.u16(bytes, lookupOffset);
+		const subTableCount = require_sfnt.u16(bytes, lookupOffset + 4);
+		const subtableOffsetsOffset = lookupOffset + LOOKUP_HEADER_SIZE;
+		if (!require_sfnt.hasBytes(bytes, subtableOffsetsOffset, subTableCount * 2)) continue;
+		for (let i = 0; i < subTableCount; i++) {
+			const subtable = parseSubtable(bytes, lookupType, lookupOffset + require_sfnt.u16(bytes, subtableOffsetsOffset + i * 2));
+			if (subtable !== void 0) subtables.push(subtable);
+		}
+	}
+	if (subtables.length === 0) return;
+	return (glyphIds) => {
+		const shaped = [];
+		const spans = [];
+		let index = 0;
+		outer: while (index < glyphIds.length) {
+			for (const subtable of subtables) if (subtable.kind === "single") {
+				const substitute = subtable.lookup(glyphIds[index]);
+				if (substitute !== void 0) {
+					shaped.push(substitute);
+					spans.push(1);
+					index += 1;
+					continue outer;
+				}
+			} else {
+				const match = subtable.match(glyphIds, index);
+				if (match !== void 0) {
+					shaped.push(match.ligatureGlyph);
+					spans.push(match.componentCount);
+					index += match.componentCount;
+					continue outer;
+				}
+			}
+			shaped.push(glyphIds[index]);
+			spans.push(1);
+			index += 1;
+		}
+		return {
+			glyphIds: shaped,
+			spans
+		};
+	};
+}
+//#endregion
+exports.buildGsubShaper = buildGsubShaper;

package/dist/gsub-table.d.cts

@@ -0,0 +1,2 @@
+import { n as GsubShaping, r as buildGsubShaper, t as GsubShaper } from "./gsub-table-URczLd85.cjs";
+export { GsubShaper, GsubShaping, buildGsubShaper };

package/dist/gsub-table.d.ts

@@ -0,0 +1,2 @@
+import { n as GsubShaping, r as buildGsubShaper, t as GsubShaper } from "./gsub-table-BRTQ8EUW.js";
+export { GsubShaper, GsubShaping, buildGsubShaper };

package/dist/gsub-table.js

@@ -0,0 +1,224 @@
+import { hasBytes, i16, sfntTableBytes, u16, u32 } from "./sfnt.js";
+import { parseCoverage } from "./ot-layout-common.js";
+//#region src/gsub-table.ts
+const LIGATURE_FEATURE_TAGS = ["liga", "rlig"];
+const GSUB_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 LOOKUP_TYPE_SINGLE_SUBST = 1;
+const LOOKUP_TYPE_LIGATURE_SUBST = 4;
+const LOOKUP_TYPE_EXTENSION_SUBST = 7;
+const EXTENSION_SUBST_HEADER_SIZE = 8;
+const PREFERRED_SCRIPT_TAGS = ["latn", "DFLT"];
+function readTag(bytes, offset) {
+	return String.fromCharCode(u16(bytes, offset) >> 8, u16(bytes, offset) & 255, u16(bytes, offset + 2) >> 8, u16(bytes, offset + 2) & 255);
+}
+const SINGLE_SUBST_FORMAT_1_SIZE = 6;
+function parseSingleSubstFormat1(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, SINGLE_SUBST_FORMAT_1_SIZE)) return;
+	const coverage = parseCoverage(bytes, subtableOffset + u16(bytes, subtableOffset + 2));
+	if (coverage === void 0) return;
+	const delta = i16(bytes, subtableOffset + 4);
+	return {
+		kind: "single",
+		lookup: (glyphId) => {
+			if (coverage.coverageIndex(glyphId) === void 0) return;
+			return glyphId + delta;
+		}
+	};
+}
+const SINGLE_SUBST_FORMAT_2_HEADER_SIZE = 6;
+function parseSingleSubstFormat2(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, SINGLE_SUBST_FORMAT_2_HEADER_SIZE)) return;
+	const coverage = parseCoverage(bytes, subtableOffset + u16(bytes, subtableOffset + 2));
+	if (coverage === void 0) return;
+	const glyphCount = u16(bytes, subtableOffset + 4);
+	const substitutesOffset = subtableOffset + SINGLE_SUBST_FORMAT_2_HEADER_SIZE;
+	if (!hasBytes(bytes, substitutesOffset, glyphCount * 2)) return;
+	return {
+		kind: "single",
+		lookup: (glyphId) => {
+			const coverageIndex = coverage.coverageIndex(glyphId);
+			if (coverageIndex === void 0 || coverageIndex >= glyphCount) return;
+			return u16(bytes, substitutesOffset + coverageIndex * 2);
+		}
+	};
+}
+const LIGATURE_SUBST_FORMAT_1_HEADER_SIZE = 6;
+const LIGATURE_SET_HEADER_SIZE = 2;
+const LIGATURE_HEADER_PREFIX_SIZE = 4;
+function parseLigatureSubstFormat1(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, LIGATURE_SUBST_FORMAT_1_HEADER_SIZE)) return;
+	const coverage = parseCoverage(bytes, subtableOffset + u16(bytes, subtableOffset + 2));
+	if (coverage === void 0) return;
+	const ligSetCount = u16(bytes, subtableOffset + 4);
+	const ligSetOffsetsOffset = subtableOffset + LIGATURE_SUBST_FORMAT_1_HEADER_SIZE;
+	if (!hasBytes(bytes, ligSetOffsetsOffset, ligSetCount * 2)) return;
+	return {
+		kind: "ligature",
+		match: (glyphIds, index) => {
+			const coverageIndex = coverage.coverageIndex(glyphIds[index]);
+			if (coverageIndex === void 0 || coverageIndex >= ligSetCount) return;
+			const ligSetOffset = subtableOffset + u16(bytes, ligSetOffsetsOffset + coverageIndex * 2);
+			if (!hasBytes(bytes, ligSetOffset, LIGATURE_SET_HEADER_SIZE)) return;
+			const ligatureCount = u16(bytes, ligSetOffset);
+			const ligatureOffsetsOffset = ligSetOffset + LIGATURE_SET_HEADER_SIZE;
+			if (!hasBytes(bytes, ligatureOffsetsOffset, ligatureCount * 2)) return;
+			for (let i = 0; i < ligatureCount; i++) {
+				const ligatureOffset = ligSetOffset + u16(bytes, ligatureOffsetsOffset + i * 2);
+				if (!hasBytes(bytes, ligatureOffset, LIGATURE_HEADER_PREFIX_SIZE)) continue;
+				const ligatureGlyph = u16(bytes, ligatureOffset);
+				const componentCount = u16(bytes, ligatureOffset + 2);
+				if (componentCount === 0) continue;
+				const componentsOffset = ligatureOffset + LIGATURE_HEADER_PREFIX_SIZE;
+				if (!hasBytes(bytes, componentsOffset, (componentCount - 1) * 2)) continue;
+				if (index + componentCount > glyphIds.length) continue;
+				let matches = true;
+				for (let c = 1; c < componentCount; c++) if (glyphIds[index + c] !== u16(bytes, componentsOffset + (c - 1) * 2)) {
+					matches = false;
+					break;
+				}
+				if (matches) return {
+					ligatureGlyph,
+					componentCount
+				};
+			}
+		}
+	};
+}
+function parseSubtable(bytes, lookupType, subtableOffset) {
+	if (lookupType === LOOKUP_TYPE_EXTENSION_SUBST) {
+		if (!hasBytes(bytes, subtableOffset, EXTENSION_SUBST_HEADER_SIZE) || u16(bytes, subtableOffset) !== 1) return;
+		const extensionLookupType = u16(bytes, subtableOffset + 2);
+		if (extensionLookupType === LOOKUP_TYPE_EXTENSION_SUBST) return;
+		return parseSubtable(bytes, extensionLookupType, subtableOffset + u32(bytes, subtableOffset + 4));
+	}
+	if (lookupType === LOOKUP_TYPE_SINGLE_SUBST) {
+		if (!hasBytes(bytes, subtableOffset, 2)) return;
+		const substFormat = u16(bytes, subtableOffset);
+		if (substFormat === 1) return parseSingleSubstFormat1(bytes, subtableOffset);
+		if (substFormat === 2) return parseSingleSubstFormat2(bytes, subtableOffset);
+		return;
+	}
+	if (lookupType === LOOKUP_TYPE_LIGATURE_SUBST) {
+		if (!hasBytes(bytes, subtableOffset, 2)) return;
+		if (u16(bytes, subtableOffset) !== 1) return;
+		return parseLigatureSubstFormat1(bytes, subtableOffset);
+	}
+}
+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 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 collectLigatureLookupIndices(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;
+		const tag = readTag(bytes, recordOffset);
+		if (!LIGATURE_FEATURE_TAGS.includes(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 buildGsubShaper(font) {
+	const bytes = sfntTableBytes(font, "GSUB");
+	if (bytes === void 0 || !hasBytes(bytes, 0, GSUB_HEADER_SIZE) || u16(bytes, 0) !== 1) return;
+	const scriptOffset = findScriptOffset(bytes, u16(bytes, 4));
+	if (scriptOffset === void 0) return;
+	const lookupIndices = collectLigatureLookupIndices(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;
+		const lookupOffset = lookupListOffset + u16(bytes, lookupOffsetsOffset + lookupIndex * 2);
+		if (!hasBytes(bytes, lookupOffset, LOOKUP_HEADER_SIZE)) continue;
+		if (u16(bytes, lookupOffset + 2) !== 0) continue;
+		const lookupType = u16(bytes, lookupOffset);
+		const subTableCount = u16(bytes, lookupOffset + 4);
+		const subtableOffsetsOffset = lookupOffset + LOOKUP_HEADER_SIZE;
+		if (!hasBytes(bytes, subtableOffsetsOffset, subTableCount * 2)) continue;
+		for (let i = 0; i < subTableCount; i++) {
+			const subtable = parseSubtable(bytes, lookupType, lookupOffset + u16(bytes, subtableOffsetsOffset + i * 2));
+			if (subtable !== void 0) subtables.push(subtable);
+		}
+	}
+	if (subtables.length === 0) return;
+	return (glyphIds) => {
+		const shaped = [];
+		const spans = [];
+		let index = 0;
+		outer: while (index < glyphIds.length) {
+			for (const subtable of subtables) if (subtable.kind === "single") {
+				const substitute = subtable.lookup(glyphIds[index]);
+				if (substitute !== void 0) {
+					shaped.push(substitute);
+					spans.push(1);
+					index += 1;
+					continue outer;
+				}
+			} else {
+				const match = subtable.match(glyphIds, index);
+				if (match !== void 0) {
+					shaped.push(match.ligatureGlyph);
+					spans.push(match.componentCount);
+					index += match.componentCount;
+					continue outer;
+				}
+			}
+			shaped.push(glyphIds[index]);
+			spans.push(1);
+			index += 1;
+		}
+		return {
+			glyphIds: shaped,
+			spans
+		};
+	};
+}
+//#endregion
+export { buildGsubShaper };

package/dist/index.d.cts

@@ -3,7 +3,7 @@ import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnost
 import { LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema } from "./layout.cjs";
 import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
 import { PdfBytesSchema, pdfCodec } from "./codec.cjs";
-import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
+import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-oc65VGlr.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { PdfEncryptionError, PdfEncryptionOptions, PdfEncryptionPermissions, PdfEncryptionScheme } from "./encrypt-write.cjs";
 import { FontFace, FontFaceParseError, readFontFace } from "./font-face.cjs";

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnost
 import { LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema } from "./layout.js";
 import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
 import { PdfBytesSchema, pdfCodec } from "./codec.js";
-import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
+import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-B4p9a3O3.js";
 import { WinAnsiSubstitution } from "./winansi.js";
 import { PdfEncryptionError, PdfEncryptionOptions, PdfEncryptionPermissions, PdfEncryptionScheme } from "./encrypt-write.js";
 import { FontFace, FontFaceParseError, readFontFace } from "./font-face.js";

package/dist/math-font-write.cjs

@@ -40,7 +40,7 @@ function buildFontFileStream(font, compress) {
 }
 function toUnicodeEntries(usedGlyphs) {
 	const entries = /* @__PURE__ */ new Map();
-	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, codePoint);
+	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, [codePoint]);
 	return entries;
 }
 function buildMathFontObjects(font, usedGlyphs, refs, compress) {

package/dist/math-font-write.js

@@ -39,7 +39,7 @@ function buildFontFileStream(font, compress) {
 }
 function toUnicodeEntries(usedGlyphs) {
 	const entries = /* @__PURE__ */ new Map();
-	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, codePoint);
+	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, [codePoint]);
 	return entries;
 }
 function buildMathFontObjects(font, usedGlyphs, refs, compress) {

package/dist/sfnt-subset.cjs

@@ -71,7 +71,7 @@ function buildPostStub(font) {
 	if (sourcePost !== void 0 && require_sfnt.hasBytes(sourcePost, POST_METRICS_OFFSET, POST_METRICS_SIZE)) post.set(sourcePost.subarray(POST_METRICS_OFFSET, 16), POST_METRICS_OFFSET);
 	return post;
 }
-function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
+function collectGlyphIds(glyf, cmap, numGlyphs, codePoints, extraGlyphIds) {
 	const used = /* @__PURE__ */ new Set([0]);
 	const unmapped = /* @__PURE__ */ new Set();
 	const pending = [0];
@@ -87,6 +87,13 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 			pending.push(glyphId);
 		}
 	}
+	for (const glyphId of extraGlyphIds) {
+		if (glyphId >= numGlyphs) return;
+		if (!used.has(glyphId)) {
+			used.add(glyphId);
+			pending.push(glyphId);
+		}
+	}
 	while (pending.length > 0) {
 		const glyphId = pending.pop();
 		if (glyf.glyphBytes(glyphId) === void 0) return;
@@ -107,7 +114,7 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 		unmapped: [...unmapped].sort((a, b) => a - b)
 	};
 }
-function subsetSfnt(font, codePoints) {
+function subsetSfnt(font, codePoints, extraGlyphIds = []) {
 	const head = require_font_tables.parseHead(font);
 	const maxp = require_font_tables.parseMaxp(font);
 	const sourceHead = require_sfnt.sfntTableBytes(font, "head");
@@ -124,7 +131,7 @@ function subsetSfnt(font, codePoints) {
 	});
 	const cmap = require_cmap_table.buildCmapLookup(font);
 	if (glyf === void 0 || cmap === void 0) return;
-	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints);
+	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints, extraGlyphIds);
 	if (collected === void 0) return;
 	const glyphIds = [...collected.used].sort((a, b) => a - b);
 	const numGlyphs = glyphIds[glyphIds.length - 1] + 1;

package/dist/sfnt-subset.d.cts

@@ -6,6 +6,6 @@ interface SfntSubsetResult {
   readonly glyphIds: readonly number[];
   readonly unmappedCodePoints: readonly number[];
 }
-declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>, extraGlyphIds?: Iterable<number>): SfntSubsetResult | undefined;
 //#endregion
 export { SfntSubsetResult, subsetSfnt };

package/dist/sfnt-subset.d.ts

@@ -6,6 +6,6 @@ interface SfntSubsetResult {
   readonly glyphIds: readonly number[];
   readonly unmappedCodePoints: readonly number[];
 }
-declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>, extraGlyphIds?: Iterable<number>): SfntSubsetResult | undefined;
 //#endregion
 export { SfntSubsetResult, subsetSfnt };

package/dist/sfnt-subset.js

@@ -70,7 +70,7 @@ function buildPostStub(font) {
 	if (sourcePost !== void 0 && hasBytes(sourcePost, POST_METRICS_OFFSET, POST_METRICS_SIZE)) post.set(sourcePost.subarray(POST_METRICS_OFFSET, 16), POST_METRICS_OFFSET);
 	return post;
 }
-function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
+function collectGlyphIds(glyf, cmap, numGlyphs, codePoints, extraGlyphIds) {
 	const used = /* @__PURE__ */ new Set([0]);
 	const unmapped = /* @__PURE__ */ new Set();
 	const pending = [0];
@@ -86,6 +86,13 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 			pending.push(glyphId);
 		}
 	}
+	for (const glyphId of extraGlyphIds) {
+		if (glyphId >= numGlyphs) return;
+		if (!used.has(glyphId)) {
+			used.add(glyphId);
+			pending.push(glyphId);
+		}
+	}
 	while (pending.length > 0) {
 		const glyphId = pending.pop();
 		if (glyf.glyphBytes(glyphId) === void 0) return;
@@ -106,7 +113,7 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 		unmapped: [...unmapped].sort((a, b) => a - b)
 	};
 }
-function subsetSfnt(font, codePoints) {
+function subsetSfnt(font, codePoints, extraGlyphIds = []) {
 	const head = parseHead(font);
 	const maxp = parseMaxp(font);
 	const sourceHead = sfntTableBytes(font, "head");
@@ -123,7 +130,7 @@ function subsetSfnt(font, codePoints) {
 	});
 	const cmap = buildCmapLookup(font);
 	if (glyf === void 0 || cmap === void 0) return;
-	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints);
+	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints, extraGlyphIds);
 	if (collected === void 0) return;
 	const glyphIds = [...collected.used].sort((a, b) => a - b);
 	const numGlyphs = glyphIds[glyphIds.length - 1] + 1;

package/dist/tounicode.cjs

@@ -8,8 +8,13 @@ function codePointToUtf16BEHex(codePoint) {
 	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
 	return hex;
 }
-function buildToUnicodeCMap(codeToCodePoint) {
-	const entries = [...codeToCodePoint].sort((a, b) => a[0] - b[0]);
+function sequenceToUtf16BEHex(codePoints) {
+	let hex = "";
+	for (const codePoint of codePoints) hex += codePointToUtf16BEHex(codePoint);
+	return hex;
+}
+function buildToUnicodeCMap(codeToSequence) {
+	const entries = [...codeToSequence].sort((a, b) => a[0] - b[0]);
 	const lines = [
 		"/CIDInit /ProcSet findresource begin",
 		"12 dict begin",
@@ -24,7 +29,7 @@ function buildToUnicodeCMap(codeToCodePoint) {
 	for (let start = 0; start < entries.length; start += MAX_BFCHAR_ENTRIES_PER_BLOCK) {
 		const block = entries.slice(start, start + MAX_BFCHAR_ENTRIES_PER_BLOCK);
 		lines.push(`${block.length} beginbfchar`);
-		for (const [code, codePoint] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+		for (const [code, sequence] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${sequenceToUtf16BEHex(sequence)}>`);
 		lines.push("endbfchar");
 	}
 	lines.push("endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");

package/dist/tounicode.d.cts

@@ -1,5 +1,5 @@
 import { r as PdfObject } from "./objects-B7HdMeWS.cjs";
 //#region src/tounicode.d.ts
-declare function buildToUnicodeCMap(codeToCodePoint: ReadonlyMap<number, number>): PdfObject;
+declare function buildToUnicodeCMap(codeToSequence: ReadonlyMap<number, readonly number[]>): PdfObject;
 //#endregion
 export { buildToUnicodeCMap };

package/dist/tounicode.d.ts

@@ -1,5 +1,5 @@
 import { r as PdfObject } from "./objects-B7HdMeWS.js";
 //#region src/tounicode.d.ts
-declare function buildToUnicodeCMap(codeToCodePoint: ReadonlyMap<number, number>): PdfObject;
+declare function buildToUnicodeCMap(codeToSequence: ReadonlyMap<number, readonly number[]>): PdfObject;
 //#endregion
 export { buildToUnicodeCMap };

package/dist/tounicode.js

@@ -7,8 +7,13 @@ function codePointToUtf16BEHex(codePoint) {
 	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
 	return hex;
 }
-function buildToUnicodeCMap(codeToCodePoint) {
-	const entries = [...codeToCodePoint].sort((a, b) => a[0] - b[0]);
+function sequenceToUtf16BEHex(codePoints) {
+	let hex = "";
+	for (const codePoint of codePoints) hex += codePointToUtf16BEHex(codePoint);
+	return hex;
+}
+function buildToUnicodeCMap(codeToSequence) {
+	const entries = [...codeToSequence].sort((a, b) => a[0] - b[0]);
 	const lines = [
 		"/CIDInit /ProcSet findresource begin",
 		"12 dict begin",
@@ -23,7 +28,7 @@ function buildToUnicodeCMap(codeToCodePoint) {
 	for (let start = 0; start < entries.length; start += MAX_BFCHAR_ENTRIES_PER_BLOCK) {
 		const block = entries.slice(start, start + MAX_BFCHAR_ENTRIES_PER_BLOCK);
 		lines.push(`${block.length} beginbfchar`);
-		for (const [code, codePoint] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+		for (const [code, sequence] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${sequenceToUtf16BEHex(sequence)}>`);
 		lines.push("endbfchar");
 	}
 	lines.push("endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");