pdf-codec 4.2.0 → 4.4.0

package/README.md

@@ -234,7 +234,7 @@ The package is layered from generic primitives outward to the codec itself:
 - **`src/util/`** — two small independently-duplicated copies of family-shared logic: `base64.ts` (verbatim copy of `odf.js`'s own, replacing a former `ooxml.js` dependency for this one helper) and `abort.ts` (`throwIfAborted`, called at every page loop boundary — there is no `await` point in this synchronous pipeline for cancellation to hook into implicitly).
 - **`src/crypto/`** — MD5, SHA-256/384/512, RC4, and AES-CBC, hand-written with zero local imports, plus a thin `random.ts` wrapper around `globalThis.crypto.getRandomValues` for the writer's own salts/file keys/IVs. Not a preference: ISO 32000-1's key-derivation algorithms name MD5 and RC4 directly, neither offered by any portable platform crypto API, and `crypto.subtle` is asynchronous where this codec's read and write paths are both synchronous end to end — `getRandomValues` itself, unlike `crypto.subtle`, is synchronous and portable, so it is used directly rather than hand-written. Reaching for `node:crypto` would break the browser bundle. Each hash/cipher module cites its specification (RFC 1321, FIPS 180-4, FIPS 197) and is tested against published conformance vectors.
 - **The codec itself, importing only `layout`/`bytes`/`image`/`crypto`/`util` plus `document-schema.js`'s port types (no OOXML or ODF knowledge):**
-  - **Write**: `objects.ts` (the `PdfObject` discriminated union), `afm-widths.ts`/`encoding.ts`/`winansi.ts`/`fonts.ts` (standard-14 metrics, WinAnsi encoding, family resolution), `font-registry.ts` (resolution port plus `resolveFaceWithRegistry`, the one step both measurer and writer resolve through so they can never disagree about which face a `LayoutFont` means), `font-face.ts` (`readFontFace`, reading a standalone font file's family/bold/italic triple off its `name`/`OS/2`/`head` tables), `measure.ts`/`text-layout.ts` (greedy line-wrapping against either standard-14 AFM widths plus per-family correction or a resolved face's own real `hmtx` advances — never both), `content-write.ts` (`LayoutItem[]` → content-stream operators, with text branching on standard-14 vs embedded face encoding, pair-kerning split into `TJ` arrays, and stroke `style` becoming real dash/line-cap state), `write.ts` (the full object graph, cross-reference table, trailer, and embedded font groups).
+  - **Write**: `objects.ts` (the `PdfObject` discriminated union), `afm-widths.ts`/`encoding.ts`/`winansi.ts`/`fonts.ts` (standard-14 metrics, WinAnsi encoding, family resolution), `font-registry.ts` (resolution port plus `resolveFaceWithRegistry`, the one step both measurer and writer resolve through so they can never disagree about which face a `LayoutFont` means), `font-face.ts` (`readFontFace`, reading a standalone font file's family/bold/italic triple off its `name`/`OS/2`/`head` tables), `measure.ts`/`text-layout.ts` (greedy line-wrapping against either standard-14 AFM widths plus per-family correction or a resolved face's own real `hmtx` advances — never both), `content-write.ts` (`LayoutItem[]` → content-stream operators, with text branching on standard-14 vs embedded face encoding, pair-kerning split into `TJ` arrays, stroke `style` becoming real dash/line-cap state, and `/P <</MCID n /OC R>> BDC`…`EMC` spans around items carrying a structure owner or an optional-content layer — the one marked-content spelling both read-side channels resolve through), `write.ts` (the full object graph, cross-reference table, trailer, and embedded font groups, plus the document-level round-trip surfaces: the `/Names /EmbeddedFiles` attachments tree and `/Outlines` bookmark tree, `/OCProperties` optional-content groups with each layer stated explicitly into the default configuration's `/ON` or `/OFF` list, the `/AcroForm` field tree with the merged-field/widget spelling (a single widget merges into its field dict; further widgets are separate `/Subtype /Widget` kids, and fully-qualified names decompose back into the `/T` chain), the `/StructTreeRoot` element tree with its `/ParentTree` number tree associating each marked item's MCID to its owning element, and the package-level residue rows restored inline onto the Catalog or trailer — the XMP packet as an uncompressed `/Metadata` stream, and any row whose serialisation references source-file objects skipped rather than emitted as a dangling reference).
   - **sfnt font tables**: `sfnt.ts` (bounds-checked table-directory reader), `cmap-table.ts` (character code → glyph ID, formats 0/4/6/12, exposed both as the best Unicode lookup and as every subtable individually, since a (3, 0) or (1, 0) subtable is keyed by a font's own codes rather than by code points), `hmtx-table.ts` (per-glyph advance widths), `font-tables.ts` (`head`/`maxp`/`OS/2`/`post`/`name`, including `post`'s own glyph names where a font still carries them), `glyf.ts` (`loca` offset index, per-glyph headers, composite component records, `glyphInkBounds`), `math-table.ts` (OpenType `MATH` constants/glyph-info/variants subtables). `ot-layout-common.ts` (Coverage/ClassDef, stored as sorted glyph ranges searched by bisection). `gpos-table.ts` reads `GPOS` for exactly one thing: pair-advance kerning through the `kern` feature, both PairPos formats and LookupType 9 Extension indirection — mark attachment, cursive joining, and contextual positioning have no consumer here. Every parser degrades to `undefined` on a missing/truncated table rather than throwing.
   - **sfnt subsetting**: `sfnt-subset.ts` — a TrueType-outline glyph subsetter (Unicode code points → glyph IDs via `cmap`, transitive closure over `glyf` composite components, rebuilt sfnt carrying only used outlines). **Glyph IDs are preserved, never renumbered**, keeping composite component references valid and making CID == GID trivially true. Output rebuilds `head`/`hhea`/`maxp`/`loca`/`glyf`/`hmtx`, copies hinting programs verbatim, stubs `post`, omits `cmap`/`name`/`OS/2`/`GSUB`/`GPOS`/`kern` (none read through a `CIDFontType2` program per ISO 32000-1 9.9). Applies to `glyf`-flavoured fonts only; CFF returns `undefined`.
   - **Embedded math font**: `math-font.ts` (parses/caches the vendored STIX Two Math font, exposing size-specific `MathFontMetrics` and stretchy-glyph entry points), `math-stretch.ts` (OpenType MATH two-stage stretching: pick smallest pre-built variant reaching target, else assemble from repeated parts with seams overlapped), `math-font-write.ts` (builds the `/Type0`/`/CIDFontType0`/`/FontDescriptor`/`/FontFile3`/ToUnicode group), `math-content-write.ts` (`PositionedFormula[]` → content-stream bytes, Identity-H CIDs for text, `re`/`m`/`l` operators for rules, glyph-ID-addressed text objects for stretched constructions wrapped in `/ActualText`).
@@ -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.cjs

@@ -313,16 +313,38 @@ function writeContentStream(items, context) {
 	const writer = new require_bytes_writer.ByteWriter();
 	const substitutions = [];
 	const missingGlyphs = [];
-	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions, missingGlyphs);
-	else if (item.kind === "image") writeImage(writer, item, context);
-	else if (item.kind === "rect") writeRect(writer, item);
-	else if (item.kind === "line") writeLine(writer, item);
-	else if (item.kind === "ellipse") writeEllipse(writer, item);
-	else if (item.kind === "path") writePath(writer, item);
+	const markedStructure = [];
+	for (const item of items) {
+		const itemLayer = "layer" in item ? item.layer : void 0;
+		const itemStructure = "structure" in item ? item.structure : void 0;
+		const layerObjectNum = itemLayer !== void 0 ? context.layerObjectNumberOf?.(itemLayer) : void 0;
+		const marked = itemStructure !== void 0 || layerObjectNum !== void 0;
+		if (marked) {
+			writer.writeAscii("/P <<");
+			if (itemStructure !== void 0 && context.nextMcid !== void 0) {
+				const mcid = context.nextMcid();
+				markedStructure.push({
+					mcid,
+					structureId: itemStructure
+				});
+				writer.writeAscii(` /MCID ${mcid}`);
+			}
+			if (layerObjectNum !== void 0) writer.writeAscii(` /OC ${layerObjectNum} 0 R`);
+			writer.writeAscii(" >> BDC\n");
+		}
+		if (item.kind === "text") writeText(writer, item, context, substitutions, missingGlyphs);
+		else if (item.kind === "image") writeImage(writer, item, context);
+		else if (item.kind === "rect") writeRect(writer, item);
+		else if (item.kind === "line") writeLine(writer, item);
+		else if (item.kind === "ellipse") writeEllipse(writer, item);
+		else if (item.kind === "path") writePath(writer, item);
+		if (marked) writer.writeAscii("EMC\n");
+	}
 	return {
 		bytes: writer.toBytes(),
 		substitutions,
-		missingGlyphs
+		missingGlyphs,
+		markedStructure
 	};
 }
 //#endregion

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
@@ -20,12 +20,19 @@ interface ContentWriteContext {
   readonly measurer: TextMeasurer;
   resolveFont(font: LayoutFont): ResolvedFontResource;
   resolveImage(imageId: string): ResolvedImageResource;
+  readonly layerObjectNumberOf?: (name: string) => number | undefined;
+  readonly nextMcid?: () => number;
 }
 interface ContentStreamResult {
   readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly markedStructure: readonly MarkedStructureItem[];
   readonly substitutions: readonly WinAnsiSubstitution[];
   readonly missingGlyphs: readonly EmbeddedFaceSubstitution[];
 }
 declare function writeContentStream(items: readonly LayoutItem[], context: ContentWriteContext): ContentStreamResult;
+interface MarkedStructureItem {
+  readonly mcid: number;
+  readonly structureId: string;
+}
 //#endregion
-export { ContentStreamResult, ContentWriteContext, ResolvedFontResource, ResolvedImageResource, writeContentStream };
+export { ContentStreamResult, ContentWriteContext, MarkedStructureItem, ResolvedFontResource, ResolvedImageResource, writeContentStream };

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
@@ -20,12 +20,19 @@ interface ContentWriteContext {
   readonly measurer: TextMeasurer;
   resolveFont(font: LayoutFont): ResolvedFontResource;
   resolveImage(imageId: string): ResolvedImageResource;
+  readonly layerObjectNumberOf?: (name: string) => number | undefined;
+  readonly nextMcid?: () => number;
 }
 interface ContentStreamResult {
   readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly markedStructure: readonly MarkedStructureItem[];
   readonly substitutions: readonly WinAnsiSubstitution[];
   readonly missingGlyphs: readonly EmbeddedFaceSubstitution[];
 }
 declare function writeContentStream(items: readonly LayoutItem[], context: ContentWriteContext): ContentStreamResult;
+interface MarkedStructureItem {
+  readonly mcid: number;
+  readonly structureId: string;
+}
 //#endregion
-export { ContentStreamResult, ContentWriteContext, ResolvedFontResource, ResolvedImageResource, writeContentStream };
+export { ContentStreamResult, ContentWriteContext, MarkedStructureItem, ResolvedFontResource, ResolvedImageResource, writeContentStream };

package/dist/content-write.js

@@ -312,16 +312,38 @@ function writeContentStream(items, context) {
 	const writer = new ByteWriter();
 	const substitutions = [];
 	const missingGlyphs = [];
-	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions, missingGlyphs);
-	else if (item.kind === "image") writeImage(writer, item, context);
-	else if (item.kind === "rect") writeRect(writer, item);
-	else if (item.kind === "line") writeLine(writer, item);
-	else if (item.kind === "ellipse") writeEllipse(writer, item);
-	else if (item.kind === "path") writePath(writer, item);
+	const markedStructure = [];
+	for (const item of items) {
+		const itemLayer = "layer" in item ? item.layer : void 0;
+		const itemStructure = "structure" in item ? item.structure : void 0;
+		const layerObjectNum = itemLayer !== void 0 ? context.layerObjectNumberOf?.(itemLayer) : void 0;
+		const marked = itemStructure !== void 0 || layerObjectNum !== void 0;
+		if (marked) {
+			writer.writeAscii("/P <<");
+			if (itemStructure !== void 0 && context.nextMcid !== void 0) {
+				const mcid = context.nextMcid();
+				markedStructure.push({
+					mcid,
+					structureId: itemStructure
+				});
+				writer.writeAscii(` /MCID ${mcid}`);
+			}
+			if (layerObjectNum !== void 0) writer.writeAscii(` /OC ${layerObjectNum} 0 R`);
+			writer.writeAscii(" >> BDC\n");
+		}
+		if (item.kind === "text") writeText(writer, item, context, substitutions, missingGlyphs);
+		else if (item.kind === "image") writeImage(writer, item, context);
+		else if (item.kind === "rect") writeRect(writer, item);
+		else if (item.kind === "line") writeLine(writer, item);
+		else if (item.kind === "ellipse") writeEllipse(writer, item);
+		else if (item.kind === "path") writePath(writer, item);
+		if (marked) writer.writeAscii("EMC\n");
+	}
 	return {
 		bytes: writer.toBytes(),
 		substitutions,
-		missingGlyphs
+		missingGlyphs,
+		markedStructure
 	};
 }
 //#endregion

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