pdf-codec 3.1.4 → 3.2.0

package/README.md

@@ -193,7 +193,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 +212,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 };