pdf-codec 3.1.4 → 3.3.0

package/README.md

@@ -87,6 +87,8 @@ An encrypted PDF that opens without a password decrypts transparently — no ext
 
 Both accept an optional `signal` (`AbortSignal`); `readPdf` additionally takes a `sink` (`PdfDiagnosticSink`, called once per recoverable parse diagnostic — see the three-tier failure policy under [Conventions](#conventions)), and `writePdf` an `onSubstitution` callback (called once per character not representable in a standard-14 font — see [Fidelity](#fidelity)).
 
+**Page boundaries: the crop box is the visible region** (ISO 32000-1 14.11.2). A page's reported `widthPt`/`heightPt` and coordinate frame come from its effective `/CropBox` — the rectangle a viewer displays and prints, inherited through the page tree like `/MediaBox` and defaulting to it — not from the media box: content an author placed outside the crop box (printer's marks, bleed, off-page slugs) is not visible and does not extract. Content wholly outside the crop box is dropped; content straddling the boundary keeps its original unclipped geometry (the item layer records what the file states — a viewer's clipping is a rendering fact, not source data); link annotations are anchored constructs rather than painted content and are never filtered, the same line the optional-content filter draws. The declared boundary rectangles a distinct crop box hides — plus `/BleedBox`/`/TrimBox`/`/ArtBox`, print-production facts with no field in the layout model — are quarantined verbatim as the `page-boxes` package-level residue row rather than silently dropped. A degenerate `/CropBox` (zero width or height) falls back to the media box with a `pdf/invalid-crop-box` warning.
+
 **Cancellation granularity and cost, for CPU-metered runtimes.** Both pipelines are synchronous end to end — there is no `await` point for cancellation to hook into implicitly — so the `signal` is checked explicitly, once per page-loop iteration (and once before `readPdf`'s document-open phase begins). A signal aborted mid-parse therefore takes effect at the next page boundary, not instantly: `readPdf`'s document-open phase (cross-reference resolution, object parsing) and a single page's content-stream interpretation are the two spans that cannot be interrupted, and a document consisting of one enormous page is effectively uninterruptible however many pages it claims. Cost is roughly linear in decompressed content length, so budget for the worst single page, not the page count. On Cloudflare Workers this is the honest shape of the trade: the parse holds the isolate for its whole duration with no opportunity to yield or report progress, and an `AbortSignal` shared with whatever can abort concurrently (a binding, another context) makes a deadline enforceable at page granularity — but it cannot convert a synchronous parse into a resumable one. An async page-at-a-time API is a deliberate non-goal of this package's current surface.
 
 The same round trip is also available as a schema-validated [`z.codec()`](https://zod.dev) pair:
@@ -193,7 +195,7 @@ One subpath is a declared entry point in its own right: **`pdf-codec/read`** (an
 import { readPdf } from 'pdf-codec/read';
 ```
 
-`src/read-graph.test.ts` walks the entry's static import graph and fails the build if `write.ts`, `math-font.ts`, `font-registry.ts`, or any asset module becomes reachable (type-only imports are exempt — they erase at compile time — so a read-side module can keep typing against the root barrel's types while its runtime graph stays narrow). The entry carries `readPdf` and the read pipeline's own helpers (`normalizeRotation`, `pageRotationTransform`, `decodePdfString`, `parsePdfDate`); the other read-adjacent surfaces it does not itself own stay deep-importable through the wildcard and are asset-free the same way — the diagnostics vocabulary (`pdf-codec/diagnostics`), the `LayoutDocument` item family (`pdf-codec/layout`), and standard-14 resolution/AFM metrics (`pdf-codec/fonts`, `pdf-codec/afm-widths`).
+`src/read-graph.test.ts` walks the entry's static import graph and fails the build if `write.ts`, `math-font.ts`, `font-registry.ts`, or any asset module becomes reachable (type-only imports are exempt — they erase at compile time — so a read-side module can keep typing against the root barrel's types while its runtime graph stays narrow). The entry carries `readPdf` and the read pipeline's own helpers (`normalizeRotation`, `pageRotationTransform`); the other read-adjacent surfaces it does not itself own stay deep-importable through the wildcard and are asset-free the same way — the diagnostics vocabulary (`pdf-codec/diagnostics`), the `LayoutDocument` item family (`pdf-codec/layout`), PDF string/date scalar decoding (`pdf-codec/pdf-text`), and standard-14 resolution/AFM metrics (`pdf-codec/fonts`, `pdf-codec/afm-widths`).
 
 ## Architecture
 
@@ -212,7 +214,7 @@ The package is layered from generic primitives outward to the codec itself:
   - **Embedded text faces**: `embedded-font.ts` (parses one TrueType-outline face's metrics and `GPOS` pair kerning, and `encodeForShowEmbedded` — the single code path both measurement and text-showing go through so encoding and measuring cannot disagree). Every geometry field is converted into PDF's 1000-units-per-em glyph space. `embedded-font-write.ts` builds the `/Type0`/`/CIDFontType2`/`/FontDescriptor`/`/FontFile2`/ToUnicode group, with `/CIDToGIDMap /Identity` written explicitly and `/Length1` set to the **uncompressed** subset length. Its subset tag is a CRC32 over the face's PostScript name and glyph-ID list, so identical input yields byte-identical output.
   - **ToUnicode CMaps**: `tounicode.ts`, shared by both embedded-font writers — a character code → Unicode code point mapping written as a bfchar CMap (9.10.3), with supplementary-plane code points encoded as UTF-16BE surrogate pairs and entries emitted in blocks of at most 100.
   - **CFF reading**: `cff.ts` (shared `INDEX`/`DICT` container structures), `cff-bounds.ts` (a Type 2 charstring interpreter computing each glyph's tight ink bounding box by tracking the current point through every path operator and solving each cubic's real extrema from the roots of its derivative — a path walker, not a rasteriser; verified against the vendored STIX Two Math font's whole 5,543-glyph repertoire, matching fontTools' `BoundsPen` to within 0.01 design units). `cff-probe.ts` reads a bare CFF program's header/Name INDEX/Top DICT to detect the `ROS` operator defining a CID-keyed font — the guard a future source-embedded-font phase needs before it can trust CID == GID against an arbitrary caller-supplied font.
-  - **Read**: `lexer.ts`/`parse.ts` (byte tokenizer and tokens → `PdfObject`), `filters.ts`/`predictors.ts` (Flate/LZW/ASCII85/ASCIIHex/RunLength/CCITTFax, TIFF/PNG predictors), `xref.ts`/`document.ts` (classic and cross-reference-stream resolution, object streams, `/Prev` chains, linear-scan recovery, the page tree with attribute inheritance), `encrypt.ts` (standard security handler: `/Encrypt` parsing, empty-user-password key derivation and `/U` verification, per-object keys, transparent string/stream decryption), `content-read.ts`/`interpret.ts` (content-stream tokenizer and graphics/text state machine, form-XObject recursion, general vector-path tracking), `cmap.ts`/`font-style.ts`/`font-read.ts` (`/ToUnicode` CMaps, font-dictionary resolution), `images-read.ts` (Image XObjects → PNG/JPEG bytes), `read.ts` (`readPdf`, assembling all of the above into a `LayoutDocument`).
+  - **Read**: `lexer.ts`/`parse.ts` (byte tokenizer and tokens → `PdfObject`), `filters.ts`/`predictors.ts` (Flate/LZW/ASCII85/ASCIIHex/RunLength/CCITTFax, TIFF/PNG predictors), `xref.ts`/`document.ts` (classic and cross-reference-stream resolution, object streams, `/Prev` chains, linear-scan recovery, the page tree with attribute inheritance), `encrypt.ts` (standard security handler: `/Encrypt` parsing, empty-user-password key derivation and `/U` verification, per-object keys, transparent string/stream decryption), `content-read.ts`/`interpret.ts` (content-stream tokenizer and graphics/text state machine, form-XObject recursion, general vector-path tracking), `cmap.ts`/`font-style.ts`/`font-read.ts` (`/ToUnicode` CMaps, font-dictionary resolution), `images-read.ts` (Image XObjects → PNG/JPEG bytes), `names.ts` (the document-level name-tree walker: one flattening pass for every `/Names` tenant), `navigation.ts` (named destinations from `/Dests` and `/Names` `/Dests`, reader-minted entries for direct destination arrays, and the `/Outlines` bookmark tree), `attachments.ts` (embedded files from the name tree, `/FileAttachment` filespecs, and `/AF`), `optional-content.ts` (`/OCProperties` groups and default-configuration visibility, plus the `/OC`-to-name resolution `interpret.ts` stamps onto span items), `annotations.ts` (sticky notes, FreeText, the `/QuadPoints` markup family, and residue for the opaque kinds), `form.ts` (the AcroForm field tree), `xmp.ts` (a bounded Dublin Core extractor for the `/Metadata` packet), `pdf-text.ts` (PDF string/date scalar decoding), `read.ts` (`readPdf`, assembling all of the above into a `LayoutDocument`).
   - `codec.ts` — `pdfCodec`, a `z.codec()` pair over `readPdf`/`writePdf`, plus a standalone local copy of the `%PDF-` header check.
 - **`src/test-support/`** — hand-built PDF fixtures (`pdf.ts`) built by literal byte/string concatenation and deliberately importing NOTHING from this package's own writer (a fixture built by `writePdf` would let a writer bug hide from the corresponding reader test). `encrypted-pdfs.ts` applies the same principle: real PDFs encrypted by [qpdf](https://qpdf.sourceforge.io/), embedded as base64, so a bug in key derivation cannot cancel out between write and read halves. `fonts.ts` holds the real vendored Carlito and Caladea faces as raw sfnt bytes, and asserts values read out of the `.ttf` files by a standalone script with a bare `DataView`, not by this package's own parsers — external cross-checks rather than a parser's output compared against itself.
 

package/dist/annotations.cjs

@@ -0,0 +1,104 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./notes-annotation-author.cjs");
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+const require_serialize = require("./serialize.cjs");
+const require_matrix = require("./matrix.cjs");
+//#region src/annotations.ts
+const SEMANTIC_SUBTYPES = /* @__PURE__ */ new Set([
+	"Text",
+	"FreeText",
+	"Highlight",
+	"Underline",
+	"StrikeOut",
+	"Squiggly"
+]);
+const OWNED_ELSEWHERE_SUBTYPES = /* @__PURE__ */ new Set([
+	"Link",
+	"FileAttachment",
+	"Widget",
+	"Popup"
+]);
+function readPageAnnotations(page, pageMatrix, resolver, sink) {
+	const annotsArr = require_objects.asArray(require_objects.dictGet(page, "Annots"));
+	if (annotsArr === void 0) return [];
+	const annotations = [];
+	for (const annotRef of annotsArr) {
+		const annot = resolver.resolveDict(annotRef);
+		if (annot === void 0) continue;
+		const subtype = require_objects.asName(require_objects.dictGet(annot, "Subtype"));
+		if (subtype === void 0 || OWNED_ELSEWHERE_SUBTYPES.has(subtype)) continue;
+		if (subtype === "Text" && annotString(annot, "T") === "documents.js:notes") continue;
+		const rectArr = require_objects.asArray(require_objects.dictGet(annot, "Rect"));
+		if (rectArr === void 0) {
+			sink({
+				code: "pdf/annotation-missing-rect",
+				severity: "warning",
+				message: `a /${subtype} annotation carries no /Rect; skipping it`
+			});
+			continue;
+		}
+		const x1 = require_objects.asNumber(rectArr[0]) ?? 0;
+		const y1 = require_objects.asNumber(rectArr[1]) ?? 0;
+		const x2 = require_objects.asNumber(rectArr[2]) ?? 0;
+		const y2 = require_objects.asNumber(rectArr[3]) ?? 0;
+		const p1 = require_matrix.applyMatrix(pageMatrix, {
+			x: Math.min(x1, x2),
+			y: Math.min(y1, y2)
+		});
+		const p2 = require_matrix.applyMatrix(pageMatrix, {
+			x: Math.max(x1, x2),
+			y: Math.max(y1, y2)
+		});
+		const contents = annotString(annot, "Contents");
+		const author = annotString(annot, "T");
+		const modifiedIso = require_pdf_text.parsePdfDate(annotString(annot, "M"));
+		annotations.push({
+			subtype,
+			xPt: Math.min(p1.x, p2.x),
+			yPt: Math.min(p1.y, p2.y),
+			widthPt: Math.abs(p2.x - p1.x),
+			heightPt: Math.abs(p2.y - p1.y),
+			...contents !== void 0 ? { contents } : {},
+			...author !== void 0 ? { author } : {},
+			...modifiedIso !== void 0 ? { modifiedIso } : {},
+			...SEMANTIC_SUBTYPES.has(subtype) ? markupFields(annot, pageMatrix) : { source: {
+				format: "pdf",
+				xml: require_serialize.serializeObjectToText(annot)
+			} }
+		});
+	}
+	return annotations;
+}
+function annotString(annot, key) {
+	const obj = require_objects.dictGet(annot, key);
+	return obj?.kind === "string" ? require_pdf_text.decodePdfString(obj.bytes) : void 0;
+}
+function markupFields(annot, pageMatrix) {
+	const quadPoints = require_objects.asArray(require_objects.dictGet(annot, "QuadPoints"));
+	if (quadPoints === void 0 || quadPoints.length < 8 || quadPoints.length % 8 !== 0) return {};
+	const quads = [];
+	for (let i = 0; i < quadPoints.length; i += 8) {
+		const corner = (index) => {
+			const x = require_objects.asNumber(quadPoints[i + index * 2]) ?? 0;
+			const y = require_objects.asNumber(quadPoints[i + index * 2 + 1]) ?? 0;
+			const transformed = require_matrix.applyMatrix(pageMatrix, {
+				x,
+				y
+			});
+			return {
+				xPt: transformed.x,
+				yPt: transformed.y
+			};
+		};
+		quads.push([
+			corner(0),
+			corner(1),
+			corner(2),
+			corner(3)
+		]);
+	}
+	return { quads };
+}
+//#endregion
+exports.readPageAnnotations = readPageAnnotations;

package/dist/annotations.d.cts

@@ -0,0 +1,9 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { r as Matrix } from "./matrix-B7_SBKQ5.cjs";
+import { PdfDict } from "./objects.cjs";
+import { PdfObjectResolver } from "./interpret.cjs";
+import { LayoutAnnotation } from "./layout.cjs";
+//#region src/annotations.d.ts
+declare function readPageAnnotations(page: PdfDict, pageMatrix: Matrix, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAnnotation[];
+//#endregion
+export { readPageAnnotations };

package/dist/annotations.d.ts

@@ -0,0 +1,9 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { r as Matrix } from "./matrix-B7_SBKQ5.js";
+import { PdfDict } from "./objects.js";
+import { PdfObjectResolver } from "./interpret.js";
+import { LayoutAnnotation } from "./layout.js";
+//#region src/annotations.d.ts
+declare function readPageAnnotations(page: PdfDict, pageMatrix: Matrix, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAnnotation[];
+//#endregion
+export { readPageAnnotations };

package/dist/annotations.js

@@ -0,0 +1,103 @@
+import "./notes-annotation-author.js";
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { decodePdfString, parsePdfDate } from "./pdf-text.js";
+import { serializeObjectToText } from "./serialize.js";
+import { applyMatrix } from "./matrix.js";
+//#region src/annotations.ts
+const SEMANTIC_SUBTYPES = /* @__PURE__ */ new Set([
+	"Text",
+	"FreeText",
+	"Highlight",
+	"Underline",
+	"StrikeOut",
+	"Squiggly"
+]);
+const OWNED_ELSEWHERE_SUBTYPES = /* @__PURE__ */ new Set([
+	"Link",
+	"FileAttachment",
+	"Widget",
+	"Popup"
+]);
+function readPageAnnotations(page, pageMatrix, resolver, sink) {
+	const annotsArr = asArray(dictGet(page, "Annots"));
+	if (annotsArr === void 0) return [];
+	const annotations = [];
+	for (const annotRef of annotsArr) {
+		const annot = resolver.resolveDict(annotRef);
+		if (annot === void 0) continue;
+		const subtype = asName(dictGet(annot, "Subtype"));
+		if (subtype === void 0 || OWNED_ELSEWHERE_SUBTYPES.has(subtype)) continue;
+		if (subtype === "Text" && annotString(annot, "T") === "documents.js:notes") continue;
+		const rectArr = asArray(dictGet(annot, "Rect"));
+		if (rectArr === void 0) {
+			sink({
+				code: "pdf/annotation-missing-rect",
+				severity: "warning",
+				message: `a /${subtype} annotation carries no /Rect; skipping it`
+			});
+			continue;
+		}
+		const x1 = asNumber(rectArr[0]) ?? 0;
+		const y1 = asNumber(rectArr[1]) ?? 0;
+		const x2 = asNumber(rectArr[2]) ?? 0;
+		const y2 = asNumber(rectArr[3]) ?? 0;
+		const p1 = applyMatrix(pageMatrix, {
+			x: Math.min(x1, x2),
+			y: Math.min(y1, y2)
+		});
+		const p2 = applyMatrix(pageMatrix, {
+			x: Math.max(x1, x2),
+			y: Math.max(y1, y2)
+		});
+		const contents = annotString(annot, "Contents");
+		const author = annotString(annot, "T");
+		const modifiedIso = parsePdfDate(annotString(annot, "M"));
+		annotations.push({
+			subtype,
+			xPt: Math.min(p1.x, p2.x),
+			yPt: Math.min(p1.y, p2.y),
+			widthPt: Math.abs(p2.x - p1.x),
+			heightPt: Math.abs(p2.y - p1.y),
+			...contents !== void 0 ? { contents } : {},
+			...author !== void 0 ? { author } : {},
+			...modifiedIso !== void 0 ? { modifiedIso } : {},
+			...SEMANTIC_SUBTYPES.has(subtype) ? markupFields(annot, pageMatrix) : { source: {
+				format: "pdf",
+				xml: serializeObjectToText(annot)
+			} }
+		});
+	}
+	return annotations;
+}
+function annotString(annot, key) {
+	const obj = dictGet(annot, key);
+	return obj?.kind === "string" ? decodePdfString(obj.bytes) : void 0;
+}
+function markupFields(annot, pageMatrix) {
+	const quadPoints = asArray(dictGet(annot, "QuadPoints"));
+	if (quadPoints === void 0 || quadPoints.length < 8 || quadPoints.length % 8 !== 0) return {};
+	const quads = [];
+	for (let i = 0; i < quadPoints.length; i += 8) {
+		const corner = (index) => {
+			const x = asNumber(quadPoints[i + index * 2]) ?? 0;
+			const y = asNumber(quadPoints[i + index * 2 + 1]) ?? 0;
+			const transformed = applyMatrix(pageMatrix, {
+				x,
+				y
+			});
+			return {
+				xPt: transformed.x,
+				yPt: transformed.y
+			};
+		};
+		quads.push([
+			corner(0),
+			corner(1),
+			corner(2),
+			corner(3)
+		]);
+	}
+	return { quads };
+}
+//#endregion
+export { readPageAnnotations };

package/dist/attachments.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+const require_filters = require("./filters.cjs");
+const require_names = require("./names.cjs");
+const require_util_base64 = require("./util/base64.cjs");
+//#region src/attachments.ts
+function readAttachments(catalog, pages, resolver, sink) {
+	const attachments = [];
+	const seen = /* @__PURE__ */ new Set();
+	const collect = (filespecRef) => {
+		const filespec = resolver.resolveDict(filespecRef);
+		if (filespec === void 0) return;
+		const name = filespecName(filespec);
+		if (name === void 0 || seen.has(name)) return;
+		const attachment = readFilespec(name, filespec, resolver, sink);
+		if (attachment !== void 0) {
+			seen.add(name);
+			attachments.push(attachment);
+		}
+	};
+	const namesRoot = resolver.resolveDict(require_objects.dictGet(catalog, "Names"));
+	for (const entry of require_names.walkNameTree(namesRoot === void 0 ? void 0 : require_objects.dictGet(namesRoot, "EmbeddedFiles"), resolver, sink)) collect(entry.value);
+	for (const page of pages) {
+		const annots = require_objects.asArray(require_objects.dictGet(page, "Annots"));
+		if (annots === void 0) continue;
+		for (const annotRef of annots) {
+			const annot = resolver.resolveDict(annotRef);
+			if (annot !== void 0 && require_objects.asName(require_objects.dictGet(annot, "Subtype")) === "FileAttachment") collect(require_objects.dictGet(annot, "FS"));
+		}
+	}
+	const af = require_objects.asArray(resolver.resolve(require_objects.dictGet(catalog, "AF")));
+	if (af !== void 0) for (const filespecRef of af) collect(filespecRef);
+	return attachments;
+}
+function filespecName(filespec) {
+	for (const key of ["UF", "F"]) {
+		const obj = require_objects.dictGet(filespec, key);
+		if (obj?.kind === "string") return require_pdf_text.decodePdfString(obj.bytes);
+	}
+}
+function readFilespec(name, filespec, resolver, sink) {
+	const ef = resolver.resolveDict(require_objects.dictGet(filespec, "EF"));
+	if (ef === void 0) return;
+	for (const key of ["F", "UF"]) {
+		const streamObj = resolver.resolve(require_objects.dictGet(ef, key));
+		if (streamObj?.kind !== "stream") continue;
+		const decoded = require_filters.decodeStream(streamObj.raw, streamObj.dict, sink);
+		const descObj = require_objects.dictGet(filespec, "Desc");
+		const subtype = require_objects.asName(require_objects.dictGet(streamObj.dict, "Subtype"));
+		return {
+			name,
+			...descObj?.kind === "string" ? { description: require_pdf_text.decodePdfString(descObj.bytes) } : {},
+			...subtype !== void 0 ? { mimeType: subtype } : {},
+			base64: require_util_base64.bytesToBase64(decoded.bytes)
+		};
+	}
+	sink({
+		code: "pdf/embedded-file-missing-stream",
+		severity: "warning",
+		message: "a filespec declares /EF but neither /F nor /UF resolves to an embedded stream"
+	});
+}
+//#endregion
+exports.readAttachments = readAttachments;

package/dist/attachments.d.cts

@@ -0,0 +1,8 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { PdfDict } from "./objects.cjs";
+import { PdfObjectResolver } from "./interpret.cjs";
+import { LayoutAttachment } from "./layout.cjs";
+//#region src/attachments.d.ts
+declare function readAttachments(catalog: PdfDict, pages: readonly PdfDict[], resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAttachment[];
+//#endregion
+export { readAttachments };

package/dist/attachments.d.ts

@@ -0,0 +1,8 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfDict } from "./objects.js";
+import { PdfObjectResolver } from "./interpret.js";
+import { LayoutAttachment } from "./layout.js";
+//#region src/attachments.d.ts
+declare function readAttachments(catalog: PdfDict, pages: readonly PdfDict[], resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAttachment[];
+//#endregion
+export { readAttachments };

package/dist/attachments.js

@@ -0,0 +1,64 @@
+import { asArray, asName, dictGet } from "./objects.js";
+import { decodePdfString } from "./pdf-text.js";
+import { decodeStream } from "./filters.js";
+import { walkNameTree } from "./names.js";
+import { bytesToBase64 } from "./util/base64.js";
+//#region src/attachments.ts
+function readAttachments(catalog, pages, resolver, sink) {
+	const attachments = [];
+	const seen = /* @__PURE__ */ new Set();
+	const collect = (filespecRef) => {
+		const filespec = resolver.resolveDict(filespecRef);
+		if (filespec === void 0) return;
+		const name = filespecName(filespec);
+		if (name === void 0 || seen.has(name)) return;
+		const attachment = readFilespec(name, filespec, resolver, sink);
+		if (attachment !== void 0) {
+			seen.add(name);
+			attachments.push(attachment);
+		}
+	};
+	const namesRoot = resolver.resolveDict(dictGet(catalog, "Names"));
+	for (const entry of walkNameTree(namesRoot === void 0 ? void 0 : dictGet(namesRoot, "EmbeddedFiles"), resolver, sink)) collect(entry.value);
+	for (const page of pages) {
+		const annots = asArray(dictGet(page, "Annots"));
+		if (annots === void 0) continue;
+		for (const annotRef of annots) {
+			const annot = resolver.resolveDict(annotRef);
+			if (annot !== void 0 && asName(dictGet(annot, "Subtype")) === "FileAttachment") collect(dictGet(annot, "FS"));
+		}
+	}
+	const af = asArray(resolver.resolve(dictGet(catalog, "AF")));
+	if (af !== void 0) for (const filespecRef of af) collect(filespecRef);
+	return attachments;
+}
+function filespecName(filespec) {
+	for (const key of ["UF", "F"]) {
+		const obj = dictGet(filespec, key);
+		if (obj?.kind === "string") return decodePdfString(obj.bytes);
+	}
+}
+function readFilespec(name, filespec, resolver, sink) {
+	const ef = resolver.resolveDict(dictGet(filespec, "EF"));
+	if (ef === void 0) return;
+	for (const key of ["F", "UF"]) {
+		const streamObj = resolver.resolve(dictGet(ef, key));
+		if (streamObj?.kind !== "stream") continue;
+		const decoded = decodeStream(streamObj.raw, streamObj.dict, sink);
+		const descObj = dictGet(filespec, "Desc");
+		const subtype = asName(dictGet(streamObj.dict, "Subtype"));
+		return {
+			name,
+			...descObj?.kind === "string" ? { description: decodePdfString(descObj.bytes) } : {},
+			...subtype !== void 0 ? { mimeType: subtype } : {},
+			base64: bytesToBase64(decoded.bytes)
+		};
+	}
+	sink({
+		code: "pdf/embedded-file-missing-stream",
+		severity: "warning",
+		message: "a filespec declares /EF but neither /F nor /UF resolves to an embedded stream"
+	});
+}
+//#endregion
+export { readAttachments };

package/dist/bytes/flate.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_bytes_reader = require("./reader.cjs");
 const require_bytes_writer = require("./writer.cjs");
+const require_bytes_reader = require("./reader.cjs");
 let fflate = require("fflate");
 //#region src/bytes/flate.ts
 const MAX_INFLATE_OUTPUT_BYTES = 536870912;

package/dist/bytes/flate.js

@@ -1,5 +1,5 @@
-import { isAsciiWhitespace } from "./reader.js";
 import { concatBytes } from "./writer.js";
+import { isAsciiWhitespace } from "./reader.js";
 import { Unzlib, inflateSync, unzlibSync, zlibSync } from "fflate";
 //#region src/bytes/flate.ts
 const MAX_INFLATE_OUTPUT_BYTES = 536870912;

package/dist/codec.d.cts

@@ -1,3 +1,4 @@
+import { LayoutFormField, LayoutOutlineItem } from "./layout.cjs";
 import { z } from "zod";
 //#region src/codec.d.ts
 declare const PdfBytesSchema: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
@@ -12,6 +13,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
     producer: z.ZodOptional<z.ZodString>;
     createdIso: z.ZodOptional<z.ZodString>;
     modifiedIso: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>;
   pages: z.ZodArray<z.ZodObject<{
     widthPt: z.ZodNumber;
@@ -41,6 +43,9 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
       widthPt: z.ZodOptional<z.ZodNumber>;
       rotationDeg: z.ZodOptional<z.ZodNumber>;
       underline: z.ZodOptional<z.ZodBoolean>;
+      layer: z.ZodOptional<z.ZodString>;
+      actualText: z.ZodOptional<z.ZodString>;
+      alt: z.ZodOptional<z.ZodString>;
       sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
       kind: z.ZodLiteral<"image">;
@@ -50,6 +55,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
       widthPt: z.ZodNumber;
       heightPt: z.ZodNumber;
       rotationDeg: z.ZodOptional<z.ZodNumber>;
+      layer: z.ZodOptional<z.ZodString>;
       sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
       kind: z.ZodLiteral<"rect">;
@@ -70,6 +76,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
         }, z.core.$strip>;
         widthPt: z.ZodNumber;
       }, z.core.$strip>>;
+      layer: z.ZodOptional<z.ZodString>;
       sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
       kind: z.ZodLiteral<"line">;
@@ -89,6 +96,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
         dotted: "dotted";
         double: "double";
       }>>;
+      layer: z.ZodOptional<z.ZodString>;
       sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
       kind: z.ZodLiteral<"ellipse">;
@@ -109,6 +117,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
         }, z.core.$strip>;
         widthPt: z.ZodNumber;
       }, z.core.$strip>>;
+      layer: z.ZodOptional<z.ZodString>;
       sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
       kind: z.ZodLiteral<"path">;
@@ -153,6 +162,7 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
         dotted: "dotted";
         double: "double";
       }>>;
+      layer: z.ZodOptional<z.ZodString>;
       sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
       kind: z.ZodLiteral<"link">;
@@ -161,8 +171,57 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
       yPt: z.ZodNumber;
       widthPt: z.ZodNumber;
       heightPt: z.ZodNumber;
+      title: z.ZodOptional<z.ZodString>;
       sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"internalLink">;
+      destination: z.ZodString;
+      xPt: z.ZodNumber;
+      yPt: z.ZodNumber;
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      title: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "kind">>;
+    annotations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      subtype: z.ZodString;
+      xPt: z.ZodNumber;
+      yPt: z.ZodNumber;
+      widthPt: z.ZodNumber;
+      heightPt: z.ZodNumber;
+      contents: z.ZodOptional<z.ZodString>;
+      author: z.ZodOptional<z.ZodString>;
+      modifiedIso: z.ZodOptional<z.ZodString>;
+      quads: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        xPt: z.ZodNumber;
+        yPt: z.ZodNumber;
+      }, z.core.$strip>], null>>>;
+      source: z.ZodOptional<z.ZodObject<{
+        format: z.ZodEnum<{
+          docx: "docx";
+          pptx: "pptx";
+          xlsx: "xlsx";
+          odt: "odt";
+          ods: "ods";
+          odp: "odp";
+          odg: "odg";
+          odm: "odm";
+          odb: "odb";
+          odf: "odf";
+          markdown: "markdown";
+          pdf: "pdf";
+        }>;
+        xml: z.ZodString;
+      }, z.core.$strict>>;
+    }, z.core.$strip>>>;
     notes: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
   images: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -174,6 +233,56 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
     widthPx: z.ZodNumber;
     heightPx: z.ZodNumber;
   }, z.core.$strip>>;
+  destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    pageIndex: z.ZodNumber;
+    target: z.ZodObject<{
+      kind: z.ZodEnum<{
+        xyz: "xyz";
+        fit: "fit";
+        fitH: "fitH";
+        fitV: "fitV";
+        fitR: "fitR";
+        fitB: "fitB";
+        fitBH: "fitBH";
+        fitBV: "fitBV";
+      }>;
+      leftPt: z.ZodOptional<z.ZodNumber>;
+      topPt: z.ZodOptional<z.ZodNumber>;
+      bottomPt: z.ZodOptional<z.ZodNumber>;
+      rightPt: z.ZodOptional<z.ZodNumber>;
+      zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>>;
+  outline: z.ZodOptional<z.ZodArray<z.ZodType<LayoutOutlineItem, LayoutOutlineItem, z.core.$ZodTypeInternals<LayoutOutlineItem, LayoutOutlineItem>>>>;
+  attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+    base64: z.ZodString;
+  }, z.core.$strip>>>;
+  layers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    visible: z.ZodBoolean;
+  }, z.core.$strip>>>;
+  form: z.ZodOptional<z.ZodArray<z.ZodType<LayoutFormField, LayoutFormField, z.core.$ZodTypeInternals<LayoutFormField, LayoutFormField>>>>;
+  source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    format: z.ZodEnum<{
+      docx: "docx";
+      pptx: "pptx";
+      xlsx: "xlsx";
+      odt: "odt";
+      ods: "ods";
+      odp: "odp";
+      odg: "odg";
+      odm: "odm";
+      odb: "odb";
+      odf: "odf";
+      markdown: "markdown";
+      pdf: "pdf";
+    }>;
+    xml: z.ZodString;
+  }, z.core.$strict>>>;
 }, z.core.$strip>>;
 //#endregion
 export { PdfBytesSchema, pdfCodec };