@awacloud/pdf 0.0.0-stage → 1.0.0

package/src/annot/annot.js

@@ -0,0 +1,212 @@
+// 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 Annotation orchestrator per ISO 32000-2:2020 §12.5.
+ *
+ * Dispatches an annotation dict (`/Type /Annot`) to a subtype-specific
+ * typer based on `/Subtype`. Also exports `typeBaseAnnot` which captures
+ * the entries common to every annotation (§12.5.2 Table 166).
+ *
+ * Common entries:
+ *   /Type /Subtype /Rect /Contents /P /NM /M /F /AP /AS /Border /C
+ *   /StructParent /OC /AF /CA /BS /BE
+ *
+ * Unknown subtypes return `{ kind, raw, _extras }` — preserve-unknowns.
+ *
+ * @module pdf/annot/annot
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+
+export const pdfAnnot = {
+    name: 'pdfAnnot',
+    dependencies: ['pdfErrors', 'pdfParser'],
+    deps: [pdfErrors, pdfParser],
+    factory(errors, parser) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+
+        const BASE_KEYS = new Set([
+            'Type', 'Subtype', 'Rect', 'Contents', 'P', 'NM', 'M', 'F', 'AP',
+            'AS', 'Border', 'C', 'StructParent', 'OC', 'AF', 'CA', 'BS', 'BE'
+        ]);
+
+        function typeBaseAnnot(dict) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/annot/not-dict',
+                    'annotation must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const e = dict.entries;
+            if (e.Type && (e.Type.type !== 'name' || e.Type.value !== 'Annot')) {
+                throw new ParseError('pdf/annot/bad-type',
+                    '/Type must be /Annot when present',
+                    { context: { actual: e.Type.value } });
+            }
+            const out = {
+                subtype:      isType(e.Subtype, 'name') ? e.Subtype.value : null,
+                rect:         toRect(e.Rect),
+                contents:     isType(e.Contents, 'string') ? e.Contents.value : null,
+                p:            e.P && e.P.type === 'ref'
+                    ? { num: e.P.num, gen: e.P.gen } : null,
+                nm:           isType(e.NM, 'string') ? e.NM.value : null,
+                m:            isType(e.M,  'string') ? e.M.value  : null,
+                f:            toInt(e.F, 0),
+                ap:           isType(e.AP, 'dict') ? e.AP : null,
+                as:           isType(e.AS, 'name') ? e.AS.value : null,
+                border:       toBorder(e.Border),
+                c:            toNumArray(e.C),
+                structParent: toInt(e.StructParent, null),
+                oc:           e.OC || null,
+                af:           e.AF || null,
+                ca:           toNum(e.CA, null),
+                bs:           isType(e.BS, 'dict') ? e.BS : null,
+                be:           isType(e.BE, 'dict') ? e.BE : null,
+                raw:          dict,
+                _extras:      {}
+            };
+            return out;
+        }
+
+        function captureExtras(target, dict, known) {
+            const e = dict.entries;
+            for (const k of Object.keys(e)) {
+                if (BASE_KEYS.has(k)) continue;
+                if (known && known.has(k)) continue;
+                target._extras[k] = e[k];
+            }
+        }
+
+        function typeAnnot(dict, typers) {
+            if (!isType(dict, 'dict')) {
+                throw new ParseError('pdf/annot/not-dict',
+                    'annotation must be a dictionary',
+                    { context: { type: dict && dict.type } });
+            }
+            const sub = dict.entries.Subtype;
+            if (!isType(sub, 'name')) {
+                throw new ParseError('pdf/annot/missing-subtype',
+                    '/Subtype is required and must be a name',
+                    { context: { kind: sub && sub.type } });
+            }
+            const name = sub.value;
+            const t = typers || {};
+            switch (name) {
+                case 'Text':           return tag('Text',       call(t.Text, dict));
+                case 'Link':           return tag('Link',       call(t.Link, dict));
+                case 'FreeText':       return tag('FreeText',   call(t.FreeText, dict));
+                case 'Line':           return tag('Line',       call(t.Shape, dict, 'Line'));
+                case 'Square':         return tag('Square',     call(t.Shape, dict, 'Square'));
+                case 'Circle':         return tag('Circle',     call(t.Shape, dict, 'Circle'));
+                case 'Polygon':        return tag('Polygon',    call(t.Shape, dict, 'Polygon'));
+                case 'PolyLine':       return tag('PolyLine',   call(t.Shape, dict, 'PolyLine'));
+                case 'Highlight':      return tag('Highlight',  call(t.Markup, dict, 'Highlight'));
+                case 'Underline':      return tag('Underline',  call(t.Markup, dict, 'Underline'));
+                case 'Squiggly':       return tag('Squiggly',   call(t.Markup, dict, 'Squiggly'));
+                case 'StrikeOut':      return tag('StrikeOut',  call(t.Markup, dict, 'StrikeOut'));
+                case 'Caret':          return tag('Caret',      call(t.Markup, dict, 'Caret'));
+                case 'Stamp':          return tag('Stamp',      call(t.Stamp, dict));
+                case 'Ink':            return tag('Ink',        call(t.Ink, dict));
+                case 'Popup':          return tag('Popup',      call(t.Popup, dict));
+                case 'FileAttachment': return tag('FileAttachment', call(t.FileAttachment, dict));
+                case 'Widget':         return tag('Widget',     call(t.Widget, dict));
+                case 'Redact':         return tag('Redact',     call(t.Redact, dict));
+                case 'Projection':     return tag('Projection', call(t.Projection, dict));
+                case 'Sound':
+                case 'Movie':
+                case 'Screen':
+                case 'PrinterMark':
+                case 'TrapNet':
+                case 'Watermark':
+                case '3D':
+                case 'RichMedia':
+                    return tag(name, fallback(dict));
+                default:
+                    return { kind: name, raw: dict, _extras: collectAll(dict) };
+            }
+        }
+
+        function call(fn, dict, arg) {
+            if (typeof fn !== 'function') {
+                // Fallback if a subtype-specific typer isn't wired.
+                return fallback(dict);
+            }
+            return arg !== undefined ? fn(dict, arg) : fn(dict);
+        }
+
+        function tag(kind, rec) { rec.kind = kind; return rec; }
+
+        function fallback(dict) {
+            const base = typeBaseAnnot(dict);
+            captureExtras(base, dict, null);
+            return base;
+        }
+
+        function collectAll(dict) {
+            const out = {};
+            const e = dict.entries;
+            for (const k of Object.keys(e)) out[k] = e[k];
+            return out;
+        }
+
+        function toRect(v) {
+            if (!v || v.type !== 'array' || v.items.length !== 4) return null;
+            const r = new Array(4);
+            for (let i = 0; i < 4; i++) {
+                const it = v.items[i];
+                if (!it || (it.type !== 'int' && it.type !== 'real')) return null;
+                r[i] = it.value;
+            }
+            return r;
+        }
+
+        function toBorder(v) {
+            if (!v || v.type !== 'array') return null;
+            const out = [];
+            for (const it of v.items) {
+                if (!it) return null;
+                if (it.type === 'int' || it.type === 'real') out.push(it.value);
+                else if (it.type === 'array') out.push(toNumArray(it));
+                else return null;
+            }
+            return out;
+        }
+
+        function toNumArray(v) {
+            if (!v || v.type !== 'array') return null;
+            const out = [];
+            for (const it of v.items) {
+                if (!it) return null;
+                if (it.type !== 'int' && it.type !== 'real') return null;
+                out.push(it.value);
+            }
+            return out;
+        }
+
+        function toInt(v, dflt) {
+            if (!v) return dflt;
+            if (v.type !== 'int' && v.type !== 'real') return dflt;
+            return v.value | 0;
+        }
+
+        function toNum(v, dflt) {
+            if (!v) return dflt;
+            if (v.type !== 'int' && v.type !== 'real') return dflt;
+            return v.value;
+        }
+
+        return {
+            BASE_KEYS,
+            typeBaseAnnot,
+            captureExtras,
+            typeAnnot
+        };
+    }
+};

package/src/annot/fileAttach.js

@@ -0,0 +1,55 @@
+// 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 FileAttachment annotation per ISO 32000-2:2020 §12.5.6.15.
+ *
+ * Subtype-specific entries:
+ *   /FS    dict|ref — file-specification (required)
+ *   /Name  name     — icon (PushPin, Graph, Paperclip, Tag)
+ *
+ * @module pdf/annot/fileAttach
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+import { pdfAnnot } from './annot.js';
+
+export const pdfFileAttachAnnot = {
+    name: 'pdfFileAttachAnnot',
+    dependencies: ['pdfErrors', 'pdfParser', 'pdfAnnot'],
+    deps: [pdfErrors, pdfParser, pdfAnnot],
+    factory(errors, parser, annot) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+        const { typeBaseAnnot, captureExtras } = annot;
+
+        const KNOWN = new Set(['FS', 'Name']);
+
+        function typeFileAttachAnnot(dict) {
+            const base = typeBaseAnnot(dict);
+            if (base.subtype && base.subtype !== 'FileAttachment') {
+                throw new ParseError('pdf/annot/fileattach/bad-subtype',
+                    '/Subtype must be /FileAttachment',
+                    { context: { actual: base.subtype } });
+            }
+            const e = dict.entries;
+            if (e.FS && e.FS.type !== 'dict' && e.FS.type !== 'ref') {
+                throw new ParseError('pdf/annot/fileattach/bad-fs',
+                    '/FS must be a dictionary or indirect reference',
+                    { context: { kind: e.FS.type } });
+            }
+            base.fs       = e.FS || null;
+            base.iconName = isType(e.Name, 'name') ? e.Name.value : null;
+            captureExtras(base, dict, KNOWN);
+            return base;
+        }
+
+        return { typeFileAttachAnnot };
+    }
+};

package/src/annot/freeText.js

@@ -0,0 +1,82 @@
+// 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 FreeText annotation per ISO 32000-2:2020 §12.5.6.6.
+ *
+ * Subtype-specific entries:
+ *   /DA  string  — default appearance (required)
+ *   /Q   int     — quadding (0 left, 1 center, 2 right)
+ *   /RC  string  — rich-text contents (XHTML)
+ *   /DS  string  — default style (CSS-like)
+ *   /CL  array   — callout-line coordinates (4 or 6 numbers)
+ *   /IT  name    — intent (FreeText, FreeTextCallout, FreeTextTypeWriter)
+ *   /RD  array   — rectangle differences
+ *   /LE  name    — line ending (callout)
+ *
+ * @module pdf/annot/freeText
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+import { pdfAnnot } from './annot.js';
+
+export const pdfFreeTextAnnot = {
+    name: 'pdfFreeTextAnnot',
+    dependencies: ['pdfErrors', 'pdfParser', 'pdfAnnot'],
+    deps: [pdfErrors, pdfParser, pdfAnnot],
+    factory(errors, parser, annot) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+        const { typeBaseAnnot, captureExtras } = annot;
+
+        const KNOWN = new Set(['DA', 'Q', 'RC', 'DS', 'CL', 'IT', 'RD', 'LE']);
+
+        function typeFreeTextAnnot(dict) {
+            const base = typeBaseAnnot(dict);
+            if (base.subtype && base.subtype !== 'FreeText') {
+                throw new ParseError('pdf/annot/freetext/bad-subtype',
+                    '/Subtype must be /FreeText',
+                    { context: { actual: base.subtype } });
+            }
+            const e = dict.entries;
+            base.da = isType(e.DA, 'string') ? e.DA.value : null;
+            base.q  = (e.Q && (e.Q.type === 'int' || e.Q.type === 'real'))
+                ? (e.Q.value | 0) : 0;
+            base.rc = isType(e.RC, 'string') ? e.RC.value : null;
+            base.ds = isType(e.DS, 'string') ? e.DS.value : null;
+            base.cl = toNumArray(e.CL, 'pdf/annot/freetext/bad-cl');
+            base.it = isType(e.IT, 'name') ? e.IT.value : null;
+            base.rd = toNumArray(e.RD, 'pdf/annot/freetext/bad-rd');
+            base.le = isType(e.LE, 'name') ? e.LE.value : null;
+            captureExtras(base, dict, KNOWN);
+            return base;
+        }
+
+        function toNumArray(v, errCode) {
+            if (!v) return null;
+            if (v.type !== 'array') {
+                throw new ParseError(errCode,
+                    'expected an array of numbers',
+                    { context: { kind: v.type } });
+            }
+            const out = [];
+            for (const it of v.items) {
+                if (!it || (it.type !== 'int' && it.type !== 'real')) {
+                    throw new ParseError(errCode,
+                        'array entries must be numbers',
+                        { context: { kind: it && it.type } });
+                }
+                out.push(it.value);
+            }
+            return out;
+        }
+
+        return { typeFreeTextAnnot };
+    }
+};

package/src/annot/ink.js

@@ -0,0 +1,77 @@
+// 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 Ink annotation per ISO 32000-2:2020 §12.5.6.13.
+ *
+ * Subtype-specific entries:
+ *   /InkList  array of arrays of numbers — each inner array is a stroke
+ *                                          as x1 y1 x2 y2 …
+ *   /BS       border style (on base)
+ *
+ * @module pdf/annot/ink
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+import { pdfAnnot } from './annot.js';
+
+export const pdfInkAnnot = {
+    name: 'pdfInkAnnot',
+    dependencies: ['pdfErrors', 'pdfParser', 'pdfAnnot'],
+    deps: [pdfErrors, pdfParser, pdfAnnot],
+    factory(errors, parser, annot) {
+        const { ParseError } = errors;
+        const { isType: _isType } = parser;
+        const { typeBaseAnnot, captureExtras } = annot;
+
+        const KNOWN = new Set(['InkList']);
+
+        function typeInkAnnot(dict) {
+            const base = typeBaseAnnot(dict);
+            if (base.subtype && base.subtype !== 'Ink') {
+                throw new ParseError('pdf/annot/ink/bad-subtype',
+                    '/Subtype must be /Ink',
+                    { context: { actual: base.subtype } });
+            }
+            base.inkList = toInkList(dict.entries.InkList);
+            captureExtras(base, dict, KNOWN);
+            return base;
+        }
+
+        function toInkList(v) {
+            if (!v) return [];
+            if (v.type !== 'array') {
+                throw new ParseError('pdf/annot/ink/bad-inklist',
+                    '/InkList must be an array of arrays',
+                    { context: { kind: v.type } });
+            }
+            const out = [];
+            for (const stroke of v.items) {
+                if (!stroke || stroke.type !== 'array') {
+                    throw new ParseError('pdf/annot/ink/bad-stroke',
+                        '/InkList entries must be arrays of numbers',
+                        { context: { kind: stroke && stroke.type } });
+                }
+                const nums = [];
+                for (const it of stroke.items) {
+                    if (!it || (it.type !== 'int' && it.type !== 'real')) {
+                        throw new ParseError('pdf/annot/ink/bad-coord',
+                            '/InkList stroke entries must be numbers',
+                            { context: { kind: it && it.type } });
+                    }
+                    nums.push(it.value);
+                }
+                out.push(nums);
+            }
+            return out;
+        }
+
+        return { typeInkAnnot };
+    }
+};

package/src/annot/link.js

@@ -0,0 +1,77 @@
+// 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 Link annotation per ISO 32000-2:2020 §12.5.6.5.
+ *
+ * Subtype-specific entries:
+ *   /Dest       array|name|string — destination (mutually exclusive with /A)
+ *   /A          dict              — action to perform
+ *   /H          name              — highlight mode (N, I, O, P)
+ *   /PA         dict              — URI action for WWW links
+ *   /QuadPoints array of numbers  — link-region quadrilaterals
+ *   /BS         dict              — border style (already on base, but
+ *                                   captured explicitly for clarity)
+ *
+ * @module pdf/annot/link
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+import { pdfAnnot } from './annot.js';
+
+export const pdfLinkAnnot = {
+    name: 'pdfLinkAnnot',
+    dependencies: ['pdfErrors', 'pdfParser', 'pdfAnnot'],
+    deps: [pdfErrors, pdfParser, pdfAnnot],
+    factory(errors, parser, annot) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+        const { typeBaseAnnot, captureExtras } = annot;
+
+        const KNOWN = new Set(['Dest', 'A', 'H', 'PA', 'QuadPoints']);
+
+        function typeLinkAnnot(dict) {
+            const base = typeBaseAnnot(dict);
+            if (base.subtype && base.subtype !== 'Link') {
+                throw new ParseError('pdf/annot/link/bad-subtype',
+                    '/Subtype must be /Link',
+                    { context: { actual: base.subtype } });
+            }
+            const e = dict.entries;
+            base.dest       = e.Dest || null;
+            base.action     = isType(e.A, 'dict') ? e.A : null;
+            base.h          = isType(e.H, 'name') ? e.H.value : null;
+            base.pa         = isType(e.PA, 'dict') ? e.PA : null;
+            base.quadPoints = toNumArray(e.QuadPoints);
+            captureExtras(base, dict, KNOWN);
+            return base;
+        }
+
+        function toNumArray(v) {
+            if (!v) return null;
+            if (v.type !== 'array') {
+                throw new ParseError('pdf/annot/link/bad-quadpoints',
+                    '/QuadPoints must be an array of numbers',
+                    { context: { kind: v.type } });
+            }
+            const out = [];
+            for (const it of v.items) {
+                if (!it || (it.type !== 'int' && it.type !== 'real')) {
+                    throw new ParseError('pdf/annot/link/bad-quadpoints',
+                        '/QuadPoints entries must be numbers',
+                        { context: { kind: it && it.type } });
+                }
+                out.push(it.value);
+            }
+            return out;
+        }
+
+        return { typeLinkAnnot };
+    }
+};

package/src/annot/markup.js

@@ -0,0 +1,91 @@
+// 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 Text-markup annotations per ISO 32000-2:2020 §12.5.6.10.
+ *
+ * Subtypes handled: Highlight, Underline, Squiggly, StrikeOut, Caret.
+ *
+ * Common entry:
+ *   /QuadPoints  array of 8n numbers — quadrilaterals covering markup
+ *
+ * Caret-specific (§12.5.6.11) optional entries:
+ *   /RD          rectangle differences
+ *   /Sy          name — symbol displayed (P or None)
+ *
+ * @module pdf/annot/markup
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+import { pdfAnnot } from './annot.js';
+
+export const pdfMarkupAnnot = {
+    name: 'pdfMarkupAnnot',
+    dependencies: ['pdfErrors', 'pdfParser', 'pdfAnnot'],
+    deps: [pdfErrors, pdfParser, pdfAnnot],
+    factory(errors, parser, annot) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+        const { typeBaseAnnot, captureExtras } = annot;
+
+        const KNOWN = new Set(['QuadPoints', 'RD', 'Sy', 'IT']);
+        const VALID = new Set(['Highlight', 'Underline', 'Squiggly', 'StrikeOut', 'Caret']);
+
+        function typeMarkupAnnot(dict, expected) {
+            if (!VALID.has(expected)) {
+                throw new ParseError('pdf/annot/markup/bad-expected',
+                    'unsupported markup subtype',
+                    { context: { expected } });
+            }
+            const base = typeBaseAnnot(dict);
+            if (base.subtype && base.subtype !== expected) {
+                throw new ParseError('pdf/annot/markup/bad-subtype',
+                    '/Subtype mismatch for markup typer',
+                    { context: { expected, actual: base.subtype } });
+            }
+            const e = dict.entries;
+            base.quadPoints = toNumArray(e.QuadPoints,
+                'pdf/annot/markup/bad-quadpoints');
+            if (expected === 'Caret') {
+                base.rd = toNumArray(e.RD, 'pdf/annot/markup/bad-rd');
+                base.sy = isType(e.Sy, 'name') ? e.Sy.value : null;
+            } else if (e.QuadPoints) {
+                if (base.quadPoints && base.quadPoints.length % 8 !== 0) {
+                    throw new ParseError('pdf/annot/markup/bad-quadpoints',
+                        '/QuadPoints length must be a multiple of 8',
+                        { context: { length: base.quadPoints.length } });
+                }
+            }
+            base.it = isType(e.IT, 'name') ? e.IT.value : null;
+            captureExtras(base, dict, KNOWN);
+            return base;
+        }
+
+        function toNumArray(v, errCode) {
+            if (!v) return null;
+            if (v.type !== 'array') {
+                throw new ParseError(errCode,
+                    'expected an array of numbers',
+                    { context: { kind: v.type } });
+            }
+            const out = [];
+            for (const it of v.items) {
+                if (!it || (it.type !== 'int' && it.type !== 'real')) {
+                    throw new ParseError(errCode,
+                        'array entries must be numbers',
+                        { context: { kind: it && it.type } });
+                }
+                out.push(it.value);
+            }
+            return out;
+        }
+
+        return { typeMarkupAnnot };
+    }
+};

package/src/annot/popup.js

@@ -0,0 +1,53 @@
+// 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 Popup annotation per ISO 32000-2:2020 §12.5.6.14.
+ *
+ * Popups are subordinate displays for markup annotations.
+ *
+ * Subtype-specific entries:
+ *   /Parent  ref     — annotation this popup is associated with
+ *   /Open    boolean — initial open state
+ *
+ * @module pdf/annot/popup
+ */
+
+/**
+ * Module factory.
+ */
+import { pdfErrors } from '../errors.js';
+import { pdfParser } from '../syntax/parser.js';
+import { pdfAnnot } from './annot.js';
+
+export const pdfPopupAnnot = {
+    name: 'pdfPopupAnnot',
+    dependencies: ['pdfErrors', 'pdfParser', 'pdfAnnot'],
+    deps: [pdfErrors, pdfParser, pdfAnnot],
+    factory(errors, parser, annot) {
+        const { ParseError } = errors;
+        const { isType } = parser;
+        const { typeBaseAnnot, captureExtras } = annot;
+
+        const KNOWN = new Set(['Parent', 'Open']);
+
+        function typePopupAnnot(dict) {
+            const base = typeBaseAnnot(dict);
+            if (base.subtype && base.subtype !== 'Popup') {
+                throw new ParseError('pdf/annot/popup/bad-subtype',
+                    '/Subtype must be /Popup',
+                    { context: { actual: base.subtype } });
+            }
+            const e = dict.entries;
+            base.parent = e.Parent && e.Parent.type === 'ref'
+                ? { num: e.Parent.num, gen: e.Parent.gen } : null;
+            base.open   = isType(e.Open, 'bool') ? !!e.Open.value : false;
+            captureExtras(base, dict, KNOWN);
+            return base;
+        }
+
+        return { typePopupAnnot };
+    }
+};