@awacloud/pdf 0.0.0-stage → 1.0.0

package/src/extra/pdf-sandbox.js

@@ -0,0 +1,88 @@
+// 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 Opt-in: strict sandbox linter for active-content PDF
+ * features.
+ *
+ * @module pdf/extra/pdf-sandbox
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+
+export const pdfSandbox = {
+    name: 'pdfSandbox',
+    dependencies: ['pdfErrors'],
+    deps: [pdfErrors],
+    factory(errors) {
+        const { ContractError } = errors;
+
+        const ACTIVE_KINDS = {
+            Launch:       { severity: 'error',
+                            message: '/Launch action present — external execution '
+                                + 'requested by document' },
+            JavaScript:   { severity: 'error',
+                            message: '/JavaScript action present — script '
+                                + 'execution requested by document' },
+            ImportData:   { severity: 'error',
+                            message: '/ImportData action present — file-system '
+                                + 'read requested by document' },
+            SubmitForm:   { severity: 'warning',
+                            message: '/SubmitForm action present — network '
+                                + 'submission requested by document' },
+            Rendition:    { severity: 'warning',
+                            message: '/Rendition action carries /JS payload' },
+            URI:          { severity: 'warning',
+                            message: '/URI action present — external navigation '
+                                + 'requested by document' }
+        };
+
+        function lintAction(rec) {
+            if (!rec || typeof rec !== 'object') return null;
+            if (rec.kind === 'Rendition' && !rec.sandboxed) return null;
+            const profile = ACTIVE_KINDS[rec.kind];
+            if (!profile) return null;
+            return {
+                kind: rec.kind,
+                code: 'pdf/sandbox/active-' + rec.kind.toLowerCase(),
+                severity: profile.severity,
+                message: profile.message,
+                context: { sandboxed: rec.sandboxed === true }
+            };
+        }
+
+        function lintActions(records) {
+            if (!records || typeof records[Symbol.iterator] !== 'function') {
+                throw new ContractError('pdf/sandbox/bad-input',
+                    'lintActions expects an iterable of action records');
+            }
+            const issues = [];
+            let hasErrors = false;
+            for (const rec of records) {
+                const issue = lintAction(rec);
+                if (issue) {
+                    issues.push(issue);
+                    if (issue.severity === 'error') hasErrors = true;
+                }
+            }
+            return {
+                sandboxed: true,
+                issues,
+                hasActiveContent: issues.length > 0,
+                hasErrors
+            };
+        }
+
+        return {
+            lintAction,
+            lintActions,
+            ACTIVE_KINDS
+        };
+    }
+};
+

package/src/extra/pdf-ua-tagged.js

@@ -0,0 +1,116 @@
+// 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 Opt-in: PDF/UA validation rules.
+ *
+ * Implements a static linter for PDF/UA-1 (ISO 14289-1:2014) and the
+ * draft PDF/UA-2 (ISO 14289-2). Required catalog structure:
+ *
+ *   - `/StructTreeRoot`              (required, tagged document)
+ *   - `/MarkInfo /Marked true`       (required)
+ *   - `/Lang`                        (required)
+ *   - `/ViewerPreferences /DisplayDocTitle true` (required)
+ *
+ * Structure-element checks (sampled):
+ *   - Figures must carry `/Alt` or `/ActualText`.
+ *   - Tables must include `TH`/`TD`/`TR`.
+ *   - The accessible-permission flag (bit 10) must be 1.
+ *
+ * @module pdf/extra/pdf-ua-tagged
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfUaTagged = {
+    name: 'pdfUaTagged',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const UA_STRUCTURE = Object.freeze({
+            required: Object.freeze(['Document', 'Part', 'Sect', 'Art', 'H', 'P', 'L', 'LI', 'Lbl', 'LBody',
+                'Table', 'TR', 'TH', 'TD', 'Figure']),
+            forbidden: Object.freeze(['Span']),
+            figure: Object.freeze(['Alt', 'ActualText']),
+            headings: Object.freeze(['H', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6'])
+        });
+
+        function validatePdfUa(typedDoc) {
+            if (!typedDoc || typeof typedDoc !== 'object') {
+                throw new ParseError('pdf/extra/pdfua/bad-doc',
+                    'validatePdfUa requires a typed document object',
+                    { context: { type: typeof typedDoc } });
+            }
+            const errors = [];
+            const warnings = [];
+            const cat = typedDoc.catalog && typedDoc.catalog.entries;
+            if (!cat) {
+                errors.push('catalog missing');
+                return { pass: false, errors, warnings };
+            }
+            if (!cat.StructTreeRoot) errors.push('catalog requires /StructTreeRoot');
+            if (!cat.Lang || !isType(cat.Lang, 'string')) {
+                errors.push('catalog requires /Lang string');
+            }
+            if (!cat.MarkInfo) {
+                errors.push('catalog requires /MarkInfo dictionary');
+            } else if (!isType(cat.MarkInfo, 'dict')) {
+                errors.push('/MarkInfo must be a dictionary');
+            } else {
+                const m = cat.MarkInfo.entries.Marked;
+                if (!isType(m, 'bool') || m.value !== true) {
+                    errors.push('/MarkInfo /Marked must be true');
+                }
+            }
+            if (cat.ViewerPreferences && isType(cat.ViewerPreferences, 'dict')) {
+                const ddt = cat.ViewerPreferences.entries.DisplayDocTitle;
+                if (!isType(ddt, 'bool') || ddt.value !== true) {
+                    warnings.push('/ViewerPreferences /DisplayDocTitle should be true');
+                }
+            } else {
+                warnings.push('catalog should have /ViewerPreferences');
+            }
+            if (typeof typedDoc.p === 'number') {
+                if ((typedDoc.p & (1 << 9)) === 0) {
+                    errors.push('permissions bit 10 (accessible) must be set');
+                }
+            }
+            return { pass: errors.length === 0, errors, warnings };
+        }
+
+        function validateUaStructElement(node) {
+            if (!node || typeof node !== 'object') {
+                throw new ParseError('pdf/extra/pdfua/struct/bad-node',
+                    'validateUaStructElement requires a node',
+                    { context: { type: typeof node } });
+            }
+            const errors = [];
+            const warnings = [];
+            if (node.s === 'Figure') {
+                if (!node.alt && !node.actualText) {
+                    errors.push('Figure requires /Alt or /ActualText');
+                }
+            }
+            if (UA_STRUCTURE.forbidden.includes(node.s)) {
+                warnings.push('avoid /' + node.s + ' as a top-level structure type');
+            }
+            return { pass: errors.length === 0, errors, warnings };
+        }
+
+        return {
+            validatePdfUa,
+            validateUaStructElement,
+            UA_STRUCTURE
+        };
+    }
+};
+

package/src/extra/pdf-x-prepress.js

@@ -0,0 +1,114 @@
+// 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 Opt-in: PDF/X conformance helpers.
+ *
+ * PDF/X (ISO 15930) defines a family of prepress-targeted profiles
+ * (PDF/X-1a, X-3, X-4, X-4p, X-5g, X-5n, X-5pg, X-6) with an
+ * `/OutputIntent` whose `/S` is `GTS_PDFX`. Required structural checks:
+ *
+ *   - `/TrimBox` (and optionally `/BleedBox`, `/ArtBox`) on every page.
+ *   - Output intent profile (Dest profile or registry identifier).
+ *   - Separation info dict (per page or document level) for X-4+.
+ *
+ * @module pdf/extra/pdf-x-prepress
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfXPrepress = {
+    name: 'pdfXPrepress',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const PDFX_PROFILES = Object.freeze({
+            'X-1a:2001': { iso: 'ISO 15930-1:2001', color: 'cmyk+spot', flavor: 'closed' },
+            'X-1a:2003': { iso: 'ISO 15930-4:2003', color: 'cmyk+spot', flavor: 'closed' },
+            'X-3:2002':  { iso: 'ISO 15930-3:2002', color: 'any',       flavor: 'closed' },
+            'X-3:2003':  { iso: 'ISO 15930-6:2003', color: 'any',       flavor: 'closed' },
+            'X-4':       { iso: 'ISO 15930-7:2010', color: 'any',       flavor: 'transparency' },
+            'X-4p':      { iso: 'ISO 15930-7:2010', color: 'any',       flavor: 'external-profile' },
+            'X-5g':      { iso: 'ISO 15930-8:2010', color: 'any',       flavor: 'external-graphics' },
+            'X-5n':      { iso: 'ISO 15930-8:2010', color: 'n-channel', flavor: 'external-profile' },
+            'X-5pg':     { iso: 'ISO 15930-8:2010', color: 'any',       flavor: 'external-both' },
+            'X-6':       { iso: 'ISO 15930-9:2020', color: 'any',       flavor: 'pdf-2.0' }
+        });
+
+        const COLOR_POLICY = Object.freeze({
+            None:     'no transformation',
+            Convert:  'convert to OutputIntent profile',
+            Tag:      'tag with profile only',
+            Embed:    'embed source profile'
+        });
+
+        function typePdfXOutputIntent(dict) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/extra/pdfx/not-dict',
+                    'OutputIntent must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const e = dict.entries;
+            const s = isType(e.S, 'name') ? e.S.value : null;
+            const ident = isType(e.OutputConditionIdentifier, 'string')
+                ? new TextDecoder('latin1').decode(e.OutputConditionIdentifier.value)
+                : null;
+            const profile = profileFromIdentifier(ident);
+            return {
+                isPdfX: s === 'GTS_PDFX',
+                subtype: s,
+                identifier: ident,
+                profile,
+                catalog: profile ? PDFX_PROFILES[profile] : null,
+                raw: dict
+            };
+        }
+
+        function profileFromIdentifier(s) {
+            if (!s) return null;
+            const m = s.match(/PDF\/(X-(?:1a:200[13]|3:200[23]|4p?|5(?:g|n|pg)|6))/i);
+            if (!m) return null;
+            const key = m[1].toUpperCase().replace('X-', 'X-');
+            for (const k of Object.keys(PDFX_PROFILES)) {
+                if (k.toLowerCase() === key.toLowerCase()) return k;
+            }
+            return null;
+        }
+
+        function lintPdfXPage(page) {
+            if (!page || !page.entries) {
+                throw new ParseError('pdf/extra/pdfx/lint/bad-page',
+                    'lintPdfXPage requires a typed page dict',
+                    { context: { type: typeof page } });
+            }
+            const errors = [];
+            const warnings = [];
+            const e = page.entries;
+            if (!e.TrimBox && !e.ArtBox) {
+                errors.push('page requires /TrimBox or /ArtBox');
+            }
+            if (e.TrimBox && e.ArtBox) {
+                errors.push('page must not have both /TrimBox and /ArtBox');
+            }
+            if (!e.BleedBox) warnings.push('page has no /BleedBox');
+            return { pass: errors.length === 0, errors, warnings };
+        }
+
+        return {
+            typePdfXOutputIntent,
+            lintPdfXPage,
+            PDFX_PROFILES,
+            COLOR_POLICY
+        };
+    }
+};
+

package/src/extra/redaction-iso32005.js

@@ -0,0 +1,136 @@
+// 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 Opt-in: typing of the ISO/TS 32005 apply-redaction audit
+ * record (read side). The TS text is not vendored; the entries below are what
+ * this module recognises. No content removal is performed.
+ *
+ * An audit record describes:
+ *   - the annotations that were applied,
+ *   - the overlay rendering hints (`/RD`, `/IC`, `/RO`),
+ *   - content-stream redact markers (`/Redact ... BMC ... EMC`) tracking
+ *     positions for visualization / forensic review.
+ *
+ * @module pdf/extra/redaction-iso32005
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfRedactionIso32005 = {
+    name: 'pdfRedactionIso32005',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const KNOWN = new Set([
+            'Type', 'AppliedAt', 'Tool', 'Annotations', 'RD', 'RO', 'IC',
+            'MarkedRegions'
+        ]);
+
+        const REDACT_MARKERS = Object.freeze({
+            begin: '/Redact BMC',
+            beginPropertyList: '/Redact BDC',
+            end:   'EMC',
+            notes: 'TS 32005 §6.3 — wraps content removed/overlaid by /RD.'
+        });
+
+        function typeRedactionRecord(dict) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/extra/redact32005/not-dict',
+                    'redaction record must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const e = dict.entries;
+            const out = {
+                appliedAt:   isType(e.AppliedAt, 'string') ? e.AppliedAt.value : null,
+                tool:        isType(e.Tool,      'string') ? e.Tool.value      : null,
+                annotations: toRefArray(e.Annotations),
+                rd:          toRect(e.RD),
+                ro:          isType(e.RO, 'ref') || isType(e.RO, 'stream') ? e.RO : null,
+                ic:          toNumArray(e.IC),
+                markedRegions: toMarkedRegions(e.MarkedRegions),
+                raw:         dict,
+                _extras:     {}
+            };
+            if (e.Annotations && e.Annotations.type !== 'array') {
+                throw new ParseError('pdf/extra/redact32005/bad-annotations',
+                    '/Annotations must be an array',
+                    { context: { type: e.Annotations.type } });
+            }
+            for (const k of Object.keys(e)) {
+                if (!KNOWN.has(k)) out._extras[k] = e[k];
+            }
+            return out;
+        }
+
+        function findRedactMarkers(bytes) {
+            if (!(bytes instanceof Uint8Array)) {
+                throw new ParseError('pdf/extra/redact32005/scan/bad-input',
+                    'findRedactMarkers requires a Uint8Array',
+                    { context: { type: typeof bytes } });
+            }
+            const text = new TextDecoder('latin1').decode(bytes);
+            const regions = [];
+            const re = /\/Redact\s+(BMC|BDC)/g;
+            let m;
+            while ((m = re.exec(text)) !== null) {
+                const begin = m.index;
+                const tail = text.indexOf('EMC', re.lastIndex);
+                regions.push({
+                    beginOffset: begin,
+                    endOffset:   tail < 0 ? null : tail + 3,
+                    kind:        m[1]
+                });
+                if (tail >= 0) re.lastIndex = tail + 3;
+            }
+            return { regions };
+        }
+
+        function toRect(v) {
+            if (!v || v.type !== 'array') return null;
+            const out = [];
+            for (const it of v.items) {
+                if (!it || (it.type !== 'int' && it.type !== 'real')) return null;
+                out.push(it.value);
+            }
+            return out;
+        }
+
+        function toNumArray(v) {
+            if (!v || v.type !== 'array') return null;
+            const out = [];
+            for (const it of v.items) {
+                if (!it || (it.type !== 'int' && it.type !== 'real')) return null;
+                out.push(it.value);
+            }
+            return out;
+        }
+
+        function toRefArray(v) {
+            if (!v || v.type !== 'array') return null;
+            return v.items.slice();
+        }
+
+        function toMarkedRegions(v) {
+            if (!v) return null;
+            if (v.type !== 'array') return null;
+            return v.items.slice();
+        }
+
+        return {
+            typeRedactionRecord,
+            findRedactMarkers,
+            REDACT_MARKERS
+        };
+    }
+};
+

package/src/extra/shading-typed.js

@@ -0,0 +1,222 @@
+// 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 Opt-in: typed Shading dictionaries (§8.7.4) and Function
+ * dictionaries (§7.10) per ISO 32000-2:2020.
+ *
+ * Shading types:
+ *   1 — Function-based
+ *   2 — Axial
+ *   3 — Radial
+ *   4 — Free-form Gouraud
+ *   5 — Lattice-form Gouraud
+ *   6 — Coons patch mesh
+ *   7 — Tensor-product patch mesh
+ *
+ * Function types: 0 (Sampled), 2 (Exponential), 3 (Stitching), 4 (PostScript).
+ *
+ * @module pdf/extra/shading-typed
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParserObj } from '../syntax/parser-obj.js';
+
+export const pdfShadingTyped = {
+    name: 'pdfShadingTyped',
+    dependencies: ['pdfErrors', 'pdfParserObj'],
+    deps: [pdfErrors, pdfParserObj],
+    factory(errors, parserObj) {
+        const { ParseError } = errors;
+        const { isType } = parserObj;
+
+        const NUM = (v) => v && (v.type === 'int' || v.type === 'real');
+
+        function typeShading(obj_) {
+            let dict;
+            if (isType(obj_, 'dict')) dict = obj_;
+            else if (isType(obj_, 'stream')) dict = obj_.dict;
+            else {
+                throw new ParseError('pdf/extra/shading/not-dict-or-stream',
+                    'Shading must be dict or stream',
+                    { context: { type: obj_ && obj_.type } });
+            }
+            const e = dict.entries;
+            if (!NUM(e.ShadingType)) {
+                throw new ParseError('pdf/extra/shading/missing-type',
+                    '/ShadingType is required and must be numeric',
+                    { context: { type: e.ShadingType && e.ShadingType.type } });
+            }
+            const st = e.ShadingType.value | 0;
+            if (st < 1 || st > 7) {
+                throw new ParseError('pdf/extra/shading/bad-type',
+                    'invalid /ShadingType (must be 1..7)',
+                    { context: { st } });
+            }
+            const base = {
+                shadingType:    st,
+                colorSpace:     e.ColorSpace || null,
+                background:     isType(e.Background, 'array') ? e.Background.items : null,
+                bbox:           isType(e.BBox, 'array') ? e.BBox.items.map(it => NUM(it) ? it.value : null) : null,
+                antiAlias:      isType(e.AntiAlias, 'bool') ? e.AntiAlias.value : false,
+                raw:            obj_,
+                _extras:        {}
+            };
+            let typed;
+            switch (st) {
+                case 1: typed = readFnBased(e); break;
+                case 2: typed = readAxial(e); break;
+                case 3: typed = readRadial(e); break;
+                case 4: typed = readFreeForm(e); break;
+                case 5: typed = readLattice(e); break;
+                case 6: typed = readCoons(e); break;
+                case 7: typed = readTensor(e); break;
+            }
+            Object.assign(base, typed);
+            const known = new Set(['ShadingType', 'ColorSpace', 'Background', 'BBox', 'AntiAlias',
+                'Domain', 'Matrix', 'Function', 'Coords', 'Extend',
+                'BitsPerCoordinate', 'BitsPerComponent', 'BitsPerFlag',
+                'Decode', 'VerticesPerRow']);
+            for (const k of Object.keys(e)) if (!known.has(k)) base._extras[k] = e[k];
+            return base;
+        }
+
+        function readFnBased(e) {
+            return {
+                domain:   isType(e.Domain, 'array') ? toNumArr(e.Domain) : [0, 1, 0, 1],
+                matrix:   isType(e.Matrix, 'array') ? toNumArr(e.Matrix) : [1, 0, 0, 1, 0, 0],
+                function: e.Function || null
+            };
+        }
+
+        function readAxial(e) {
+            requireArrLen(e.Coords, 4, 'Axial /Coords');
+            return {
+                coords:   toNumArr(e.Coords),
+                domain:   isType(e.Domain, 'array') ? toNumArr(e.Domain) : [0, 1],
+                function: e.Function || null,
+                extend:   extendArr(e.Extend)
+            };
+        }
+
+        function readRadial(e) {
+            requireArrLen(e.Coords, 6, 'Radial /Coords');
+            return {
+                coords:   toNumArr(e.Coords),
+                domain:   isType(e.Domain, 'array') ? toNumArr(e.Domain) : [0, 1],
+                function: e.Function || null,
+                extend:   extendArr(e.Extend)
+            };
+        }
+
+        function readFreeForm(e) { return meshCommon(e, true); }
+        function readLattice(e) {
+            const c = meshCommon(e, false);
+            if (!NUM(e.VerticesPerRow)) {
+                throw new ParseError('pdf/extra/shading/lattice-missing-vpr',
+                    'Lattice shading requires /VerticesPerRow');
+            }
+            c.verticesPerRow = e.VerticesPerRow.value | 0;
+            return c;
+        }
+        function readCoons(e)  { return meshCommon(e, true); }
+        function readTensor(e) { return meshCommon(e, true); }
+
+        function meshCommon(e, hasFlag) {
+            if (!NUM(e.BitsPerCoordinate) || !NUM(e.BitsPerComponent)) {
+                throw new ParseError('pdf/extra/shading/mesh-missing-bits',
+                    'mesh shading requires /BitsPerCoordinate and /BitsPerComponent');
+            }
+            if (!isType(e.Decode, 'array')) {
+                throw new ParseError('pdf/extra/shading/mesh-missing-decode',
+                    'mesh shading requires /Decode');
+            }
+            const out = {
+                bitsPerCoordinate: e.BitsPerCoordinate.value | 0,
+                bitsPerComponent:  e.BitsPerComponent.value | 0,
+                decode:            toNumArr(e.Decode),
+                function:          e.Function || null
+            };
+            if (hasFlag) {
+                if (!NUM(e.BitsPerFlag)) {
+                    throw new ParseError('pdf/extra/shading/mesh-missing-flag',
+                        'this mesh shading requires /BitsPerFlag');
+                }
+                out.bitsPerFlag = e.BitsPerFlag.value | 0;
+            }
+            return out;
+        }
+
+        function extendArr(v) {
+            if (!isType(v, 'array') || v.items.length !== 2) return [false, false];
+            return [
+                isType(v.items[0], 'bool') ? v.items[0].value : false,
+                isType(v.items[1], 'bool') ? v.items[1].value : false
+            ];
+        }
+
+        function toNumArr(v) {
+            if (!isType(v, 'array')) return null;
+            const out = [];
+            for (const it of v.items) {
+                if (!NUM(it)) return null;
+                out.push(it.value);
+            }
+            return out;
+        }
+
+        function requireArrLen(v, len, what) {
+            if (!isType(v, 'array') || v.items.length !== len) {
+                throw new ParseError('pdf/extra/shading/bad-coords',
+                    `${what} must be an array of ${len} numbers`,
+                    { context: { actualLen: v && v.items && v.items.length } });
+            }
+        }
+
+        function typeFunction(obj_) {
+            let dict;
+            if (isType(obj_, 'dict')) dict = obj_;
+            else if (isType(obj_, 'stream')) dict = obj_.dict;
+            else {
+                throw new ParseError('pdf/extra/function/not-dict-or-stream',
+                    'Function must be dict or stream',
+                    { context: { type: obj_ && obj_.type } });
+            }
+            const e = dict.entries;
+            if (!NUM(e.FunctionType)) {
+                throw new ParseError('pdf/extra/function/missing-type',
+                    '/FunctionType is required');
+            }
+            const ft = e.FunctionType.value | 0;
+            if (![0, 2, 3, 4].includes(ft)) {
+                throw new ParseError('pdf/extra/function/bad-type',
+                    '/FunctionType must be 0, 2, 3, or 4',
+                    { context: { ft } });
+            }
+            return {
+                functionType: ft,
+                domain:       toNumArr(e.Domain),
+                range:        toNumArr(e.Range),
+                c0:           toNumArr(e.C0),
+                c1:           toNumArr(e.C1),
+                n:            NUM(e.N) ? e.N.value : null,
+                functions:    isType(e.Functions, 'array') ? e.Functions.items : null,
+                bounds:       toNumArr(e.Bounds),
+                encode:       toNumArr(e.Encode),
+                size:         toNumArr(e.Size),
+                bitsPerSample: NUM(e.BitsPerSample) ? (e.BitsPerSample.value | 0) : null,
+                order:        NUM(e.Order) ? (e.Order.value | 0) : null,
+                decode:       toNumArr(e.Decode),
+                raw:          obj_
+            };
+        }
+
+        return { typeShading, typeFunction };
+    }
+};
+