pdf-codec 4.0.12 → 4.1.0

package/README.md

@@ -4,7 +4,7 @@
 
 > A hand-written, dependency-minimal PDF codec: parses arbitrary real-world PDFs into a structured, positioned-content document and generates new PDFs from one, built on its own codec-owned `LayoutDocument` item model and [Zod 4](https://zod.dev) codecs.
 
-`pdf-codec` is the PDF-reading-and-writing half of [`documents.js`](https://github.com/ExaDev/documents.js), extracted into its own package: every layer of the PDF format — the object model, the cross-reference table, the content-stream operators, standard-font metrics, the parser's cross-reference/object-stream resolution and content-stream interpreter — is hand-written against the ISO 32000-1 specification, with no external PDF library (`pdf-lib`, `pdfjs-dist`, `mupdf`, or any other) as a dependency. The one exception is [`fflate`](https://github.com/101arrowz/fflate) for raw DEFLATE/zlib compression. The OpenType/CFF font parsing this package's own writer uses to embed a real math font (`sfnt.ts`/`math-*.ts`) is hand-written too, as are the cryptographic primitives its reader needs to open an encrypted PDF (`crypto/` — MD5, SHA-2, RC4, AES), because `node:crypto` would end this package's platform neutrality and WebCrypto offers neither MD5 nor RC4 nor a synchronous API. The one bundled binary asset is the vendored STIX Two Math font itself (OFL-1.1, see [Fidelity](#fidelity) and `assets/fonts/NOTICE.md`).
+`pdf-codec` is the PDF-reading-and-writing half of [`documents.js`](https://github.com/ExaDev/documents.js), extracted into its own package: every layer of the PDF format — the object model, the cross-reference table, the content-stream operators, standard-font metrics, the parser's cross-reference/object-stream resolution and content-stream interpreter — is hand-written against the ISO 32000-1 specification, with no external PDF library (`pdf-lib`, `pdfjs-dist`, `mupdf`, or any other) as a dependency. The one exception is [`fflate`](https://github.com/101arrowz/fflate) for raw DEFLATE/zlib compression. The OpenType/CFF font parsing this package's own writer uses to embed a real math font (`sfnt.ts`/`math-*.ts`) is hand-written too, as are the cryptographic primitives the reader needs to open an encrypted PDF and the writer needs to produce one (`crypto/` — MD5, SHA-2, RC4, AES, and a `getRandomValues`-backed CSPRNG for the writer's own salts/keys/IVs), because `node:crypto` would end this package's platform neutrality and WebCrypto's `crypto.subtle` offers neither MD5 nor RC4 nor a synchronous API (`crypto.getRandomValues` itself is synchronous and used directly). The one bundled binary asset is the vendored STIX Two Math font itself (OFL-1.1, see [Fidelity](#fidelity) and `assets/fonts/NOTICE.md`).
 
 This is a genuinely large undertaking with an honest trade-off spelled out in [Fidelity](#fidelity): this is not, and does not attempt to be, as robust against adversarial or badly malformed real-world PDFs as a library with 15+ years of hardening. What it buys instead is a dependency-free, fully auditable PDF implementation with no supply-chain surface beyond `document-schema.js`, `fflate`, and `zod`.
 
@@ -89,7 +89,7 @@ const bytes = writePdf(layout);
 
 There is deliberately **no `DocumentTree`-returning read or `DocumentTree`-accepting write here**, and `readPdf`/`writePdf` are this package's primary API precisely because of that. Only `markdown-codec`'s own read entry point returns `document-schema.js`'s flat `ContentDocument` directly — `ooxml.js`'s `readDocx`/`readPptx` return `DocxDocument`/`PptxDocument` and `odf.js`'s `readOdt`/`readOds` return `OdtDocument`/`OdsDocument`, each codec's own native model, with only `ooxml.js`'s separate `readXlsxContent` producing a `ContentDocument` outright. What lets `documents.js` offer one tree-native entry point uniformly across those formats (`decompose`/`assembleTree` outward, `flattenTree` back) is its own `readXContent` wrapper layer (`readDocxContent`, `readOdtContent`, and siblings), projecting each codec's native model into the flat `ContentDocument` — a step the codecs themselves don't take. PDF has no such wrapper to project through: `readPdf` yields _layout_ cheaply, because positioned glyphs and paths are all the format actually states, and semantic content only through a separate, expensive, lossy reconstruction pass that infers paragraphs, headings, tables, and shapes back out of geometry. That inference is semantic policy rather than codec business, so it lives in `documents.js` — a caller wanting a PDF as a `DocumentTree` passes `onDocument` to a named conversion function or to `convertDocument` itself and reads the tree off that callback (`convertDocument` on its own returns only bytes), or uses `createLocalDocumentConverter()`'s `DocumentConverter` port, whose `ConversionResult.package` is populated by wiring that same callback internally. The write direction is asymmetric for a different reason than it might look: turning a `DocumentTree` into PDF bytes is not itself a layout pass — `documents.js`'s `layoutDocumentFromPackage` is a mechanical inverse that walks the positions a _prior_ layout pass already stamped onto the package's own content nodes as `frames`, and it only works at all when those frames exist (a bridge conversion's own dump, e.g. `odt-to-docx`, carries no `pages` and cannot reach PDF this way). The actual font-measuring, line-breaking engine runs earlier, wherever the package first passed through an X-to-PDF or PDF-to-X conversion — both the frame-stamping and the frame-walking are `documents.js`'s. Keeping both edges out of this package is still what makes the item layer an honest record of what a file says, separate from what any consumer thinks it means.
 
-An encrypted PDF that opens without a password decrypts transparently — no extra option, no password parameter; one that genuinely needs a user password throws `PdfPasswordRequiredError`. See [Gotchas](#gotchas-and-quirks) for exactly which encryption is supported.
+An encrypted PDF that opens without a password decrypts transparently — no extra option, no password parameter; one that genuinely needs a user password throws `PdfPasswordRequiredError`. `writePdf` encrypts on the way out via its own `encryption` option (`WritePdfOptions.encryption`, `PdfEncryptionOptions` from `pdf-codec`) — a user password, an optional owner password, a choice of scheme (`"rc4-40" | "rc4-128" | "aes-128" | "aes-256"`, default `"aes-256"`), and permission flags. See [Gotchas](#gotchas-and-quirks) for exactly which encryption is supported on both sides.
 
 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)).
 
@@ -232,7 +232,7 @@ The package is layered from generic primitives outward to the codec itself:
 - **The math port types** — `MathColor`/`MathGlyphRun`/`MathRule`/`MathStroke`/`MathLayoutItem`/`MathBox`/`MathGlyphMetrics`/`MathFontMetrics` and `PositionedFormula`, sourced from `document-schema.js`'s math layout port (one shared definition across the family, not a local mirror). Deliberately not imported from `documents.js` — that would be a circular dependency once `documents.js` depends on this package. Because every one of these types is plain data (only `MathFontMetrics` carries a method), a real `MathBox` value `documents.js` produces passes into `writePdf({ formulas })` with zero cast, zero wrapper, and zero transformation.
 - **`src/bytes/`** and **`src/image/`** — generic byte and image-container primitives with zero PDF-specific knowledge: a chunked byte writer, backtracking byte reader, CRC32, a hand-written PNG decoder/encoder, JPEG marker scanning for dimensions only (compressed bytes pass through unchanged), a hand-written CCITT Group 3/Group 4 fax decoder (ITU-T T.4/T.6), a hand-written JBIG2 decoder (ITU-T T.88 — `jbig2-arith.ts` MQ decoder, `jbig2-bitmap.ts`, `jbig2-generic.ts`, `jbig2-text.ts`, `jbig2.ts`), and a hand-written JPEG 2000 decoder (ISO/IEC 15444-1 — `jp2-boxes.ts`, `jpeg2000-codestream.ts`, `jpeg2000-tagtree.ts`, `jpeg2000-t2.ts`, `jpeg2000-t1.ts`, `jpeg2000-dwt.ts`, `jpeg2000.ts`). `src/filters.ts` owns all PDF knowledge for CCITT/JBIG2 (resolving parameters, `/JBIG2Globals`, inverting polarity); `src/images-read.ts` owns the JPEG 2000 PDF integration. `src/bytes/flate.ts` is the only file that imports `fflate`.
 - **`src/util/`** — two small independently-duplicated copies of family-shared logic: `base64.ts` (verbatim copy of `odf.js`'s own, replacing a former `ooxml.js` dependency for this one helper) and `abort.ts` (`throwIfAborted`, called at every page loop boundary — there is no `await` point in this synchronous pipeline for cancellation to hook into implicitly).
-- **`src/crypto/`** — MD5, SHA-256/384/512, RC4, and AES-CBC, hand-written with zero local imports. Not a preference: ISO 32000-1's key-derivation algorithms name MD5 and RC4 directly, neither offered by any portable platform crypto API, and `crypto.subtle` is asynchronous where this codec's read path is synchronous end to end. Reaching for `node:crypto` would break the browser bundle. Each module cites its specification (RFC 1321, FIPS 180-4, FIPS 197) and is tested against published conformance vectors.
+- **`src/crypto/`** — MD5, SHA-256/384/512, RC4, and AES-CBC, hand-written with zero local imports, plus a thin `random.ts` wrapper around `globalThis.crypto.getRandomValues` for the writer's own salts/file keys/IVs. Not a preference: ISO 32000-1's key-derivation algorithms name MD5 and RC4 directly, neither offered by any portable platform crypto API, and `crypto.subtle` is asynchronous where this codec's read and write paths are both synchronous end to end — `getRandomValues` itself, unlike `crypto.subtle`, is synchronous and portable, so it is used directly rather than hand-written. Reaching for `node:crypto` would break the browser bundle. Each hash/cipher module cites its specification (RFC 1321, FIPS 180-4, FIPS 197) and is tested against published conformance vectors.
 - **The codec itself, importing only `layout`/`bytes`/`image`/`crypto`/`util` plus `document-schema.js`'s port types (no OOXML or ODF knowledge):**
   - **Write**: `objects.ts` (the `PdfObject` discriminated union), `afm-widths.ts`/`encoding.ts`/`winansi.ts`/`fonts.ts` (standard-14 metrics, WinAnsi encoding, family resolution), `font-registry.ts` (resolution port plus `resolveFaceWithRegistry`, the one step both measurer and writer resolve through so they can never disagree about which face a `LayoutFont` means), `font-face.ts` (`readFontFace`, reading a standalone font file's family/bold/italic triple off its `name`/`OS/2`/`head` tables), `measure.ts`/`text-layout.ts` (greedy line-wrapping against either standard-14 AFM widths plus per-family correction or a resolved face's own real `hmtx` advances — never both), `content-write.ts` (`LayoutItem[]` → content-stream operators, with text branching on standard-14 vs embedded face encoding, pair-kerning split into `TJ` arrays, and stroke `style` becoming real dash/line-cap state), `write.ts` (the full object graph, cross-reference table, trailer, and embedded font groups).
   - **sfnt font tables**: `sfnt.ts` (bounds-checked table-directory reader), `cmap-table.ts` (character code → glyph ID, formats 0/4/6/12, exposed both as the best Unicode lookup and as every subtable individually, since a (3, 0) or (1, 0) subtable is keyed by a font's own codes rather than by code points), `hmtx-table.ts` (per-glyph advance widths), `font-tables.ts` (`head`/`maxp`/`OS/2`/`post`/`name`, including `post`'s own glyph names where a font still carries them), `glyf.ts` (`loca` offset index, per-glyph headers, composite component records, `glyphInkBounds`), `math-table.ts` (OpenType `MATH` constants/glyph-info/variants subtables). `ot-layout-common.ts` (Coverage/ClassDef, stored as sorted glyph ranges searched by bisection). `gpos-table.ts` reads `GPOS` for exactly one thing: pair-advance kerning through the `kern` feature, both PairPos formats and LookupType 9 Extension indirection — mark attachment, cursive joining, and contextual positioning have no consumer here. Every parser degrades to `undefined` on a missing/truncated table rather than throwing.
@@ -261,7 +261,8 @@ Dependency direction is strictly downward and checkable: `layout` imports only `
 
 - **Reading arbitrary real-world PDFs is the single largest risk surface in this package**, and the parser targets cleanly-generated output from mainstream producers (Word, PowerPoint, Chrome, LibreOffice, Acrobat), recovering from the malformations those producers actually create, and failing loudly and specifically on anything else — not matching a mature library's robustness against adversarial input.
 - **An encrypted PDF is readable when, and only when, it opens without a password** — the overwhelmingly common real-world case (a permissions-only file whose owner password may be set but whose user password is empty). Supported: `/Filter /Standard` at `/V` 1, 2, 4, and 5 — RC4-40, RC4-128, AES-128, AES-256 — including `/EncryptMetadata false` and `/Identity` crypt filters. A file genuinely needing a user password throws `PdfPasswordRequiredError` (distinct from `PdfEncryptedError`, because "supply the password" and "this codec cannot read this at all" are different things to tell a user).
-- **Nothing in this codec accepts, prompts for, or guesses a password.** Authenticating as owner is a permissions escalation, not a way to read a file you were already allowed to read.
+- **Nothing in this codec's reader accepts, prompts for, or guesses a password.** Authenticating as owner is a permissions escalation, not a way to read a file you were already allowed to read.
+- **`writePdf` produces real, spec-conformant encryption for all four of the schemes above** (`src/encrypt-write.ts`, `WritePdfOptions.encryption`) — genuine `/O`/`/U`/`/OE`/`/UE`/`/Perms` computation per ISO 32000-2 7.6.4.4's Algorithms 3, 8, 9, and 10, a real user and (optional, defaulting to the user password) owner password, and per-`/P`-bit permission flags. Unlike the reader, the writer's own password is not scoped to empty: a genuinely non-empty user password is fully supported and round-trips against the published algorithm (see `encrypt-write.test.ts`), even though this package's own reader — scoped as above — can only ever open the result back up if the user password used to encrypt it was itself empty. Two boundaries are deliberately narrower than the full spec rather than approximated silently: a revision 2-4 (rc4-40/rc4-128/aes-128) password must be plain printable ASCII, not the full 8-bit PDFDocEncoding table, and a revision 6 (aes-256) password is Unicode-normalised with NFKC rather than the full SASLPrep/stringprep profile (prohibited-character tables and the bidirectional-text rule are not implemented). Both throw `PdfEncryptionError` for a password outside that scope rather than silently mis-encoding it into one that will not open the file it was meant to protect.
 - **`CCITTFaxDecode`, `JBIG2Decode` and `JPXDecode` images all decode for real** via hand-written decoders (`src/image/ccitt.ts` for ITU-T T.4/T.6 fax; `src/image/jbig2*.ts` for ITU-T T.88; `src/image/jpeg2000*.ts` for ISO/IEC 15444-1). JPEG images (`DCTDecode`) pass through losslessly in both directions. See [JBIG2 scope](#jbig2-scope) and [JPEG 2000 scope](#jpeg-2000-scope) for exactly what is and is not implemented.
 - **`interpret.ts` tracks general vector paths, not just axis-aligned `re` rectangles.** `m`/`l`/`c`/`v`/`y`/`h` (and `re` itself) accumulate real subpaths — CTM-transformed line/cubic segments, open or closed — and any paint operator emits an item built from them. A recovered path matching one of three characteristic shape patterns comes back as that shape's own kind, not a generic `LayoutPath`: an axis-aligned closed four-corner subpath is a `LayoutRect`; a closed subpath of four cubic segments meeting its bounding box at cardinal points with kappa-ratio control points is a `LayoutEllipse`; an open single-straight-segment stroke-only subpath is a `LayoutLine` (tolerance: `max(1e-3pt, 1e-4 × extent)`). **These are deliberate, bounded heuristics** — a false positive changes an item's kind, never its geometry, since every detected shape reproduces its source path's own points exactly. Off-axis rotations, non-quadrant curves, polygons, and multi-subpath figures stay a `LayoutPath`.
 - **`writePdf`/`readPdf` round-trip a page's own `notes` field via a hidden `/Subtype /Text` annotation** with the `Hidden` flag set so it never renders or prints, distinguished from a genuine third-party sticky note by an internal author marker. This is a round-trip mechanism specific to this package's own writer/reader pair. `documents.js` uses this to carry pptx/odp speaker notes through PDF.
@@ -347,7 +348,7 @@ There is a single `main` branch and no open pull request workflow established so
 - [documents.js](https://github.com/ExaDev/documents.js) — the package this codec was extracted from, and its principal downstream consumer: docx/pptx/odt/odp/ods/odg ⇄ PDF conversion, and MathML formula rendering (its own `src/mathml/` typesetting engine feeds a real `MathBox` into this package's `writePdf({ formulas })` with zero cast).
 - [document-schema.js](../document-schema.js/README.md) — the sibling package that owns the canonical `ContentDocument`/`DocumentTree` pivots the wider family shares, plus the shared leaf shapes and port types this package imports (`Color`, `LayoutFont`, `LayoutMetadata`, `TextMeasurer`, the math family). The `LayoutDocument` item family itself lived there until moving into this package.
 - [qpdf](https://qpdf.sourceforge.io/) — the independent implementation that produces this package's encrypted-PDF test fixtures. A build-time and test-time tool only, never a dependency of the package itself.
-- The specifications `src/crypto/` implements, each cited in the module that implements it and checked against published conformance vectors: [RFC 1321](https://www.rfc-editor.org/rfc/rfc1321) (MD5), [FIPS 180-4](https://csrc.nist.gov/pubs/fips/180-4/upd1/final) (SHA-256/384/512), [FIPS 197](https://csrc.nist.gov/pubs/fips/197/final) (AES), and [NIST SP 800-38A](https://csrc.nist.gov/pubs/sp/800/38/a/final) (CBC mode). The standard security handler is ISO 32000-1 7.6, extended for revisions 5 and 6 by ISO 32000-2 7.6.4.3.
+- The specifications `src/crypto/` implements, each cited in the module that implements it and checked against published conformance vectors: [RFC 1321](https://www.rfc-editor.org/rfc/rfc1321) (MD5), [FIPS 180-4](https://csrc.nist.gov/pubs/fips/180-4/upd1/final) (SHA-256/384/512), [FIPS 197](https://csrc.nist.gov/pubs/fips/197/final) (AES), and [NIST SP 800-38A](https://csrc.nist.gov/pubs/sp/800/38/a/final) (CBC mode). The standard security handler is ISO 32000-1 7.6, extended for revisions 5 and 6 by ISO 32000-2 7.6.4.3; the write side's own password algorithms (`src/encrypt-write.ts`) are ISO 32000-2 7.6.4.4's Algorithms 3, 8, 9, and 10.
 - [STIX Two Math](https://github.com/stipub/stixfonts) — the embedded math font, vendored at `assets/fonts/STIXTwoMath-Regular.otf` and embedded into `dist/` as a base64 string (`src/assets/stix-two-math-font.ts`, generated by `scripts/generate-math-font-asset.mjs`). Copyright 2001-2021 The STIX Fonts Project Authors, licensed [OFL-1.1](assets/fonts/OFL.txt) — see `assets/fonts/NOTICE.md` for the exact source commit and version.
 
 ## npm aliases

package/dist/annotations.d.cts

@@ -1,6 +1,6 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
 import { r as Matrix } from "./matrix-B7_SBKQ5.cjs";
-import { PdfDict } from "./objects.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
 import { PdfObjectResolver } from "./interpret.cjs";
 import { LayoutAnnotation } from "./layout.cjs";
 //#region src/annotations.d.ts

package/dist/annotations.d.ts

@@ -1,6 +1,6 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
 import { r as Matrix } from "./matrix-B7_SBKQ5.js";
-import { PdfDict } from "./objects.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
 import { PdfObjectResolver } from "./interpret.js";
 import { LayoutAnnotation } from "./layout.js";
 //#region src/annotations.d.ts

package/dist/attachments.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict } from "./objects.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
 import { PdfObjectResolver } from "./interpret.cjs";
 import { LayoutAttachment } from "./layout.cjs";
 //#region src/attachments.d.ts

package/dist/attachments.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict } from "./objects.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
 import { PdfObjectResolver } from "./interpret.js";
 import { LayoutAttachment } from "./layout.js";
 //#region src/attachments.d.ts

package/dist/content-read.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict, PdfObject } from "./objects.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
 //#region src/content-read.d.ts
 interface ContentOperation {
   readonly operands: readonly PdfObject[];

package/dist/content-read.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict, PdfObject } from "./objects.js";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
 //#region src/content-read.d.ts
 interface ContentOperation {
   readonly operands: readonly PdfObject[];

package/dist/crypto/random.cjs

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/crypto/random.ts
+function randomBytes(length) {
+	const bytes = new Uint8Array(length);
+	globalThis.crypto.getRandomValues(bytes);
+	return bytes;
+}
+//#endregion
+exports.randomBytes = randomBytes;

package/dist/crypto/random.d.cts

@@ -0,0 +1,4 @@
+//#region src/crypto/random.d.ts
+declare function randomBytes(length: number): Uint8Array<ArrayBuffer>;
+//#endregion
+export { randomBytes };

package/dist/crypto/random.d.ts

@@ -0,0 +1,4 @@
+//#region src/crypto/random.d.ts
+declare function randomBytes(length: number): Uint8Array<ArrayBuffer>;
+//#endregion
+export { randomBytes };

package/dist/crypto/random.js

@@ -0,0 +1,8 @@
+//#region src/crypto/random.ts
+function randomBytes(length) {
+	const bytes = new Uint8Array(length);
+	globalThis.crypto.getRandomValues(bytes);
+	return bytes;
+}
+//#endregion
+export { randomBytes };

package/dist/document.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict, PdfObject } from "./objects.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
 //#region src/document.d.ts
 interface PdfDocument {
   readonly trailer: PdfDict;

package/dist/document.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict, PdfObject } from "./objects.js";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
 //#region src/document.d.ts
 interface PdfDocument {
   readonly trailer: PdfDict;

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

@@ -1,4 +1,4 @@
-import { PdfDict, PdfObject } from "./objects.cjs";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
 import { t as EmbeddedFace } from "./embedded-font-BU6Jgcof.cjs";
 import { SfntSubsetResult } from "./sfnt-subset.cjs";
 //#region src/embedded-font-write.d.ts

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

@@ -1,4 +1,4 @@
-import { PdfDict, PdfObject } from "./objects.js";
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
 import { t as EmbeddedFace } from "./embedded-font-fREdbxnr.js";
 import { SfntSubsetResult } from "./sfnt-subset.js";
 //#region src/embedded-font-write.d.ts

package/dist/encrypt-write.cjs

@@ -0,0 +1,234 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_bytes_writer = require("./bytes/writer.cjs");
+const require_crypto_aes = require("./crypto/aes.cjs");
+const require_crypto_md5 = require("./crypto/md5.cjs");
+const require_crypto_rc4 = require("./crypto/rc4.cjs");
+const require_encrypt = require("./encrypt.cjs");
+const require_crypto_random = require("./crypto/random.cjs");
+//#region src/encrypt-write.ts
+var PdfEncryptionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PdfEncryptionError";
+	}
+};
+const RC4_128_KEY_BYTES = 16;
+const R6_PASSWORD_MAX_BYTES = 127;
+const RESERVED_BIT_7_AND_8 = 192;
+const DEPRECATED_ALWAYS_ONE_BIT_10 = 512;
+const SCHEME_SPECS = {
+	"rc4-40": {
+		v: 1,
+		r: 2,
+		keyBytes: 5,
+		method: "rc4"
+	},
+	"rc4-128": {
+		v: 2,
+		r: 3,
+		keyBytes: RC4_128_KEY_BYTES,
+		method: "rc4"
+	},
+	"aes-128": {
+		v: 4,
+		r: 4,
+		keyBytes: 16,
+		method: "aes"
+	},
+	"aes-256": {
+		v: 5,
+		r: 6,
+		keyBytes: 32,
+		method: "aes"
+	}
+};
+function legacyPasswordBytes(password) {
+	const bytes = new Uint8Array(password.length);
+	for (let i = 0; i < password.length; i++) {
+		const code = password.charCodeAt(i);
+		if (code > 127) throw new PdfEncryptionError(`password contains character code ${String(code)}, outside the printable-ASCII range this writer supports for the rc4-40/rc4-128/aes-128 schemes; use a plain-ASCII password, or the aes-256 scheme, whose revision-6 passwords are Unicode`);
+		bytes[i] = code;
+	}
+	return bytes;
+}
+function r6PasswordBytes(password) {
+	return new TextEncoder().encode(password.normalize("NFKC")).subarray(0, R6_PASSWORD_MAX_BYTES);
+}
+function permissionsToP(permissions) {
+	let p = 0;
+	if (permissions?.print ?? true) p |= 4;
+	if (permissions?.modifyContents ?? true) p |= 8;
+	if (permissions?.copy ?? true) p |= 16;
+	if (permissions?.annotate ?? true) p |= 32;
+	p |= RESERVED_BIT_7_AND_8;
+	if (permissions?.fillForms ?? true) p |= 256;
+	p |= DEPRECATED_ALWAYS_ONE_BIT_10;
+	if (permissions?.assemble ?? true) p |= 1024;
+	if (permissions?.printHighRes ?? true) p |= 2048;
+	for (let bit = 13; bit <= 32; bit++) p |= 1 << bit - 1;
+	return p;
+}
+function computeLegacyOwnerValue(ownerPassword, userPassword, revision, keyBytes) {
+	let digest = require_crypto_md5.md5(require_encrypt.padOrTruncatePassword(ownerPassword));
+	if (revision >= 3) for (let i = 0; i < 50; i++) digest = require_crypto_md5.md5(digest);
+	const ownerKey = digest.subarray(0, keyBytes);
+	let value = require_crypto_rc4.rc4(ownerKey, require_encrypt.padOrTruncatePassword(userPassword));
+	if (revision >= 3) for (let i = 1; i <= 19; i++) {
+		const roundKey = Uint8Array.from(ownerKey, (byte) => byte ^ i);
+		value = require_crypto_rc4.rc4(roundKey, value);
+	}
+	return value;
+}
+function computeLegacyUserValue(fileKey, fileId, revision) {
+	const core = require_encrypt.legacyUserValueCore(fileKey, fileId, revision);
+	if (revision === 2) return core;
+	return require_bytes_writer.concatBytes([core, require_crypto_random.randomBytes(require_encrypt.PASSWORD_PADDING.length - core.length)]);
+}
+function encryptAes(key, data) {
+	const iv = require_crypto_random.randomBytes(16);
+	const padLength = 16 - data.length % 16;
+	const padded = new Uint8Array(data.length + padLength);
+	padded.set(data);
+	padded.fill(padLength, data.length);
+	return require_bytes_writer.concatBytes([iv, require_crypto_aes.aesCbcEncrypt(key, iv, padded)]);
+}
+function applyEncryptMethod(method, fileKey, perObjectKeys, bytes, num, gen) {
+	if (method === "identity") return bytes;
+	const key = perObjectKeys ? require_encrypt.objectKey(fileKey, num, gen, method) : fileKey;
+	return method === "rc4" ? require_crypto_rc4.rc4(key, bytes) : encryptAes(key, bytes);
+}
+function buildEncryptor(encryptDict, fileKey, method, perObjectKeys, encryptMetadata) {
+	return {
+		encryptDict,
+		encryptString(bytes, num, gen) {
+			return applyEncryptMethod(method, fileKey, perObjectKeys, bytes, num, gen);
+		},
+		encryptStream(bytes, dict, num, gen) {
+			const type = dict.entries.get("Type");
+			if (!encryptMetadata && type?.kind === "name" && type.name === "Metadata") return bytes;
+			return applyEncryptMethod(method, fileKey, perObjectKeys, bytes, num, gen);
+		}
+	};
+}
+function buildLegacyEncryptor(spec, options, fileId) {
+	const userPassword = legacyPasswordBytes(options.userPassword ?? "");
+	const ownerPassword = legacyPasswordBytes(options.ownerPassword ?? options.userPassword ?? "");
+	const encryptMetadata = options.encryptMetadata ?? true;
+	const p = permissionsToP(options.permissions);
+	const owner = computeLegacyOwnerValue(ownerPassword, userPassword, spec.r, spec.keyBytes);
+	const fileKey = require_encrypt.computeLegacyFileKeyFromPaddedPassword(require_encrypt.padOrTruncatePassword(userPassword), owner, p, fileId, spec.r, spec.keyBytes, encryptMetadata);
+	const user = computeLegacyUserValue(fileKey, fileId, spec.r);
+	const entries = /* @__PURE__ */ new Map([
+		["Filter", require_objects.pdfName("Standard")],
+		["V", require_objects.pdfNum(spec.v)],
+		["R", require_objects.pdfNum(spec.r)],
+		["O", require_objects.pdfHexString(owner)],
+		["U", require_objects.pdfHexString(user)],
+		["P", require_objects.pdfNum(p)],
+		["Length", require_objects.pdfNum(spec.keyBytes * 8)]
+	]);
+	if (spec.v === 4) {
+		entries.set("CF", require_objects.pdfDict({ StdCF: require_objects.pdfDict({
+			AuthEvent: require_objects.pdfName("DocOpen"),
+			CFM: require_objects.pdfName("AESV2"),
+			Length: require_objects.pdfNum(spec.keyBytes)
+		}) }));
+		entries.set("StmF", require_objects.pdfName("StdCF"));
+		entries.set("StrF", require_objects.pdfName("StdCF"));
+		entries.set("EncryptMetadata", require_objects.pdfBool(encryptMetadata));
+	}
+	return buildEncryptor(require_objects.pdfDict(entries), fileKey, spec.method, true, encryptMetadata);
+}
+function buildAes256Encryptor(spec, options) {
+	const userPassword = r6PasswordBytes(options.userPassword ?? "");
+	const ownerPassword = r6PasswordBytes(options.ownerPassword ?? options.userPassword ?? "");
+	const encryptMetadata = options.encryptMetadata ?? true;
+	const p = permissionsToP(options.permissions);
+	const fileKey = require_crypto_random.randomBytes(32);
+	const userValidationSalt = require_crypto_random.randomBytes(8);
+	const userKeySalt = require_crypto_random.randomBytes(8);
+	const empty = /* @__PURE__ */ new Uint8Array(0);
+	const userHash = require_encrypt.hardenedHash(userPassword, userValidationSalt, empty, spec.r);
+	const u = require_bytes_writer.concatBytes([
+		userHash,
+		userValidationSalt,
+		userKeySalt
+	]);
+	const userIntermediateKey = require_encrypt.hardenedHash(userPassword, userKeySalt, empty, spec.r);
+	const ue = require_crypto_aes.aesCbcEncrypt(userIntermediateKey, require_encrypt.ZERO_IV, fileKey);
+	const ownerValidationSalt = require_crypto_random.randomBytes(8);
+	const ownerKeySalt = require_crypto_random.randomBytes(8);
+	const ownerHash = require_encrypt.hardenedHash(ownerPassword, ownerValidationSalt, u, spec.r);
+	const o = require_bytes_writer.concatBytes([
+		ownerHash,
+		ownerValidationSalt,
+		ownerKeySalt
+	]);
+	const ownerIntermediateKey = require_encrypt.hardenedHash(ownerPassword, ownerKeySalt, u, spec.r);
+	const oe = require_crypto_aes.aesCbcEncrypt(ownerIntermediateKey, require_encrypt.ZERO_IV, fileKey);
+	const permsBlock = /* @__PURE__ */ new Uint8Array(16);
+	permsBlock.set(require_encrypt.permissionsBytes(p), 0);
+	permsBlock.set([
+		255,
+		255,
+		255,
+		255
+	], 4);
+	permsBlock[8] = encryptMetadata ? 84 : 70;
+	permsBlock.set([
+		97,
+		100,
+		98
+	], 9);
+	permsBlock.set(require_crypto_random.randomBytes(4), 12);
+	const perms = require_crypto_aes.aesCbcEncrypt(fileKey, require_encrypt.ZERO_IV, permsBlock);
+	const entries = /* @__PURE__ */ new Map([
+		["Filter", require_objects.pdfName("Standard")],
+		["V", require_objects.pdfNum(spec.v)],
+		["R", require_objects.pdfNum(spec.r)],
+		["O", require_objects.pdfHexString(o)],
+		["U", require_objects.pdfHexString(u)],
+		["OE", require_objects.pdfHexString(oe)],
+		["UE", require_objects.pdfHexString(ue)],
+		["P", require_objects.pdfNum(p)],
+		["Perms", require_objects.pdfHexString(perms)],
+		["Length", require_objects.pdfNum(spec.keyBytes * 8)],
+		["CF", require_objects.pdfDict({ StdCF: require_objects.pdfDict({
+			AuthEvent: require_objects.pdfName("DocOpen"),
+			CFM: require_objects.pdfName("AESV3"),
+			Length: require_objects.pdfNum(spec.keyBytes)
+		}) })],
+		["StmF", require_objects.pdfName("StdCF")],
+		["StrF", require_objects.pdfName("StdCF")],
+		["EncryptMetadata", require_objects.pdfBool(encryptMetadata)]
+	]);
+	return buildEncryptor(require_objects.pdfDict(entries), fileKey, spec.method, false, encryptMetadata);
+}
+function createStandardEncryptor(options, fileId) {
+	const scheme = options.scheme ?? "aes-256";
+	const spec = SCHEME_SPECS[scheme];
+	return spec.v === 5 ? buildAes256Encryptor(spec, options) : buildLegacyEncryptor(spec, options, fileId);
+}
+function encryptIndirectObject(value, num, gen, encryptor) {
+	if (value.kind === "string") return {
+		kind: "string",
+		bytes: encryptor.encryptString(value.bytes, num, gen),
+		hex: value.hex
+	};
+	if (value.kind === "array") return require_objects.pdfArray(value.items.map((item) => encryptIndirectObject(item, num, gen, encryptor)));
+	if (value.kind === "dict") return encryptDictEntries(value, num, gen, encryptor);
+	if (value.kind === "stream") return {
+		kind: "stream",
+		dict: encryptDictEntries(value.dict, num, gen, encryptor),
+		raw: encryptor.encryptStream(value.raw, value.dict, num, gen)
+	};
+	return value;
+}
+function encryptDictEntries(dict, num, gen, encryptor) {
+	return require_objects.pdfDict(new Map(Array.from(dict.entries, ([key, entry]) => [key, encryptIndirectObject(entry, num, gen, encryptor)])));
+}
+//#endregion
+exports.PdfEncryptionError = PdfEncryptionError;
+exports.createStandardEncryptor = createStandardEncryptor;
+exports.encryptIndirectObject = encryptIndirectObject;

package/dist/encrypt-write.d.cts

@@ -0,0 +1,31 @@
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
+//#region src/encrypt-write.d.ts
+declare class PdfEncryptionError extends Error {
+  constructor(message: string);
+}
+type PdfEncryptionScheme = "rc4-40" | "rc4-128" | "aes-128" | "aes-256";
+interface PdfEncryptionPermissions {
+  readonly print?: boolean;
+  readonly modifyContents?: boolean;
+  readonly copy?: boolean;
+  readonly annotate?: boolean;
+  readonly fillForms?: boolean;
+  readonly assemble?: boolean;
+  readonly printHighRes?: boolean;
+}
+interface PdfEncryptionOptions {
+  readonly userPassword?: string;
+  readonly ownerPassword?: string;
+  readonly scheme?: PdfEncryptionScheme;
+  readonly permissions?: PdfEncryptionPermissions;
+  readonly encryptMetadata?: boolean;
+}
+interface PdfEncryptor {
+  readonly encryptDict: PdfDict;
+  encryptString(bytes: Uint8Array<ArrayBuffer>, num: number, gen: number): Uint8Array<ArrayBuffer>;
+  encryptStream(bytes: Uint8Array<ArrayBuffer>, dict: PdfDict, num: number, gen: number): Uint8Array<ArrayBuffer>;
+}
+declare function createStandardEncryptor(options: PdfEncryptionOptions, fileId: Uint8Array<ArrayBuffer>): PdfEncryptor;
+declare function encryptIndirectObject(value: PdfObject, num: number, gen: number, encryptor: PdfEncryptor): PdfObject;
+//#endregion
+export { PdfEncryptionError, PdfEncryptionOptions, PdfEncryptionPermissions, PdfEncryptionScheme, PdfEncryptor, createStandardEncryptor, encryptIndirectObject };

package/dist/encrypt-write.d.ts

@@ -0,0 +1,31 @@
+import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
+//#region src/encrypt-write.d.ts
+declare class PdfEncryptionError extends Error {
+  constructor(message: string);
+}
+type PdfEncryptionScheme = "rc4-40" | "rc4-128" | "aes-128" | "aes-256";
+interface PdfEncryptionPermissions {
+  readonly print?: boolean;
+  readonly modifyContents?: boolean;
+  readonly copy?: boolean;
+  readonly annotate?: boolean;
+  readonly fillForms?: boolean;
+  readonly assemble?: boolean;
+  readonly printHighRes?: boolean;
+}
+interface PdfEncryptionOptions {
+  readonly userPassword?: string;
+  readonly ownerPassword?: string;
+  readonly scheme?: PdfEncryptionScheme;
+  readonly permissions?: PdfEncryptionPermissions;
+  readonly encryptMetadata?: boolean;
+}
+interface PdfEncryptor {
+  readonly encryptDict: PdfDict;
+  encryptString(bytes: Uint8Array<ArrayBuffer>, num: number, gen: number): Uint8Array<ArrayBuffer>;
+  encryptStream(bytes: Uint8Array<ArrayBuffer>, dict: PdfDict, num: number, gen: number): Uint8Array<ArrayBuffer>;
+}
+declare function createStandardEncryptor(options: PdfEncryptionOptions, fileId: Uint8Array<ArrayBuffer>): PdfEncryptor;
+declare function encryptIndirectObject(value: PdfObject, num: number, gen: number, encryptor: PdfEncryptor): PdfObject;
+//#endregion
+export { PdfEncryptionError, PdfEncryptionOptions, PdfEncryptionPermissions, PdfEncryptionScheme, PdfEncryptor, createStandardEncryptor, encryptIndirectObject };