@pdfme/pdf-lib 5.4.0-dev.59 → 5.4.0-dev.65

package/src/core/document/PDFCrossRefSection.ts

@@ -43,18 +43,10 @@ class PDFCrossRefSection {
   toString(): string {
     let section = `xref\n`;
 
-    for (
-      let rangeIdx = 0, rangeLen = this.subsections.length;
-      rangeIdx < rangeLen;
-      rangeIdx++
-    ) {
+    for (let rangeIdx = 0, rangeLen = this.subsections.length; rangeIdx < rangeLen; rangeIdx++) {
       const range = this.subsections[rangeIdx];
       section += `${range[0].ref.objectNumber} ${range.length}\n`;
-      for (
-        let entryIdx = 0, entryLen = range.length;
-        entryIdx < entryLen;
-        entryIdx++
-      ) {
+      for (let entryIdx = 0, entryLen = range.length; entryIdx < entryLen; entryIdx++) {
         const entry = range[entryIdx];
         section += padStart(String(entry.offset), 10, '0');
         section += ' ';
@@ -121,11 +113,7 @@ class PDFCrossRefSection {
     return offset - initialOffset;
   }
 
-  private copyEntriesIntoBuffer(
-    entries: Entry[],
-    buffer: Uint8Array,
-    offset: number,
-  ): number {
+  private copyEntriesIntoBuffer(entries: Entry[], buffer: Uint8Array, offset: number): number {
     const length = entries.length;
 
     for (let idx = 0; idx < length; idx++) {

package/src/core/document/PDFHeader.ts

@@ -2,8 +2,7 @@ import CharCodes from '../syntax/CharCodes';
 import { charFromCode, copyStringIntoBuffer } from '../../utils';
 
 class PDFHeader {
-  static forVersion = (major: number, minor: number) =>
-    new PDFHeader(major, minor);
+  static forVersion = (major: number, minor: number) => new PDFHeader(major, minor);
 
   private readonly major: string;
   private readonly minor: string;

package/src/core/document/PDFTrailer.ts

@@ -2,8 +2,7 @@ import CharCodes from '../syntax/CharCodes';
 import { copyStringIntoBuffer } from '../../utils';
 
 class PDFTrailer {
-  static forLastCrossRefSectionOffset = (offset: number) =>
-    new PDFTrailer(offset);
+  static forLastCrossRefSectionOffset = (offset: number) => new PDFTrailer(offset);
 
   private readonly lastXRefOffset: string;
 

package/src/core/embedders/CMap.ts

@@ -1,12 +1,7 @@
 import { Glyph } from '../../types/fontkit';
 
 import { toHexString, toHexStringOfMinLength } from '../../utils';
-import {
-  hasSurrogates,
-  highSurrogate,
-  isWithinBMP,
-  lowSurrogate,
-} from '../../utils/unicode';
+import { hasSurrogates, highSurrogate, isWithinBMP, lowSurrogate } from '../../utils/unicode';
 
 /** [fontId, codePoint] */
 type BfChar = [string, string];

package/src/core/embedders/CustomFontEmbedder.ts

@@ -6,12 +6,7 @@ import PDFHexString from '../objects/PDFHexString';
 import PDFRef from '../objects/PDFRef';
 import PDFString from '../objects/PDFString';
 import PDFContext from '../PDFContext';
-import {
-  byAscendingId,
-  Cache,
-  sortedUniq,
-  toHexStringOfMinLength,
-} from '../../utils';
+import { byAscendingId, Cache, sortedUniq, toHexStringOfMinLength } from '../../utils';
 
 /**
  * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
@@ -81,10 +76,7 @@ class CustomFontEmbedder {
     return totalWidth * scale;
   }
 
-  heightOfFontAtSize(
-    size: number,
-    options: { descender?: boolean } = {},
-  ): number {
+  heightOfFontAtSize(size: number, options: { descender?: boolean } = {}): number {
     const { descender = true } = options;
 
     const { ascent, descent, bbox } = this.font;
@@ -105,15 +97,11 @@ class CustomFontEmbedder {
   }
 
   embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
-    this.baseFontName =
-      this.customName || context.addRandomSuffix(this.fontName);
+    this.baseFontName = this.customName || context.addRandomSuffix(this.fontName);
     return this.embedFontDict(context, ref);
   }
 
-  protected async embedFontDict(
-    context: PDFContext,
-    ref?: PDFRef,
-  ): Promise<PDFRef> {
+  protected async embedFontDict(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
     const cidFontDictRef = await this.embedCIDFontDict(context);
     const unicodeCMapRef = this.embedUnicodeCmap(context);
 

package/src/core/embedders/CustomFontSubsetEmbedder.ts

@@ -1,10 +1,4 @@
-import {
-  Font,
-  Fontkit,
-  Glyph,
-  Subset,
-  TypeFeatures,
-} from '../../types/fontkit';
+import { Font, Fontkit, Glyph, Subset, TypeFeatures } from '../../types/fontkit';
 
 import CustomFontEmbedder from './CustomFontEmbedder';
 import PDFHexString from '../objects/PDFHexString';
@@ -23,12 +17,7 @@ class CustomFontSubsetEmbedder extends CustomFontEmbedder {
     fontFeatures?: TypeFeatures,
   ) {
     const font = await fontkit.create(fontData);
-    return new CustomFontSubsetEmbedder(
-      font,
-      fontData,
-      customFontName,
-      fontFeatures,
-    );
+    return new CustomFontSubsetEmbedder(font, fontData, customFontName, fontFeatures);
   }
 
   private readonly subset: Subset;

package/src/core/embedders/FileEmbedder.ts

@@ -28,11 +28,7 @@ export interface EmbeddedFileOptions {
 }
 
 class FileEmbedder {
-  static for(
-    bytes: Uint8Array,
-    fileName: string,
-    options: EmbeddedFileOptions = {},
-  ) {
+  static for(bytes: Uint8Array, fileName: string, options: EmbeddedFileOptions = {}) {
     return new FileEmbedder(bytes, fileName, options);
   }
 
@@ -40,36 +36,22 @@ class FileEmbedder {
   readonly fileName: string;
   readonly options: EmbeddedFileOptions;
 
-  private constructor(
-    fileData: Uint8Array,
-    fileName: string,
-    options: EmbeddedFileOptions = {},
-  ) {
+  private constructor(fileData: Uint8Array, fileName: string, options: EmbeddedFileOptions = {}) {
     this.fileData = fileData;
     this.fileName = fileName;
     this.options = options;
   }
 
   async embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {
-    const {
-      mimeType,
-      description,
-      creationDate,
-      modificationDate,
-      afRelationship,
-    } = this.options;
+    const { mimeType, description, creationDate, modificationDate, afRelationship } = this.options;
 
     const embeddedFileStream = context.flateStream(this.fileData, {
       Type: 'EmbeddedFile',
       Subtype: mimeType ?? undefined,
       Params: {
         Size: this.fileData.length,
-        CreationDate: creationDate
-          ? PDFString.fromDate(creationDate)
-          : undefined,
-        ModDate: modificationDate
-          ? PDFString.fromDate(modificationDate)
-          : undefined,
+        CreationDate: creationDate ? PDFString.fromDate(creationDate) : undefined,
+        ModDate: modificationDate ? PDFString.fromDate(modificationDate) : undefined,
       },
     });
     const embeddedFileStreamRef = context.register(embeddedFileStream);

package/src/core/embedders/JpegEmbedder.ts

@@ -61,13 +61,7 @@ class JpegEmbedder {
 
     const colorSpace = channelName;
 
-    return new JpegEmbedder(
-      imageData,
-      bitsPerComponent,
-      width,
-      height,
-      colorSpace,
-    );
+    return new JpegEmbedder(imageData, bitsPerComponent, width, height, colorSpace);
   }
 
   readonly bitsPerComponent: number;
@@ -109,10 +103,7 @@ class JpegEmbedder {
       //
       // Applying a swap here as a hedge that most bytes passing
       // through this method will benefit from it.
-      Decode:
-        this.colorSpace === ColorSpace.DeviceCMYK
-          ? [1, 0, 1, 0, 1, 0, 1, 0]
-          : undefined,
+      Decode: this.colorSpace === ColorSpace.DeviceCMYK ? [1, 0, 1, 0, 1, 0, 1, 0] : undefined,
     });
 
     if (ref) {

package/src/core/embedders/PDFPageEmbedder.ts

@@ -1,7 +1,4 @@
-import {
-  MissingPageContentsEmbeddingError,
-  UnrecognizedStreamTypeError,
-} from '../errors';
+import { MissingPageContentsEmbeddingError, UnrecognizedStreamTypeError } from '../errors';
 import PDFArray from '../objects/PDFArray';
 import PDFNumber from '../objects/PDFNumber';
 import PDFRawStream from '../objects/PDFRawStream';
@@ -40,22 +37,24 @@ export interface PageBoundingBox {
 const fullPageBoundingBox = (page: PDFPageLeaf) => {
   const mediaBox = page.MediaBox();
 
-  const width =
-    mediaBox.lookup(2, PDFNumber).asNumber() -
-    mediaBox.lookup(0, PDFNumber).asNumber();
+  const width = mediaBox.lookup(2, PDFNumber).asNumber() - mediaBox.lookup(0, PDFNumber).asNumber();
 
   const height =
-    mediaBox.lookup(3, PDFNumber).asNumber() -
-    mediaBox.lookup(1, PDFNumber).asNumber();
+    mediaBox.lookup(3, PDFNumber).asNumber() - mediaBox.lookup(1, PDFNumber).asNumber();
 
   return { left: 0, bottom: 0, right: width, top: height };
 };
 
 // Returns the identity matrix, modified to position the content of the given
 // bounding box at (0, 0).
-const boundingBoxAdjustedMatrix = (
-  bb: PageBoundingBox,
-): TransformationMatrix => [1, 0, 0, 1, -bb.left, -bb.bottom];
+const boundingBoxAdjustedMatrix = (bb: PageBoundingBox): TransformationMatrix => [
+  1,
+  0,
+  0,
+  1,
+  -bb.left,
+  -bb.bottom,
+];
 
 class PDFPageEmbedder {
   static async for(
@@ -85,8 +84,7 @@ class PDFPageEmbedder {
     this.width = bb.right - bb.left;
     this.height = bb.top - bb.bottom;
     this.boundingBox = bb;
-    this.transformationMatrix =
-      transformationMatrix ?? boundingBoxAdjustedMatrix(bb);
+    this.transformationMatrix = transformationMatrix ?? boundingBoxAdjustedMatrix(bb);
   }
 
   async embedIntoContext(context: PDFContext, ref?: PDFRef): Promise<PDFRef> {

package/src/core/embedders/StandardFontEmbedder.ts

@@ -1,9 +1,4 @@
-import {
-  Encodings,
-  Font,
-  FontNames,
-  EncodingType,
-} from '@pdf-lib/standard-fonts';
+import { Encodings, Font, FontNames, EncodingType } from '@pdf-lib/standard-fonts';
 
 import PDFHexString from '../objects/PDFHexString';
 import PDFRef from '../objects/PDFRef';
@@ -70,10 +65,7 @@ class StandardFontEmbedder {
     return totalWidth * scale;
   }
 
-  heightOfFontAtSize(
-    size: number,
-    options: { descender?: boolean } = {},
-  ): number {
+  heightOfFontAtSize(size: number, options: { descender?: boolean } = {}): number {
     const { descender = true } = options;
 
     const { Ascender, Descender, FontBBox } = this.font;
@@ -99,8 +91,7 @@ class StandardFontEmbedder {
       Subtype: 'Type1',
       BaseFont: this.customName || this.fontName,
 
-      Encoding:
-        this.encoding === Encodings.WinAnsi ? 'WinAnsiEncoding' : undefined,
+      Encoding: this.encoding === Encodings.WinAnsi ? 'WinAnsiEncoding' : undefined,
     });
 
     if (ref) {

package/src/core/errors.ts

@@ -20,9 +20,7 @@ export class UnexpectedObjectTypeError extends Error {
   constructor(expected: any | any[], actual: any) {
     const name = (t: any) => t?.name ?? t?.constructor?.name;
 
-    const expectedTypes = Array.isArray(expected)
-      ? expected.map(name)
-      : [name(expected)];
+    const expectedTypes = Array.isArray(expected) ? expected.map(name) : [name(expected)];
 
     const msg =
       `Expected instance of ${expectedTypes.join(' or ')}, ` +

package/src/core/index.ts

@@ -14,16 +14,10 @@ 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 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 PDFPageEmbedder, type PageBoundingBox } from './embedders/PDFPageEmbedder';
 
 export {
   default as ViewerPreferences,

package/src/core/interactive/ViewerPreferences.ts

@@ -4,12 +4,7 @@ import PDFDict from '../objects/PDFDict';
 import PDFName from '../objects/PDFName';
 import PDFNumber from '../objects/PDFNumber';
 import PDFContext from '../PDFContext';
-import {
-  assertEachIs,
-  assertInteger,
-  assertIsOneOf,
-  assertRange,
-} from '../../utils';
+import { assertEachIs, assertInteger, assertIsOneOf, assertRange } from '../../utils';
 
 const asEnum = <T extends string | number, U extends { [key: string]: T }>(
   rawValue: T | undefined,
@@ -83,11 +78,7 @@ type BoolViewerPrefKey =
   | 'CenterWindow'
   | 'DisplayDocTitle'
   | 'PickTrayByPDFSize';
-type NameViewerPrefKey =
-  | 'NonFullScreenPageMode'
-  | 'Direction'
-  | 'PrintScaling'
-  | 'Duplex';
+type NameViewerPrefKey = 'NonFullScreenPageMode' | 'Direction' | 'PrintScaling' | 'Duplex';
 
 interface PageRange {
   start: number;
@@ -99,8 +90,7 @@ class ViewerPreferences {
   readonly dict: PDFDict;
 
   /** @ignore */
-  static fromDict = (dict: PDFDict): ViewerPreferences =>
-    new ViewerPreferences(dict);
+  static fromDict = (dict: PDFDict): ViewerPreferences => new ViewerPreferences(dict);
 
   /** @ignore */
   static create = (context: PDFContext) => {
@@ -429,11 +419,7 @@ class ViewerPreferences {
    *                              exiting full screen mode.
    */
   setNonFullScreenPageMode(nonFullScreenPageMode: NonFullScreenPageMode) {
-    assertIsOneOf(
-      nonFullScreenPageMode,
-      'nonFullScreenPageMode',
-      NonFullScreenPageMode,
-    );
+    assertIsOneOf(nonFullScreenPageMode, 'nonFullScreenPageMode', NonFullScreenPageMode);
     const mode = PDFName.of(nonFullScreenPageMode);
     this.dict.set(PDFName.of('NonFullScreenPageMode'), mode);
   }

package/src/core/objects/PDFArray.ts

@@ -57,18 +57,12 @@ class PDFArray extends PDFObject {
   lookupMaybe(index: number, type: typeof PDFArray): PDFArray | undefined;
   lookupMaybe(index: number, type: typeof PDFBool): PDFBool | undefined;
   lookupMaybe(index: number, type: typeof PDFDict): PDFDict | undefined;
-  lookupMaybe(
-    index: number,
-    type: typeof PDFHexString,
-  ): PDFHexString | undefined;
+  lookupMaybe(index: number, type: typeof PDFHexString): PDFHexString | undefined;
   lookupMaybe(index: number, type: typeof PDFName): PDFName | undefined;
   lookupMaybe(index: number, type: typeof PDFNull): typeof PDFNull | undefined;
   lookupMaybe(index: number, type: typeof PDFNumber): PDFNumber | undefined;
   lookupMaybe(index: number, type: typeof PDFStream): PDFStream | undefined;
-  lookupMaybe(
-    index: number,
-    type: typeof PDFRawStream,
-  ): PDFRawStream | undefined;
+  lookupMaybe(index: number, type: typeof PDFRawStream): PDFRawStream | undefined;
   lookupMaybe(index: number, type: typeof PDFRef): PDFRef | undefined;
   lookupMaybe(index: number, type: typeof PDFString): PDFString | undefined;
   lookupMaybe(

package/src/core/objects/PDFDict.ts

@@ -16,8 +16,7 @@ export type DictMap = Map<PDFName, PDFObject>;
 class PDFDict extends PDFObject {
   static withContext = (context: PDFContext) => new PDFDict(new Map(), context);
 
-  static fromMapWithContext = (map: DictMap, context: PDFContext) =>
-    new PDFDict(map, context);
+  static fromMapWithContext = (map: DictMap, context: PDFContext) => new PDFDict(map, context);
 
   readonly context: PDFContext;
 
@@ -66,10 +65,7 @@ class PDFDict extends PDFObject {
   lookupMaybe(key: PDFName, type: typeof PDFArray): PDFArray | undefined;
   lookupMaybe(key: PDFName, type: typeof PDFBool): PDFBool | undefined;
   lookupMaybe(key: PDFName, type: typeof PDFDict): PDFDict | undefined;
-  lookupMaybe(
-    key: PDFName,
-    type: typeof PDFHexString,
-  ): PDFHexString | undefined;
+  lookupMaybe(key: PDFName, type: typeof PDFHexString): PDFHexString | undefined;
   lookupMaybe(key: PDFName, type: typeof PDFName): PDFName | undefined;
   lookupMaybe(key: PDFName, type: typeof PDFNull): typeof PDFNull | undefined;
   lookupMaybe(key: PDFName, type: typeof PDFNumber): PDFNumber | undefined;
@@ -125,11 +121,7 @@ class PDFDict extends PDFObject {
     type1: typeof PDFString,
     type2: typeof PDFHexString,
   ): PDFString | PDFHexString;
-  lookup(
-    ref: PDFName,
-    type1: typeof PDFDict,
-    type2: typeof PDFStream,
-  ): PDFDict | PDFStream;
+  lookup(ref: PDFName, type1: typeof PDFDict, type2: typeof PDFStream): PDFDict | PDFStream;
   lookup(
     ref: PDFName,
     type1: typeof PDFString,

package/src/core/objects/PDFName.ts

@@ -2,20 +2,13 @@ import { PrivateConstructorError } from '../errors';
 import PDFObject from './PDFObject';
 import CharCodes from '../syntax/CharCodes';
 import { IsIrregular } from '../syntax/Irregular';
-import {
-  charFromHexCode,
-  copyStringIntoBuffer,
-  toCharCode,
-  toHexString,
-} from '../../utils';
+import { charFromHexCode, copyStringIntoBuffer, toCharCode, toHexString } from '../../utils';
 
 const decodeName = (name: string) =>
   name.replace(/#([\dABCDEF]{2})/g, (_, hex) => charFromHexCode(hex));
 
 const isRegularChar = (charCode: number) =>
-  charCode >= CharCodes.ExclamationPoint &&
-  charCode <= CharCodes.Tilde &&
-  !IsIrregular[charCode];
+  charCode >= CharCodes.ExclamationPoint && charCode <= CharCodes.Tilde && !IsIrregular[charCode];
 
 const ENFORCER = {};
 const pool = new Map<string, PDFName>();

package/src/core/objects/PDFRawStream.ts

@@ -5,20 +5,13 @@ import { arrayAsString } from '../../utils';
 import { CipherTransform } from '../crypto';
 
 class PDFRawStream extends PDFStream {
-  static of = (
-    dict: PDFDict,
-    contents: Uint8Array,
-    transform?: CipherTransform,
-  ) => new PDFRawStream(dict, contents, transform);
+  static of = (dict: PDFDict, contents: Uint8Array, transform?: CipherTransform) =>
+    new PDFRawStream(dict, contents, transform);
 
   readonly contents: Uint8Array;
   readonly transform?: CipherTransform;
 
-  private constructor(
-    dict: PDFDict,
-    contents: Uint8Array,
-    transform?: CipherTransform,
-  ) {
+  private constructor(dict: PDFDict, contents: Uint8Array, transform?: CipherTransform) {
     super(dict);
     this.contents = contents;
     this.transform = transform;

package/src/core/objects/PDFRef.ts

@@ -22,11 +22,7 @@ class PDFRef extends PDFObject {
   readonly generationNumber: number;
   readonly tag: string;
 
-  private constructor(
-    enforcer: any,
-    objectNumber: number,
-    generationNumber: number,
-  ) {
+  private constructor(enforcer: any, objectNumber: number, generationNumber: number) {
     if (enforcer !== ENFORCER) throw new PrivateConstructorError('PDFRef');
     super();
     this.objectNumber = objectNumber;

package/src/core/objects/PDFStream.ts

@@ -19,10 +19,7 @@ class PDFStream extends PDFObject {
   }
 
   getContentsString(): string {
-    throw new MethodNotImplementedError(
-      this.constructor.name,
-      'getContentsString',
-    );
+    throw new MethodNotImplementedError(this.constructor.name, 'getContentsString');
   }
 
   getContents(): Uint8Array {
@@ -30,10 +27,7 @@ class PDFStream extends PDFObject {
   }
 
   getContentsSize(): number {
-    throw new MethodNotImplementedError(
-      this.constructor.name,
-      'getContentsSize',
-    );
+    throw new MethodNotImplementedError(this.constructor.name, 'getContentsSize');
   }
 
   updateDict(): void {

package/src/core/operators/PDFOperator.ts

@@ -9,17 +9,10 @@ import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
 import { copyStringIntoBuffer } from '../../utils';
 
-export type PDFOperatorArg =
-  | string
-  | PDFName
-  | PDFArray
-  | PDFNumber
-  | PDFString
-  | PDFHexString;
+export type PDFOperatorArg = string | PDFName | PDFArray | PDFNumber | PDFString | PDFHexString;
 
 class PDFOperator {
-  static of = (name: PDFOperatorNames, args?: PDFOperatorArg[]) =>
-    new PDFOperator(name, args);
+  static of = (name: PDFOperatorNames, args?: PDFOperatorArg[]) => new PDFOperator(name, args);
 
   private readonly name: PDFOperatorNames;
   private readonly args: PDFOperatorArg[];

package/src/core/parser/PDFObjectParser.ts

@@ -32,17 +32,11 @@ import { CipherTransformFactory } from '../crypto';
 
 // TODO: Throw error if eof is reached before finishing object parse...
 class PDFObjectParser extends BaseParser {
-  static forBytes = (
-    bytes: Uint8Array,
-    context: PDFContext,
-    capNumbers?: boolean,
-  ) => new PDFObjectParser(ByteStream.of(bytes), context, capNumbers);
+  static forBytes = (bytes: Uint8Array, context: PDFContext, capNumbers?: boolean) =>
+    new PDFObjectParser(ByteStream.of(bytes), context, capNumbers);
 
-  static forByteStream = (
-    byteStream: ByteStream,
-    context: PDFContext,
-    capNumbers = false,
-  ) => new PDFObjectParser(byteStream, context, capNumbers);
+  static forByteStream = (byteStream: ByteStream, context: PDFContext, capNumbers = false) =>
+    new PDFObjectParser(byteStream, context, capNumbers);
 
   protected readonly context: PDFContext;
   private readonly cryptoFactory?: CipherTransformFactory;
@@ -68,10 +62,7 @@ class PDFObjectParser extends BaseParser {
 
     const byte = this.bytes.peek();
 
-    if (
-      byte === CharCodes.LessThan &&
-      this.bytes.peekAhead(1) === CharCodes.LessThan
-    ) {
+    if (byte === CharCodes.LessThan && this.bytes.peekAhead(1) === CharCodes.LessThan) {
       return this.parseDictOrStream(ref);
     }
     if (byte === CharCodes.LessThan) return this.parseHexString(ref);

package/src/core/parser/PDFObjectStreamParser.ts

@@ -8,10 +8,8 @@ import PDFObjectParser from './PDFObjectParser';
 import { waitForTick } from '../../utils';
 
 class PDFObjectStreamParser extends PDFObjectParser {
-  static forStream = (
-    rawStream: PDFRawStream,
-    shouldWaitForTick?: () => boolean,
-  ) => new PDFObjectStreamParser(rawStream, shouldWaitForTick);
+  static forStream = (rawStream: PDFRawStream, shouldWaitForTick?: () => boolean) =>
+    new PDFObjectStreamParser(rawStream, shouldWaitForTick);
 
   private alreadyParsed: boolean;
   private readonly shouldWaitForTick: () => boolean;

package/src/core/parser/PDFParser.ts

@@ -32,14 +32,7 @@ class PDFParser extends PDFObjectParser {
     throwOnInvalidObject?: boolean,
     capNumbers?: boolean,
     cryptoFactory?: CipherTransformFactory,
-  ) =>
-    new PDFParser(
-      pdfBytes,
-      objectsPerTick,
-      throwOnInvalidObject,
-      capNumbers,
-      cryptoFactory,
-    );
+  ) => new PDFParser(pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers, cryptoFactory);
 
   private readonly objectsPerTick: number;
   private readonly throwOnInvalidObject: boolean;
@@ -53,15 +46,10 @@ class PDFParser extends PDFObjectParser {
     capNumbers = false,
     cryptoFactory?: CipherTransformFactory,
   ) {
-    super(
-      ByteStream.of(pdfBytes),
-      PDFContext.create(),
-      capNumbers,
-      cryptoFactory,
-    );
+    super(ByteStream.of(pdfBytes), PDFContext.create(), capNumbers, cryptoFactory);
     this.objectsPerTick = objectsPerTick;
     this.throwOnInvalidObject = throwOnInvalidObject;
-    this.context.isDecrypted = !!cryptoFactory?.encryptionKey
+    this.context.isDecrypted = !!cryptoFactory?.encryptionKey;
   }
 
   async parseDocument(): Promise<PDFContext> {
@@ -94,8 +82,7 @@ class PDFParser extends PDFObjectParser {
 
   private maybeRecoverRoot(): void {
     const isValidCatalog = (obj?: PDFObject) =>
-      obj instanceof PDFDict &&
-      obj.lookup(PDFName.of('Type')) === PDFName.of('Catalog');
+      obj instanceof PDFDict && obj.lookup(PDFName.of('Type')) === PDFName.of('Catalog');
 
     const catalog = this.context.lookup(this.context.trailerInfo.Root);
 
@@ -175,10 +162,7 @@ class PDFParser extends PDFObjectParser {
       object instanceof PDFRawStream &&
       object.dict.lookup(PDFName.of('Type')) === PDFName.of('ObjStm')
     ) {
-      await PDFObjectStreamParser.forStream(
-        object,
-        this.shouldWaitForTick,
-      ).parseIntoContext();
+      await PDFObjectStreamParser.forStream(object, this.shouldWaitForTick).parseIntoContext();
     } else if (
       object instanceof PDFRawStream &&
       object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')

package/src/core/parser/PDFXRefStreamParser.ts

@@ -16,8 +16,7 @@ export interface Entry {
 }
 
 class PDFXRefStreamParser {
-  static forStream = (rawStream: PDFRawStream) =>
-    new PDFXRefStreamParser(rawStream);
+  static forStream = (rawStream: PDFRawStream) => new PDFXRefStreamParser(rawStream);
 
   private alreadyParsed: boolean;