@campxdev/pdfme 1.1.0 → 1.2.1

package/dist/types/_vendors/pdf-lib/core/crypto.d.ts

@@ -0,0 +1,95 @@
+import PDFDict from './objects/PDFDict.js';
+import PDFName from './objects/PDFName.js';
+import DecryptStream from './streams/DecryptStream.js';
+import { StreamType } from './streams/Stream.js';
+declare class ARCFourCipher {
+    private s;
+    private a;
+    private b;
+    constructor(key: Uint8Array);
+    encryptBlock(data: Uint8Array): Uint8Array<ArrayBuffer>;
+    decryptBlock(data: Uint8Array): Uint8Array<ArrayBuffer>;
+    encrypt(data: Uint8Array): Uint8Array<ArrayBuffer>;
+}
+declare const calculateMD5: (data: Uint8Array, offset: number, length: number) => Uint8Array<ArrayBuffer>;
+declare const calculateSHA256: (data: Uint8Array, offset: number, length: number) => Uint8Array<ArrayBuffer>;
+declare const calculateSHA512: (data: Uint8Array, offset: number, length: number, mode384?: boolean) => Uint8Array<ArrayBuffer>;
+declare function calculateSHA384(data: Uint8Array, offset: number, length: number): Uint8Array<ArrayBuffer>;
+declare class NullCipher {
+    decryptBlock(data: Uint8Array): Uint8Array<ArrayBufferLike>;
+    encrypt(data: Uint8Array): Uint8Array<ArrayBufferLike>;
+}
+declare class AESBaseCipher {
+    protected _s: Uint8Array;
+    protected _keySize: number;
+    protected _key: Uint8Array;
+    protected _cyclesOfRepetition: number;
+    private _inv_s;
+    private _mix;
+    private _mixCol;
+    buffer: Uint8Array;
+    bufferPosition: number;
+    bufferLength: number;
+    iv: Uint8Array;
+    constructor();
+    _expandKey(_cipherKey: Uint8Array): void;
+    _decrypt(input: Uint8Array, key: Uint8Array): Uint8Array<ArrayBuffer>;
+    _encrypt(input: Uint8Array, key: Uint8Array): Uint8Array<ArrayBuffer>;
+    _decryptBlock2(data: Uint8Array, finalize: boolean): Uint8Array<ArrayBuffer>;
+    decryptBlock(data: Uint8Array, finalize: boolean, iv?: Uint8Array): Uint8Array;
+    encrypt(data: Uint8Array, iv: Uint8Array): Uint8Array<ArrayBuffer>;
+}
+declare class AES128Cipher extends AESBaseCipher {
+    private _rcon;
+    constructor(key: Uint8Array);
+    _expandKey(cipherKey: Uint8Array): Uint8Array<ArrayBuffer>;
+}
+declare class AES256Cipher extends AESBaseCipher {
+    constructor(key: Uint8Array);
+    _expandKey(cipherKey: Uint8Array): Uint8Array<ArrayBuffer>;
+}
+declare class PDF17 {
+    checkOwnerPassword(password: Uint8Array, ownerValidationSalt: Uint8Array, userBytes: Uint8Array, ownerPassword: Uint8Array): boolean;
+    checkUserPassword(password: Uint8Array, userValidationSalt: Uint8Array, userPassword: Uint8Array): boolean;
+    getOwnerKey(password: Uint8Array, ownerKeySalt: Uint8Array, userBytes: Uint8Array, ownerEncryption: Uint8Array): Uint8Array<ArrayBufferLike>;
+    getUserKey(password: Uint8Array, userKeySalt: Uint8Array, userEncryption: Uint8Array): Uint8Array<ArrayBufferLike>;
+}
+declare class PDF20 {
+    calculatePDF20Hash(password: Uint8Array, input: Uint8Array, userBytes: Uint8Array): Uint8Array<ArrayBuffer>;
+    hash(password: Uint8Array, concatBytes: Uint8Array, userBytes: Uint8Array): Uint8Array<ArrayBuffer>;
+    checkOwnerPassword(password: Uint8Array, ownerValidationSalt: Uint8Array, userBytes: Uint8Array, ownerPassword: Uint8Array): boolean;
+    checkUserPassword(password: Uint8Array, userValidationSalt: Uint8Array, userPassword: Uint8Array): boolean;
+    getOwnerKey(password: Uint8Array, ownerKeySalt: Uint8Array, userBytes: Uint8Array, ownerEncryption: Uint8Array): Uint8Array<ArrayBufferLike>;
+    getUserKey(password: Uint8Array, userKeySalt: Uint8Array, userEncryption: Uint8Array): Uint8Array<ArrayBufferLike>;
+}
+type Cipher = ARCFourCipher | NullCipher | AES128Cipher | AES256Cipher;
+declare class CipherTransform {
+    private StringCipherConstructor;
+    private StreamCipherConstructor;
+    constructor(stringCipherConstructor: () => Cipher, streamCipherConstructor: () => Cipher);
+    createStream(stream: StreamType, length: number): DecryptStream;
+    decryptString(s: string): string;
+    decryptBytes(d: Uint8Array): Uint8Array<ArrayBufferLike>;
+    encryptString(s: string): string;
+}
+declare class CipherTransformFactory {
+    encryptMetadata: boolean;
+    encryptionKey: Uint8Array;
+    algorithm: number;
+    filterName: string;
+    dict: PDFDict;
+    cf: PDFDict;
+    stmf: PDFName;
+    strf: PDFName;
+    eff: PDFName;
+    private defaultPasswordBytes;
+    private identityName;
+    constructor(dict: PDFDict, fileIdBytes: Uint8Array, password?: string);
+    createCipherTransform(num: number, gen: number): CipherTransform;
+    createEncryptionKey20(revision: number, password: Uint8Array | undefined, ownerPassword: Uint8Array, ownerValidationSalt: Uint8Array, ownerKeySalt: Uint8Array, uBytes: Uint8Array, userPassword: Uint8Array, userValidationSalt: Uint8Array, userKeySalt: Uint8Array, ownerEncryption: Uint8Array, userEncryption: Uint8Array, _perms: Uint8Array): Uint8Array<ArrayBufferLike> | null;
+    prepareKeyData(fileId: Uint8Array, password: Uint8Array | undefined, ownerPassword: Uint8Array, userPassword: Uint8Array, flags: number, revision: number, keyLength: number, encryptMetadata: boolean): Uint8Array<ArrayBuffer> | null;
+    decodeUserPassword(password: Uint8Array, ownerPassword: Uint8Array, revision: number, keyLength: number): Uint8Array<ArrayBufferLike>;
+    buildObjectKey(num: number, gen: number, encryptionKey: Uint8Array, isAes?: boolean): Uint8Array<ArrayBuffer>;
+    buildCipherConstructor(cf: PDFDict, name: PDFName, num: number, gen: number, key: Uint8Array): (() => NullCipher) | (() => AES256Cipher);
+}
+export { AES128Cipher, AES256Cipher, ARCFourCipher, calculateMD5, calculateSHA256, calculateSHA384, calculateSHA512, CipherTransformFactory, CipherTransform, PDF17, PDF20, };

package/dist/types/_vendors/pdf-lib/core/document/PDFCrossRefSection.d.ts

@@ -0,0 +1,27 @@
+import PDFRef from '../objects/PDFRef';
+export interface Entry {
+    ref: PDFRef;
+    offset: number;
+    deleted: boolean;
+}
+/**
+ * Entries should be added using the [[addEntry]] and [[addDeletedEntry]]
+ * methods **in order of ascending object number**.
+ */
+declare class PDFCrossRefSection {
+    static create: () => PDFCrossRefSection;
+    static createEmpty: () => PDFCrossRefSection;
+    private subsections;
+    private chunkIdx;
+    private chunkLength;
+    private constructor();
+    addEntry(ref: PDFRef, offset: number): void;
+    addDeletedEntry(ref: PDFRef, nextFreeObjectNumber: number): void;
+    toString(): string;
+    sizeInBytes(): number;
+    copyBytesInto(buffer: Uint8Array, offset: number): number;
+    private copySubsectionsIntoBuffer;
+    private copyEntriesIntoBuffer;
+    private append;
+}
+export default PDFCrossRefSection;

package/dist/types/_vendors/pdf-lib/core/document/PDFHeader.d.ts

@@ -0,0 +1,10 @@
+declare class PDFHeader {
+    static forVersion: (major: number, minor: number) => PDFHeader;
+    private readonly major;
+    private readonly minor;
+    private constructor();
+    toString(): string;
+    sizeInBytes(): number;
+    copyBytesInto(buffer: Uint8Array, offset: number): number;
+}
+export default PDFHeader;

package/dist/types/_vendors/pdf-lib/core/document/PDFTrailer.d.ts

@@ -0,0 +1,9 @@
+declare class PDFTrailer {
+    static forLastCrossRefSectionOffset: (offset: number) => PDFTrailer;
+    private readonly lastXRefOffset;
+    private constructor();
+    toString(): string;
+    sizeInBytes(): number;
+    copyBytesInto(buffer: Uint8Array, offset: number): number;
+}
+export default PDFTrailer;

package/dist/types/_vendors/pdf-lib/core/document/PDFTrailerDict.d.ts

@@ -0,0 +1,10 @@
+import PDFDict from '../objects/PDFDict';
+declare class PDFTrailerDict {
+    static of: (dict: PDFDict) => PDFTrailerDict;
+    readonly dict: PDFDict;
+    private constructor();
+    toString(): string;
+    sizeInBytes(): number;
+    copyBytesInto(buffer: Uint8Array, offset: number): number;
+}
+export default PDFTrailerDict;

package/dist/types/_vendors/pdf-lib/core/embedders/CMap.d.ts

@@ -0,0 +1,3 @@
+import { Glyph } from '../../types/fontkit';
+/** `glyphs` should be an array of unique glyphs */
+export declare const createCmap: (glyphs: Glyph[], glyphId: (g?: Glyph) => number) => string;

package/dist/types/_vendors/pdf-lib/core/embedders/CustomFontEmbedder.d.ts

@@ -0,0 +1,44 @@
+import { Font, Fontkit, Glyph, TypeFeatures } from '../../types/fontkit';
+import PDFHexString from '../objects/PDFHexString';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import { Cache } from '../../utils';
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/devongovett/pdfkit/blob/e71edab0dd4657b5a767804ba86c94c58d01fbca/lib/image/jpeg.coffee
+ */
+declare class CustomFontEmbedder {
+    static for(fontkit: Fontkit, fontData: Uint8Array, customName?: string, fontFeatures?: TypeFeatures): Promise<CustomFontEmbedder>;
+    readonly font: Font;
+    readonly scale: number;
+    readonly fontData: Uint8Array;
+    readonly fontName: string;
+    readonly customName: string | undefined;
+    readonly fontFeatures: TypeFeatures | undefined;
+    protected baseFontName: string;
+    protected glyphCache: Cache<Glyph[]>;
+    protected constructor(font: Font, fontData: Uint8Array, customName?: string, fontFeatures?: TypeFeatures);
+    /**
+     * Encode the JavaScript string into this font. (JavaScript encodes strings in
+     * Unicode, but embedded fonts use their own custom encodings)
+     */
+    encodeText(text: string): PDFHexString;
+    widthOfTextAtSize(text: string, size: number): number;
+    heightOfFontAtSize(size: number, options?: {
+        descender?: boolean;
+    }): number;
+    sizeOfFontAtHeight(height: number): number;
+    embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef>;
+    protected embedFontDict(context: PDFContext, ref?: PDFRef): Promise<PDFRef>;
+    protected isCFF(): boolean;
+    protected embedCIDFontDict(context: PDFContext): Promise<PDFRef>;
+    protected embedFontDescriptor(context: PDFContext): Promise<PDFRef>;
+    protected serializeFont(): Promise<Uint8Array>;
+    protected embedFontStream(context: PDFContext): Promise<PDFRef>;
+    protected embedUnicodeCmap(context: PDFContext): PDFRef;
+    protected glyphId(glyph?: Glyph): number;
+    protected computeWidths(): (number | number[])[];
+    private allGlyphsInFontSortedById;
+}
+export default CustomFontEmbedder;

package/dist/types/_vendors/pdf-lib/core/embedders/CustomFontSubsetEmbedder.d.ts

@@ -0,0 +1,20 @@
+import { Fontkit, Glyph, TypeFeatures } from '../../types/fontkit';
+import CustomFontEmbedder from './CustomFontEmbedder';
+import PDFHexString from '../objects/PDFHexString';
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/devongovett/pdfkit/blob/e71edab0dd4657b5a767804ba86c94c58d01fbca/lib/image/jpeg.coffee
+ */
+declare class CustomFontSubsetEmbedder extends CustomFontEmbedder {
+    static for(fontkit: Fontkit, fontData: Uint8Array, customFontName?: string, fontFeatures?: TypeFeatures): Promise<CustomFontSubsetEmbedder>;
+    private readonly subset;
+    private readonly glyphs;
+    private readonly glyphIdMap;
+    private constructor();
+    encodeText(text: string): PDFHexString;
+    protected isCFF(): boolean;
+    protected glyphId(glyph?: Glyph): number;
+    protected serializeFont(): Promise<Uint8Array>;
+}
+export default CustomFontSubsetEmbedder;

package/dist/types/_vendors/pdf-lib/core/embedders/FileEmbedder.d.ts

@@ -0,0 +1,33 @@
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+/**
+ * From the PDF-A3 specification, section **3.1. Requirements - General**.
+ * See:
+ * * https://www.pdfa.org/wp-content/uploads/2018/10/PDF20_AN002-AF.pdf
+ */
+export declare enum AFRelationship {
+    Source = "Source",
+    Data = "Data",
+    Alternative = "Alternative",
+    Supplement = "Supplement",
+    EncryptedPayload = "EncryptedPayload",
+    FormData = "EncryptedPayload",
+    Schema = "Schema",
+    Unspecified = "Unspecified"
+}
+export interface EmbeddedFileOptions {
+    mimeType?: string;
+    description?: string;
+    creationDate?: Date;
+    modificationDate?: Date;
+    afRelationship?: AFRelationship;
+}
+declare class FileEmbedder {
+    static for(bytes: Uint8Array, fileName: string, options?: EmbeddedFileOptions): FileEmbedder;
+    private readonly fileData;
+    readonly fileName: string;
+    readonly options: EmbeddedFileOptions;
+    private constructor();
+    embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef>;
+}
+export default FileEmbedder;

package/dist/types/_vendors/pdf-lib/core/embedders/FontFlags.d.ts

@@ -0,0 +1,13 @@
+import { Font } from '../../types/fontkit';
+export interface FontFlagOptions {
+    fixedPitch?: boolean;
+    serif?: boolean;
+    symbolic?: boolean;
+    script?: boolean;
+    nonsymbolic?: boolean;
+    italic?: boolean;
+    allCap?: boolean;
+    smallCap?: boolean;
+    forceBold?: boolean;
+}
+export declare const deriveFontFlags: (font: Font) => number;

package/dist/types/_vendors/pdf-lib/core/embedders/JavaScriptEmbedder.d.ts

@@ -0,0 +1,10 @@
+import PDFContext from '../PDFContext';
+import PDFRef from '../objects/PDFRef';
+declare class JavaScriptEmbedder {
+    static for(script: string, scriptName: string): JavaScriptEmbedder;
+    private readonly script;
+    readonly scriptName: string;
+    private constructor();
+    embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef>;
+}
+export default JavaScriptEmbedder;

package/dist/types/_vendors/pdf-lib/core/embedders/JpegEmbedder.d.ts

@@ -0,0 +1,23 @@
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+declare enum ColorSpace {
+    DeviceGray = "DeviceGray",
+    DeviceRGB = "DeviceRGB",
+    DeviceCMYK = "DeviceCMYK"
+}
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/foliojs/pdfkit/blob/a6af76467ce06bd6a2af4aa7271ccac9ff152a7d/lib/image/jpeg.js
+ */
+declare class JpegEmbedder {
+    static for(imageData: Uint8Array): Promise<JpegEmbedder>;
+    readonly bitsPerComponent: number;
+    readonly height: number;
+    readonly width: number;
+    readonly colorSpace: ColorSpace;
+    private readonly imageData;
+    private constructor();
+    embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef>;
+}
+export default JpegEmbedder;

package/dist/types/_vendors/pdf-lib/core/embedders/PDFPageEmbedder.d.ts

@@ -0,0 +1,37 @@
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFPageLeaf from '../structures/PDFPageLeaf';
+import { TransformationMatrix } from '../../types/matrix';
+/**
+ * Represents a page bounding box.
+ * Usually `left` and `bottom` are 0 and right, top are equal
+ * to width, height if you want to clip to the whole page.
+ *
+ *       y
+ *       ^
+ *       | +--------+ (width,height)
+ *       | |        |
+ *       | |  Page  |
+ *       | |        |
+ *       | |        |
+ * (0,0) | +--------+
+ *       +----------> x
+ */
+export interface PageBoundingBox {
+    left: number /** The left of the bounding box */;
+    bottom: number /** The bottom of the bounding box */;
+    right: number /** The right of the bounding box */;
+    top: number /** The top of the bounding box */;
+}
+declare class PDFPageEmbedder {
+    static for(page: PDFPageLeaf, boundingBox?: PageBoundingBox, transformationMatrix?: TransformationMatrix): Promise<PDFPageEmbedder>;
+    readonly width: number;
+    readonly height: number;
+    readonly boundingBox: PageBoundingBox;
+    readonly transformationMatrix: TransformationMatrix;
+    private readonly page;
+    private constructor();
+    embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef>;
+    private decodeContents;
+}
+export default PDFPageEmbedder;

package/dist/types/_vendors/pdf-lib/core/embedders/PngEmbedder.d.ts

@@ -0,0 +1,19 @@
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/devongovett/pdfkit/blob/e71edab0dd4657b5a767804ba86c94c58d01fbca/lib/image/png.coffee
+ */
+declare class PngEmbedder {
+    static for(imageData: Uint8Array): Promise<PngEmbedder>;
+    readonly bitsPerComponent: number;
+    readonly height: number;
+    readonly width: number;
+    readonly colorSpace: 'DeviceRGB';
+    private readonly image;
+    private constructor();
+    embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef>;
+    private embedAlphaChannel;
+}
+export default PngEmbedder;

package/dist/types/_vendors/pdf-lib/core/embedders/StandardFontEmbedder.d.ts

@@ -0,0 +1,36 @@
+import { Font, FontNames, EncodingType } from '@pdf-lib/standard-fonts';
+import PDFHexString from '../objects/PDFHexString';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+export interface Glyph {
+    code: number;
+    name: string;
+}
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/foliojs/pdfkit/blob/f91bdd61c164a72ea06be1a43dc0a412afc3925f/lib/font/afm.coffee
+ */
+declare class StandardFontEmbedder {
+    static for: (fontName: FontNames, customName?: string) => StandardFontEmbedder;
+    readonly font: Font;
+    readonly encoding: EncodingType;
+    readonly fontName: string;
+    readonly customName: string | undefined;
+    private constructor();
+    /**
+     * Encode the JavaScript string into this font. (JavaScript encodes strings in
+     * Unicode, but standard fonts use either WinAnsi, ZapfDingbats, or Symbol
+     * encodings)
+     */
+    encodeText(text: string): PDFHexString;
+    widthOfTextAtSize(text: string, size: number): number;
+    heightOfFontAtSize(size: number, options?: {
+        descender?: boolean;
+    }): number;
+    sizeOfFontAtHeight(height: number): number;
+    embedIntoContext(context: PDFContext, ref?: PDFRef): PDFRef;
+    private widthOfGlyph;
+    private encodeTextAsGlyphs;
+}
+export default StandardFontEmbedder;

package/dist/types/_vendors/pdf-lib/core/errors.d.ts

@@ -0,0 +1,91 @@
+import PDFObject from './objects/PDFObject';
+export declare class MethodNotImplementedError extends Error {
+    constructor(className: string, methodName: string);
+}
+export declare class PrivateConstructorError extends Error {
+    constructor(className: string);
+}
+export declare class UnexpectedObjectTypeError extends Error {
+    constructor(expected: any | any[], actual: any);
+}
+export declare class UnsupportedEncodingError extends Error {
+    constructor(encoding: string);
+}
+export declare class ReparseError extends Error {
+    constructor(className: string, methodName: string);
+}
+export declare class MissingCatalogError extends Error {
+    constructor(ref?: PDFObject);
+}
+export declare class MissingPageContentsEmbeddingError extends Error {
+    constructor();
+}
+export declare class UnrecognizedStreamTypeError extends Error {
+    constructor(stream: any);
+}
+export declare class PageEmbeddingMismatchedContextError extends Error {
+    constructor();
+}
+export declare class PDFArrayIsNotRectangleError extends Error {
+    constructor(size: number);
+}
+export declare class InvalidPDFDateStringError extends Error {
+    constructor(value: string);
+}
+export declare class InvalidTargetIndexError extends Error {
+    constructor(targetIndex: number, Count: number);
+}
+export declare class CorruptPageTreeError extends Error {
+    constructor(targetIndex: number, operation: string);
+}
+export declare class IndexOutOfBoundsError extends Error {
+    constructor(index: number, min: number, max: number);
+}
+export declare class InvalidAcroFieldValueError extends Error {
+    constructor();
+}
+export declare class MultiSelectValueError extends Error {
+    constructor();
+}
+export declare class MissingDAEntryError extends Error {
+    constructor(fieldName: string);
+}
+export declare class MissingTfOperatorError extends Error {
+    constructor(fieldName: string);
+}
+/***** Parser Errors ******/
+export interface Position {
+    line: number;
+    column: number;
+    offset: number;
+}
+export declare class NumberParsingError extends Error {
+    constructor(pos: Position, value: string);
+}
+export declare class PDFParsingError extends Error {
+    constructor(pos: Position, details: string);
+}
+export declare class NextByteAssertionError extends PDFParsingError {
+    constructor(pos: Position, expectedByte: number, actualByte: number);
+}
+export declare class PDFObjectParsingError extends PDFParsingError {
+    constructor(pos: Position, byte: number);
+}
+export declare class PDFInvalidObjectParsingError extends PDFParsingError {
+    constructor(pos: Position);
+}
+export declare class PDFStreamParsingError extends PDFParsingError {
+    constructor(pos: Position);
+}
+export declare class UnbalancedParenthesisError extends PDFParsingError {
+    constructor(pos: Position);
+}
+export declare class StalledParserError extends PDFParsingError {
+    constructor(pos: Position);
+}
+export declare class MissingPDFHeaderError extends PDFParsingError {
+    constructor(pos: Position);
+}
+export declare class MissingKeywordError extends PDFParsingError {
+    constructor(pos: Position, keyword: number[]);
+}

package/dist/types/_vendors/pdf-lib/core/index.d.ts

@@ -0,0 +1,47 @@
+export * from './errors';
+export { default as CharCodes } from './syntax/CharCodes';
+export { default as PDFContext } from './PDFContext';
+export { default as PDFObjectCopier } from './PDFObjectCopier';
+export { default as PDFWriter } from './writers/PDFWriter';
+export { default as PDFStreamWriter } from './writers/PDFStreamWriter';
+export { default as PDFHeader } from './document/PDFHeader';
+export { default as PDFTrailer } from './document/PDFTrailer';
+export { default as PDFTrailerDict } from './document/PDFTrailerDict';
+export { default as PDFCrossRefSection } from './document/PDFCrossRefSection';
+export { default as StandardFontEmbedder } from './embedders/StandardFontEmbedder';
+export { default as CustomFontEmbedder } from './embedders/CustomFontEmbedder';
+export { default as CustomFontSubsetEmbedder } from './embedders/CustomFontSubsetEmbedder';
+export { default as FileEmbedder, AFRelationship } from './embedders/FileEmbedder';
+export { default as JpegEmbedder } from './embedders/JpegEmbedder';
+export { default as PngEmbedder } from './embedders/PngEmbedder';
+export { default as PDFPageEmbedder, type PageBoundingBox } from './embedders/PDFPageEmbedder';
+export { default as ViewerPreferences, NonFullScreenPageMode, ReadingDirection, PrintScaling, Duplex, } from './interactive/ViewerPreferences';
+export { default as PDFObject } from './objects/PDFObject';
+export { default as PDFBool } from './objects/PDFBool';
+export { default as PDFNumber } from './objects/PDFNumber';
+export { default as PDFString } from './objects/PDFString';
+export { default as PDFHexString } from './objects/PDFHexString';
+export { default as PDFName } from './objects/PDFName';
+export { default as PDFNull } from './objects/PDFNull';
+export { default as PDFArray } from './objects/PDFArray';
+export { default as PDFDict } from './objects/PDFDict';
+export { default as PDFRef } from './objects/PDFRef';
+export { default as PDFInvalidObject } from './objects/PDFInvalidObject';
+export { default as PDFStream } from './objects/PDFStream';
+export { default as PDFRawStream } from './objects/PDFRawStream';
+export { default as PDFCatalog } from './structures/PDFCatalog';
+export { default as PDFContentStream } from './structures/PDFContentStream';
+export { default as PDFCrossRefStream } from './structures/PDFCrossRefStream';
+export { default as PDFObjectStream } from './structures/PDFObjectStream';
+export { default as PDFPageTree } from './structures/PDFPageTree';
+export { default as PDFPageLeaf } from './structures/PDFPageLeaf';
+export { default as PDFFlateStream } from './structures/PDFFlateStream';
+export { default as PDFOperator } from './operators/PDFOperator';
+export { default as PDFOperatorNames } from './operators/PDFOperatorNames';
+export { default as PDFObjectParser } from './parser/PDFObjectParser';
+export { default as PDFObjectStreamParser } from './parser/PDFObjectStreamParser';
+export { default as PDFParser } from './parser/PDFParser';
+export { default as PDFXRefStreamParser } from './parser/PDFXRefStreamParser';
+export { decodePDFRawStream } from './streams/decode';
+export * from './annotation';
+export * from './acroform';