@pdfme/pdf-lib 6.0.3 → 6.0.5-dev.1

package/src/core/structures/PDFPageTree.ts

@@ -1,192 +0,0 @@
-import PDFArray from '../objects/PDFArray';
-import PDFDict, { DictMap } from '../objects/PDFDict';
-import PDFName from '../objects/PDFName';
-import PDFNumber from '../objects/PDFNumber';
-import PDFRef from '../objects/PDFRef';
-import PDFContext from '../PDFContext';
-import PDFPageLeaf from './PDFPageLeaf';
-import { InvalidTargetIndexError, CorruptPageTreeError } from '../errors';
-
-export type TreeNode = PDFPageTree | PDFPageLeaf;
-
-class PDFPageTree extends PDFDict {
-  static withContext = (context: PDFContext, parent?: PDFRef) => {
-    const dict = new Map();
-    dict.set(PDFName.of('Type'), PDFName.of('Pages'));
-    dict.set(PDFName.of('Kids'), context.obj([]));
-    dict.set(PDFName.of('Count'), context.obj(0));
-    if (parent) dict.set(PDFName.of('Parent'), parent);
-    return new PDFPageTree(dict, context);
-  };
-
-  static fromMapWithContext = (map: DictMap, context: PDFContext) => new PDFPageTree(map, context);
-
-  Parent(): PDFPageTree | undefined {
-    return this.lookup(PDFName.of('Parent')) as PDFPageTree | undefined;
-  }
-
-  Kids(): PDFArray {
-    return this.lookup(PDFName.of('Kids'), PDFArray);
-  }
-
-  Count(): PDFNumber {
-    return this.lookup(PDFName.of('Count'), PDFNumber);
-  }
-
-  pushTreeNode(treeRef: PDFRef): void {
-    const Kids = this.Kids();
-    Kids.push(treeRef);
-  }
-
-  pushLeafNode(leafRef: PDFRef): void {
-    const Kids = this.Kids();
-    this.insertLeafKid(Kids.size(), leafRef);
-  }
-
-  /**
-   * 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 {
-    const Kids = this.Kids();
-    const Count = this.Count().asNumber();
-
-    if (targetIndex > Count) {
-      throw new InvalidTargetIndexError(targetIndex, Count);
-    }
-
-    let leafsRemainingUntilTarget = targetIndex;
-    for (let idx = 0, len = Kids.size(); idx < len; idx++) {
-      if (leafsRemainingUntilTarget === 0) {
-        // Insert page and return
-        this.insertLeafKid(idx, leafRef);
-        return undefined;
-      }
-
-      const kidRef = Kids.get(idx) as PDFRef;
-      const kid = this.context.lookup(kidRef);
-
-      if (kid instanceof PDFPageTree) {
-        if (kid.Count().asNumber() > leafsRemainingUntilTarget) {
-          // Dig in
-          return kid.insertLeafNode(leafRef, leafsRemainingUntilTarget) || kidRef;
-        } else {
-          // Move on
-          leafsRemainingUntilTarget -= kid.Count().asNumber();
-        }
-      }
-
-      if (kid instanceof PDFPageLeaf) {
-        // Move on
-        leafsRemainingUntilTarget -= 1;
-      }
-    }
-
-    if (leafsRemainingUntilTarget === 0) {
-      // Insert page at the end and return
-      this.insertLeafKid(Kids.size(), leafRef);
-      return undefined;
-    }
-
-    // Should never get here if `targetIndex` is valid
-    throw new CorruptPageTreeError(targetIndex, 'insertLeafNode');
-  }
-
-  /**
-   * 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 = true): void {
-    const Kids = this.Kids();
-    const Count = this.Count().asNumber();
-
-    if (targetIndex >= Count) {
-      throw new InvalidTargetIndexError(targetIndex, Count);
-    }
-
-    let leafsRemainingUntilTarget = targetIndex;
-    for (let idx = 0, len = Kids.size(); idx < len; idx++) {
-      const kidRef = Kids.get(idx) as PDFRef;
-      const kid = this.context.lookup(kidRef);
-
-      if (kid instanceof PDFPageTree) {
-        if (kid.Count().asNumber() > leafsRemainingUntilTarget) {
-          // Dig in
-          kid.removeLeafNode(leafsRemainingUntilTarget, prune);
-          if (prune && kid.Kids().size() === 0) Kids.remove(idx);
-          return;
-        } else {
-          // Move on
-          leafsRemainingUntilTarget -= kid.Count().asNumber();
-        }
-      }
-
-      if (kid instanceof PDFPageLeaf) {
-        if (leafsRemainingUntilTarget === 0) {
-          // Remove page and return
-          this.removeKid(idx);
-          return;
-        } else {
-          // Move on
-          leafsRemainingUntilTarget -= 1;
-        }
-      }
-    }
-
-    // Should never get here if `targetIndex` is valid
-    throw new CorruptPageTreeError(targetIndex, 'removeLeafNode');
-  }
-
-  ascend(visitor: (node: PDFPageTree) => any): void {
-    visitor(this);
-    const Parent = this.Parent();
-    if (Parent) Parent.ascend(visitor);
-  }
-
-  /** Performs a Post-Order traversal of this page tree */
-  traverse(visitor: (node: TreeNode, ref: PDFRef) => any): void {
-    const Kids = this.Kids();
-    for (let idx = 0, len = Kids.size(); idx < len; idx++) {
-      const kidRef = Kids.get(idx) as PDFRef;
-      const kid = this.context.lookup(kidRef) as TreeNode;
-      if (kid instanceof PDFPageTree) kid.traverse(visitor);
-      visitor(kid, kidRef);
-    }
-  }
-
-  private insertLeafKid(kidIdx: number, leafRef: PDFRef): void {
-    const Kids = this.Kids();
-
-    this.ascend((node) => {
-      const newCount = node.Count().asNumber() + 1;
-      node.set(PDFName.of('Count'), PDFNumber.of(newCount));
-    });
-
-    Kids.insert(kidIdx, leafRef);
-  }
-
-  private removeKid(kidIdx: number): void {
-    const Kids = this.Kids();
-
-    const kid = Kids.lookup(kidIdx);
-    if (kid instanceof PDFPageLeaf) {
-      this.ascend((node) => {
-        const newCount = node.Count().asNumber() - 1;
-        node.set(PDFName.of('Count'), PDFNumber.of(newCount));
-      });
-    }
-
-    Kids.remove(kidIdx);
-  }
-}
-
-export default PDFPageTree;

package/src/core/syntax/CharCodes.ts

@@ -1,62 +0,0 @@
-enum CharCodes {
-  Null = 0,
-  Backspace = 8,
-  Tab = 9,
-  Newline = 10,
-  FormFeed = 12,
-  CarriageReturn = 13,
-  Space = 32,
-  ExclamationPoint = 33,
-  Hash = 35,
-  Percent = 37,
-  LeftParen = 40,
-  RightParen = 41,
-  Plus = 43,
-  Minus = 45,
-  Dash = Minus,
-  Period = 46,
-  ForwardSlash = 47,
-  Zero = 48,
-  One = 49,
-  Two = 50,
-  Three = 51,
-  Four = 52,
-  Five = 53,
-  Six = 54,
-  Seven = 55,
-  Eight = 56,
-  Nine = 57,
-  LessThan = 60,
-  GreaterThan = 62,
-  A = 65,
-  D = 68,
-  E = 69,
-  F = 70,
-  O = 79,
-  P = 80,
-  R = 82,
-  LeftSquareBracket = 91,
-  BackSlash = 92,
-  RightSquareBracket = 93,
-  a = 97,
-  b = 98,
-  d = 100,
-  e = 101,
-  f = 102,
-  i = 105,
-  j = 106,
-  l = 108,
-  m = 109,
-  n = 110,
-  o = 111,
-  r = 114,
-  s = 115,
-  t = 116,
-  u = 117,
-  x = 120,
-  LeftCurly = 123,
-  RightCurly = 125,
-  Tilde = 126,
-}
-
-export default CharCodes;

package/src/core/syntax/Delimiters.ts

@@ -1,14 +0,0 @@
-import CharCodes from './CharCodes';
-
-export const IsDelimiter = new Uint8Array(256);
-
-IsDelimiter[CharCodes.LeftParen] = 1;
-IsDelimiter[CharCodes.RightParen] = 1;
-IsDelimiter[CharCodes.LessThan] = 1;
-IsDelimiter[CharCodes.GreaterThan] = 1;
-IsDelimiter[CharCodes.LeftSquareBracket] = 1;
-IsDelimiter[CharCodes.RightSquareBracket] = 1;
-IsDelimiter[CharCodes.LeftCurly] = 1;
-IsDelimiter[CharCodes.RightCurly] = 1;
-IsDelimiter[CharCodes.ForwardSlash] = 1;
-IsDelimiter[CharCodes.Percent] = 1;

package/src/core/syntax/Irregular.ts

@@ -1,10 +0,0 @@
-import CharCodes from './CharCodes';
-import { IsDelimiter } from './Delimiters';
-import { IsWhitespace } from './Whitespace';
-
-export const IsIrregular = new Uint8Array(256);
-
-for (let idx = 0, len = 256; idx < len; idx++) {
-  IsIrregular[idx] = IsWhitespace[idx] || IsDelimiter[idx] ? 1 : 0;
-}
-IsIrregular[CharCodes.Hash] = 1;

package/src/core/syntax/Keywords.ts

@@ -1,57 +0,0 @@
-import CharCodes from './CharCodes';
-
-const { Space, CarriageReturn, Newline } = CharCodes;
-
-const stream = [CharCodes.s, CharCodes.t, CharCodes.r, CharCodes.e, CharCodes.a, CharCodes.m];
-
-const endstream = [
-  CharCodes.e,
-  CharCodes.n,
-  CharCodes.d,
-  CharCodes.s,
-  CharCodes.t,
-  CharCodes.r,
-  CharCodes.e,
-  CharCodes.a,
-  CharCodes.m,
-];
-
-export const Keywords = {
-  header: [CharCodes.Percent, CharCodes.P, CharCodes.D, CharCodes.F, CharCodes.Dash],
-  eof: [CharCodes.Percent, CharCodes.Percent, CharCodes.E, CharCodes.O, CharCodes.F],
-  obj: [CharCodes.o, CharCodes.b, CharCodes.j],
-  endobj: [CharCodes.e, CharCodes.n, CharCodes.d, CharCodes.o, CharCodes.b, CharCodes.j],
-  xref: [CharCodes.x, CharCodes.r, CharCodes.e, CharCodes.f],
-  trailer: [
-    CharCodes.t,
-    CharCodes.r,
-    CharCodes.a,
-    CharCodes.i,
-    CharCodes.l,
-    CharCodes.e,
-    CharCodes.r,
-  ],
-  startxref: [
-    CharCodes.s,
-    CharCodes.t,
-    CharCodes.a,
-    CharCodes.r,
-    CharCodes.t,
-    CharCodes.x,
-    CharCodes.r,
-    CharCodes.e,
-    CharCodes.f,
-  ],
-  true: [CharCodes.t, CharCodes.r, CharCodes.u, CharCodes.e],
-  false: [CharCodes.f, CharCodes.a, CharCodes.l, CharCodes.s, CharCodes.e],
-  null: [CharCodes.n, CharCodes.u, CharCodes.l, CharCodes.l],
-  stream,
-  streamEOF1: [...stream, Space, CarriageReturn, Newline],
-  streamEOF2: [...stream, CarriageReturn, Newline],
-  streamEOF3: [...stream, CarriageReturn],
-  streamEOF4: [...stream, Newline],
-  endstream,
-  EOF1endstream: [CarriageReturn, Newline, ...endstream],
-  EOF2endstream: [CarriageReturn, ...endstream],
-  EOF3endstream: [Newline, ...endstream],
-};

package/src/core/syntax/Numeric.ts

@@ -1,26 +0,0 @@
-import CharCodes from './CharCodes';
-
-export const IsDigit = new Uint8Array(256);
-
-IsDigit[CharCodes.Zero] = 1;
-IsDigit[CharCodes.One] = 1;
-IsDigit[CharCodes.Two] = 1;
-IsDigit[CharCodes.Three] = 1;
-IsDigit[CharCodes.Four] = 1;
-IsDigit[CharCodes.Five] = 1;
-IsDigit[CharCodes.Six] = 1;
-IsDigit[CharCodes.Seven] = 1;
-IsDigit[CharCodes.Eight] = 1;
-IsDigit[CharCodes.Nine] = 1;
-
-export const IsNumericPrefix = new Uint8Array(256);
-
-IsNumericPrefix[CharCodes.Period] = 1;
-IsNumericPrefix[CharCodes.Plus] = 1;
-IsNumericPrefix[CharCodes.Minus] = 1;
-
-export const IsNumeric = new Uint8Array(256);
-
-for (let idx = 0, len = 256; idx < len; idx++) {
-  IsNumeric[idx] = IsDigit[idx] || IsNumericPrefix[idx] ? 1 : 0;
-}

package/src/core/syntax/Whitespace.ts

@@ -1,10 +0,0 @@
-import CharCodes from './CharCodes';
-
-export const IsWhitespace = new Uint8Array(256);
-
-IsWhitespace[CharCodes.Null] = 1;
-IsWhitespace[CharCodes.Tab] = 1;
-IsWhitespace[CharCodes.Newline] = 1;
-IsWhitespace[CharCodes.FormFeed] = 1;
-IsWhitespace[CharCodes.CarriageReturn] = 1;
-IsWhitespace[CharCodes.Space] = 1;

package/src/core/writers/PDFStreamWriter.ts

@@ -1,114 +0,0 @@
-import PDFHeader from '../document/PDFHeader';
-import PDFTrailer from '../document/PDFTrailer';
-import PDFInvalidObject from '../objects/PDFInvalidObject';
-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 PDFCrossRefStream from '../structures/PDFCrossRefStream';
-import PDFObjectStream from '../structures/PDFObjectStream';
-import PDFWriter from './PDFWriter';
-import { last, waitForTick } from '../../utils';
-
-class PDFStreamWriter extends PDFWriter {
-  static forContext = (
-    context: PDFContext,
-    objectsPerTick: number,
-    encodeStreams = true,
-    objectsPerStream = 50,
-  ) => new PDFStreamWriter(context, objectsPerTick, encodeStreams, objectsPerStream);
-
-  private readonly encodeStreams: boolean;
-  private readonly objectsPerStream: number;
-
-  private constructor(
-    context: PDFContext,
-    objectsPerTick: number,
-    encodeStreams: boolean,
-    objectsPerStream: number,
-  ) {
-    super(context, objectsPerTick);
-
-    this.encodeStreams = encodeStreams;
-    this.objectsPerStream = objectsPerStream;
-  }
-
-  protected async computeBufferSize() {
-    let objectNumber = this.context.largestObjectNumber + 1;
-
-    const header = PDFHeader.forVersion(1, 7);
-
-    let size = header.sizeInBytes() + 2;
-
-    const xrefStream = PDFCrossRefStream.create(this.createTrailerDict(), this.encodeStreams);
-
-    const uncompressedObjects: [PDFRef, PDFObject][] = [];
-    const compressedObjects: [PDFRef, PDFObject][][] = [];
-    const objectStreamRefs: PDFRef[] = [];
-
-    const indirectObjects = this.context.enumerateIndirectObjects();
-    for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
-      const indirectObject = indirectObjects[idx];
-      const [ref, object] = indirectObject;
-
-      const shouldNotCompress =
-        ref === this.context.trailerInfo.Encrypt ||
-        object instanceof PDFStream ||
-        object instanceof PDFInvalidObject ||
-        ref.generationNumber !== 0;
-
-      if (shouldNotCompress) {
-        uncompressedObjects.push(indirectObject);
-        xrefStream.addUncompressedEntry(ref, size);
-        size += this.computeIndirectObjectSize(indirectObject);
-        if (this.shouldWaitForTick(1)) await waitForTick();
-      } else {
-        let chunk = last(compressedObjects);
-        let objectStreamRef = last(objectStreamRefs);
-        if (!chunk || chunk.length % this.objectsPerStream === 0) {
-          chunk = [];
-          compressedObjects.push(chunk);
-          objectStreamRef = PDFRef.of(objectNumber++);
-          objectStreamRefs.push(objectStreamRef);
-        }
-        xrefStream.addCompressedEntry(ref, objectStreamRef, chunk.length);
-        chunk.push(indirectObject);
-      }
-    }
-
-    for (let idx = 0, len = compressedObjects.length; idx < len; idx++) {
-      const chunk = compressedObjects[idx];
-      const ref = objectStreamRefs[idx];
-
-      const objectStream = PDFObjectStream.withContextAndObjects(
-        this.context,
-        chunk,
-        this.encodeStreams,
-      );
-
-      xrefStream.addUncompressedEntry(ref, size);
-      size += this.computeIndirectObjectSize([ref, objectStream]);
-
-      uncompressedObjects.push([ref, objectStream]);
-
-      if (this.shouldWaitForTick(chunk.length)) await waitForTick();
-    }
-
-    const xrefStreamRef = PDFRef.of(objectNumber++);
-    xrefStream.dict.set(PDFName.of('Size'), PDFNumber.of(objectNumber));
-    xrefStream.addUncompressedEntry(xrefStreamRef, size);
-    const xrefOffset = size;
-    size += this.computeIndirectObjectSize([xrefStreamRef, xrefStream]);
-
-    uncompressedObjects.push([xrefStreamRef, xrefStream]);
-
-    const trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
-    size += trailer.sizeInBytes();
-
-    return { size, header, indirectObjects: uncompressedObjects, trailer };
-  }
-}
-
-export default PDFStreamWriter;

package/src/core/writers/PDFWriter.ts

@@ -1,146 +0,0 @@
-import PDFCrossRefSection from '../document/PDFCrossRefSection';
-import PDFHeader from '../document/PDFHeader';
-import PDFTrailer from '../document/PDFTrailer';
-import PDFTrailerDict from '../document/PDFTrailerDict';
-import PDFDict from '../objects/PDFDict';
-import PDFObject from '../objects/PDFObject';
-import PDFRef from '../objects/PDFRef';
-import PDFContext from '../PDFContext';
-import PDFObjectStream from '../structures/PDFObjectStream';
-import CharCodes from '../syntax/CharCodes';
-import { copyStringIntoBuffer, waitForTick } from '../../utils';
-
-export interface SerializationInfo {
-  size: number;
-  header: PDFHeader;
-  indirectObjects: [PDFRef, PDFObject][];
-  xref?: PDFCrossRefSection;
-  trailerDict?: PDFTrailerDict;
-  trailer: PDFTrailer;
-}
-
-class PDFWriter {
-  static forContext = (context: PDFContext, objectsPerTick: number) =>
-    new PDFWriter(context, objectsPerTick);
-
-  protected readonly context: PDFContext;
-
-  protected readonly objectsPerTick: number;
-  private parsedObjects = 0;
-
-  protected constructor(context: PDFContext, objectsPerTick: number) {
-    this.context = context;
-    this.objectsPerTick = objectsPerTick;
-  }
-
-  async serializeToBuffer(): Promise<Uint8Array<ArrayBuffer>> {
-    const { size, header, indirectObjects, xref, trailerDict, trailer } =
-      await this.computeBufferSize();
-
-    let offset = 0;
-    const buffer = new Uint8Array(size);
-
-    offset += header.copyBytesInto(buffer, offset);
-    buffer[offset++] = CharCodes.Newline;
-    buffer[offset++] = CharCodes.Newline;
-
-    for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
-      const [ref, object] = indirectObjects[idx];
-
-      const objectNumber = String(ref.objectNumber);
-      offset += copyStringIntoBuffer(objectNumber, buffer, offset);
-      buffer[offset++] = CharCodes.Space;
-
-      const generationNumber = String(ref.generationNumber);
-      offset += copyStringIntoBuffer(generationNumber, buffer, offset);
-      buffer[offset++] = CharCodes.Space;
-
-      buffer[offset++] = CharCodes.o;
-      buffer[offset++] = CharCodes.b;
-      buffer[offset++] = CharCodes.j;
-      buffer[offset++] = CharCodes.Newline;
-
-      offset += object.copyBytesInto(buffer, offset);
-
-      buffer[offset++] = CharCodes.Newline;
-      buffer[offset++] = CharCodes.e;
-      buffer[offset++] = CharCodes.n;
-      buffer[offset++] = CharCodes.d;
-      buffer[offset++] = CharCodes.o;
-      buffer[offset++] = CharCodes.b;
-      buffer[offset++] = CharCodes.j;
-      buffer[offset++] = CharCodes.Newline;
-      buffer[offset++] = CharCodes.Newline;
-
-      const n = object instanceof PDFObjectStream ? object.getObjectsCount() : 1;
-      if (this.shouldWaitForTick(n)) await waitForTick();
-    }
-
-    if (xref) {
-      offset += xref.copyBytesInto(buffer, offset);
-      buffer[offset++] = CharCodes.Newline;
-    }
-
-    if (trailerDict) {
-      offset += trailerDict.copyBytesInto(buffer, offset);
-      buffer[offset++] = CharCodes.Newline;
-      buffer[offset++] = CharCodes.Newline;
-    }
-
-    offset += trailer.copyBytesInto(buffer, offset);
-
-    return buffer;
-  }
-
-  protected computeIndirectObjectSize([ref, object]: [PDFRef, PDFObject]): number {
-    const refSize = ref.sizeInBytes() + 3; // 'R' -> 'obj\n'
-    const objectSize = object.sizeInBytes() + 9; // '\nendobj\n\n'
-    return refSize + objectSize;
-  }
-
-  protected createTrailerDict(): PDFDict {
-    return this.context.obj({
-      Size: this.context.largestObjectNumber + 1,
-      Root: this.context.trailerInfo.Root,
-      Encrypt: this.context.trailerInfo.Encrypt,
-      Info: this.context.trailerInfo.Info,
-      ID: this.context.trailerInfo.ID,
-    });
-  }
-
-  protected async computeBufferSize(): Promise<SerializationInfo> {
-    const header = PDFHeader.forVersion(1, 7);
-
-    let size = header.sizeInBytes() + 2;
-
-    const xref = PDFCrossRefSection.create();
-
-    const indirectObjects = this.context.enumerateIndirectObjects();
-
-    for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
-      const indirectObject = indirectObjects[idx];
-      const [ref] = indirectObject;
-      xref.addEntry(ref, size);
-      size += this.computeIndirectObjectSize(indirectObject);
-      if (this.shouldWaitForTick(1)) await waitForTick();
-    }
-
-    const xrefOffset = size;
-    size += xref.sizeInBytes() + 1; // '\n'
-
-    const trailerDict = PDFTrailerDict.of(this.createTrailerDict());
-    size += trailerDict.sizeInBytes() + 2; // '\n\n'
-
-    const trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
-    size += trailer.sizeInBytes();
-
-    return { size, header, indirectObjects, xref, trailerDict, trailer };
-  }
-
-  protected shouldWaitForTick = (n: number) => {
-    this.parsedObjects += n;
-    return this.parsedObjects % this.objectsPerTick === 0;
-  };
-}
-
-export default PDFWriter;