@awacloud/pdf 0.0.0-stage → 1.0.0

package/src/syntax/filters/dispatch.js

@@ -0,0 +1,176 @@
+// 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 Filter dispatch — applies a PDF filter chain
+ * (`/Filter` + `/DecodeParms`) on raw stream bytes per ISO 32000-2:2020
+ * §7.4.
+ *
+ * The dispatch map ships Flate/AHx/A85/RL (+ DCT/JPX/Crypt passthrough);
+ * LZW, CCITTFax and JBIG2 are not in the map; their implementations live on
+ * extras and are wired with `register(name, impl)` — no extra registers itself.
+ *
+ * @module pdf/syntax/filters/dispatch
+ */
+
+/**
+ * Module factory — collects all registered decoders into one map.
+ * Worker-safe: factory body is self-contained.
+ */
+import { pdfErrors } from '../../errors.js';
+import { pdfFlate } from './flate.js';
+import { pdfAsciiHex } from './asciiHex.js';
+import { pdfAscii85 } from './ascii85.js';
+import { pdfRunLength } from './runLength.js';
+
+export const pdfFilterDispatch = {
+    name: 'pdfFilterDispatch',
+    dependencies: ['pdfErrors', 'pdfFlate', 'pdfAsciiHex', 'pdfAscii85', 'pdfRunLength'],
+    deps: [pdfErrors, pdfFlate, pdfAsciiHex, pdfAscii85, pdfRunLength],
+    factory(errors, flate, asciiHex, ascii85, runLength) {
+        const { ParseError } = errors;
+        function isType(node, kind) { return !!(node && node.type === kind); }
+
+        const ABBREV = {
+            Fl: 'FlateDecode',
+            AHx: 'ASCIIHexDecode',
+            A85: 'ASCII85Decode',
+            RL: 'RunLengthDecode',
+            LZW: 'LZWDecode',
+            DCT: 'DCTDecode',
+            JPX: 'JPXDecode',
+            CCF: 'CCITTFaxDecode'
+        };
+        function resolveAbbrev(name) { return ABBREV[name] || name; }
+        function passthrough() {
+            return {
+                decode(bytes) { return bytes; },
+                encode(bytes) { return bytes; }
+            };
+        }
+
+        function normalizeFilterList(filterEntry) {
+            if (!filterEntry) return [];
+            if (filterEntry.type === 'name') {
+                return [resolveAbbrev(filterEntry.value)];
+            }
+            if (filterEntry.type === 'array') {
+                const out = [];
+                for (const it of filterEntry.items) {
+                    if (it.type !== 'name') {
+                        throw new ParseError('pdf/filter/non-name',
+                            '/Filter array entries must be names',
+                            { context: { kind: it.type } });
+                    }
+                    out.push(resolveAbbrev(it.value));
+                }
+                return out;
+            }
+            throw new ParseError('pdf/filter/bad-type',
+                '/Filter must be a name or array of names',
+                { context: { type: filterEntry.type } });
+        }
+
+        function applyDecodeChain(bytes, filters, params, decoders) {
+            let cur = bytes;
+            for (let i = 0; i < filters.length; i++) {
+                const name = filters[i];
+                const p    = params ? (params[i] || null) : null;
+                const dec  = decoders[name];
+                if (!dec) {
+                    throw new ParseError('pdf/filter/unsupported',
+                        `filter "${name}" not registered`,
+                        { context: { name, available: Object.keys(decoders) } });
+                }
+                cur = dec.decode(cur, p);
+            }
+            return cur;
+        }
+
+        function applyEncodeChain(bytes, filters, params, decoders) {
+            let cur = bytes;
+            for (let i = 0; i < filters.length; i++) {
+                const name = filters[i];
+                const p    = params ? (params[i] || null) : null;
+                const enc  = decoders[name];
+                if (!enc || typeof enc.encode !== 'function') {
+                    throw new ParseError('pdf/filter/no-encoder',
+                        `filter "${name}" has no encoder`,
+                        { context: { name } });
+                }
+                cur = enc.encode(cur, p);
+            }
+            return cur;
+        }
+
+        // Marshal a typed dict node ({type:'dict', entries:{K: {type,value}}})
+        // to a plain key -> value object, per ISO 32000-2:2020 §7.4 — the
+        // decoders (e.g. pdfFlate's predictor) expect plain values, not
+        // typed AST nodes (a typed node read as plain silently no-ops the
+        // predictor).
+        function plainParams(dictNode) {
+            const entries = dictNode.entries || {};
+            const out = {};
+            for (const key of Object.keys(entries)) {
+                const v = entries[key];
+                out[key] = v ? v.value : undefined;
+            }
+            return out;
+        }
+
+        function decodeParmsList(entry, count) {
+            if (!entry) return null;
+            if (entry.type === 'null') return null;
+            if (entry.type === 'dict') {
+                const arr = new Array(count).fill(null);
+                if (count > 0) arr[0] = plainParams(entry);
+                return arr;
+            }
+            if (entry.type === 'array') {
+                return entry.items.map(it => (it.type === 'dict' ? plainParams(it) : null));
+            }
+            throw new ParseError('pdf/filter/bad-decodeparms',
+                '/DecodeParms must be a dict, array, or null',
+                { context: { type: entry.type } });
+        }
+
+        function decodeStream(streamObj, decoders) {
+            if (!isType(streamObj, 'stream')) {
+                throw new ParseError('pdf/filter/not-stream',
+                    'decodeStream expects a stream object');
+            }
+            const dict = streamObj.dict;
+            const filters = normalizeFilterList(dict.entries.Filter);
+            const params  = decodeParmsList(dict.entries.DecodeParms, filters.length);
+            return applyDecodeChain(streamObj.raw, filters, params, decoders);
+        }
+
+        const decoders = {
+            FlateDecode:     flate,
+            ASCIIHexDecode:  asciiHex,
+            ASCII85Decode:   ascii85,
+            RunLengthDecode: runLength,
+            DCTDecode:       passthrough(),
+            JPXDecode:       passthrough(),
+            Crypt:           passthrough()
+        };
+        function decode(streamObj) { return decodeStream(streamObj, decoders); }
+        function decodeChain(bytes, filters, params) {
+            return applyDecodeChain(bytes, filters, params, decoders);
+        }
+        function encodeChain(bytes, filters, params) {
+            return applyEncodeChain(bytes, filters, params, decoders);
+        }
+        function register(name, impl) { decoders[name] = impl; }
+        function names() { return Object.keys(decoders); }
+        return {
+            decode, decodeChain, encodeChain, register, names, decoders,
+            normalizeFilterList,
+            applyDecodeChain,
+            applyEncodeChain,
+            decodeStream
+        };
+    }
+};

package/src/syntax/filters/flate.js

@@ -0,0 +1,316 @@
+// 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 FlateDecode filter wrapper.
+ *
+ * PDF FlateDecode (ISO 32000-2:2020 §7.4.4) uses zlib framing (RFC 1950).
+ * `@awacloud/fw/io/compress/zlib` produces and consumes this format.
+ *
+ * Supports the optional `Predictor` DecodeParms:
+ *   - 1                          : None (default)
+ *   - 2                          : TIFF Predictor 2
+ *   - 10, 11, 12, 13, 14         : PNG None/Sub/Up/Average/Paeth (per row)
+ *   - 15                         : PNG optimum (encoder picks per row;
+ *                                  decoder reads tag byte regardless)
+ *
+ * @module pdf/syntax/filters/flate
+ */
+
+/**
+ * Module factory — worker-safe, self-contained.
+ *
+ * `fwZlib` is injected via the runtime dependency resolution.
+ */
+import { pdfErrors } from '../../errors.js';
+import { zlib } from '@awacloud/fw/io/compress/zlib.js';
+
+export const pdfFlate = {
+    name: 'pdfFlate',
+    dependencies: ['pdfErrors', 'zlib'],
+    deps: [pdfErrors, zlib],
+    factory(errors, fwZlib) {
+        const { ParseError } = errors;
+        if (!fwZlib || typeof fwZlib.unzlibSync !== 'function'
+                    || typeof fwZlib.zlibSync   !== 'function') {
+            throw new ParseError('pdf/flate/missing-fw',
+                'pdfFlate requires the @awacloud/fw zlib module',
+                { context: { keys: fwZlib && Object.keys(fwZlib) } });
+        }
+
+        function paeth(a, b, c) {
+            const p = a + b - c;
+            const pa = Math.abs(p - a);
+            const pb = Math.abs(p - b);
+            const pc = Math.abs(p - c);
+            if (pa <= pb && pa <= pc) return a;
+            if (pb <= pc) return b;
+            return c;
+        }
+
+        function predictorParams(params) {
+            const predictor = (params && params.predictor != null)
+                ? params.predictor | 0 : ((params && params.Predictor != null)
+                    ? params.Predictor | 0 : 1);
+            const columns = (params && params.columns != null)
+                ? params.columns | 0 : ((params && params.Columns != null)
+                    ? params.Columns | 0 : 1);
+            const colors = (params && params.colors != null)
+                ? params.colors | 0 : ((params && params.Colors != null)
+                    ? params.Colors | 0 : 1);
+            const bpc = (params && params.bitsPerComponent != null)
+                ? params.bitsPerComponent | 0
+                : ((params && params.BitsPerComponent != null)
+                    ? params.BitsPerComponent | 0 : 8);
+            if (predictor !== 1 && predictor !== 2
+                && (predictor < 10 || predictor > 15)) {
+                throw new ParseError('pdf/flate/bad-predictor',
+                    'unsupported Predictor value',
+                    { context: { predictor } });
+            }
+            if (columns <= 0 || colors <= 0 || bpc <= 0) {
+                throw new ParseError('pdf/flate/bad-predictor-params',
+                    'Columns, Colors and BitsPerComponent must be > 0',
+                    { context: { columns, colors, bpc } });
+            }
+            // Stride/row size in bytes — we support byte-aligned configs
+            // (bpc multiple of 8) for the predictor codec. Sub-byte
+            // configurations decode the raw bytes per row but apply
+            // byte-wise PNG filters (TIFF Predictor 2 requires bpc=8).
+            const bitsPerPixel = colors * bpc;
+            const bytesPerPixel = Math.max(1, (bitsPerPixel + 7) >> 3);
+            const rowBytes = ((columns * bitsPerPixel) + 7) >> 3;
+            return { predictor, columns, colors, bpc, bytesPerPixel, rowBytes };
+        }
+
+        function pngUnfilterRow(filter, row, prevRow, bpp) {
+            const out = new Uint8Array(row.length);
+            for (let i = 0; i < row.length; i++) {
+                const left = i >= bpp ? out[i - bpp] : 0;
+                const up = prevRow ? prevRow[i] : 0;
+                const upLeft = (prevRow && i >= bpp) ? prevRow[i - bpp] : 0;
+                let v = row[i];
+                switch (filter) {
+                    case 0: break;                                  // None
+                    case 1: v = (v + left) & 0xFF; break;           // Sub
+                    case 2: v = (v + up) & 0xFF; break;             // Up
+                    case 3: v = (v + ((left + up) >> 1)) & 0xFF; break; // Avg
+                    case 4: v = (v + paeth(left, up, upLeft)) & 0xFF; break;
+                    default:
+                        throw new ParseError('pdf/flate/bad-png-filter',
+                            'unknown PNG filter tag',
+                            { context: { tag: filter } });
+                }
+                out[i] = v;
+            }
+            return out;
+        }
+
+        function pngFilterRow(filter, row, prevRow, bpp) {
+            const out = new Uint8Array(row.length);
+            for (let i = 0; i < row.length; i++) {
+                const left = i >= bpp ? row[i - bpp] : 0;
+                const up = prevRow ? prevRow[i] : 0;
+                const upLeft = (prevRow && i >= bpp) ? prevRow[i - bpp] : 0;
+                const v = row[i];
+                switch (filter) {
+                    case 0: out[i] = v; break;
+                    case 1: out[i] = (v - left) & 0xFF; break;
+                    case 2: out[i] = (v - up) & 0xFF; break;
+                    case 3: out[i] = (v - ((left + up) >> 1)) & 0xFF; break;
+                    case 4: out[i] = (v - paeth(left, up, upLeft)) & 0xFF; break;
+                    default:
+                        throw new ParseError('pdf/flate/bad-png-filter',
+                            'unknown PNG filter tag',
+                            { context: { tag: filter } });
+                }
+            }
+            return out;
+        }
+
+        function tiff2Decode(bytes, p) {
+            // TIFF Predictor 2: each sample = previous-sample-in-row + cur.
+            // Operates per row, per component, byte-aligned (bpc=8).
+            if (p.bpc !== 8) {
+                throw new ParseError('pdf/flate/tiff-bpc-unsupported',
+                    'TIFF Predictor 2 requires BitsPerComponent=8',
+                    { context: { bpc: p.bpc } });
+            }
+            const out = new Uint8Array(bytes.length);
+            const stride = p.colors;
+            const rowBytes = p.rowBytes;
+            const rows = (bytes.length / rowBytes) | 0;
+            for (let r = 0; r < rows; r++) {
+                const base = r * rowBytes;
+                for (let i = 0; i < rowBytes; i++) {
+                    const left = i >= stride ? out[base + i - stride] : 0;
+                    out[base + i] = (bytes[base + i] + left) & 0xFF;
+                }
+            }
+            return out;
+        }
+
+        function tiff2Encode(bytes, p) {
+            if (p.bpc !== 8) {
+                throw new ParseError('pdf/flate/tiff-bpc-unsupported',
+                    'TIFF Predictor 2 requires BitsPerComponent=8',
+                    { context: { bpc: p.bpc } });
+            }
+            const out = new Uint8Array(bytes.length);
+            const stride = p.colors;
+            const rowBytes = p.rowBytes;
+            const rows = (bytes.length / rowBytes) | 0;
+            for (let r = 0; r < rows; r++) {
+                const base = r * rowBytes;
+                for (let i = 0; i < rowBytes; i++) {
+                    const left = i >= stride ? bytes[base + i - stride] : 0;
+                    out[base + i] = (bytes[base + i] - left) & 0xFF;
+                }
+            }
+            return out;
+        }
+
+        function pngDecode(bytes, p) {
+            const rowBytes = p.rowBytes;
+            const stride = rowBytes + 1; // +1 for filter tag
+            if (bytes.length % stride !== 0) {
+                throw new ParseError('pdf/flate/png-row-mismatch',
+                    'predicted stream length is not a multiple of (rowBytes+1)',
+                    { context: { length: bytes.length, stride } });
+            }
+            const rows = bytes.length / stride;
+            const out = new Uint8Array(rows * rowBytes);
+            let prev = null;
+            for (let r = 0; r < rows; r++) {
+                const tag = bytes[r * stride];
+                const row = bytes.subarray(r * stride + 1, r * stride + stride);
+                const unfiltered = pngUnfilterRow(tag, row, prev, p.bytesPerPixel);
+                out.set(unfiltered, r * rowBytes);
+                prev = unfiltered;
+            }
+            return out;
+        }
+
+        function pngEncode(bytes, p) {
+            // For predictors 10..14, force the single filter type
+            // (Predictor - 10). For Predictor 15 (optimum), use Up for
+            // rows after the first, None for the first — a simple and
+            // deterministic heuristic; downstream decoders read the tag.
+            const rowBytes = p.rowBytes;
+            if (bytes.length % rowBytes !== 0) {
+                throw new ParseError('pdf/flate/png-row-mismatch',
+                    'input length is not a multiple of rowBytes',
+                    { context: { length: bytes.length, rowBytes } });
+            }
+            const rows = bytes.length / rowBytes;
+            const outStride = rowBytes + 1;
+            const out = new Uint8Array(rows * outStride);
+            const forced = p.predictor === 15 ? -1 : (p.predictor - 10);
+            let prev = null;
+            for (let r = 0; r < rows; r++) {
+                const row = bytes.subarray(r * rowBytes, (r + 1) * rowBytes);
+                let tag = forced;
+                if (tag < 0) tag = r === 0 ? 0 : 2; // optimum heuristic
+                const filtered = pngFilterRow(tag, row, prev, p.bytesPerPixel);
+                out[r * outStride] = tag;
+                out.set(filtered, r * outStride + 1);
+                prev = row;
+            }
+            return out;
+        }
+
+        // fw's inflate reports "input exhausted before the final block" as
+        // error code 0 ('unexpected EOF'); every other failure has its own code.
+        function endedBeforeFinalBlock(e) {
+            return !!e && e.code === 0;
+        }
+
+        // Inflate `bytes` through the streaming decoder WITHOUT signalling the
+        // end of input, and return everything it emitted (possibly empty).
+        function inflatePrefix(bytes) {
+            const chunks = [];
+            let total = 0;
+            const stream = new fwZlib.UnzlibStream((chunk) => {
+                chunks.push(chunk);
+                total += chunk.length;
+            });
+            stream.push(bytes, false);
+            const out = new Uint8Array(total);
+            let off = 0;
+            for (const chunk of chunks) { out.set(chunk, off); off += chunk.length; }
+            return out;
+        }
+
+        function markTruncated(out) {
+            Object.defineProperty(out, 'truncated', { value: true, enumerable: false });
+            return out;
+        }
+
+        function decode(bytes, params) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/flate/bad-input',
+                    'FlateDecode expects Uint8Array');
+            }
+            let raw;
+            let truncated = false;
+            try {
+                raw = fwZlib.unzlibSync(bytes);
+            } catch (e) {
+                const inflateFailed = () => new ParseError('pdf/flate/inflate-failed',
+                    'inflate failed: ' + (e && e.message),
+                    { context: { length: bytes.length }, cause: e });
+                if (!endedBeforeFinalBlock(e)
+                        || typeof fwZlib.UnzlibStream !== 'function') {
+                    throw inflateFailed();
+                }
+                // A stream that ends before its final deflate block yields the
+                // bytes decoded so far, flagged `truncated` (viewers do the same).
+                let prefix;
+                try { prefix = inflatePrefix(bytes); } catch { throw inflateFailed(); }
+                if (prefix.length === 0) throw inflateFailed();
+                raw = prefix;
+                truncated = true;
+            }
+            const done = (out) => (truncated ? markTruncated(out) : out);
+            if (!params) return done(raw);
+            const hasPredictor = (params.predictor != null && params.predictor !== 1)
+                || (params.Predictor != null && params.Predictor !== 1);
+            if (!hasPredictor) return done(raw);
+            const p = predictorParams(params);
+            if (p.predictor === 1) return done(raw);
+            // A truncated prefix keeps only its whole predicted rows; a complete
+            // stream keeps the strict row check.
+            const stride = p.predictor === 2 ? p.rowBytes : p.rowBytes + 1;
+            if (truncated) raw = raw.subarray(0, raw.length - (raw.length % stride));
+            if (p.predictor === 2) return done(tiff2Decode(raw, p));
+            return done(pngDecode(raw, p));
+        }
+
+        function encode(bytes, params) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/flate/bad-input',
+                    'FlateEncode expects Uint8Array');
+            }
+            let payload = bytes;
+            if (params) {
+                const hasPredictor = (params.predictor != null && params.predictor !== 1)
+                    || (params.Predictor != null && params.Predictor !== 1);
+                if (hasPredictor) {
+                    const p = predictorParams(params);
+                    if (p.predictor === 2) payload = tiff2Encode(bytes, p);
+                    else if (p.predictor >= 10) payload = pngEncode(bytes, p);
+                }
+            }
+            try {
+                return fwZlib.zlibSync(payload);
+            } catch (e) {
+                throw new ParseError('pdf/flate/deflate-failed',
+                    'deflate failed: ' + (e && e.message),
+                    { context: { length: payload.length }, cause: e });
+            }
+        }
+        return { decode, encode };
+    }
+};

package/src/syntax/filters/runLength.js

@@ -0,0 +1,96 @@
+// 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 RunLengthDecode filter per ISO 32000-2:2020 §7.4.5.
+ *
+ * Each control byte `n` is interpreted as:
+ * - `0..127` → copy the next `n + 1` bytes literally,
+ * - `128`    → end-of-data marker (stop decoding),
+ * - `129..255` → repeat the next byte `257 - n` times (2..128 times).
+ *
+ * @module pdf/syntax/filters/runLength
+ */
+
+/**
+ * Module factory — worker-safe.
+ */
+import { pdfErrors } from '../../errors.js';
+
+export const pdfRunLength = {
+    name: 'pdfRunLength',
+    dependencies: ['pdfErrors'],
+    deps: [pdfErrors],
+    factory(errors) {
+        const { ParseError } = errors;
+        function decode(bytes) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/runLength/bad-input',
+                    'RunLengthDecode expects Uint8Array');
+            }
+            const out = [];
+            let i = 0;
+            while (i < bytes.length) {
+                const n = bytes[i++];
+                if (n === 128) break;
+                if (n < 128) {
+                    const count = n + 1;
+                    if (i + count > bytes.length) {
+                        throw new ParseError('pdf/runLength/truncated-literal',
+                            'truncated literal run',
+                            { context: { offset: i - 1, want: count, have: bytes.length - i } });
+                    }
+                    for (let k = 0; k < count; k++) out.push(bytes[i + k]);
+                    i += count;
+                } else {
+                    if (i >= bytes.length) {
+                        throw new ParseError('pdf/runLength/truncated-repeat',
+                            'truncated repeat run',
+                            { context: { offset: i - 1 } });
+                    }
+                    const v = bytes[i++];
+                    const count = 257 - n;
+                    for (let k = 0; k < count; k++) out.push(v);
+                }
+            }
+            return Uint8Array.from(out);
+        }
+
+        function encode(bytes) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/runLength/bad-input',
+                    'RunLengthEncode expects Uint8Array');
+            }
+            const out = [];
+            let i = 0;
+            while (i < bytes.length) {
+                const v = bytes[i];
+                let runLen = 1;
+                while (runLen < 128 && i + runLen < bytes.length && bytes[i + runLen] === v) {
+                    runLen++;
+                }
+                if (runLen >= 3) {
+                    out.push(257 - runLen, v);
+                    i += runLen;
+                    continue;
+                }
+                let litStart = i;
+                let litLen = 0;
+                while (litLen < 128 && i < bytes.length) {
+                    let look = 1;
+                    while (look < 3 && i + look < bytes.length && bytes[i + look] === bytes[i]) look++;
+                    if (look >= 3 && litLen > 0) break;
+                    i++; litLen++;
+                }
+                out.push(litLen - 1);
+                for (let k = 0; k < litLen; k++) out.push(bytes[litStart + k]);
+            }
+            out.push(128);
+            return Uint8Array.from(out);
+        }
+
+        return { decode, encode };
+    }
+};

package/src/syntax/objStream.js

@@ -0,0 +1,99 @@
+// 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 Object Stream parser per ISO 32000-2:2020 §7.5.7.
+ *
+ * @module pdf/syntax/objStream
+ */
+
+/**
+ * Module factory — worker-safe, self-contained.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParserObj } from './parser-obj.js';
+import { pdfTokenizer } from './tokenizer.js';
+import { pdfParser } from './parser.js';
+
+export const pdfObjStream = {
+    name: 'pdfObjStream',
+    dependencies: ['pdfErrors', 'pdfParserObj', 'pdfTokenizer', 'pdfParser'],
+    deps: [pdfErrors, pdfParserObj, pdfTokenizer, pdfParser],
+    factory(errors, parserObj, tokenizerMod, parserMod) {
+        const { ParseError } = errors;
+        const { isType } = parserObj;
+        const tokenize = tokenizerMod.tokenize;
+        const parseObject = parserMod.parseObject;
+
+        function readInt(entry, label) {
+            if (!entry || entry.type !== 'int') {
+                throw new ParseError('pdf/objstm/missing-int',
+                    `ObjStm dict missing required /${label}`,
+                    { context: { label, hasEntry: !!entry, type: entry && entry.type } });
+            }
+            return entry.value;
+        }
+
+        function parseObjectStream(decoded, dict) {
+            if (!(decoded instanceof Uint8Array)) {
+                throw new ParseError('pdf/objstm/bad-input',
+                    'parseObjectStream expects Uint8Array',
+                    { context: { typeof: typeof decoded } });
+            }
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/objstm/bad-dict',
+                    'ObjStm dict must be a typed dict');
+            }
+            const e = dict.entries;
+            if (e.Type && (e.Type.type !== 'name' || e.Type.value !== 'ObjStm')) {
+                throw new ParseError('pdf/objstm/wrong-type',
+                    '/Type must be /ObjStm', { context: { actual: e.Type.value } });
+            }
+            const N = readInt(e.N, 'N');
+            const First = readInt(e.First, 'First');
+            if (N < 0) {
+                throw new ParseError('pdf/objstm/bad-N',
+                    '/N must be non-negative', { context: { N } });
+            }
+            if (First < 0 || First > decoded.length) {
+                throw new ParseError('pdf/objstm/bad-First',
+                    '/First out of payload range',
+                    { context: { First, length: decoded.length } });
+            }
+
+            const header = tokenize(decoded, { start: 0, end: First });
+            const nums = new Array(N);
+            const offs = new Array(N);
+            for (let i = 0; i < N; i++) {
+                const tNum = header.next();
+                const tOff = header.next();
+                if (!tNum || tNum.kind !== 'int' || !tOff || tOff.kind !== 'int') {
+                    throw new ParseError('pdf/objstm/bad-pair',
+                        'ObjStm header expects N pairs of integers',
+                        { context: { index: i } });
+                }
+                nums[i] = tNum.value;
+                offs[i] = tOff.value;
+            }
+
+            const out = new Array(N);
+            for (let i = 0; i < N; i++) {
+                const start = First + offs[i];
+                const end = (i + 1 < N) ? (First + offs[i + 1]) : decoded.length;
+                if (start < First || end > decoded.length || start > end) {
+                    throw new ParseError('pdf/objstm/bad-offset',
+                        'ObjStm member offset out of range',
+                        { context: { index: i, start, end, length: decoded.length } });
+                }
+                const tok = tokenize(decoded, { start, end });
+                const value = parseObject(tok);
+                out[i] = { num: nums[i], gen: 0, value };
+            }
+            return out;
+        }
+
+        return { parseObjectStream };
+    }
+};