@pdfme/pdf-lib 1.18.4 → 5.4.0-dev.42

package/dist/types/src/core/operators/PDFOperator.d.ts

@@ -0,0 +1,19 @@
+import PDFArray from '../objects/PDFArray';
+import PDFHexString from '../objects/PDFHexString';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFString from '../objects/PDFString';
+import PDFOperatorNames from './PDFOperatorNames';
+import PDFContext from '../PDFContext';
+export type PDFOperatorArg = string | PDFName | PDFArray | PDFNumber | PDFString | PDFHexString;
+declare class PDFOperator {
+    static of: (name: PDFOperatorNames, args?: PDFOperatorArg[]) => PDFOperator;
+    private readonly name;
+    private readonly args;
+    private constructor();
+    clone(context?: PDFContext): PDFOperator;
+    toString(): string;
+    sizeInBytes(): number;
+    copyBytesInto(buffer: Uint8Array, offset: number): number;
+}
+export default PDFOperator;

package/dist/types/src/core/operators/PDFOperatorNames.d.ts

@@ -0,0 +1,76 @@
+declare enum PDFOperatorNames {
+    NonStrokingColor = "sc",
+    NonStrokingColorN = "scn",
+    NonStrokingColorRgb = "rg",
+    NonStrokingColorGray = "g",
+    NonStrokingColorCmyk = "k",
+    NonStrokingColorspace = "cs",
+    StrokingColor = "SC",
+    StrokingColorN = "SCN",
+    StrokingColorRgb = "RG",
+    StrokingColorGray = "G",
+    StrokingColorCmyk = "K",
+    StrokingColorspace = "CS",
+    BeginMarkedContentSequence = "BDC",
+    BeginMarkedContent = "BMC",
+    EndMarkedContent = "EMC",
+    MarkedContentPointWithProps = "DP",
+    MarkedContentPoint = "MP",
+    DrawObject = "Do",
+    ConcatTransformationMatrix = "cm",
+    PopGraphicsState = "Q",
+    PushGraphicsState = "q",
+    SetFlatness = "i",
+    SetGraphicsStateParams = "gs",
+    SetLineCapStyle = "J",
+    SetLineDashPattern = "d",
+    SetLineJoinStyle = "j",
+    SetLineMiterLimit = "M",
+    SetLineWidth = "w",
+    SetTextMatrix = "Tm",
+    SetRenderingIntent = "ri",
+    AppendRectangle = "re",
+    BeginInlineImage = "BI",
+    BeginInlineImageData = "ID",
+    EndInlineImage = "EI",
+    ClipEvenOdd = "W*",
+    ClipNonZero = "W",
+    CloseAndStroke = "s",
+    CloseFillEvenOddAndStroke = "b*",
+    CloseFillNonZeroAndStroke = "b",
+    ClosePath = "h",
+    AppendBezierCurve = "c",
+    CurveToReplicateFinalPoint = "y",
+    CurveToReplicateInitialPoint = "v",
+    EndPath = "n",
+    FillEvenOddAndStroke = "B*",
+    FillEvenOdd = "f*",
+    FillNonZeroAndStroke = "B",
+    FillNonZero = "f",
+    LegacyFillNonZero = "F",
+    LineTo = "l",
+    MoveTo = "m",
+    ShadingFill = "sh",
+    StrokePath = "S",
+    BeginText = "BT",
+    EndText = "ET",
+    MoveText = "Td",
+    MoveTextSetLeading = "TD",
+    NextLine = "T*",
+    SetCharacterSpacing = "Tc",
+    SetFontAndSize = "Tf",
+    SetTextHorizontalScaling = "Tz",
+    SetTextLineHeight = "TL",
+    SetTextRenderingMode = "Tr",
+    SetTextRise = "Ts",
+    SetWordSpacing = "Tw",
+    ShowText = "Tj",
+    ShowTextAdjusted = "TJ",
+    ShowTextLine = "'",// tslint:disable-line quotemark
+    ShowTextLineAndSpace = "\"",
+    Type3D0 = "d0",
+    Type3D1 = "d1",
+    BeginCompatibilitySection = "BX",
+    EndCompatibilitySection = "EX"
+}
+export default PDFOperatorNames;

package/dist/types/src/core/parser/BaseParser.d.ts

@@ -0,0 +1,14 @@
+import ByteStream from '../parser/ByteStream';
+declare class BaseParser {
+    protected readonly bytes: ByteStream;
+    protected readonly capNumbers: boolean;
+    constructor(bytes: ByteStream, capNumbers?: boolean);
+    protected parseRawInt(): number;
+    protected parseRawNumber(): number;
+    protected skipWhitespace(): void;
+    protected skipLine(): void;
+    protected skipComment(): boolean;
+    protected skipWhitespaceAndComments(): void;
+    protected matchKeyword(keyword: number[]): boolean;
+}
+export default BaseParser;

package/dist/types/src/core/parser/ByteStream.d.ts

@@ -0,0 +1,26 @@
+import PDFRawStream from '../objects/PDFRawStream';
+declare class ByteStream {
+    static of: (bytes: Uint8Array) => ByteStream;
+    static fromPDFRawStream: (rawStream: PDFRawStream) => ByteStream;
+    private readonly bytes;
+    private readonly length;
+    private idx;
+    private line;
+    private column;
+    constructor(bytes: Uint8Array);
+    moveTo(offset: number): void;
+    next(): number;
+    assertNext(expected: number): number;
+    peek(): number;
+    peekAhead(steps: number): number;
+    peekAt(offset: number): number;
+    done(): boolean;
+    offset(): number;
+    slice(start: number, end: number): Uint8Array;
+    position(): {
+        line: number;
+        column: number;
+        offset: number;
+    };
+}
+export default ByteStream;

package/dist/types/src/core/parser/PDFObjectParser.d.ts

@@ -0,0 +1,31 @@
+import { Position } from '../errors';
+import PDFArray from '../objects/PDFArray';
+import PDFDict from '../objects/PDFDict';
+import PDFHexString from '../objects/PDFHexString';
+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 PDFString from '../objects/PDFString';
+import BaseParser from './BaseParser';
+import ByteStream from './ByteStream';
+import PDFContext from '../PDFContext';
+import { CipherTransformFactory } from '../crypto';
+declare class PDFObjectParser extends BaseParser {
+    static forBytes: (bytes: Uint8Array, context: PDFContext, capNumbers?: boolean) => PDFObjectParser;
+    static forByteStream: (byteStream: ByteStream, context: PDFContext, capNumbers?: boolean) => PDFObjectParser;
+    protected readonly context: PDFContext;
+    private readonly cryptoFactory?;
+    constructor(byteStream: ByteStream, context: PDFContext, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory);
+    parseObject(ref?: PDFRef): PDFObject;
+    protected parseNumberOrRef(): PDFNumber | PDFRef;
+    protected parseHexString(ref?: PDFRef): PDFHexString;
+    protected parseString(ref?: PDFRef): PDFString;
+    protected parseName(): PDFName;
+    protected parseArray(ref?: PDFRef): PDFArray;
+    protected parseDict(ref?: PDFRef): PDFDict;
+    protected parseDictOrStream(ref?: PDFRef): PDFDict | PDFStream;
+    protected findEndOfStreamFallback(startPos: Position): number;
+}
+export default PDFObjectParser;

package/dist/types/src/core/parser/PDFObjectStreamParser.d.ts

@@ -0,0 +1,13 @@
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFObjectParser from './PDFObjectParser';
+declare class PDFObjectStreamParser extends PDFObjectParser {
+    static forStream: (rawStream: PDFRawStream, shouldWaitForTick?: () => boolean) => PDFObjectStreamParser;
+    private alreadyParsed;
+    private readonly shouldWaitForTick;
+    private readonly firstOffset;
+    private readonly objectCount;
+    constructor(rawStream: PDFRawStream, shouldWaitForTick?: () => boolean);
+    parseIntoContext(): Promise<void>;
+    private parseOffsetsAndObjectNumbers;
+}
+export default PDFObjectStreamParser;

package/dist/types/src/core/parser/PDFParser.d.ts

@@ -0,0 +1,46 @@
+import PDFObjectParser from './PDFObjectParser';
+import PDFContext from '../PDFContext';
+import { CipherTransformFactory } from '../crypto';
+declare class PDFParser extends PDFObjectParser {
+    static forBytesWithOptions: (pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory) => PDFParser;
+    private readonly objectsPerTick;
+    private readonly throwOnInvalidObject;
+    private alreadyParsed;
+    private parsedObjects;
+    constructor(pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory);
+    parseDocument(): Promise<PDFContext>;
+    private maybeRecoverRoot;
+    private parseHeader;
+    private parseIndirectObjectHeader;
+    private matchIndirectObjectHeader;
+    private shouldWaitForTick;
+    private parseIndirectObject;
+    private tryToParseInvalidIndirectObject;
+    private parseIndirectObjects;
+    private maybeParseCrossRefSection;
+    private maybeParseTrailerDict;
+    private maybeParseTrailer;
+    private parseDocumentSection;
+    /**
+     * This operation is not necessary for valid PDF files. But some invalid PDFs
+     * contain jibberish in between indirect objects. This method is designed to
+     * skip past that jibberish, should it exist, until it reaches the next
+     * indirect object header, an xref table section, or the file trailer.
+     */
+    private skipJibberish;
+    /**
+     * Skips the binary comment following a PDF header. The specification
+     * defines this binary comment (section 7.5.2 File Header) as a sequence of 4
+     * or more bytes that are 128 or greater, and which are preceded by a "%".
+     *
+     * This would imply that to strip out this binary comment, we could check for
+     * a sequence of bytes starting with "%", and remove all subsequent bytes that
+     * are 128 or greater. This works for many documents that properly comply with
+     * the spec. But in the wild, there are PDFs that omit the leading "%", and
+     * include bytes that are less than 128 (e.g. 0 or 1). So in order to parse
+     * these headers correctly, we just throw out all bytes leading up to the
+     * first indirect object header.
+     */
+    private skipBinaryHeaderComment;
+}
+export default PDFParser;

package/dist/types/src/core/parser/PDFXRefStreamParser.d.ts

@@ -0,0 +1,21 @@
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFRef from '../objects/PDFRef';
+export interface Entry {
+    ref: PDFRef;
+    offset: number;
+    deleted: boolean;
+    inObjectStream: boolean;
+}
+declare class PDFXRefStreamParser {
+    static forStream: (rawStream: PDFRawStream) => PDFXRefStreamParser;
+    private alreadyParsed;
+    private readonly dict;
+    private readonly context;
+    private readonly bytes;
+    private readonly subsections;
+    private readonly byteWidths;
+    constructor(rawStream: PDFRawStream);
+    parseIntoContext(): Entry[];
+    private parseEntries;
+}
+export default PDFXRefStreamParser;

package/dist/types/src/core/streams/Ascii85Stream.d.ts

@@ -0,0 +1,9 @@
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
+declare class Ascii85Stream extends DecodeStream {
+    private stream;
+    private input;
+    constructor(stream: StreamType, maybeLength?: number);
+    protected readBlock(): void;
+}
+export default Ascii85Stream;

package/dist/types/src/core/streams/AsciiHexStream.d.ts

@@ -0,0 +1,9 @@
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
+declare class AsciiHexStream extends DecodeStream {
+    private stream;
+    private firstDigit;
+    constructor(stream: StreamType, maybeLength?: number);
+    protected readBlock(): void;
+}
+export default AsciiHexStream;

package/dist/types/src/core/streams/DecodeStream.d.ts

@@ -0,0 +1,26 @@
+import Stream, { StreamType } from './Stream';
+/**
+ * Super class for the decoding streams
+ */
+declare class DecodeStream implements StreamType {
+    protected bufferLength: number;
+    protected buffer: Uint8Array;
+    protected eof: boolean;
+    private pos;
+    private minBufferLength;
+    constructor(maybeMinBufferLength?: number);
+    get isEmpty(): boolean;
+    getByte(): number;
+    getUint16(): number;
+    getInt32(): number;
+    getBytes(length: number, forceClamped?: boolean): Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBuffer>;
+    peekByte(): number;
+    peekBytes(length: number, forceClamped?: boolean): Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBuffer>;
+    skip(n: number): void;
+    reset(): void;
+    makeSubStream(start: number, length: number): Stream;
+    decode(): Uint8Array;
+    protected readBlock(): void;
+    protected ensureBuffer(requested: number): Uint8Array<ArrayBufferLike>;
+}
+export default DecodeStream;

package/dist/types/src/core/streams/DecryptStream.d.ts

@@ -0,0 +1,12 @@
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
+type DecryptFnType = (arg1: Uint8Array | Uint8ClampedArray, arg2: boolean) => Uint8Array;
+declare class DecryptStream extends DecodeStream {
+    private stream;
+    private initialized;
+    private nextChunk;
+    private decrypt;
+    constructor(stream: StreamType, decrypt: DecryptFnType, maybeLength?: number);
+    readBlock(): void;
+}
+export default DecryptStream;

package/dist/types/src/core/streams/FlateStream.d.ts

@@ -0,0 +1,13 @@
+import DecodeStream from '../../core/streams/DecodeStream';
+import { StreamType } from '../../core/streams/Stream';
+declare class FlateStream extends DecodeStream {
+    private stream;
+    private codeSize;
+    private codeBuf;
+    constructor(stream: StreamType, maybeLength?: number);
+    protected readBlock(): void;
+    private getBits;
+    private getCode;
+    private generateHuffmanTable;
+}
+export default FlateStream;

package/dist/types/src/core/streams/LZWStream.d.ts

@@ -0,0 +1,12 @@
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
+declare class LZWStream extends DecodeStream {
+    private stream;
+    private cachedData;
+    private bitsCached;
+    private lzwState?;
+    constructor(stream: StreamType, maybeLength: number | undefined, earlyChange: 0 | 1);
+    protected readBlock(): void;
+    private readBits;
+}
+export default LZWStream;

package/dist/types/src/core/streams/RunLengthStream.d.ts

@@ -0,0 +1,8 @@
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
+declare class RunLengthStream extends DecodeStream {
+    private stream;
+    constructor(stream: StreamType, maybeLength?: number);
+    protected readBlock(): void;
+}
+export default RunLengthStream;

package/dist/types/src/core/streams/Stream.d.ts

@@ -0,0 +1,34 @@
+export interface StreamType {
+    isEmpty: boolean;
+    getByte(): number;
+    getUint16(): number;
+    getInt32(): number;
+    getBytes(length: number, forceClamped?: boolean): Uint8Array | Uint8ClampedArray;
+    peekByte(): number;
+    peekBytes(length: number, forceClamped?: boolean): Uint8Array | Uint8ClampedArray;
+    skip(n: number): void;
+    reset(): void;
+    makeSubStream(start: number, length: number): StreamType;
+    decode(): Uint8Array;
+}
+declare class Stream implements StreamType {
+    private bytes;
+    private start;
+    private pos;
+    private end;
+    constructor(buffer: Uint8Array, start?: number, length?: number);
+    get length(): number;
+    get isEmpty(): boolean;
+    getByte(): number;
+    getUint16(): number;
+    getInt32(): number;
+    getBytes(length: number, forceClamped?: boolean): Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBuffer>;
+    peekByte(): number;
+    peekBytes(length: number, forceClamped?: boolean): Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBuffer>;
+    skip(n: number): void;
+    reset(): void;
+    moveStart(): void;
+    makeSubStream(start: number, length: number): Stream;
+    decode(): Uint8Array;
+}
+export default Stream;

package/dist/types/src/core/streams/decode.d.ts

@@ -0,0 +1,3 @@
+import PDFRawStream from '../objects/PDFRawStream';
+import { StreamType } from './Stream';
+export declare const decodePDFRawStream: ({ dict, contents, transform, }: PDFRawStream) => StreamType;

package/dist/types/src/core/structures/PDFCatalog.d.ts

@@ -0,0 +1,27 @@
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFPageTree from './PDFPageTree';
+import { PDFAcroForm } from '../acroform';
+import ViewerPreferences from '../interactive/ViewerPreferences';
+declare class PDFCatalog extends PDFDict {
+    static withContextAndPages: (context: PDFContext, pages: PDFPageTree | PDFRef) => PDFCatalog;
+    static fromMapWithContext: (map: DictMap, context: PDFContext) => PDFCatalog;
+    Pages(): PDFPageTree;
+    AcroForm(): PDFDict | undefined;
+    getAcroForm(): PDFAcroForm | undefined;
+    getOrCreateAcroForm(): PDFAcroForm;
+    ViewerPreferences(): PDFDict | undefined;
+    getViewerPreferences(): ViewerPreferences | undefined;
+    getOrCreateViewerPreferences(): ViewerPreferences;
+    /**
+     * Inserts the given ref as a leaf node of this catalog's page tree at the
+     * specified index (zero-based). Also increments the `Count` of each node in
+     * the page tree hierarchy to accomodate the new page.
+     *
+     * Returns the ref of the PDFPageTree node into which `leafRef` was inserted.
+     */
+    insertLeafNode(leafRef: PDFRef, index: number): PDFRef;
+    removeLeafNode(index: number): void;
+}
+export default PDFCatalog;

package/dist/types/src/core/structures/PDFContentStream.d.ts

@@ -0,0 +1,15 @@
+import PDFDict from '../objects/PDFDict';
+import PDFOperator from '../operators/PDFOperator';
+import PDFContext from '../PDFContext';
+import PDFFlateStream from './PDFFlateStream';
+declare class PDFContentStream extends PDFFlateStream {
+    static of: (dict: PDFDict, operators: PDFOperator[], encode?: boolean) => PDFContentStream;
+    private readonly operators;
+    private constructor();
+    push(...operators: PDFOperator[]): void;
+    clone(context?: PDFContext): PDFContentStream;
+    getContentsString(): string;
+    getUnencodedContents(): Uint8Array;
+    getUnencodedContentsSize(): number;
+}
+export default PDFContentStream;

package/dist/types/src/core/structures/PDFCrossRefStream.d.ts

@@ -0,0 +1,53 @@
+import PDFDict from '../objects/PDFDict';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFFlateStream from './PDFFlateStream';
+export declare enum EntryType {
+    Deleted = 0,
+    Uncompressed = 1,
+    Compressed = 2
+}
+export interface DeletedEntry {
+    type: EntryType.Deleted;
+    ref: PDFRef;
+    nextFreeObjectNumber: number;
+}
+export interface UncompressedEntry {
+    type: EntryType.Uncompressed;
+    ref: PDFRef;
+    offset: number;
+}
+export interface CompressedEntry {
+    type: EntryType.Compressed;
+    ref: PDFRef;
+    objectStreamRef: PDFRef;
+    index: number;
+}
+export type Entry = DeletedEntry | UncompressedEntry | CompressedEntry;
+export type EntryTuple = [number, number, number];
+/**
+ * Entries should be added using the [[addDeletedEntry]],
+ * [[addUncompressedEntry]], and [[addCompressedEntry]] methods
+ * **in order of ascending object number**.
+ */
+declare class PDFCrossRefStream extends PDFFlateStream {
+    static create: (dict: PDFDict, encode?: boolean) => PDFCrossRefStream;
+    static of: (dict: PDFDict, entries: Entry[], encode?: boolean) => PDFCrossRefStream;
+    private readonly entries;
+    private readonly entryTuplesCache;
+    private readonly maxByteWidthsCache;
+    private readonly indexCache;
+    private constructor();
+    addDeletedEntry(ref: PDFRef, nextFreeObjectNumber: number): void;
+    addUncompressedEntry(ref: PDFRef, offset: number): void;
+    addCompressedEntry(ref: PDFRef, objectStreamRef: PDFRef, index: number): void;
+    clone(context?: PDFContext): PDFCrossRefStream;
+    getContentsString(): string;
+    getUnencodedContents(): Uint8Array;
+    getUnencodedContentsSize(): number;
+    updateDict(): void;
+    private computeIndex;
+    private computeEntryTuples;
+    private computeMaxEntryByteWidths;
+}
+export default PDFCrossRefStream;

package/dist/types/src/core/structures/PDFFlateStream.d.ts

@@ -0,0 +1,13 @@
+import PDFDict from '../objects/PDFDict';
+import PDFStream from '../objects/PDFStream';
+import { Cache } from '../../utils';
+declare class PDFFlateStream extends PDFStream {
+    protected readonly contentsCache: Cache<Uint8Array>;
+    protected readonly encode: boolean;
+    constructor(dict: PDFDict, encode: boolean);
+    computeContents: () => Uint8Array;
+    getContents(): Uint8Array;
+    getContentsSize(): number;
+    getUnencodedContents(): Uint8Array;
+}
+export default PDFFlateStream;

package/dist/types/src/core/structures/PDFObjectStream.d.ts

@@ -0,0 +1,20 @@
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFFlateStream from './PDFFlateStream';
+export type IndirectObject = [PDFRef, PDFObject];
+declare class PDFObjectStream extends PDFFlateStream {
+    static withContextAndObjects: (context: PDFContext, objects: IndirectObject[], encode?: boolean) => PDFObjectStream;
+    private readonly objects;
+    private readonly offsets;
+    private readonly offsetsString;
+    private constructor();
+    getObjectsCount(): number;
+    clone(context?: PDFContext): PDFObjectStream;
+    getContentsString(): string;
+    getUnencodedContents(): Uint8Array;
+    getUnencodedContentsSize(): number;
+    private computeOffsetsString;
+    private computeObjectOffsets;
+}
+export default PDFObjectStream;

package/dist/types/src/core/structures/PDFPageLeaf.d.ts

@@ -0,0 +1,54 @@
+import PDFArray from '../objects/PDFArray';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+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 PDFPageTree from './PDFPageTree';
+declare class PDFPageLeaf extends PDFDict {
+    static readonly InheritableEntries: string[];
+    static withContextAndParent: (context: PDFContext, parent: PDFRef) => PDFPageLeaf;
+    static fromMapWithContext: (map: DictMap, context: PDFContext, autoNormalizeCTM?: boolean) => PDFPageLeaf;
+    private normalized;
+    private readonly autoNormalizeCTM;
+    private constructor();
+    clone(context?: PDFContext): PDFPageLeaf;
+    Parent(): PDFPageTree | undefined;
+    Contents(): PDFStream | PDFArray | undefined;
+    Annots(): PDFArray | undefined;
+    BleedBox(): PDFArray | undefined;
+    TrimBox(): PDFArray | undefined;
+    ArtBox(): PDFArray | undefined;
+    Resources(): PDFDict | undefined;
+    MediaBox(): PDFArray;
+    CropBox(): PDFArray | undefined;
+    Rotate(): PDFNumber | undefined;
+    getInheritableAttribute(name: PDFName): PDFObject | undefined;
+    setParent(parentRef: PDFRef): void;
+    addContentStream(contentStreamRef: PDFRef): void;
+    wrapContentStreams(startStream: PDFRef, endStream: PDFRef): boolean;
+    addAnnot(annotRef: PDFRef): void;
+    removeAnnot(annotRef: PDFRef): void;
+    setFontDictionary(name: PDFName, fontDictRef: PDFRef): void;
+    newFontDictionaryKey(tag: string): PDFName;
+    newFontDictionary(tag: string, fontDictRef: PDFRef): PDFName;
+    setXObject(name: PDFName, xObjectRef: PDFRef): void;
+    newXObjectKey(tag: string): PDFName;
+    newXObject(tag: string, xObjectRef: PDFRef): PDFName;
+    setExtGState(name: PDFName, extGStateRef: PDFRef | PDFDict): void;
+    newExtGStateKey(tag: string): PDFName;
+    newExtGState(tag: string, extGStateRef: PDFRef | PDFDict): PDFName;
+    ascend(visitor: (node: PDFPageTree | PDFPageLeaf) => any): void;
+    normalize(): void;
+    normalizedEntries(): {
+        Annots: PDFArray;
+        Resources: PDFDict;
+        Contents: PDFArray | undefined;
+        Font: PDFDict;
+        XObject: PDFDict;
+        ExtGState: PDFDict;
+    };
+}
+export default PDFPageLeaf;

package/dist/types/src/core/structures/PDFPageTree.d.ts

@@ -0,0 +1,41 @@
+import PDFArray from '../objects/PDFArray';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFNumber from '../objects/PDFNumber';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFPageLeaf from './PDFPageLeaf';
+export type TreeNode = PDFPageTree | PDFPageLeaf;
+declare class PDFPageTree extends PDFDict {
+    static withContext: (context: PDFContext, parent?: PDFRef) => PDFPageTree;
+    static fromMapWithContext: (map: DictMap, context: PDFContext) => PDFPageTree;
+    Parent(): PDFPageTree | undefined;
+    Kids(): PDFArray;
+    Count(): PDFNumber;
+    pushTreeNode(treeRef: PDFRef): void;
+    pushLeafNode(leafRef: PDFRef): void;
+    /**
+     * Inserts the given ref as a leaf node of this page tree at the specified
+     * index (zero-based). Also increments the `Count` of each page tree in the
+     * hierarchy to accomodate the new page.
+     *
+     * Returns the ref of the PDFPageTree node into which `leafRef` was inserted,
+     * or `undefined` if it was inserted into the root node (the PDFPageTree upon
+     * which the method was first called).
+     */
+    insertLeafNode(leafRef: PDFRef, targetIndex: number): PDFRef | undefined;
+    /**
+     * Removes the leaf node at the specified index (zero-based) from this page
+     * tree. Also decrements the `Count` of each page tree in the hierarchy to
+     * account for the removed page.
+     *
+     * If `prune` is true, then intermediate tree nodes will be removed from the
+     * tree if they contain 0 children after the leaf node is removed.
+     */
+    removeLeafNode(targetIndex: number, prune?: boolean): void;
+    ascend(visitor: (node: PDFPageTree) => any): void;
+    /** Performs a Post-Order traversal of this page tree */
+    traverse(visitor: (node: TreeNode, ref: PDFRef) => any): void;
+    private insertLeafKid;
+    private removeKid;
+}
+export default PDFPageTree;