@adnsistemas/pdf-lib 2.8.1 → 2.9.1

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)) {

package/src/core/parser/PDFParser.ts

@@ -25,6 +25,7 @@ import { IsDigit } from '../syntax/Numeric';
 import { waitForTick } from '../../utils';
 import { CipherTransformFactory } from '../crypto';
 import PDFNumber from '../objects/PDFNumber';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFParser extends PDFObjectParser {
   static forBytesWithOptions = (
@@ -110,8 +111,8 @@ class PDFParser extends PDFObjectParser {
 
   private maybeRecoverRoot(): void {
     const isValidCatalog = (obj?: PDFObject) =>
-      obj instanceof PDFDict &&
-      obj.lookup(PDFName.of('Type')) === PDFName.of('Catalog');
+      isPDFInstance(obj, PDFClasses.PDFDict) &&
+      (obj as PDFDict).lookup(PDFName.of('Type')) === PDFName.of('Catalog');
 
     const catalog = this.context.lookup(this.context.trailerInfo.Root);
 
@@ -188,18 +189,22 @@ class PDFParser extends PDFObjectParser {
     this.matchKeyword(Keywords.endobj);
 
     if (
-      object instanceof PDFRawStream &&
-      object.dict.lookup(PDFName.of('Type')) === PDFName.of('ObjStm')
+      isPDFInstance(object, PDFClasses.PDFRawStream) &&
+      (object as PDFRawStream).dict.lookup(PDFName.of('Type')) ===
+        PDFName.of('ObjStm')
     ) {
       await PDFObjectStreamParser.forStream(
-        object,
+        object as PDFRawStream,
         this.shouldWaitForTick,
       ).parseIntoContext();
     } else if (
-      object instanceof PDFRawStream &&
-      object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')
+      isPDFInstance(object, PDFClasses.PDFRawStream) &&
+      (object as PDFRawStream).dict.lookup(PDFName.of('Type')) ===
+        PDFName.of('XRef')
     ) {
-      const entries = PDFXRefStreamParser.forStream(object).parseIntoContext();
+      const entries = PDFXRefStreamParser.forStream(
+        object as PDFRawStream,
+      ).parseIntoContext();
       if (entries.length) {
         const xref = PDFCrossRefSection.createEmpty();
         for (const entry of entries) {

package/src/core/parser/PDFXRefStreamParser.ts

@@ -7,6 +7,7 @@ import PDFRawStream from '../objects/PDFRawStream';
 import PDFRef from '../objects/PDFRef';
 import ByteStream from './ByteStream';
 import PDFContext from '../PDFContext';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 export interface Entry {
   ref: PDFRef;
@@ -41,11 +42,15 @@ class PDFXRefStreamParser {
     const Size = this.dict.lookup(PDFName.of('Size'), PDFNumber);
 
     const Index = this.dict.lookup(PDFName.of('Index'));
-    if (Index instanceof PDFArray) {
+    if (isPDFInstance(Index, PDFClasses.PDFArray)) {
       this.subsections = [];
-      for (let idx = 0, len = Index.size(); idx < len; idx += 2) {
-        const firstObjectNumber = Index.lookup(idx + 0, PDFNumber).asNumber();
-        const length = Index.lookup(idx + 1, PDFNumber).asNumber();
+      for (let idx = 0, len = (Index as PDFArray).size(); idx < len; idx += 2) {
+        const firstObjectNumber = (Index as PDFArray)
+          .lookup(idx + 0, PDFNumber)
+          .asNumber();
+        const length = (Index as PDFArray)
+          .lookup(idx + 1, PDFNumber)
+          .asNumber();
         this.subsections.push({ firstObjectNumber, length });
       }
     } else {

package/src/core/streams/decode.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { UnexpectedObjectTypeError, UnsupportedEncodingError } from '../errors';
 import PDFArray from '../objects/PDFArray';
 import PDFDict from '../objects/PDFDict';
@@ -22,10 +23,10 @@ const decodeStream = (
   }
   if (encoding === PDFName.of('LZWDecode')) {
     let earlyChange = 1;
-    if (params instanceof PDFDict) {
-      const EarlyChange = params.lookup(PDFName.of('EarlyChange'));
-      if (EarlyChange instanceof PDFNumber) {
-        earlyChange = EarlyChange.asNumber();
+    if (isPDFInstance(params, PDFClasses.PDFDict)) {
+      const EarlyChange = (params as PDFDict).lookup(PDFName.of('EarlyChange'));
+      if (isPDFInstance(EarlyChange, PDFClasses.PDFNumber)) {
+        earlyChange = (EarlyChange as PDFNumber).asNumber();
       }
     }
     return new LZWStream(stream, undefined, earlyChange as 0 | 1);
@@ -56,17 +57,17 @@ export const decodePDFRawStream = ({
   const Filter = dict.lookup(PDFName.of('Filter'));
   const DecodeParms = dict.lookup(PDFName.of('DecodeParms'));
 
-  if (Filter instanceof PDFName) {
+  if (isPDFInstance(Filter, PDFClasses.PDFName)) {
     stream = decodeStream(
       stream,
-      Filter,
+      Filter as PDFName,
       DecodeParms as PDFDict | typeof PDFNull | undefined,
     );
-  } else if (Filter instanceof PDFArray) {
-    for (let idx = 0, len = Filter.size(); idx < len; idx++) {
+  } else if (isPDFInstance(Filter, PDFClasses.PDFArray)) {
+    for (let idx = 0, len = (Filter as PDFArray).size(); idx < len; idx++) {
       stream = decodeStream(
         stream,
-        Filter.lookup(idx, PDFName),
+        (Filter as PDFArray).lookup(idx, PDFName),
         DecodeParms && (DecodeParms as PDFArray).lookupMaybe(idx, PDFDict),
       );
     }

package/src/core/structures/PDFCatalog.ts

@@ -6,8 +6,13 @@ import PDFPageTree from './PDFPageTree';
 import { PDFAcroForm } from '../acroform';
 import ViewerPreferences from '../interactive/ViewerPreferences';
 import PDFArray from '../objects/PDFArray';
+import { PDFClasses } from '../../api/objects';
 
 class PDFCatalog extends PDFDict {
+  static className = () => PDFClasses.PDFCatalog;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFCatalog;
+  }
   static withContextAndPages = (
     context: PDFContext,
     pages: PDFPageTree | PDFRef,

package/src/core/structures/PDFContentStream.ts

@@ -3,8 +3,13 @@ import PDFOperator from '../operators/PDFOperator';
 import PDFContext from '../PDFContext';
 import PDFFlateStream from './PDFFlateStream';
 import CharCodes from '../syntax/CharCodes';
+import { PDFClasses } from '../../api/objects';
 
 class PDFContentStream extends PDFFlateStream {
+  static className = () => PDFClasses.PDFContentStream;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFContentStream;
+  }
   static of = (dict: PDFDict, operators: PDFOperator[], encode = true) =>
     new PDFContentStream(dict, operators, encode);
 

package/src/core/structures/PDFObjectStream.ts

@@ -6,10 +6,15 @@ import PDFContext from '../PDFContext';
 import PDFFlateStream from './PDFFlateStream';
 import CharCodes from '../syntax/CharCodes';
 import { copyStringIntoBuffer, last } from '../../utils';
+import { PDFClasses } from '../../api/objects';
 
 export type IndirectObject = [PDFRef, PDFObject];
 
 class PDFObjectStream extends PDFFlateStream {
+  static className = () => PDFClasses.PDFObjectStream;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFObjectStream;
+  }
   static withContextAndObjects = (
     context: PDFContext,
     objects: IndirectObject[],

package/src/core/structures/PDFPageLeaf.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import PDFArray from '../objects/PDFArray';
 import PDFDict, { DictMap } from '../objects/PDFDict';
 import PDFName from '../objects/PDFName';
@@ -9,6 +10,10 @@ import PDFContext from '../PDFContext';
 import PDFPageTree from './PDFPageTree';
 
 class PDFPageLeaf extends PDFDict {
+  static className = () => PDFClasses.PDFPageLeaf;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFPageLeaf;
+  }
   static readonly InheritableEntries = [
     'Resources',
     'MediaBox',
@@ -124,9 +129,9 @@ class PDFPageLeaf extends PDFDict {
 
   wrapContentStreams(startStream: PDFRef, endStream: PDFRef): boolean {
     const Contents = this.Contents();
-    if (Contents instanceof PDFArray) {
-      Contents.insert(0, startStream);
-      Contents.push(endStream);
+    if (isPDFInstance(Contents, PDFClasses.PDFArray)) {
+      (Contents as PDFArray).insert(0, startStream);
+      (Contents as PDFArray).push(endStream);
       return true;
     }
     return false;
@@ -208,7 +213,7 @@ class PDFPageLeaf extends PDFDict {
 
     const contentsRef = this.get(PDFName.Contents);
     const contents = this.context.lookup(contentsRef);
-    if (contents instanceof PDFStream) {
+    if (isPDFInstance(contents, PDFClasses.PDFStream)) {
       this.set(PDFName.Contents, context.obj([contentsRef]));
     }
 

package/src/core/structures/PDFPageTree.ts

@@ -6,10 +6,16 @@ import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
 import PDFPageLeaf from './PDFPageLeaf';
 import { InvalidTargetIndexError, CorruptPageTreeError } from '../errors';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 export type TreeNode = PDFPageTree | PDFPageLeaf;
 
 class PDFPageTree extends PDFDict {
+  static className = () => PDFClasses.PDFPageTree;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFPageTree;
+  }
+
   static withContext = (context: PDFContext, parent?: PDFRef) => {
     const dict = new Map();
     dict.set(PDFName.of('Type'), PDFName.of('Pages'));
@@ -72,19 +78,24 @@ class PDFPageTree extends PDFDict {
       const kidRef = Kids.get(idx) as PDFRef;
       const kid = this.context.lookup(kidRef);
 
-      if (kid instanceof PDFPageTree) {
-        if (kid.Count().asNumber() > leafsRemainingUntilTarget) {
+      if (isPDFInstance(kid, PDFClasses.PDFPageTree)) {
+        if (
+          (kid as PDFPageTree).Count().asNumber() > leafsRemainingUntilTarget
+        ) {
           // Dig in
           return (
-            kid.insertLeafNode(leafRef, leafsRemainingUntilTarget) || kidRef
+            (kid as PDFPageTree).insertLeafNode(
+              leafRef,
+              leafsRemainingUntilTarget,
+            ) || kidRef
           );
         } else {
           // Move on
-          leafsRemainingUntilTarget -= kid.Count().asNumber();
+          leafsRemainingUntilTarget -= (kid as PDFPageTree).Count().asNumber();
         }
       }
 
-      if (kid instanceof PDFPageLeaf) {
+      if (isPDFInstance(kid, PDFClasses.PDFPageLeaf)) {
         // Move on
         leafsRemainingUntilTarget -= 1;
       }
@@ -121,19 +132,22 @@ class PDFPageTree extends PDFDict {
       const kidRef = Kids.get(idx) as PDFRef;
       const kid = this.context.lookup(kidRef);
 
-      if (kid instanceof PDFPageTree) {
-        if (kid.Count().asNumber() > leafsRemainingUntilTarget) {
+      if (isPDFInstance(kid, PDFClasses.PDFPageTree)) {
+        if (
+          (kid as PDFPageTree).Count().asNumber() > leafsRemainingUntilTarget
+        ) {
           // Dig in
-          kid.removeLeafNode(leafsRemainingUntilTarget, prune);
-          if (prune && kid.Kids().size() === 0) Kids.remove(idx);
+          (kid as PDFPageTree).removeLeafNode(leafsRemainingUntilTarget, prune);
+          if (prune && (kid as PDFPageTree).Kids().size() === 0)
+            Kids.remove(idx);
           return;
         } else {
           // Move on
-          leafsRemainingUntilTarget -= kid.Count().asNumber();
+          leafsRemainingUntilTarget -= (kid as PDFPageTree).Count().asNumber();
         }
       }
 
-      if (kid instanceof PDFPageLeaf) {
+      if (isPDFInstance(kid, PDFClasses.PDFPageLeaf)) {
         if (leafsRemainingUntilTarget === 0) {
           // Remove page and return
           this.removeKid(idx);
@@ -161,7 +175,8 @@ class PDFPageTree extends PDFDict {
     for (let idx = 0, len = Kids.size(); idx < len; idx++) {
       const kidRef = Kids.get(idx) as PDFRef;
       const kid = this.context.lookup(kidRef) as TreeNode;
-      if (kid instanceof PDFPageTree) kid.traverse(visitor);
+      if (isPDFInstance(kid, PDFClasses.PDFPageTree))
+        (kid as PDFPageTree).traverse(visitor);
       visitor(kid, kidRef);
     }
   }
@@ -181,7 +196,7 @@ class PDFPageTree extends PDFDict {
     const Kids = this.Kids();
 
     const kid = Kids.lookup(kidIdx);
-    if (kid instanceof PDFPageLeaf) {
+    if (isPDFInstance(kid, PDFClasses.PDFPageLeaf)) {
       this.ascend((node) => {
         const newCount = node.Count().asNumber() - 1;
         node.set(PDFName.of('Count'), PDFNumber.of(newCount));

package/src/core/writers/PDFStreamWriter.ts

@@ -2,23 +2,23 @@ import { defaultDocumentSnapshot } from '../../api/snapshot';
 import type { DocumentSnapshot } from '../../api/snapshot';
 import PDFHeader from '../document/PDFHeader';
 import PDFTrailer from '../document/PDFTrailer';
-import PDFInvalidObject from '../objects/PDFInvalidObject';
 import PDFName from '../objects/PDFName';
 import PDFNumber from '../objects/PDFNumber';
 import PDFObject from '../objects/PDFObject';
 import PDFRef from '../objects/PDFRef';
-import PDFStream from '../objects/PDFStream';
 import PDFContext from '../PDFContext';
 import PDFCrossRefStream from '../structures/PDFCrossRefStream';
 import PDFObjectStream from '../structures/PDFObjectStream';
 import PDFWriter from '../writers/PDFWriter';
 import { last, waitForTick } from '../../utils';
 import PDFDict from '../objects/PDFDict';
-import PDFCatalog from '../structures/PDFCatalog';
-import PDFPageTree from '../structures/PDFPageTree';
-import PDFPageLeaf from '../structures/PDFPageLeaf';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 class PDFStreamWriter extends PDFWriter {
+  static className = () => PDFClasses.PDFStreamWriter;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFStreamWriter;
+  }
   static forContext = (
     context: PDFContext,
     objectsPerTick: number,
@@ -97,13 +97,13 @@ class PDFStreamWriter extends PDFWriter {
 
       const shouldNotCompress =
         ref === this.context.trailerInfo.Encrypt ||
-        object instanceof PDFStream ||
-        object instanceof PDFInvalidObject ||
-        object instanceof PDFCatalog ||
-        object instanceof PDFPageTree ||
-        object instanceof PDFPageLeaf ||
+        isPDFInstance(object, PDFClasses.PDFStream) ||
+        isPDFInstance(object, PDFClasses.PDFInvalidObject) ||
+        isPDFInstance(object, PDFClasses.PDFCatalog) ||
+        isPDFInstance(object, PDFClasses.PDFPageTree) ||
+        isPDFInstance(object, PDFClasses.PDFPageLeaf) ||
         ref.generationNumber !== 0 ||
-        (object instanceof PDFDict &&
+        (isPDFInstance(object, PDFClasses.PDFDict) &&
           (object as PDFDict).lookup(PDFName.of('Type')) === PDFName.of('Sig'));
 
       if (shouldNotCompress) {

package/src/core/writers/PDFWriter.ts

@@ -1,7 +1,4 @@
-import {
-  DefaultDocumentSnapshot,
-  defaultDocumentSnapshot,
-} from '../../api/snapshot';
+import { defaultDocumentSnapshot } from '../../api/snapshot';
 import type { DocumentSnapshot } from '../../api/snapshot';
 import PDFCrossRefSection from '../document/PDFCrossRefSection';
 import PDFHeader from '../document/PDFHeader';
@@ -19,6 +16,7 @@ import PDFSecurity from '../security/PDFSecurity';
 import PDFStream from '../objects/PDFStream';
 import PDFName from '../objects/PDFName';
 import PDFRawStream from '../objects/PDFRawStream';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 export interface SerializationInfo {
   size: number;
@@ -30,6 +28,10 @@ export interface SerializationInfo {
 }
 
 class PDFWriter {
+  static className = () => PDFClasses.PDFWriter;
+  myClass(): PDFClasses {
+    return PDFClasses.PDFWriter;
+  }
   static forContext = (context: PDFContext, objectsPerTick: number) =>
     new PDFWriter(context, objectsPerTick, defaultDocumentSnapshot);
 
@@ -96,8 +98,9 @@ class PDFWriter {
           if (objects[idx][0].objectNumber < checkWatermark) break;
           const object = objects[idx][1];
           if (
-            object instanceof PDFRawStream &&
-            object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')
+            isPDFInstance(object, PDFClasses.PDFRawStream) &&
+            (object as PDFRawStream).dict.lookup(PDFName.of('Type')) ===
+              PDFName.of('XRef')
           ) {
             this._lastXRefObjectNumber = objects[idx][0].objectNumber;
             break;
@@ -112,7 +115,10 @@ class PDFWriter {
   }
 
   async serializeToBuffer(): Promise<Uint8Array> {
-    const incremental = !(this.snapshot instanceof DefaultDocumentSnapshot);
+    const incremental = !isPDFInstance(
+      this.snapshot,
+      PDFClasses.DefaultDocumentSnapshot,
+    );
     const { size, header, indirectObjects, xref, trailerDict, trailer } =
       await this.computeBufferSize(incremental);
 
@@ -157,8 +163,9 @@ class PDFWriter {
       buffer[offset++] = CharCodes.Newline;
       buffer[offset++] = CharCodes.Newline;
 
-      const n =
-        object instanceof PDFObjectStream ? object.getObjectsCount() : 1;
+      const n = isPDFInstance(object, PDFClasses.PDFObjectStream)
+        ? (object as PDFObjectStream).getObjectsCount()
+        : 1;
       if (this.shouldWaitForTick(n)) await waitForTick();
     }
 
@@ -264,14 +271,14 @@ class PDFWriter {
   }
 
   protected encrypt(ref: PDFRef, object: PDFObject, security: PDFSecurity) {
-    if (object instanceof PDFStream) {
+    if (isPDFInstance(object, PDFClasses.PDFStream)) {
       const encryptFn = security.getEncryptFn(
         ref.objectNumber,
         ref.generationNumber,
       );
-      const unencryptedContents = object.getContents();
+      const unencryptedContents = (object as PDFStream).getContents();
       const encryptedContents = encryptFn(unencryptedContents);
-      object.updateContents(encryptedContents);
+      (object as PDFStream).updateContents(encryptedContents);
     }
   }
 

package/src/utils/elements/Arc.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { angleABC, distance, distanceCoords, rotate, vector } from '../maths';
 
 import Circle from './Circle';
@@ -5,6 +6,10 @@ import GraphElement from './GraphElement';
 import Point from './Point';
 
 export default class Arc extends GraphElement {
+  static className = () => PDFClasses.Arc;
+  myClass(): PDFClasses {
+    return PDFClasses.Arc;
+  }
   O: Point;
   A: Point;
   B: Point;
@@ -51,13 +56,13 @@ export default class Arc extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Arc)) return false;
+    if (!isPDFInstance(element, PDFClasses.Arc)) return false;
     const dest = this.destination();
     const o = this.origin();
-    const eDest = element.destination();
-    const eO = element.origin();
+    const eDest = (element as Arc).destination();
+    const eO = (element as Arc).origin();
     return (
-      this.getCircle().isEqual(element.getCircle()) &&
+      this.getCircle().isEqual((element as Arc).getCircle()) &&
       ((dest.isEqual(eDest) && o.isEqual(eO)) ||
         (dest.isEqual(eO) && o.isEqual(eDest)))
     );

package/src/utils/elements/Circle.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import {
   distance,
   distanceCoords,
@@ -11,6 +12,10 @@ import {
 import GraphElement from './GraphElement';
 import Point from './Point';
 export default class Circle extends GraphElement {
+  static className = () => PDFClasses.Circle;
+  myClass(): PDFClasses {
+    return PDFClasses.Circle;
+  }
   O: Point;
   r: number;
 
@@ -35,9 +40,9 @@ export default class Circle extends GraphElement {
 
   isEqual(element: GraphElement): boolean {
     return (
-      element instanceof Circle &&
-      this.center().isEqual(element.center()) &&
-      isEqual(this.ray(), element.ray())
+      isPDFInstance(element, PDFClasses.Circle) &&
+      this.center().isEqual((element as Circle).center()) &&
+      isEqual(this.ray(), (element as Circle).ray())
     );
   }