@adnsistemas/pdf-lib 2.8.1 → 2.9.0

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

package/src/utils/elements/Ellipse.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { Size } from '../../types';
 import {
   angle,
@@ -15,6 +16,10 @@ import Point from './Point';
 import Segment from './Segment';
 
 export default class Ellipse extends GraphElement {
+  static className = () => PDFClasses.Ellipse;
+  myClass(): PDFClasses {
+    return PDFClasses.Ellipse;
+  }
   A: Point;
   B: Point;
   C: Point;
@@ -62,13 +67,13 @@ export default class Ellipse extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Ellipse)) return false;
+    if (!isPDFInstance(element, PDFClasses.Ellipse)) return false;
     const a = this.a();
     const b = this.b();
     const rotation = this.rotation();
-    const eltA = element.a();
-    const eltB = element.b();
-    const eltRotation = element.rotation();
+    const eltA = (element as Ellipse).a();
+    const eltB = (element as Ellipse).b();
+    const eltRotation = (element as Ellipse).rotation();
     // If the main axis is the same on both ellipse
     if (eltA < eltB === a < b) {
       // The rotation is equivalent module PI as the element is symetrical

package/src/utils/elements/GraphElement.ts

@@ -1,8 +1,11 @@
+import { PDFClasses } from '../../api/objects';
 import { distance } from '../maths';
 
 import Point from './Point';
 
 export default abstract class GraphElement {
+  abstract myClass(): PDFClasses;
+
   abstract isEqual(element: GraphElement): boolean;
 
   abstract orthoProjection(P: Point): Point;

package/src/utils/elements/Line.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { Coordinates } from '../../types';
 import { intersectionLine } from '../intersections';
 import { isColinear, isEqual, orthogonal, vector } from '../maths';
@@ -6,6 +7,10 @@ import GraphElement from './GraphElement';
 import Point from './Point';
 
 export default class Line extends GraphElement {
+  static className = () => PDFClasses.Line;
+  myClass(): PDFClasses {
+    return PDFClasses.Line;
+  }
   origin(): Point {
     return this.A;
   }
@@ -46,12 +51,15 @@ export default class Line extends GraphElement {
   isEqual(element: GraphElement): boolean {
     const vect = this.dirVect();
     return (
-      element instanceof Line &&
-      isColinear(vect, element.dirVect()) &&
+      isPDFInstance(element, PDFClasses.Line) &&
+      isColinear(vect, (element as Line).dirVect()) &&
       (isEqual(vect.x, 0)
         ? // We need to take care of the case of the vertical line
-          isEqual(this.origin().toCoords().x, element.origin().toCoords().x)
-        : isEqual(this.b(), element.b()))
+          isEqual(
+            this.origin().toCoords().x,
+            (element as Line).origin().toCoords().x,
+          )
+        : isEqual(this.b(), (element as Line).b()))
     );
   }
 

package/src/utils/elements/Plot.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import { Coordinates } from '../../types';
 import { plus } from '../maths';
 
@@ -5,6 +6,10 @@ import GraphElement from './GraphElement';
 import Point from './Point';
 import Segment from './Segment';
 export default class Plot extends GraphElement {
+  static className = () => PDFClasses.Plot;
+  myClass(): PDFClasses {
+    return PDFClasses.Plot;
+  }
   points: Coordinates[];
 
   constructor(points: Coordinates[] = []) {
@@ -21,9 +26,11 @@ export default class Plot extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Plot)) return false;
+    if (!isPDFInstance(element, PDFClasses.Plot)) return false;
     const points = this.getPoints().map((coord) => new Point(coord));
-    const points2 = element.getPoints().map((coord) => new Point(coord));
+    const points2 = (element as Plot)
+      .getPoints()
+      .map((coord) => new Point(coord));
     return (
       points.every((point, i) => point.isEqual(points2[i])) ||
       points.reverse().every((point, i) => point.isEqual(points2[i]))

package/src/utils/elements/Point.ts

@@ -1,9 +1,14 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import type { Coordinates } from '../../types';
 
 import { isEqual, plus } from '../maths';
 import GraphElement from './GraphElement';
 
 export default class Point extends GraphElement {
+  static className = () => PDFClasses.Point;
+  myClass(): PDFClasses {
+    return PDFClasses.Point;
+  }
   static type = 'PointFixed';
 
   x: number;
@@ -20,9 +25,9 @@ export default class Point extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Point)) return false;
+    if (!isPDFInstance(element, PDFClasses.Point)) return false;
     const A = this.toCoords();
-    const B = element.toCoords();
+    const B = (element as Point).toCoords();
     return isEqual(A.x, B.x) && isEqual(A.y, B.y);
   }
 

package/src/utils/elements/Rectangle.ts

@@ -1,8 +1,13 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import GraphElement from './GraphElement';
 import Point from './Point';
 import Segment from './Segment';
 
 export default class Rectangle extends GraphElement {
+  static className = () => PDFClasses.Rectangle;
+  myClass(): PDFClasses {
+    return PDFClasses.Rectangle;
+  }
   static type = 'Rectangle';
   start: Point;
   end: Point;
@@ -48,9 +53,9 @@ export default class Rectangle extends GraphElement {
 
   isEqual(element: GraphElement): boolean {
     return (
-      element instanceof Rectangle &&
-      this.getStart().isEqual(element.getStart()) &&
-      this.getEnd().isEqual(element.getEnd())
+      isPDFInstance(element, PDFClasses.Rectangle) &&
+      this.getStart().isEqual((element as Rectangle).getStart()) &&
+      this.getEnd().isEqual((element as Rectangle).getEnd())
     );
   }