@adnsistemas/pdf-lib 2.8.0 → 2.9.0

package/ts3.4/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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/es/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;
 }

package/ts3.4/es/core/acroform/PDFAcroRadioButton.d.ts

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

package/ts3.4/es/core/acroform/PDFAcroSignature.d.ts

@@ -1,7 +1,10 @@
+import { PDFClasses } from '../../api/objects';
 import PDFDict from '../objects/PDFDict';
 import PDFRef from '../objects/PDFRef';
 import PDFAcroTerminal from './PDFAcroTerminal';
 declare class PDFAcroSignature extends PDFAcroTerminal {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroSignature;
 }
 export default PDFAcroSignature;

package/ts3.4/es/core/acroform/PDFAcroText.d.ts

@@ -5,7 +5,10 @@ import PDFString from '../objects/PDFString';
 import PDFHexString from '../objects/PDFHexString';
 import PDFRef from '../objects/PDFRef';
 import PDFAcroTerminal from './PDFAcroTerminal';
+import { PDFClasses } from '../../api/objects';
 declare class PDFAcroText extends PDFAcroTerminal {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static fromDict: (dict: PDFDict, ref: PDFRef) => PDFAcroText;
     static create: (context: PDFContext) => PDFAcroText;
     MaxLen(): PDFNumber | undefined;

package/ts3.4/es/core/crypto.d.ts

@@ -1,3 +1,4 @@
+import { PDFClasses } from '../api/objects';
 import PDFDict from './objects/PDFDict';
 import PDFName from './objects/PDFName';
 import DecryptStream from './streams/DecryptStream';
@@ -20,6 +21,8 @@ declare class NullCipher {
     encrypt(data: Uint8Array): Uint8Array;
 }
 declare class AESBaseCipher {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     protected _s: Uint8Array;
     protected _keySize: number;
     protected _key: Uint8Array;

package/ts3.4/es/core/embedders/StandardFontEmbedder.d.ts

@@ -2,6 +2,7 @@ import { Font, FontNames, EncodingType } from '@pdf-lib/standard-fonts';
 import PDFHexString from '../objects/PDFHexString';
 import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
+import { PDFClasses } from '../../api/objects';
 export interface Glyph {
     code: number;
     name: string;
@@ -12,6 +13,8 @@ export interface Glyph {
  *   https://github.com/foliojs/pdfkit/blob/f91bdd61c164a72ea06be1a43dc0a412afc3925f/lib/font/afm.coffee
  */
 declare class StandardFontEmbedder {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static for: (fontName: FontNames, customName?: string) => StandardFontEmbedder;
     readonly font: Font;
     readonly encoding: EncodingType;

package/ts3.4/es/core/objects/PDFArray.d.ts

@@ -10,7 +10,10 @@ import PDFStream from './PDFStream';
 import PDFString from './PDFString';
 import PDFContext from '../PDFContext';
 import PDFRawStream from './PDFRawStream';
+import { PDFClasses } from '../../api/objects';
 declare class PDFArray extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static withContext: (context: PDFContext) => PDFArray;
     private readonly array;
     private readonly context;

package/ts3.4/es/core/objects/PDFBool.d.ts

@@ -1,5 +1,8 @@
 import PDFObject from './PDFObject';
+import { PDFClasses } from '../../api/objects';
 declare class PDFBool extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static readonly True: PDFBool;
     static readonly False: PDFBool;
     private readonly value;

package/ts3.4/es/core/objects/PDFDict.d.ts

@@ -9,8 +9,11 @@ import PDFRef from './PDFRef';
 import PDFStream from './PDFStream';
 import PDFString from './PDFString';
 import PDFContext from '../PDFContext';
+import { PDFClasses } from '../../api/objects';
 export type DictMap = Map<PDFName, PDFObject>;
 declare class PDFDict extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static withContext: (context: PDFContext) => PDFDict;
     static fromMapWithContext: (map: DictMap, context: PDFContext) => PDFDict;
     readonly context: PDFContext;

package/ts3.4/es/core/objects/PDFHexString.d.ts

@@ -1,5 +1,8 @@
 import PDFObject from './PDFObject';
+import { PDFClasses } from '../../api/objects';
 declare class PDFHexString extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static of: (value: string) => PDFHexString;
     static fromText: (value: string) => PDFHexString;
     static fromBytes: (bytes: Uint8Array) => PDFHexString;

package/ts3.4/es/core/objects/PDFInvalidObject.d.ts

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

package/ts3.4/es/core/objects/PDFName.d.ts

@@ -1,5 +1,8 @@
 import PDFObject from './PDFObject';
+import { PDFClasses } from '../../api/objects';
 declare class PDFName extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static of: (name: string) => PDFName;
     static readonly Length: PDFName;
     static readonly FlateDecode: PDFName;

package/ts3.4/es/core/objects/PDFNull.d.ts

@@ -1,5 +1,8 @@
 import PDFObject from './PDFObject';
+import { PDFClasses } from '../../api/objects';
 declare class PDFNull extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     asNull(): null;
     clone(): PDFNull;
     toString(): string;

package/ts3.4/es/core/objects/PDFNumber.d.ts

@@ -1,5 +1,8 @@
+import { PDFClasses } from '../../api/objects';
 import PDFObject from './PDFObject';
 declare class PDFNumber extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static of: (value: number) => PDFNumber;
     private readonly numberValue;
     private readonly stringValue;

package/ts3.4/es/core/objects/PDFObject.d.ts

@@ -1,5 +1,8 @@
+import { PDFClasses } from '../../api/objects';
 import PDFContext from '../PDFContext';
 declare class PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     registerChange(): void;
     clone(_context?: PDFContext): PDFObject;
     toString(): string;

package/ts3.4/es/core/objects/PDFRawStream.d.ts

@@ -2,7 +2,10 @@ import PDFDict from './PDFDict';
 import PDFStream from './PDFStream';
 import PDFContext from '../PDFContext';
 import { CipherTransform } from '../crypto';
+import { PDFClasses } from '../../api/objects';
 declare class PDFRawStream extends PDFStream {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static of: (dict: PDFDict, contents: Uint8Array, transform?: CipherTransform) => PDFRawStream;
     contents: Uint8Array;
     readonly transform?: CipherTransform;

package/ts3.4/es/core/objects/PDFRef.d.ts

@@ -1,5 +1,8 @@
 import PDFObject from '../objects/PDFObject';
+import { PDFClasses } from '../../api';
 declare class PDFRef extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static of: (objectNumber: number, generationNumber?: number) => PDFRef;
     readonly objectNumber: number;
     readonly generationNumber: number;

package/ts3.4/es/core/objects/PDFStream.d.ts

@@ -1,7 +1,10 @@
 import PDFDict from './PDFDict';
 import PDFObject from './PDFObject';
 import PDFContext from '../PDFContext';
+import { PDFClasses } from '../../api/objects';
 declare class PDFStream extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     readonly dict: PDFDict;
     constructor(dict: PDFDict);
     clone(_context?: PDFContext): PDFStream;

package/ts3.4/es/core/objects/PDFString.d.ts

@@ -1,5 +1,8 @@
 import PDFObject from './PDFObject';
+import { PDFClasses } from '../../api/objects';
 declare class PDFString extends PDFObject {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static of: (value: string) => PDFString;
     static fromDate: (date: Date) => PDFString;
     private readonly value;

package/ts3.4/es/core/structures/PDFCatalog.d.ts

@@ -5,7 +5,10 @@ import PDFPageTree from './PDFPageTree';
 import { PDFAcroForm } from '../acroform';
 import ViewerPreferences from '../interactive/ViewerPreferences';
 import PDFArray from '../objects/PDFArray';
+import { PDFClasses } from '../../api/objects';
 declare class PDFCatalog extends PDFDict {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static withContextAndPages: (context: PDFContext, pages: PDFPageTree | PDFRef) => PDFCatalog;
     static fromMapWithContext: (map: DictMap, context: PDFContext) => PDFCatalog;
     Pages(): PDFPageTree;

package/ts3.4/es/core/structures/PDFContentStream.d.ts

@@ -2,7 +2,10 @@ import PDFDict from '../objects/PDFDict';
 import PDFOperator from '../operators/PDFOperator';
 import PDFContext from '../PDFContext';
 import PDFFlateStream from './PDFFlateStream';
+import { PDFClasses } from '../../api/objects';
 declare class PDFContentStream extends PDFFlateStream {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static of: (dict: PDFDict, operators: PDFOperator[], encode?: boolean) => PDFContentStream;
     private readonly operators;
     private constructor();

package/ts3.4/es/core/structures/PDFObjectStream.d.ts

@@ -2,11 +2,14 @@ import PDFObject from '../objects/PDFObject';
 import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
 import PDFFlateStream from './PDFFlateStream';
+import { PDFClasses } from '../../api/objects';
 export type IndirectObject = [
     PDFRef,
     PDFObject
 ];
 declare class PDFObjectStream extends PDFFlateStream {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static withContextAndObjects: (context: PDFContext, objects: IndirectObject[], encode?: boolean) => PDFObjectStream;
     private readonly objects;
     private readonly offsets;

package/ts3.4/es/core/structures/PDFPageLeaf.d.ts

@@ -1,3 +1,4 @@
+import { PDFClasses } from '../../api/objects';
 import PDFArray from '../objects/PDFArray';
 import PDFDict, { DictMap } from '../objects/PDFDict';
 import PDFName from '../objects/PDFName';
@@ -8,6 +9,8 @@ import PDFStream from '../objects/PDFStream';
 import PDFContext from '../PDFContext';
 import PDFPageTree from './PDFPageTree';
 declare class PDFPageLeaf extends PDFDict {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static readonly InheritableEntries: string[];
     static withContextAndParent: (context: PDFContext, parent: PDFRef) => PDFPageLeaf;
     static fromMapWithContext: (map: DictMap, context: PDFContext, autoNormalizeCTM?: boolean) => PDFPageLeaf;

package/ts3.4/es/core/structures/PDFPageTree.d.ts

@@ -4,8 +4,11 @@ import PDFNumber from '../objects/PDFNumber';
 import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
 import PDFPageLeaf from './PDFPageLeaf';
+import { PDFClasses } from '../../api/objects';
 export type TreeNode = PDFPageTree | PDFPageLeaf;
 declare class PDFPageTree extends PDFDict {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static withContext: (context: PDFContext, parent?: PDFRef) => PDFPageTree;
     static fromMapWithContext: (map: DictMap, context: PDFContext) => PDFPageTree;
     Parent(): PDFPageTree | undefined;

package/ts3.4/es/core/writers/PDFStreamWriter.d.ts

@@ -5,7 +5,10 @@ import PDFObject from '../objects/PDFObject';
 import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
 import PDFWriter from '../writers/PDFWriter';
+import { PDFClasses } from '../../api/objects';
 declare class PDFStreamWriter extends PDFWriter {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static forContext: (context: PDFContext, objectsPerTick: number, encodeStreams?: boolean, objectsPerStream?: number) => PDFStreamWriter;
     static forContextWithSnapshot: (context: PDFContext, objectsPerTick: number, snapshot: DocumentSnapshot, encodeStreams?: boolean, objectsPerStream?: number) => PDFStreamWriter;
     private readonly encodeStreams;

package/ts3.4/es/core/writers/PDFWriter.d.ts

@@ -8,6 +8,7 @@ import PDFObject from '../objects/PDFObject';
 import PDFRef from '../objects/PDFRef';
 import PDFContext from '../PDFContext';
 import PDFSecurity from '../security/PDFSecurity';
+import { PDFClasses } from '../../api/objects';
 export interface SerializationInfo {
     size: number;
     header: PDFHeader;
@@ -20,6 +21,8 @@ export interface SerializationInfo {
     trailer: PDFTrailer;
 }
 declare class PDFWriter {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     static forContext: (context: PDFContext, objectsPerTick: number) => PDFWriter;
     static forContextWithSnapshot: (context: PDFContext, objectsPerTick: number, snapshot: DocumentSnapshot) => PDFWriter;
     protected readonly context: PDFContext;

package/ts3.4/es/utils/elements/Arc.d.ts

@@ -1,7 +1,10 @@
+import { PDFClasses } from '../../api/objects';
 import Circle from './Circle';
 import GraphElement from './GraphElement';
 import Point from './Point';
 export default class Arc extends GraphElement {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     O: Point;
     A: Point;
     B: Point;

package/ts3.4/es/utils/elements/Circle.d.ts

@@ -1,6 +1,9 @@
+import { PDFClasses } from '../../api/objects';
 import GraphElement from './GraphElement';
 import Point from './Point';
 export default class Circle extends GraphElement {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     O: Point;
     r: number;
     constructor(O?: Point, r?: number);

package/ts3.4/es/utils/elements/Ellipse.d.ts

@@ -1,8 +1,11 @@
+import { PDFClasses } from '../../api/objects';
 import { Size } from '../../types';
 import GraphElement from './GraphElement';
 import Point from './Point';
 import Segment from './Segment';
 export default class Ellipse extends GraphElement {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     A: Point;
     B: Point;
     C: Point;

package/ts3.4/es/utils/elements/GraphElement.d.ts

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

package/ts3.4/es/utils/elements/Line.d.ts

@@ -1,7 +1,10 @@
+import { PDFClasses } from '../../api/objects';
 import { Coordinates } from '../../types';
 import GraphElement from './GraphElement';
 import Point from './Point';
 export default class Line extends GraphElement {
+    static className: () => PDFClasses;
+    myClass(): PDFClasses;
     origin(): Point;
     dirVect(): Coordinates;
     A: Point;