@awacloud/pdf 0.0.0-stage → 1.0.0

package/package.json

@@ -1,6 +1,99 @@
 {
   "name": "@awacloud/pdf",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "license": "AGPL-3.0-only",
+  "author": "Matthieu Bouilloux",
+  "company": "AwaCloud SAS",
+  "copyright": "Copyright (c) 2026 AwaCloud SAS",
+  "type": "module",
+  "main": "src/main.js",
+  "description": "Browser-safe PDF 2.0 reader/writer — ISO 32000-2:2020, PDF 1.7 legacy read, typed object graph, AES-256 encrypted write, PKCS#7/PAdES signatures (sign + verify). Zero runtime dependency beyond @awacloud/fw and @awacloud/fonts.",
+  "keywords": [
+    "pdf",
+    "pdf-2.0",
+    "iso-32000",
+    "pades",
+    "pkcs7",
+    "tagged-pdf",
+    "pdf-a",
+    "pdf-ua",
+    "xmp",
+    "acroform",
+    "browser",
+    "worker-safe"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "files": [
+    "src/**/*.js",
+    "!src/**/*.test.js",
+    "dist/**",
+    "docs",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": "./src/main.js",
+    "./pdf": "./src/pdf.js",
+    "./errors": "./src/errors.js",
+    "./serializer": "./src/syntax/serializer.js",
+    "./filters/*.js": "./src/syntax/filters/*.js",
+    "./filters/*": "./src/syntax/filters/*.js",
+    "./annot/*.js": "./src/annot/*.js",
+    "./annot/*": "./src/annot/*.js",
+    "./tagged/*.js": "./src/tagged/*.js",
+    "./tagged/*": "./src/tagged/*.js",
+    "./crypto/*.js": "./src/crypto/*.js",
+    "./crypto/*": "./src/crypto/*.js",
+    "./sig/*.js": "./src/sig/*.js",
+    "./sig/*": "./src/sig/*.js",
+    "./ocg/*.js": "./src/ocg/*.js",
+    "./ocg/*": "./src/ocg/*.js",
+    "./action/*.js": "./src/action/*.js",
+    "./action/*": "./src/action/*.js",
+    "./embedded/*.js": "./src/embedded/*.js",
+    "./embedded/*": "./src/embedded/*.js",
+    "./metadata/*.js": "./src/metadata/*.js",
+    "./metadata/*": "./src/metadata/*.js",
+    "./prepress/*.js": "./src/prepress/*.js",
+    "./prepress/*": "./src/prepress/*.js",
+    "./extra/*.js": "./src/extra/*.js",
+    "./extra/*": "./src/extra/*.js",
+    "./bundles/*.js": "./src/bundles/*.js",
+    "./bundles/*": "./src/bundles/*.js",
+    "./pdf-large": "./src/bundles/pdf-large.js",
+    "./pdf-full": "./src/bundles/pdf-full.js",
+    "./pdf-legacy": "./src/bundles/pdf-legacy.js",
+    "./build/*": {
+      "default": "./dist/build/*"
+    },
+    "./standalone/*": {
+      "default": "./dist/standalone/*"
+    }
+  },
+  "scripts": {
+    "gen:bundles": "bun run tools/generate-bundles.mjs",
+    "lint": "eslint . --max-warnings 0"
+  },
+  "dependencies": {
+    "@awacloud/fw": "0.1.0",
+    "@awacloud/fonts": "1.0.0"
+  },
+  "awa": {
+    "maturity": "L4",
+    "coverageFloor": 0.58
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/awacloud/awa.git",
+    "directory": "packages/front/office/pdf"
+  },
+  "homepage": "https://awaforge.eu",
+  "bugs": {
+    "url": "https://github.com/awacloud/awa/issues"
+  }
+}

package/src/_shared/index.js

@@ -0,0 +1,179 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview `pdfShared` — canonical source of PDF byte-level
+ * constants and stateless helpers previously duplicated across many
+ * `@awacloud/pdf` factories.
+ *
+ * Exposes :
+ * - **Magic bytes** : `HEADER_PREFIX` (`%PDF-`), `EOF_MARKER` (`%%EOF`),
+ *   `BINARY_MARKER` (the `%¡¢£¤\n` byte tail).
+ * - **ASCII constants** : `ASCII` object grouping the byte values used
+ *   by the tokenizer / parsers / writers — `SP`, `HT`, `LF`, `CR`, `FF`,
+ *   `NUL`, `HASH`, `PERCENT`, `BACKSLASH`, `SLASH`, `LPAREN`, `RPAREN`,
+ *   `LANGLE`, `RANGLE`, `LBRACK`, `RBRACK`, `LBRACE`, `RBRACE`, `PLUS`,
+ *   `MINUS`, `DOT`, `ZERO`, `NINE`, `A_UP`, `F_UP`, `Z_UP`, `A_LO`,
+ *   `F_LO`, `Z_LO`.
+ * - **Character class predicates** (PDF 32000-2 §7.2) : `isWs`, `isEol`,
+ *   `isDigit`, `isHex`, `isDelim`, `isRegular`, `hexNibble`. Each is a
+ *   pure function over byte values.
+ * - **Hex tables** : `HEX_LO` — 128-entry lookup `byte → nibble value`
+ *   (`-1` for non-hex), used by `asciiHex` and serializer.
+ * - **UTF-8 / latin1 codec singletons** : `te` (`TextEncoder`),
+ *   `tdUtf8` (`TextDecoder('utf-8')`), `tdUtf8Lenient`
+ *   (`TextDecoder('utf-8', { fatal: false })`), `tdLatin1`
+ *   (`TextDecoder('latin1')`). Both `tdUtf8` and `tdUtf8Lenient` are
+ *   non-fatal (`fatal: false` is the `TextDecoder` default). Available to
+ *   `writer.js` and `serializer.js`.
+ * - **Codec helpers** : `encodeAscii(s)` / `decodeLatin1(bytes)` /
+ *   `decodeUtf8(bytes)` / `decodeUtf8Lenient(bytes)` — thin wrappers
+ *   over the singletons.
+ * - **Byte helpers** : `pad10(n)`, `hexLit(bytes)`, `bytesEqual(a, b, n)`,
+ *   `concatBytes(arrays)` — available to modules; `writer.js` and
+ *   `serializer.js` still carry their own copies.
+ *
+ * **Worker-safe** : every export is either a constant byte array, a
+ * pure function, or a singleton instantiated inside the factory body
+ * (so `factory.toString()` produces a self-contained closure).
+ *
+ * @module pdf/_shared
+ */
+
+export const pdfShared = {
+    name: 'pdfShared',
+    dependencies: [],
+
+    factory() {
+        // --- Magic bytes -----------------------------------------------
+        const HEADER_PREFIX  = new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2D]); // %PDF-
+        const EOF_MARKER     = new Uint8Array([0x25, 0x25, 0x45, 0x4F, 0x46]); // %%EOF
+        // Binary marker line emitted right after the version header so
+        // transports treat the file as binary (per PDF 32000-2 §7.5.2).
+        const BINARY_MARKER  = new Uint8Array([0x25, 0xE2, 0xE3, 0xCF, 0xD3, 0x0A]);
+
+        // --- ASCII byte constants --------------------------------------
+        const ASCII = Object.freeze({
+            NUL: 0x00, HT: 0x09, LF: 0x0A, FF: 0x0C, CR: 0x0D, SP: 0x20,
+            HASH: 0x23, PERCENT: 0x25, LPAREN: 0x28, RPAREN: 0x29,
+            PLUS: 0x2B, MINUS: 0x2D, DOT: 0x2E, SLASH: 0x2F,
+            ZERO: 0x30, NINE: 0x39,
+            LANGLE: 0x3C, RANGLE: 0x3E,
+            A_UP: 0x41, F_UP: 0x46, Z_UP: 0x5A,
+            LBRACK: 0x5B, BACKSLASH: 0x5C, RBRACK: 0x5D,
+            A_LO: 0x61, F_LO: 0x66, Z_LO: 0x7A,
+            LBRACE: 0x7B, RBRACE: 0x7D
+        });
+
+        // --- Character class predicates (PDF 32000-2 §7.2) -------------
+        function isWs(b) {
+            return b === 0x20 || b === 0x09 || b === 0x0A
+                || b === 0x0D || b === 0x0C || b === 0x00;
+        }
+        function isEol(b) { return b === 0x0A || b === 0x0D; }
+        function isDigit(b) { return b >= 0x30 && b <= 0x39; }
+        function isHex(b) {
+            return (b >= 0x30 && b <= 0x39)
+                || (b >= 0x41 && b <= 0x46)
+                || (b >= 0x61 && b <= 0x66);
+        }
+        function isDelim(b) {
+            return b === 0x28 || b === 0x29   // ( )
+                || b === 0x3C || b === 0x3E   // < >
+                || b === 0x5B || b === 0x5D   // [ ]
+                || b === 0x2F || b === 0x25   // / %
+                || b === 0x7B || b === 0x7D;  // { }
+        }
+        function isRegular(b) { return !isWs(b) && !isDelim(b); }
+
+        function hexNibble(b) {
+            if (b >= 0x30 && b <= 0x39) return b - 0x30;
+            if (b >= 0x41 && b <= 0x46) return b - 0x41 + 10;
+            if (b >= 0x61 && b <= 0x66) return b - 0x61 + 10;
+            return -1;
+        }
+
+        // --- Hex lookup table (byte → nibble value, -1 if non-hex) -----
+        // 128 entries, indexable by ASCII byte. Identical semantics to
+        // hexNibble() but O(1) without branches.
+        const HEX_LO = (function buildHexLo() {
+            const t = new Int8Array(128);
+            t.fill(-1);
+            for (let c = 0x30; c <= 0x39; c++) t[c] = c - 0x30;
+            for (let c = 0x41; c <= 0x46; c++) t[c] = c - 0x41 + 10;
+            for (let c = 0x61; c <= 0x66; c++) t[c] = c - 0x61 + 10;
+            return t;
+        })();
+
+        // --- UTF-8 / latin1 codec singletons ---------------------------
+        const te             = new TextEncoder();
+        const tdUtf8         = new TextDecoder('utf-8');
+        const tdUtf8Lenient  = new TextDecoder('utf-8', { fatal: false });
+        const tdLatin1       = new TextDecoder('latin1');
+
+        function encodeAscii(s)         { return te.encode(s); }
+        function decodeUtf8(bytes)      { return tdUtf8.decode(bytes); }
+        function decodeUtf8Lenient(b)   { return tdUtf8Lenient.decode(b); }
+        function decodeLatin1(bytes)    { return tdLatin1.decode(bytes); }
+
+        // --- Byte helpers ----------------------------------------------
+        function pad10(n) { return String(n).padStart(10, '0'); }
+
+        function hexLit(bytes) {
+            const H = '0123456789ABCDEF';
+            let s = '<';
+            for (let i = 0; i < bytes.length; i++) {
+                s += H[bytes[i] >> 4] + H[bytes[i] & 0xF];
+            }
+            return s + '>';
+        }
+
+        /**
+         * Constant-time-ish equality of two byte arrays.
+         *
+         * @param {Uint8Array} a
+         * @param {Uint8Array} b
+         * @param {number} [n] — optional prefix length to compare;
+         *        defaults to `min(a.length, b.length)` and requires both
+         *        arrays to be that length exactly.
+         */
+        function bytesEqual(a, b, n) {
+            if (!a || !b) return false;
+            if (n == null) {
+                if (a.length !== b.length) return false;
+                n = a.length;
+            } else {
+                if (a.length < n || b.length < n) return false;
+            }
+            let diff = 0;
+            for (let i = 0; i < n; i++) diff |= (a[i] ^ b[i]);
+            return diff === 0;
+        }
+
+        function concatBytes(arrays) {
+            let total = 0;
+            for (const a of arrays) total += a.length;
+            const out = new Uint8Array(total);
+            let o = 0;
+            for (const a of arrays) { out.set(a, o); o += a.length; }
+            return out;
+        }
+
+        return {
+            // magic
+            HEADER_PREFIX, EOF_MARKER, BINARY_MARKER,
+            // ASCII constants
+            ASCII,
+            // char classes
+            isWs, isEol, isDigit, isHex, isDelim, isRegular, hexNibble,
+            HEX_LO,
+            // codec singletons
+            te, tdUtf8, tdUtf8Lenient, tdLatin1,
+            encodeAscii, decodeUtf8, decodeUtf8Lenient, decodeLatin1,
+            // byte helpers
+            pad10, hexLit, bytesEqual, concatBytes
+        };
+    }
+};

package/src/action/action.js

@@ -0,0 +1,119 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Action orchestrator per ISO 32000-2:2020 §12.6.
+ *
+ * Dispatches on `/S` (action type) and delegates to a specialised typer
+ * when available, otherwise returns a generic `{ kind, raw, _extras }`
+ * record for action subtypes not (yet) covered by a dedicated module
+ * (Thread, Sound, Movie, Hide, SubmitForm, ResetForm, ImportData,
+ * SetOCGState, Rendition, Trans, GoTo3DView, GoToDp, JavaScript).
+ *
+ * The `/Next` entry (a single action dict or an array of them) is
+ * recursively typed, with cycle protection via a Set of seen dicts.
+ *
+ * Optional sub-typers are passed via the `typers` argument — this lets
+ * callers wire `typeGoTo`, `typeUri`, etc. without creating a hard
+ * import chain.
+ *
+ * @module pdf/action/action
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfAction = {
+    name: 'pdfAction',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const GENERIC_KINDS = new Set([
+            'GoTo', 'GoToR', 'GoToE', 'GoToDp', 'Launch', 'Thread', 'URI',
+            'Sound', 'Movie', 'Hide', 'Named', 'SubmitForm', 'ResetForm',
+            'ImportData', 'SetOCGState', 'Rendition', 'Trans', 'GoTo3DView',
+            'JavaScript', 'RichMediaExecute'
+        ]);
+
+        function typeAction(dict, typers, opts) {
+            const seen = new Set();
+            const maxDepth = (opts && opts.maxDepth) || 16;
+            return walk(dict, 0);
+
+            function walk(d, depth) {
+                if (depth > maxDepth) {
+                    throw new ParseError('pdf/action/max-depth',
+                        'action /Next chain too deep',
+                        { context: { depth, maxDepth } });
+                }
+                if (!isType(d, 'dict')) {
+                    throw new ParseError('pdf/action/not-dict',
+                        'action must be a dictionary',
+                        { context: { type: d && d.type } });
+                }
+                if (seen.has(d)) {
+                    throw new ParseError('pdf/action/cycle',
+                        'cycle detected in action /Next chain');
+                }
+                seen.add(d);
+
+                const e = d.entries;
+                if (e.Type && (e.Type.type !== 'name' || e.Type.value !== 'Action')) {
+                    throw new ParseError('pdf/action/bad-type',
+                        '/Type must be /Action when present',
+                        { context: { actual: e.Type.value } });
+                }
+                if (!e.S || e.S.type !== 'name') {
+                    throw new ParseError('pdf/action/missing-s',
+                        'action missing /S name',
+                        { context: { type: e.S && e.S.type } });
+                }
+                const kind = e.S.value;
+
+                let rec;
+                const t = typers && typers[kind];
+                if (typeof t === 'function') {
+                    rec = t(d);
+                    if (!rec.kind) rec.kind = kind;
+                } else {
+                    if (!GENERIC_KINDS.has(kind)) {
+                        rec = { kind, vendor: true, raw: d, _extras: collectExtras(e) };
+                    } else {
+                        rec = { kind, raw: d, _extras: collectExtras(e) };
+                    }
+                }
+
+                if (e.Next) {
+                    if (e.Next.type === 'dict') {
+                        rec.next = [walk(e.Next, depth + 1)];
+                    } else if (e.Next.type === 'array') {
+                        rec.next = e.Next.items.map((nx) => walk(nx, depth + 1));
+                    } else {
+                        throw new ParseError('pdf/action/bad-next',
+                            '/Next must be a dict or array of dicts',
+                            { context: { type: e.Next.type } });
+                    }
+                }
+                return rec;
+            }
+        }
+
+        function collectExtras(entries) {
+            const out = {};
+            for (const k of Object.keys(entries)) {
+                if (k !== 'Type' && k !== 'S' && k !== 'Next') out[k] = entries[k];
+            }
+            return out;
+        }
+
+        return { typeAction };
+    }
+};

package/src/action/goTo.js

@@ -0,0 +1,89 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview GoTo / GoToR / GoToE actions per ISO 32000-2:2020
+ * §12.6.4.2, §12.6.4.3, §12.6.4.4.
+ *
+ * GoTo  — navigate to a destination in the current document.
+ * GoToR — navigate to a destination in a remote document (`/F` + `/D`).
+ * GoToE — navigate to a destination in an embedded document.
+ *
+ * These typers read the raw entries; resolution of `/F` (file
+ * specification) and `/D` (destination) is left to the caller via
+ * dedicated modules (`fileSpec`, `destination`).
+ *
+ * @module pdf/action/goTo
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfActionGoTo = {
+    name: 'pdfActionGoTo',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        function expectDict(d, kind) {
+            if (!isType(d, 'dict')) {
+                throw new ParseError('pdf/action/' + kind.toLowerCase() + '/not-dict',
+                    kind + ' action must be a dictionary',
+                    { context: { type: d && d.type } });
+            }
+        }
+
+        function typeGoTo(dict) {
+            expectDict(dict, 'GoTo');
+            const e = dict.entries;
+            if (!e.D) {
+                throw new ParseError('pdf/action/goto/missing-d',
+                    'GoTo action is missing /D');
+            }
+            return { kind: 'GoTo', dest: e.D, raw: dict };
+        }
+
+        function typeGoToR(dict) {
+            expectDict(dict, 'GoToR');
+            const e = dict.entries;
+            if (!e.F) {
+                throw new ParseError('pdf/action/gotor/missing-f',
+                    'GoToR action is missing /F');
+            }
+            if (!e.D) {
+                throw new ParseError('pdf/action/gotor/missing-d',
+                    'GoToR action is missing /D');
+            }
+            const out = { kind: 'GoToR', file: e.F, dest: e.D, raw: dict };
+            if (e.NewWindow && e.NewWindow.type === 'bool') {
+                out.newWindow = e.NewWindow.value;
+            }
+            return out;
+        }
+
+        function typeGoToE(dict) {
+            expectDict(dict, 'GoToE');
+            const e = dict.entries;
+            if (!e.D) {
+                throw new ParseError('pdf/action/gotoe/missing-d',
+                    'GoToE action is missing /D');
+            }
+            const out = { kind: 'GoToE', dest: e.D, raw: dict };
+            if (e.F) out.file = e.F;
+            if (e.T) out.target = e.T;
+            if (e.NewWindow && e.NewWindow.type === 'bool') {
+                out.newWindow = e.NewWindow.value;
+            }
+            return out;
+        }
+
+        return { typeGoTo, typeGoToR, typeGoToE };
+    }
+};

package/src/action/launch.js

@@ -0,0 +1,61 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Launch action per ISO 32000-2:2020 §12.6.4.6.
+ *
+ * `/S /Launch` actions request the PDF viewer to run an external
+ * application or open a file. Executing such an action is a known
+ * security risk; this typer **never executes anything** — it surfaces
+ * the entries plus a `securityWarning` flag so the host application can
+ * decide what to do (typically: ignore, or prompt the user).
+ *
+ * @module pdf/action/launch
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfActionLaunch = {
+    name: 'pdfActionLaunch',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        function typeLaunch(dict) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/action/launch/not-dict',
+                    'Launch action must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const e = dict.entries;
+            const out = {
+                kind: 'Launch',
+                sandboxed: true,
+                securityWarning: 'launch actions are not executed by @awacloud/pdf',
+                raw: dict
+            };
+            if (e.F)   out.file = e.F;
+            if (e.Win && e.Win.type === 'dict') out.win = e.Win;
+            if (e.Mac && e.Mac.type === 'dict') out.mac = e.Mac;
+            if (e.Unix && e.Unix.type === 'dict') out.unix = e.Unix;
+            if (e.NewWindow && e.NewWindow.type === 'bool') {
+                out.newWindow = e.NewWindow.value;
+            }
+            if (!out.file && !out.win && !out.mac && !out.unix) {
+                throw new ParseError('pdf/action/launch/empty',
+                    'Launch action has no /F, /Win, /Mac, or /Unix target');
+            }
+            return out;
+        }
+
+        return { typeLaunch };
+    }
+};

package/src/action/named.js

@@ -0,0 +1,54 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview Named action per ISO 32000-2:2020 §12.6.4.11.
+ *
+ * `/S /Named` actions carry a `/N` name. The standard predefined names
+ * are NextPage, PrevPage, FirstPage, LastPage; vendor-defined names are
+ * accepted but flagged via `standard: false`.
+ *
+ * @module pdf/action/named
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfActionNamed = {
+    name: 'pdfActionNamed',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const STANDARD = new Set(['NextPage', 'PrevPage', 'FirstPage', 'LastPage']);
+
+        function typeNamed(dict) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/action/named/not-dict',
+                    'Named action must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const e = dict.entries;
+            if (!e.N || e.N.type !== 'name') {
+                throw new ParseError('pdf/action/named/missing-n',
+                    'Named action missing /N name',
+                    { context: { type: e.N && e.N.type } });
+            }
+            return {
+                kind: 'Named',
+                name: e.N.value,
+                standard: STANDARD.has(e.N.value),
+                raw: dict
+            };
+        }
+
+        return { typeNamed };
+    }
+};

package/src/action/uri.js

@@ -0,0 +1,51 @@
+// Copyright (c) 2026 AwaCloud SAS
+// Author: Matthieu Bouilloux
+// SPDX-License-Identifier: AGPL-3.0-only
+// Dual-licensed; see the NOTICE file for licensing and any additional terms.
+
+/**
+ * @fileoverview URI action per ISO 32000-2:2020 §12.6.4.7.
+ *
+ * `/S /URI` actions navigate to a URI; `/IsMap` indicates that mouse
+ * coordinates should be appended for image-map style links. The URI
+ * value is preserved as a raw byte string — callers decide how to
+ * decode it (typically PDFDocEncoding or UTF-8).
+ *
+ * @module pdf/action/uri
+ */
+
+/**
+ * Module factory — worker-safe, self-contained.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfActionUri = {
+    name: 'pdfActionUri',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors) {
+        const { ParseError } = errors;
+        // Self-contained isType: tolerates `parser = {}` from tests.
+        function isType(node, kind) { return !!(node && node.type === kind); }
+
+        function typeUri(dict) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/action/uri/not-dict',
+                    'URI action must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const e = dict.entries;
+            if (!e.URI || e.URI.type !== 'string') {
+                throw new ParseError('pdf/action/uri/missing',
+                    'URI action missing /URI string',
+                    { context: { type: e.URI && e.URI.type } });
+            }
+            const out = { kind: 'URI', uri: e.URI.value, raw: dict };
+            if (e.IsMap && e.IsMap.type === 'bool') out.isMap = e.IsMap.value;
+            return out;
+        }
+
+        return { typeUri };
+    }
+};