pdf-parser.js 4.5.6 → 4.7.0

package/dist/gsub-table.js

@@ -1,7 +1,14 @@
 import { hasBytes, i16, sfntTableBytes, u16, u32 } from "./sfnt.js";
-import { parseCoverage } from "./ot-layout-common.js";
+import { parseClassDef, parseCoverage } from "./ot-layout-common.js";
+import { parseGdefTable } from "./gdef-table.js";
 //#region src/gsub-table.ts
-const LIGATURE_FEATURE_TAGS = ["liga", "rlig"];
+const DEFAULT_GSUB_FEATURE_TAGS = [
+	"liga",
+	"rlig",
+	"calt",
+	"clig"
+];
+const GSUB_OPT_IN_FEATURE_TAGS = ["smcp", "dlig"];
 const GSUB_HEADER_SIZE = 10;
 const SCRIPT_RECORD_SIZE = 6;
 const FEATURE_RECORD_SIZE = 6;
@@ -10,105 +17,411 @@ 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_CONTEXT_SUBST = 5;
+const LOOKUP_TYPE_CHAIN_CONTEXT_SUBST = 6;
 const LOOKUP_TYPE_EXTENSION_SUBST = 7;
 const EXTENSION_SUBST_HEADER_SIZE = 8;
+const LOOKUP_FLAG_IGNORE_BASE_GLYPHS = 2;
+const LOOKUP_FLAG_IGNORE_LIGATURES = 4;
+const LOOKUP_FLAG_IGNORE_MARKS = 8;
+const LOOKUP_FLAG_USE_MARK_FILTERING_SET = 16;
+const LOOKUP_FLAG_MARK_ATTACHMENT_TYPE = 65280;
+const MAX_LOOKUP_NESTING_DEPTH = 6;
 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);
 }
+function glyphSkipper(lookupFlag, markFilteringSet, gdef) {
+	if (gdef === void 0 || lookupFlag === 0) return () => false;
+	const ignoreBase = (lookupFlag & LOOKUP_FLAG_IGNORE_BASE_GLYPHS) !== 0;
+	const ignoreLigatures = (lookupFlag & LOOKUP_FLAG_IGNORE_LIGATURES) !== 0;
+	const ignoreMarks = (lookupFlag & LOOKUP_FLAG_IGNORE_MARKS) !== 0;
+	const markAttachmentType = (lookupFlag & LOOKUP_FLAG_MARK_ATTACHMENT_TYPE) >> 8;
+	const useMarkFilteringSet = (lookupFlag & LOOKUP_FLAG_USE_MARK_FILTERING_SET) !== 0;
+	return (glyphId) => {
+		const glyphClass = gdef.glyphClass(glyphId);
+		if (ignoreBase && glyphClass === 1) return true;
+		if (ignoreLigatures && glyphClass === 2) return true;
+		if (glyphClass !== 3) return false;
+		if (ignoreMarks) return true;
+		if (markAttachmentType !== 0 && gdef.markAttachClass(glyphId) !== markAttachmentType) return true;
+		return useMarkFilteringSet && !gdef.markFilteringSetCovers(markFilteringSet, glyphId);
+	};
+}
+function nextVisibleSlot(slots, from, skip) {
+	for (let i = Math.max(from, 0); i < slots.length; i++) if (!skip(slots[i].glyphId)) return i;
+}
+function prevVisibleSlot(slots, before, skip) {
+	for (let i = Math.min(before, slots.length) - 1; i >= 0; i--) if (!skip(slots[i].glyphId)) return i;
+}
 const SINGLE_SUBST_FORMAT_1_SIZE = 6;
-function parseSingleSubstFormat1(bytes, subtableOffset) {
+function parseSingleSubstFormat1(bytes, subtableOffset, skip) {
 	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;
-		}
+	return (slots, index) => {
+		const slot = slots[index];
+		if (skip(slot.glyphId)) return;
+		if (coverage.coverageIndex(slot.glyphId) === void 0) return;
+		return {
+			consumed: 1,
+			replacement: [{
+				glyphId: slot.glyphId + delta,
+				span: slot.span
+			}]
+		};
 	};
 }
 const SINGLE_SUBST_FORMAT_2_HEADER_SIZE = 6;
-function parseSingleSubstFormat2(bytes, subtableOffset) {
+function parseSingleSubstFormat2(bytes, subtableOffset, skip) {
 	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);
-		}
+	return (slots, index) => {
+		const slot = slots[index];
+		if (skip(slot.glyphId)) return;
+		const coverageIndex = coverage.coverageIndex(slot.glyphId);
+		if (coverageIndex === void 0 || coverageIndex >= glyphCount) return;
+		return {
+			consumed: 1,
+			replacement: [{
+				glyphId: u16(bytes, substitutesOffset + coverageIndex * 2),
+				span: slot.span
+			}]
+		};
 	};
 }
 const LIGATURE_SUBST_FORMAT_1_HEADER_SIZE = 6;
 const LIGATURE_SET_HEADER_SIZE = 2;
 const LIGATURE_HEADER_PREFIX_SIZE = 4;
-function parseLigatureSubstFormat1(bytes, subtableOffset) {
+function parseLigatureSubstFormat1(bytes, subtableOffset, skip) {
 	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)) {
+	return (slots, index) => {
+		const first = slots[index];
+		if (skip(first.glyphId)) return;
+		const coverageIndex = coverage.coverageIndex(first.glyphId);
+		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;
+			const matchedSlots = [index];
+			let cursor = index;
+			let matches = true;
+			for (let c = 1; c < componentCount; c++) {
+				const next = nextVisibleSlot(slots, cursor + 1, skip);
+				if (next === void 0 || slots[next].glyphId !== u16(bytes, componentsOffset + (c - 1) * 2)) {
 					matches = false;
 					break;
 				}
-				if (matches) return {
-					ligatureGlyph,
-					componentCount
-				};
+				matchedSlots.push(next);
+				cursor = next;
+			}
+			if (!matches) continue;
+			const lastSlot = matchedSlots[matchedSlots.length - 1];
+			let windowSpan = 0;
+			const retained = [];
+			for (let s = index; s <= lastSlot; s++) {
+				windowSpan += slots[s].span;
+				if (skip(slots[s].glyphId)) retained.push({
+					glyphId: slots[s].glyphId,
+					span: 0
+				});
 			}
+			return {
+				consumed: lastSlot - index + 1,
+				replacement: [{
+					glyphId: ligatureGlyph,
+					span: windowSpan
+				}, ...retained]
+			};
 		}
 	};
 }
-function parseSubtable(bytes, lookupType, subtableOffset) {
+function matchContextualRule(slots, index, skip, backtrack, inputTests, lookahead) {
+	const inputSlots = [index];
+	let cursor = index;
+	for (const test of inputTests) {
+		const next = nextVisibleSlot(slots, cursor + 1, skip);
+		if (next === void 0 || !test(slots[next].glyphId)) return;
+		inputSlots.push(next);
+		cursor = next;
+	}
+	let back = index;
+	for (let b = backtrack.length - 1; b >= 0; b--) {
+		const previous = prevVisibleSlot(slots, back, skip);
+		if (previous === void 0 || !backtrack[b](slots[previous].glyphId)) return;
+		back = previous;
+	}
+	let ahead = inputSlots[inputSlots.length - 1];
+	for (const test of lookahead) {
+		const next = nextVisibleSlot(slots, ahead + 1, skip);
+		if (next === void 0 || !test(slots[next].glyphId)) return;
+		ahead = next;
+	}
+	return inputSlots;
+}
+function applyContextualRule(slots, inputSlots, records, lookupOf, skip, depth) {
+	const first = inputSlots[0];
+	const last = inputSlots[inputSlots.length - 1];
+	const window = [];
+	for (let s = first; s <= last; s++) window.push({
+		glyphId: slots[s].glyphId,
+		span: slots[s].span
+	});
+	for (const record of records) {
+		const lookup = lookupOf(record.lookupIndex);
+		if (lookup === void 0 || record.sequenceIndex >= inputSlots.length || depth >= MAX_LOOKUP_NESTING_DEPTH) return;
+		const target = visibleInputSlot(window, record.sequenceIndex, skip);
+		if (target !== void 0) applyLookupAtSlot(window, target, lookup, depth + 1);
+	}
+	return {
+		consumed: last - first + 1,
+		replacement: window
+	};
+}
+function visibleInputSlot(window, position, skip) {
+	let seen = 0;
+	for (let i = 0; i < window.length; i++) {
+		if (skip(window[i].glyphId)) continue;
+		if (seen === position) return i;
+		seen += 1;
+	}
+}
+function applyLookupAtSlot(slots, index, lookup, depth) {
+	for (const subtable of lookup.subtables) {
+		const application = subtable(slots, index, depth);
+		if (application !== void 0) {
+			slots.splice(index, application.consumed, ...application.replacement);
+			return application.replacement.length;
+		}
+	}
+	return 0;
+}
+const SUBST_LOOKUP_RECORD_SIZE = 4;
+function readSubstLookupRecords(bytes, offset, count) {
+	if (!hasBytes(bytes, offset, count * SUBST_LOOKUP_RECORD_SIZE)) return;
+	const records = [];
+	for (let i = 0; i < count; i++) {
+		const recordOffset = offset + i * SUBST_LOOKUP_RECORD_SIZE;
+		records.push({
+			sequenceIndex: u16(bytes, recordOffset),
+			lookupIndex: u16(bytes, recordOffset + 2)
+		});
+	}
+	return records;
+}
+function parseFormat3Rule(bytes, subtableOffset, chained) {
+	let offset = subtableOffset + 2;
+	const backtrack = [];
+	const input = [];
+	const lookahead = [];
+	const readCoverageArray = () => {
+		if (!hasBytes(bytes, offset, 2)) return;
+		const count = u16(bytes, offset);
+		offset += 2;
+		if (!hasBytes(bytes, offset, count * 2)) return;
+		const coverages = [];
+		for (let i = 0; i < count; i++) {
+			const coverageOffset = u16(bytes, offset + i * 2);
+			if (coverageOffset === 0) return;
+			const coverage = parseCoverage(bytes, subtableOffset + coverageOffset);
+			if (coverage === void 0) return;
+			coverages.push(coverage);
+		}
+		offset += count * 2;
+		return coverages;
+	};
+	if (chained) {
+		const backtracks = readCoverageArray();
+		if (backtracks === void 0) return;
+		backtrack.push(...backtracks);
+	}
+	{
+		const inputs = readCoverageArray();
+		if (inputs === void 0 || inputs.length === 0) return;
+		input.push(...inputs);
+	}
+	if (chained) {
+		const lookaheads = readCoverageArray();
+		if (lookaheads === void 0) return;
+		lookahead.push(...lookaheads);
+	}
+	if (!hasBytes(bytes, offset, 2)) return;
+	const substCount = u16(bytes, offset);
+	const records = readSubstLookupRecords(bytes, offset + 2, substCount);
+	if (records === void 0) return;
+	return {
+		backtrack,
+		input,
+		lookahead,
+		records
+	};
+}
+function format3Subtable(rule, skip, lookupOf) {
+	const inputRest = [];
+	for (let i = 1; i < rule.input.length; i++) {
+		const coverage = rule.input[i];
+		inputRest.push((glyphId) => coverage.coverageIndex(glyphId) !== void 0);
+	}
+	const backtrack = rule.backtrack.map((coverage) => (glyphId) => coverage.coverageIndex(glyphId) !== void 0);
+	const lookahead = rule.lookahead.map((coverage) => (glyphId) => coverage.coverageIndex(glyphId) !== void 0);
+	return (slots, index, depth) => {
+		const slot = slots[index];
+		if (skip(slot.glyphId)) return;
+		if (rule.input[0].coverageIndex(slot.glyphId) === void 0) return;
+		const inputSlots = matchContextualRule(slots, index, skip, backtrack, inputRest, lookahead);
+		if (inputSlots === void 0) return;
+		return applyContextualRule(slots, inputSlots, rule.records, lookupOf, skip, depth);
+	};
+}
+function readSequenceRule(bytes, ruleOffset, chained) {
+	let offset = ruleOffset;
+	const readU16 = () => {
+		if (!hasBytes(bytes, offset, 2)) return;
+		const value = u16(bytes, offset);
+		offset += 2;
+		return value;
+	};
+	const readArray = () => {
+		const count = readU16();
+		if (count === void 0 || !hasBytes(bytes, offset, count * 2)) return;
+		const values = [];
+		for (let i = 0; i < count; i++) values.push(u16(bytes, offset + i * 2));
+		offset += count * 2;
+		return values;
+	};
+	const backtrack = chained ? readArray() : [];
+	const glyphCount = readU16();
+	if (backtrack === void 0 || glyphCount === void 0 || glyphCount === 0 || !hasBytes(bytes, offset, (glyphCount - 1) * 2)) return;
+	const input = [];
+	for (let i = 0; i < glyphCount - 1; i++) input.push(u16(bytes, offset + i * 2));
+	offset += (glyphCount - 1) * 2;
+	const lookahead = chained ? readArray() : [];
+	const substCount = readU16();
+	if (lookahead === void 0 || substCount === void 0) return;
+	const records = readSubstLookupRecords(bytes, offset, substCount);
+	if (records === void 0) return;
+	return {
+		backtrack,
+		input,
+		lookahead,
+		records
+	};
+}
+function sequenceSubtable(bytes, subtableOffset, coverage, setCount, setOffsetsOffset, chained, access, skip, lookupOf) {
+	const readSet = (entryGlyphId) => {
+		const setIndex = access.setIndexOf(entryGlyphId);
+		if (setIndex === void 0 || setIndex >= setCount) return [];
+		const setOffset = u16(bytes, setOffsetsOffset + setIndex * 2);
+		if (setOffset === 0) return [];
+		const ruleSetOffset = subtableOffset + setOffset;
+		if (!hasBytes(bytes, ruleSetOffset, 2)) return [];
+		const ruleCount = u16(bytes, ruleSetOffset);
+		if (!hasBytes(bytes, ruleSetOffset + 2, ruleCount * 2)) return [];
+		const rules = [];
+		for (let i = 0; i < ruleCount; i++) {
+			const rule = readSequenceRule(bytes, ruleSetOffset + u16(bytes, ruleSetOffset + 2 + i * 2), chained);
+			if (rule !== void 0) rules.push(rule);
+		}
+		return rules;
+	};
+	return (slots, index, depth) => {
+		const slot = slots[index];
+		if (skip(slot.glyphId)) return;
+		if (coverage.coverageIndex(slot.glyphId) === void 0) return;
+		for (const rule of readSet(slot.glyphId)) {
+			const inputSlots = matchContextualRule(slots, index, skip, rule.backtrack.map(access.backtrackTest), rule.input.map(access.inputTest), rule.lookahead.map(access.lookaheadTest));
+			if (inputSlots !== void 0) return applyContextualRule(slots, inputSlots, rule.records, lookupOf, skip, depth);
+		}
+	};
+}
+function parseSubtable(bytes, lookupType, subtableOffset, skip, lookupOf) {
 	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));
+		return parseSubtable(bytes, extensionLookupType, subtableOffset + u32(bytes, subtableOffset + 4), skip, lookupOf);
 	}
 	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);
+		if (substFormat === 1) return parseSingleSubstFormat1(bytes, subtableOffset, skip);
+		if (substFormat === 2) return parseSingleSubstFormat2(bytes, subtableOffset, skip);
 		return;
 	}
 	if (lookupType === LOOKUP_TYPE_LIGATURE_SUBST) {
 		if (!hasBytes(bytes, subtableOffset, 2)) return;
 		if (u16(bytes, subtableOffset) !== 1) return;
-		return parseLigatureSubstFormat1(bytes, subtableOffset);
+		return parseLigatureSubstFormat1(bytes, subtableOffset, skip);
+	}
+	if (lookupType === LOOKUP_TYPE_CONTEXT_SUBST || lookupType === LOOKUP_TYPE_CHAIN_CONTEXT_SUBST) return parseContextualSubtable(bytes, lookupType === LOOKUP_TYPE_CHAIN_CONTEXT_SUBST, subtableOffset, skip, lookupOf);
+}
+function parseContextualSubtable(bytes, chained, subtableOffset, skip, lookupOf) {
+	if (!hasBytes(bytes, subtableOffset, 2)) return;
+	const substFormat = u16(bytes, subtableOffset);
+	if (substFormat === 3) {
+		const rule = parseFormat3Rule(bytes, subtableOffset, chained);
+		return rule === void 0 ? void 0 : format3Subtable(rule, skip, lookupOf);
+	}
+	if (substFormat === 1) {
+		const prefixSize = 6;
+		if (!hasBytes(bytes, subtableOffset, prefixSize)) return;
+		const coverage = parseCoverage(bytes, subtableOffset + u16(bytes, subtableOffset + 2));
+		if (coverage === void 0) return;
+		const setCount = u16(bytes, subtableOffset + 4);
+		const setOffsetsOffset = subtableOffset + prefixSize;
+		if (!hasBytes(bytes, setOffsetsOffset, setCount * 2)) return;
+		const glyphEquality = (expected) => (glyphId) => glyphId === expected;
+		return sequenceSubtable(bytes, subtableOffset, coverage, setCount, setOffsetsOffset, chained, {
+			setIndexOf: (entryGlyphId) => coverage.coverageIndex(entryGlyphId),
+			backtrackTest: glyphEquality,
+			inputTest: glyphEquality,
+			lookaheadTest: glyphEquality
+		}, skip, lookupOf);
+	}
+	if (substFormat === 2) {
+		const prefixSize = chained ? 12 : 8;
+		if (!hasBytes(bytes, subtableOffset, prefixSize)) return;
+		const coverage = parseCoverage(bytes, subtableOffset + u16(bytes, subtableOffset + 2));
+		if (coverage === void 0) return;
+		const inputClassDefOffset = chained ? u16(bytes, subtableOffset + 6) : u16(bytes, subtableOffset + 4);
+		const inputClassDef = inputClassDefOffset === 0 ? constantZeroClassDef : parseClassDef(bytes, subtableOffset + inputClassDefOffset);
+		const readAuxClassDef = (offset) => offset === 0 ? constantZeroClassDef : parseClassDef(bytes, subtableOffset + offset);
+		const backtrackClassDef = chained ? readAuxClassDef(u16(bytes, subtableOffset + 4)) : constantZeroClassDef;
+		const lookaheadClassDef = chained ? readAuxClassDef(u16(bytes, subtableOffset + 8)) : constantZeroClassDef;
+		if (inputClassDef === void 0 || backtrackClassDef === void 0 || lookaheadClassDef === void 0) return;
+		const setCount = u16(bytes, subtableOffset + prefixSize - 2);
+		const setOffsetsOffset = subtableOffset + prefixSize;
+		if (!hasBytes(bytes, setOffsetsOffset, setCount * 2)) return;
+		const classEquality = (classDef, expected) => (glyphId) => classDef(glyphId) === expected;
+		return sequenceSubtable(bytes, subtableOffset, coverage, setCount, setOffsetsOffset, chained, {
+			setIndexOf: (entryGlyphId) => inputClassDef(entryGlyphId),
+			backtrackTest: (expected) => classEquality(backtrackClassDef, expected),
+			inputTest: (expected) => classEquality(inputClassDef, expected),
+			lookaheadTest: (expected) => classEquality(lookaheadClassDef, expected)
+		}, skip, lookupOf);
 	}
 }
+const constantZeroClassDef = () => 0;
 function findScriptOffset(bytes, scriptListOffset) {
 	if (!hasBytes(bytes, scriptListOffset, 2)) return;
 	const scriptCount = u16(bytes, scriptListOffset);
@@ -133,7 +446,7 @@ function parseDefaultLangSysFeatureIndices(bytes, scriptOffset) {
 	for (let i = 0; i < featureIndexCount; i++) indices.push(u16(bytes, indicesOffset + i * 2));
 	return indices;
 }
-function collectLigatureLookupIndices(bytes, featureListOffset, featureIndices) {
+function collectLookupIndices(bytes, featureListOffset, featureIndices, featureTags) {
 	if (!hasBytes(bytes, featureListOffset, 2)) return [];
 	const featureCount = u16(bytes, featureListOffset);
 	const recordsOffset = featureListOffset + 2;
@@ -143,8 +456,7 @@ function collectLigatureLookupIndices(bytes, featureListOffset, featureIndices)
 	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;
+		if (!featureTags.includes(readTag(bytes, recordOffset))) continue;
 		const featureOffset = featureListOffset + u16(bytes, recordOffset + 4);
 		if (!hasBytes(bytes, featureOffset, FEATURE_HEADER_SIZE)) continue;
 		const lookupIndexCount = u16(bytes, featureOffset + 2);
@@ -160,65 +472,68 @@ function collectLigatureLookupIndices(bytes, featureListOffset, featureIndices)
 	}
 	return lookupIndices;
 }
-function buildGsubShaper(font) {
+function buildGsubShaper(font, options = {}) {
 	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));
+	const featureTags = [...DEFAULT_GSUB_FEATURE_TAGS, ...options.optInFeatures ?? []];
+	const lookupIndices = collectLookupIndices(bytes, u16(bytes, 6), parseDefaultLangSysFeatureIndices(bytes, scriptOffset), featureTags);
 	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 gdef = parseGdefTable(font);
+	const lookups = [];
+	const lookupOf = (lookupIndex) => lookups[lookupIndex];
+	for (let i = 0; i < lookupCount; i++) {
+		const lookupOffset = lookupListOffset + u16(bytes, lookupOffsetsOffset + i * 2);
+		if (!hasBytes(bytes, lookupOffset, LOOKUP_HEADER_SIZE)) {
+			lookups.push(void 0);
+			continue;
+		}
+		const lookupFlag = u16(bytes, lookupOffset + 2);
 		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));
+		const markFilteringSetWidth = (lookupFlag & LOOKUP_FLAG_USE_MARK_FILTERING_SET) !== 0 ? 2 : 0;
+		if (!hasBytes(bytes, subtableOffsetsOffset, subTableCount * 2 + markFilteringSetWidth)) {
+			lookups.push(void 0);
+			continue;
+		}
+		const skip = glyphSkipper(lookupFlag, markFilteringSetWidth === 0 ? 0 : u16(bytes, subtableOffsetsOffset + subTableCount * 2), gdef);
+		const subtables = [];
+		for (let s = 0; s < subTableCount; s++) {
+			const subtable = parseSubtable(bytes, lookupType, lookupOffset + u16(bytes, subtableOffsetsOffset + s * 2), skip, lookupOf);
 			if (subtable !== void 0) subtables.push(subtable);
 		}
+		lookups.push({ subtables });
 	}
-	if (subtables.length === 0) return;
+	const appliedLookups = [];
+	for (const lookupIndex of lookupIndices) {
+		const lookup = lookupOf(lookupIndex);
+		if (lookup !== void 0) appliedLookups.push(lookup);
+	}
+	if (appliedLookups.every((lookup) => lookup.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;
-				}
+		const slots = glyphIds.map((glyphId) => ({
+			glyphId,
+			span: 1
+		}));
+		for (const lookup of appliedLookups) {
+			let slotIndex = 0;
+			while (slotIndex < slots.length) {
+				const advanced = applyLookupAtSlot(slots, slotIndex, lookup, 0);
+				slotIndex += advanced !== 0 ? advanced : 1;
 			}
-			shaped.push(glyphIds[index]);
-			spans.push(1);
-			index += 1;
 		}
 		return {
-			glyphIds: shaped,
-			spans
+			glyphIds: slots.map((slot) => slot.glyphId),
+			spans: slots.map((slot) => slot.span)
 		};
 	};
 }
 //#endregion
-export { buildGsubShaper };
+export { DEFAULT_GSUB_FEATURE_TAGS, GSUB_OPT_IN_FEATURE_TAGS, buildGsubShaper };

package/dist/images-read.cjs

@@ -249,7 +249,11 @@ function readJpeg2000Image(dict, raw, resolver, sink) {
 		format: "png",
 		bytes: (0, byte_codec.encodePng)(withAlpha),
 		widthPx: image.width,
-		heightPx: image.height
+		heightPx: image.height,
+		original: {
+			filter: "jpeg2000",
+			bytes: raw
+		}
 	};
 }
 function readImageXObject(dict, raw, resolver, sink) {
@@ -262,6 +266,11 @@ function readImageXObject(dict, raw, resolver, sink) {
 		return;
 	}
 	const decoded = require_filters.decodeStream(raw, dict, sink, (obj) => resolver.resolve(obj));
+	const jbig2Original = decoded.jbig2 === void 0 ? void 0 : {
+		filter: "jbig2",
+		bytes: decoded.jbig2.encoded,
+		...decoded.jbig2.globals !== void 0 ? { globalsBytes: decoded.jbig2.globals } : {}
+	};
 	if (decoded.remainingFilter === "DCTDecode") {
 		let info;
 		try {
@@ -323,7 +332,8 @@ function readImageXObject(dict, raw, resolver, sink) {
 		format: "png",
 		bytes: (0, byte_codec.encodePng)(withAlpha),
 		widthPx: width,
-		heightPx: height
+		heightPx: height,
+		...jbig2Original !== void 0 ? { original: jbig2Original } : {}
 	};
 }
 //#endregion

package/dist/images-read.d.cts

@@ -7,6 +7,11 @@ interface ExtractedPdfImage {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly widthPx: number;
   readonly heightPx: number;
+  readonly original?: {
+    readonly filter: "jbig2" | "jpeg2000";
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly globalsBytes?: Uint8Array<ArrayBuffer>;
+  };
 }
 declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
 //#endregion

package/dist/images-read.d.ts

@@ -7,6 +7,11 @@ interface ExtractedPdfImage {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly widthPx: number;
   readonly heightPx: number;
+  readonly original?: {
+    readonly filter: "jbig2" | "jpeg2000";
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly globalsBytes?: Uint8Array<ArrayBuffer>;
+  };
 }
 declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
 //#endregion