pdf-parser.js 3.0.8 → 4.5.2

package/dist/form.js

@@ -0,0 +1,137 @@
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { decodePdfString } from "./pdf-text.js";
+//#region src/form.ts
+const FLAG_READ_ONLY = 1;
+const FLAG_PUSHBUTTON = 4;
+const FLAG_RADIO = 32768;
+const FLAG_COMBO = 131072;
+function readAcroForm(catalog, resolver, pageIndex, sink) {
+	const acroForm = resolver.resolveDict(dictGet(catalog, "AcroForm"));
+	if (acroForm === void 0) return [];
+	const fields = [];
+	const visited = /* @__PURE__ */ new Set();
+	for (const fieldRef of asArray(resolver.resolve(dictGet(acroForm, "Fields"))) ?? []) {
+		const fieldDict = resolver.resolveDict(fieldRef);
+		if (fieldDict !== void 0) readField(fieldDict, "", resolver, pageIndex, sink, fields, visited);
+	}
+	return fields;
+}
+function readField(node, parentName, resolver, pageIndex, sink, out, visited) {
+	if (visited.has(node)) {
+		sink({
+			code: "pdf/form-field-cycle",
+			severity: "warning",
+			message: "the AcroForm field tree contains a cycle; stopping descent at the repeated field"
+		});
+		return;
+	}
+	visited.add(node);
+	const ownName = annotText(node, "T");
+	const name = ownName === void 0 ? parentName : parentName.length > 0 ? `${parentName}.${ownName}` : ownName;
+	const fieldObj = dictGet(node, "FT");
+	const fieldType = asName(fieldObj);
+	if (fieldType === void 0) {
+		const children = [];
+		for (const kidRef of asArray(resolver.resolve(dictGet(node, "Kids"))) ?? []) {
+			const kid = resolver.resolveDict(kidRef);
+			if (kid !== void 0) readField(kid, name, resolver, pageIndex, sink, children, visited);
+		}
+		out.push({
+			name,
+			fieldType: "group",
+			widgets: [],
+			children
+		});
+		return;
+	}
+	const flags = asNumber(resolver.resolve(dictGet(node, "Ff"))) ?? 0;
+	const value = fieldValue(node, resolver);
+	const options = fieldOptions(node, resolver);
+	const alias = annotText(node, "TU");
+	const widgets = [];
+	for (const kidRef of asArray(resolver.resolve(dictGet(node, "Kids"))) ?? []) {
+		const kid = resolver.resolveDict(kidRef);
+		if (kid === void 0 || dictGet(kid, "FT") !== void 0) continue;
+		const widget = widgetPlacement(kid, pageIndex);
+		if (widget !== void 0) widgets.push(widget);
+	}
+	if (widgets.length === 0 && dictGet(node, "Rect") !== void 0) {
+		const widget = widgetPlacement(node, pageIndex);
+		if (widget !== void 0) widgets.push(widget);
+	}
+	out.push({
+		name,
+		fieldType: mapFieldType(fieldType, flags),
+		...valueFields(fieldType, value),
+		...options !== void 0 ? { options } : {},
+		...alias !== void 0 ? { alias } : {},
+		...(flags & FLAG_READ_ONLY) !== 0 ? { readOnly: true } : {},
+		widgets,
+		children: []
+	});
+}
+function mapFieldType(fieldType, flags) {
+	if (fieldType === "Tx") return "text";
+	if (fieldType === "Btn") {
+		if ((flags & FLAG_PUSHBUTTON) !== 0) return "button";
+		if ((flags & FLAG_RADIO) !== 0) return "radio";
+		return "checkbox";
+	}
+	if (fieldType === "Ch") return (flags & FLAG_COMBO) !== 0 ? "combobox" : "listbox";
+	return "signature";
+}
+function valueFields(fieldType, value) {
+	if (value === void 0) return {};
+	if (fieldType === "Btn") return {
+		checked: value !== "Off",
+		...value !== "Off" ? { value } : {}
+	};
+	if (fieldType === "Sig") return {};
+	return { value };
+}
+function fieldValue(node, resolver) {
+	const value = resolver.resolve(dictGet(node, "V"));
+	if (value?.kind === "string") return decodePdfString(value.bytes);
+	if (value?.kind === "name") return value.name;
+	if (value?.kind === "number") return String(value.value);
+}
+function fieldOptions(node, resolver) {
+	const opts = asArray(resolver.resolve(dictGet(node, "Opt")));
+	if (opts === void 0) return;
+	const values = [];
+	for (const opt of opts) {
+		const resolved = resolver.resolve(opt);
+		if (resolved?.kind === "string") values.push(decodePdfString(resolved.bytes));
+		else if (resolved?.kind === "array") {
+			const first = resolved.items[0];
+			const exportValue = first?.kind === "string" ? decodePdfString(first.bytes) : first?.kind === "name" ? first.name : void 0;
+			if (exportValue !== void 0) values.push(exportValue);
+		}
+	}
+	return values.length > 0 ? values : void 0;
+}
+function widgetPlacement(widget, pageIndex) {
+	const pageNo = pageIndex(dictGet(widget, "P"));
+	if (pageNo === void 0) return;
+	return rectWidget(asArray(dictGet(widget, "Rect")), pageNo);
+}
+function rectWidget(rect, pageNo) {
+	if (rect === void 0) return;
+	const x1 = asNumber(rect[0]) ?? 0;
+	const y1 = asNumber(rect[1]) ?? 0;
+	const x2 = asNumber(rect[2]) ?? 0;
+	const y2 = asNumber(rect[3]) ?? 0;
+	return {
+		pageIndex: pageNo,
+		xPt: Math.min(x1, x2),
+		yPt: Math.min(y1, y2),
+		widthPt: Math.abs(x2 - x1),
+		heightPt: Math.abs(y2 - y1)
+	};
+}
+function annotText(dict, key) {
+	const obj = dictGet(dict, key);
+	return obj?.kind === "string" ? decodePdfString(obj.bytes) : void 0;
+}
+//#endregion
+export { readAcroForm };

package/dist/gsub-table-BRTQ8EUW.d.ts

@@ -0,0 +1,10 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/gsub-table.d.ts
+interface GsubShaping {
+  readonly glyphIds: number[];
+  readonly spans: number[];
+}
+type GsubShaper = (glyphIds: readonly number[]) => GsubShaping;
+declare function buildGsubShaper(font: SfntFont): GsubShaper | undefined;
+//#endregion
+export { GsubShaping as n, buildGsubShaper as r, GsubShaper as t };

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

@@ -0,0 +1,10 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/gsub-table.d.ts
+interface GsubShaping {
+  readonly glyphIds: number[];
+  readonly spans: number[];
+}
+type GsubShaper = (glyphIds: readonly number[]) => GsubShaping;
+declare function buildGsubShaper(font: SfntFont): GsubShaper | undefined;
+//#endregion
+export { GsubShaping as n, buildGsubShaper as r, GsubShaper as t };

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 };