pdf-parser.js 5.2.30 → 5.3.0

package/dist/gsub-table-D6niKeLi.js

@@ -0,0 +1,556 @@
+import { hasBytes, i16, sfntTableBytes, u16, u32 } from "./sfnt.js";
+import { parseClassDef, parseCoverage } from "./ot-layout-common.js";
+import { parseGdefTable } from "./gdef-table.js";
+//#region src/gsub-context.ts
+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 >= 6) return;
+		const target = visibleInputSlot(window, record.sequenceIndex, skip);
+		if (target !== void 0) {
+			const application = applyLookupAtSlot(window, target, lookup, depth + 1);
+			if (application !== void 0) window.splice(target, application.consumed, ...application.replacement);
+		}
+	}
+	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) return application;
+	}
+}
+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 === 7) {
+		if (!hasBytes(bytes, subtableOffset, 8) || u16(bytes, subtableOffset) !== 1) return;
+		const extensionLookupType = u16(bytes, subtableOffset + 2);
+		if (extensionLookupType === 7) return;
+		return parseSubtable(bytes, extensionLookupType, subtableOffset + u32(bytes, subtableOffset + 4), skip, lookupOf);
+	}
+	if (lookupType === 1) {
+		if (!hasBytes(bytes, subtableOffset, 2)) return;
+		const substFormat = u16(bytes, subtableOffset);
+		if (substFormat === 1) return parseSingleSubstFormat1(bytes, subtableOffset, skip);
+		if (substFormat === 2) return parseSingleSubstFormat2(bytes, subtableOffset, skip);
+		return;
+	}
+	if (lookupType === 4) {
+		if (!hasBytes(bytes, subtableOffset, 2)) return;
+		if (u16(bytes, subtableOffset) !== 1) return;
+		return parseLigatureSubstFormat1(bytes, subtableOffset, skip);
+	}
+	if (lookupType === 5 || lookupType === 6) return parseContextualSubtable(bytes, lookupType === 6, 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);
+	}
+}
+//#endregion
+//#region src/gsub-table.ts
+const constantZeroClassDef = () => 0;
+const DEFAULT_GSUB_FEATURE_TAGS = [
+	"liga",
+	"rlig",
+	"calt",
+	"clig"
+];
+const GSUB_OPT_IN_FEATURE_TAGS = ["smcp", "dlig"];
+const GSUB_HEADER_SIZE = 10;
+const GSUB_HEADER_SCRIPT_LIST_OFFSET = 4;
+const GSUB_HEADER_FEATURE_LIST_OFFSET = 6;
+const GSUB_HEADER_LOOKUP_LIST_OFFSET = 8;
+const SCRIPT_RECORD_SIZE = 6;
+const SCRIPT_RECORD_OFFSET_FIELD_OFFSET = 4;
+const FEATURE_RECORD_SIZE = 6;
+const FEATURE_RECORD_OFFSET_FIELD_OFFSET = 4;
+const LANG_SYS_HEADER_SIZE = 6;
+const LANG_SYS_FEATURE_INDEX_COUNT_OFFSET = 4;
+const FEATURE_HEADER_SIZE = 4;
+const LOOKUP_HEADER_SIZE = 6;
+const LOOKUP_HEADER_SUBTABLE_COUNT_OFFSET = 4;
+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 EXTENSION_SUBST_OFFSET_FIELD_OFFSET = 4;
+const BITS_PER_BYTE = 8;
+const BYTE_MASK = 255;
+const SUBST_FORMAT_AND_COVERAGE_SIZE = 4;
+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) >> BITS_PER_BYTE, u16(bytes, offset) & BYTE_MASK, u16(bytes, offset + 2) >> BITS_PER_BYTE, u16(bytes, offset + 2) & BYTE_MASK);
+}
+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) >> BITS_PER_BYTE;
+	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, 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 (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, 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 (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, 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 (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;
+				}
+				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 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 + SCRIPT_RECORD_OFFSET_FIELD_OFFSET);
+	}
+	return scriptListOffset + u16(bytes, recordsOffset + SCRIPT_RECORD_OFFSET_FIELD_OFFSET);
+}
+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 + LANG_SYS_FEATURE_INDEX_COUNT_OFFSET);
+	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 collectLookupIndices(bytes, featureListOffset, featureIndices, featureTags) {
+	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 (!featureTags.includes(readTag(bytes, recordOffset))) continue;
+		const featureOffset = featureListOffset + u16(bytes, recordOffset + FEATURE_RECORD_OFFSET_FIELD_OFFSET);
+		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, 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, GSUB_HEADER_SCRIPT_LIST_OFFSET));
+	if (scriptOffset === void 0) return;
+	const featureTags = [...DEFAULT_GSUB_FEATURE_TAGS, ...options.optInFeatures ?? []];
+	const lookupIndices = collectLookupIndices(bytes, u16(bytes, GSUB_HEADER_FEATURE_LIST_OFFSET), parseDefaultLangSysFeatureIndices(bytes, scriptOffset), featureTags);
+	if (lookupIndices.length === 0) return;
+	const lookupListOffset = u16(bytes, GSUB_HEADER_LOOKUP_LIST_OFFSET);
+	if (!hasBytes(bytes, lookupListOffset, 2)) return;
+	const lookupCount = u16(bytes, lookupListOffset);
+	const lookupOffsetsOffset = lookupListOffset + 2;
+	if (!hasBytes(bytes, lookupOffsetsOffset, lookupCount * 2)) return;
+	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 + LOOKUP_HEADER_SUBTABLE_COUNT_OFFSET);
+		const subtableOffsetsOffset = lookupOffset + LOOKUP_HEADER_SIZE;
+		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 });
+	}
+	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 slots = glyphIds.map((glyphId) => ({
+			glyphId,
+			span: 1
+		}));
+		for (const lookup of appliedLookups) {
+			let slotIndex = 0;
+			while (slotIndex < slots.length) {
+				const application = applyLookupAtSlot(slots, slotIndex, lookup, 0);
+				if (application === void 0) {
+					slotIndex += 1;
+					continue;
+				}
+				slots.splice(slotIndex, application.consumed, ...application.replacement);
+				slotIndex += application.replacement.length !== 0 ? application.replacement.length : 1;
+			}
+		}
+		return {
+			glyphIds: slots.map((slot) => slot.glyphId),
+			spans: slots.map((slot) => slot.span)
+		};
+	};
+}
+//#endregion
+export { sequenceSubtable as A, format3Subtable as C, parseSubtable as D, parseFormat3Rule as E, readSequenceRule as O, applyLookupAtSlot as S, parseContextualSubtable as T, parseSingleSubstFormat1 as _, LOOKUP_TYPE_CHAIN_CONTEXT_SUBST as a, readTag as b, LOOKUP_TYPE_LIGATURE_SUBST as c, SUBST_FORMAT_AND_COVERAGE_SIZE as d, buildGsubShaper as f, parseLigatureSubstFormat1 as g, nextVisibleSlot as h, GSUB_OPT_IN_FEATURE_TAGS as i, visibleInputSlot as j, readSubstLookupRecords as k, LOOKUP_TYPE_SINGLE_SUBST as l, glyphSkipper as m, EXTENSION_SUBST_HEADER_SIZE as n, LOOKUP_TYPE_CONTEXT_SUBST as o, constantZeroClassDef as p, EXTENSION_SUBST_OFFSET_FIELD_OFFSET as r, LOOKUP_TYPE_EXTENSION_SUBST as s, DEFAULT_GSUB_FEATURE_TAGS as t, MAX_LOOKUP_NESTING_DEPTH as u, parseSingleSubstFormat2 as v, matchContextualRule as w, applyContextualRule as x, prevVisibleSlot as y };

package/dist/gsub-table-DW7Wmi9V.d.cts

@@ -0,0 +1,52 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+import { o as GdefTable } from "./gdef-table-D0Hzn4KD.cjs";
+import { t as ClassDefTable } from "./ot-layout-common-BcsGRFBS.cjs";
+//#region src/gsub-table.d.ts
+declare const constantZeroClassDef: ClassDefTable;
+declare const DEFAULT_GSUB_FEATURE_TAGS: readonly ["liga", "rlig", "calt", "clig"];
+declare const GSUB_OPT_IN_FEATURE_TAGS: readonly ["smcp", "dlig"];
+type GsubOptInFeatureTag = (typeof GSUB_OPT_IN_FEATURE_TAGS)[number];
+interface GsubShaperOptions {
+  readonly optInFeatures?: readonly GsubOptInFeatureTag[];
+}
+declare const LOOKUP_TYPE_SINGLE_SUBST = 1;
+declare const LOOKUP_TYPE_LIGATURE_SUBST = 4;
+declare const LOOKUP_TYPE_CONTEXT_SUBST = 5;
+declare const LOOKUP_TYPE_CHAIN_CONTEXT_SUBST = 6;
+declare const LOOKUP_TYPE_EXTENSION_SUBST = 7;
+declare const EXTENSION_SUBST_HEADER_SIZE = 8;
+declare const EXTENSION_SUBST_OFFSET_FIELD_OFFSET = 4;
+declare const SUBST_FORMAT_AND_COVERAGE_SIZE = 4;
+declare const MAX_LOOKUP_NESTING_DEPTH = 6;
+declare function readTag(bytes: Uint8Array<ArrayBuffer>, offset: number): string;
+interface GsubShaping {
+  readonly glyphIds: number[];
+  readonly spans: number[];
+}
+type GsubShaper = (glyphIds: readonly number[]) => GsubShaping;
+interface ShapingSlot {
+  glyphId: number;
+  span: number;
+}
+interface SlotApplication {
+  readonly consumed: number;
+  readonly replacement: readonly ShapingSlot[];
+}
+interface SubstLookupRecord {
+  readonly sequenceIndex: number;
+  readonly lookupIndex: number;
+}
+type GsubSubtable = (slots: readonly ShapingSlot[], index: number, depth: number) => SlotApplication | undefined;
+interface GsubLookup {
+  readonly subtables: readonly GsubSubtable[];
+}
+declare function glyphSkipper(lookupFlag: number, markFilteringSet: number, gdef: GdefTable | undefined): (glyphId: number) => boolean;
+declare function nextVisibleSlot(slots: readonly ShapingSlot[], from: number, skip: (glyphId: number) => boolean): number | undefined;
+declare function prevVisibleSlot(slots: readonly ShapingSlot[], before: number, skip: (glyphId: number) => boolean): number | undefined;
+declare function parseSingleSubstFormat1(bytes: Uint8Array<ArrayBuffer>, subtableOffset: number, skip: (glyphId: number) => boolean): GsubSubtable | undefined;
+declare function parseSingleSubstFormat2(bytes: Uint8Array<ArrayBuffer>, subtableOffset: number, skip: (glyphId: number) => boolean): GsubSubtable | undefined;
+declare function parseLigatureSubstFormat1(bytes: Uint8Array<ArrayBuffer>, subtableOffset: number, skip: (glyphId: number) => boolean): GsubSubtable | undefined;
+type ContextualGlyphTest = (glyphId: number) => boolean;
+declare function buildGsubShaper(font: SfntFont, options?: GsubShaperOptions): GsubShaper | undefined;
+//#endregion
+export { readTag as A, constantZeroClassDef as C, parseSingleSubstFormat1 as D, parseLigatureSubstFormat1 as E, parseSingleSubstFormat2 as O, buildGsubShaper as S, nextVisibleSlot as T, MAX_LOOKUP_NESTING_DEPTH as _, GSUB_OPT_IN_FEATURE_TAGS as a, SlotApplication as b, GsubShaper as c, GsubSubtable as d, LOOKUP_TYPE_CHAIN_CONTEXT_SUBST as f, LOOKUP_TYPE_SINGLE_SUBST as g, LOOKUP_TYPE_LIGATURE_SUBST as h, EXTENSION_SUBST_OFFSET_FIELD_OFFSET as i, prevVisibleSlot as k, GsubShaperOptions as l, LOOKUP_TYPE_EXTENSION_SUBST as m, DEFAULT_GSUB_FEATURE_TAGS as n, GsubLookup as o, LOOKUP_TYPE_CONTEXT_SUBST as p, EXTENSION_SUBST_HEADER_SIZE as r, GsubOptInFeatureTag as s, ContextualGlyphTest as t, GsubShaping as u, SUBST_FORMAT_AND_COVERAGE_SIZE as v, glyphSkipper as w, SubstLookupRecord as x, ShapingSlot as y };