pdf-parser.js 5.2.29 → 5.3.0

package/dist/gsub-table.cjs

@@ -1,557 +1,22 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sfnt = require("./sfnt.cjs");
-const require_ot_layout_common = require("./ot-layout-common.cjs");
-const require_gdef_table = require("./gdef-table.cjs");
-//#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(require_sfnt.u16(bytes, offset) >> BITS_PER_BYTE, require_sfnt.u16(bytes, offset) & BYTE_MASK, require_sfnt.u16(bytes, offset + 2) >> BITS_PER_BYTE, require_sfnt.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 (!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 + SUBST_FORMAT_AND_COVERAGE_SIZE);
-	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 (!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 + SUBST_FORMAT_AND_COVERAGE_SIZE);
-	const substitutesOffset = subtableOffset + SINGLE_SUBST_FORMAT_2_HEADER_SIZE;
-	if (!require_sfnt.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: require_sfnt.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 (!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 + SUBST_FORMAT_AND_COVERAGE_SIZE);
-	const ligSetOffsetsOffset = subtableOffset + LIGATURE_SUBST_FORMAT_1_HEADER_SIZE;
-	if (!require_sfnt.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 + 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;
-			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 !== require_sfnt.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 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) {
-			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 (!require_sfnt.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: require_sfnt.u16(bytes, recordOffset),
-			lookupIndex: require_sfnt.u16(bytes, recordOffset + 2)
-		});
-	}
-	return records;
-}
-function parseFormat3Rule(bytes, subtableOffset, chained) {
-	let offset = subtableOffset + 2;
-	const backtrack = [];
-	const input = [];
-	const lookahead = [];
-	const readCoverageArray = () => {
-		if (!require_sfnt.hasBytes(bytes, offset, 2)) return;
-		const count = require_sfnt.u16(bytes, offset);
-		offset += 2;
-		if (!require_sfnt.hasBytes(bytes, offset, count * 2)) return;
-		const coverages = [];
-		for (let i = 0; i < count; i++) {
-			const coverageOffset = require_sfnt.u16(bytes, offset + i * 2);
-			if (coverageOffset === 0) return;
-			const coverage = require_ot_layout_common.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 (!require_sfnt.hasBytes(bytes, offset, 2)) return;
-	const substCount = require_sfnt.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 (!require_sfnt.hasBytes(bytes, offset, 2)) return;
-		const value = require_sfnt.u16(bytes, offset);
-		offset += 2;
-		return value;
-	};
-	const readArray = () => {
-		const count = readU16();
-		if (count === void 0 || !require_sfnt.hasBytes(bytes, offset, count * 2)) return;
-		const values = [];
-		for (let i = 0; i < count; i++) values.push(require_sfnt.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 || !require_sfnt.hasBytes(bytes, offset, (glyphCount - 1) * 2)) return;
-	const input = [];
-	for (let i = 0; i < glyphCount - 1; i++) input.push(require_sfnt.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 = require_sfnt.u16(bytes, setOffsetsOffset + setIndex * 2);
-		if (setOffset === 0) return [];
-		const ruleSetOffset = subtableOffset + setOffset;
-		if (!require_sfnt.hasBytes(bytes, ruleSetOffset, 2)) return [];
-		const ruleCount = require_sfnt.u16(bytes, ruleSetOffset);
-		if (!require_sfnt.hasBytes(bytes, ruleSetOffset + 2, ruleCount * 2)) return [];
-		const rules = [];
-		for (let i = 0; i < ruleCount; i++) {
-			const rule = readSequenceRule(bytes, ruleSetOffset + require_sfnt.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 (!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 + EXTENSION_SUBST_OFFSET_FIELD_OFFSET), skip, lookupOf);
-	}
-	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, skip);
-		if (substFormat === 2) return parseSingleSubstFormat2(bytes, subtableOffset, skip);
-		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, 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 (!require_sfnt.hasBytes(bytes, subtableOffset, 2)) return;
-	const substFormat = require_sfnt.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 (!require_sfnt.hasBytes(bytes, subtableOffset, prefixSize)) return;
-		const coverage = require_ot_layout_common.parseCoverage(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 2));
-		if (coverage === void 0) return;
-		const setCount = require_sfnt.u16(bytes, subtableOffset + SUBST_FORMAT_AND_COVERAGE_SIZE);
-		const setOffsetsOffset = subtableOffset + prefixSize;
-		if (!require_sfnt.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 (!require_sfnt.hasBytes(bytes, subtableOffset, prefixSize)) return;
-		const coverage = require_ot_layout_common.parseCoverage(bytes, subtableOffset + require_sfnt.u16(bytes, subtableOffset + 2));
-		if (coverage === void 0) return;
-		const inputClassDefOffset = chained ? require_sfnt.u16(bytes, subtableOffset + 6) : require_sfnt.u16(bytes, subtableOffset + SUBST_FORMAT_AND_COVERAGE_SIZE);
-		const inputClassDef = inputClassDefOffset === 0 ? constantZeroClassDef : require_ot_layout_common.parseClassDef(bytes, subtableOffset + inputClassDefOffset);
-		const readAuxClassDef = (offset) => offset === 0 ? constantZeroClassDef : require_ot_layout_common.parseClassDef(bytes, subtableOffset + offset);
-		const backtrackClassDef = chained ? readAuxClassDef(require_sfnt.u16(bytes, subtableOffset + SUBST_FORMAT_AND_COVERAGE_SIZE)) : constantZeroClassDef;
-		const lookaheadClassDef = chained ? readAuxClassDef(require_sfnt.u16(bytes, subtableOffset + 8)) : constantZeroClassDef;
-		if (inputClassDef === void 0 || backtrackClassDef === void 0 || lookaheadClassDef === void 0) return;
-		const setCount = require_sfnt.u16(bytes, subtableOffset + prefixSize - 2);
-		const setOffsetsOffset = subtableOffset + prefixSize;
-		if (!require_sfnt.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);
-	}
-}
-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 + SCRIPT_RECORD_OFFSET_FIELD_OFFSET);
-	}
-	return scriptListOffset + require_sfnt.u16(bytes, recordsOffset + SCRIPT_RECORD_OFFSET_FIELD_OFFSET);
-}
-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 + LANG_SYS_FEATURE_INDEX_COUNT_OFFSET);
-	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 collectLookupIndices(bytes, featureListOffset, featureIndices, featureTags) {
-	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 (!featureTags.includes(readTag(bytes, recordOffset))) continue;
-		const featureOffset = featureListOffset + require_sfnt.u16(bytes, recordOffset + FEATURE_RECORD_OFFSET_FIELD_OFFSET);
-		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, options = {}) {
-	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, GSUB_HEADER_SCRIPT_LIST_OFFSET));
-	if (scriptOffset === void 0) return;
-	const featureTags = [...DEFAULT_GSUB_FEATURE_TAGS, ...options.optInFeatures ?? []];
-	const lookupIndices = collectLookupIndices(bytes, require_sfnt.u16(bytes, GSUB_HEADER_FEATURE_LIST_OFFSET), parseDefaultLangSysFeatureIndices(bytes, scriptOffset), featureTags);
-	if (lookupIndices.length === 0) return;
-	const lookupListOffset = require_sfnt.u16(bytes, GSUB_HEADER_LOOKUP_LIST_OFFSET);
-	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 gdef = require_gdef_table.parseGdefTable(font);
-	const lookups = [];
-	const lookupOf = (lookupIndex) => lookups[lookupIndex];
-	for (let i = 0; i < lookupCount; i++) {
-		const lookupOffset = lookupListOffset + require_sfnt.u16(bytes, lookupOffsetsOffset + i * 2);
-		if (!require_sfnt.hasBytes(bytes, lookupOffset, LOOKUP_HEADER_SIZE)) {
-			lookups.push(void 0);
-			continue;
-		}
-		const lookupFlag = require_sfnt.u16(bytes, lookupOffset + 2);
-		const lookupType = require_sfnt.u16(bytes, lookupOffset);
-		const subTableCount = require_sfnt.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 (!require_sfnt.hasBytes(bytes, subtableOffsetsOffset, subTableCount * 2 + markFilteringSetWidth)) {
-			lookups.push(void 0);
-			continue;
-		}
-		const skip = glyphSkipper(lookupFlag, markFilteringSetWidth === 0 ? 0 : require_sfnt.u16(bytes, subtableOffsetsOffset + subTableCount * 2), gdef);
-		const subtables = [];
-		for (let s = 0; s < subTableCount; s++) {
-			const subtable = parseSubtable(bytes, lookupType, lookupOffset + require_sfnt.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
-exports.DEFAULT_GSUB_FEATURE_TAGS = DEFAULT_GSUB_FEATURE_TAGS;
-exports.GSUB_OPT_IN_FEATURE_TAGS = GSUB_OPT_IN_FEATURE_TAGS;
-exports.buildGsubShaper = buildGsubShaper;
+const require_gsub_table = require("./gsub-table-hFfYmf1W.cjs");
+exports.DEFAULT_GSUB_FEATURE_TAGS = require_gsub_table.DEFAULT_GSUB_FEATURE_TAGS;
+exports.EXTENSION_SUBST_HEADER_SIZE = require_gsub_table.EXTENSION_SUBST_HEADER_SIZE;
+exports.EXTENSION_SUBST_OFFSET_FIELD_OFFSET = require_gsub_table.EXTENSION_SUBST_OFFSET_FIELD_OFFSET;
+exports.GSUB_OPT_IN_FEATURE_TAGS = require_gsub_table.GSUB_OPT_IN_FEATURE_TAGS;
+exports.LOOKUP_TYPE_CHAIN_CONTEXT_SUBST = require_gsub_table.LOOKUP_TYPE_CHAIN_CONTEXT_SUBST;
+exports.LOOKUP_TYPE_CONTEXT_SUBST = require_gsub_table.LOOKUP_TYPE_CONTEXT_SUBST;
+exports.LOOKUP_TYPE_EXTENSION_SUBST = require_gsub_table.LOOKUP_TYPE_EXTENSION_SUBST;
+exports.LOOKUP_TYPE_LIGATURE_SUBST = require_gsub_table.LOOKUP_TYPE_LIGATURE_SUBST;
+exports.LOOKUP_TYPE_SINGLE_SUBST = require_gsub_table.LOOKUP_TYPE_SINGLE_SUBST;
+exports.MAX_LOOKUP_NESTING_DEPTH = require_gsub_table.MAX_LOOKUP_NESTING_DEPTH;
+exports.SUBST_FORMAT_AND_COVERAGE_SIZE = require_gsub_table.SUBST_FORMAT_AND_COVERAGE_SIZE;
+exports.buildGsubShaper = require_gsub_table.buildGsubShaper;
+exports.constantZeroClassDef = require_gsub_table.constantZeroClassDef;
+exports.glyphSkipper = require_gsub_table.glyphSkipper;
+exports.nextVisibleSlot = require_gsub_table.nextVisibleSlot;
+exports.parseLigatureSubstFormat1 = require_gsub_table.parseLigatureSubstFormat1;
+exports.parseSingleSubstFormat1 = require_gsub_table.parseSingleSubstFormat1;
+exports.parseSingleSubstFormat2 = require_gsub_table.parseSingleSubstFormat2;
+exports.prevVisibleSlot = require_gsub_table.prevVisibleSlot;
+exports.readTag = require_gsub_table.readTag;

package/dist/gsub-table.d.cts

@@ -1,2 +1,2 @@
-import { a as GsubShaperOptions, i as GsubShaper, n as GSUB_OPT_IN_FEATURE_TAGS, o as GsubShaping, r as GsubOptInFeatureTag, s as buildGsubShaper, t as DEFAULT_GSUB_FEATURE_TAGS } from "./gsub-table-Bm9kSMzk.cjs";
-export { DEFAULT_GSUB_FEATURE_TAGS, GSUB_OPT_IN_FEATURE_TAGS, GsubOptInFeatureTag, GsubShaper, GsubShaperOptions, GsubShaping, buildGsubShaper };
+import { A as readTag, C as constantZeroClassDef, D as parseSingleSubstFormat1, E as parseLigatureSubstFormat1, O as parseSingleSubstFormat2, S as buildGsubShaper, T as nextVisibleSlot, _ as MAX_LOOKUP_NESTING_DEPTH, a as GSUB_OPT_IN_FEATURE_TAGS, b as SlotApplication, c as GsubShaper, d as GsubSubtable, f as LOOKUP_TYPE_CHAIN_CONTEXT_SUBST, g as LOOKUP_TYPE_SINGLE_SUBST, h as LOOKUP_TYPE_LIGATURE_SUBST, i as EXTENSION_SUBST_OFFSET_FIELD_OFFSET, k as prevVisibleSlot, l as GsubShaperOptions, m as LOOKUP_TYPE_EXTENSION_SUBST, n as DEFAULT_GSUB_FEATURE_TAGS, o as GsubLookup, p as LOOKUP_TYPE_CONTEXT_SUBST, r as EXTENSION_SUBST_HEADER_SIZE, s as GsubOptInFeatureTag, t as ContextualGlyphTest, u as GsubShaping, v as SUBST_FORMAT_AND_COVERAGE_SIZE, w as glyphSkipper, x as SubstLookupRecord, y as ShapingSlot } from "./gsub-table-DW7Wmi9V.cjs";
+export { ContextualGlyphTest, DEFAULT_GSUB_FEATURE_TAGS, EXTENSION_SUBST_HEADER_SIZE, EXTENSION_SUBST_OFFSET_FIELD_OFFSET, GSUB_OPT_IN_FEATURE_TAGS, GsubLookup, GsubOptInFeatureTag, GsubShaper, GsubShaperOptions, GsubShaping, GsubSubtable, LOOKUP_TYPE_CHAIN_CONTEXT_SUBST, LOOKUP_TYPE_CONTEXT_SUBST, LOOKUP_TYPE_EXTENSION_SUBST, LOOKUP_TYPE_LIGATURE_SUBST, LOOKUP_TYPE_SINGLE_SUBST, MAX_LOOKUP_NESTING_DEPTH, SUBST_FORMAT_AND_COVERAGE_SIZE, ShapingSlot, SlotApplication, SubstLookupRecord, buildGsubShaper, constantZeroClassDef, glyphSkipper, nextVisibleSlot, parseLigatureSubstFormat1, parseSingleSubstFormat1, parseSingleSubstFormat2, prevVisibleSlot, readTag };

package/dist/gsub-table.d.ts

@@ -1,2 +1,2 @@
-import { a as GsubShaperOptions, i as GsubShaper, n as GSUB_OPT_IN_FEATURE_TAGS, o as GsubShaping, r as GsubOptInFeatureTag, s as buildGsubShaper, t as DEFAULT_GSUB_FEATURE_TAGS } from "./gsub-table-CdfESH2-.js";
-export { DEFAULT_GSUB_FEATURE_TAGS, GSUB_OPT_IN_FEATURE_TAGS, GsubOptInFeatureTag, GsubShaper, GsubShaperOptions, GsubShaping, buildGsubShaper };
+import { A as readTag, C as constantZeroClassDef, D as parseSingleSubstFormat1, E as parseLigatureSubstFormat1, O as parseSingleSubstFormat2, S as buildGsubShaper, T as nextVisibleSlot, _ as MAX_LOOKUP_NESTING_DEPTH, a as GSUB_OPT_IN_FEATURE_TAGS, b as SlotApplication, c as GsubShaper, d as GsubSubtable, f as LOOKUP_TYPE_CHAIN_CONTEXT_SUBST, g as LOOKUP_TYPE_SINGLE_SUBST, h as LOOKUP_TYPE_LIGATURE_SUBST, i as EXTENSION_SUBST_OFFSET_FIELD_OFFSET, k as prevVisibleSlot, l as GsubShaperOptions, m as LOOKUP_TYPE_EXTENSION_SUBST, n as DEFAULT_GSUB_FEATURE_TAGS, o as GsubLookup, p as LOOKUP_TYPE_CONTEXT_SUBST, r as EXTENSION_SUBST_HEADER_SIZE, s as GsubOptInFeatureTag, t as ContextualGlyphTest, u as GsubShaping, v as SUBST_FORMAT_AND_COVERAGE_SIZE, w as glyphSkipper, x as SubstLookupRecord, y as ShapingSlot } from "./gsub-table-BDpJWqpf.js";
+export { ContextualGlyphTest, DEFAULT_GSUB_FEATURE_TAGS, EXTENSION_SUBST_HEADER_SIZE, EXTENSION_SUBST_OFFSET_FIELD_OFFSET, GSUB_OPT_IN_FEATURE_TAGS, GsubLookup, GsubOptInFeatureTag, GsubShaper, GsubShaperOptions, GsubShaping, GsubSubtable, LOOKUP_TYPE_CHAIN_CONTEXT_SUBST, LOOKUP_TYPE_CONTEXT_SUBST, LOOKUP_TYPE_EXTENSION_SUBST, LOOKUP_TYPE_LIGATURE_SUBST, LOOKUP_TYPE_SINGLE_SUBST, MAX_LOOKUP_NESTING_DEPTH, SUBST_FORMAT_AND_COVERAGE_SIZE, ShapingSlot, SlotApplication, SubstLookupRecord, buildGsubShaper, constantZeroClassDef, glyphSkipper, nextVisibleSlot, parseLigatureSubstFormat1, parseSingleSubstFormat1, parseSingleSubstFormat2, prevVisibleSlot, readTag };