@adnsistemas/pdf-lib 2.8.0 → 2.9.0

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,15 @@ import PDFStream from './PDFStream';
 import PDFString from './PDFString';
 import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
+import { PDFClasses } from '../../api/objects';
 
 export type DictMap = Map<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) =>

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;

package/src/core/objects/PDFObject.ts

@@ -1,7 +1,13 @@
+import { PDFClasses } from '../../api/objects';
 import { MethodNotImplementedError } from '../errors';
 import PDFContext from '../PDFContext';
 
 class PDFObject {
+  static className = () => PDFClasses.PDFObject;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFObject;
+  }
+
   registerChange() {
     throw new MethodNotImplementedError(
       this.constructor.name,

package/src/core/objects/PDFRawStream.ts

@@ -3,8 +3,13 @@ import PDFStream from './PDFStream';
 import PDFContext from '../PDFContext';
 import { arrayAsString } from '../../utils';
 import { CipherTransform } from '../crypto';
+import { PDFClasses } from '../../api/objects';
 
 class PDFRawStream extends PDFStream {
+  static className = () => PDFClasses.PDFRawStream;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFRawStream;
+  }
   static of = (
     dict: PDFDict,
     contents: Uint8Array,

package/src/core/objects/PDFRef.ts

@@ -1,11 +1,16 @@
 import { PrivateConstructorError } from '../errors';
 import PDFObject from '../objects/PDFObject';
 import { copyStringIntoBuffer } from '../../utils';
+import { PDFClasses } from '../../api';
 
 const ENFORCER = {};
 const pool = new Map<string, PDFRef>();
 
 class PDFRef extends PDFObject {
+  static className = () => PDFClasses.PDFRef;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFRef;
+  }
   static of = (objectNumber: number, generationNumber = 0) => {
     const tag = `${objectNumber} ${generationNumber} R`;
 

package/src/core/objects/PDFStream.ts

@@ -5,8 +5,13 @@ import PDFNumber from './PDFNumber';
 import PDFObject from './PDFObject';
 import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
+import { PDFClasses } from '../../api/objects';
 
 class PDFStream extends PDFObject {
+  static className = () => PDFClasses.PDFStream;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFStream;
+  }
   readonly dict: PDFDict;
 
   constructor(dict: PDFDict) {

package/src/core/objects/PDFString.ts

@@ -10,8 +10,13 @@ import {
   hasUtf16BOM,
 } from '../../utils';
 import { InvalidPDFDateStringError } from '../errors';
+import { PDFClasses } from '../../api/objects';
 
 class PDFString extends PDFObject {
+  static className = () => PDFClasses.PDFString;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFString;
+  }
   // The PDF spec allows newlines and parens to appear directly within a literal
   // string. These character _may_ be escaped. But they do not _have_ to be. So
   // for simplicity, we will not bother escaping them.

package/src/core/operators/PDFOperator.ts

@@ -8,6 +8,7 @@ import PDFOperatorNames from './PDFOperatorNames';
 import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
 import { copyStringIntoBuffer } from '../../utils';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 export type PDFOperatorArg =
   | string
@@ -33,7 +34,9 @@ class PDFOperator {
     const args = new Array(this.args.length);
     for (let idx = 0, len = args.length; idx < len; idx++) {
       const arg = this.args[idx];
-      args[idx] = arg instanceof PDFObject ? arg.clone(context) : arg;
+      args[idx] = isPDFInstance(arg, PDFClasses.PDFObject)
+        ? (arg as PDFObject).clone(context)
+        : arg;
     }
     return PDFOperator.of(this.name, args);
   }
@@ -51,7 +54,10 @@ class PDFOperator {
     let size = 0;
     for (let idx = 0, len = this.args.length; idx < len; idx++) {
       const arg = this.args[idx];
-      size += (arg instanceof PDFObject ? arg.sizeInBytes() : arg.length) + 1;
+      size +=
+        (isPDFInstance(arg, PDFClasses.PDFObject)
+          ? (arg as PDFObject).sizeInBytes()
+          : (arg as string).length) + 1;
     }
     size += this.name.length;
     return size;
@@ -62,10 +68,10 @@ class PDFOperator {
 
     for (let idx = 0, len = this.args.length; idx < len; idx++) {
       const arg = this.args[idx];
-      if (arg instanceof PDFObject) {
-        offset += arg.copyBytesInto(buffer, offset);
+      if (isPDFInstance(arg, PDFClasses.PDFObject)) {
+        offset += (arg as PDFObject).copyBytesInto(buffer, offset);
       } else {
-        offset += copyStringIntoBuffer(arg, buffer, offset);
+        offset += copyStringIntoBuffer(arg as string, buffer, offset);
       }
       buffer[offset++] = CharCodes.Space;
     }

package/src/core/parser/PDFObjectParser.ts

@@ -29,6 +29,7 @@ import { IsDigit, IsNumeric } from '../syntax/Numeric';
 import { IsWhitespace } from '../syntax/Whitespace';
 import { arrayAsString, charFromCode } from '../../utils';
 import { CipherTransformFactory } from '../crypto';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 // TODO: Throw error if eof is reached before finishing object parse...
 class PDFObjectParser extends BaseParser {
@@ -256,8 +257,8 @@ class PDFObjectParser extends BaseParser {
     let end: number;
 
     const Length = dict.get(PDFName.of('Length'));
-    if (Length instanceof PDFNumber) {
-      end = start + Length.asNumber();
+    if (isPDFInstance(Length, PDFClasses.PDFNumber)) {
+      end = start + (Length as PDFNumber).asNumber();
       this.bytes.moveTo(end);
       this.skipWhitespaceAndComments();
       if (!this.matchKeyword(Keywords.endstream)) {