pdf-codec 4.1.0 → 4.3.0

package/README.md

@@ -272,9 +272,9 @@ Dependency direction is strictly downward and checkable: `layout` imports only `
 - **Real per-glyph ink bounds are measured from the outline (`inkAscentPt`/`inkDescentPt`), computed by walking each glyph's Type 2 charstring.** `ascentPerEm`/`descentPerEm` remain alongside them as the uniform face-wide figure, still the right measure for anything sized against the font rather than particular characters, and the fallback for a glyph with no outline to measure. An ink box is genuinely tight, which for a math font is often _larger_ than the nominal metrics (over a tenth of STIX Two Math's repertoire draws above its nominal ascent). `inkDescentPt` is negative where the glyph's lowest ink sits above the baseline.
 - **A `LayoutLine`/`LayoutPath` `style` of `dashed`/`dotted` becomes a real dash-array (`d`) operator scaled to the stroke's own width; `double` becomes two genuinely separate offset strokes.** Dash lengths are stroke-width multiples so a hairline and a thick rule both read as recognisably dashed: `dashed` emits `[3w 3w] 0 d`, `dotted` emits `[0 2w] 0 d` with a `1 J` round cap (the zero on-length under a round cap paints a filled circle — exactly a dot; under PDF's default butt cap it paints nothing). Both are reset immediately after the paint operator (`[] 0 d`, `0 J`) since the graphics state persists for the whole content stream. `double` has no PDF operator and is drawn as geometry: width `w` splits into three equal bands, each rule `w/3` wide with centreline `w/3` offset, outer edges matching the single stroke's. The read side tracks the `d` operator's own dash array as graphics state and recovers `dashed`/`dotted` back onto a stroked `LayoutLine`/`LayoutPath` from it — a zero on-length reads as `dotted`, any other non-empty array as `dashed`, an empty array (or none at all) as `solid`. `double` has no operator of its own to recover from, so it reads back as whatever geometry its two offset strokes actually are (typically two plain solid lines or paths), not as `double`.
 - **An embedded `CIDFontType2` program needs no `cmap` table of its own**, and `sfnt-subset.ts`'s output doesn't carry one — character code → CID goes through the `Type0` font's `/Encoding` (Identity-H, so CID == character code), and CID → GID through `/CIDToGIDMap /Identity` (matching the GID-preserving design). Both happen inside the PDF's object graph, before the embedded font program is consulted (ISO 32000-1 9.7.4.2).
-- **`GPOS` pair kerning is read and applied for an embedded face; no other OpenType layout feature is.** `GSUB` (ligatures, contextual alternates, small caps) is never applied — a face's `fi` ligature is drawn as two separate glyphs. The legacy `kern` table is not read either (neither Carlito nor Caladea ships one). A kerned run is shown with `TJ`, and the sign of a `TJ` number is the opposite of the adjustment it expresses (ISO 32000-1 9.4.3: a positive number moves the next glyph closer). A run with no kerning pairs stays as one unsplit hex string with `Tj`.
+- **`GPOS` pair kerning and `GSUB`'s default ligature features are read and applied for an embedded face; the contextual and opt-in layout features are not.** An `fi` in a face whose `liga` feature declares the ligature draws as that real ligature glyph (advances, kerning, subsetting, and the ToUnicode CMap all describing the one substituted sequence — a ligature's ToUnicode entry maps back to its whole character run, so copy/paste recovers `fi`, not one glyph's worth of it). Still refused by name: the contextual features (`calt`, `clig`), which reach through Contextual/Chaining Contextual lookup machinery out of proportion to apply; the opt-in features (`smcp`, `dlig` and friends), which no real shaper turns on until a caller asks; and lookups with a nonzero `lookupFlag`, whose behaviour depends on GDEF glyph classes this package does not read. The legacy `kern` table is not read either (neither Carlito nor Caladea ships one). A kerned run is shown with `TJ`, and the sign of a `TJ` number is the opposite of the adjustment it expresses (ISO 32000-1 9.4.3: a positive number moves the next glyph closer). A run with no kerning pairs stays as one unsplit hex string with `Tj`.
 - **Kerning applies to whole shown strings, so a wrap decision does not see a pair straddling the boundary between two separately-measured words.** The width a line reports is the width the page draws; making the wrap decision itself exact would mean widening the `TextMeasurer` port for a sub-point difference that only ever errs towards breaking a line early.
-- **`font-substitutes.ts` maps both `Calibri` and `Calibri Light` onto the same ordinary-weight Carlito face** — Carlito ships only one weight per style axis, so `Calibri Light` substitutes to standard Carlito rather than a genuinely lighter face. An honest, documented approximation: width metrics match, visibly thinner strokes do not.
+- **`font-substitutes.ts` maps both `Calibri` and `Calibri Light` onto the same ordinary-weight Carlito face** — Carlito ships only one weight per style axis (no Light face exists upstream to vendor), so `Calibri Light` substitutes to standard Carlito rather than a genuinely lighter face. An honest, documented approximation: width metrics match, visibly thinner strokes do not — and a REPORTED one, never silent: the registry's `onSubstitution` channel fires for it like every vendored substitution, naming `Calibri Light` → `carlito` so a caller can act on the weight mismatch (pinned by test in write-embedded-font.test.ts).
 - **`cff-probe.ts`'s CID-keyed CFF guard exists for a source-embedded-font phase this package hasn't built yet** — it is not wired into any write path today. Every face currently embedded is `glyf`-flavoured TrueType, and `sfnt-subset.ts` already refuses anything else before this guard would run.
 
 ## Text extraction and font encodings
@@ -315,7 +315,7 @@ A differential test pins the _set_ of template positions and offsets but not the
 
 **Supply a `FontRegistry` and Calibri/Cambria stop being an approximation at all** — the vendored Carlito/Caladea faces are the real metric-compatible TrueType families, resolved automatically. Aptos still has no vendored substitute. A resolved face is measured at its own real `hmtx` advances (never the width-correction table — applying both would silently draw text narrower than measured), subsetted to used glyphs, and embedded as a real `/Type0` + `/CIDFontType2` + `/FontFile2` group. Remaining limits: only TrueType (`glyf`) outlines can be embedded; a character with no glyph is drawn as `.notdef` and reported through `onMissingGlyph`; and vertical-metric policy is caller-chosen.
 
-**The acceptance bar for embedded-font fidelity is "no page-count drift on a real corpus", not "line-identical".** An embedded run is placed at real `hmtx` advances adjusted by real `GPOS` pair kerning — measured and drawn from one shared computation. What separates this from line-identical: `GSUB` ligatures/contextual alternates are never applied, and kerning is within each shown string rather than across whitespace boundaries a wrap decision measures separately.
+**The acceptance bar for embedded-font fidelity is "no page-count drift on a real corpus", not "line-identical".** An embedded run is placed at real `hmtx` advances adjusted by real `GPOS` pair kerning, shaped through real `GSUB` default ligatures — measured and drawn from one shared computation. What separates this from line-identical: contextual alternates and the opt-in layout features are never applied, and kerning is within each shown string rather than across whitespace boundaries a wrap decision measures separately.
 
 **The one exception is math-formula rendering (`WritePdfOptions.formulas`): this genuinely embeds a real, hand-parsed font.** Real box-model glyph runs through the embedded STIX Two Math font with genuine per-glyph metrics and font-wide layout constants parsed directly from the `MATH` table. Stretchy constructions are real: a `MathVariants` variant or assembly resolved, measured against actual outlines, and drawn by glyph ID.
 

package/dist/content-write.d.cts

@@ -1,6 +1,6 @@
 import { r as StandardFontName } from "./afm-widths-CneRyu5l.cjs";
 import { LayoutItem } from "./layout.cjs";
-import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
+import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-oc65VGlr.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { LayoutFont, TextMeasurer } from "document-schema.js";
 //#region src/content-write.d.ts

package/dist/content-write.d.ts

@@ -1,6 +1,6 @@
 import { r as StandardFontName } from "./afm-widths-CneRyu5l.js";
 import { LayoutItem } from "./layout.js";
-import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
+import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-B4p9a3O3.js";
 import { WinAnsiSubstitution } from "./winansi.js";
 import { LayoutFont, TextMeasurer } from "document-schema.js";
 //#region src/content-write.d.ts

package/dist/{embedded-font-fREdbxnr.d.ts → embedded-font-B4p9a3O3.d.ts}

@@ -1,4 +1,5 @@
 import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+import { t as GsubShaper } from "./gsub-table-BRTQ8EUW.js";
 //#region src/embedded-font.d.ts
 declare const NOTDEF_GLYPH_ID = 0;
 interface EmbeddedFaceMetrics {
@@ -27,6 +28,7 @@ interface EmbeddedFace {
   glyphId(codePoint: number): number | undefined;
   glyphSpaceWidth(glyphId: number): number;
   kernGlyphSpace(leftGlyphId: number, rightGlyphId: number): number;
+  readonly gsubShaper: GsubShaper | undefined;
 }
 declare function loadEmbeddedFace(font: SfntFont): EmbeddedFace | undefined;
 interface EmbeddedFaceSubstitution {
@@ -43,6 +45,6 @@ interface EmbeddedShow {
   readonly kerns: readonly EmbeddedKern[];
 }
 declare function encodeForShowEmbedded(text: string, face: EmbeddedFace): EmbeddedShow;
-declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, number>;
+declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, readonly number[]>;
 //#endregion
 export { EmbeddedShow as a, encodeForShowEmbedded as c, EmbeddedKern as i, loadEmbeddedFace as l, EmbeddedFaceMetrics as n, NOTDEF_GLYPH_ID as o, EmbeddedFaceSubstitution as r, collectEmbeddedGlyphs as s, EmbeddedFace as t };

package/dist/{embedded-font-BU6Jgcof.d.cts → embedded-font-oc65VGlr.d.cts}

@@ -1,4 +1,5 @@
 import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+import { t as GsubShaper } from "./gsub-table-URczLd85.cjs";
 //#region src/embedded-font.d.ts
 declare const NOTDEF_GLYPH_ID = 0;
 interface EmbeddedFaceMetrics {
@@ -27,6 +28,7 @@ interface EmbeddedFace {
   glyphId(codePoint: number): number | undefined;
   glyphSpaceWidth(glyphId: number): number;
   kernGlyphSpace(leftGlyphId: number, rightGlyphId: number): number;
+  readonly gsubShaper: GsubShaper | undefined;
 }
 declare function loadEmbeddedFace(font: SfntFont): EmbeddedFace | undefined;
 interface EmbeddedFaceSubstitution {
@@ -43,6 +45,6 @@ interface EmbeddedShow {
   readonly kerns: readonly EmbeddedKern[];
 }
 declare function encodeForShowEmbedded(text: string, face: EmbeddedFace): EmbeddedShow;
-declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, number>;
+declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, readonly number[]>;
 //#endregion
 export { EmbeddedShow as a, encodeForShowEmbedded as c, EmbeddedKern as i, loadEmbeddedFace as l, EmbeddedFaceMetrics as n, NOTDEF_GLYPH_ID as o, EmbeddedFaceSubstitution as r, collectEmbeddedGlyphs as s, EmbeddedFace as t };

package/dist/embedded-font-write.d.cts

@@ -1,5 +1,5 @@
 import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
-import { t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
+import { t as EmbeddedFace } from "./embedded-font-oc65VGlr.cjs";
 import { SfntSubsetResult } from "./sfnt-subset.cjs";
 //#region src/embedded-font-write.d.ts
 declare function embeddedSubsetTag(postScriptName: string, glyphIds: readonly number[]): string;
@@ -17,6 +17,6 @@ interface EmbeddedFontObjects {
   readonly fontFile: PdfObject;
   readonly toUnicode: PdfObject;
 }
-declare function buildEmbeddedFontObjects(face: EmbeddedFace, subset: SfntSubsetResult, usedGlyphs: ReadonlyMap<number, number>, refs: EmbeddedFontObjectRefs, compress: boolean): EmbeddedFontObjects;
+declare function buildEmbeddedFontObjects(face: EmbeddedFace, subset: SfntSubsetResult, usedGlyphs: ReadonlyMap<number, readonly number[]>, refs: EmbeddedFontObjectRefs, compress: boolean): EmbeddedFontObjects;
 //#endregion
 export { EmbeddedFontObjectRefs, EmbeddedFontObjects, buildEmbeddedFontObjects, embeddedSubsetTag };

package/dist/embedded-font-write.d.ts

@@ -1,5 +1,5 @@
 import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
-import { t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
+import { t as EmbeddedFace } from "./embedded-font-B4p9a3O3.js";
 import { SfntSubsetResult } from "./sfnt-subset.js";
 //#region src/embedded-font-write.d.ts
 declare function embeddedSubsetTag(postScriptName: string, glyphIds: readonly number[]): string;
@@ -17,6 +17,6 @@ interface EmbeddedFontObjects {
   readonly fontFile: PdfObject;
   readonly toUnicode: PdfObject;
 }
-declare function buildEmbeddedFontObjects(face: EmbeddedFace, subset: SfntSubsetResult, usedGlyphs: ReadonlyMap<number, number>, refs: EmbeddedFontObjectRefs, compress: boolean): EmbeddedFontObjects;
+declare function buildEmbeddedFontObjects(face: EmbeddedFace, subset: SfntSubsetResult, usedGlyphs: ReadonlyMap<number, readonly number[]>, refs: EmbeddedFontObjectRefs, compress: boolean): EmbeddedFontObjects;
 //#endregion
 export { EmbeddedFontObjectRefs, EmbeddedFontObjects, buildEmbeddedFontObjects, embeddedSubsetTag };

package/dist/embedded-font.cjs

@@ -4,6 +4,7 @@ const require_cmap_table = require("./cmap-table.cjs");
 const require_font_tables = require("./font-tables.cjs");
 const require_glyf = require("./glyf.cjs");
 const require_gpos_table = require("./gpos-table.cjs");
+const require_gsub_table = require("./gsub-table.cjs");
 const require_hmtx_table = require("./hmtx-table.cjs");
 //#region src/embedded-font.ts
 const GLYPH_SPACE_UNITS_PER_EM = 1e3;
@@ -57,10 +58,12 @@ function readEmbeddedFace(font) {
 	const scale = (designUnits) => scaleToGlyphSpace(designUnits, unitsPerEm);
 	const capHeight = resolveCapHeight(font, cmap, os2?.sCapHeight, hhea.ascent);
 	const kern = require_gpos_table.buildGposKernLookup(font);
+	const gsubShaper = require_gsub_table.buildGsubShaper(font);
 	return {
 		font,
 		postScriptName: name.postScriptName,
 		numGlyphs: maxp.numGlyphs,
+		gsubShaper,
 		metrics: {
 			unitsPerEm,
 			ascentGlyphSpace: scale(hhea.ascent),
@@ -109,30 +112,31 @@ function parseHhea(font) {
 }
 const CID_BYTE_LENGTH = 2;
 function encodeForShowEmbedded(text, face) {
-	const glyphIds = [];
+	const resolvedGlyphIds = [];
 	const substitutions = [];
-	const kerns = [];
-	let width1000 = 0;
 	for (const character of text) {
 		const glyphId = face.glyphId(character.codePointAt(0));
 		if (glyphId === void 0) substitutions.push({ from: character });
-		const shown = glyphId ?? 0;
-		const previous = glyphIds[glyphIds.length - 1];
-		if (previous !== void 0) {
-			const adjustment1000 = face.kernGlyphSpace(previous, shown);
+		resolvedGlyphIds.push(glyphId ?? 0);
+	}
+	const shownGlyphIds = face.gsubShaper === void 0 ? resolvedGlyphIds : face.gsubShaper(resolvedGlyphIds).glyphIds;
+	const kerns = [];
+	let width1000 = 0;
+	for (const [index, shown] of shownGlyphIds.entries()) {
+		if (index > 0) {
+			const adjustment1000 = face.kernGlyphSpace(shownGlyphIds[index - 1], shown);
 			if (adjustment1000 !== 0) {
 				kerns.push({
-					codeOffset: glyphIds.length * CID_BYTE_LENGTH,
+					codeOffset: index * CID_BYTE_LENGTH,
 					adjustment1000
 				});
 				width1000 += adjustment1000;
 			}
 		}
-		glyphIds.push(shown);
 		width1000 += face.glyphSpaceWidth(shown);
 	}
-	const codes = new Uint8Array(glyphIds.length * CID_BYTE_LENGTH);
-	glyphIds.forEach((glyphId, index) => {
+	const codes = new Uint8Array(shownGlyphIds.length * CID_BYTE_LENGTH);
+	shownGlyphIds.forEach((glyphId, index) => {
 		codes[index * CID_BYTE_LENGTH] = glyphId >> 8 & 255;
 		codes[index * CID_BYTE_LENGTH + 1] = glyphId & 255;
 	});
@@ -145,10 +149,37 @@ function encodeForShowEmbedded(text, face) {
 }
 function collectEmbeddedGlyphs(texts, face) {
 	const used = /* @__PURE__ */ new Map();
-	for (const text of texts) for (const character of text) {
-		const codePoint = character.codePointAt(0);
-		const glyphId = face.glyphId(codePoint);
-		if (glyphId !== void 0 && !used.has(glyphId)) used.set(glyphId, codePoint);
+	for (const text of texts) {
+		const resolvedGlyphIds = [];
+		const codePoints = [];
+		for (const character of text) {
+			const codePoint = character.codePointAt(0);
+			const glyphId = face.glyphId(codePoint);
+			if (glyphId === void 0) {
+				resolvedGlyphIds.push(0);
+				codePoints.push(void 0);
+			} else {
+				resolvedGlyphIds.push(glyphId);
+				codePoints.push(codePoint);
+			}
+		}
+		const shaping = face.gsubShaper === void 0 ? {
+			glyphIds: resolvedGlyphIds,
+			spans: resolvedGlyphIds.map(() => 1)
+		} : face.gsubShaper(resolvedGlyphIds);
+		let cursor = 0;
+		for (const [index, glyphId] of shaping.glyphIds.entries()) {
+			const span = shaping.spans[index];
+			const sequence = [];
+			for (let s = 0; s < span; s++) {
+				const codePoint = codePoints[cursor + s];
+				if (codePoint !== void 0) sequence.push(codePoint);
+			}
+			cursor += span;
+			if (glyphId !== 0 && sequence.length > 0) {
+				if (used.get(glyphId) === void 0) used.set(glyphId, sequence);
+			}
+		}
 	}
 	return used;
 }

package/dist/embedded-font.d.cts

@@ -1,2 +1,2 @@
-import { a as EmbeddedShow, c as encodeForShowEmbedded, i as EmbeddedKern, l as loadEmbeddedFace, n as EmbeddedFaceMetrics, o as NOTDEF_GLYPH_ID, r as EmbeddedFaceSubstitution, s as collectEmbeddedGlyphs, t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
+import { a as EmbeddedShow, c as encodeForShowEmbedded, i as EmbeddedKern, l as loadEmbeddedFace, n as EmbeddedFaceMetrics, o as NOTDEF_GLYPH_ID, r as EmbeddedFaceSubstitution, s as collectEmbeddedGlyphs, t as EmbeddedFace } from "./embedded-font-oc65VGlr.cjs";
 export { EmbeddedFace, EmbeddedFaceMetrics, EmbeddedFaceSubstitution, EmbeddedKern, EmbeddedShow, NOTDEF_GLYPH_ID, collectEmbeddedGlyphs, encodeForShowEmbedded, loadEmbeddedFace };

package/dist/embedded-font.d.ts

@@ -1,2 +1,2 @@
-import { a as EmbeddedShow, c as encodeForShowEmbedded, i as EmbeddedKern, l as loadEmbeddedFace, n as EmbeddedFaceMetrics, o as NOTDEF_GLYPH_ID, r as EmbeddedFaceSubstitution, s as collectEmbeddedGlyphs, t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
+import { a as EmbeddedShow, c as encodeForShowEmbedded, i as EmbeddedKern, l as loadEmbeddedFace, n as EmbeddedFaceMetrics, o as NOTDEF_GLYPH_ID, r as EmbeddedFaceSubstitution, s as collectEmbeddedGlyphs, t as EmbeddedFace } from "./embedded-font-B4p9a3O3.js";
 export { EmbeddedFace, EmbeddedFaceMetrics, EmbeddedFaceSubstitution, EmbeddedKern, EmbeddedShow, NOTDEF_GLYPH_ID, collectEmbeddedGlyphs, encodeForShowEmbedded, loadEmbeddedFace };

package/dist/embedded-font.js

@@ -3,6 +3,7 @@ import { buildCmapLookup } from "./cmap-table.js";
 import { parseHead, parseMaxp, parseName, parseOs2, parsePost } from "./font-tables.js";
 import { parseGlyf } from "./glyf.js";
 import { buildGposKernLookup } from "./gpos-table.js";
+import { buildGsubShaper } from "./gsub-table.js";
 import { parseHmtx } from "./hmtx-table.js";
 //#region src/embedded-font.ts
 const GLYPH_SPACE_UNITS_PER_EM = 1e3;
@@ -56,10 +57,12 @@ function readEmbeddedFace(font) {
 	const scale = (designUnits) => scaleToGlyphSpace(designUnits, unitsPerEm);
 	const capHeight = resolveCapHeight(font, cmap, os2?.sCapHeight, hhea.ascent);
 	const kern = buildGposKernLookup(font);
+	const gsubShaper = buildGsubShaper(font);
 	return {
 		font,
 		postScriptName: name.postScriptName,
 		numGlyphs: maxp.numGlyphs,
+		gsubShaper,
 		metrics: {
 			unitsPerEm,
 			ascentGlyphSpace: scale(hhea.ascent),
@@ -108,30 +111,31 @@ function parseHhea(font) {
 }
 const CID_BYTE_LENGTH = 2;
 function encodeForShowEmbedded(text, face) {
-	const glyphIds = [];
+	const resolvedGlyphIds = [];
 	const substitutions = [];
-	const kerns = [];
-	let width1000 = 0;
 	for (const character of text) {
 		const glyphId = face.glyphId(character.codePointAt(0));
 		if (glyphId === void 0) substitutions.push({ from: character });
-		const shown = glyphId ?? 0;
-		const previous = glyphIds[glyphIds.length - 1];
-		if (previous !== void 0) {
-			const adjustment1000 = face.kernGlyphSpace(previous, shown);
+		resolvedGlyphIds.push(glyphId ?? 0);
+	}
+	const shownGlyphIds = face.gsubShaper === void 0 ? resolvedGlyphIds : face.gsubShaper(resolvedGlyphIds).glyphIds;
+	const kerns = [];
+	let width1000 = 0;
+	for (const [index, shown] of shownGlyphIds.entries()) {
+		if (index > 0) {
+			const adjustment1000 = face.kernGlyphSpace(shownGlyphIds[index - 1], shown);
 			if (adjustment1000 !== 0) {
 				kerns.push({
-					codeOffset: glyphIds.length * CID_BYTE_LENGTH,
+					codeOffset: index * CID_BYTE_LENGTH,
 					adjustment1000
 				});
 				width1000 += adjustment1000;
 			}
 		}
-		glyphIds.push(shown);
 		width1000 += face.glyphSpaceWidth(shown);
 	}
-	const codes = new Uint8Array(glyphIds.length * CID_BYTE_LENGTH);
-	glyphIds.forEach((glyphId, index) => {
+	const codes = new Uint8Array(shownGlyphIds.length * CID_BYTE_LENGTH);
+	shownGlyphIds.forEach((glyphId, index) => {
 		codes[index * CID_BYTE_LENGTH] = glyphId >> 8 & 255;
 		codes[index * CID_BYTE_LENGTH + 1] = glyphId & 255;
 	});
@@ -144,10 +148,37 @@ function encodeForShowEmbedded(text, face) {
 }
 function collectEmbeddedGlyphs(texts, face) {
 	const used = /* @__PURE__ */ new Map();
-	for (const text of texts) for (const character of text) {
-		const codePoint = character.codePointAt(0);
-		const glyphId = face.glyphId(codePoint);
-		if (glyphId !== void 0 && !used.has(glyphId)) used.set(glyphId, codePoint);
+	for (const text of texts) {
+		const resolvedGlyphIds = [];
+		const codePoints = [];
+		for (const character of text) {
+			const codePoint = character.codePointAt(0);
+			const glyphId = face.glyphId(codePoint);
+			if (glyphId === void 0) {
+				resolvedGlyphIds.push(0);
+				codePoints.push(void 0);
+			} else {
+				resolvedGlyphIds.push(glyphId);
+				codePoints.push(codePoint);
+			}
+		}
+		const shaping = face.gsubShaper === void 0 ? {
+			glyphIds: resolvedGlyphIds,
+			spans: resolvedGlyphIds.map(() => 1)
+		} : face.gsubShaper(resolvedGlyphIds);
+		let cursor = 0;
+		for (const [index, glyphId] of shaping.glyphIds.entries()) {
+			const span = shaping.spans[index];
+			const sequence = [];
+			for (let s = 0; s < span; s++) {
+				const codePoint = codePoints[cursor + s];
+				if (codePoint !== void 0) sequence.push(codePoint);
+			}
+			cursor += span;
+			if (glyphId !== 0 && sequence.length > 0) {
+				if (used.get(glyphId) === void 0) used.set(glyphId, sequence);
+			}
+		}
 	}
 	return used;
 }

package/dist/font-registry.d.cts

@@ -1,5 +1,5 @@
 import { r as StandardFontName } from "./afm-widths-CneRyu5l.cjs";
-import { t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
+import { t as EmbeddedFace } from "./embedded-font-oc65VGlr.cjs";
 import { FontRegistryOptions, LayoutFont } from "document-schema.js";
 //#region src/font-registry.d.ts
 type ResolvedFace = {

package/dist/font-registry.d.ts

@@ -1,5 +1,5 @@
 import { r as StandardFontName } from "./afm-widths-CneRyu5l.js";
-import { t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
+import { t as EmbeddedFace } from "./embedded-font-B4p9a3O3.js";
 import { FontRegistryOptions, LayoutFont } from "document-schema.js";
 //#region src/font-registry.d.ts
 type ResolvedFace = {

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