@adnsistemas/pdf-lib 2.8.1 → 2.9.1

package/src/core/PDFContext.ts

@@ -1,5 +1,6 @@
 import pako from 'pako';
-import type { DocumentSnapshot } from '../api';
+import type { DocumentSnapshot } from '../api/snapshot/DocumentSnapshot';
+import { isPDFInstance, PDFClasses } from '../api/objects';
 
 import PDFHeader from './document/PDFHeader';
 import { UnexpectedObjectTypeError } from './errors';
@@ -85,8 +86,8 @@ class PDFContext {
 
   security?: PDFSecurity;
 
-  private readonly indirectObjects: Map<PDFRef, PDFObject>;
-  private readonly objectsPreviousVersions: Map<PDFRef, PDFObject[]>;
+  private readonly indirectObjects: Map<string, [PDFRef, PDFObject]>;
+  private readonly objectsPreviousVersions: Map<string, PDFObject[]>;
 
   private pushGraphicsStateContentStreamRef?: PDFRef;
   private popGraphicsStateContentStreamRef?: PDFRef;
@@ -111,17 +112,17 @@ class PDFContext {
 
   assign(ref: PDFRef, object: PDFObject): void {
     if (this.preserveObjectsVersions) {
-      const prevOV = this.indirectObjects.get(ref);
+      const prevOV = this.indirectObjects.get(ref.toString());
       if (prevOV) {
-        const prevList = this.objectsPreviousVersions.get(ref);
+        const prevList = this.objectsPreviousVersions.get(ref.toString());
         if (!prevList) {
-          this.objectsPreviousVersions.set(ref, [prevOV]);
+          this.objectsPreviousVersions.set(ref.toString(), [prevOV[1]]);
         } else {
-          prevList.unshift(prevOV);
+          prevList.unshift(prevOV[1]);
         }
       }
     }
-    this.indirectObjects.set(ref, object);
+    this.indirectObjects.set(ref.toString(), [ref, object]);
     if (ref.objectNumber > this.largestObjectNumber) {
       this.largestObjectNumber = ref.objectNumber;
     }
@@ -143,18 +144,18 @@ class PDFContext {
   delete(ref: PDFRef): boolean {
     if (this.snapshot) this.snapshot.markDeletedRef(ref);
     if (this.preserveObjectsVersions) {
-      const object = this.indirectObjects.get(ref);
+      const object = this.indirectObjects.get(ref.toString());
       if (object) {
         // check is not already deleted
-        const verlist = this.objectsPreviousVersions.get(ref);
+        const verlist = this.objectsPreviousVersions.get(ref.toString());
         if (verlist) {
-          verlist.unshift(object);
+          verlist.unshift(object[1]);
         } else {
-          this.objectsPreviousVersions.set(ref, [object]);
+          this.objectsPreviousVersions.set(ref.toString(), [object[1]]);
         }
       }
     }
-    return this.indirectObjects.delete(ref);
+    return this.indirectObjects.delete(ref.toString());
   }
 
   lookupMaybe(ref: LookupKey, type: typeof PDFArray): PDFArray | undefined;
@@ -181,17 +182,27 @@ class PDFContext {
     // removed in next breaking API change.
     const preservePDFNull = types.includes(PDFNull);
 
-    const result = ref instanceof PDFRef ? this.indirectObjects.get(ref) : ref;
-
-    if (!result || (result === PDFNull && !preservePDFNull)) return undefined;
+    let result;
+    if (isPDFInstance(ref, PDFClasses.PDFRef)) {
+      const iobj = this.indirectObjects.get((ref as PDFRef).toString());
+      result = iobj ? iobj[1] : undefined;
+    } else {
+      result = ref;
+    }
+    if (
+      !result ||
+      (isPDFInstance(result, PDFClasses.PDFNull) && !preservePDFNull)
+    )
+      return undefined;
 
     for (let idx = 0, len = types.length; idx < len; idx++) {
       const type = types[idx];
-      if (type === PDFNull) {
-        if (result === PDFNull) return result;
-      } else {
-        if (result instanceof type) return result;
-      }
+      if (
+        isPDFInstance(type, PDFClasses.PDFNull) &&
+        isPDFInstance(result, PDFClasses.PDFNull)
+      )
+        return result;
+      if (isPDFInstance(result, type)) return result;
     }
     throw new UnexpectedObjectTypeError(types, result);
   }
@@ -214,29 +225,36 @@ class PDFContext {
   ): PDFString | PDFHexString;
 
   lookup(ref: LookupKey, ...types: any[]) {
-    const result = ref instanceof PDFRef ? this.indirectObjects.get(ref) : ref;
+    let result;
+    if (isPDFInstance(ref, PDFClasses.PDFRef)) {
+      const iobj = this.indirectObjects.get((ref as PDFRef).toString());
+      result = iobj ? iobj[1] : undefined;
+    } else {
+      result = ref;
+    }
 
     if (types.length === 0) return result;
 
     for (let idx = 0, len = types.length; idx < len; idx++) {
       const type = types[idx];
-      if (type === PDFNull) {
-        if (result === PDFNull) return result;
-      } else {
-        if (result instanceof type) return result;
-      }
+      if (
+        isPDFInstance(type, PDFClasses.PDFNull) &&
+        isPDFInstance(result, PDFClasses.PDFNull)
+      )
+        return result;
+      if (isPDFInstance(result, type)) return result;
     }
 
     throw new UnexpectedObjectTypeError(types, result);
   }
 
   getRef(pdfObject: PDFObject | PDFRef): PDFRef | undefined {
-    if (pdfObject instanceof PDFRef) return pdfObject;
+    if (isPDFInstance(pdfObject, PDFClasses.PDFRef)) return pdfObject as PDFRef;
     return this.getObjectRef(pdfObject);
   }
 
   getObjectRef(pdfObject: PDFObject): PDFRef | undefined {
-    const entries = Array.from(this.indirectObjects.entries());
+    const entries = Array.from(this.indirectObjects.values());
     for (let idx = 0, len = entries.length; idx < len; idx++) {
       const [ref, object] = entries[idx];
       if (object === pdfObject) {
@@ -248,7 +266,7 @@ class PDFContext {
   }
 
   enumerateIndirectObjects(): [PDFRef, PDFObject][] {
-    return Array.from(this.indirectObjects.entries()).sort(
+    return Array.from(this.indirectObjects.values()).sort(
       byAscendingObjectNumber,
     );
   }
@@ -261,7 +279,7 @@ class PDFContext {
   obj(literal: LiteralArray): PDFArray;
 
   obj(literal: Literal) {
-    if (literal instanceof PDFObject) {
+    if (isPDFInstance(literal, PDFClasses.PDFObject)) {
       return literal;
     } else if (literal === null || literal === undefined) {
       return PDFNull;
@@ -321,34 +339,35 @@ class PDFContext {
     }: LiteralConfig = {},
   ): Literal | PDFObject {
     const cfg = { deep, literalRef, literalStreamDict, literalString };
-    if (obj instanceof PDFArray) {
-      const lit = obj.asArray();
+    if (isPDFInstance(obj, PDFClasses.PDFArray)) {
+      const lit = (obj as PDFArray).asArray();
       return deep ? lit.map((value) => this.getLiteral(value, cfg)) : lit;
-    } else if (obj instanceof PDFBool) {
-      return obj.asBoolean();
-    } else if (obj instanceof PDFDict) {
+    } else if (isPDFInstance(obj, PDFClasses.PDFBool)) {
+      return (obj as PDFBool).asBoolean();
+    } else if (isPDFInstance(obj, PDFClasses.PDFDict)) {
       const lit: LiteralObject = {};
-      const entries = obj.entries();
+      const entries = (obj as PDFDict).entries();
       for (let idx = 0, len = entries.length; idx < len; idx++) {
         const [name, value] = entries[idx];
         lit[this.getLiteral(name)] = deep ? this.getLiteral(value, cfg) : value;
       }
       return lit;
-    } else if (obj instanceof PDFName) {
-      return obj.decodeText();
+    } else if (isPDFInstance(obj, PDFClasses.PDFName)) {
+      return (obj as PDFName).decodeText();
     } else if (obj === PDFNull) {
       return null;
-    } else if (obj instanceof PDFNumber) {
-      return obj.asNumber();
-    } else if (obj instanceof PDFRef && literalRef) {
-      return obj.objectNumber;
-    } else if (obj instanceof PDFStream && literalStreamDict) {
-      return this.getLiteral(obj.dict, cfg);
+    } else if (isPDFInstance(obj, PDFClasses.PDFNumber)) {
+      return (obj as PDFNumber).asNumber();
+    } else if (isPDFInstance(obj, PDFClasses.PDFRef) && literalRef) {
+      return (obj as PDFRef).objectNumber;
+    } else if (isPDFInstance(obj, PDFClasses.PDFStream) && literalStreamDict) {
+      return this.getLiteral((obj as PDFStream).dict, cfg);
     } else if (
-      (obj instanceof PDFString || obj instanceof PDFHexString) &&
+      (isPDFInstance(obj, PDFClasses.PDFString) ||
+        isPDFInstance(obj, PDFClasses.PDFHexString)) &&
       literalString
     ) {
-      return obj.asString();
+      return (obj as PDFString | PDFHexString).asString();
     }
     return obj;
   }
@@ -444,7 +463,7 @@ class PDFContext {
   }
 
   private findContainingIndirectObject(target: PDFObject): PDFRef | undefined {
-    const entries = Array.from(this.indirectObjects.entries());
+    const entries = Array.from(this.indirectObjects.values());
     for (let idx = 0, len = entries.length; idx < len; idx++) {
       const [ref, object] = entries[idx];
       if (this.objectContains(object, target)) {
@@ -457,17 +476,19 @@ class PDFContext {
   private objectContains(container: PDFObject, target: PDFObject): boolean {
     if (container === target) return true;
 
-    if (container instanceof PDFDict) {
-      const values = container.values();
+    if (isPDFInstance(container, PDFClasses.PDFDict)) {
+      const values = (container as PDFDict).values();
       for (let i = 0, len = values.length; i < len; i++) {
         if (this.objectContains(values[i], target)) return true;
       }
-    } else if (container instanceof PDFArray) {
-      for (let i = 0, len = container.size(); i < len; i++) {
-        if (this.objectContains(container.get(i), target)) return true;
+    } else if (isPDFInstance(container, PDFClasses.PDFArray)) {
+      for (let i = 0, len = (container as PDFArray).size(); i < len; i++) {
+        if (this.objectContains((container as PDFArray).get(i), target))
+          return true;
       }
-    } else if (container instanceof PDFStream) {
-      if (this.objectContains(container.dict, target)) return true;
+    } else if (isPDFInstance(container, PDFClasses.PDFStream)) {
+      if (this.objectContains((container as PDFStream).dict, target))
+        return true;
     }
 
     return false;
@@ -475,7 +496,7 @@ class PDFContext {
 
   getObjectVersions(ref: PDFRef): PDFObject[] {
     if (!this.preserveObjectsVersions) return [];
-    const list = this.objectsPreviousVersions.get(ref);
+    const list = this.objectsPreviousVersions.get(ref.toString());
     if (list) return list;
     return [];
   }

package/src/core/PDFObjectCopier.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../api/objects';
 import PDFArray from './objects/PDFArray';
 import PDFDict from './objects/PDFDict';
 import PDFName from './objects/PDFName';
@@ -43,11 +44,11 @@ class PDFObjectCopier {
 
   // prettier-ignore
   copy = <T extends PDFObject>(object: T): T => (
-      object instanceof PDFPageLeaf ? this.copyPDFPage(object)
-    : object instanceof PDFDict     ? this.copyPDFDict(object)
-    : object instanceof PDFArray    ? this.copyPDFArray(object)
-    : object instanceof PDFStream   ? this.copyPDFStream(object)
-    : object instanceof PDFRef      ? this.copyPDFIndirectObject(object)
+      isPDFInstance(object, PDFClasses.PDFPageLeaf) ? this.copyPDFPage(object as any as PDFPageLeaf)
+    : isPDFInstance(object, PDFClasses.PDFDict)     ? this.copyPDFDict(object as any as PDFDict)
+    : isPDFInstance(object, PDFClasses.PDFArray)    ? this.copyPDFArray(object as any as PDFArray)
+    : isPDFInstance(object, PDFClasses.PDFStream)   ? this.copyPDFStream(object as any as PDFStream)
+    : isPDFInstance(object, PDFClasses.PDFRef)      ? this.copyPDFIndirectObject(object as any as PDFRef)
     : object.clone()
   ) as T;
 

package/src/core/acroform/PDFAcroButton.ts

@@ -6,6 +6,7 @@ import PDFName from '../objects/PDFName';
 import PDFRef from '../objects/PDFRef';
 import PDFAcroTerminal from './PDFAcroTerminal';
 import { IndexOutOfBoundsError } from '../errors';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFAcroButton extends PDFAcroTerminal {
   Opt(): PDFString | PDFHexString | PDFArray | undefined {
@@ -26,15 +27,21 @@ class PDFAcroButton extends PDFAcroTerminal {
 
     if (!opt) return undefined;
 
-    if (opt instanceof PDFString || opt instanceof PDFHexString) {
-      return [opt];
+    if (
+      isPDFInstance(opt, PDFClasses.PDFString) ||
+      isPDFInstance(opt, PDFClasses.PDFHexString)
+    ) {
+      return [opt as PDFString | PDFHexString];
     }
 
     const values: (PDFString | PDFHexString)[] = [];
-    for (let idx = 0, len = opt.size(); idx < len; idx++) {
-      const value = opt.lookup(idx);
-      if (value instanceof PDFString || value instanceof PDFHexString) {
-        values.push(value);
+    for (let idx = 0, len = (opt as PDFArray).size(); idx < len; idx++) {
+      const value = (opt as PDFArray).lookup(idx);
+      if (
+        isPDFInstance(value, PDFClasses.PDFString) ||
+        isPDFInstance(value, PDFClasses.PDFHexString)
+      ) {
+        values.push(value as PDFString | PDFHexString);
       }
     }
 
@@ -46,14 +53,17 @@ class PDFAcroButton extends PDFAcroTerminal {
 
     if (!opt) return;
 
-    if (opt instanceof PDFString || opt instanceof PDFHexString) {
+    if (
+      isPDFInstance(opt, PDFClasses.PDFString) ||
+      isPDFInstance(opt, PDFClasses.PDFHexString)
+    ) {
       if (idx !== 0) throw new IndexOutOfBoundsError(idx, 0, 0);
       this.setOpt([]);
     } else {
-      if (idx < 0 || idx > opt.size()) {
-        throw new IndexOutOfBoundsError(idx, 0, opt.size());
+      if (idx < 0 || idx > (opt as PDFArray).size()) {
+        throw new IndexOutOfBoundsError(idx, 0, (opt as PDFArray).size());
       }
-      opt.remove(idx);
+      (opt as PDFArray).remove(idx);
     }
   }
 

package/src/core/acroform/PDFAcroCheckBox.ts

@@ -4,8 +4,13 @@ import PDFDict from '../objects/PDFDict';
 import PDFName from '../objects/PDFName';
 import PDFAcroButton from './PDFAcroButton';
 import { InvalidAcroFieldValueError } from '../errors';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFAcroCheckBox extends PDFAcroButton {
+  static className = () => PDFClasses.PDFAcroCheckBox;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroCheckBox;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) =>
     new PDFAcroCheckBox(dict, ref);
 
@@ -36,7 +41,7 @@ class PDFAcroCheckBox extends PDFAcroButton {
 
   getValue(): PDFName {
     const v = this.V();
-    if (v instanceof PDFName) return v;
+    if (isPDFInstance(v, PDFClasses.PDFName)) return v as PDFName;
     return PDFName.of('Off');
   }
 

package/src/core/acroform/PDFAcroChoice.ts

@@ -5,6 +5,7 @@ import PDFArray from '../objects/PDFArray';
 import PDFName from '../objects/PDFName';
 import { AcroChoiceFlags } from './flags';
 import { InvalidAcroFieldValueError, MultiSelectValueError } from '../errors';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFAcroChoice extends PDFAcroTerminal {
   setValues(values: (PDFString | PDFHexString)[]) {
@@ -62,15 +63,22 @@ class PDFAcroChoice extends PDFAcroTerminal {
   getValues(): (PDFString | PDFHexString)[] {
     const v = this.V();
 
-    if (v instanceof PDFString || v instanceof PDFHexString) return [v];
+    if (
+      isPDFInstance(v, PDFClasses.PDFString) ||
+      isPDFInstance(v, PDFClasses.PDFHexString)
+    )
+      return [v as PDFString | PDFHexString];
 
-    if (v instanceof PDFArray) {
+    if (isPDFInstance(v, PDFClasses.PDFArray)) {
       const values: (PDFString | PDFHexString)[] = [];
 
-      for (let idx = 0, len = v.size(); idx < len; idx++) {
-        const value = v.lookup(idx);
-        if (value instanceof PDFString || value instanceof PDFHexString) {
-          values.push(value);
+      for (let idx = 0, len = (v as PDFArray).size(); idx < len; idx++) {
+        const value = (v as PDFArray).lookup(idx);
+        if (
+          isPDFInstance(value, PDFClasses.PDFString) ||
+          isPDFInstance(value, PDFClasses.PDFHexString)
+        ) {
+          values.push(value as PDFString | PDFHexString);
         }
       }
 
@@ -110,31 +118,49 @@ class PDFAcroChoice extends PDFAcroTerminal {
     const Opt = this.Opt();
 
     // Not supposed to happen - Opt _should_ always be `PDFArray | undefined`
-    if (Opt instanceof PDFString || Opt instanceof PDFHexString) {
-      return [{ value: Opt, display: Opt }];
+    if (
+      isPDFInstance(Opt, PDFClasses.PDFString) ||
+      isPDFInstance(Opt, PDFClasses.PDFHexString)
+    ) {
+      return [
+        {
+          value: Opt as PDFString | PDFHexString,
+          display: Opt as PDFString | PDFHexString,
+        },
+      ];
     }
 
-    if (Opt instanceof PDFArray) {
+    if (isPDFInstance(Opt, PDFClasses.PDFArray)) {
       const res: {
         value: PDFString | PDFHexString;
         display: PDFString | PDFHexString;
       }[] = [];
 
-      for (let idx = 0, len = Opt.size(); idx < len; idx++) {
-        const item = Opt.lookup(idx);
+      for (let idx = 0, len = (Opt as PDFArray).size(); idx < len; idx++) {
+        const item = (Opt as PDFArray).lookup(idx);
 
         // If `item` is a string, use that as both the export and text value
-        if (item instanceof PDFString || item instanceof PDFHexString) {
-          res.push({ value: item, display: item });
+        if (
+          isPDFInstance(item, PDFClasses.PDFString) ||
+          isPDFInstance(item, PDFClasses.PDFHexString)
+        ) {
+          res.push({
+            value: item as PDFString | PDFHexString,
+            display: item as PDFString | PDFHexString,
+          });
         }
 
         // If `item` is an array of one, treat it the same as just a string,
         // if it's an array of two then `item[0]` is the export value and
         // `item[1]` is the text value
-        if (item instanceof PDFArray) {
-          if (item.size() > 0) {
-            const first = item.lookup(0, PDFString, PDFHexString);
-            const second = item.lookupMaybe(1, PDFString, PDFHexString);
+        if (isPDFInstance(item, PDFClasses.PDFArray)) {
+          if ((item as PDFArray).size() > 0) {
+            const first = (item as PDFArray).lookup(0, PDFString, PDFHexString);
+            const second = (item as PDFArray).lookupMaybe(
+              1,
+              PDFString,
+              PDFHexString,
+            );
             res.push({ value: first, display: second || first });
           }
         }

package/src/core/acroform/PDFAcroComboBox.ts

@@ -3,8 +3,13 @@ import PDFAcroChoice from './PDFAcroChoice';
 import PDFContext from '../PDFContext';
 import PDFRef from '../objects/PDFRef';
 import { AcroChoiceFlags } from './flags';
+import { PDFClasses } from '../../api/objects';
 
 class PDFAcroComboBox extends PDFAcroChoice {
+  static className = () => PDFClasses.PDFAcroComboBox;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroComboBox;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) =>
     new PDFAcroComboBox(dict, ref);
 

package/src/core/acroform/PDFAcroField.ts

@@ -8,6 +8,7 @@ import PDFArray from '../objects/PDFArray';
 import PDFRef from '../objects/PDFRef';
 import { findLastMatch } from '../../utils';
 import { MissingDAEntryError, MissingTfOperatorError } from '../errors';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 // Examples:
 //   `/Helv 12 Tf` -> ['Helv', '12']
@@ -16,6 +17,10 @@ import { MissingDAEntryError, MissingTfOperatorError } from '../errors';
 const tfRegex =
   /\/([^\0\t\n\f\r ]+)[\0\t\n\f\r ]*(\d*\.\d+|\d+)?[\0\t\n\f\r ]+Tf/;
 class PDFAcroField {
+  static className = () => PDFClasses.PDFAcroField;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroField;
+  }
   readonly dict: PDFDict;
   readonly ref: PDFRef;
 
@@ -48,7 +53,11 @@ class PDFAcroField {
 
   DA(): PDFString | PDFHexString | undefined {
     const da = this.dict.lookup(PDFName.of('DA'));
-    if (da instanceof PDFString || da instanceof PDFHexString) return da;
+    if (
+      isPDFInstance(da, PDFClasses.PDFString) ||
+      isPDFInstance(da, PDFClasses.PDFHexString)
+    )
+      return da as PDFString | PDFHexString;
     return undefined;
   }
 
@@ -62,9 +71,9 @@ class PDFAcroField {
     // return new PDFAcroField(parent);
 
     const parentRef = this.dict.get(PDFName.of('Parent'));
-    if (parentRef instanceof PDFRef) {
+    if (isPDFInstance(parentRef, PDFClasses.PDFRef)) {
       const parent = this.dict.lookup(PDFName.of('Parent'), PDFDict);
-      return new PDFAcroField(parent, parentRef);
+      return new PDFAcroField(parent, parentRef as PDFRef);
     }
 
     return undefined;
@@ -97,8 +106,8 @@ class PDFAcroField {
   getDefaultAppearance(): string | undefined {
     const DA = this.DA();
 
-    if (DA instanceof PDFHexString) {
-      return DA.decodeText();
+    if (isPDFInstance(DA, PDFClasses.PDFHexString)) {
+      return (DA as PDFHexString).decodeText();
     }
 
     return DA?.asString();

package/src/core/acroform/PDFAcroForm.ts

@@ -4,10 +4,14 @@ import PDFArray from '../objects/PDFArray';
 import PDFName from '../objects/PDFName';
 import PDFRef from '../objects/PDFRef';
 import PDFAcroField from './PDFAcroField';
-import PDFAcroNonTerminal from './PDFAcroNonTerminal';
 import { createPDFAcroField, createPDFAcroFields } from './utils';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFAcroForm {
+  static className = () => PDFClasses.PDFAcroForm;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroForm;
+  }
   readonly dict: PDFDict;
 
   static fromDict = (dict: PDFDict) => new PDFAcroForm(dict);
@@ -23,7 +27,7 @@ class PDFAcroForm {
 
   Fields(): PDFArray | undefined {
     const fields = this.dict.lookup(PDFName.of('Fields'));
-    if (fields instanceof PDFArray) return fields;
+    if (isPDFInstance(fields, PDFClasses.PDFArray)) return fields as PDFArray;
     return undefined;
   }
 
@@ -49,7 +53,7 @@ class PDFAcroForm {
         const field = fields[idx];
         allFields.push(field);
         const [fieldModel] = field;
-        if (fieldModel instanceof PDFAcroNonTerminal) {
+        if (isPDFInstance(fieldModel, PDFClasses.PDFAcroNonTerminal)) {
           pushFields(createPDFAcroFields(fieldModel.Kids()));
         }
       }

package/src/core/acroform/PDFAcroListBox.ts

@@ -2,8 +2,13 @@ import PDFDict from '../objects/PDFDict';
 import PDFAcroChoice from './PDFAcroChoice';
 import PDFContext from '../PDFContext';
 import PDFRef from '../objects/PDFRef';
+import { PDFClasses } from '../../api/objects';
 
 class PDFAcroListBox extends PDFAcroChoice {
+  static className = () => PDFClasses.PDFAcroListBox;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroListBox;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) =>
     new PDFAcroListBox(dict, ref);
 

package/src/core/acroform/PDFAcroNonTerminal.ts

@@ -3,8 +3,13 @@ import PDFRef from '../objects/PDFRef';
 import PDFName from '../objects/PDFName';
 import PDFContext from '../PDFContext';
 import PDFAcroField from './PDFAcroField';
+import { PDFClasses } from '../../api/objects';
 
 class PDFAcroNonTerminal extends PDFAcroField {
+  static className = () => PDFClasses.PDFAcroNonTerminal;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroNonTerminal;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) =>
     new PDFAcroNonTerminal(dict, ref);
 

package/src/core/acroform/PDFAcroPushButton.ts

@@ -3,8 +3,13 @@ import PDFAcroButton from './PDFAcroButton';
 import PDFContext from '../PDFContext';
 import PDFRef from '../objects/PDFRef';
 import { AcroButtonFlags } from './flags';
+import { PDFClasses } from '../../api/objects';
 
 class PDFAcroPushButton extends PDFAcroButton {
+  static className = () => PDFClasses.PDFAcroPushButton;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroPushButton;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) =>
     new PDFAcroPushButton(dict, ref);
 

package/src/core/acroform/PDFAcroRadioButton.ts

@@ -5,8 +5,13 @@ import PDFAcroButton from './PDFAcroButton';
 import PDFContext from '../PDFContext';
 import { AcroButtonFlags } from './flags';
 import { InvalidAcroFieldValueError } from '../errors';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFAcroRadioButton extends PDFAcroButton {
+  static className = () => PDFClasses.PDFAcroRadioButton;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroRadioButton;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) =>
     new PDFAcroRadioButton(dict, ref);
 
@@ -38,7 +43,7 @@ class PDFAcroRadioButton extends PDFAcroButton {
 
   getValue(): PDFName {
     const v = this.V();
-    if (v instanceof PDFName) return v;
+    if (isPDFInstance(v, PDFClasses.PDFName)) return v as PDFName;
     return PDFName.of('Off');
   }
 

package/src/core/acroform/PDFAcroSignature.ts

@@ -1,8 +1,13 @@
+import { PDFClasses } from '../../api/objects';
 import PDFDict from '../objects/PDFDict';
 import PDFRef from '../objects/PDFRef';
 import PDFAcroTerminal from './PDFAcroTerminal';
 
 class PDFAcroSignature extends PDFAcroTerminal {
+  static className = () => PDFClasses.PDFAcroSignature;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroSignature;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) =>
     new PDFAcroSignature(dict, ref);
 }