@adnsistemas/pdf-lib 2.8.1 → 2.9.0

package/src/utils/elements/Segment.ts

@@ -1,3 +1,4 @@
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 import {
   distance,
   isColinear,
@@ -13,6 +14,10 @@ import Line from './Line';
 import Point from './Point';
 
 export default class Segment extends GraphElement {
+  static className = () => PDFClasses.Segment;
+  myClass(): PDFClasses {
+    return PDFClasses.Segment;
+  }
   static type = 'Segment';
   A: Point;
   B: Point;
@@ -39,15 +44,14 @@ export default class Segment extends GraphElement {
   }
 
   isEqual(element: GraphElement): boolean {
-    if (!(element instanceof Segment)) return false;
+    if (!isPDFInstance(element, PDFClasses.Segment)) return false;
     const o = this.origin();
     const dest = this.destination();
-    const oE = element.origin();
-    const destE = element.destination();
+    const oE = (element as Segment).origin();
+    const destE = (element as Segment).destination();
     return (
-      element instanceof Segment &&
-      ((o.isEqual(oE) && dest.isEqual(destE)) ||
-        (o.isEqual(destE) && dest.isEqual(oE)))
+      (o.isEqual(oE) && dest.isEqual(destE)) ||
+      (o.isEqual(destE) && dest.isEqual(oE))
     );
   }
 

package/src/utils/intersections.ts

@@ -18,29 +18,47 @@ import {
   vector,
   rotate,
 } from './maths';
+import { isPDFInstance, PDFClasses } from '../api/objects';
 
 export const intersections = (
   A: GraphicElement,
   B: GraphicElement,
 ): Coordinates[] => {
-  if (A instanceof Point || B instanceof Point) return [];
+  if (isPDFInstance(A, PDFClasses.Point) || isPDFInstance(B, PDFClasses.Point))
+    return [];
   else if (A instanceof Text || B instanceof Text) return [];
   else if (A instanceof Image || B instanceof Image) return [];
   // TODO: calculate the coords of the intersection: https://www.emathzone.com/tutorials/geometry/intersection-of-line-and-ellipse.html
-  else if (A instanceof Line) return intersectionsLine(A, B);
-  else if (A instanceof Segment) {
-    return intersectionsLine(A.getLine(), B).filter((P) =>
-      A.includes(new Point(P)),
+  else if (isPDFInstance(A, PDFClasses.Line))
+    return intersectionsLine(
+      A as Line,
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
     );
-  } else if (A instanceof Circle) return intersectionsCircle(A, B);
-  else if (A instanceof Arc) {
-    return intersectionsCircle(A.getCircle(), B).filter((P) =>
-      A.includes(new Point(P)),
+  else if (isPDFInstance(A, PDFClasses.Segment)) {
+    return intersectionsLine(
+      (A as Segment).getLine(),
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
+    ).filter((P) => (A as Segment).includes(new Point(P)));
+  } else if (isPDFInstance(A, PDFClasses.Circle))
+    return intersectionsCircle(
+      A as Circle,
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
     );
-  } else if (A instanceof Plot) return intersectionsPlot(A, B);
-  else if (A instanceof Rectangle) return intersectionsRectangle(A, B);
-  else if (A instanceof Ellipse) return intersectionsEllipse(A, B);
-  return A;
+  else if (isPDFInstance(A, PDFClasses.Arc)) {
+    return intersectionsCircle(
+      (A as Arc).getCircle(),
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
+    ).filter((P) => (A as Arc).includes(new Point(P)));
+  } else if (isPDFInstance(A, PDFClasses.Plot))
+    return intersectionsPlot(A as Plot, B);
+  else if (isPDFInstance(A, PDFClasses.Rectangle))
+    return intersectionsRectangle(A as Rectangle, B);
+  else if (isPDFInstance(A, PDFClasses.Ellipse))
+    return intersectionsEllipse(
+      A as Ellipse,
+      B as Arc | Circle | Ellipse | Line | Plot | Rectangle | Segment,
+    );
+  return A as never;
 };
 
 export const intersection = (
@@ -52,45 +70,52 @@ const intersectionsLine = (
   A: Line,
   B: Exclude<GraphicElement, Text | Point>,
 ): Coordinates[] => {
-  if (B instanceof Line) return intersectionLine(A, B);
-  else if (B instanceof Segment) {
-    return intersectionLine(A, B.getLine()).filter((P) =>
-      B.includes(new Point(P)),
+  if (isPDFInstance(B, PDFClasses.Line)) return intersectionLine(A, B as Line);
+  else if (isPDFInstance(B, PDFClasses.Segment)) {
+    return intersectionLine(A, (B as Segment).getLine()).filter((P) =>
+      (B as Segment).includes(new Point(P)),
     );
-  } else if (B instanceof Circle) return intersectionCircleLine(B, A);
-  else if (B instanceof Arc) {
-    return intersectionsCircle(B.getCircle(), A).filter((P) =>
-      B.includes(new Point(P)),
+  } else if (isPDFInstance(B, PDFClasses.Circle))
+    return intersectionCircleLine(B as Circle, A);
+  else if (isPDFInstance(B, PDFClasses.Arc)) {
+    return intersectionsCircle((B as Arc).getCircle(), A).filter((P) =>
+      (B as Arc).includes(new Point(P)),
     );
-  } else if (B instanceof Plot) return intersectionsPlot(B, A);
-  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
-  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
-  return B;
+  } else if (isPDFInstance(B, PDFClasses.Plot))
+    return intersectionsPlot(B as Plot, A);
+  else if (isPDFInstance(B, PDFClasses.Rectangle))
+    return intersectionsRectangle(B as Rectangle, A);
+  else if (isPDFInstance(B, PDFClasses.Ellipse))
+    return intersectionsEllipse(B as Ellipse, A);
+  return B as never;
 };
 
 const intersectionsEllipse = (
   A: Ellipse,
   B: Exclude<GraphicElement, Text | Point>,
 ): Coordinates[] => {
-  if (B instanceof Line) return intersectionsLineAndEllipse(A, B);
-  else if (B instanceof Segment) {
-    return intersectionsEllipse(A, B.getLine()).filter((P) =>
-      B.includes(new Point(P)),
+  if (isPDFInstance(B, PDFClasses.Line))
+    return intersectionsLineAndEllipse(A, B as Line);
+  else if (isPDFInstance(B, PDFClasses.Segment)) {
+    return intersectionsEllipse(A, (B as Segment).getLine()).filter((P) =>
+      (B as Segment).includes(new Point(P)),
     );
   }
   // TODO:
-  // else if (B instanceof Circle) return intersectionEllipseCircle(B, A)
-  else if (B instanceof Circle) return [];
+  // else if (isPDFInstnace(B, PDFClasses.Circle)) return intersectionEllipseCircle(B as Circle, A);
+  else if (isPDFInstance(B, PDFClasses.Circle)) return [];
   // TODO:
-  // else if (B instanceof Ellipse) return intersectionEllipseEllipse(B, A)
-  else if (B instanceof Ellipse) return [];
-  else if (B instanceof Arc) {
-    return intersectionsEllipse(A, B.getCircle()).filter((P) =>
-      B.includes(new Point(P)),
+  // else if (isPDFInstance(B, PDFClasses.Ellipse)) return intersectionEllipseEllipse(B as Ellipse, A);
+  else if (isPDFInstance(B, PDFClasses.Ellipse)) return [];
+  else if (isPDFInstance(B, PDFClasses.Arc)) {
+    return intersectionsEllipse(A, (B as Arc).getCircle()).filter((P) =>
+      (B as Arc).includes(new Point(P)),
     );
-  } else if (B instanceof Plot) return intersectionsPlot(B, A);
-  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
-  return B;
+  } else if (isPDFInstance(B, PDFClasses.Plot))
+    return intersectionsPlot(B as Plot, A);
+  else if (isPDFInstance(B, PDFClasses.Rectangle))
+    return intersectionsRectangle(B as Rectangle, A);
+  return B as never;
 };
 
 const intersectionsLineAndEllipse = (A: Ellipse, B: Line): Coordinates[] => {
@@ -253,20 +278,25 @@ const intersectionsCircle = (
   A: Circle,
   B: Exclude<GraphicElement, Text | Point>,
 ): Coordinates[] => {
-  if (B instanceof Circle) return intersectionCircle(A, B);
-  else if (B instanceof Line) return intersectionCircleLine(A, B);
-  else if (B instanceof Segment) {
-    return intersectionCircleLine(A, B.getLine()).filter((P) =>
-      B.includes(new Point(P)),
+  if (isPDFInstance(B, PDFClasses.Circle))
+    return intersectionCircle(A, B as Circle);
+  else if (isPDFInstance(B, PDFClasses.Line))
+    return intersectionCircleLine(A, B as Line);
+  else if (isPDFInstance(B, PDFClasses.Segment)) {
+    return intersectionCircleLine(A, (B as Segment).getLine()).filter((P) =>
+      (B as Segment).includes(new Point(P)),
     );
-  } else if (B instanceof Arc) {
-    return intersectionCircle(A, B.getCircle()).filter((P) =>
-      B.includes(new Point(P)),
+  } else if (isPDFInstance(B, PDFClasses.Arc)) {
+    return intersectionCircle(A, (B as Arc).getCircle()).filter((P) =>
+      (B as Arc).includes(new Point(P)),
     );
-  } else if (B instanceof Plot) return intersectionsPlot(B, A);
-  else if (B instanceof Rectangle) return intersectionsRectangle(B, A);
-  else if (B instanceof Ellipse) return intersectionsEllipse(B, A);
-  return B;
+  } else if (isPDFInstance(B, PDFClasses.Plot))
+    return intersectionsPlot(B as Plot, A);
+  else if (isPDFInstance(B, PDFClasses.Rectangle))
+    return intersectionsRectangle(B as Rectangle, A);
+  else if (isPDFInstance(B, PDFClasses.Ellipse))
+    return intersectionsEllipse(B as Ellipse, A);
+  return B as never;
 };
 
 export const getIntersections = (elements: GraphicElement[]) => {

package/ts3.4/cjs/api/PDFDocument.d.ts

@@ -15,6 +15,7 @@ import PDFEmbeddedFile from './PDFEmbeddedFile';
 import PDFSvg from './PDFSvg';
 import { SecurityOptions } from '../core/security/PDFSecurity';
 import { DocumentSnapshot } from './snapshot';
+import { PDFClasses } from './objects';
 export type BasePDFAttachment = {
     name: string;
     data: Uint8Array;
@@ -99,6 +100,8 @@ export default class PDFDocument {
      * @returns Resolves with the newly created document.
      */
     static create(options?: CreateOptions): Promise<PDFDocument>;
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /** The low-level context of this document. */
     readonly context: PDFContext;
     /** The catalog of this document. */

package/ts3.4/cjs/api/form/PDFButton.d.ts

@@ -6,6 +6,7 @@ import { ImageAlignment } from '../image/alignment';
 import { AppearanceProviderFor } from './appearances';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { PDFRef, PDFAcroPushButton } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a button field of a [[PDFForm]].
  *
@@ -16,6 +17,8 @@ import { PDFRef, PDFAcroPushButton } from '../../core';
  * have a text label describing the action that they perform when clicked.
  */
 export default class PDFButton extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getButton]] method, which will create an

package/ts3.4/cjs/api/form/PDFCheckBox.d.ts

@@ -3,6 +3,7 @@ import PDFPage from '../PDFPage';
 import { AppearanceProviderFor } from './appearances';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { PDFRef, PDFAcroCheckBox } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a check box field of a [[PDFForm]].
  *
@@ -13,6 +14,8 @@ import { PDFRef, PDFAcroCheckBox } from '../../core';
  * square in shape and display a check mark when they are in the `on` state.
  */
 export default class PDFCheckBox extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getCheckBox]] method, which will create an

package/ts3.4/cjs/api/form/PDFDropdown.d.ts

@@ -4,6 +4,7 @@ import PDFFont from '../PDFFont';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { PDFRef, PDFAcroComboBox } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a dropdown field of a [[PDFForm]].
  *
@@ -17,6 +18,8 @@ import { PDFRef, PDFAcroComboBox } from '../../core';
  * choose an option from the list (see [[PDFDropdown.isEditable]]).
  */
 export default class PDFDropdown extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getDropdown]] method, which will create an

package/ts3.4/cjs/api/form/PDFField.d.ts

@@ -6,6 +6,7 @@ import { Rotation } from '../rotations';
 import { PDFRef, PDFWidgetAnnotation, PDFOperator, PDFName, PDFDict, PDFAcroTerminal } from '../../core';
 import { ImageAlignment } from '../image';
 import PDFImage from '../PDFImage';
+import { PDFClasses } from '../objects';
 export interface FieldAppearanceOptions {
     x?: number;
     y?: number;
@@ -41,6 +42,8 @@ export declare const assertFieldAppearanceOptions: (options?: FieldAppearanceOpt
  * to be rendered.
  */
 export default class PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /** The low-level PDFAcroTerminal wrapped by this field. */
     readonly acroField: PDFAcroTerminal;
     /** The unique reference assigned to this field within the document. */

package/ts3.4/cjs/api/form/PDFOptionList.d.ts

@@ -4,6 +4,7 @@ import PDFFont from '../PDFFont';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { PDFRef, PDFAcroListBox } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents an option list field of a [[PDFForm]].
  *
@@ -16,6 +17,8 @@ import { PDFRef, PDFAcroListBox } from '../../core';
  * more than one option (see [[PDFOptionList.isMultiselect]]).
  */
 export default class PDFOptionList extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getOptionList]] method, which will create

package/ts3.4/cjs/api/form/PDFRadioGroup.d.ts

@@ -3,6 +3,7 @@ import PDFPage from '../PDFPage';
 import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { PDFRef, PDFAcroRadioButton } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a radio group field of a [[PDFForm]].
  *
@@ -21,6 +22,8 @@ import { PDFRef, PDFAcroRadioButton } from '../../core';
  * [[PDFRadioGroup.isMutuallyExclusive]]).
  */
 export default class PDFRadioGroup extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getOptionList]] method, which will create an

package/ts3.4/cjs/api/form/PDFSignature.d.ts

@@ -1,6 +1,7 @@
 import PDFDocument from '../PDFDocument';
 import PDFField from './PDFField';
 import { PDFRef, PDFAcroSignature } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a signature field of a [[PDFForm]].
  *
@@ -9,6 +10,8 @@ import { PDFRef, PDFAcroSignature } from '../../core';
  * reading the contents of existing digital signatures.
  */
 export default class PDFSignature extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getSignature]] method, which will create an

package/ts3.4/cjs/api/form/PDFTextField.d.ts

@@ -6,6 +6,7 @@ import PDFField, { FieldAppearanceOptions } from './PDFField';
 import { AppearanceProviderFor } from './appearances';
 import { TextAlignment } from '../text/alignment';
 import { PDFRef, PDFAcroText } from '../../core';
+import { PDFClasses } from '../objects';
 /**
  * Represents a text field of a [[PDFForm]].
  *
@@ -16,6 +17,8 @@ import { PDFRef, PDFAcroText } from '../../core';
  * to be entered (see [[PDFTextField.isMultiline]]).
  */
 export default class PDFTextField extends PDFField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     /**
      * > **NOTE:** You probably don't want to call this method directly. Instead,
      * > consider using the [[PDFForm.getTextField]] method, which will create an

package/ts3.4/cjs/api/objects.d.ts

@@ -2,4 +2,65 @@ import { PDFName, PDFNumber } from '../core';
 export declare const asPDFName: (name: string | PDFName) => PDFName;
 export declare const asPDFNumber: (num: number | PDFNumber) => PDFNumber;
 export declare const asNumber: (num: number | PDFNumber) => number;
+export declare enum PDFClasses {
+    PDFDict = "PDFDict",
+    PDFObject = "PDFObject",
+    PDFNumber = "PDFNumber",
+    PDFName = "PDFName",
+    PDFStream = "PDFStream",
+    PDFWriter = "PDFWriter",
+    PDFStreamWriter = "PDFStreamWriter",
+    PDFString = "PDFString",
+    PDFHexString = "PDFHexString",
+    PDFDocument = "PDFDocument",
+    PDFPageLeaf = "PDFPageLeaf",
+    StandardFontEmbedder = "StandardFontEmbedder",
+    PDFArray = "PDFArray",
+    PDFButton = "PDFButton",
+    PDFCheckBox = "PDFCheckBox",
+    PDFDropdown = "PDFDropdown",
+    PDFOptionList = "PDFOptionList",
+    PDFRadioGroup = "PDFRadioGroup",
+    PDFSignature = "PDFSignature",
+    PDFTextField = "PDFTextField",
+    PDFField = "PDFField",
+    PDFRef = "PDFRef",
+    PDFAcroForm = "PDFAcroForm",
+    PDFAcroField = "PDFAcroField",
+    PDFAcroNonTerminal = "PDFAcroNonTerminal",
+    PDFAcroPushButton = "PDFAcroPushButton",
+    PDFAcroCheckBox = "PDFAcroCheckBox",
+    PDFAcroComboBox = "PDFAcroComboBox",
+    PDFAcroListBox = "PDFAcroListBox",
+    PDFAcroText = "PDFAcroText",
+    PDFAcroRadioButton = "PDFAcroRadioButton",
+    PDFAcroSignature = "PDFAcroSignature",
+    AESBaseCipher = "AESBaseCipher",
+    PDFBool = "PDFBool",
+    PDFRawStream = "PDFRawStream",
+    PDFContentStream = "PDFContentStream",
+    Segment = "Segment",
+    Rectangle = "Rectangle",
+    Arc = "Arc",
+    Circle = "Circle",
+    Ellipse = "Ellipse",
+    Line = "Line",
+    Plot = "Plot",
+    Point = "Point",
+    PDFPageTree = "PDFPageTree",
+    PDFInvalidObject = "PDFInvalidObject",
+    PDFCatalog = "PDFCatalog",
+    DefaultDocumentSnapshot = "DefaultDocumentSnapshot",
+    PDFObjectStream = "PDFObjectStream",
+    IncrementalDocumentSnapshot = "IncrementalDocumentSnapshot",
+    PDFNull = "PDFNull"
+}
+/**
+ * Replaces instanceof operator by a "secure function" that uses clases internal identification.
+ * This allows complex environments, where objects comes from different library instances, to work as expected.
+ * @param {any} object Object to which compare the classname.
+ * @param {PDFClasses | typeof PDFClass} className Class name object is expected to be an instanca (or subclass instance)
+ * @returns {boolean}
+ */
+export declare const isPDFInstance: (object: any, className: PDFClasses) => boolean;
 //# sourceMappingURL=objects.d.ts.map

package/ts3.4/cjs/api/operators.d.ts

@@ -1,3 +1,31 @@
+/** =============== There is a circular dependency ===============
+ * To avoid inclusion "undefined" elementos, enums are declared before
+ * imports.
+ */
+export declare enum LineCapStyle {
+    Butt = 0,
+    Round = 1,
+    Projecting = 2
+}
+export declare enum LineJoinStyle {
+    Miter = 0,
+    Round = 1,
+    Bevel = 2
+}
+export declare enum FillRule {
+    NonZero = "f",
+    EvenOdd = "f*"
+}
+export declare enum TextRenderingMode {
+    Fill = 0,
+    Outline = 1,
+    FillAndOutline = 2,
+    Invisible = 3,
+    FillAndClip = 4,
+    OutlineAndClip = 5,
+    FillAndOutlineAndClip = 6,
+    Clip = 7
+}
 import { PDFHexString, PDFName, PDFNumber, PDFOperator } from '../core';
 export declare const clip: () => PDFOperator;
 export declare const clipEvenOdd: () => PDFOperator;
@@ -10,17 +38,7 @@ export declare const skewRadians: (xSkewAngle: number | PDFNumber, ySkewAngle: n
 export declare const skewDegrees: (xSkewAngle: number | PDFNumber, ySkewAngle: number | PDFNumber) => PDFOperator;
 export declare const setDashPattern: (dashArray: (number | PDFNumber)[], dashPhase: number | PDFNumber) => PDFOperator;
 export declare const restoreDashPattern: () => PDFOperator;
-export declare enum LineCapStyle {
-    Butt = 0,
-    Round = 1,
-    Projecting = 2
-}
 export declare const setLineCap: (style: LineCapStyle) => PDFOperator;
-export declare enum LineJoinStyle {
-    Miter = 0,
-    Round = 1,
-    Bevel = 2
-}
 export declare const setLineJoin: (style: LineJoinStyle) => PDFOperator;
 export declare const setGraphicsState: (state: string | PDFName) => PDFOperator;
 export declare const pushGraphicsState: () => PDFOperator;
@@ -45,10 +63,6 @@ export declare const rectangle: (xPos: number | PDFNumber, yPos: number | PDFNum
  */
 export declare const square: (xPos: number, yPos: number, size: number) => PDFOperator;
 export declare const stroke: () => PDFOperator;
-export declare enum FillRule {
-    NonZero = "f",
-    EvenOdd = "f*"
-}
 export declare const fill: () => PDFOperator;
 export declare const fillEvenOdd: () => PDFOperator;
 export declare const fillAndStroke: () => PDFOperator;
@@ -65,16 +79,6 @@ export declare const setWordSpacing: (spacing: number | PDFNumber) => PDFOperato
 export declare const setCharacterSqueeze: (squeeze: number | PDFNumber) => PDFOperator;
 export declare const setLineHeight: (lineHeight: number | PDFNumber) => PDFOperator;
 export declare const setTextRise: (rise: number | PDFNumber) => PDFOperator;
-export declare enum TextRenderingMode {
-    Fill = 0,
-    Outline = 1,
-    FillAndOutline = 2,
-    Invisible = 3,
-    FillAndClip = 4,
-    OutlineAndClip = 5,
-    FillAndOutlineAndClip = 6,
-    Clip = 7
-}
 export declare const setTextRenderingMode: (mode: TextRenderingMode) => PDFOperator;
 export declare const setTextMatrix: (a: number | PDFNumber, b: number | PDFNumber, c: number | PDFNumber, d: number | PDFNumber, e: number | PDFNumber, f: number | PDFNumber) => PDFOperator;
 export declare const rotateAndSkewTextRadiansAndTranslate: (rotationAngle: number | PDFNumber, xSkewAngle: number | PDFNumber, ySkewAngle: number | PDFNumber, x: number | PDFNumber, y: number | PDFNumber) => PDFOperator;

package/ts3.4/cjs/api/snapshot/DefaultDocumentSnapshot.d.ts

@@ -1,6 +1,9 @@
 import { PDFObject, PDFRef } from '../../core';
+import { PDFClasses } from '../objects';
 import { DocumentSnapshot } from './DocumentSnapshot';
 export declare class DefaultDocumentSnapshot implements DocumentSnapshot {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     pdfSize: number;
     prevStartXRef: number;
     deletedCount: number;

package/ts3.4/cjs/api/snapshot/DocumentSnapshot.d.ts

@@ -1,8 +1,10 @@
 import { PDFObject, PDFRef } from '../../core';
+import { PDFClasses } from '../objects';
 export interface DocumentSnapshot {
     pdfSize: number;
     prevStartXRef: number;
     deletedCount: number;
+    myClass: () => PDFClasses;
     shouldSave: (objectNumber: number) => boolean;
     markRefForSave: (ref: PDFRef) => void;
     markRefsForSave: (refs: PDFRef[]) => void;

package/ts3.4/cjs/api/snapshot/IncrementalDocumentSnapshot.d.ts

@@ -1,4 +1,5 @@
 import { PDFContext, PDFObject, PDFRef } from '../../core';
+import { PDFClasses } from '../objects';
 import { DocumentSnapshot } from './DocumentSnapshot';
 export declare class IncrementalDocumentSnapshot implements DocumentSnapshot {
     pdfSize: number;
@@ -9,6 +10,8 @@ export declare class IncrementalDocumentSnapshot implements DocumentSnapshot {
     private changedObjects;
     context: PDFContext;
     constructor(lastObjectNumber: number, indirectObjects: Set<number>, pdfSize: number, prevStartXRef: number, context: PDFContext);
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     shouldSave(objectNumber: number): boolean;
     markRefForSave(ref: PDFRef): void;
     markRefsForSave(refs: PDFRef[]): void;

package/ts3.4/cjs/core/PDFContext.d.ts

@@ -1,4 +1,4 @@
-import { DocumentSnapshot } from '../api';
+import { DocumentSnapshot } from '../api/snapshot/DocumentSnapshot';
 import PDFHeader from './document/PDFHeader';
 import PDFArray from './objects/PDFArray';
 import PDFBool from './objects/PDFBool';

package/ts3.4/cjs/core/acroform/PDFAcroCheckBox.d.ts

@@ -3,7 +3,10 @@ import PDFRef from '../objects/PDFRef';
 import PDFDict from '../objects/PDFDict';
 import PDFName from '../objects/PDFName';
 import PDFAcroButton from './PDFAcroButton';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroCheckBox extends PDFAcroButton {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroCheckBox;
     static create: (context: PDFContext) => PDFAcroCheckBox;
     setValue(value: PDFName): void;

package/ts3.4/cjs/core/acroform/PDFAcroComboBox.d.ts

@@ -2,7 +2,10 @@ import PDFDict from '../objects/PDFDict';
 import PDFAcroChoice from './PDFAcroChoice';
 import PDFContext from '../PDFContext';
 import PDFRef from '../objects/PDFRef';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroComboBox extends PDFAcroChoice {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroComboBox;
     static create: (context: PDFContext) => PDFAcroComboBox;
 }

package/ts3.4/cjs/core/acroform/PDFAcroField.d.ts

@@ -6,7 +6,10 @@ import PDFObject from '../objects/PDFObject';
 import PDFNumber from '../objects/PDFNumber';
 import PDFArray from '../objects/PDFArray';
 import PDFRef from '../objects/PDFRef';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     readonly dict: PDFDict;
     readonly ref: PDFRef;
     protected constructor(dict: PDFDict, ref: PDFRef);

package/ts3.4/cjs/core/acroform/PDFAcroForm.d.ts

@@ -3,7 +3,10 @@ import PDFDict from '../objects/PDFDict';
 import PDFArray from '../objects/PDFArray';
 import PDFRef from '../objects/PDFRef';
 import PDFAcroField from './PDFAcroField';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroForm {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     readonly dict: PDFDict;
     static fromDict: (dict: PDFDict) => PDFAcroForm;
     static create: (context: PDFContext) => PDFAcroForm;

package/ts3.4/cjs/core/acroform/PDFAcroListBox.d.ts

@@ -2,7 +2,10 @@ import PDFDict from '../objects/PDFDict';
 import PDFAcroChoice from './PDFAcroChoice';
 import PDFContext from '../PDFContext';
 import PDFRef from '../objects/PDFRef';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroListBox extends PDFAcroChoice {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroListBox;
     static create: (context: PDFContext) => PDFAcroListBox;
 }

package/ts3.4/cjs/core/acroform/PDFAcroNonTerminal.d.ts

@@ -2,7 +2,10 @@ import PDFDict from '../objects/PDFDict';
 import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
 import PDFAcroField from './PDFAcroField';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroNonTerminal extends PDFAcroField {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroNonTerminal;
     static create: (context: PDFContext) => PDFAcroNonTerminal;
     addField(field: PDFRef): void;

package/ts3.4/cjs/core/acroform/PDFAcroPushButton.d.ts

@@ -2,7 +2,10 @@ import PDFDict from '../objects/PDFDict';
 import PDFAcroButton from './PDFAcroButton';
 import PDFContext from '../PDFContext';
 import PDFRef from '../objects/PDFRef';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroPushButton extends PDFAcroButton {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroPushButton;
     static create: (context: PDFContext) => PDFAcroPushButton;
 }