@adnsistemas/pdf-lib 2.8.1 → 2.9.1

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

package/src/core/annotation/AppearanceCharacteristics.ts

@@ -4,6 +4,7 @@ import PDFNumber from '../objects/PDFNumber';
 import PDFArray from '../objects/PDFArray';
 import PDFHexString from '../objects/PDFHexString';
 import PDFString from '../objects/PDFString';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class AppearanceCharacteristics {
   readonly dict: PDFDict;
@@ -17,37 +18,49 @@ class AppearanceCharacteristics {
 
   R(): PDFNumber | undefined {
     const R = this.dict.lookup(PDFName.of('R'));
-    if (R instanceof PDFNumber) return R;
+    if (isPDFInstance(R, PDFClasses.PDFNumber)) return R as PDFNumber;
     return undefined;
   }
 
   BC(): PDFArray | undefined {
     const BC = this.dict.lookup(PDFName.of('BC'));
-    if (BC instanceof PDFArray) return BC;
+    if (isPDFInstance(BC, PDFClasses.PDFArray)) return BC as PDFArray;
     return undefined;
   }
 
   BG(): PDFArray | undefined {
     const BG = this.dict.lookup(PDFName.of('BG'));
-    if (BG instanceof PDFArray) return BG;
+    if (isPDFInstance(BG, PDFClasses.PDFArray)) return BG as PDFArray;
     return undefined;
   }
 
   CA(): PDFHexString | PDFString | undefined {
     const CA = this.dict.lookup(PDFName.of('CA'));
-    if (CA instanceof PDFHexString || CA instanceof PDFString) return CA;
+    if (
+      isPDFInstance(CA, PDFClasses.PDFHexString) ||
+      isPDFInstance(CA, PDFClasses.PDFString)
+    )
+      return CA as PDFString | PDFHexString;
     return undefined;
   }
 
   RC(): PDFHexString | PDFString | undefined {
     const RC = this.dict.lookup(PDFName.of('RC'));
-    if (RC instanceof PDFHexString || RC instanceof PDFString) return RC;
+    if (
+      isPDFInstance(RC, PDFClasses.PDFHexString) ||
+      isPDFInstance(RC, PDFClasses.PDFString)
+    )
+      return RC as PDFString | PDFHexString;
     return undefined;
   }
 
   AC(): PDFHexString | PDFString | undefined {
     const AC = this.dict.lookup(PDFName.of('AC'));
-    if (AC instanceof PDFHexString || AC instanceof PDFString) return AC;
+    if (
+      isPDFInstance(AC, PDFClasses.PDFHexString) ||
+      isPDFInstance(AC, PDFClasses.PDFString)
+    )
+      return AC as PDFString | PDFHexString;
     return undefined;
   }
 
@@ -63,7 +76,8 @@ class AppearanceCharacteristics {
     const components: number[] = [];
     for (let idx = 0, len = BC?.size(); idx < len; idx++) {
       const component = BC.get(idx);
-      if (component instanceof PDFNumber) components.push(component.asNumber());
+      if (isPDFInstance(component, PDFClasses.PDFNumber))
+        components.push((component as PDFNumber).asNumber());
     }
 
     return components;
@@ -77,7 +91,8 @@ class AppearanceCharacteristics {
     const components: number[] = [];
     for (let idx = 0, len = BG?.size(); idx < len; idx++) {
       const component = BG.get(idx);
-      if (component instanceof PDFNumber) components.push(component.asNumber());
+      if (isPDFInstance(component, PDFClasses.PDFNumber))
+        components.push((component as PDFNumber).asNumber());
     }
 
     return components;

package/src/core/annotation/BorderStyle.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import PDFDict from '../objects/PDFDict';
 import PDFName from '../objects/PDFName';
 import PDFNumber from '../objects/PDFNumber';
@@ -14,7 +15,7 @@ class BorderStyle {
 
   W(): PDFNumber | undefined {
     const W = this.dict.lookup(PDFName.of('W'));
-    if (W instanceof PDFNumber) return W;
+    if (isPDFInstance(W, PDFClasses.PDFNumber)) return W as PDFNumber;
     return undefined;
   }
 

package/src/core/annotation/PDFAnnotation.ts

@@ -4,6 +4,7 @@ import PDFStream from '../objects/PDFStream';
 import PDFArray from '../objects/PDFArray';
 import PDFRef from '../objects/PDFRef';
 import PDFNumber from '../objects/PDFNumber';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFAnnotation {
   readonly dict: PDFDict;
@@ -41,7 +42,7 @@ class PDFAnnotation {
 
   getAppearanceState(): PDFName | undefined {
     const AS = this.dict.lookup(PDFName.of('AS'));
-    if (AS instanceof PDFName) return AS;
+    if (isPDFInstance(AS, PDFClasses.PDFName)) return AS as PDFName;
     return undefined;
   }
 
@@ -65,7 +66,11 @@ class PDFAnnotation {
   getNormalAppearance(): PDFRef | PDFDict {
     const AP = this.ensureAP();
     const N = AP.get(PDFName.of('N'));
-    if (N instanceof PDFRef || N instanceof PDFDict) return N;
+    if (
+      isPDFInstance(N, PDFClasses.PDFRef) ||
+      isPDFInstance(N, PDFClasses.PDFDict)
+    )
+      return N as PDFRef | PDFDict;
 
     throw new Error(`Unexpected N type: ${N?.constructor.name}`);
   }

package/src/core/annotation/PDFWidgetAnnotation.ts

@@ -7,6 +7,7 @@ import PDFContext from '../PDFContext';
 import BorderStyle from './BorderStyle';
 import PDFAnnotation from './PDFAnnotation';
 import AppearanceCharacteristics from './AppearanceCharacteristics';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFWidgetAnnotation extends PDFAnnotation {
   static fromDict = (dict: PDFDict): PDFWidgetAnnotation =>
@@ -24,25 +25,29 @@ class PDFWidgetAnnotation extends PDFAnnotation {
 
   MK(): PDFDict | undefined {
     const MK = this.dict.lookup(PDFName.of('MK'));
-    if (MK instanceof PDFDict) return MK;
+    if (isPDFInstance(MK, PDFClasses.PDFDict)) return MK as PDFDict;
     return undefined;
   }
 
   BS(): PDFDict | undefined {
     const BS = this.dict.lookup(PDFName.of('BS'));
-    if (BS instanceof PDFDict) return BS;
+    if (isPDFInstance(BS, PDFClasses.PDFDict)) return BS as PDFDict;
     return undefined;
   }
 
   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;
   }
 
   P(): PDFRef | undefined {
     const P = this.dict.get(PDFName.of('P'));
-    if (P instanceof PDFRef) return P;
+    if (isPDFInstance(P, PDFClasses.PDFRef)) return P as PDFRef;
     return undefined;
   }
 
@@ -57,8 +62,8 @@ class PDFWidgetAnnotation extends PDFAnnotation {
   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();
@@ -97,8 +102,8 @@ class PDFWidgetAnnotation extends PDFAnnotation {
   getOnValue(): PDFName | undefined {
     const normal = this.getAppearances()?.normal;
 
-    if (normal instanceof PDFDict) {
-      const keys = normal.keys();
+    if (isPDFInstance(normal, PDFClasses.PDFDict)) {
+      const keys = (normal as PDFDict).keys();
       for (let idx = 0, len = keys.length; idx < len; idx++) {
         const key = keys[idx];
         if (key !== PDFName.of('Off')) return key;

package/src/core/crypto.ts

@@ -14,6 +14,7 @@
  */
 /* tslint:disable */
 
+import { isPDFInstance, PDFClasses } from '../api/objects';
 import { arrayAsString, isArrayEqual } from '../utils/arrays';
 import { stringAsByteArray } from '../utils/strings';
 import PDFBool from './objects/PDFBool';
@@ -701,6 +702,10 @@ class NullCipher {
 }
 
 class AESBaseCipher {
+  static className = () => PDFClasses.AESBaseCipher;
+  myClass(): PDFClasses {
+    return PDFClasses.AESBaseCipher;
+  }
   protected _s: Uint8Array;
   protected _keySize!: number;
   protected _key!: Uint8Array;
@@ -1475,7 +1480,7 @@ class CipherTransform {
 
   encryptString(s: string) {
     const cipher = this.StringCipherConstructor();
-    if (cipher instanceof AESBaseCipher) {
+    if (isPDFInstance(cipher, PDFClasses.AESBaseCipher)) {
       // Append some chars equal to "16 - (M mod 16)"
       // where M is the string length (see section 7.6.2 in PDF specification)
       // to have a final string where the length is a multiple of 16.
@@ -1507,7 +1512,7 @@ class CipherTransform {
     }
 
     let data = stringAsByteArray(s);
-    data = cipher.encrypt(data);
+    data = (cipher as NullCipher).encrypt(data);
     return arrayAsString(data);
   }
 }
@@ -1559,7 +1564,10 @@ class CipherTransformFactory {
         // Trying to find default handler -- it usually has Length.
         const cfDict = dict.get(PDFName.of('CF')) as PDFDict;
         const streamCryptoName = dict.get(PDFName.of('StmF')) as PDFName;
-        if (cfDict instanceof PDFDict && streamCryptoName instanceof PDFName) {
+        if (
+          isPDFInstance(cfDict, PDFClasses.PDFDict) &&
+          isPDFInstance(streamCryptoName, PDFClasses.PDFName)
+        ) {
           cfDict.suppressEncryption = true;
           const handlerDict = cfDict.get(
             PDFName.of(streamCryptoName.asString()),
@@ -1686,7 +1694,7 @@ class CipherTransformFactory {
 
     if (algorithm >= 4) {
       const cf = dict.get(PDFName.of('CF')) as PDFDict;
-      if (cf instanceof PDFDict) {
+      if (isPDFInstance(cf, PDFClasses.PDFDict)) {
         // The 'CF' dictionary itself should not be encrypted, and by setting
         // `suppressEncryption` we can prevent an infinite loop inside of
         // `XRef_fetchUncompressed` if the dictionary contains indirect
@@ -1948,7 +1956,7 @@ class CipherTransformFactory {
     gen: number,
     key: Uint8Array,
   ) {
-    if (!(name instanceof PDFName)) {
+    if (!isPDFInstance(name, PDFClasses.PDFName)) {
       throw new Error('Invalid crypt filter name.');
     }
     const cryptFilter = cf.get(

package/src/core/embedders/PDFPageEmbedder.ts

@@ -14,6 +14,7 @@ import PDFPageLeaf from '../structures/PDFPageLeaf';
 import CharCodes from '../syntax/CharCodes';
 import { TransformationMatrix } from '../../types/matrix';
 import { mergeIntoTypedArray } from '../../utils';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 /**
  * Represents a page bounding box.
@@ -125,10 +126,10 @@ class PDFPageEmbedder {
       const stream = contents.lookup(idx, PDFStream);
 
       let content: Uint8Array;
-      if (stream instanceof PDFRawStream) {
-        content = decodePDFRawStream(stream).decode();
-      } else if (stream instanceof PDFContentStream) {
-        content = stream.getUnencodedContents();
+      if (isPDFInstance(stream, PDFClasses.PDFRawStream)) {
+        content = decodePDFRawStream(stream as PDFRawStream).decode();
+      } else if (isPDFInstance(stream, PDFClasses.PDFContentStream)) {
+        content = (stream as PDFContentStream).getUnencodedContents();
       } else {
         throw new UnrecognizedStreamTypeError(stream);
       }

package/src/core/embedders/StandardFontEmbedder.ts

@@ -9,6 +9,7 @@ import PDFHexString from '../objects/PDFHexString';
 import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
 import { toCodePoint, toHexString } from '../../utils';
+import { PDFClasses } from '../../api/objects';
 
 export interface Glyph {
   code: number;
@@ -21,6 +22,10 @@ export interface Glyph {
  *   https://github.com/foliojs/pdfkit/blob/f91bdd61c164a72ea06be1a43dc0a412afc3925f/lib/font/afm.coffee
  */
 class StandardFontEmbedder {
+  static className = () => PDFClasses.StandardFontEmbedder;
+  myClass(): PDFClasses {
+    return PDFClasses.StandardFontEmbedder;
+  }
   static for = (fontName: FontNames, customName?: string) =>
     new StandardFontEmbedder(fontName, customName);
 

package/src/core/interactive/ViewerPreferences.ts

@@ -10,6 +10,7 @@ import {
   assertIsOneOf,
   assertRange,
 } from '../../utils';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 const asEnum = <T extends string | number, U extends { [key: string]: T }>(
   rawValue: T | undefined,
@@ -115,13 +116,15 @@ class ViewerPreferences {
 
   protected lookupBool(key: BoolViewerPrefKey): PDFBool | undefined {
     const returnObj = this.dict.lookup(PDFName.of(key));
-    if (returnObj instanceof PDFBool) return returnObj;
+    if (isPDFInstance(returnObj, PDFClasses.PDFBool))
+      return returnObj as PDFBool;
     return undefined;
   }
 
   protected lookupName(key: NameViewerPrefKey): PDFName | undefined {
     const returnObj = this.dict.lookup(PDFName.of(key));
-    if (returnObj instanceof PDFName) return returnObj;
+    if (isPDFInstance(returnObj, PDFClasses.PDFName))
+      return returnObj as PDFName;
     return undefined;
   }
 
@@ -183,14 +186,16 @@ class ViewerPreferences {
   /** @ignore */
   PrintPageRange(): PDFArray | undefined {
     const PrintPageRange = this.dict.lookup(PDFName.of('PrintPageRange'));
-    if (PrintPageRange instanceof PDFArray) return PrintPageRange;
+    if (isPDFInstance(PrintPageRange, PDFClasses.PDFArray))
+      return PrintPageRange as PDFArray;
     return undefined;
   }
 
   /** @ignore */
   NumCopies(): PDFNumber | undefined {
     const NumCopies = this.dict.lookup(PDFName.of('NumCopies'));
-    if (NumCopies instanceof PDFNumber) return NumCopies;
+    if (isPDFInstance(NumCopies, PDFClasses.PDFNumber))
+      return NumCopies as PDFNumber;
     return undefined;
   }
 

package/src/core/objects/PDFArray.ts

@@ -12,8 +12,13 @@ import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
 import { PDFArrayIsNotRectangleError } from '../errors';
 import PDFRawStream from './PDFRawStream';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFArray extends PDFObject {
+  static className = () => PDFClasses.PDFArray;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFArray;
+  }
   static withContext = (context: PDFContext) => new PDFArray(context);
 
   private readonly array: PDFObject[];
@@ -178,9 +183,9 @@ class PDFArray extends PDFObject {
   scalePDFNumbers(x: number, y: number): void {
     for (let idx = 0, len = this.size(); idx < len; idx++) {
       const el = this.lookup(idx);
-      if (el instanceof PDFNumber) {
+      if (isPDFInstance(el, PDFClasses.PDFNumber)) {
         const factor = idx % 2 === 0 ? x : y;
-        this.set(idx, PDFNumber.of(el.asNumber() * factor));
+        this.set(idx, PDFNumber.of((el as PDFNumber).asNumber() * factor));
       }
     }
   }

package/src/core/objects/PDFBool.ts

@@ -1,10 +1,15 @@
 import { PrivateConstructorError } from '../errors';
 import PDFObject from './PDFObject';
 import CharCodes from '../syntax/CharCodes';
+import { PDFClasses } from '../../api/objects';
 
 const ENFORCER = {};
 
 class PDFBool extends PDFObject {
+  static className = () => PDFClasses.PDFBool;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFBool;
+  }
   static readonly True = new PDFBool(ENFORCER, true);
   static readonly False = new PDFBool(ENFORCER, false);
 

package/src/core/objects/PDFDict.ts

@@ -10,10 +10,17 @@ import PDFStream from './PDFStream';
 import PDFString from './PDFString';
 import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 export type DictMap = Map<PDFName, PDFObject>;
+// dictionary keys must be unique, using PDFName does not guarantee that
+type InternalDictMap = Map<string, [PDFName, PDFObject]>;
 
 class PDFDict extends PDFObject {
+  static className = () => PDFClasses.PDFDict;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFDict;
+  }
   static withContext = (context: PDFContext) => new PDFDict(new Map(), context);
 
   static fromMapWithContext = (map: DictMap, context: PDFContext) =>
@@ -21,31 +28,33 @@ class PDFDict extends PDFObject {
 
   readonly context: PDFContext;
 
-  private readonly dict: DictMap;
+  private readonly dict: InternalDictMap;
 
   suppressEncryption: boolean = false;
 
   protected constructor(map: DictMap, context: PDFContext) {
     super();
-    this.dict = map;
+    this.dict = new Map(
+      Array.from(map.entries()).map((entry) => [entry[0].toString(), entry]),
+    );
     this.context = context;
   }
 
   keys(): PDFName[] {
-    return Array.from(this.dict.keys());
+    return Array.from(this.dict.values()).map((value) => value[0]);
   }
 
   values(): PDFObject[] {
-    return Array.from(this.dict.values());
+    return Array.from(this.dict.values()).map((value) => value[1]);
   }
 
   entries(): [PDFName, PDFObject][] {
-    return Array.from(this.dict.entries());
+    return Array.from(this.dict.values());
   }
 
   set(key: PDFName, value: PDFObject): void {
     this.registerChange();
-    this.dict.set(key, value);
+    this.dict.set(key.asString(), [key, value]);
   }
 
   get(
@@ -54,14 +63,20 @@ class PDFDict extends PDFObject {
     // removed in next breaking API change.
     preservePDFNull = false,
   ): PDFObject | undefined {
-    const value = this.dict.get(key);
-    if (value === PDFNull && !preservePDFNull) return undefined;
-    return value;
+    if (!key.asString) return undefined;
+    const value = this.dict.get(key.asString());
+    if (
+      !value ||
+      (isPDFInstance(value[1], PDFClasses.PDFNull) && !preservePDFNull)
+    )
+      return undefined;
+    return value[1];
   }
 
   has(key: PDFName): boolean {
-    const value = this.dict.get(key);
-    return value !== undefined && value !== PDFNull;
+    if (!key.asString) return false;
+    const value = this.dict.get(key.asString());
+    return value !== undefined && !isPDFInstance(value[1], PDFClasses.PDFNull);
   }
 
   lookupMaybe(key: PDFName, type: typeof PDFArray): PDFArray | undefined;
@@ -105,7 +120,8 @@ class PDFDict extends PDFObject {
       ...types,
     ) as any;
 
-    if (value === PDFNull && !preservePDFNull) return undefined;
+    if (isPDFInstance(value, PDFClasses.PDFNull) && !preservePDFNull)
+      return undefined;
 
     return value;
   }
@@ -149,18 +165,19 @@ class PDFDict extends PDFObject {
       ...types,
     ) as any;
 
-    if (value === PDFNull && !preservePDFNull) return undefined;
+    if (isPDFInstance(value, PDFClasses.PDFNull) && !preservePDFNull)
+      return undefined;
 
     return value;
   }
 
   delete(key: PDFName): boolean {
     this.registerChange();
-    return this.dict.delete(key);
+    return this.dict.delete(key.asString());
   }
 
   asMap(): Map<PDFName, PDFObject> {
-    return new Map(this.dict);
+    return new Map(this.dict.values());
   }
 
   /** Generate a random key that doesn't exist in current key set */

package/src/core/objects/PDFHexString.ts

@@ -11,8 +11,13 @@ import {
   byteArrayToHexString,
 } from '../../utils';
 import { InvalidPDFDateStringError } from '../errors';
+import { PDFClasses } from '../../api/objects';
 
 class PDFHexString extends PDFObject {
+  static className = () => PDFClasses.PDFHexString;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFHexString;
+  }
   static of = (value: string) => new PDFHexString(value);
 
   static fromText = (value: string) => {

package/src/core/objects/PDFInvalidObject.ts

@@ -1,6 +1,11 @@
+import { PDFClasses } from '../../api/objects';
 import PDFObject from './PDFObject';
 
 class PDFInvalidObject extends PDFObject {
+  static className = () => PDFClasses.PDFInvalidObject;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFInvalidObject;
+  }
   static of = (data: Uint8Array) => new PDFInvalidObject(data);
 
   private readonly data: Uint8Array;

package/src/core/objects/PDFName.ts

@@ -8,6 +8,7 @@ import {
   toCharCode,
   toHexString,
 } from '../../utils';
+import { PDFClasses } from '../../api/objects';
 
 const decodeName = (name: string) =>
   name.replace(/#([\dABCDEF]{2})/g, (_, hex) => charFromHexCode(hex));
@@ -21,6 +22,10 @@ const ENFORCER = {};
 const pool = new Map<string, PDFName>();
 
 class PDFName extends PDFObject {
+  static className = () => PDFClasses.PDFName;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFName;
+  }
   static of = (name: string): PDFName => {
     const decodedValue = decodeName(name);
 

package/src/core/objects/PDFNull.ts

@@ -1,7 +1,12 @@
 import PDFObject from './PDFObject';
 import CharCodes from '../syntax/CharCodes';
+import { PDFClasses } from '../../api/objects';
 
 class PDFNull extends PDFObject {
+  static className = () => PDFClasses.PDFNull;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFNull;
+  }
   asNull(): null {
     return null;
   }

package/src/core/objects/PDFNumber.ts

@@ -1,8 +1,13 @@
+import { PDFClasses } from '../../api/objects';
 import { copyStringIntoBuffer, numberToString } from '../../utils/index';
 
 import PDFObject from './PDFObject';
 
 class PDFNumber extends PDFObject {
+  static className = () => PDFClasses.PDFNumber;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFNumber;
+  }
   static of = (value: number) => new PDFNumber(value);
 
   private readonly numberValue: number;