@awacloud/pdf 0.0.0-stage → 1.0.0

package/docs/guide/coverage.md

@@ -0,0 +1,113 @@
+# Coverage
+
+What `@awacloud/pdf` covers of ISO 32000-2:2020 (PDF 2.0), of the ISO
+technical specifications around it and of PDF 1.7 legacy reading — chapter
+by chapter, with the caveats that bound each claim.
+
+**Prerequisites** — the package `@awacloud/pdf` (root entry, plus the
+`extra/*` modules or one of the three bundles for the rows marked "via
+extra"); any modern JavaScript runtime. See
+[`CHANGELOG.md`](../../CHANGELOG.md) for the module list.
+
+## Coverage — ISO 32000-2:2020
+
+| Chapter | Domain | Coverage |
+|----------|---------|-----------|
+| §7.2-7.5 | Syntax (tokens, objects, xref, trailer) | **100%** read + write |
+| §7.4 | Filters | Through `pdfFilterDispatch` — the path `read` uses to decode cross-reference and object streams: FlateDecode (with `/Predictor` PNG 10–15 and TIFF 2, encode and decode), ASCIIHexDecode, ASCII85Decode, RunLengthDecode; DCTDecode, JPXDecode and Crypt pass through undecoded. `/DecodeParms` reach the decoders as plain values, so a predictor is applied; only scalar entries (numbers, names, booleans, strings) survive that marshalling — a dictionary, array or indirect-reference entry reaches the decoder as `undefined`. LZWDecode and CCITTFaxDecode are **not** registered in the dispatch by default (`pdf/filter/unsupported`): decode them through `extra/legacy-deprecated-filters` (LZW via `@awacloud/fw`, a full ITU-T T.4 / T.6 CCITT codec), or add them with `register(name, impl)`. JBIG2Decode: segment headers only (`extra/jbig2-read`), no image decode |
+| §7.5.7-8 | Object Stream + Cross-Reference Stream | Read: cross-reference streams, mixed `/Prev` chains and hybrid-reference files, object streams materialised on demand — both decoded through the dispatch path above, so a stream whose filter the dispatch does not register cannot be read; object streams inside an encrypted document are refused (`pdf/document/objstm-encrypted`). Write: `pdfXrefStreamWriter` emits `/Type /XRef` documents (opt-in `/ObjStm` grouping); `appendIncremental` extends a cross-reference-stream base with an uncompressed `/Type /XRef` section and refuses a hybrid-reference base |
+| §7.6 | Encryption (Standard SH v4/v5/v6) | v4 (AESV2/RC4-128) + v5 (AES-256) + v6 (Algorithm 2.B) decrypt **and** encrypt, plus AES-GCM (TS 32003); encrypted write via `pdfEncryptedWriter`. On read, the handlers are called by the caller: `read` refuses an encrypted file (`pdf/document/encrypted`) unless `allowEncrypted: true`, and then returns the ciphertext as is |
+| §7.7-7.8 | Document structure (Catalog, Pages, Resources) | **100%** |
+| §7.11 | Embedded files + Portfolios | 100% via `embedded/` + `extra/embedded-files-portfolio` |
+| §8.2-8.5 | Content streams (operators, path, painting) | ~70 operators catalogued |
+| §8.6 | Colour spaces | Device + Cal* + Lab + ICCBased + Indexed + Separation + DeviceN + Pattern + NChannel (via extra) |
+| §8.7 | Patterns + Shading | Types 1-7 + Function 0/2/3/4 (via extra) |
+| §8.9 / §8.10 | Images + XObjects (Image + Form) | 100% typed |
+| §8.11 | Optional Content | 100% + `/VE` evaluator (via extra) |
+| §9.6-9.9 | Fonts (Type1/Type3/TrueType/Type0/CIDFont) | 100% typed; parsing delegated to `@awacloud/fonts` |
+| §11 | Transparency (groups, soft masks, blend modes) | 100% via `extra/transparency-typed` |
+| §12.3 | Outlines + Destinations | 100% |
+| §12.5 | Annotations (25+ subtypes) | 100% typed |
+| §12.6 | Actions (GoTo / URI / Named / Launch / …) | 9 subtypes + extras |
+| §12.7 | AcroForm | Btn/Tx/Ch/Sig + appearance streams |
+| §12.8 | Digital signatures | PKCS#7 detached, `/ByteRange` hardened validation, real public-key verification (RSA-PSS/ECDSA/Ed25519 — see [Crypto](./crypto.md)), PAdES profile detection |
+| §14.3 | Metadata | Info dict + raw XMP + extended XMP (via extra) |
+| §14.6-14.8 | Tagged PDF + MCID resolution | 100% via `tagged/` |
+| §14.11 | Prepress + Output Intents | 100% |
+| Annex F | Linearization | Read: the `/Linearized` parameter dictionary is typed (`linearization/`); hint streams are not decoded. Write: `extra/linearization-write` builds the `/Linearized` dictionary and a zero-length hint-stream placeholder — `write` never produces a linearized file |
+
+## ISO Technical Specifications
+
+| TS | Spec | Status |
+|----|------|--------|
+| ISO 32001 | Digital signatures (PAdES B/T/LT/LTA) | profile detection via `extra/sig-pades` |
+| ISO 32002 | Crypto computations | digest + signature OID dispatch; Ed25519 signatures use SHA-512 (RFC 8419) and their signing update declares the `ISO_` developer extension (`/ExtensionLevel 32002`) in the Catalog, with `/Version /2.0` below PDF 2.0 (EdDSA in viewers: see the [PAdES guide](./pades-integration.md)) |
+| ISO 32003 | AES-GCM crypt filter | full, via `crypto/aesGcm` + `extra/sig-aes-gcm` |
+| ISO 32004 | Document parts | typed read via `extra/document-parts` |
+| ISO/TS 32005 (referenced; the TS text is not in the repository) | Redaction | read-side only: `annot/redact` types the Redact annotation (ISO 32000-2 §12.5.6.21), `extra/redaction-iso32005` types the apply-redaction audit record. No content is removed or redrawn. |
+| ISO 14289-2 | PDF/UA-2 accessibility | linter via `extra/pdf-ua-tagged` |
+| WTPDF 1.0 | Well-Tagged PDF | best-practice linter via `extra/well-tagged-pdf` |
+
+## PDF 1.7 read tolerance
+
+Via the `pdf-legacy` bundle:
+
+| 1.7 feature | Status |
+|-------------|--------|
+| `%PDF-1.x` header | accepted on read |
+| Standard SH v4 (RC4 v2/v3) | password check + string / stream decryption helpers in `extra/legacy-rc4-read`, called by the caller (see §7.6 above) |
+| LZWDecode filter | wrapper over `@awacloud/fw/io/compress/lzw` in `extra/legacy-deprecated-filters`; not registered in the filter dispatch |
+| XFA forms | read-only, opaque surface (`extra/legacy-xfa-read`); `write` re-emits `/XFA` as it was |
+| Sound / Movie annotations | typed, read-only (`extra/legacy-deprecated-annots`); not converted to RichMedia |
+| CCITTFaxDecode | full ITU-T T.4 / T.6 decode (K < 0 Group 4, K = 0 Group 3 1-D, K > 0 Group 3 mixed) via `extra/legacy-deprecated-filters` and `extra/ccitt-fax-decoder`; not registered in the filter dispatch |
+| JBIG2Decode | segment headers only (`extra/jbig2-read`); its `decode` throws |
+
+**Write** emits `%PDF-2.0` through `pdf.write`;
+`pdfBuilder.setVersion()` / `writeDocument({ version })` emit the requested
+header. The writer re-emits the objects of the model it is given: legacy
+content read from a 1.x file is written back as it was, not converted.
+
+## Extras (opt-in via `.use()` or a bundle)
+
+The opt-in modules under `extra/*`, wired through [`.use()`](./extending.md) or one
+of the three [bundles](../api/bundles/README.md) (`pdf-large`, `pdf-full`,
+`pdf-legacy`). See [`docs/api/extra/README.md`](../api/extra/README.md) for
+the full catalogue.
+
+## Limitation: whole-buffer reading
+
+`@awacloud/pdf` requires the complete document to be loaded in memory
+(`Uint8Array`) before any `.read(...)` call. The PDF format places the
+xref table **at the end of the file** (§7.5.4), so there is no upstream
+streaming mode without linearization (header hint objects). Implications:
+
+- Reading a 100 MB PDF → peak memory ≥ 100 MB (before the resolved-object
+  cache).
+- No `pdf.readStream(...)` API: a wrapper consuming a `ReadableStream`
+  must accumulate the bytes first.
+- A **linearized** file does not lift this limit: the reader still needs
+  the whole buffer, and [`pdfLinearization`](../api/linearization/linearization.md)
+  only types the `/Linearized` parameter dictionary.
+
+This is a deliberate choice — an upstream streaming mode would require
+either violating the xref-at-end spec requirement, or imposing the
+linearization extension on write, both incompatible with a strict PDF 2.0
+model that stays tolerant on read.
+
+Hard parser quotas are configurable per resolved `pdfParser` instance
+(`parserLimits`/`setParserLimits` are returned by the factory, not
+top-level module exports):
+
+```js
+const parser = runtime.resolve('pdfParser');
+console.log(parser.parserLimits.maxDepth);          // 200
+console.log(parser.parserLimits.maxStreamBytes);    // 256 MiB
+parser.setParserLimits({ maxStreamBytes: 64 * 1024 * 1024 }); // strict 64 MiB
+```
+
+## See also
+
+- [Read pipeline](./read-pdf.md)
+- [Extending](./extending.md)
+- [Crypto — risks and limitations](./crypto.md)
+- [CHANGELOG](../../CHANGELOG.md)

package/docs/guide/crypto.md

@@ -0,0 +1,121 @@
+# Crypto — risks and limitations
+
+> Summary of `@awacloud/pdf`'s crypto choices and the security properties it
+> does (or does *not*) guarantee.
+
+**Prerequisites** — the package `@awacloud/pdf` (root entry
+`@awacloud/pdf`, or the committed `@awacloud/pdf/standalone/*` build) and its
+`@awacloud/fw` / `@awacloud/fonts` dependencies; any modern JavaScript runtime
+(browser main thread or Worker, Bun, Node.js 18+). The cryptography goes through `@awacloud/fw/crypto/*`
+(synchronous, no Web Crypto); the modules below are `@awacloud/pdf/crypto/*`
+and `@awacloud/pdf/sig/*`.
+
+## Standard Security Handler (V=4 R=4 / V=5 R=5 / V=5 R=6)
+
+`crypto/standardV4.js` implements the V=4 R=4 handler (AES-128-CBC or
+RC4-128 crypt filters), `crypto/standardV5.js` the V=5 R=5 handler (AES-256,
+Algorithm 2.A, no hardening loop) and `crypto/standardV6.js` the PDF 2.0
+V=5 R=6 handler (AES-256 with the Algorithm 2.B hardening loop). `read`
+does not apply them by itself: it refuses an encrypted file unless
+`allowEncrypted: true` is passed, and the caller then decrypts through
+these handlers.
+
+### AES-CBC without a MAC: malleability risk
+
+The PDF format mandates plain **AES-256-CBC** for encrypted strings and
+streams when `/Method /AESV3` is used. Consequences:
+
+- **No authenticated integrity protection** on an encrypted field: an
+  attacker able to modify ciphertext bytes of an encrypted PDF string
+  causes predictable changes in the decrypted plaintext (CBC
+  bit-flipping). Until a MAC or AEAD is applied *on top* (e.g. a digital
+  signature over the whole document), malleability is a property of the
+  format itself.
+- The **TS 32003 — AES-GCM** extension covers this by replacing CBC with
+  GCM (authenticated encryption). The `aesGcm.js` module is shipped for
+  consumers who want to implement this out-of-strict-spec extension.
+
+### Password authentication
+
+Algorithm 2.B (R=6) resists dictionary attacks correctly thanks to the
+hardening loop (≥ 64 iterations of SHA-2 + AES-128, conditional
+termination on the ciphertext). In `standardV6.js`:
+
+- The AES-128 key-schedule scratch buffer is reused across rounds.
+- A forced bail-out at 1024 rounds guards against a runaway loop
+  (`pdf/crypto/v6/hardening-runaway`).
+
+## Signatures
+
+`sig/signature.js` and `sig/timestamp.js` type PKCS#7/CMS signatures and
+RFC 3161 tokens **and execute real public-key verification** through the
+`verifyPk` primitive dispatcher (RSA-PSS, ECDSA, Ed25519) — `verifyPk` is
+wired by construction, called from `_verifyPkcs7Signature` on every
+`verifySignature(...)`/`verifyAllSignatures(...)` call. There is no
+"structural-only, PK verify left to the consumer" mode: the digest is
+recomputed from the `/ByteRange`-covered bytes, the signer certificate's
+SPKI is extracted, and the matching fw primitive
+(`rsa.pssVerify`/`ecc.ecdsa…verify`/`ed25519.verify`) is invoked directly.
+
+### Semantics of `verifySignature(...)`
+
+| Field | Meaning |
+|-------|------|
+| `verified` | `true` **iff** the RSA-PSS / ECDSA / Ed25519 public-key verification ran and succeeded. `false` in every other case (parse failure, digest mismatch, missing/unmatched signer cert, unsupported algorithm, or a failed public-key check). |
+| `valid` | Historical alias of `verified` — kept in sync, same boolean. |
+| `pkVerified` | `true` only once `_verifyPkcs7Signature` reaches and passes the `verifyPk` call; `false` on every earlier bail-out. |
+| `computedDigest` | The digest recomputed over the `/ByteRange` ranges — useful for a caller that wants to re-run `rsa.pssVerify` / `ecc…verify` itself. |
+| `errors` | Array of `{ code, message }` records — the parse/verification step that failed, if any (e.g. `pdf/sig/pkcs7-malformed`, `pdf/sig/signer-cert-not-found`, or a `pdf/sig/verify-pk/*` code from `verifyPk` on primitive-level failure). |
+
+RSA PKCS#1 v1.5 signatures are refused outright
+(`pdf/sig/rsa-pkcs1v15-deprecated`, NIST SP 800-131A Rev.2) rather than
+verified — use RSA-PSS.
+
+**Ceiling that remains real**: `certChain.validateChainOrder` compares
+issuer/subject strings only (no cryptographic chain, revocation, or trust
+anchor check). Still open: a cryptographic chain-of-trust check over the
+PKCS#7 SignerInfo certificates, and PAdES long-term validation (which
+needs network I/O for revocation data).
+`valid`/`verified: true` proves the PKCS#7 signature was cryptographically
+valid over the signed bytes and the signer certificate was structurally
+matched — it is **not** proof the certificate itself is trusted or
+unrevoked.
+
+### Hardened ByteRange verification
+
+`auditByteRange(documentBytes, byteRange, opts)` (from L3+) detects:
+
+- `pdf/sig/byterange/self-overlap` — the second range starts before the
+  first one ends.
+- `pdf/sig/byterange/gap-start-mismatch` /
+  `pdf/sig/byterange/gap-end-mismatch` — the declared gap does not land
+  exactly on the `/Contents` hex string.
+- `pdf/sig/byterange/cross-overlap` — overlap with another `/ByteRange`
+  (useful for multiple signatures / incremental updates).
+- `pdf/sig/byterange/incomplete-coverage` — the second range does not
+  reach `documentBytes.length` (unsigned tail).
+- `pdf/sig/byterange/non-zero-start` — the first range does not start at
+  0.
+
+### Active actions (`/Launch`, `/JavaScript`, `/SubmitForm`)
+
+The `action/launch.js` typer returns a record with:
+
+```js
+{ kind: 'Launch', sandboxed: true,
+  securityWarning: 'launch actions are not executed by @awacloud/pdf', … }
+```
+
+The opt-in `pdfSandbox` linter (bundle `pdf-full`) consolidates every
+active-content record into a unified audit — `lintActions(records)`
+returns `{ issues, hasErrors, hasActiveContent }` with `error` severity for
+`Launch` / `JavaScript` / `ImportData` and `warning` for `URI` /
+`SubmitForm` / `Rendition + /JS`.
+
+**The package never executes anything.** These helpers exist so the host
+application can refuse or prompt before propagating active content.
+
+## See also
+
+- [Coverage](./coverage.md)
+- [CHANGELOG](../../CHANGELOG.md)

package/docs/guide/extending.md

@@ -0,0 +1,76 @@
+# Extending via `.use()`
+
+The public [`pdf`](../api/pdf.md) API exposes an extension hook `.use(extension)` to add methods without modifying the core. This guide shows the extension shape, the idempotence rule and how the bundles use the same hook.
+
+**Prerequisites** — the package `@awacloud/pdf` (root entry
+`@awacloud/pdf`, or the committed `@awacloud/pdf/standalone/*` build) and its
+`@awacloud/fw` / `@awacloud/fonts` dependencies; any modern JavaScript runtime
+(browser main thread or Worker, Bun, Node.js 18+).
+
+## Shape of an extension
+
+```js
+{
+    name: 'unique-identifier',           // string, kebab-case recommended
+    register(api, ctx) {                 // ctx = { usedExtensions: Set }
+        return { someNewMethod() { /* … */ } };
+    }
+}
+```
+
+`register` receives the current API and can:
+
+- consume its methods (`api.read`, `api.header`, …) to compose behaviour;
+- return an object whose keys (except `use`) are merged into the public API;
+- return `undefined` for a pure side effect (no new method).
+
+## Idempotence by name
+
+`.use()` is **idempotent**: applying the same `name` twice is a silent no-op. No double-merge, no error. The internal `usedExtensions` set is queryable via `api.usedExtension(name)`.
+
+```js
+const ext = { name: 'demo', register: () => ({ ping: () => 42 }) };
+
+api.use(ext);
+api.use(ext);                     // no-op
+api.ping();                       // 42
+api.usedExtension('demo');        // true
+```
+
+## Validation
+
+A malformed extension (missing `name` or `register`) throws `ContractError` (`pdf/use/bad-extension`). See [`pdfErrors`](../api/errors.md).
+
+## Example — count annotations
+
+```js
+import { ModuleRuntime } from '@awacloud/fw/core/runtime.js';
+import { fw_require, pkg_require, modules } from '@awacloud/pdf';
+
+const rt = new ModuleRuntime();
+for (const m of fw_require)  rt.register(m);
+for (const m of pkg_require) rt.register(m);
+for (const m of modules)     rt.register(m);
+
+const api = rt.resolve('pdf');
+
+api.use({
+    name: 'count-annots',
+    register(api) {
+        return {
+            countAnnots(bytes) {
+                return api.read(bytes).pages
+                    .reduce((n, p) => n + p.annots.length, 0);
+            }
+        };
+    }
+});
+
+api.countAnnots(bytes);           // → int
+```
+
+## See also
+
+- [`pdf` orchestrator](../api/pdf.md)
+- [`pdfErrors`](../api/errors.md)
+- [Coverage](./coverage.md) — the extras planned/shipped through this hook.

package/docs/guide/getting-started.md

@@ -0,0 +1,75 @@
+# Getting Started
+
+`@awacloud/pdf` reads and writes PDF documents in pure JavaScript, browser-side, with no runtime dependency beyond `@awacloud/fw` and `@awacloud/fonts`. This guide installs the package, wires it on a `ModuleRuntime` and reads a first document.
+
+**Prerequisites** — the package `@awacloud/pdf` (root entry
+`@awacloud/pdf`, or the committed `@awacloud/pdf/standalone/*` build) and its
+`@awacloud/fw` / `@awacloud/fonts` dependencies; any modern JavaScript runtime
+(browser main thread or Worker, Bun, Node.js 18+).
+
+## Install
+
+```bash
+npm install @awacloud/pdf
+```
+
+Browser import map:
+
+```html
+<script type="importmap">
+{ "imports": {
+    "@awacloud/fw":     "/node_modules/@awacloud/fw/src/main.js",
+    "@awacloud/fw/":    "/node_modules/@awacloud/fw/src/",
+    "@awacloud/fonts":  "/node_modules/@awacloud/fonts/src/main.js",
+    "@awacloud/fonts/": "/node_modules/@awacloud/fonts/src/",
+    "@awacloud/pdf":    "/node_modules/@awacloud/pdf/src/main.js",
+    "@awacloud/pdf/":   "/node_modules/@awacloud/pdf/src/"
+}}
+</script>
+<script type="module" src="./app.js"></script>
+```
+
+## With `@awacloud/fw` `ModuleRuntime`
+
+`pdf` is a **strict factory-only descriptor** — its `factory` takes 13
+positional dependency arguments and has no zero-argument convenience
+form. Materialise a working instance by registering the package's manifest
+arrays on a `ModuleRuntime` and resolving by name (or use the committed
+`@awacloud/pdf/standalone/pdf.js` build, whose `pdfBundled.factory()`
+takes no arguments):
+
+```js
+import { ModuleRuntime } from '@awacloud/fw/core/runtime.js';
+import { fw_require, pkg_require, modules } from '@awacloud/pdf';
+
+const rt = new ModuleRuntime();
+for (const m of fw_require)  rt.register(m);   // @awacloud/fw crypto/io modules
+for (const m of pkg_require) rt.register(m);   // @awacloud/fonts subset helpers
+for (const m of modules)     rt.register(m);   // @awacloud/pdf's own modules
+
+const api = rt.resolve('pdf');
+const doc = api.read(bytes);              // bytes: Uint8Array
+
+console.log(doc.version);                 // header version, e.g. "1.7" or "2.0"
+console.log(doc.pages.length);            // → page count
+console.log(doc.pages[0].mediaBox);       // the page's own /MediaBox, or null when inherited
+```
+
+`modules` is topologically ordered — registration order only matters in
+that every dependency must be registered before `resolve('pdf')` is
+called; `ModuleRuntime` resolves each declared dependency by name
+regardless of array order.
+
+## Reading just the header
+
+```js
+api.header(bytes);
+// → { version: '2.0', end: <offset> }   (the header's own version)
+```
+
+## Next steps
+
+- [Detailed read pipeline](./read-pdf.md)
+- [Extending via `.use()`](./extending.md)
+- [Coverage](./coverage.md)
+- [API index](../api/README.md)

package/docs/guide/legacy-1.7.md

@@ -0,0 +1,42 @@
+# Reading legacy PDF 1.7
+
+`@awacloud/pdf` targets **ISO 32000-2:2020 (PDF 2.0)** for writing. On **read**, `%PDF-1.x` headers produced by any ISO 32000-1:2008-conformant tool are accepted. This guide states what the core reader does with a 1.x file; the legacy-only constructs (XFA, RC4, LZW, CCITT fax, Sound/Movie) are read by the `pdf-legacy` bundle's extras — see [Coverage](./coverage.md#pdf-17-read-tolerance).
+
+**Prerequisites** — the package `@awacloud/pdf` (root entry
+`@awacloud/pdf`, or the committed `@awacloud/pdf/standalone/*` build) and its
+`@awacloud/fw` / `@awacloud/fonts` dependencies; any modern JavaScript runtime
+(browser main thread or Worker, Bun, Node.js 18+).
+
+## Behaviour
+
+`readHeader(bytes)` does not constrain the `x.y` suffix value:
+
+```js
+api.header(bytes);
+// → { version: '1.7', end: 9 }
+// → { version: '1.4', end: 9 }
+// → { version: '2.0', end: 9 }
+```
+
+Whatever version is exposed in `doc.version` is the raw string found in the header (`'1.7'`, `'2.0'`, …). No normalization is applied.
+
+## Guarantees
+
+- Headers `%PDF-1.0` through `%PDF-2.0` are all accepted.
+- The header may be preceded by up to 1024 bytes of binary junk (§7.5.2 tolerance).
+- Classical xref works identically across 1.x and 2.0.
+- 2.0-exclusive constructs (associated files, document parts, extended namespaces) are preserved in `_extras` when read from a 1.x file, without erroring.
+
+## Cross-reference forms across 1.x and 2.0
+
+`pdfDocument.readDocument` (the code path behind `api.read(bytes)`) walks every cross-reference section in the `/Prev` chain and picks its form from the bytes it finds: an `xref` keyword takes the classical table path (`pdfXref.parseXrefTable`), anything else is parsed as a `/Type /XRef` cross-reference stream (§7.5.8) through `pdfCrossRefStream`. A PDF 1.5+ file that uses **only** cross-reference streams therefore opens through `api.read(bytes)`, and so do mixed chains — a classical incremental section stacked on an xref-stream base, or an xref stream stacked on a classical base.
+
+Objects stored inside a `/Type /ObjStm` container (§7.5.7) are materialised on demand through `pdfObjStream`: `doc._raw.resolve(ref)` returns them like any other indirect, and each container is decoded once per document. A hybrid file (classical xref table plus a `/XRefStm` pointer, the common PDF 1.5+ producer output) has its companion stream merged too; entries the classical table itself provides take precedence.
+
+**Not supported.** Object streams inside an **encrypted** document stay out of the default pipeline: `readDocument`'s `resolveCompressed` throws `pdf/document/objstm-encrypted` because no decrypt path is composed for it (`resolveCompressed` in `src/document/document.js`).
+
+## See also
+
+- [Coverage](./coverage.md)
+- [`pdfDocument`](../api/document/document.md)
+- [`pdfXref`](../api/syntax/xref.md)