@adnsistemas/pdf-lib 1.18.0 → 2.4.2

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

@@ -1,24 +1,28 @@
-import PDFArray from "./PDFArray";
-import PDFBool from "./PDFBool";
-import PDFHexString from "./PDFHexString";
-import PDFName from "./PDFName";
-import PDFNull from "./PDFNull";
-import PDFNumber from "./PDFNumber";
-import PDFObject from "./PDFObject";
-import PDFRef from "./PDFRef";
-import PDFStream from "./PDFStream";
-import PDFString from "./PDFString";
-import PDFContext from "../PDFContext";
-export declare type DictMap = Map<PDFName, PDFObject>;
+import PDFArray from './PDFArray';
+import PDFBool from './PDFBool';
+import PDFHexString from './PDFHexString';
+import PDFName from './PDFName';
+import PDFNull from './PDFNull';
+import PDFNumber from './PDFNumber';
+import PDFObject from './PDFObject';
+import PDFRef from './PDFRef';
+import PDFStream from './PDFStream';
+import PDFString from './PDFString';
+import PDFContext from '../PDFContext';
+export type DictMap = Map<PDFName, PDFObject>;
 declare class PDFDict extends PDFObject {
     static withContext: (context: PDFContext) => PDFDict;
     static fromMapWithContext: (map: DictMap, context: PDFContext) => PDFDict;
     readonly context: PDFContext;
     private readonly dict;
+    suppressEncryption: boolean;
     protected constructor(map: DictMap, context: PDFContext);
     keys(): PDFName[];
     values(): PDFObject[];
-    entries(): [PDFName, PDFObject][];
+    entries(): [
+        PDFName,
+        PDFObject
+    ][];
     set(key: PDFName, value: PDFObject): void;
     get(key: PDFName, preservePDFNull?: boolean): PDFObject | undefined;
     has(key: PDFName): boolean;

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

@@ -1,7 +1,8 @@
-import PDFObject from "./PDFObject";
+import PDFObject from './PDFObject';
 declare class PDFHexString extends PDFObject {
     static of: (value: string) => PDFHexString;
     static fromText: (value: string) => PDFHexString;
+    static fromBytes: (bytes: Uint8Array) => PDFHexString;
     private readonly value;
     constructor(value: string);
     asBytes(): Uint8Array;

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

@@ -1,4 +1,4 @@
-import PDFObject from "./PDFObject";
+import PDFObject from './PDFObject';
 declare class PDFInvalidObject extends PDFObject {
     static of: (data: Uint8Array) => PDFInvalidObject;
     private readonly data;

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

@@ -1,4 +1,4 @@
-import PDFObject from "./PDFObject";
+import PDFObject from './PDFObject';
 declare class PDFName extends PDFObject {
     static of: (name: string) => PDFName;
     static readonly Length: PDFName;

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

@@ -1,4 +1,4 @@
-import PDFObject from "./PDFObject";
+import PDFObject from './PDFObject';
 declare class PDFNull extends PDFObject {
     asNull(): null;
     clone(): PDFNull;

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

@@ -1,4 +1,4 @@
-import PDFObject from "./PDFObject";
+import PDFObject from './PDFObject';
 declare class PDFNumber extends PDFObject {
     static of: (value: number) => PDFNumber;
     private readonly numberValue;

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

@@ -1,4 +1,4 @@
-import PDFContext from "../PDFContext";
+import PDFContext from '../PDFContext';
 declare class PDFObject {
     registerChange(): void;
     clone(_context?: PDFContext): PDFObject;

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

@@ -1,15 +1,18 @@
-import PDFDict from "./PDFDict";
-import PDFStream from "./PDFStream";
-import PDFContext from "../PDFContext";
+import PDFDict from './PDFDict';
+import PDFStream from './PDFStream';
+import PDFContext from '../PDFContext';
+import { CipherTransform } from '../crypto';
 declare class PDFRawStream extends PDFStream {
-    static of: (dict: PDFDict, contents: Uint8Array) => PDFRawStream;
-    readonly contents: Uint8Array;
+    static of: (dict: PDFDict, contents: Uint8Array, transform?: CipherTransform) => PDFRawStream;
+    contents: Uint8Array;
+    readonly transform?: CipherTransform;
     private constructor();
     asUint8Array(): Uint8Array;
     clone(context?: PDFContext): PDFRawStream;
     getContentsString(): string;
     getContents(): Uint8Array;
     getContentsSize(): number;
+    updateContents(contents: Uint8Array): void;
 }
 export default PDFRawStream;
 //# sourceMappingURL=PDFRawStream.d.ts.map

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

@@ -1,4 +1,4 @@
-import PDFObject from "./PDFObject";
+import PDFObject from '../objects/PDFObject';
 declare class PDFRef extends PDFObject {
     static of: (objectNumber: number, generationNumber?: number) => PDFRef;
     readonly objectNumber: number;

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

@@ -1,6 +1,6 @@
-import PDFDict from "./PDFDict";
-import PDFObject from "./PDFObject";
-import PDFContext from "../PDFContext";
+import PDFDict from './PDFDict';
+import PDFObject from './PDFObject';
+import PDFContext from '../PDFContext';
 declare class PDFStream extends PDFObject {
     readonly dict: PDFDict;
     constructor(dict: PDFDict);
@@ -8,6 +8,7 @@ declare class PDFStream extends PDFObject {
     getContentsString(): string;
     getContents(): Uint8Array;
     getContentsSize(): number;
+    updateContents(_contents: Uint8Array): void;
     updateDict(): void;
     sizeInBytes(): number;
     toString(): string;

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

@@ -1,4 +1,4 @@
-import PDFObject from "./PDFObject";
+import PDFObject from './PDFObject';
 declare class PDFString extends PDFObject {
     static of: (value: string) => PDFString;
     static fromDate: (date: Date) => PDFString;

package/ts3.4/es/core/operators/PDFOperator.d.ts

@@ -1,13 +1,13 @@
-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 declare type PDFOperatorArg = string | PDFName | PDFArray | PDFNumber | PDFString | PDFHexString;
+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[] | undefined) => PDFOperator;
+    static of: (name: PDFOperatorNames, args?: PDFOperatorArg[]) => PDFOperator;
     private readonly name;
     private readonly args;
     private constructor();

package/ts3.4/es/core/parser/BaseParser.d.ts

@@ -1,4 +1,4 @@
-import ByteStream from "./ByteStream";
+import ByteStream from '../parser/ByteStream';
 declare class BaseParser {
     protected readonly bytes: ByteStream;
     protected readonly capNumbers: boolean;

package/ts3.4/es/core/parser/ByteStream.d.ts

@@ -1,4 +1,4 @@
-import PDFRawStream from "../objects/PDFRawStream";
+import PDFRawStream from '../objects/PDFRawStream';
 declare class ByteStream {
     static of: (bytes: Uint8Array) => ByteStream;
     static fromPDFRawStream: (rawStream: PDFRawStream) => ByteStream;

package/ts3.4/es/core/parser/PDFObjectParser.d.ts

@@ -1,29 +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 { 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 | undefined) => PDFObjectParser;
+    static forBytes: (bytes: Uint8Array, context: PDFContext, capNumbers?: boolean) => PDFObjectParser;
     static forByteStream: (byteStream: ByteStream, context: PDFContext, capNumbers?: boolean) => PDFObjectParser;
     protected readonly context: PDFContext;
-    constructor(byteStream: ByteStream, context: PDFContext, capNumbers?: boolean);
-    parseObject(): PDFObject;
+    private readonly cryptoFactory?;
+    constructor(byteStream: ByteStream, context: PDFContext, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory);
+    parseObject(ref?: PDFRef): PDFObject;
     protected parseNumberOrRef(): PDFNumber | PDFRef;
-    protected parseHexString(): PDFHexString;
-    protected parseString(): PDFString;
+    protected parseHexString(ref?: PDFRef): PDFHexString;
+    protected parseString(ref?: PDFRef): PDFString;
     protected parseName(): PDFName;
-    protected parseArray(): PDFArray;
-    protected parseDict(): PDFDict;
-    protected parseDictOrStream(): PDFDict | PDFStream;
+    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/ts3.4/es/core/parser/PDFObjectStreamParser.d.ts

@@ -1,7 +1,7 @@
-import PDFRawStream from "../objects/PDFRawStream";
-import PDFObjectParser from "./PDFObjectParser";
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFObjectParser from './PDFObjectParser';
 declare class PDFObjectStreamParser extends PDFObjectParser {
-    static forStream: (rawStream: PDFRawStream, shouldWaitForTick?: (() => boolean) | undefined) => PDFObjectStreamParser;
+    static forStream: (rawStream: PDFRawStream, shouldWaitForTick?: () => boolean) => PDFObjectStreamParser;
     private alreadyParsed;
     private readonly shouldWaitForTick;
     private readonly firstOffset;

package/ts3.4/es/core/parser/PDFParser.d.ts

@@ -1,12 +1,14 @@
-import PDFObjectParser from "./PDFObjectParser";
-import PDFContext from "../PDFContext";
+import PDFObjectParser from './PDFObjectParser';
+import PDFContext from '../PDFContext';
+import { CipherTransformFactory } from '../crypto';
 declare class PDFParser extends PDFObjectParser {
-    static forBytesWithOptions: (pdfBytes: Uint8Array, objectsPerTick?: number | undefined, throwOnInvalidObject?: boolean | undefined, capNumbers?: boolean | undefined, forIncrementalUpdate?: boolean | undefined) => PDFParser;
+    static forBytesWithOptions: (pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, warnOnInvalidObjects?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory, forIncrementalUpdate?: boolean) => PDFParser;
     private readonly objectsPerTick;
     private readonly throwOnInvalidObject;
+    private readonly warnOnInvalidObjects;
     private alreadyParsed;
     private parsedObjects;
-    constructor(pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, capNumbers?: boolean, forIncrementalUpdate?: boolean);
+    constructor(pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, warnOnInvalidObjects?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory, forIncrementalUpdate?: boolean);
     parseDocument(): Promise<PDFContext>;
     private maybeRecoverRoot;
     private parseHeader;

package/ts3.4/es/core/parser/PDFXRefStreamParser.d.ts

@@ -1,5 +1,5 @@
-import PDFRawStream from "../objects/PDFRawStream";
-import PDFRef from "../objects/PDFRef";
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFRef from '../objects/PDFRef';
 export interface Entry {
     ref: PDFRef;
     offset: number;

package/ts3.4/es/core/security/PDFSecurity.d.ts

@@ -0,0 +1,75 @@
+import PDFContext from '../PDFContext';
+/**
+ * Interface representing user permissions.
+ *
+ * @interface UserPermissions
+ */
+interface UserPermissions {
+    /**
+     * Printing Permission
+     * For Security handlers of revision <= 2 : Boolean
+     * For Security handlers of revision >= 3 : 'lowResolution' or 'highResolution'
+     */
+    printing?: boolean | 'lowResolution' | 'highResolution';
+    /**
+     * Modify Content Permission (Other than 'annotating', 'fillingForms' and 'documentAssembly')
+     */
+    modifying?: boolean;
+    /** Copy or otherwise extract text and graphics from document */
+    copying?: boolean;
+    /** Permission to add or modify text annotations */
+    annotating?: boolean;
+    /**
+     * Security handlers of revision >= 3
+     * Fill in existing interactive form fields (including signature fields)
+     */
+    fillingForms?: boolean;
+    /**
+     * Security handlers of revision >= 3
+     * Extract text and graphics (in support of accessibility to users with disabilities or for other purposes)
+     */
+    contentAccessibility?: boolean;
+    /**
+     * Security handlers of revision >= 3
+     * Assemble the document (insert, rotate or delete pages and create bookmarks or thumbnail images)
+     */
+    documentAssembly?: boolean;
+}
+export type EncryptFn = (buffer: Uint8Array) => Uint8Array;
+/**
+ * Interface options for security
+ * @interface SecurityOptions
+ */
+export interface SecurityOptions {
+    /**
+     * Password that provides unlimited access to the encrypted document.
+     *
+     * Opening encrypted document with owner password allows full (owner) access to the document
+     */
+    ownerPassword?: string;
+    /** Password that restricts reader according to the defined permissions.
+     *
+     * Opening encrypted document with user password will have limitations in accordance to the permission defined.
+     */
+    userPassword?: string;
+    /** Object representing type of user permission enforced on the document
+     * @link {@link UserPermissions}
+     */
+    permissions?: UserPermissions;
+}
+declare class PDFSecurity {
+    context: PDFContext;
+    private id;
+    private encryption;
+    private keyBits;
+    private encryptionKey;
+    static create(context: PDFContext, options: SecurityOptions): PDFSecurity;
+    constructor(context: PDFContext, options: SecurityOptions);
+    private initialize;
+    private initializeV1V2V4;
+    private initializeV5;
+    getEncryptFn(obj: number, gen: number): (buffer: Uint8Array) => Uint8Array;
+    encrypt(): this;
+}
+export default PDFSecurity;
+//# sourceMappingURL=PDFSecurity.d.ts.map

package/ts3.4/es/core/streams/Ascii85Stream.d.ts

@@ -1,5 +1,5 @@
-import DecodeStream from "./DecodeStream";
-import { StreamType } from "./Stream";
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
 declare class Ascii85Stream extends DecodeStream {
     private stream;
     private input;

package/ts3.4/es/core/streams/AsciiHexStream.d.ts

@@ -1,5 +1,5 @@
-import DecodeStream from "./DecodeStream";
-import { StreamType } from "./Stream";
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
 declare class AsciiHexStream extends DecodeStream {
     private stream;
     private firstDigit;

package/ts3.4/es/core/streams/DecodeStream.d.ts

@@ -1,4 +1,4 @@
-import Stream, { StreamType } from "./Stream";
+import Stream, { StreamType } from './Stream';
 /**
  * Super class for the decoding streams
  */

package/ts3.4/es/core/streams/DecryptStream.d.ts

@@ -0,0 +1,13 @@
+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;
+//# sourceMappingURL=DecryptStream.d.ts.map

package/ts3.4/es/core/streams/FlateStream.d.ts

@@ -1,5 +1,5 @@
-import DecodeStream from "./DecodeStream";
-import { StreamType } from "./Stream";
+import DecodeStream from '../../core/streams/DecodeStream';
+import { StreamType } from '../../core/streams/Stream';
 declare class FlateStream extends DecodeStream {
     private stream;
     private codeSize;

package/ts3.4/es/core/streams/LZWStream.d.ts

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

package/ts3.4/es/core/streams/RunLengthStream.d.ts

@@ -1,5 +1,5 @@
-import DecodeStream from "./DecodeStream";
-import { StreamType } from "./Stream";
+import DecodeStream from './DecodeStream';
+import { StreamType } from './Stream';
 declare class RunLengthStream extends DecodeStream {
     private stream;
     constructor(stream: StreamType, maybeLength?: number);

package/ts3.4/es/core/streams/decode.d.ts

@@ -1,4 +1,4 @@
-import PDFRawStream from "../objects/PDFRawStream";
-import { StreamType } from "./Stream";
-export declare const decodePDFRawStream: ({ dict, contents }: PDFRawStream) => StreamType;
+import PDFRawStream from '../objects/PDFRawStream';
+import { StreamType } from './Stream';
+export declare const decodePDFRawStream: ({ dict, contents, transform, }: PDFRawStream) => StreamType;
 //# sourceMappingURL=decode.d.ts.map

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

@@ -1,8 +1,8 @@
-import PDFDict, { DictMap } from "../objects/PDFDict";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
-import PDFPageTree from "./PDFPageTree";
-import { PDFAcroForm } from "../acroform";
+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;

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

@@ -1,7 +1,7 @@
-import PDFDict from "../objects/PDFDict";
-import PDFOperator from "../operators/PDFOperator";
-import PDFContext from "../PDFContext";
-import PDFFlateStream from "./PDFFlateStream";
+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;

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

@@ -1,7 +1,7 @@
-import PDFDict from "../objects/PDFDict";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
-import PDFFlateStream from "./PDFFlateStream";
+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,
@@ -23,8 +23,12 @@ export interface CompressedEntry {
     objectStreamRef: PDFRef;
     index: number;
 }
-export declare type Entry = DeletedEntry | UncompressedEntry | CompressedEntry;
-export declare type EntryTuple = [number, number, number];
+export type Entry = DeletedEntry | UncompressedEntry | CompressedEntry;
+export type EntryTuple = [
+    number,
+    number,
+    number
+];
 /**
  * Entries should be added using the [[addDeletedEntry]],
  * [[addUncompressedEntry]], and [[addCompressedEntry]] methods

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

@@ -1,14 +1,15 @@
-import PDFDict from "../objects/PDFDict";
-import PDFStream from "../objects/PDFStream";
-import { Cache } from "../../utils";
+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 contentsCache: Cache<Uint8Array>;
     protected readonly encode: boolean;
     constructor(dict: PDFDict, encode: boolean);
     computeContents: () => Uint8Array;
     getContents(): Uint8Array;
     getContentsSize(): number;
     getUnencodedContents(): Uint8Array;
+    updateContents(contents: Uint8Array): void;
 }
 export default PDFFlateStream;
 //# sourceMappingURL=PDFFlateStream.d.ts.map

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

@@ -1,8 +1,11 @@
-import PDFObject from "../objects/PDFObject";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
-import PDFFlateStream from "./PDFFlateStream";
-export declare type IndirectObject = [PDFRef, PDFObject];
+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;

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

@@ -1,12 +1,12 @@
-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";
+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;

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

@@ -1,12 +1,12 @@
-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 declare type TreeNode = PDFPageTree | PDFPageLeaf;
+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 | undefined) => PDFPageTree;
+    static withContext: (context: PDFContext, parent?: PDFRef) => PDFPageTree;
     static fromMapWithContext: (map: DictMap, context: PDFContext) => PDFPageTree;
     Parent(): PDFPageTree | undefined;
     Kids(): PDFArray;

package/ts3.4/es/core/syntax/Keywords.d.ts

@@ -1,4 +1,4 @@
-import CharCodes from "./CharCodes";
+import CharCodes from './CharCodes';
 export declare const Keywords: {
     header: CharCodes[];
     eof: CharCodes[];

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

@@ -1,10 +1,10 @@
-import { DocumentSnapshot } from "../../api/snapshot";
-import PDFHeader from "../document/PDFHeader";
-import PDFTrailer from "../document/PDFTrailer";
-import PDFObject from "../objects/PDFObject";
-import PDFRef from "../objects/PDFRef";
-import PDFContext from "../PDFContext";
-import PDFWriter from "./PDFWriter";
+import { DocumentSnapshot } from 'src/api/snapshot';
+import PDFHeader from 'src/core/document/PDFHeader';
+import PDFTrailer from 'src/core/document/PDFTrailer';
+import PDFObject from 'src/core/objects/PDFObject';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFContext from 'src/core/PDFContext';
+import PDFWriter from 'src/core/writers/PDFWriter';
 declare class PDFStreamWriter extends PDFWriter {
     static forContext: (context: PDFContext, objectsPerTick: number, encodeStreams?: boolean, objectsPerStream?: number) => PDFStreamWriter;
     static forContextWithSnapshot: (context: PDFContext, objectsPerTick: number, snapshot: DocumentSnapshot, encodeStreams?: boolean, objectsPerStream?: number) => PDFStreamWriter;
@@ -14,7 +14,10 @@ declare class PDFStreamWriter extends PDFWriter {
     protected computeBufferSize(incremental: boolean): Promise<{
         size: number;
         header: PDFHeader;
-        indirectObjects: [PDFRef, PDFObject][];
+        indirectObjects: [
+            PDFRef,
+            PDFObject
+        ][];
         trailer: PDFTrailer;
     }>;
 }