pdf-codec 4.1.0 → 4.3.0

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

package/dist/index.d.cts

@@ -3,7 +3,7 @@ import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnost
 import { LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema } from "./layout.cjs";
 import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
 import { PdfBytesSchema, pdfCodec } from "./codec.cjs";
-import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
+import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-oc65VGlr.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { PdfEncryptionError, PdfEncryptionOptions, PdfEncryptionPermissions, PdfEncryptionScheme } from "./encrypt-write.cjs";
 import { FontFace, FontFaceParseError, readFontFace } from "./font-face.cjs";

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnost
 import { LAYOUT_FORMAT_VERSION, LayoutAnnotation, LayoutAnnotationQuad, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachment, LayoutAttachmentSchema, LayoutDestination, LayoutDestinationSchema, LayoutDestinationTarget, LayoutDestinationTargetSchema, LayoutDocument, LayoutDocumentSchema, LayoutEllipse, LayoutEllipseSchema, LayoutFormField, LayoutFormFieldSchema, LayoutFormWidget, LayoutFormWidgetSchema, LayoutImage, LayoutImageAsset, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLink, LayoutInternalLinkSchema, LayoutItem, LayoutItemSchema, LayoutLayer, LayoutLayerSchema, LayoutLine, LayoutLineSchema, LayoutLink, LayoutLinkSchema, LayoutOutlineItem, LayoutOutlineItemSchema, LayoutPage, LayoutPageSchema, LayoutPath, LayoutPathSchema, LayoutPathSegment, LayoutPathSegmentSchema, LayoutRect, LayoutRectSchema, LayoutStructureElement, LayoutStructureElementSchema, LayoutSubpath, LayoutSubpathSchema, LayoutText, LayoutTextSchema } from "./layout.js";
 import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
 import { PdfBytesSchema, pdfCodec } from "./codec.js";
-import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
+import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-B4p9a3O3.js";
 import { WinAnsiSubstitution } from "./winansi.js";
 import { PdfEncryptionError, PdfEncryptionOptions, PdfEncryptionPermissions, PdfEncryptionScheme } from "./encrypt-write.js";
 import { FontFace, FontFaceParseError, readFontFace } from "./font-face.js";

package/dist/math-font-write.cjs

@@ -40,7 +40,7 @@ function buildFontFileStream(font, compress) {
 }
 function toUnicodeEntries(usedGlyphs) {
 	const entries = /* @__PURE__ */ new Map();
-	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, codePoint);
+	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, [codePoint]);
 	return entries;
 }
 function buildMathFontObjects(font, usedGlyphs, refs, compress) {

package/dist/math-font-write.js

@@ -39,7 +39,7 @@ function buildFontFileStream(font, compress) {
 }
 function toUnicodeEntries(usedGlyphs) {
 	const entries = /* @__PURE__ */ new Map();
-	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, codePoint);
+	for (const [glyphId, codePoint] of usedGlyphs) if (codePoint !== void 0) entries.set(glyphId, [codePoint]);
 	return entries;
 }
 function buildMathFontObjects(font, usedGlyphs, refs, compress) {

package/dist/sfnt-subset.cjs

@@ -71,7 +71,7 @@ function buildPostStub(font) {
 	if (sourcePost !== void 0 && require_sfnt.hasBytes(sourcePost, POST_METRICS_OFFSET, POST_METRICS_SIZE)) post.set(sourcePost.subarray(POST_METRICS_OFFSET, 16), POST_METRICS_OFFSET);
 	return post;
 }
-function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
+function collectGlyphIds(glyf, cmap, numGlyphs, codePoints, extraGlyphIds) {
 	const used = /* @__PURE__ */ new Set([0]);
 	const unmapped = /* @__PURE__ */ new Set();
 	const pending = [0];
@@ -87,6 +87,13 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 			pending.push(glyphId);
 		}
 	}
+	for (const glyphId of extraGlyphIds) {
+		if (glyphId >= numGlyphs) return;
+		if (!used.has(glyphId)) {
+			used.add(glyphId);
+			pending.push(glyphId);
+		}
+	}
 	while (pending.length > 0) {
 		const glyphId = pending.pop();
 		if (glyf.glyphBytes(glyphId) === void 0) return;
@@ -107,7 +114,7 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 		unmapped: [...unmapped].sort((a, b) => a - b)
 	};
 }
-function subsetSfnt(font, codePoints) {
+function subsetSfnt(font, codePoints, extraGlyphIds = []) {
 	const head = require_font_tables.parseHead(font);
 	const maxp = require_font_tables.parseMaxp(font);
 	const sourceHead = require_sfnt.sfntTableBytes(font, "head");
@@ -124,7 +131,7 @@ function subsetSfnt(font, codePoints) {
 	});
 	const cmap = require_cmap_table.buildCmapLookup(font);
 	if (glyf === void 0 || cmap === void 0) return;
-	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints);
+	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints, extraGlyphIds);
 	if (collected === void 0) return;
 	const glyphIds = [...collected.used].sort((a, b) => a - b);
 	const numGlyphs = glyphIds[glyphIds.length - 1] + 1;

package/dist/sfnt-subset.d.cts

@@ -6,6 +6,6 @@ interface SfntSubsetResult {
   readonly glyphIds: readonly number[];
   readonly unmappedCodePoints: readonly number[];
 }
-declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>, extraGlyphIds?: Iterable<number>): SfntSubsetResult | undefined;
 //#endregion
 export { SfntSubsetResult, subsetSfnt };

package/dist/sfnt-subset.d.ts

@@ -6,6 +6,6 @@ interface SfntSubsetResult {
   readonly glyphIds: readonly number[];
   readonly unmappedCodePoints: readonly number[];
 }
-declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>, extraGlyphIds?: Iterable<number>): SfntSubsetResult | undefined;
 //#endregion
 export { SfntSubsetResult, subsetSfnt };

package/dist/sfnt-subset.js

@@ -70,7 +70,7 @@ function buildPostStub(font) {
 	if (sourcePost !== void 0 && hasBytes(sourcePost, POST_METRICS_OFFSET, POST_METRICS_SIZE)) post.set(sourcePost.subarray(POST_METRICS_OFFSET, 16), POST_METRICS_OFFSET);
 	return post;
 }
-function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
+function collectGlyphIds(glyf, cmap, numGlyphs, codePoints, extraGlyphIds) {
 	const used = /* @__PURE__ */ new Set([0]);
 	const unmapped = /* @__PURE__ */ new Set();
 	const pending = [0];
@@ -86,6 +86,13 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 			pending.push(glyphId);
 		}
 	}
+	for (const glyphId of extraGlyphIds) {
+		if (glyphId >= numGlyphs) return;
+		if (!used.has(glyphId)) {
+			used.add(glyphId);
+			pending.push(glyphId);
+		}
+	}
 	while (pending.length > 0) {
 		const glyphId = pending.pop();
 		if (glyf.glyphBytes(glyphId) === void 0) return;
@@ -106,7 +113,7 @@ function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
 		unmapped: [...unmapped].sort((a, b) => a - b)
 	};
 }
-function subsetSfnt(font, codePoints) {
+function subsetSfnt(font, codePoints, extraGlyphIds = []) {
 	const head = parseHead(font);
 	const maxp = parseMaxp(font);
 	const sourceHead = sfntTableBytes(font, "head");
@@ -123,7 +130,7 @@ function subsetSfnt(font, codePoints) {
 	});
 	const cmap = buildCmapLookup(font);
 	if (glyf === void 0 || cmap === void 0) return;
-	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints);
+	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints, extraGlyphIds);
 	if (collected === void 0) return;
 	const glyphIds = [...collected.used].sort((a, b) => a - b);
 	const numGlyphs = glyphIds[glyphIds.length - 1] + 1;

package/dist/tounicode.cjs

@@ -8,8 +8,13 @@ function codePointToUtf16BEHex(codePoint) {
 	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
 	return hex;
 }
-function buildToUnicodeCMap(codeToCodePoint) {
-	const entries = [...codeToCodePoint].sort((a, b) => a[0] - b[0]);
+function sequenceToUtf16BEHex(codePoints) {
+	let hex = "";
+	for (const codePoint of codePoints) hex += codePointToUtf16BEHex(codePoint);
+	return hex;
+}
+function buildToUnicodeCMap(codeToSequence) {
+	const entries = [...codeToSequence].sort((a, b) => a[0] - b[0]);
 	const lines = [
 		"/CIDInit /ProcSet findresource begin",
 		"12 dict begin",
@@ -24,7 +29,7 @@ function buildToUnicodeCMap(codeToCodePoint) {
 	for (let start = 0; start < entries.length; start += MAX_BFCHAR_ENTRIES_PER_BLOCK) {
 		const block = entries.slice(start, start + MAX_BFCHAR_ENTRIES_PER_BLOCK);
 		lines.push(`${block.length} beginbfchar`);
-		for (const [code, codePoint] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+		for (const [code, sequence] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${sequenceToUtf16BEHex(sequence)}>`);
 		lines.push("endbfchar");
 	}
 	lines.push("endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");

package/dist/tounicode.d.cts

@@ -1,5 +1,5 @@
 import { r as PdfObject } from "./objects-B7HdMeWS.cjs";
 //#region src/tounicode.d.ts
-declare function buildToUnicodeCMap(codeToCodePoint: ReadonlyMap<number, number>): PdfObject;
+declare function buildToUnicodeCMap(codeToSequence: ReadonlyMap<number, readonly number[]>): PdfObject;
 //#endregion
 export { buildToUnicodeCMap };

package/dist/tounicode.d.ts

@@ -1,5 +1,5 @@
 import { r as PdfObject } from "./objects-B7HdMeWS.js";
 //#region src/tounicode.d.ts
-declare function buildToUnicodeCMap(codeToCodePoint: ReadonlyMap<number, number>): PdfObject;
+declare function buildToUnicodeCMap(codeToSequence: ReadonlyMap<number, readonly number[]>): PdfObject;
 //#endregion
 export { buildToUnicodeCMap };

package/dist/tounicode.js

@@ -7,8 +7,13 @@ function codePointToUtf16BEHex(codePoint) {
 	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
 	return hex;
 }
-function buildToUnicodeCMap(codeToCodePoint) {
-	const entries = [...codeToCodePoint].sort((a, b) => a[0] - b[0]);
+function sequenceToUtf16BEHex(codePoints) {
+	let hex = "";
+	for (const codePoint of codePoints) hex += codePointToUtf16BEHex(codePoint);
+	return hex;
+}
+function buildToUnicodeCMap(codeToSequence) {
+	const entries = [...codeToSequence].sort((a, b) => a[0] - b[0]);
 	const lines = [
 		"/CIDInit /ProcSet findresource begin",
 		"12 dict begin",
@@ -23,7 +28,7 @@ function buildToUnicodeCMap(codeToCodePoint) {
 	for (let start = 0; start < entries.length; start += MAX_BFCHAR_ENTRIES_PER_BLOCK) {
 		const block = entries.slice(start, start + MAX_BFCHAR_ENTRIES_PER_BLOCK);
 		lines.push(`${block.length} beginbfchar`);
-		for (const [code, codePoint] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+		for (const [code, sequence] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${sequenceToUtf16BEHex(sequence)}>`);
 		lines.push("endbfchar");
 	}
 	lines.push("endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");

package/dist/write.cjs

@@ -202,11 +202,14 @@ function destinationViewArray(target) {
 	if (target.kind === "fitBV") return [require_objects.pdfName("FitBV"), n(target.leftPt)];
 	return [require_objects.pdfName(target.kind === "fitB" ? "FitB" : "Fit")];
 }
-function buildInternalLinkAnnotDict(link, doc, pageAllocs) {
-	const destination = doc.destinations?.find((d) => d.name === link.destination);
-	if (destination === void 0) throw new Error(`internal link names destination "${link.destination}", which the document's destinations table does not carry -- this is a caller-invariant violation`);
+function resolveDestinationArray(doc, pageAllocs, name, what) {
+	const destination = doc.destinations?.find((d) => d.name === name);
+	if (destination === void 0) throw new Error(`${what} names destination "${name}", which the document's destinations table does not carry -- this is a caller-invariant violation`);
 	const targetPage = pageAllocs[destination.pageIndex];
-	if (targetPage === void 0) throw new Error(`destination "${link.destination}" names page index ${destination.pageIndex}, which is beyond the document's own pages -- this is a caller-invariant violation`);
+	if (targetPage === void 0) throw new Error(`destination "${destination.name}" names page index ${destination.pageIndex}, which is beyond the document's own pages -- this is a caller-invariant violation`);
+	return [require_objects.pdfRef(targetPage.pageNum, 0), ...destinationViewArray(destination.target)];
+}
+function buildInternalLinkAnnotDict(link, doc, pageAllocs) {
 	return require_objects.pdfDict({
 		Type: require_objects.pdfName("Annot"),
 		Subtype: require_objects.pdfName("Link"),
@@ -221,7 +224,7 @@ function buildInternalLinkAnnotDict(link, doc, pageAllocs) {
 			0,
 			0
 		].map((v) => require_objects.pdfNum(v))),
-		Dest: require_objects.pdfArray([require_objects.pdfRef(targetPage.pageNum, 0), ...destinationViewArray(destination.target)])
+		Dest: require_objects.pdfArray(resolveDestinationArray(doc, pageAllocs, link.destination, "internal link"))
 	});
 }
 function isLinkItem(item) {
@@ -322,13 +325,28 @@ function writePdf(doc, options = {}) {
 		contentsNum: nextObjNum++
 	}));
 	const encryptDictNum = options.encryption === void 0 ? void 0 : nextObjNum++;
+	const attachmentAllocs = (doc.attachments ?? []).map(() => ({
+		fileNum: nextObjNum++,
+		specNum: nextObjNum++
+	}));
+	const attachmentsNamesNum = attachmentAllocs.length > 0 ? nextObjNum++ : void 0;
+	const outlineRootNum = (doc.outline ?? []).length > 0 ? nextObjNum++ : void 0;
+	const outlineItemNums = [];
+	if (outlineRootNum !== void 0) {
+		const countItems = (items) => {
+			let n = 0;
+			for (const item of items) n += 1 + countItems(item.children);
+			return n;
+		};
+		for (let i = 0; i < countItems(doc.outline ?? []); i += 1) outlineItemNums.push(nextObjNum++);
+	}
 	const objects = [];
+	const catalogEntries = [["Type", require_objects.pdfName("Catalog")], ["Pages", require_objects.pdfRef(pagesNum, 0)]];
+	if (attachmentsNamesNum !== void 0) catalogEntries.push(["Names", require_objects.pdfRef(attachmentsNamesNum, 0)]);
+	if (outlineRootNum !== void 0) catalogEntries.push(["Outlines", require_objects.pdfRef(outlineRootNum, 0)]);
 	objects.push({
 		num: catalogNum,
-		value: require_objects.pdfDict({
-			Type: require_objects.pdfName("Catalog"),
-			Pages: require_objects.pdfRef(pagesNum, 0)
-		})
+		value: require_objects.pdfDict(Object.fromEntries(catalogEntries))
 	});
 	objects.push({
 		num: pagesNum,
@@ -342,6 +360,73 @@ function writePdf(doc, options = {}) {
 		num: infoNum,
 		value: buildInfoDict(doc)
 	});
+	for (const [index, attachment] of (doc.attachments ?? []).entries()) {
+		const alloc = attachmentAllocs[index];
+		const fileEntries = [["Type", require_objects.pdfName("EmbeddedFile")]];
+		if (attachment.mimeType !== void 0) fileEntries.push(["Subtype", require_objects.pdfName(attachment.mimeType)]);
+		objects.push({
+			num: alloc.fileNum,
+			value: require_objects.pdfStream(require_objects.pdfDict(Object.fromEntries(fileEntries)), require_util_base64.base64ToBytes(attachment.base64))
+		});
+		const specEntries = [
+			["Type", require_objects.pdfName("Filespec")],
+			["F", require_objects.pdfLiteralString(new TextEncoder().encode(attachment.name))],
+			["EF", require_objects.pdfDict({ F: require_objects.pdfRef(alloc.fileNum, 0) })]
+		];
+		if (attachment.description !== void 0) specEntries.push(["Desc", require_objects.pdfLiteralString(new TextEncoder().encode(attachment.description))]);
+		objects.push({
+			num: alloc.specNum,
+			value: require_objects.pdfDict(Object.fromEntries(specEntries))
+		});
+	}
+	if (attachmentsNamesNum !== void 0) {
+		const names = [];
+		for (const [index, attachment] of (doc.attachments ?? []).entries()) {
+			names.push(require_objects.pdfLiteralString(new TextEncoder().encode(attachment.name)));
+			names.push(require_objects.pdfRef(attachmentAllocs[index].specNum, 0));
+		}
+		objects.push({
+			num: attachmentsNamesNum,
+			value: require_objects.pdfDict({ EmbeddedFiles: require_objects.pdfDict({ Names: require_objects.pdfArray(names) }) })
+		});
+	}
+	if (outlineRootNum !== void 0 && (doc.outline ?? []).length > 0) {
+		let itemCursor = 0;
+		const emitItems = (items, parentNum) => {
+			const siblingNums = [];
+			let prevNum;
+			for (const item of items) {
+				const ownNum = outlineItemNums[itemCursor];
+				itemCursor += 1;
+				siblingNums.push(ownNum);
+				const childNums = emitItems(item.children, ownNum);
+				const entries = [["Title", require_objects.pdfLiteralString(new TextEncoder().encode(item.title))], ["Parent", require_objects.pdfRef(parentNum, 0)]];
+				if (item.destination !== void 0) entries.push(["Dest", require_objects.pdfArray(resolveDestinationArray(doc, pageAllocs, item.destination, `outline item "${item.title}"`))]);
+				if (prevNum !== void 0) entries.push(["Prev", require_objects.pdfRef(prevNum, 0)]);
+				if (siblingNums.length < items.length) entries.push(["Next", require_objects.pdfRef(outlineItemNums[itemCursor], 0)]);
+				if (childNums.length > 0) {
+					entries.push(["First", require_objects.pdfRef(childNums[0], 0)]);
+					entries.push(["Last", require_objects.pdfRef(childNums[childNums.length - 1], 0)]);
+					entries.push(["Count", require_objects.pdfNum(childNums.length)]);
+				}
+				objects.push({
+					num: ownNum,
+					value: require_objects.pdfDict(Object.fromEntries(entries))
+				});
+				prevNum = ownNum;
+			}
+			return siblingNums;
+		};
+		const topLevelNums = emitItems(doc.outline ?? [], outlineRootNum);
+		objects.push({
+			num: outlineRootNum,
+			value: require_objects.pdfDict({
+				Type: require_objects.pdfName("Outlines"),
+				First: require_objects.pdfRef(topLevelNums[0], 0),
+				Last: require_objects.pdfRef(topLevelNums[topLevelNums.length - 1], 0)
+			})
+		});
+	}
 	for (const [standardName, alloc] of fontAllocs) {
 		const { font, descriptor } = buildFontObjects(standardName, require_objects.pdfRef(alloc.descNum, 0));
 		objects.push({
@@ -397,9 +482,10 @@ function writePdf(doc, options = {}) {
 		});
 	}
 	for (const [face, alloc] of embeddedAllocs) {
-		const subset = require_sfnt_subset.subsetSfnt(face.font, [...alloc.codePoints].sort((a, b) => a - b));
+		const usedGlyphs = require_embedded_font.collectEmbeddedGlyphs(alloc.texts, face);
+		const subset = require_sfnt_subset.subsetSfnt(face.font, [...alloc.codePoints].sort((a, b) => a - b), [...usedGlyphs.keys()].sort((a, b) => a - b));
 		if (subset === void 0) throw new Error(`font "${face.postScriptName}" resolved to an embeddable face, but its glyph outlines could not be subsetted -- only TrueType-outline ('glyf') fonts can be embedded, so supply a TrueType face for this family or drop it from the registry`);
-		const built = require_embedded_font_write.buildEmbeddedFontObjects(face, subset, require_embedded_font.collectEmbeddedGlyphs(alloc.texts, face), {
+		const built = require_embedded_font_write.buildEmbeddedFontObjects(face, subset, usedGlyphs, {
 			cidFontRef: require_objects.pdfRef(alloc.cidFontNum, 0),
 			descriptorRef: require_objects.pdfRef(alloc.descriptorNum, 0),
 			fontFileRef: require_objects.pdfRef(alloc.fontFileNum, 0),

package/dist/write.d.cts

@@ -1,5 +1,5 @@
 import { LayoutDocument } from "./layout.cjs";
-import { r as EmbeddedFaceSubstitution } from "./embedded-font-BU6Jgcof.cjs";
+import { r as EmbeddedFaceSubstitution } from "./embedded-font-oc65VGlr.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { PdfEncryptionOptions } from "./encrypt-write.cjs";
 import { FontRegistry } from "./font-registry.cjs";

package/dist/write.d.ts

@@ -1,5 +1,5 @@
 import { LayoutDocument } from "./layout.js";
-import { r as EmbeddedFaceSubstitution } from "./embedded-font-fREdbxnr.js";
+import { r as EmbeddedFaceSubstitution } from "./embedded-font-B4p9a3O3.js";
 import { WinAnsiSubstitution } from "./winansi.js";
 import { PdfEncryptionOptions } from "./encrypt-write.js";
 import { FontRegistry } from "./font-registry.js";