@adnsistemas/pdf-lib 2.8.0 → 2.9.0

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';
@@ -181,17 +182,24 @@ class PDFContext {
     // removed in next breaking API change.
     const preservePDFNull = types.includes(PDFNull);
 
-    const result = ref instanceof PDFRef ? this.indirectObjects.get(ref) : ref;
+    const result = isPDFInstance(ref, PDFClasses.PDFRef)
+      ? this.indirectObjects.get(ref as PDFRef)
+      : ref;
 
-    if (!result || (result === PDFNull && !preservePDFNull)) return undefined;
+    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,24 +222,27 @@ class PDFContext {
   ): PDFString | PDFHexString;
 
   lookup(ref: LookupKey, ...types: any[]) {
-    const result = ref instanceof PDFRef ? this.indirectObjects.get(ref) : ref;
+    const result = isPDFInstance(ref, PDFClasses.PDFRef)
+      ? this.indirectObjects.get(ref as PDFRef)
+      : 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);
   }
 
@@ -261,7 +272,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 +332,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;
   }
@@ -457,17 +469,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;

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);
 }

package/src/core/acroform/PDFAcroText.ts

@@ -6,8 +6,13 @@ import PDFHexString from '../objects/PDFHexString';
 import PDFName from '../objects/PDFName';
 import PDFRef from '../objects/PDFRef';
 import PDFAcroTerminal from './PDFAcroTerminal';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFAcroText extends PDFAcroTerminal {
+  static className = () => PDFClasses.PDFAcroText;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFAcroText;
+  }
   static fromDict = (dict: PDFDict, ref: PDFRef) => new PDFAcroText(dict, ref);
 
   static create = (context: PDFContext) => {
@@ -21,13 +26,13 @@ class PDFAcroText extends PDFAcroTerminal {
 
   MaxLen(): PDFNumber | undefined {
     const maxLen = this.dict.lookup(PDFName.of('MaxLen'));
-    if (maxLen instanceof PDFNumber) return maxLen;
+    if (isPDFInstance(maxLen, PDFClasses.PDFNumber)) return maxLen as PDFNumber;
     return undefined;
   }
 
   Q(): PDFNumber | undefined {
     const q = this.dict.lookup(PDFName.of('Q'));
-    if (q instanceof PDFNumber) return q;
+    if (isPDFInstance(q, PDFClasses.PDFNumber)) return q as PDFNumber;
     return undefined;
   }
 
@@ -68,7 +73,11 @@ class PDFAcroText extends PDFAcroTerminal {
 
   getValue(): PDFString | PDFHexString | undefined {
     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;
     return undefined;
   }
 }

package/src/core/acroform/utils.ts

@@ -18,6 +18,7 @@ import PDFAcroCheckBox from './PDFAcroCheckBox';
 import PDFAcroComboBox from './PDFAcroComboBox';
 import PDFAcroListBox from './PDFAcroListBox';
 import { AcroButtonFlags, AcroChoiceFlags } from './flags';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 export const createPDFAcroFields = (
   kidDicts?: PDFArray,
@@ -28,9 +29,15 @@ export const createPDFAcroFields = (
   for (let idx = 0, len = kidDicts.size(); idx < len; idx++) {
     const ref = kidDicts.get(idx);
     const dict = kidDicts.lookup(idx);
-    // if (dict instanceof PDFDict) kids.push(PDFAcroField.fromDict(dict));
-    if (ref instanceof PDFRef && dict instanceof PDFDict) {
-      kids.push([createPDFAcroField(dict, ref), ref]);
+    // if (isPDFInstance(dict, PDFClasses.PDFDict)) kids.push(PDFAcroField.fromDict(dict));
+    if (
+      isPDFInstance(ref, PDFClasses.PDFRef) &&
+      isPDFInstance(dict, PDFClasses.PDFDict)
+    ) {
+      kids.push([
+        createPDFAcroField(dict as PDFDict, ref as PDFRef),
+        ref as PDFRef,
+      ]);
     }
   }
 
@@ -65,10 +72,12 @@ export const createPDFAcroField = (
 const isNonTerminalAcroField = (dict: PDFDict): boolean => {
   const kids = dict.lookup(PDFName.of('Kids'));
 
-  if (kids instanceof PDFArray) {
-    for (let idx = 0, len = kids.size(); idx < len; idx++) {
-      const kid = kids.lookup(idx);
-      const kidIsField = kid instanceof PDFDict && kid.has(PDFName.of('T'));
+  if (isPDFInstance(kids, PDFClasses.PDFArray)) {
+    for (let idx = 0, len = (kids as PDFArray).size(); idx < len; idx++) {
+      const kid = (kids as PDFArray).lookup(idx);
+      const kidIsField =
+        isPDFInstance(kid, PDFClasses.PDFDict) &&
+        (kid as PDFDict).has(PDFName.of('T'));
       if (kidIsField) return true;
     }
   }