@adnsistemas/pdf-lib 1.18.0 → 2.4.2

package/src/core/objects/PDFHexString.ts

@@ -1,5 +1,5 @@
-import PDFObject from 'src/core/objects/PDFObject';
-import CharCodes from 'src/core/syntax/CharCodes';
+import PDFObject from './PDFObject';
+import CharCodes from '../syntax/CharCodes';
 import {
   copyStringIntoBuffer,
   toHexStringOfMinLength,
@@ -8,8 +8,9 @@ import {
   pdfDocEncodingDecode,
   parseDate,
   hasUtf16BOM,
-} from 'src/utils';
-import { InvalidPDFDateStringError } from 'src/core/errors';
+  byteArrayToHexString,
+} from '../../utils';
+import { InvalidPDFDateStringError } from '../errors';
 
 class PDFHexString extends PDFObject {
   static of = (value: string) => new PDFHexString(value);
@@ -25,6 +26,9 @@ class PDFHexString extends PDFObject {
     return new PDFHexString(hex);
   };
 
+  static fromBytes = (bytes: Uint8Array) =>
+    PDFHexString.of(byteArrayToHexString(bytes));
+
   private readonly value: string;
 
   constructor(value: string) {

package/src/core/objects/PDFInvalidObject.ts

@@ -1,4 +1,4 @@
-import PDFObject from 'src/core/objects/PDFObject';
+import PDFObject from './PDFObject';
 
 class PDFInvalidObject extends PDFObject {
   static of = (data: Uint8Array) => new PDFInvalidObject(data);

package/src/core/objects/PDFName.ts

@@ -1,13 +1,13 @@
-import { PrivateConstructorError } from 'src/core/errors';
-import PDFObject from 'src/core/objects/PDFObject';
-import CharCodes from 'src/core/syntax/CharCodes';
-import { IsIrregular } from 'src/core/syntax/Irregular';
+import { PrivateConstructorError } from '../errors';
+import PDFObject from './PDFObject';
+import CharCodes from '../syntax/CharCodes';
+import { IsIrregular } from '../syntax/Irregular';
 import {
   charFromHexCode,
   copyStringIntoBuffer,
   toCharCode,
   toHexString,
-} from 'src/utils';
+} from '../../utils';
 
 const decodeName = (name: string) =>
   name.replace(/#([\dABCDEF]{2})/g, (_, hex) => charFromHexCode(hex));
@@ -151,7 +151,7 @@ class PDFName extends PDFObject {
   }
 
   copyBytesInto(buffer: Uint8Array, offset: number): number {
-    offset += copyStringIntoBuffer(this.encodedName, buffer, offset);
+    copyStringIntoBuffer(this.encodedName, buffer, offset);
     return this.encodedName.length;
   }
 }

package/src/core/objects/PDFNull.ts

@@ -1,5 +1,5 @@
-import PDFObject from 'src/core/objects/PDFObject';
-import CharCodes from 'src/core/syntax/CharCodes';
+import PDFObject from './PDFObject';
+import CharCodes from '../syntax/CharCodes';
 
 class PDFNull extends PDFObject {
   asNull(): null {

package/src/core/objects/PDFNumber.ts

@@ -1,6 +1,6 @@
-import { copyStringIntoBuffer, numberToString } from 'src/utils/index';
+import { copyStringIntoBuffer, numberToString } from '../../utils/index';
 
-import PDFObject from 'src/core/objects/PDFObject';
+import PDFObject from './PDFObject';
 
 class PDFNumber extends PDFObject {
   static of = (value: number) => new PDFNumber(value);
@@ -36,7 +36,7 @@ class PDFNumber extends PDFObject {
   }
 
   copyBytesInto(buffer: Uint8Array, offset: number): number {
-    offset += copyStringIntoBuffer(this.stringValue, buffer, offset);
+    copyStringIntoBuffer(this.stringValue, buffer, offset);
     return this.stringValue.length;
   }
 }

package/src/core/objects/PDFObject.ts

@@ -1,5 +1,5 @@
-import { MethodNotImplementedError } from 'src/core/errors';
-import PDFContext from 'src/core/PDFContext';
+import { MethodNotImplementedError } from '../errors';
+import PDFContext from '../PDFContext';
 
 class PDFObject {
   registerChange() {

package/src/core/objects/PDFRawStream.ts

@@ -1,17 +1,27 @@
-import PDFDict from 'src/core/objects/PDFDict';
-import PDFStream from 'src/core/objects/PDFStream';
-import PDFContext from 'src/core/PDFContext';
-import { arrayAsString } from 'src/utils';
+import PDFDict from './PDFDict';
+import PDFStream from './PDFStream';
+import PDFContext from '../PDFContext';
+import { arrayAsString } from '../../utils';
+import { CipherTransform } from '../crypto';
 
 class PDFRawStream extends PDFStream {
-  static of = (dict: PDFDict, contents: Uint8Array) =>
-    new PDFRawStream(dict, contents);
-
-  readonly contents: Uint8Array;
-
-  private constructor(dict: PDFDict, contents: Uint8Array) {
+  static of = (
+    dict: PDFDict,
+    contents: Uint8Array,
+    transform?: CipherTransform,
+  ) => new PDFRawStream(dict, contents, transform);
+
+  contents: Uint8Array;
+  readonly transform?: CipherTransform;
+
+  private constructor(
+    dict: PDFDict,
+    contents: Uint8Array,
+    transform?: CipherTransform,
+  ) {
     super(dict);
     this.contents = contents;
+    this.transform = transform;
   }
 
   asUint8Array(): Uint8Array {
@@ -33,6 +43,10 @@ class PDFRawStream extends PDFStream {
   getContentsSize(): number {
     return this.contents.length;
   }
+
+  updateContents(contents: Uint8Array): void {
+    this.contents = contents;
+  }
 }
 
 export default PDFRawStream;

package/src/core/objects/PDFRef.ts

@@ -1,6 +1,6 @@
-import { PrivateConstructorError } from 'src/core/errors';
-import PDFObject from 'src/core/objects/PDFObject';
-import { copyStringIntoBuffer } from 'src/utils';
+import { PrivateConstructorError } from '../errors';
+import PDFObject from '../objects/PDFObject';
+import { copyStringIntoBuffer } from '../../utils';
 
 const ENFORCER = {};
 const pool = new Map<string, PDFRef>();
@@ -47,7 +47,7 @@ class PDFRef extends PDFObject {
   }
 
   copyBytesInto(buffer: Uint8Array, offset: number): number {
-    offset += copyStringIntoBuffer(this.tag, buffer, offset);
+    copyStringIntoBuffer(this.tag, buffer, offset);
     return this.tag.length;
   }
 }

package/src/core/objects/PDFStream.ts

@@ -1,10 +1,10 @@
-import { MethodNotImplementedError } from 'src/core/errors';
-import PDFDict from 'src/core/objects/PDFDict';
-import PDFName from 'src/core/objects/PDFName';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFContext from 'src/core/PDFContext';
-import CharCodes from 'src/core/syntax/CharCodes';
+import { MethodNotImplementedError } from '../errors';
+import PDFDict from './PDFDict';
+import PDFName from './PDFName';
+import PDFNumber from './PDFNumber';
+import PDFObject from './PDFObject';
+import PDFContext from '../PDFContext';
+import CharCodes from '../syntax/CharCodes';
 
 class PDFStream extends PDFObject {
   readonly dict: PDFDict;
@@ -36,6 +36,13 @@ class PDFStream extends PDFObject {
     );
   }
 
+  updateContents(_contents: Uint8Array): void {
+    throw new MethodNotImplementedError(
+      this.constructor.name,
+      'updateContents',
+    );
+  }
+
   updateDict(): void {
     const contentsSize = this.getContentsSize();
     this.dict.set(PDFName.Length, PDFNumber.of(contentsSize));

package/src/core/objects/PDFString.ts

@@ -1,5 +1,5 @@
-import PDFObject from 'src/core/objects/PDFObject';
-import CharCodes from 'src/core/syntax/CharCodes';
+import PDFObject from './PDFObject';
+import CharCodes from '../syntax/CharCodes';
 import {
   copyStringIntoBuffer,
   padStart,
@@ -8,8 +8,8 @@ import {
   toCharCode,
   parseDate,
   hasUtf16BOM,
-} from 'src/utils';
-import { InvalidPDFDateStringError } from 'src/core/errors';
+} from '../../utils';
+import { InvalidPDFDateStringError } from '../errors';
 
 class PDFString extends PDFObject {
   // The PDF spec allows newlines and parens to appear directly within a literal

package/src/core/operators/PDFOperator.ts

@@ -1,13 +1,13 @@
-import PDFArray from 'src/core/objects/PDFArray';
-import PDFHexString from 'src/core/objects/PDFHexString';
-import PDFName from 'src/core/objects/PDFName';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFString from 'src/core/objects/PDFString';
-import PDFOperatorNames from 'src/core/operators/PDFOperatorNames';
-import PDFContext from 'src/core/PDFContext';
-import CharCodes from 'src/core/syntax/CharCodes';
-import { copyStringIntoBuffer } from 'src/utils';
+import PDFArray from '../objects/PDFArray';
+import PDFHexString from '../objects/PDFHexString';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFString from '../objects/PDFString';
+import PDFOperatorNames from './PDFOperatorNames';
+import PDFContext from '../PDFContext';
+import CharCodes from '../syntax/CharCodes';
+import { copyStringIntoBuffer } from '../../utils';
 
 export type PDFOperatorArg =
   | string

package/src/core/parser/BaseParser.ts

@@ -1,9 +1,9 @@
-import { NumberParsingError } from 'src/core/errors';
-import ByteStream from 'src/core/parser/ByteStream';
-import CharCodes from 'src/core/syntax/CharCodes';
-import { IsDigit, IsNumeric } from 'src/core/syntax/Numeric';
-import { IsWhitespace } from 'src/core/syntax/Whitespace';
-import { charFromCode } from 'src/utils';
+import { NumberParsingError } from '../errors';
+import ByteStream from '../parser/ByteStream';
+import CharCodes from '../syntax/CharCodes';
+import { IsDigit, IsNumeric } from '../syntax/Numeric';
+import { IsWhitespace } from '../syntax/Whitespace';
+import { charFromCode } from '../../utils';
 
 const { Newline, CarriageReturn } = CharCodes;
 

package/src/core/parser/ByteStream.ts

@@ -1,7 +1,7 @@
-import { NextByteAssertionError } from 'src/core/errors';
-import PDFRawStream from 'src/core/objects/PDFRawStream';
-import { decodePDFRawStream } from 'src/core/streams/decode';
-import CharCodes from 'src/core/syntax/CharCodes';
+import { NextByteAssertionError } from '../errors';
+import PDFRawStream from '../objects/PDFRawStream';
+import { decodePDFRawStream } from '../streams/decode';
+import CharCodes from '../syntax/CharCodes';
 
 // TODO: See how line/col tracking affects performance
 class ByteStream {

package/src/core/parser/PDFObjectParser.ts

@@ -3,31 +3,32 @@ import {
   PDFStreamParsingError,
   Position,
   UnbalancedParenthesisError,
-} from 'src/core/errors';
-import PDFArray from 'src/core/objects/PDFArray';
-import PDFBool from 'src/core/objects/PDFBool';
-import PDFDict, { DictMap } from 'src/core/objects/PDFDict';
-import PDFHexString from 'src/core/objects/PDFHexString';
-import PDFName from 'src/core/objects/PDFName';
-import PDFNull from 'src/core/objects/PDFNull';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFRawStream from 'src/core/objects/PDFRawStream';
-import PDFRef from 'src/core/objects/PDFRef';
-import PDFStream from 'src/core/objects/PDFStream';
-import PDFString from 'src/core/objects/PDFString';
-import BaseParser from 'src/core/parser/BaseParser';
-import ByteStream from 'src/core/parser/ByteStream';
-import PDFContext from 'src/core/PDFContext';
-import PDFCatalog from 'src/core/structures/PDFCatalog';
-import PDFPageLeaf from 'src/core/structures/PDFPageLeaf';
-import PDFPageTree from 'src/core/structures/PDFPageTree';
-import CharCodes from 'src/core/syntax/CharCodes';
-import { IsDelimiter } from 'src/core/syntax/Delimiters';
-import { Keywords } from 'src/core/syntax/Keywords';
-import { IsDigit, IsNumeric } from 'src/core/syntax/Numeric';
-import { IsWhitespace } from 'src/core/syntax/Whitespace';
-import { charFromCode } from 'src/utils';
+} from '../errors';
+import PDFArray from '../objects/PDFArray';
+import PDFBool from '../objects/PDFBool';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFHexString from '../objects/PDFHexString';
+import PDFName from '../objects/PDFName';
+import PDFNull from '../objects/PDFNull';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFRawStream from '../objects/PDFRawStream';
+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 PDFCatalog from '../structures/PDFCatalog';
+import PDFPageLeaf from '../structures/PDFPageLeaf';
+import PDFPageTree from '../structures/PDFPageTree';
+import CharCodes from '../syntax/CharCodes';
+import { IsDelimiter } from '../syntax/Delimiters';
+import { Keywords } from '../syntax/Keywords';
+import { IsDigit, IsNumeric } from '../syntax/Numeric';
+import { IsWhitespace } from '../syntax/Whitespace';
+import { charFromCode } from '../../utils';
+import { CipherTransformFactory } from '../crypto';
 
 // TODO: Throw error if eof is reached before finishing object parse...
 class PDFObjectParser extends BaseParser {
@@ -44,14 +45,21 @@ class PDFObjectParser extends BaseParser {
   ) => new PDFObjectParser(byteStream, context, capNumbers);
 
   protected readonly context: PDFContext;
+  private readonly cryptoFactory?: CipherTransformFactory;
 
-  constructor(byteStream: ByteStream, context: PDFContext, capNumbers = false) {
+  constructor(
+    byteStream: ByteStream,
+    context: PDFContext,
+    capNumbers = false,
+    cryptoFactory?: CipherTransformFactory,
+  ) {
     super(byteStream, capNumbers);
     this.context = context;
+    this.cryptoFactory = cryptoFactory;
   }
 
   // TODO: Is it possible to reduce duplicate parsing for ref lookaheads?
-  parseObject(): PDFObject {
+  parseObject(ref?: PDFRef): PDFObject {
     this.skipWhitespaceAndComments();
 
     if (this.matchKeyword(Keywords.true)) return PDFBool.True;
@@ -64,12 +72,12 @@ class PDFObjectParser extends BaseParser {
       byte === CharCodes.LessThan &&
       this.bytes.peekAhead(1) === CharCodes.LessThan
     ) {
-      return this.parseDictOrStream();
+      return this.parseDictOrStream(ref);
     }
-    if (byte === CharCodes.LessThan) return this.parseHexString();
-    if (byte === CharCodes.LeftParen) return this.parseString();
+    if (byte === CharCodes.LessThan) return this.parseHexString(ref);
+    if (byte === CharCodes.LeftParen) return this.parseString(ref);
     if (byte === CharCodes.ForwardSlash) return this.parseName();
-    if (byte === CharCodes.LeftSquareBracket) return this.parseArray();
+    if (byte === CharCodes.LeftSquareBracket) return this.parseArray(ref);
     if (IsNumeric[byte]) return this.parseNumberOrRef();
 
     throw new PDFObjectParsingError(this.bytes.position(), byte);
@@ -94,7 +102,7 @@ class PDFObjectParser extends BaseParser {
   }
 
   // TODO: Maybe update PDFHexString.of() logic to remove whitespace and validate input?
-  protected parseHexString(): PDFHexString {
+  protected parseHexString(ref?: PDFRef): PDFHexString {
     let value = '';
 
     this.bytes.assertNext(CharCodes.LessThan);
@@ -103,10 +111,22 @@ class PDFObjectParser extends BaseParser {
     }
     this.bytes.assertNext(CharCodes.GreaterThan);
 
+    if (this.cryptoFactory && ref) {
+      const transformer = this.cryptoFactory.createCipherTransform(
+        ref.objectNumber,
+        ref.generationNumber,
+      );
+      const arr = transformer.decryptBytes(PDFHexString.of(value).asBytes());
+      value = arr.reduce(
+        (str: string, byte: number) => str + byte.toString(16).padStart(2, '0'),
+        '',
+      );
+    }
+
     return PDFHexString.of(value);
   }
 
-  protected parseString(): PDFString {
+  protected parseString(ref?: PDFRef): PDFString {
     let nestingLvl = 0;
     let isEscaped = false;
     let value = '';
@@ -130,8 +150,17 @@ class PDFObjectParser extends BaseParser {
 
       // Once (if) the unescaped parenthesis balance out, return their contents
       if (nestingLvl === 0) {
+        let actualValue = value.substring(1, value.length - 1);
+
+        if (this.cryptoFactory && ref) {
+          const transformer = this.cryptoFactory.createCipherTransform(
+            ref.objectNumber,
+            ref.generationNumber,
+          );
+          actualValue = transformer.decryptString(actualValue);
+        }
         // Remove the outer parens so they aren't part of the contents
-        return PDFString.of(value.substring(1, value.length - 1));
+        return PDFString.of(actualValue);
       }
     }
 
@@ -154,13 +183,13 @@ class PDFObjectParser extends BaseParser {
     return PDFName.of(name);
   }
 
-  protected parseArray(): PDFArray {
+  protected parseArray(ref?: PDFRef): PDFArray {
     this.bytes.assertNext(CharCodes.LeftSquareBracket);
     this.skipWhitespaceAndComments();
 
     const pdfArray = PDFArray.withContext(this.context);
     while (this.bytes.peek() !== CharCodes.RightSquareBracket) {
-      const element = this.parseObject();
+      const element = this.parseObject(ref);
       pdfArray.push(element);
       this.skipWhitespaceAndComments();
     }
@@ -168,7 +197,7 @@ class PDFObjectParser extends BaseParser {
     return pdfArray;
   }
 
-  protected parseDict(): PDFDict {
+  protected parseDict(ref?: PDFRef): PDFDict {
     this.bytes.assertNext(CharCodes.LessThan);
     this.bytes.assertNext(CharCodes.LessThan);
     this.skipWhitespaceAndComments();
@@ -181,7 +210,7 @@ class PDFObjectParser extends BaseParser {
       this.bytes.peekAhead(1) !== CharCodes.GreaterThan
     ) {
       const key = this.parseName();
-      const value = this.parseObject();
+      const value = this.parseObject(ref);
       dict.set(key, value);
       this.skipWhitespaceAndComments();
     }
@@ -203,10 +232,10 @@ class PDFObjectParser extends BaseParser {
     }
   }
 
-  protected parseDictOrStream(): PDFDict | PDFStream {
+  protected parseDictOrStream(ref?: PDFRef): PDFDict | PDFStream {
     const startPos = this.bytes.position();
 
-    const dict = this.parseDict();
+    const dict = this.parseDict(ref);
 
     this.skipWhitespaceAndComments();
 
@@ -236,7 +265,15 @@ class PDFObjectParser extends BaseParser {
       end = this.findEndOfStreamFallback(startPos);
     }
 
-    const contents = this.bytes.slice(start, end);
+    let contents = this.bytes.slice(start, end);
+
+    if (this.cryptoFactory && ref) {
+      const transform = this.cryptoFactory.createCipherTransform(
+        ref.objectNumber,
+        ref.generationNumber,
+      );
+      contents = transform.decryptBytes(contents);
+    }
 
     return PDFRawStream.of(dict, contents);
   }

package/src/core/parser/PDFObjectStreamParser.ts

@@ -1,11 +1,11 @@
-import { ReparseError } from 'src/core/errors';
-import PDFName from 'src/core/objects/PDFName';
-import PDFNumber from 'src/core/objects/PDFNumber';
-import PDFRawStream from 'src/core/objects/PDFRawStream';
-import PDFRef from 'src/core/objects/PDFRef';
-import ByteStream from 'src/core/parser/ByteStream';
-import PDFObjectParser from 'src/core/parser/PDFObjectParser';
-import { waitForTick } from 'src/utils';
+import { ReparseError } from '../errors';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFRef from '../objects/PDFRef';
+import ByteStream from './ByteStream';
+import PDFObjectParser from './PDFObjectParser';
+import { waitForTick } from '../../utils';
 
 class PDFObjectStreamParser extends PDFObjectParser {
   static forStream = (
@@ -39,8 +39,8 @@ class PDFObjectStreamParser extends PDFObjectParser {
     for (let idx = 0, len = offsetsAndObjectNumbers.length; idx < len; idx++) {
       const { objectNumber, offset } = offsetsAndObjectNumbers[idx];
       this.bytes.moveTo(this.firstOffset + offset);
-      const object = this.parseObject();
       const ref = PDFRef.of(objectNumber, 0);
+      const object = this.parseObject(ref);
       this.context.assign(ref, object);
       if (this.shouldWaitForTick()) await waitForTick();
     }

package/src/core/parser/PDFParser.ts

@@ -1,47 +1,53 @@
-import PDFCrossRefSection from 'src/core/document/PDFCrossRefSection';
-import PDFHeader from 'src/core/document/PDFHeader';
-import PDFTrailer from 'src/core/document/PDFTrailer';
+import PDFCrossRefSection from '../document/PDFCrossRefSection';
+import PDFHeader from '../document/PDFHeader';
+import PDFTrailer from '../document/PDFTrailer';
 import {
   MissingKeywordError,
   MissingPDFHeaderError,
   PDFInvalidObjectParsingError,
   ReparseError,
   StalledParserError,
-} from 'src/core/errors';
-import PDFDict from 'src/core/objects/PDFDict';
-import PDFInvalidObject from 'src/core/objects/PDFInvalidObject';
-import PDFName from 'src/core/objects/PDFName';
-import PDFObject from 'src/core/objects/PDFObject';
-import PDFRawStream from 'src/core/objects/PDFRawStream';
-import PDFRef from 'src/core/objects/PDFRef';
-import ByteStream from 'src/core/parser/ByteStream';
-import PDFObjectParser from 'src/core/parser/PDFObjectParser';
-import PDFObjectStreamParser from 'src/core/parser/PDFObjectStreamParser';
-import PDFXRefStreamParser from 'src/core/parser/PDFXRefStreamParser';
-import PDFContext from 'src/core/PDFContext';
-import CharCodes from 'src/core/syntax/CharCodes';
-import { Keywords } from 'src/core/syntax/Keywords';
-import { IsDigit } from 'src/core/syntax/Numeric';
-import { waitForTick } from 'src/utils';
+} from '../errors';
+import PDFDict from '../objects/PDFDict';
+import PDFInvalidObject from '../objects/PDFInvalidObject';
+import PDFName from '../objects/PDFName';
+import PDFObject from '../objects/PDFObject';
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFRef from '../objects/PDFRef';
+import ByteStream from './ByteStream';
+import PDFObjectParser from './PDFObjectParser';
+import PDFObjectStreamParser from './PDFObjectStreamParser';
+import PDFXRefStreamParser from './PDFXRefStreamParser';
+import PDFContext from '../PDFContext';
+import CharCodes from '../syntax/CharCodes';
+import { Keywords } from '../syntax/Keywords';
+import { IsDigit } from '../syntax/Numeric';
+import { waitForTick } from '../../utils';
+import { CipherTransformFactory } from '../crypto';
 
 class PDFParser extends PDFObjectParser {
   static forBytesWithOptions = (
     pdfBytes: Uint8Array,
     objectsPerTick?: number,
     throwOnInvalidObject?: boolean,
+    warnOnInvalidObjects?: boolean,
     capNumbers?: boolean,
+    cryptoFactory?: CipherTransformFactory,
     forIncrementalUpdate?: boolean,
   ) =>
     new PDFParser(
       pdfBytes,
       objectsPerTick,
       throwOnInvalidObject,
+      warnOnInvalidObjects,
       capNumbers,
+      cryptoFactory,
       forIncrementalUpdate,
     );
 
   private readonly objectsPerTick: number;
   private readonly throwOnInvalidObject: boolean;
+  private readonly warnOnInvalidObjects: boolean;
   private alreadyParsed = false;
   private parsedObjects = 0;
 
@@ -49,12 +55,21 @@ class PDFParser extends PDFObjectParser {
     pdfBytes: Uint8Array,
     objectsPerTick = Infinity,
     throwOnInvalidObject = false,
+    warnOnInvalidObjects = false,
     capNumbers = false,
+    cryptoFactory?: CipherTransformFactory,
     forIncrementalUpdate = false,
   ) {
-    super(ByteStream.of(pdfBytes), PDFContext.create(), capNumbers);
+    super(
+      ByteStream.of(pdfBytes),
+      PDFContext.create(),
+      capNumbers,
+      cryptoFactory,
+    );
     this.objectsPerTick = objectsPerTick;
     this.throwOnInvalidObject = throwOnInvalidObject;
+    this.warnOnInvalidObjects = warnOnInvalidObjects;
+    this.context.isDecrypted = !!cryptoFactory?.encryptionKey;
     this.context.pdfFileDetails.pdfSize = pdfBytes.length;
     if (forIncrementalUpdate) {
       this.context.pdfFileDetails.originalBytes = pdfBytes;
@@ -158,7 +173,7 @@ class PDFParser extends PDFObjectParser {
     const ref = this.parseIndirectObjectHeader();
 
     this.skipWhitespaceAndComments();
-    const object = this.parseObject();
+    const object = this.parseObject(ref);
 
     this.skipWhitespaceAndComments();
     // if (!this.matchKeyword(Keywords.endobj)) {
@@ -194,11 +209,11 @@ class PDFParser extends PDFObjectParser {
 
     const msg = `Trying to parse invalid object: ${JSON.stringify(startPos)})`;
     if (this.throwOnInvalidObject) throw new Error(msg);
-    console.warn(msg);
+    if (this.warnOnInvalidObjects) console.warn(msg);
 
     const ref = this.parseIndirectObjectHeader();
 
-    console.warn(`Invalid object ref: ${ref}`);
+    if (this.warnOnInvalidObjects) console.warn(`Invalid object ref: ${ref}`);
 
     this.skipWhitespaceAndComments();
     const start = this.bytes.offset();
@@ -256,6 +271,11 @@ class PDFParser extends PDFObjectParser {
       const firstInt = this.parseRawInt();
       this.skipWhitespaceAndComments();
 
+      // Check if second digit is valid integer
+      if (!IsDigit[this.bytes.peek()]) {
+        return PDFCrossRefSection.createEmpty();
+      }
+
       const secondInt = this.parseRawInt();
       this.skipWhitespaceAndComments();