@awacloud/pdf

Pure JavaScript library to read and write PDF documents in the browser, with no runtime dependency beyond @awacloud/fw and @awacloud/fonts. The reference is ISO 32000-2:2020 (PDF 2.0); PDF 1.x files are read too. pdf.write emits a %PDF-2.0 header; pdfBuilder.setVersion and pdfWriter.writeDocument({ version }) emit the header they are given (for example %PDF-1.7). Objects are re-emitted as read, not converted.

The core reads the file structure (classical cross-reference tables, cross-reference streams, object streams, incremental updates) into a typed object graph, and types the document layer on top of it: pages, resources, content streams, fonts (parsing delegated to @awacloud/fonts), AcroForm, annotations, Tagged PDF, optional content, outlines, actions, destinations, embedded files, metadata and prepress boxes. It writes documents from a read model or from scratch (pdfBuilder), as an incremental update, with cross-reference streams, or encrypted with the standard security handler. It signs and verifies PKCS#7 / PAdES signatures (levels B, T, LT, LTA) with public-key verification through @awacloud/fw/crypto/* (synchronous, worker-safe, no Web Crypto). An opt-in layer (extra/*) adds the long tail of PDF 2.0 and PDF 1.7 legacy reading, grouped into the bundles pdf-large, pdf-full and pdf-legacy.

Known limits, so they are not a surprise:

• The whole file must be in memory as a Uint8Array; there is no streaming reader.
• An encrypted file is refused by read (pdf/document/encrypted) unless you opt in to the raw container; decryption is done by calling the security-handler modules (pdfSecurity, pdfStandardV4/V5/V6) yourself.
• Content streams are parsed to an operator list, not rendered.
• write re-emits the objects it is given: it does not convert legacy content (XFA, RC4 encryption, LZW streams, Sound / Movie annotations) to PDF 2.0 equivalents.
• JBIG2 is read at the segment-header level only (no image decode), and the linearization extra builds the linearization dictionary and a hint-stream placeholder, not a linearized file.

Installation

npm install @awacloud/pdf

In the browser, via import map:

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

Quick Start

In the snippets below, bytes is a Uint8Array holding a PDF file.

Stand-alone (without the @awacloud/fw runtime)

pdf (src/pdf.js) is a factory descriptor whose factory takes its dependencies as positional arguments, so import { pdf } from '@awacloud/pdf' cannot be invoked on its own. The zero-ceremony path is the committed dist/standalone build, whose pdf root has every dependency inlined and is invocable with no arguments:

import { pdfBundled } from '@awacloud/pdf/standalone/pdf.js';

const api = pdfBundled.factory();
const doc = api.read(bytes);              // Uint8Array → typed model
console.log(doc.version);                 // header version, e.g. "1.5" or "2.0"
console.log(doc.pages.length);            // number of pages
console.log(doc.pages[0].mediaBox);       // the page's own /MediaBox, or null when inherited

const out = api.write(doc);               // → Uint8Array, %PDF-2.0
console.log(api.read(out).pages.length);  // the written file reads back

api.write(doc) re-emits the read model's indirect object graph in canonical form: %PDF-2.0 header, sequential objects, classical cross-reference table, trailer. The layered dist/standalone roots (pdf-large, pdf-full, pdf-legacy and the four -rw roots) are invocable the same way — see Committed dist below.

With the @awacloud/fw runtime

import { ModuleRuntime } from '@awacloud/fw/core/runtime.js';
import { fw_require, modules } from '@awacloud/pdf';

const rt = new ModuleRuntime();
for (const m of fw_require) rt.register(m);
for (const m of modules)    rt.register(m);

const api = rt.resolve('pdf');
const doc = api.read(bytes);
console.log(doc.pages.length);

.use(...) hook (idempotent extension)

import { pdfBundled } from '@awacloud/pdf/standalone/pdf.js';

const api = pdfBundled.factory();
api.use({
    name: 'my-extra',
    register(self) {
        return {
            countAnnots: (b) => self.read(b).pages
                .reduce((n, p) => n + p.annots.length, 0)
        };
    }
});
console.log(api.countAnnots(bytes));
console.log(api.usedExtension('my-extra'));   // true

.use() is idempotent by name: applying the same extension twice is a no-op.

With a bundle (extras wired automatically)

Bundles are module descriptors, consumed through a ModuleRuntime:

import { ModuleRuntime } from '@awacloud/fw/core/runtime.js';
import { fw_require, pkg_require, modules, extras, bundle } 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);
for (const m of extras)      rt.register(m);
for (const m of bundle)      rt.register(m);

const api = rt.resolve('pdfLargeBundle');
const doc = api.read(bytes);
console.log(doc.pages.length);

// Each wired extra is reachable under its factory name:
console.log(api.usedExtension('pdfAOutputIntent'));        // true
console.log(api.pdfAOutputIntent.PDFA_PROFILES['2b'].iso); // 'ISO 19005-2:2011'

Reading cross-reference forms

api.read(bytes) accepts classical (xref table) and PDF 1.5+ cross-reference-stream (/Type /XRef, §7.5.8) sections — mixed /Prev chains and hybrid-reference files (a classical trailer carrying /XRefStm) resolve end to end, and objects held in a /Type /ObjStm container (§7.5.7) are materialised on demand. /DecodeParms (e.g. a PNG predictor on a cross-reference stream) reach the decoders as plain parameters and are honoured, and an indirect /ExtGState (or other resource category) on a page does not drop the whole resource map. A non-catalog object that is free but still referenced degrades to a recorded entry in doc.losses instead of throwing (a free /Root is still refused); appendIncremental extends a cross-reference-stream base with an uncompressed /Type /XRef section.

Bundles

src/main.js exports the five descriptor arrays (fw_require, pkg_require, modules, extras, bundle) and every modules descriptor by binding name; the extras and bundle descriptors are not exported individually from the root, so import { pdfLargeBundle } from '@awacloud/pdf' is undefined — register the arrays as above, or import one bundle from its own sub-path (@awacloud/pdf/pdf-large, @awacloud/pdf/pdf-full, @awacloud/pdf/pdf-legacy).

• pdfLargeBundle — the core plus the P0 and P1 extras (common PDF 2.0 features).
• pdfFullBundle — pdf-large plus the P2 and P3 extras, including the opt-in action sandbox linter.
• pdfLegacyBundle — pdf-full plus the PDF 1.7 legacy readers (XFA, RC4, deprecated filters, deprecated multimedia annotations).

Each bundle's extras are listed literally in its descriptor's dependencies; see docs/api/bundles/ for the per-bundle tables.

Committed dist — two build surfaces

For consumers who don't want to hand-assemble the fw_require / modules manifest, dist/ ships a committed, pre-generated build: an 8-root matrix crossing the four assembly roots (pdf, pdf-large, pdf-full, pdf-legacy, the Read family) with four -rw roots (pdf-rw, pdf-large-rw, pdf-full-rw, pdf-legacy-rw, the Read+Write family — each Read root plus the write inventory, including pdfXrefStreamWriter, and the signature verifier pdfSignature beside the signer), in two path-discriminated surfaces:

Each root emits a .js / .min.js / .meta.json triplet (e.g. dist/build/pdf-large.js, pdf-large.min.js, pdf-large.meta.json), plus a single dist/build/index.js barrel re-exporting the whole src/main.js namespace (the five registration arrays and every named descriptor) for registration on an @awacloud/fw runtime. Each .meta.json sidecar records the root's modules, fwDependencies (read back from the generated descriptor, never hardcoded) and build byte sizes. See docs/api/bundles/dist-matrix.md for the 8-root × 2-surface table, the -rw naming scheme and the write inventory.

Idempotence: bun run gen:bundles (tools/generate-bundles.mjs) produces byte-identical output across runs (no build stamp; every .js / .min.js opens with the /*! … */ licence banner at byte 0). It is a thin wrapper around @awacloud/tool-prebuild-generator, a build tool of the source monorepo that is not published.

Invocability: every dist/standalone root is invocable with no arguments, the layered ones included — each layered extra is registered through the { name, register } envelope pdf.use() requires, so pdfRwBundled.factory() returns a core on which core.usedExtension('pdfSign') and core.usedExtension('pdfSignature') are both true and core.pdfSignature.verifySignature is callable. The dist/build roots need an @awacloud/fw runtime to inject their declared dependencies.

Source structure

src/
├── main.js            — entry point: the five descriptor arrays + named descriptors
├── pdf.js             — top-level api (read, header, write, use, usedExtension)
├── errors.js          — `pdfErrors` (PdfError + ParseError / RenderError /
│                         ContractError / EncryptionError + isPdfError)
├── _shared/           — `pdfShared` byte constants and stateless helpers
├── syntax/            — tokenizer, parser, serializer, xref, trailer,
│                         object streams, cross-reference streams, filters/
├── document/          — catalog, page tree, document reader, writers
│                         (classical, builder, incremental, xref-stream, encrypted)
├── content/ font/ form/ annot/ tagged/ ocg/ outline/ destination/ action/
├── embedded/ associatedFiles/ linearization/ metadata/ prepress/
├── crypto/            — security handlers V4 / V5 / V6, permissions, AES-GCM
├── sig/               — signature typing + verification, signing, ByteRange,
│                         RFC 3161 timestamps, certificate chains, DSS
├── extra/             — opt-in extras (P0–P3 + legacy)
└── bundles/           — pdf-large, pdf-full, pdf-legacy descriptors

Documentation

API per module: docs/api/README.md. Sibling package with the same factory + bundles layout: @awacloud/ooxml.

Tests

$ bun test packages/front/office/pdf/

Co-located unit tests (*.test.js next to each source file) plus integration suites under tests/, among them:

• tests/roundtrip.integration.test.js — wiring via the @awacloud/fw ModuleRuntime, read → write → read, worker transportability of every factory
• tests/legacy-conversion.test.js — PDF 1.x read tolerance
• tests/fuzz.test.js — garbage and truncated input → typed ParseError
• tests/_helpers/build.js — shared fixture builder

Design choices

• Plain binary format — no ZIP (unlike @awacloud/ooxml and @awacloud/odf). The PDF container is its own format: %PDF-2.0 header + indirect objects + cross-reference section + trailer.
• Worker-safe — each factory is self-sufficient (serializable via factory.toString()). Constants are inlined in the body, no mutable module-level closure.
• No external dependency — @awacloud/fw and @awacloud/fonts only. Codecs that @awacloud/fw does not provide (the simple filters, RC4, CCITT fax) are implemented in this package.
• Typed errors — no raw throw new Error(...); only PdfError and its subclasses, with a stable kebab-case code and a structured context. The classes are not exported at the top level: they are declared inside the pdfErrors factory body, so each pdfErrors.factory() call creates a fresh set of classes. Resolve pdfErrors through one ModuleRuntime (which caches the instance) to share class identities across consumers; across two separate factory() calls, instanceof does not hold — compare e.code instead.

Exposed sub-paths

The src/document/* modules (writers, builder, catalog, pages, resources) have no sub-path of their own: they are reached through the root entry's named descriptors.

Maturity

L4 (awa.maturity in package.json): the package covers its declared surface, within the limits listed above, and ships a test suite and per-module reference pages.

Licence

AGPL-3.0-only — see LICENSE. The package is also available under a commercial licence; see NOTICE.

Copyright (c) 2026 AwaCloud SAS

Project

• Website: https://awaforge.eu
• Source: packages/front/office/pdf
• Issues: https://github.com/awacloud/awa/issues
• Security policy: https://github.com/awacloud/awa/blob/@awacloud/pdf@1.0.0/SECURITY.md

npm install @awacloud/pdf@1.0.0